> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-es/ciencia-e-investigacion/alphafold2.md).

# Predicción de proteínas AlphaFold2

> **Predice estructuras de proteínas con IA galardonada con el Premio Nobel, impulsada por aceleración GPU en Clore.ai**

AlphaFold2, desarrollado por DeepMind, revolucionó la biología estructural al predecir estructuras 3D de proteínas con precisión atómica. Se ha aplicado a más de 200 millones de secuencias de proteínas y obtuvo el Premio Nobel de Química 2024. Ejecutar AlphaFold2 requiere una gran memoria GPU y capacidad de cómputo; Clore.ai proporciona acceso asequible a las GPU de gama alta necesarias.

**GitHub:** [google-deepmind/alphafold](https://github.com/google-deepmind/alphafold) — 13K+ ⭐

***

## Requisitos previos

* Una cuenta de Clore.ai con saldo suficiente
* Familiaridad básica con la línea de comandos de Linux
* Tu(s) secuencia(s) de proteína objetivo en formato FASTA
* \~2.5TB de espacio en disco para las bases de datos genéticas completas (o usa bases de datos reducidas para pruebas)

***

## ¿Por qué ejecutar AlphaFold2 en Clore.ai?

AlphaFold2 se beneficia enormemente de la aceleración por GPU:

| Hardware           | Tiempo de predicción (proteína típica de \~400 aa) |
| ------------------ | -------------------------------------------------- |
| Solo CPU           | 6–24+ horas                                        |
| Una sola A100 80GB | 15–45 minutos                                      |
| Una sola RTX 4090  | 20–60 minutos                                      |
| Una sola RTX 3090  | 30–90 minutos                                      |

Clore.ai ofrece nodos A100, RTX 4090 y RTX 3090 a una fracción del costo de los proveedores en la nube, haciendo accesibles los estudios de proteómica a gran escala.

***

## Paso 1 — Elige tu alquiler de GPU en Clore.ai

{% hint style="info" %}
**GPU recomendadas para AlphaFold2:**

* **A100 80GB** — Ideal para proteínas grandes (>700 aa) y predicción de multímeros
* **RTX 4090 24GB** — Excelente para monómeros estándar (<500 aa)
* **RTX 3090 24GB** — Rentable para proteínas más pequeñas

Para la predicción de multímeros, se recomienda encarecidamente 40GB+ de VRAM.
{% endhint %}

1. Inicia sesión en [clore.ai](https://clore.ai) y ve a **Marketplace**
2. Filtra por modelo de GPU (se recomiendan A100 o RTX 4090)
3. Asegúrate de que el servidor tenga **al menos 100GB de espacio en disco** (o 2.5TB para las bases de datos completas)
4. Selecciona un servidor y haz clic en **Alquilar**

***

## Paso 2 — Configura tu implementación

Al configurar tu pedido de alquiler, usa la siguiente configuración:

**Imagen de Docker:**

```
nvidia/cuda:11.8.0-cudnn8-runtime-ubuntu20.04
```

{% hint style="warning" %}
AlphaFold2 requiere una configuración personalizada de Docker. Lo instalaremos desde el código fuente dentro del contenedor. Como alternativa, usa la imagen de la comunidad `catgumag/alphafold` o `merteroglu/alphafold2` que preempaqueta el entorno.
{% endhint %}

**Puertos a exponer:**

```
22
```

**Variables de entorno:**

```
NVIDIA_VISIBLE_DEVICES=all
NVIDIA_DRIVER_CAPABILITIES=compute,utility
```

**Recursos mínimos:**

* CPU: 8 núcleos
* RAM: 32GB (64GB recomendados para proteínas grandes)
* Disco: mínimo 100GB (2.5TB para las bases de datos completas)

***

## Paso 3 — Conéctate por SSH

Una vez que tu instancia esté en ejecución:

```bash
ssh root@<ip-del-servidor> -p <puerto-ssh>
```

Verifica que la GPU sea visible:

```bash
nvidia-smi
```

La salida esperada debe mostrar tu GPU (por ejemplo, A100 80GB SXM4).

***

## Paso 4 — Instala AlphaFold2

### Opción A: Usando el script instalador oficial

```bash
# Actualiza los paquetes del sistema
apt-get update && apt-get install -y \\
    wget \\
    git \\
    python3-pip \\
    python3-dev \\
    aria2 \\
    hmmer \\
    kalign \\
    hhsuite

# Instala Miniconda
wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh -O miniconda.sh
bash miniconda.sh -b -p /opt/conda
export PATH="/opt/conda/bin:$PATH"

# Clona AlphaFold2
git clone https://github.com/google-deepmind/alphafold.git /opt/alphafold
cd /opt/alphafold

# Crea el entorno conda
conda env create -f environment.yml
conda activate alphafold
```

### Opción B: Usando pip (configuración más rápida)

```bash
# Instala dependencias del sistema
apt-get update && apt-get install -y \\
    wget curl git aria2 hmmer kalign

# Instala hhsuite
conda install -c bioconda hhsuite

# Clona e instala AlphaFold2
git clone https://github.com/google-deepmind/alphafold.git /opt/alphafold
cd /opt/alphafold

pip install -r requirements.txt
pip install --upgrade "jax[cuda11_pip]" -f https://storage.googleapis.com/jax-releases/jax_cuda_releases.html

# Instala AlphaFold
python3 setup.py install
```

***

## Paso 5 — Descarga las bases de datos genéticas

{% hint style="warning" %}
**La descarga de la base de datos completa requiere \~2.5TB de espacio en disco y puede tardar de 6 a 24 horas.** Para las pruebas iniciales, usa las bases de datos reducidas (consulta la sección de BD reducida más abajo).
{% endhint %}

### Bases de datos completas (uso en producción)

```bash
cd /opt/alphafold

# Descarga todas las bases de datos usando el script proporcionado
bash scripts/download_all_data.sh /data/alphafold_databases
```

Esto descarga:

* **BFD** (\~270GB) — Gran Base de Datos Fantástica
* **UniRef90** (\~58GB) — Clústeres de referencia de UniProt
* **MGnify** (\~64GB) — Secuencias metagenómicas
* **PDB70** (\~56GB) — Estructuras representativas del Protein Data Bank
* **PDB seqres** (\~0.2GB)
* **UniClust30** (\~86GB)
* **Small BFD** (\~17GB) — Versión reducida

### Bases de datos reducidas (pruebas/desarrollo)

Para pruebas con disco limitado:

```bash
# Descarga solo small_bfd y las bases de datos necesarias
bash scripts/download_small_bfd.sh /data/alphafold_databases
bash scripts/download_pdb70.sh /data/alphafold_databases
bash scripts/download_uniclust30.sh /data/alphafold_databases
bash scripts/download_uniref90.sh /data/alphafold_databases
bash scripts/download_mgnify.sh /data/alphafold_databases
bash scripts/download_pdb_seqres.sh /data/alphafold_databases
bash scripts/download_uniprot.sh /data/alphafold_databases
```

***

## Paso 6 — Descarga los pesos del modelo de AlphaFold

```bash
# Crea un directorio para los parámetros del modelo
mkdir -p /data/alphafold_databases/params

# Descarga los parámetros del modelo (~3.5GB)
wget -q -P /data/alphafold_databases/params \\
    https://storage.googleapis.com/alphafold/alphafold_params_2022-12-06.tar

# Extrae
tar -xf /data/alphafold_databases/params/alphafold_params_2022-12-06.tar \\
    -C /data/alphafold_databases/params
```

***

## Paso 7 — Prepara tu secuencia de entrada

Crea un archivo FASTA con tu secuencia de proteína objetivo:

```bash
cat > /tmp/target_protein.fasta << 'EOF'
>my_protein
MKTLLLTLVVVTIVCLDLGAVGNGSGLKCRQTGSCVHFPKDLQALPKDDTASDLNRSLDAEAFKAFQRLAENFNATEYRDIQNFNNKIQHSLEELAKKLDEKLAKLKEKLKQLEN
EOF
```

{% hint style="info" %}
**Consejos sobre el formato FASTA:**

* La línea de encabezado comienza con `>`
* La secuencia solo debe contener letras estándar de aminoácidos (ACDEFGHIKLMNPQRSTVWY)
* Elimina cualquier espacio o carácter no estándar
* Para la predicción de multímeros, incluye todas las cadenas con encabezados separados
  {% endhint %}

***

## Paso 8 — Ejecuta AlphaFold2

### Predicción de monómero (cadena única)

```bash
cd /opt/alphafold

python3 run_alphafold.py \\
    --fasta_paths=/tmp/target_protein.fasta \\
    --max_template_date=2022-01-01 \\
    --model_preset=monomer \\
    --db_preset=full_dbs \\
    --data_dir=/data/alphafold_databases \\
    --output_dir=/tmp/alphafold_output \\
    --uniref90_database_path=/data/alphafold_databases/uniref90/uniref90.fasta \\
    --mgnify_database_path=/data/alphafold_databases/mgnify/mgy_clusters_2022_05.fa \\
    --template_mmcif_dir=/data/alphafold_databases/pdb_mmcif/mmcif_files \\
    --obsolete_pdbs_path=/data/alphafold_databases/pdb_mmcif/obsolete.dat \\
    --pdb70_database_path=/data/alphafold_databases/pdb70/pdb70 \\
    --bfd_database_path=/data/alphafold_databases/bfd/bfd_metaclust_clu_complete_id30_c90_final_seq.sorted_opt \\
    --uniclust30_database_path=/data/alphafold_databases/uniclust30/uniclust30_2018_08/uniclust30_2018_08 \\
    --use_gpu_relax=True
```

### Predicción de multímero (complejo proteico)

```bash
python3 run_alphafold.py \\
    --fasta_paths=/tmp/complex.fasta \\
    --max_template_date=2022-01-01 \\
    --model_preset=multimer \\
    --db_preset=full_dbs \\
    --data_dir=/data/alphafold_databases \\
    --output_dir=/tmp/alphafold_output \\
    --uniref90_database_path=/data/alphafold_databases/uniref90/uniref90.fasta \\
    --mgnify_database_path=/data/alphafold_databases/mgnify/mgy_clusters_2022_05.fa \\
    --template_mmcif_dir=/data/alphafold_databases/pdb_mmcif/mmcif_files \\
    --obsolete_pdbs_path=/data/alphafold_databases/pdb_mmcif/obsolete.dat \\
    --uniprot_database_path=/data/alphafold_databases/uniprot/uniprot.fasta \\
    --pdb_seqres_database_path=/data/alphafold_databases/pdb_seqres/pdb_seqres.txt \\
    --use_gpu_relax=True
```

***

## Paso 9 — Comprende los archivos de salida

AlphaFold2 produce varios archivos de salida por cada predicción:

```
/tmp/alphafold_output/my_protein/
├── ranked_0.pdb          # Estructura mejor predicha
├── ranked_1.pdb          # Segunda mejor predicción
├── ranked_2.pdb
├── ranked_3.pdb
├── ranked_4.pdb
├── result_model_1.pkl    # Datos completos de la predicción (pickle)
├── result_model_2.pkl
├── ...
├── msas/                 # Alineamientos de secuencias múltiples
│   ├── bfd_uniclust_hits.a3m
│   ├── mgnify_hits.sto
│   └── uniref90_hits.sto
└── timings.json          # Desglose del tiempo de ejecución
```

{% hint style="info" %}
**Interpretación de resultados:**

* **ranked\_0.pdb** es tu mejor estructura — ábrela en PyMOL, ChimeraX o UCSF Chimera
* **puntuación pLDDT** (0–100): confianza por residuo. >90 = muy alta, 70–90 = buena, 50–70 = baja, <50 = desordenada
* **PAE (Error de Alineamiento Predicho)** los gráficos muestran la confianza entre dominios
  {% endhint %}

***

## Paso 10 — Visualiza los resultados

### Descarga los archivos PDB a tu máquina local

```bash
# Desde tu máquina local:
scp -P <ssh-port> root@<server-ip>:/tmp/alphafold_output/my_protein/ranked_0.pdb ./

# O usa rsync para el directorio de salida completo:
rsync -avz -e "ssh -p <ssh-port>" \\
    root@<server-ip>:/tmp/alphafold_output/ \\
    ./alphafold_results/
```

### Visualiza en PyMOL (localmente)

```python
# En PyMOL:
load ranked_0.pdb
spectrum b, blue_white_red, minimum=0, maximum=100
# Colorea por puntuación pLDDT (almacenada en la columna B-factor)
```

### Análisis rápido de pLDDT

```python
import numpy as np

# Analiza el B-factor (pLDDT) desde PDB
plddt_scores = []
with open('ranked_0.pdb', 'r') as f:
    for line in f:
        if line.startswith('ATOM'):
            plddt = float(line[60:66].strip())
            plddt_scores.append(plddt)

print(f"Puntuación media pLDDT: {np.mean(plddt_scores):.1f}")
print(f"Residuos >90 pLDDT: {sum(s > 90 for s in plddt_scores)}/{len(plddt_scores)}")
```

***

## Usando ColabFold (alternativa más rápida)

ColabFold es una implementación más rápida de AlphaFold2 que usa MMseqs2 para la generación de MSA:

```bash
pip install colabfold[alphafold]

# Ejecuta la predicción (paso MSA mucho más rápido)
colabfold_batch /tmp/target_protein.fasta /tmp/colabfold_output \\
    --num-recycle 3 \\
    --use-gpu-relax
```

{% hint style="success" %}
**ColabFold suele ser de 10 a 40 veces más rápido** que la canalización original de AlphaFold2 gracias al servidor MSA de MMseqs2. Ideal para flujos de trabajo de investigación iterativos.
{% endhint %}

***

## Solución de problemas

### Memoria insuficiente en CUDA

```bash
# Reduce la complejidad del modelo o usa memoria unificada
export XLA_PYTHON_CLIENT_ALLOCATOR=platform
export XLA_PYTHON_CLIENT_MEM_FRACTION=0.85

# O ejecuta con reciclaje reducido
--num_multimer_predictions_per_model 1
```

### Errores de HHblits / Jackhmmer

```bash
# Asegúrate de que hhsuite esté instalado correctamente
which hhblits
hhblits --version

# Reinstala si es necesario
conda install -c bioconda hhsuite -y
```

### Fallos en la descarga de bases de datos

```bash
# Reanuda las descargas interrumpidas con aria2
aria2c -c -x 16 -s 16 <database-url> -d /data/alphafold_databases/
```

### Problemas de compatibilidad JAX/CUDA

```bash
# Comprueba que JAX puede ver la GPU
python3 -c "import jax; print(jax.devices())"

# Reinstala JAX con la versión correcta de CUDA
pip install --upgrade "jax[cuda11_pip]" \\
    -f https://storage.googleapis.com/jax-releases/jax_cuda_releases.html
```

***

## Consejos de rendimiento

{% hint style="success" %}
**Optimiza tus ejecuciones de AlphaFold2:**

1. **Usa ColabFold** para una generación de MSA más rápida (10–40x de aceleración)
2. **Establece `--num-recycle 1`** para un filtrado rápido, usa 3 para las predicciones finales
3. **Usa `--db_preset=reduced_dbs`** para trabajo exploratorio
4. **Procesa múltiples secuencias por lotes** en un solo archivo FASTA para ejecuciones eficientes de la canalización
5. **Habilita la relajación por GPU** (`--use_gpu_relax=True`) — mucho más rápido que la relajación por CPU
   {% endhint %}

***

## Estimación de costos en Clore.ai

| Escenario                             | GPU       | Tiempo est. | Costo est.   |
| ------------------------------------- | --------- | ----------- | ------------ |
| Proteína única (\~300 aa)             | RTX 3090  | 1–2h        | \~$0.30–0.60 |
| Proteína única (\~500 aa)             | RTX 4090  | 45–90min    | \~$0.40–0.80 |
| Complejo multímero                    | A100 80GB | 2–4h        | \~$1.50–3.00 |
| Filtrado del proteoma (100 proteínas) | A100 80GB | 8–12h       | \~$6–10      |

*Los costos son aproximados y dependen de los precios actuales del mercado.*

***

## Recursos adicionales

* [GitHub de AlphaFold2](https://github.com/google-deepmind/alphafold)
* [Base de datos AlphaFold](https://alphafold.ebi.ac.uk/) — Estructuras precomputadas para más de 200 millones de proteínas
* [GitHub de ColabFold](https://github.com/sokrypton/ColabFold)
* [Blog de AlphaFold de DeepMind](https://www.deepmind.com/research/highlighted-research/alphafold)
* [OpenFold](https://github.com/aqlaboratory/openfold) — Reimplementación en PyTorch entrenable
* [ESMFold](https://github.com/facebookresearch/esm) — Alternativa más rápida de Meta

***

*Esta guía cubre la implementación de AlphaFold2 en alquileres de GPU de Clore.ai. Para la versión más reciente, AlphaFold3, consulta la guía separada de AlphaFold3.*

***

## Recomendaciones de GPU para Clore.ai

| Caso de uso                    | GPU recomendada | Costo estimado en Clore.ai                |
| ------------------------------ | --------------- | ----------------------------------------- |
| Desarrollo/Pruebas             | RTX 3090 (24GB) | $0.07–0.21/gpu/hr                         |
| Proteínas estándar             | RTX 4090 (24GB) | $0.14–0.42/gpu/hr                         |
| Moléculas grandes / Multímeros | A100 80GB       | [bare metal](https://clore.ai/bare-metal) |

> 💡 Todos los ejemplos de esta guía pueden desplegarse en [Clore.ai](https://clore.ai/marketplace) servidores GPU. Explora las GPUs disponibles y alquila por hora: sin compromisos, acceso root completo.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-es/ciencia-e-investigacion/alphafold2.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.