AlphaFold: Protein Structure Prediction

Hola, soy Alex de DEV STORIES DOT EU. AlphaFold: Predicción de la Estructura de Proteínas, episodio 1 de 21. Durante cincuenta años, los científicos pudieron leer el texto en crudo de nuestro ADN, pero no podían predecir qué construiría realmente ese texto. Tenían el source code de la vida, pero ni idea de cómo compilaba en las máquinas físicas que hacen funcionar nuestras células. Este gran desafío se conoce como el Problema del Plegamiento de Proteínas. Las proteínas son las máquinas moleculares que te mantienen vivo. Se encargan de casi todo lo que ocurre dentro de tu cuerpo, desde transportar oxígeno en la sangre hasta combatir infecciones. Cada proteína comienza su vida como un string unidimensional. Este string se construye a partir de un vocabulario de veinte componentes químicos básicos diferentes llamados aminoácidos. Piensa en la secuencia de aminoácidos como el source code en crudo de la biología. Es un string lineal de caracteres, que se lee secuencialmente. Pero una línea recta de aminoácidos no puede realizar ningún trabajo real. Igual que un archivo de plain text necesita compilarse en un binario ejecutable para correr, la secuencia unidimensional de aminoácidos debe plegarse en una forma tridimensional muy específica. En el mundo biológico, la forma determina completamente la función. Los contornos físicos de una proteína definen con qué puede interactuar. Una proteína plegada en forma de bolsillo puede capturar y descomponer una molécula de azúcar específica. Una proteína plegada en forma de tubo rígido puede actuar como soporte estructural para una célula. Si el proceso de plegamiento sale mal, el programa biológico crashea. En los seres humanos, las proteínas mal plegadas son la causa raíz de muchas enfermedades graves. La secuencia de aminoácidos contiene todas las instrucciones necesarias para formar esta estructura tridimensional exacta. Los diferentes aminoácidos tienen propiedades químicas distintas. Algunos tienen cargas positivas o negativas y actúan como imanes. Algunos repelen el agua e intentan esconderse en el centro de la estructura, mientras que otros son atraídos por el agua y empujan hacia el exterior. Estas fuerzas físicas en competencia hacen que el string se enrede, se retuerza y encaje en una única configuración estable. Aquí está la clave. Las matemáticas detrás de este proceso de plegamiento son alucinantes. Un chain de proteínas típico está compuesto por cientos de aminoácidos. El número de formas posibles en que un chain tan largo podría doblarse es de aproximadamente diez elevado a trescientos. Un científico llamado Cyrus Levinthal señaló que si una proteína probara secuencialmente todas las formas posibles para encontrar la correcta, el proceso tardaría más que la edad del universo. Sin embargo, dentro de tus células, un nuevo string de proteínas encaja en su forma correcta en unos pocos milisegundos. El problema del plegamiento de proteínas es el intento de superar esta brecha. Es el reto de tomar una secuencia unidimensional de aminoácidos como único input y predecir computacionalmente su estructura tridimensional final. Históricamente, los científicos tenían que depender de técnicas físicas de laboratorio muy lentas para mapear estas estructuras. Métodos como la cristalografía de rayos X implicaban congelar proteínas en cristales y dispararles haces para medir los ángulos de la luz dispersada. Encontrar la estructura de una sola proteína podía llevar años de minucioso ensayo y error. Dado que la tecnología de secuenciación genética superó al mapeo físico, la comunidad científica acumuló cientos de millones de secuencias unidimensionales conocidas, pero solo mapeó las estructuras 3D de una pequeña fracción de ellas. Teníamos un sinfín de líneas de source code, pero ningún decompiler que nos mostrara la lógica de ejecución. Resolver el problema del plegamiento de proteínas computacionalmente nos da los planos mecánicos exactos de la biología, convirtiendo el descubrimiento de fármacos de un proceso lento de adivinanzas en el laboratorio a una ingeniería precisa y dirigida. Si te gusta el podcast y quieres apoyar el programa, puedes buscar DevStoriesEU en Patreon. Eso es todo por este episodio. ¡Gracias por escuchar, y a seguir construyendo!

Hola, soy Alex de DEV STORIES DOT EU. AlphaFold: Predicción de la Estructura de Proteínas, episodio 2 de 21. Quieres predecir la forma física de una única secuencia de proteínas, pero mirar solo esa secuencia no es suficiente. Para averiguar cómo se pliega, en realidad necesitas examinar su árbol genealógico evolutivo para detectar patrones sincronizados de mutaciones a lo largo de millones de años. Entender cómo un algoritmo procesa esos patrones evolutivos es exactamente lo que cubrimos en Inside AlphaFold 2: Architecture Overview. La arquitectura funciona como un flujo continuo de datos, transformando un string de letras de aminoácidos en una forma 3D. Empieza con la secuencia objetivo. Antes de que ocurra ningún procesamiento de red neuronal, AlphaFold busca en enormes bases de datos biológicas para recopilar dos inputs específicos basados en esa secuencia. El primer input es el Multiple Sequence Alignment, o MSA. Esta es una colección de secuencias de proteínas similares de otros organismos. Si dos aminoácidos en una secuencia mutan constantemente juntos en diferentes especies, es muy probable que se estén tocando físicamente en la estructura plegada final. El segundo input consiste en templates estructurales. Estas son estructuras 3D conocidas de proteínas que son muy similares a tu secuencia objetivo. Estos MSAs y templates en crudo entran directamente en la Embedding layer. La Embedding layer traduce estos datos biológicos a dos formatos matemáticos distintos que la red neuronal puede procesar. Estos son la representación MSA y la representación Pair. La representación MSA es una matriz que guarda el historial de mutaciones evolutivas. La representación Pair es un grid bidimensional abstracto que rastrea la distancia potencial y la relación física entre cada posible par de aminoácidos en la secuencia. Una vez creadas, ambas representaciones entran en el stack Evoformer. El Evoformer es el motor de AlphaFold 2, y consiste en 48 bloques de procesamiento distintos. Aquí está la clave. Dentro de cada bloque, la representación MSA y la representación Pair hablan entre sí. Intercambian información para refinar sus respectivos datos. Si los datos evolutivos en la representación MSA sugieren fuertemente que dos aminoácidos interactúan, esta actualiza la representación Pair para acercarlos en el grid de distancia abstracto. Por el contrario, si la representación Pair se da cuenta de que juntar dos aminoácidos viola las restricciones de espacio físico, actualiza la representación MSA para reevaluar ese vínculo evolutivo. Esta comunicación cruzada ocurre continuamente a medida que los datos fluyen por los 48 bloques, produciendo un mapa muy preciso de las relaciones internas. La gente suele asumir que el Evoformer genera la forma física final, pero no es así. El Evoformer solo construye representaciones matemáticas abstractas de distancias y vínculos evolutivos. Su output son matrices de datos altamente refinadas, no un objeto físico. Para obtener la forma plegada real, los datos salen del bloque 48 del Evoformer y entran en el Structure Module. El Structure Module toma la representación Pair refinada y los datos de la secuencia original, y traduce ese grid abstracto en coordenadas atómicas 3D reales. Asigna una posición exacta X, Y y Z en el espacio para cada átomo en el backbone de la proteína y sus cadenas laterales. El éxito de AlphaFold 2 depende de que el Evoformer obligue continuamente a la historia evolutiva y a las restricciones espaciales a estar de acuerdo entre sí antes de que se dibuje una sola coordenada 3D. Eso es todo por este episodio. ¡Gracias por escuchar, y sigue construyendo!

Hola, soy Alex de DEV STORIES DOT EU. AlphaFold: Protein Structure Prediction, episodio 3 de 21. La característica más potente de un modelo de IA no siempre es su output, sino su capacidad para decirte exactamente cuándo está adivinando. Si miras un modelo de proteína predicho y asumes que cada loop y dominio está perfectamente ubicado en la realidad, es muy probable que tus experimentos downstream fallen. Para usar estos modelos de forma segura en la vida real, necesitas entender Evaluating Predictions: pLDDT y PAE. AlphaFold devuelve dos métricas distintas para cuantificar su incertidumbre. La primera es pLDDT, que significa predicted Local Distance Difference Test. Esta evalúa la confianza local. Para cada residuo de aminoácido de la proteína, AlphaFold asigna un score entre 0 y 100. Este score te dice cuánta confianza tiene la red en la estructura local del backbone. Cuando un residuo tiene un score por encima de 90, estás ante una confianza muy alta. A este nivel, incluso las orientaciones de las side-chains suelen ser fiables. Un score entre 70 y 90 sigue representando una predicción del backbone buena y fiable. A medida que el score cae por debajo de 70, la confianza se vuelve inestable. Aquí está la clave. Cuando ves un score pLDDT por debajo de 50, tu primer instinto podría ser que el modelo ha fallado al encontrar el fold correcto. Eso suele ser incorrecto. Un score pLDDT muy bajo a menudo indica una región intrínsecamente desordenada. Físicamente, la proteína carece de una estructura fija de forma aislada. Podría ser un linker flexible o una cola que solo se pliega cuando se une a otra molécula. La IA no está fallando; está prediciendo con precisión que este trozo de la proteína es naturalmente flexible. Aunque pLDDT es excelente para los folds locales, tiene un gran punto ciego. Evalúa las regiones de forma aislada. Imagina una proteína con dos dominios estructurales completamente separados, conectados por un string largo de aminoácidos. Ejecutas la predicción, compruebas el pLDDT y ves que ambos dominios tienen un score por encima de 90. Sus estructuras internas son sólidas. Sin embargo, pLDDT no puede decirte si esos dos dominios están correctamente posicionados el uno respecto al otro en el espacio tridimensional. Para resolver esto, AlphaFold proporciona una segunda métrica llamada Predicted Aligned Error, o PAE. Esta métrica evalúa la posición relativa de los dominios. El PAE mide el error de distancia esperado entre dos residuos específicos cualesquiera de la proteína. La lógica plantea una pregunta sencilla: si alineamos la predicción con la estructura real perfectamente en el residuo X, ¿por cuántos Ångströms se desviará el residuo Y? Esto te da un grid bidimensional de errores por pares. Volviendo al escenario de la proteína de dos dominios, si compruebas el PAE entre residuos dentro del primer dominio, el error será muy bajo. Lo mismo se aplica dentro del segundo dominio. Pero si compruebas el PAE entre un residuo del dominio uno y un residuo del dominio dos, el error podría ser muy alto. Un PAE alto entre dominios significa que su orientación relativa es completamente incierta. El modelo sabe exactamente qué aspecto tienen las dos formas por separado, pero no tiene ni idea del ángulo en el que se sitúan la una respecto a la otra. Debes evaluar ambas métricas juntas para entender la foto completa. Usas el pLDDT para fiarte del folding local y para identificar regiones de desorden natural. Te basas en el PAE para verificar si la disposición global de esas distintas partes plegadas es realmente fija, o solo una suposición espacial del algoritmo. Nunca trates una estructura predicha como una única verdad rígida; trátala como un mapa de probabilidades donde cada dominio y linker lleva su propia prueba de fiabilidad. Gracias por pasar unos minutos conmigo. Hasta la próxima, cuídate.

Hola, soy Alex de DEV STORIES DOT EU. AlphaFold: Predicción de la Estructura de Proteínas, episodio 4 de 21. Entrenar un modelo de machine learning revolucionario es impresionante, pero para un biólogo en activo, una red neuronal en crudo es solo otra herramienta pesada que configurar. Para cambiar de verdad el sector, no te limitas a publicar el modelo. Lo usas para plegar casi todas las proteínas conocidas en la Tierra y publicas los resultados online gratis. Esta es la AlphaFold Protein Structure Database. Creada en colaboración entre Google DeepMind y EMBL-EBI, esta base de datos contiene más de 200 millones de estructuras predichas. Esa enorme cifra representa casi todo el universo de proteínas conocido. En lugar de configurar el hardware y ejecutar el algoritmo AlphaFold tú mismo, te saltas el compute por completo y consultas las predicciones ya terminadas. Piensa en el workflow para usar la interfaz web. Si estás investigando el receptor 2 de ácidos grasos libres, entras en alphafold punto ebi punto ac punto uk y escribes ese nombre en la barra de búsqueda. Puedes buscar por nombre de gen o secuencia, pero el método más preciso es usar un número de acceso de UniProt. Como la base de datos mapea directamente con UniProt, cada estructura está estrechamente vinculada a los metadatos biológicos existentes. Cuando seleccionas tu objetivo en los resultados, aterrizas en la página de entrada específica de esa proteína. Esta es la parte que importa. La característica central de la página de entrada es un visor 3D interactivo, pero no solo te muestra la geometría física. Representa visualmente la confianza interna del modelo en esa geometría. AlphaFold puntúa su propia precisión para cada aminoácido usando una métrica llamada pLDDT. El visor 3D codifica por colores el modelo físico basándose en estas puntuaciones exactas. El azul oscuro indica una confianza muy alta en la estructura. El azul claro indica confianza. El amarillo significa baja confianza, y el naranja significa muy baja confianza. Cuando rotas el receptor 2 de ácidos grasos libres en el navegador, verás estructuras helicoidales nítidas de color azul oscuro donde la proteína atraviesa la membrana celular. Pero las colas sueltas que cuelgan de los extremos podrían ser de color naranja brillante. Esas regiones naranjas rara vez son fallos del algoritmo. Suelen ser regiones intrínsecamente desordenadas, es decir, partes de la proteína que no tienen una forma fija en la realidad biológica. Ver la estructura en el navegador está bien para un sanity check rápido, pero el trabajo computacional real requiere los datos raw. Debajo del visor, encontrarás la sección de descargas. Puedes descargar las coordenadas 3D en el formato PDB estándar o en el moderno formato mmCIF. Arrastras estos archivos directamente a tu software de modelado local para medir distancias o simular interacciones moleculares. Junto a los archivos de coordenadas, también debes descargar los datos de Predicted Aligned Error. Esto se proporciona como un simple archivo JSON. Mientras que los colores en el visor 3D te dicen si un trozo local de la proteína es preciso, el archivo JSON de PAE te dice si las posiciones relativas de dos trozos diferentes son precisas. Contiene una matriz de márgenes de error para las distancias entre cada par de residuos. Si tu proteína tiene dos dominios azules sólidos separados por una bisagra flexible, los datos JSON te dirán si realmente puedes confiar en el ángulo entre ellos. La AlphaFold Protein Structure Database cambia tu workflow por completo. Ya no te pasas días intentando predecir una estructura; dedicas minutos a buscarla, y tu trabajo real pasa a ser interpretar las métricas de confianza adjuntas a la descarga. Eso es todo por este episodio. ¡Gracias por escuchar, y a seguir creando!

Hola, soy Alex de DEV STORIES DOT EU. AlphaFold: Predicción de la Estructura de Proteínas, episodio 5 de 21. La bioinformática en el mundo real no se hace simplemente haciendo clic en botones de descarga en un navegador web. Cuando necesitas analizar cientos de proteínas, creas pipelines automatizados y escalables. Esto nos lleva a la automatización del descubrimiento: la API de la AlphaFold Database. Ya sabes que la base de datos contiene millones de predicciones estructurales, pero visualizar una proteína cada vez en una web es inviable para proyectos grandes. Si estás ejecutando un análisis comparativo de toda una familia de enzimas, o evaluando objetivos para un pipeline de descubrimiento de fármacos, necesitas que esas estructuras se descarguen directamente en tu entorno de computación. La AlphaFold Database proporciona una REST API para solucionar exactamente este cuello de botella. Permite a tu código hacer queries a la base de datos y recuperar datos estructurales de forma programática sin intervención humana. La primary key para esta automatización es el ID de UniProt. Puedes pensar en un ID de UniProt como el código de barras universal para cualquier proteína. Tu pipeline generalmente empieza con una lista de estos IDs. Usando una librería HTTP estándar en Python, envías una request a la API pidiendo los datos de predicción asociados a un código de barras específico. Esta es la parte importante. Cuando haces esa request, la API no te devuelve un archivo enorme lleno de coordenadas atómicas tridimensionales. Servir archivos pesados mediante una API call síncrona es lento y frágil. En su lugar, la API devuelve un manifest. Este manifest es una response ligera que describe exactamente qué recursos hay disponibles para la proteína que has pedido. Conceptualmente, este manifest te da los metadatos biológicos y un directorio de links de descarga directa. Apunta a los archivos de estructura 3D reales en formatos estándar de la industria. Y lo que es crucial, también proporciona links a las métricas de confianza, como la matriz de Predicted Aligned Error, o PAE. Necesitas ambas cosas. En un pipeline automatizado, descargar la estructura es solo la mitad del trabajo. También tienes que descargar los datos PAE para que tus algoritmos downstream sepan qué partes de la proteína tienen una alta confianza y cuáles son flexibles. Veamos cómo fluye esta lógica en un script típico de Python. Configuras un loop para iterar sobre tu lista de IDs de UniProt. Dentro del loop, haces tu network request para el primer ID. Antes de hacer nada más, compruebas el status code de HTTP. No todas las secuencias de proteínas que existen tienen una estructura de AlphaFold precalculada. Si pides una proteína no mapeada, la base de datos devuelve un error cuatro cero cuatro Not Found estándar. Tu script debe hacer un catch de este error de forma elegante, hacer un log del ID que falta y continuar con la siguiente iteración. Si ignoras los status codes e intentas parsear una response que no existe, todo tu batch job hará crash en la primera proteína no soportada. Cuando la request tiene éxito, tu script lee el manifest devuelto. Escribes la lógica para extraer los links de descarga específicos que te interesan, que normalmente son el archivo de coordenadas principal y el archivo de matriz de errores correspondiente. Luego, tu script hace requests HTTP secundarias a esos links específicos, haciendo streaming de los datos pesados directamente a tu almacenamiento local o a tu cloud bucket. Al separar la query de la descarga, la API mantiene la fase inicial de descubrimiento increíblemente rápida. Puedes comprobar rápidamente la disponibilidad de miles de proteínas, crear una lista validada de links y luego gestionar las descargas pesadas en bulk. El verdadero valor de la API de AlphaFold es que elimina el cuello de botella humano, convirtiendo una enorme base de datos estática en un componente totalmente programable de tu arquitectura de investigación. Eso es todo por este episodio. ¡Gracias por escuchar, y sigue programando!

Hola, soy Alex de DEV STORIES DOT EU. AlphaFold: Predicción de la estructura de proteínas, episodio 6 de 21. Cuando ejecutas una predicción de la estructura de una proteína, la red neuronal rara vez es el cuello de botella. La verdadera espera ocurre antes incluso de que el modelo arranque, robándote horas del día solo para buscar en bases de datos genéticas. Predecir estructuras con ColabFold cambia por completo esta ecuación. El pipeline estándar de AlphaFold se basa en una herramienta llamada Jackhmmer. Jackhmmer escanea bases de datos locales masivas, de terabytes, para encontrar parientes evolutivos de tu proteína objetivo. Esta búsqueda crea el Alineamiento Múltiple de Secuencias, o MSA. El MSA es el input crítico que le dice a AlphaFold qué partes de la proteína tienen más probabilidades de interactuar basándose en su historia evolutiva. Sin embargo, generar este alineamiento de la forma tradicional lleva horas de tiempo de cómputo y te obliga a gestionar datasets enormes en tu propia infraestructura. ColabFold modifica este pipeline atacando ese cuello de botella específico. Sustituye Jackhmmer por un algoritmo de búsqueda diferente llamado MMseqs2. MMseqs2 está muy optimizado para la búsqueda de secuencias a alta velocidad. Pero ColabFold va un paso más allá de simplemente cambiar de algoritmo. En lugar de hacerte ejecutar MMseqs2 y sus bases de datos asociadas en tu máquina local, ColabFold externaliza este paso por completo. Coge tu secuencia de input y la envía a un servidor público dedicado de MMseqs2 a través de una API. Este servidor se encarga del trabajo pesado. Busca en sus propias bases de datos gestionadas de forma centralizada y devuelve el MSA terminado directamente a tu entorno. Este cambio de arquitectura significa que no necesitas almacenamiento local de bases de datos en absoluto. Por esto mismo puedes ejecutar ColabFold perfectamente dentro de un Jupyter Notebook alojado en servicios en la nube como Google Colab o UCloud. El setup casi no requiere infraestructura. Abres el notebook y pegas tu secuencia de aminoácidos. Puede ser una proteína de tipo silvestre, o una secuencia mutada personalizada con la que estés experimentando. Cuando ejecutas el notebook, la ejecución ocurre en dos fases distintas. Primero, tu entorno en la nube hace una llamada rápida a la API del servidor remoto MMseqs2. El servidor calcula el alineamiento y envía el MSA de vuelta a tu notebook. Esto reduce un proceso que normalmente lleva horas a solo unos minutos o incluso segundos. Ahora, entra en juego la segunda parte de este workflow. Tu notebook le pasa ese MSA recuperado a la red neuronal de AlphaFold. Aquí es donde ocurre la predicción de plegamiento real. A diferencia de la búsqueda en la base de datos, este paso de inferencia se ejecuta en local dentro de tu instancia en la nube. Utiliza la GPU asignada a tu sesión de Google Colab o UCloud para calcular las coordenadas espaciales de la estructura de la proteína. Como la lenta búsqueda en bases de datos se externaliza y se acelera, tu tiempo total de iteración se reduce drásticamente. Obtienes la predicción de alta precisión de la red neuronal que esperas de AlphaFold, pero la obtienes rápido. Si necesitas probar cómo una mutación puntual específica altera la forma física de una proteína, simplemente editas una sola letra en tu variable de secuencia, vuelves a ejecutar la celda y evalúas el nuevo output. Aquí está la clave. ColabFold demuestra que, al desacoplar por completo la búsqueda del alineamiento, que requiere muchísimos datos, de la inferencia de la red neuronal, puedes meter herramientas de biología estructural de primer nivel en un navegador web estándar. Eso es todo por este episodio. Gracias por escuchar, ¡y seguid creando!

Hola, soy Alex de DEV STORIES DOT EU. AlphaFold: Protein Structure Prediction, episodio 7 de 21. Predecir una sola proteína es como adivinar la forma de una pieza de puzle aislada. Pero en biología, las proteínas rara vez actúan solas. Si metes dos secuencias aleatorias en un modelo de predicción estándar, a menudo simplemente las fusionará en el espacio tridimensional, independientemente de si realmente se unen en la naturaleza. Para descubrir cómo encajan realmente múltiples piezas flexibles, necesitas una herramienta diferente. Esa es AlphaFold-Multimer. El AlphaFold estándar está optimizado para cadenas polipeptídicas individuales. AlphaFold-Multimer es una versión reentrenada del sistema diseñada específicamente para predecir complejos proteicos. Está entrenado para reconocer y modelar tanto interfaces homoméricas, donde se unen múltiples copias de la misma proteína, como interfaces heteroméricas, donde interactúan proteínas completamente diferentes. Cuando le pasas múltiples secuencias a AlphaFold-Multimer, siempre devuelve un complejo predicho. El desafío crucial es determinar si esa interfaz predicha es una interacción biológica real o una colisión artificial forzada. El modelo hace lo que le pides, así que colocará las cadenas una al lado de la otra. Para resolver el problema de las interacciones falsas, AlphaFold-Multimer introduce una métrica de confianza especializada llamada interface predicted Template Modeling score, o ipTM. Las puntuaciones de confianza estándar evalúan lo bien que se pliega un trozo localizado de una cadena. La puntuación ipTM ignora por completo la estructura interna de las proteínas individuales. En su lugar, mide la precisión de las posiciones relativas de las cadenas. Específicamente, evalúa la confianza en la interfaz donde se unen las proteínas. Imagina un escenario en el que estás prediciendo un complejo anticuerpo-antígeno de dos cadenas. Le pasas al modelo la secuencia de aminoácidos del anticuerpo y la secuencia del antígeno diana. El sistema genera una estructura que contiene ambas moléculas. Primero, compruebas las puntuaciones de confianza locales estándar para cada cadena. Podrían ser muy altas, lo que indica que el modelo sabe exactamente cómo se pliegan el anticuerpo aislado y el antígeno aislado. Presta atención a esta parte. Puedes tener cadenas individuales perfectamente plegadas con una puntuación ipTM cercana a cero. Si el ipTM es bajo, el modelo te está diciendo que, aunque las formas son correctas, no tiene ni idea de cómo se conectan. Simplemente aparcó las dos estructuras plegadas una junto a la otra porque le diste dos secuencias. La interfaz no tiene sentido. Sin embargo, si la puntuación ipTM es alta, normalmente cualquier cosa por encima de cero coma ocho, el modelo confía en la interacción. Un ipTM alto significa que el sistema ha encontrado evidencia estructural y evolutiva de que estas superficies específicas encajan. El modelo no las está juntando a la fuerza; está prediciendo un evento de unión genuino. Para clasificar los outputs finales, AlphaFold-Multimer calcula una puntuación de confianza combinada. Esta métrica combinada le da mucho peso a la interfaz, normalmente tomando el ochenta por ciento de la puntuación ipTM y sumando el veinte por ciento de la puntuación estructural general. El modelo con la puntuación combinada más alta se devuelve como tu mejor predicción. La precisión estructural de las cadenas individuales no garantiza una interacción válida. El interface predicted Template Modeling score es la métrica definitiva para demostrar que el modelo ha descubierto un complejo biológico genuino en lugar de simplemente cumplir la petición de agrupar dos secuencias. Eso es todo por este episodio. Gracias por escuchar, ¡y sigue construyendo!

Hola, soy Alex de DEV STORIES DOT EU. AlphaFold: Predicción de la Estructura de Proteínas, episodio 8 de 21. Un solo typo en una secuencia de miles de aminoácidos puede marcar la diferencia entre la salud y una enfermedad genética grave. Pero cuando secuencias el genoma de un paciente y encuentras una mutación nueva, ¿cómo sabes si es la causa raíz o simplemente ruido biológico inofensivo? AlphaMissense ofrece una respuesta matemática a ese mismo problema. Una variante missense es una mutación genética donde el cambio de una sola letra de ADN resulta en la sustitución de un aminoácido por otro en la proteína final. El genoma humano medio contiene miles de estas variantes. Muchas son totalmente benignas. Alteran una parte periférica de la proteína sin afectar a su función general. Otras rompen la proteína por completo, provocando enfermedades genéticas graves. Separar las variantes peligrosas de las inofensivas es un cuello de botella enorme en la genética clínica. AlphaMissense es un modelo creado específicamente para clasificar estos efectos. Tenemos que aclarar un malentendido muy común desde el principio. AlphaMissense no predice los cambios estructurales en 3D causados por una mutación. No genera un output con un archivo nuevo que muestre la forma deformada de la proteína. En su lugar, aprovecha el contexto estructural y evolutivo que ya ha aprendido la red de AlphaFold para calcular una probabilidad. Devuelve como output un score de patogenicidad continuo que va de cero a uno. Este score representa la probabilidad de que una mutación específica cause una enfermedad. Imagina un escenario concreto. Estás analizando el genoma de un paciente y aíslas una nueva sustitución de un solo aminoácido en un gen crítico. Una valina ha reemplazado a una alanina en la posición 142. El paciente está enfermo, pero esta mutación exacta nunca se ha documentado en la literatura médica. Necesitas saber si esta sustitución es patogénica. Haces una query a la base de datos de AlphaMissense para esta variante específica. Por debajo, el modelo evalúa la conservación evolutiva de esa posición exacta mirando los alineamientos de secuencias múltiples. Comprueba si la naturaleza ha tolerado cambios en esta posición a lo largo de millones de años de evolución. También evalúa el contexto estructural. Un aminoácido fuertemente empaquetado en el núcleo hidrofóbico de la proteína es mucho más sensible a los cambios que uno que flota libremente en la superficie exterior. AlphaMissense procesa estas señales evolutivas y estructurales para devolverte tu score. Un score cercano a cero significa que la variante probablemente sea benigna. La proteína probablemente se pliega y funciona con normalidad. Un score cercano a uno la marca como probablemente patogénica. La sustitución casi con total seguridad rompe la estabilidad o la función de la proteína. Para que estos datos sean accionables, el modelo aplica thresholds predefinidos. Los scores que quedan por encima del threshold superior se categorizan como probablemente patogénicos. Los scores por debajo del threshold inferior son probablemente benignos. Cualquier cosa que caiga en la franja intermedia se clasifica como ambigua. Esta clasificación te permite filtrar al instante el ruido genómico. En lugar de diseñar experimentos de laboratorio caros y lentos para probar cada variante desconocida en el genoma del paciente, enfocas inmediatamente tus recursos clínicos en las pocas mutaciones que AlphaMissense marca con un score alto. Aquí está la clave. El verdadero impacto de esta herramienta es su escala. AlphaMissense no espera a recibir queries. Ya ha calculado el score de patogenicidad para los 71 millones de posibles sustituciones de un solo aminoácido en todo el proteoma humano, catalogando los resultados antes de que un paciente llegue a pisar la clínica. Si te gusta el podcast y quieres ayudarnos a que el programa siga adelante, puedes apoyarnos buscando DevStoriesEU en Patreon. Eso es todo por este episodio. ¡Gracias por escuchar, y a seguir construyendo!

Hola, soy Alex de DEV STORIES DOT EU. AlphaFold: Predicción de la Estructura de Proteínas, episodio 9 de 21. Podrías pensar que el mayor obstáculo para predecir estructuras de proteínas es encontrar una GPU lo suficientemente potente. Pero el verdadero cuello de botella es el almacenamiento. Antes de plegar un solo aminoácido, necesitas consultar bases de datos evolutivas masivas de varios terabytes. Este episodio trata sobre hacer el deploy de AlphaFold 2 en local. Ejecutar AlphaFold en tu propio hardware te da una estricta privacidad para las secuencias propietarias y elimina los límites de tiempo de ejecución que se encuentran en los servidores públicos. DeepMind proporciona el código open-source directamente en GitHub. Para usarlo, primero debes replicar el entorno de referencia genética exacto que el modelo utiliza para encontrar secuencias similares. Esto requiere descargar copias locales de bases de datos públicas como BFD, MGnify, UniRef90 y PDB70. En conjunto, estas bases de datos sin comprimir consumen aproximadamente tres terabytes de almacenamiento. Imagina a un ingeniero DevOps aprovisionando un nuevo nodo de High Performance Computing para un equipo de investigación. El primerísimo requisito es un disco de tres terabytes. Aquí no puedes usar discos mecánicos baratos y lentos. Necesitas almacenamiento NVMe rápido. La búsqueda entre millones de secuencias genéticas genera operaciones de lectura de disco muy agresivas. Si tu almacenamiento es lento, todo el pipeline se ahoga antes de que los datos lleguen a la red neuronal. Aquí está la clave. El pipeline local de AlphaFold consta de dos fases de computación distintas, y requieren perfiles de hardware completamente diferentes. La fase uno genera el Multiple Sequence Alignment, o MSA. El sistema busca en tus terabytes de bases de datos locales usando herramientas bioinformáticas externas. Esta fase usa exactamente cero ciclos de GPU. Su cuello de botella depende totalmente de los cores de la CPU, la memoria del sistema y la velocidad del disco. La fase dos es la inferencia estructural en sí. Aquí es donde la red neuronal toma el control para generar las coordenadas 3D, y esta fase requiere estrictamente una GPU con una cantidad significativa de VRAM. Si aprovisionas un nodo con una GPU enorme pero una CPU débil, tu job de predicción se quedará atascado durante horas en la fase de alineamiento. Gestionar las dependencias de software para estas dos fases es especialmente difícil. Tienes que cuadrar versiones específicas de CUDA, Jax y las herramientas de alineamiento de secuencias. Para solucionar esto, el repositorio oficial se apoya muchísimo en Docker. La contenerización asegura que este complejo entorno de ejecución se mantenga aislado y consistente en diferentes sistemas operativos. Configurar el deploy implica dos scripts principales. Primero, ejecutas un script de bash que te proporcionan para descargar los datos. Lo apuntas a tu disco NVMe y lo dejas corriendo. Dependiendo de tu conexión de red, descargar y extraer estos archivos puede tardar unos días. Una vez que los datos ya están en tu almacenamiento rápido, estás listo para la ejecución. Controlas el pipeline usando un script wrapper de Python que te proporcionan, llamado run docker dot py. Ejecutas este script desde la terminal, pasándole algunos argumentos obligatorios. Le pasas el path al archivo FASTA de entrada que contiene tu secuencia de aminoácidos objetivo. Le pasas el path al directorio de tu base de datos de varios terabytes. Especificas un directorio de salida. Finalmente, configuras una fecha máxima de publicación de plantillas, lo que restringe al modelo de usar plantillas estructurales conocidas que se hayan publicado después de un momento específico. El wrapper de Python coge estos argumentos y construye el contenedor Docker. Monta los directorios de tu host local en el contenedor como volúmenes, permitiendo que el software aislado lea tus bases de datos y escriba los archivos de salida de vuelta en tu disco. El contenedor entonces toma el control, orquestando automáticamente la búsqueda de alineamiento intensiva en CPU y el proceso de inferencia intensivo en GPU. Hacer el deploy de AlphaFold en local es fundamentalmente un reto de infraestructura, que requiere que equilibres una velocidad de disco rápida para la fase de alineamiento intensiva en CPU, con una VRAM capaz para la fase de plegado intensiva en GPU. Gracias por pasar unos minutos conmigo. Hasta la próxima, cuídate.

Hola, soy Alex de DEV STORIES DOT EU. AlphaFold: Predicción de la Estructura de Proteínas, episodio 10 de 21. Durante años, si querías ver cómo interactuaba un fármaco potencial con una proteína target, tenías que ejecutar tu secuencia, generar una estructura proteica y luego usar un software completamente aparte para hacer un docking computacional del fármaco en su sitio. Estabas forzando un químico rígido dentro de un modelo rígido. AlphaFold 3 cambia esto por completo al hacer el folding de todo al mismo tiempo. Hoy presentamos AlphaFold 3: Más allá de las proteínas. Las versiones anteriores de AlphaFold se centraban exclusivamente en predecir la estructura de las proteínas basándose en sus secuencias de aminoácidos. Eran increíblemente buenas en eso, pero los sistemas biológicos reales no funcionan como proteínas desnudas flotando en el vacío. Las proteínas interactúan con el ADN para activar y desactivar genes. Dependen de iones metálicos para catalizar reacciones. Son bloqueadas o activadas por pequeñas moléculas de fármacos. Antes de esta actualización, modelar estas interacciones complejas requería un pipeline fragmentado. Primero predecías la estructura de la proteína, luego quizás modelabas el ADN por separado y, finalmente, intentabas calcular cómo encajaban físicamente. Este enfoque secuencial tiene un gran defecto: asume que la estructura de la proteína es estática. En realidad, las proteínas cambian de forma dinámicamente al unirse a otras moléculas. Aquí está la clave. AlphaFold 3 pasa de ser una simple herramienta de protein folding a un predictor generalizado de complejos biomoleculares. Amplía su vocabulario nativo más allá de los aminoácidos para incluir tres categorías de moléculas completamente nuevas. En primer lugar, ahora admite ácidos nucleicos, lo que significa que puedes pasarle como input secuencias tanto de ADN como de ARN. En segundo lugar, comprende de forma nativa los ligandos de moléculas pequeñas, lo que abarca la gran mayoría de los fármacos. En tercer lugar, admite la inclusión de iones esenciales que a menudo se encuentran en el núcleo de las proteínas funcionales. En lugar de predecir estos componentes de forma aislada, AlphaFold 3 predice la estructura conjunta de todas estas entidades moleculares distintas a la vez. Calcula las interacciones entre cada átomo de todo el complejo en una sola pasada. Piensa en cómo esto cambia un escenario de modelado estándar. Ya no estás analizando un target aislado. Ahora puedes definir un input que contenga una secuencia de proteínas, una hebra específica de ADN y la definición química de un pequeño fármaco inhibidor. El sistema los evalúa juntos. El output resultante muestra a la proteína agarrando activamente la hebra de ADN, mientras que la pequeña molécula del fármaco está encajada perfectamente en el binding pocket. Como se hizo el folding de todo en el mismo espacio computacional, el modelo de la proteína refleja automáticamente los cambios estructurales causados tanto por el ADN como por el fármaco. Esto no es simplemente el antiguo motor de AlphaFold con un algoritmo de docking acoplado al final. Es una arquitectura de modelo completamente distinta, entrenada directamente sobre cómo interactúan las diferentes clases de moléculas biológicas en el espacio físico. El cambio más significativo con AlphaFold 3 es que ya no estás generando partes biológicas aisladas, sino que estás prediciendo máquinas moleculares completas que interactúan, exactamente tal y como existen en el mundo físico. Eso es todo por este episodio. Gracias por escuchar, ¡y sigue construyendo!

Hola, soy Alex de DEV STORIES DOT EU. AlphaFold: Predicción de la Estructura de Proteínas, episodio 11 de 21. Ya no necesitas un título de ingeniería ni un superordenador para ejecutar la IA biomolecular más avanzada del mundo. La barrera de entrada ha bajado a un simple navegador web. Ese es el AlphaFold Server, tu puerta de entrada directa a AlphaFold 3. Históricamente, ejecutar predicciones de estructuras complejas implicaba gestionar dependencias de software, descargar terabytes de bases de datos genéticas y mantener potentes GPUs. El AlphaFold Server se salta todo eso. Es una interfaz web completamente gráfica que permite a biólogos y químicos ejecutar jobs de AlphaFold 3 sin escribir ni una sola línea de código. Todos los alineamientos de secuencias múltiples, la búsqueda de templates y el plegamiento basado en difusión ocurren de forma remota en una infraestructura de computación compartida. Antes de ver paso a paso una predicción, tenemos que aclarar dos límites estrictos. Primero, el AlphaFold Server es exclusivamente para uso no comercial. Segundo, como depende de los recursos de computación proporcionados, tu cuenta está sujeta a límites diarios de jobs. No puedes usarlo para hacer fuerza bruta en una pipeline de screening masivo. Está diseñado para el diseño experimental específico de un solo job. Así es como construyes un job de predicción complejo y multi-chain en la interfaz. Todo el workflow gira en torno a añadir entidades separadas a un workspace compartido. Empiezas con tu proteína principal. Haces clic en el botón para añadir una entidad de proteína. Aparece un campo de texto. Simplemente pegas tu secuencia de aminoácidos de una letra directamente en esa caja. Si esperas que esta proteína forme un homodímero, no necesitas pegar la secuencia dos veces. Solo cambias la configuración del número de copias a dos, y el sistema se encarga de la estequiometría. Ahora, la segunda parte de esto es añadir moléculas que interactúan. Supón que quieres ver cómo se une esa proteína a un segmento específico de ADN. Haces clic para añadir una entidad de ADN y pegas la secuencia de la cadena forward. Para construir la doble hélice real, añades otra entidad de ADN y pegas la secuencia reverse complement. AlphaFold 3 los modelará juntos en el mismo espacio tridimensional, prediciendo tanto el emparejamiento de bases del ADN como su interfaz estructural con tu proteína. Aquí es donde se pone interesante para los componentes no poliméricos. El servidor soporta ligandos, iones y cofactores de forma nativa. Si tu proteína requiere un ion metálico específico para estabilizar su plegamiento, haces clic para añadir una entidad de ion. No necesitas buscar identificadores químicos complejos ni escribir strings SMILES para componentes estándar. El servidor proporciona un menú dropdown integrado. Simplemente buscas un ion común, seleccionas Magnesio o Zinc, defines cuántas copias necesitas, y la interfaz lo fija. Una vez que tu workspace contiene la secuencia de la proteína, las dos hebras de ADN y el ion seleccionado, le das al botón de submit. Ese es todo el setup. Por debajo, el servidor toma el control. Gestiona las pipelines de alineamiento, introduce los datos en la red neuronal de AlphaFold 3 y ejecuta el proceso de difusión estructural. Cuando el job termina, los resultados se cargan directamente en tu navegador. Obtienes un visor 3D embebido para inspeccionar el complejo predicho de inmediato. Más importante aún, obtienes un paquete limpio para descargar, que contiene los archivos de coordenadas atómicas predichas y todas las métricas de confianza asociadas para tu análisis local. El verdadero poder del servidor no es solo el acceso inmediato al modelo, sino la pura velocidad de iteración que proporciona al probar hipótesis estructurales. Eso es todo por este episodio. ¡Gracias por escuchar, y seguid construyendo!

Hola, soy Alex de DEV STORIES DOT EU. AlphaFold: Predicción de la Estructura de Proteínas, episodio 12 de 21. Predecir con exactitud cómo se une un nuevo fármaco a una proteína diana parece un avance brutal, hasta que te das cuenta de que la IA simplemente ha colocado dos átomos de carbono sólidos en el mismo espacio físico exacto. Una estructura con un renderizado precioso es inútil si desafía las leyes de la física. Hoy hablaremos sobre cómo interpretar los resultados de AlphaFold 3 para ayudarte a separar la información biológica de las alucinaciones computacionales. AlphaFold 3 genera un archivo de coordenadas tridimensionales junto con un conjunto de métricas específicas. Evaluar un resultado requiere leer estas métricas en conjunto, ya que un score alto en un área puede enmascarar un fallo catastrófico en otra. Primero, te fijas en la confianza local usando una métrica llamada pLDDT. Esta puntúa cada átomo o residuo en una escala de cero a cien. Un score alto significa que el modelo tiene mucha certeza sobre la geometría local específica de esa chain. Pero la confianza local por sí sola no es suficiente. Puedes tener una proteína y un ligando de molécula pequeña perfectamente predichos que flotan independientemente en el espacio. Para saber si interactúan realmente, debes comprobar el Predicted Aligned Error, o PAE. El PAE mide el error de posición esperado en angstroms. Cuanto menor sea el número, mejor. Cuando predices complejos, como una proteína uniéndose a una hebra de ADN o a una molécula de fármaco, te centras en el cross-PAE. Piensa en el output del PAE como una matriz de heatmap. La diagonal muestra la confianza del modelo en la estructura interna de una sola chain. Las áreas fuera de la diagonal muestran la confianza entre diferentes entidades. Si el PAE entre tu proteína y tu ligando es bajo, AlphaFold tiene mucha confianza en sus posiciones relativas. Cree firmemente que el ligando se encuentra exactamente en ese pocket específico. Esta es la clave. Una alta confianza no implica automáticamente realidad física. AlphaFold 3 es un modelo de deep learning, no un simulador de dinámica molecular. Prioriza los patrones espaciales reconocidos sobre la física estricta. Esto nos lleva al clash score. Dado que AlphaFold 3 modela ligandos, ácidos nucleicos y residuos modificados directamente, sin un paso de relajación basado en la física, los outputs pueden contener steric clashes severos. Un clash ocurre cuando a dos átomos se les asignan coordenadas que los sitúan a una distancia imposible, superponiéndose en la práctica. El server calcula y proporciona un clash score para tu output. Un clash score alto es una red flag enorme. Imagina un escenario en el que analizas un output y la chain principal de la proteína tiene un pLDDT superior a 90. El cross-PAE entre la proteína y tu ligando diana es muy bajo. Las métricas de interfaz sugieren un evento de binding fuerte y seguro. Sobre el papel, parece una predicción de docking perfecta. Luego compruebas el clash score y ves que está altísimo. Si cargas las coordenadas físicas en un viewer, verás que el ligando atraviesa directamente el backbone de la proteína. La red neuronal reconoció que el ligando pertenece a ese binding pocket general, pero falló al enrutar los átomos alrededor de las side chains existentes. Alucinó una molécula fantasma que ignora la materia sólida. Cuando evalúas un resultado de AlphaFold 3, debes comprobar la confianza estructural y el realismo físico simultáneamente. Usa el pLDDT para verificar la forma de las moléculas individuales. Usa el PAE para confirmar que interactúan donde esperas que lo hagan. Luego, comprueba el clash score para asegurarte de que el modelo no ha violado la química básica para forzar que ocurra esa interacción. Recuerda que un modelo de deep learning genera como output una hipótesis espacial basada en el reconocimiento de patrones, por lo que una predicción de alta confianza solo es válida si los átomos respetan realmente las leyes de la física. Eso es todo por este episodio. Gracias por escuchar, ¡y sigue programando!

Hola, soy Alex de DEV STORIES DOT EU. AlphaFold: Predicción de la Estructura de Proteínas, episodio 13 de 21. DeepMind ha hecho open-source su último modelo de biología estructural, pero si clonas el repository e intentas ejecutarlo, fallará inmediatamente. El código es completamente público, pero la red neuronal real que genera las predicciones está estrictamente controlada. Hoy vamos a ver el inference pipeline de AlphaFold 3 y cómo te las apañas realmente para hacer su deploy. Para ejecutar AlphaFold 3 localmente, tienes que unir dos piezas separadas: el código de ejecución y los parámetros del modelo. El repository te da la lógica del pipeline. Para los parámetros, en concreto los weights de la versión tres punto cero punto uno, tienes que solicitar acceso por separado. Google te pide que envíes un formulario detallando tu caso de uso para investigación no comercial. Una vez que aprueban tu solicitud, recibes un enlace para descargar los pesados weights del modelo. Este enfoque dividido permite a DeepMind restringir el uso comercial, a la vez que deja a los investigadores inspeccionar y ejecutar el pipeline open-source en su propio hardware. Después de descargar los weights, tu siguiente paso es definir qué quieres que prediga el modelo. Las versiones anteriores de AlphaFold trabajaban sobre todo con cadenas de proteínas individuales, así que podías simplemente pasarle un string de texto básico con los aminoácidos. AlphaFold 3 modela interacciones complejas entre diversos tipos de moléculas, por lo que un string básico ya no es suficiente. En su lugar, creas un archivo de configuración. Este archivo actúa como un manifest completo para tu objetivo biológico. Especificas las moléculas exactas que participan en tu experimento. Puede ser una proteína estándar, una cadena de ADN o ARN, o un ligando de molécula pequeña específico. En este mismo archivo de configuración, también defines las seeds de aleatoriedad. Como la nueva arquitectura del modelo se basa en un proceso de difusión para generar la estructura tridimensional final, introducir ligeras variaciones en la random seed produce diferentes estados estructurales posibles. Al definir múltiples seeds en tu configuración, le indicas al pipeline que genere predicciones distintas para exactamente el mismo input. También declaras una versión de dialect en este archivo, que simplemente le dice al parsing engine que aplique las reglas de validación de AlphaFold 3 a tu manifest. Con tus weights descargados y tu archivo de configuración listo, pasas a la ejecución. Como este pipeline depende de versiones muy específicas de librerías de machine learning y drivers de GPU, ejecutarlo directamente en tu sistema operativo host es arriesgado. El flujo de trabajo oficial se basa en Docker. Construyes una imagen de container directamente desde el repository proporcionado, fijando el entorno perfecto. Para ejecutar realmente la inference, lanzas este container y lo conectas a tu máquina host haciendo mount de tres rutas críticas. Primero, haces mount de la carpeta que contiene tu archivo de configuración de input. Segundo, haces mount del directorio que contiene esos enormes weights del modelo ya aprobados que descargaste antes. Finalmente, haces mount de un directorio vacío donde el container puede escribir sus resultados. Una vez que arranca el container, invocas el script de run principal. El pipeline valida tu manifest de input, carga los weights desde tu directorio montado a la memoria de la GPU, y empieza la predicción estructural. Cuando el proceso termina, tu carpeta de output montada contendrá las coordenadas finales de las moléculas que pediste, formateadas y listas para su visualización. El principal desafío de este pipeline no es el código subyacente, sino gestionar la logística para conseguir los weights del modelo y estructurar meticulosamente tu archivo de configuración para mapear interacciones biológicas complejas. Si quieres apoyar el programa, puedes buscar DevStoriesEU en Patreon. Eso es todo por este episodio. ¡Gracias por escuchar y sigue construyendo!

Hola, soy Alex de DEV STORIES DOT EU. AlphaFold: Predicción de la estructura de proteínas, episodio 14 de 21. El mayor error que cometen los ingenieros al hacer deploy de AlphaFold es dejar las costosas GPUs inactivas mientras esperan a que terminen las queries básicas a la base de datos. Provisionas una A100, lanzas un job y ves cómo tu utilización se queda plana en el cero por ciento durante horas. La solución es separar tus entornos de ejecución, que es exactamente lo que vamos a ver hoy con Data Pipelines y Hardware Requirements. AlphaFold 3 hace dos tipos de trabajo fundamentalmente distintos. Primero, busca en bases de datos genéticas masivas para construir Multiple Sequence Alignments y encontrar templates estructurales. Segundo, pasa esos datos procesados a la red neuronal para predecir la estructura tridimensional final. La búsqueda en la base de datos está totalmente limitada por la CPU y las velocidades de lectura del almacenamiento. La predicción de la red neuronal requiere una GPU. Si corres el setup por defecto, AlphaFold hace ambos pasos en secuencia en la misma máquina. Esto significa que tu carísima GPU no hace absolutamente nada mientras tu CPU se pasa horas procesando terabytes de bases de datos de referencia. Aquí está la clave. El repositorio proporciona dos flags de ejecución específicos para desacoplar estas cargas de trabajo. El primer flag es run data pipeline. Cuando ejecutas el script con este flag activado y run inference desactivado, AlphaFold solo hace las búsquedas genéticas y de templates. Lee tu configuración de entrada, hace las queries a las bases de datos locales y genera todas las features de secuencia necesarias. Luego guarda este estado intermedio de los datos en el disco. Lo más importante es que este paso requiere cero recursos de GPU. Depende estrictamente de una máquina con muchos cores de CPU y discos NVMe rápidos para manejar las pesadas operaciones de input y output. Una vez que el data pipeline termina de construir las features, usas el segundo flag. Ejecutas el script de nuevo, pero pones run data pipeline en false y run inference en true. AlphaFold se saltará la búsqueda en la base de datos por completo. Carga directamente los datos de las features cacheadas que acabas de generar, inicializa los pesos del modelo y ejecuta el forward pass de la red neuronal. Este paso es completamente GPU bound. Depende exclusivamente de tu acelerador de hardware y de su memoria de alto ancho de banda. Esta separación explícita es cómo diseñas una infraestructura enterprise en condiciones. En lugar de conectar discos enormes de bases de datos a múltiples máquinas GPU carísimas, provisionas una flota de nodos CPU rentables. Distribuyes tus requests de predicción entrantes entre estos nodos CPU, usándolos para hacer queries agresivas a las bases de datos y generar alineamientos en paralelo. Cada vez que un nodo CPU termina un job del data pipeline, deja los archivos de features resultantes en un sistema de almacenamiento compartido. Mientras tanto, mantienes un único nodo altamente utilizado con una GPU potente. Esta máquina existe estrictamente para inferencia. Monitoriza constantemente el almacenamiento compartido. Cuando aparece un nuevo archivo de features, lo coge, ejecuta la predicción de la red neuronal en minutos, escribe la estructura molecular final e inmediatamente descarga el siguiente archivo. Tu GPU nunca más vuelve a esperar por un cuello de botella de almacenamiento o una búsqueda en la base de datos. Desacoplar el data pipeline, que es CPU bound, de la inferencia, que es GPU bound, es la forma más efectiva de escalar la predicción de la estructura de proteínas manteniendo los costes de hardware bajo control. Gracias por pasar unos minutos conmigo. Hasta la próxima, cuídate.

Hola, soy Alex de DEV STORIES DOT EU. AlphaFold: Predicción de la Estructura de Proteínas, episodio 15 de 21. Tu modelo de proteína es sorprendentemente pequeño, con menos de cien millones de parámetros. Predices con éxito la estructura de una secuencia de 500 residuos en una GPU estándar de 16 gigabytes, pero cuando le pasas una secuencia de 1500 residuos, el proceso crashea instantáneamente con un error de out of memory, pidiendo de repente más de 80 gigabytes de VRAM. Este escalado catastrófico ocurre por una característica arquitectónica específica llamada el Memory Bottleneck: O(n³) Attention. Según el paper de FastFold de Cheng et al., este consumo explosivo de memoria no tiene nada que ver con los weights del modelo. El modelo completo de AlphaFold contiene solo 93 millones de parámetros. El bottleneck está completamente en las activaciones intermedias generadas durante el forward pass. A medida que crece la longitud de la secuencia, la memoria necesaria para almacenar estos tensores intermedios escala cúbicamente. Para entender por qué, tenemos que mirar dentro del Evoformer. El Evoformer es el tronco estructural principal de AlphaFold, compuesto por 48 bloques apilados. Dentro de cada bloque, el modelo se basa en un mecanismo de attention especializado. Los transformers estándar, como los que se usan en los modelos de lenguaje, suelen tener mecanismos de attention donde la memoria escala cuadráticamente con la longitud de la secuencia. Solo comparan una secuencia unidimensional consigo misma. AlphaFold es diferente. Utiliza una representación intermedia bidimensional para modelar las interacciones pairwise entre aminoácidos. Aquí está la clave. Para predecir con precisión estructuras de proteínas tridimensionales, la red no puede simplemente mirar pares de residuos de forma aislada. Debe evaluar relaciones triangulares para asegurar que las distancias predichas entre tres puntos sean físicamente posibles en el espacio tridimensional. Para calcular esto, el módulo de attention genera tensores de activación intermedios. El memory footprint de estos tensores sigue una fórmula estricta. Es la longitud de la secuencia al cubo, multiplicada por el número de attention heads, multiplicada por el tamaño en bytes del data type. AlphaFold usa precisión BFloat16, que ocupa dos bytes por valor. Vamos a repasar las matemáticas para el developer que crasheó su GPU. Cuando le pasas una secuencia de 500 residuos al modelo, la longitud de la secuencia es 500. El cubo de 500 es 125 millones. Si tienes cuatro attention heads, multiplicas 125 millones por cuatro, y luego por dos bytes para la precisión. Una sola attention layer crea aproximadamente un gigabyte de activaciones intermedias. Tu GPU de 16 gigabytes maneja esto y le sobra espacio. Ahora cambias el input a una secuencia de 1500 residuos. Solo has triplicado la longitud del input. Pero como el escalado es cúbico, tienes que elevar 1500 al cubo, lo que da más de 3300 millones. Multiplica eso por cuatro heads y dos bytes, y esa misma attention layer ahora demanda casi 27 gigabytes de memoria solo para almacenar sus activaciones. Como la red pasa estos datos a través de 48 bloques Evoformer consecutivos, el requerimiento total de memoria supera instantáneamente los 80 gigabytes. Los tensores crecen tan rápido que el hardware simplemente aborta el proceso. Por eso AlphaFold requiere una optimización intensiva para secuencias largas. La cantidad bruta de parámetros de una red neuronal no te dice casi nada sobre sus requisitos de hardware cuando la geometría interna obliga a que los datos intermedios crezcan en tres dimensiones simultáneamente. Si quieres apoyar el programa, puedes buscar DevStoriesEU en Patreon. Eso es todo por este episodio. ¡Gracias por escuchar, y sigue programando!

Hola, soy Alex de DEV STORIES DOT EU. AlphaFold: Predicción de la estructura de proteínas, episodio 16 de 21. Si un tensor intermedio es demasiado masivo para una sola GPU, el instinto habitual es dividir los model parameters entre varias tarjetas. Pero cuando tu red neuronal solo tiene 93 millones de parámetros y tus activation tensors consumen 20 gigabytes, dividir el modelo no resuelve nada. Necesitas dividir la geometría de los propios datos. Eso es exactamente lo que resuelve el Dynamic Axial Parallelism. Para entender por qué existe este enfoque, tenemos que analizar los bottlenecks identificados en el paper de FastFold. El motor principal de AlphaFold es el bloque Evoformer. Procesa multiple sequence alignments y pair representations, que esencialmente funcionan como enormes grids bidimensionales de datos. El Tensor Parallelism estándar intenta gestionar cargas de trabajo pesadas dividiendo los linear layer weights entre diferentes GPUs. Para AlphaFold, esto genera graves ineficiencias. El Tensor Parallelism requiere una sincronización frecuente y pesada, activando hasta doce pasos de comunicación por bloque. Además, solo se aplica a los módulos de attention y feed-forward. Peor aún, su escalado está limitado por el número de attention heads. En el pair stack de AlphaFold, eso te limita a un máximo de solo cuatro GPUs. El Dynamic Axial Parallelism, o DAP, abandona por completo el enfoque de weight-splitting. En su lugar, DAP mantiene los model parameters completos e intactos en cada dispositivo. El modelo en sí nunca se distribuye. Las intermediate activations sí. El Evoformer procesa datos a lo largo de dos dimensiones de secuencia, pero las operaciones matemáticas solo ocurren a lo largo de una dimensión a la vez. Este comportamiento permite que DAP divida limpiamente los datos a lo largo de la dimensión inactiva. Imagínate esto en un setup multi-GPU. Un enorme grid de datos de secuencia entra en la layer. DAP divide este input horizontalmente. La GPU cero se queda con el primer chunk de filas, la GPU uno con el siguiente, y así sucesivamente. Cada GPU calcula entonces la attention para su slice específico de datos. Como cada GPU tiene una copia completa de los model weights, y como la computación está aislada en el eje horizontal, las GPUs no necesitan hablar entre sí. Computan sus chunks de forma independiente. Aquí está la clave. Una vez que termina ese cálculo horizontal, el modelo necesita procesar los datos a lo largo de la dimensión de secuencia vertical. Para que esto ocurra, las GPUs ejecutan un paso de comunicación all-to-all. Transponen la geometría de los datos a través de la red. La GPU cero hace un scatter de sus fragmentos de columna a los demás dispositivos y hace un gather de las piezas que necesita para la siguiente fase. La orientación del split se invierte. Ahora los datos están divididos verticalmente por todo el cluster. Las GPUs ejecutan inmediatamente la siguiente layer de cálculos de attention, de nuevo con cero cross-talk durante el cálculo matemático en sí. Esta estrategia de transposición reduce el volumen de comunicación en un orden de magnitud completo en comparación con el Tensor Parallelism estándar. También permite el paralelismo en todos y cada uno de los módulos computacionales del Evoformer. Como los enormes activation tensors se distribuyen uniformemente por el cluster, el consumo total de memoria cae drásticamente, evitando que los dispositivos individuales crasheen bajo el peso de secuencias largas. Cuando tu bottleneck de hardware se debe al enorme tamaño físico de las intermediate representations en lugar de a la profundidad de la red neuronal, no fragmentas la arquitectura. Distribuyes los ejes de los datos. Eso es todo por este episodio. ¡Gracias por escuchar, y sigue construyendo!

Hola, soy Alex de DEV STORIES DOT EU. AlphaFold: Predicción de la Estructura de Proteínas, episodio 17 de 21. ¿Qué pasaría si tu compilador fuera lo suficientemente inteligente como para hacer un slice automático de tus operaciones matriciales para que encajen perfectamente en el presupuesto de memoria de tu hardware? Imagina a un ingeniero dedicando días a hacer profiling y slicing del código manualmente para evitar errores de Out of Memory. Cada vez que cambia la longitud de la secuencia, los slices fijos fallan. Compáralo con un sistema que estima dinámicamente el memory footprint y genera código particionado sobre la marcha. AutoChunk es el algoritmo que hace esto posible. En el paper de FastFold, los investigadores abordaron los enormes cuellos de botella de memoria que supone ejecutar secuencias largas en modelos de predicción de proteínas. El enfoque estándar para evitar quedarse sin memoria es el chunking. Particionas un tensor a lo largo de dimensiones que no interactúan durante un cálculo, procesas esos bloques más pequeños secuencialmente y los vuelves a unir. Normalmente, este es un proceso manual y laborioso. Haces profiling del código, adivinas los mejores tamaños de slice y hardcodeas los límites. El paper de FastFold señala que los esquemas de chunking fijos son ineficientes porque no pueden adaptarse a dimensiones de secuencia variables ni a picos de memoria operacionales específicos. Aquí está la clave. Los investigadores de FastFold observaron que el 95 por ciento de las operaciones del modelo utilizan menos del 20 por ciento de la peak memory. El chunking a nivel de módulo es totalmente innecesario. Solo necesitas aplicar chunking a las operaciones específicas que provocan los picos de memoria. AutoChunk automatiza esto analizando tu código como un grafo computacional. Toma ese grafo y el presupuesto de memoria específico de tu hardware como inputs. En términos sencillos, el algoritmo ejecuta un loop continuo. Mientras se siga necesitando una estrategia de memoria, estima el consumo de memoria del grafo para encontrar el único nodo con el mayor uso. Un nodo aquí es una operación básica, como una suma o una proyección lineal. Una vez que marca ese nodo de peak memory, AutoChunk determina el rango de chunk máximo posible extendiéndose hacia afuera desde él. Calcula esto comprobando todos los nodos activos que actualmente mantienen datos en memoria. A continuación, identifica cada estrategia de chunk posible dentro de ese rango, rastreando las dimensiones del tensor hacia arriba a través del grafo. A una dimensión solo se le puede aplicar chunking si es una dimensión libre, lo que significa que no ocurre ninguna computación a través de ella durante ese rango específico de operaciones. Como rastrear cada output hacia arriba es computacionalmente costoso, AutoChunk utiliza una búsqueda en dos etapas. La etapa uno comprueba si los nodos de inicio y fin de un rango cumplen las reglas de chunking. Si lo hacen, la etapa dos realiza una verificación profunda para todos los nodos intermedios. Después de mapear las posibilidades, AutoChunk selecciona la estrategia que mantiene la memoria estrictamente por debajo del presupuesto mientras minimiza la penalización en la velocidad de ejecución. Finalmente, el algoritmo sale del loop y pasa las estrategias elegidas a un generador de código, insertando la lógica de partición óptima directamente en el grafo. Ya no hardcodeas los slices de matrices esperando que aguanten en producción. El sistema analiza el estado de la memoria activa y escribe la lógica de partición por ti. La conclusión más útil es que el chunking nunca debería ser una configuración estática a nivel de módulo; al aislar y particionar solo las operaciones atípicas específicas que causan picos de peak memory, puedes procesar secuencias muchísimo más largas sin destrozar la velocidad de ejecución. Eso es todo por este episodio. Gracias por escuchar, ¡y sigue programando!

Hola, soy Alex de DEV STORIES DOT EU. AlphaFold: Predicción de la Estructura de Proteínas, episodio 18 de 21. Montas un clúster masivo multimillonario con mil GPUs para entrenar tu modelo, pero su utilización se estanca. Todo tu anillo distribuido se paraliza porque a una sola máquina le ha tocado una secuencia evolutiva muy compleja y necesita 100 segundos para generar un alineamiento. Superar el desequilibrio de comunicación es cómo solucionas exactamente este cuello de botella. El problema subyacente aquí se conoce como el problema del straggler. En el entrenamiento distribuido, cada GPU de tu clúster procesa un batch de datos local. Al final de un step de entrenamiento, todas las GPUs deben alcanzar un punto de sincronización para compartir sus gradientes. Tu clúster solo avanza tan rápido como su máquina más lenta. Como se detalla en el paper de ScaleFold de Zhu et al, la preparación de los batches de entrenamiento para el plegamiento de proteínas es muy variable. Algunas secuencias de aminoácidos son cortas y sencillas. Otras requieren alineamientos múltiples de secuencias masivos, tardando hasta tres órdenes de magnitud más en prepararse. Un batch rápido tarda una fracción de segundo. Un batch lento tarda 100 segundos. Si usas el dataloader por defecto de PyTorch, este genera los batches en un orden estricto y determinista. Si uno de los workers de tu dataloader se queda atascado preparando una secuencia masiva, el proceso de entrenamiento espera a que termine ese batch específico. Incluso si otros workers ya han terminado de preparar los batches siguientes, la pipeline se bloquea. Tu step de entrenamiento termina, tu GPU local se queda en idle, y como no puede alcanzar el punto de sincronización, las otras 999 GPUs de tu clúster se quedan completamente en idle esperándola. Los autores de ScaleFold resolvieron esto construyendo una pipeline de datos non-blocking. En lugar de forzar una secuencia rígida, la pipeline devuelve un batch en el momento en que cualquier batch en proceso está listo. Aquí está la clave. El sistema desacopla el orden de preparación de datos del orden de consumo de datos usando una priority queue. Primero, asignas múltiples workers del dataloader para preparar batches de forma asíncrona. Cuando un worker recibe un batch para procesar, el sistema etiqueta ese batch con su índice de secuencia original. Este índice se convierte en su puntuación de prioridad. Sigamos la lógica. El worker uno recibe el batch A, una secuencia rápida. El worker dos recibe el batch B, la secuencia de 100 segundos. El worker tres recibe el batch C, otra secuencia rápida. El worker uno termina el batch A inmediatamente y lo añade a la priority queue. El proceso de entrenamiento lo consume y ejecuta un step. El worker dos sigue procesando el enorme batch B. En el sistema por defecto, la GPU se detendría y esperaría. Pero en esta pipeline non-blocking, el worker tres termina el batch C y lo añade a la priority queue. Como el batch B aún no está listo, la queue simplemente le entrega el batch C al proceso de entrenamiento. Las GPUs continúan entrenando sin pausa. Eventualmente, el worker dos termina el batch B y lo añade a la queue. Como el batch B tiene un índice original anterior, la priority queue lo coloca inmediatamente al principio de la cola. El proceso de entrenamiento lo consume en el siguiente step. Este mecanismo de prioridad garantiza un ordenamiento de muestras best-effort. La secuencia global exacta de los datos varía ligeramente entre las distintas ejecuciones de entrenamiento, pero el paper confirma que esto no afecta negativamente a la convergencia del entrenamiento. Eliminas el tiempo en idle causado por los picos de uso de CPU en segundo plano y las muestras de datos complejas. El batch de datos más lento ya no dicta la velocidad de ejecución de tu máquina más rápida. Eso es todo por este episodio. ¡Gracias por escuchar, y seguid construyendo!

Hola, soy Alex de DEV STORIES DOT EU. AlphaFold: Predicción de la Estructura de Proteínas, episodio 19 de 21. A veces, la GPU no es realmente lenta haciendo cálculos matemáticos. Simplemente se pasa todo el tiempo esperando a que la CPU le dé la siguiente instrucción, dejando tu profiler lleno de enormes espacios en blanco. La solución a este problema es el Kernel Fusion y la optimización de la GPU. Según el paper de ScaleFold, entrenar el modelo AlphaFold requiere lanzar más de 150.000 operaciones individuales por step. La mayoría de estas son kernels memory-bound, como pequeñas LayerNorms u operaciones element-wise fragmentadas. Cada vez que la CPU le dice a la GPU que ejecute una operación de PyTorch, hay un launch overhead. Cuando encadenas 150.000 operaciones pequeñas, ese overhead eclipsa por completo a los cálculos matemáticos. Fíjate en la Multi-Head Attention de AlphaFold, que se lleva más o menos el treinta y cuatro por ciento del tiempo total del training step. No es una attention estándar. AlphaFold añade un término de pair bias específico a la matriz de logits justo antes de la operación softmax. En el PyTorch por defecto, esto crea una chain de eventos separados. Primero, lanzas un kernel para la batched matrix multiplication. La GPU lee los datos de la memoria global, hace los cálculos y vuelve a escribir el resultado. Luego, la CPU lanza un segundo kernel para añadir el pair bias. La GPU vuelve a leer la matriz de la memoria, añade el bias y la vuelve a escribir. Finalmente, se lanza un tercer kernel para la softmax. Este round-trip constante a la memoria global ahoga a la GPU. Los autores del paper de ScaleFold solucionan esto escribiendo custom kernels usando el compilador Triton de OpenAI. En lugar de steps separados, fusionan toda la secuencia en un único kernel. Aquí está la clave. Al fusionar las operaciones, la GPU carga los datos de entrada en su rápida SRAM on-chip una sola vez. Hace la multiplicación de matrices, añade el pair bias, aplica la softmax y hace la multiplicación final directamente dentro de la SRAM. Solo escribe en la memoria global cuando el bloque completo de Multi-Head Attention ha terminado. Las librerías optimizadas estándar como FlashAttention no funcionan aquí debido a esa inyección única de pair bias, lo que hace que un custom kernel de Triton sea estrictamente necesario para evitar el cuello de botella del memory bandwidth. Este enfoque se extiende a otras partes fragmentadas del modelo. LayerNorm consume el catorce por ciento del tiempo del step porque AlphaFold usa dimensiones pequeñas, típicamente 128 o 256. Al usar Dynamic Axial Parallelism, o DAP, estos tamaños de problema se reducen aún más, dejando el hardware infrautilizado. ScaleFold introduce un kernel de LayerNorm fusionado donde un único thread block de CUDA procesa múltiples filas de entrada a la vez. Calcula las estadísticas de normalización en un solo pass en lugar de usar métodos iterativos costosos, y usa una reducción de dos steps en el backward pass para evitar operaciones atómicas. Incluso el optimizer se fusiona. Los autores de ScaleFold combinaron el optimizer Adam y el Stochastic Weight Averaging en un solo kernel. Los valores intermedios entre los steps del optimizer se quedan en los registers de la GPU, evitando por completo las lecturas de memoria. Para el resto del modelo, confían en las herramientas del compilador de PyTorch para fusionar automáticamente las operaciones fragmentadas restantes, especialmente en componentes en serie como el Structure Module. Cuando estás lidiando con miles de operaciones pequeñas y memory-bound, tu cuello de botella no son los teraflops, es el memory bandwidth y el launch overhead de la CPU. Fusionar esas operaciones en bloques de ejecución únicos y continuos es la única forma de saturar realmente el hardware. ¡Gracias por escuchar, happy coding a todos!

Hola, soy Alex de DEV STORIES DOT EU. AlphaFold: Predicción de la Estructura de Proteínas, episodio 20 de 21. Escalar un modelo de IA de 128 GPUs a 2000 GPUs no es solo cuestión de comprar más hardware; requiere rediseñar por completo cómo respira el sistema. Cuando añades tanto compute, descubres enormes cuellos de botella en cómo tus máquinas host hablan con tus aceleradores. Resolver esos cuellos de botella requiere construir un pipeline de alto throughput, que es exactamente cómo los investigadores han bajado hace poco el pretraining de AlphaFold de siete días a diez horas. El diseño de esta arquitectura viene del paper de ScaleFold. Los autores identificaron una realidad de scaling brutal. A medida que distribuyes un modelo entre miles de GPUs, la carga de trabajo matemática por cada GPU individual se reduce. Las GPUs terminan sus cálculos tan rápido que la CPU no puede emitir nuevas instrucciones de kernel lo suficientemente rápido como para mantenerlas ocupadas. El overhead de la CPU se convierte en el cuello de botella principal. Para solucionar esto, eliminas la CPU del loop de ejecución usando CUDA Graphs. Un CUDA Graph captura una secuencia de operaciones de la GPU y sus asignaciones de memoria en un único graph estático. Una vez capturado, la GPU ejecuta todo el graph directamente sin esperar a que la CPU haga el dispatch de cada kernel individual. Aquí está la clave. No puedes simplemente aplicar CUDA Graphs estándar a AlphaFold. La arquitectura de AlphaFold usa un mecanismo de recycling, retroalimentando las predicciones en el modelo de forma dinámica. Esto crea un computation graph dinámico. Si las operaciones cambian, un CUDA Graph estándar se rompe y tiene que volver a capturarse, lo que arruina la ganancia de rendimiento. El paper de ScaleFold soluciona esto diseñando una caché de CUDA Graphs. En lugar de un graph rígido, el sistema captura y almacena múltiples graphs que representan los diferentes escenarios de recycling. Cuando la ejecución dinámica cambia, el sistema simplemente saca el graph precompilado correcto de la caché. Se hace un bypass completo de la CPU. Ahora, la segunda pieza de esta arquitectura de alto throughput. Una vez que el tiempo de tu step de training está muy optimizado, aparece un nuevo cuello de botella. En un pipeline estándar, los nodos de training se pausan periódicamente para ejecutar métricas de validación. Según el paper de ScaleFold, a medida que los tiempos de step se reducen, esta fase de evaluación puede consumir hasta el 43 por ciento del tiempo total del pipeline. Tu enorme y caro clúster de training se queda inactivo durante casi la mitad del tiempo solo comprobando su propio trabajo. La solución es la Evaluación Asíncrona. Desacoplas por completo la validación del loop de training. Los nodos de training nunca se pausan. Calculan gradientes constantemente, actualizan pesos y hacen stream de los checkpoints del modelo a un pool separado y dedicado de nodos de evaluación. En la implementación de ScaleFold, de unas 2000 GPUs, solo 32 estaban dedicadas a evaluación. El resto no hacía más que entrenar. Sin embargo, mover la evaluación a nodos separados introduce una race condition. Los nodos de evaluación deben terminar de validar un checkpoint antes de que los nodos de training produzcan el siguiente. Si la evaluación se queda atrás, tu pipeline se atasca. Para garantizar que los nodos de evaluación sigan el ritmo, el sistema hace un bypass completo del almacenamiento en disco. Todo el dataset de evaluación se guarda en caché directamente en la DRAM de la CPU de los nodos de validación. Al eliminar el overhead de dispatch de la CPU con CUDA Graphs en caché y hacer el offload de la validación a nodos asíncronos cacheados en memoria, el pipeline nunca deja de moverse. El hardware por fin se satura. Cuando diseñas arquitecturas a gran escala, tu trabajo principal ya no es optimizar las matemáticas; tu trabajo principal es evitar que las GPUs se queden esperando. Eso es todo por hoy. Gracias por escuchar, ve a construir algo genial.

Hola, soy Alex de DEV STORIES DOT EU. AlphaFold: Predicción de la Estructura de Proteínas, episodio 21 de 21. Durante años, la industria asumió que predecir la estructura de una proteína requería diseños de redes neuronales personalizados e increíblemente especializados. Necesitabas alineamientos de secuencias múltiples, representaciones explícitas de pares y actualizaciones triangulares computacionalmente pesadas solo para obtener un resultado viable. Pero, ¿y si un transformer estándar y genérico pudiera hacer exactamente lo mismo? La respuesta es un concepto llamado flow-matching con SimpleFold. El paper de SimpleFold de Apple introduce un cambio radical respecto a las arquitecturas rígidas que hemos visto en los modelos de plegamiento tradicionales. Elimina por completo las heurísticas específicas del dominio. Los modelos tradicionales hacen hard-code de la intuición biológica en la red. Utilizan alineamientos de secuencias múltiples para encontrar pistas evolutivas y actualizaciones triangulares para imponer reglas geométricas. Esto requiere un compute masivo y una ingeniería altamente especializada. SimpleFold abandona estas mecánicas, optando en su lugar por un modelo generativo de flow-matching construido exclusivamente sobre bloques transformer de propósito general. SimpleFold trata el plegamiento como una tarea generativa condicional. Piensa en los modelos text-to-image, donde un prompt de texto guía la generación de una imagen. Aquí, la secuencia de aminoácidos es el prompt, y el output es la estructura de coordenadas tridimensionales de todos los átomos. Lo consigue usando flow-matching. El flow-matching genera datos definiendo una ruta continua desde una distribución de ruido simple hasta una distribución de datos compleja. Durante el entrenamiento, el modelo aprende un campo de velocidad dependiente del tiempo. Integra una ecuación diferencial ordinaria a lo largo del tiempo, moviendo gradualmente el ruido aleatorio hacia las coordenadas atómicas reales. El proceso empieza cuando un modelo de lenguaje de proteínas preentrenado y frozen, específicamente ESM2, convierte la secuencia de aminoácidos de entrada en un sequence embedding. Al mismo tiempo, un encoder de átomos coge las coordenadas atómicas con ruido y las procesa en atom tokens. Aquí está la clave. En lugar de mantener mapas de interacción por pares complejos y muy pesados en memoria, SimpleFold usa una operación de agrupación. Simplemente hace la media de los atom tokens que pertenecen al mismo residuo en un único token de residuo. Estos tokens de residuo se concatenan con los sequence embeddings y se pasan al residue trunk. Este trunk contiene la mayor parte de los parámetros del modelo. Está compuesto íntegramente por bloques transformer estándar con capas adaptativas condicionadas al timestep del flujo. No hay módulos equivariantes geométricos ni matemáticas triangulares. Solo operaciones estándar de attention y escalado. Finalmente, una operación de desagrupación hace broadcast de los tokens de residuo actualizados de vuelta a sus átomos individuales. Un decoder de átomos predice entonces el campo de velocidad para actualizar las posiciones finales de los átomos. Durante el entrenamiento, el sistema no hace sampling del tiempo de forma uniforme. Hace un oversampling fuerte de los timesteps más cercanos al manifold de datos limpios. Como las estructuras de las proteínas tienen una jerarquía estricta coarse-to-fine, este enfoque en la etapa final obliga al modelo a aprender estructuras muy refinadas, incluyendo cadenas laterales delicadas. Además, como el modelo usa un objetivo generativo en lugar de un objetivo de regresión determinista, captura la incertidumbre de forma natural. Si pasas la misma secuencia por SimpleFold varias veces, puede generar un ensemble de diferentes conformaciones válidas, reflejando con precisión cómo se mueven y existen realmente las proteínas en la naturaleza. SimpleFold demuestra que, si mapeas el problema correctamente, un transformer de propósito general puede aprender la física subyacente del plegamiento de proteínas directamente de los datos. Te animo a leer el paper, explorar la documentación oficial y probar a ejecutar el código en tu propio hardware. También puedes visitar devstories.eu para sugerir temas para nuestra próxima serie. Eso es todo por este episodio. ¡Gracias por escuchar, y sigue construyendo!