# Predicción de proteínas AlphaFold2

> **Predice estructuras de proteínas con la IA ganadora del Premio Nobel — potenciada 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 ganó el Premio Nobel de Química 2024. Ejecutar AlphaFold2 requiere una cantidad significativa de memoria y cómputo en GPU — Clore.ai ofrece acceso asequible a las GPUs de alto rendimiento necesarias.

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

***

## Prerrequisitos

* Una cuenta en 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 \~400 aa) |
| --------------- | ----------------------------------------------- |
| Solo CPU        | 6–24+ horas                                     |
| A100 80GB única | 15–45 minutos                                   |
| RTX 4090 única  | 20–60 minutos                                   |
| RTX 3090 única  | 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 proteómicos a gran escala.

***

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

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

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

Para predicción de multimers, 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 bases de datos completas)
4. Selecciona un servidor y haz clic en **Alquilar**

***

## Paso 2 — Configura tu despliegue

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

**Imagen Docker:**

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

{% hint style="warning" %}
AlphaFold2 requiere una configuración Docker personalizada. Lo instalaremos desde la fuente dentro del contenedor. Alternativamente, usa la imagen comunitaria `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 recomendado para proteínas grandes)
* Disco: 100GB mínimo (2.5TB para bases de datos completas)

***

## Paso 3 — Conéctate vía SSH

Una vez que tu instancia esté en funcionamiento:

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

Verifica que la GPU sea visible:

```bash
nvidia-smi
```

La salida esperada debería mostrar tu GPU (p. ej., A100 80GB SXM4).

***

## Paso 4 — Instala AlphaFold2

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

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

# Instalar 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"

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

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

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

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

# Instalar hhsuite
conda install -c bioconda hhsuite

# Clonar e instalar 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

# Instalar el propio AlphaFold
python3 setup.py install
```

***

## Paso 5 — Descargar bases de datos genéticas

{% hint style="warning" %}
**La descarga de las bases de datos completas requiere \~2.5TB de espacio en disco y puede tardar 6–24 horas.** Para pruebas iniciales, usa las bases de datos reducidas (ver la sección Bases de datos reducidas abajo).
{% endhint %}

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

```bash
cd /opt/alphafold

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

Esto descarga:

* **BFD** (\~270GB) — Big Fantastic Database
* **UniRef90** (\~58GB) — UniProt Reference Clusters
* **MGnify** (\~64GB) — Secuencias de metagenómica
* **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 espacio en disco limitado:

```bash
# Descargar 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 — Descargar los pesos del modelo de AlphaFold

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

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

# Extraer
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 la secuencia de proteína objetivo:

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

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

* La línea de encabezado comienza con `>`
* La secuencia debe contener sólo letras de aminoácidos estándar (ACDEFGHIKLMNPQRSTVWY)
* Elimina cualquier hueco o carácter no estándar
* Para predicción de multimers, 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 — Comprender los archivos de salida

AlphaFold2 produce varios archivos de salida por predicción:

```
/tmp/alphafold_output/my_protein/
├── ranked_0.pdb          # Mejor estructura 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 múltiples de secuencias
│   ├── 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
* **pLDDT score** (0–100): confianza por residuo. >90 = muy alta, 70–90 = buena, 50–70 = baja, <50 = desordenada
* **PAE (Predicted Aligned Error)** los gráficos muestran la confianza inter-dominio
  {% endhint %}

***

## Paso 10 — Visualiza los resultados

### Descarga 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 completo de salida:
rsync -avz -e "ssh -p <ssh-port>" \
    root@<server-ip>:/tmp/alphafold_output/ \
    ./alphafold_results/
```

### Visualizar en PyMOL (localmente)

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

### Análisis rápido de pLDDT

```python
import numpy as np

# Parsear B-factor (pLDDT) del 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"Mean pLDDT: {np.mean(plddt_scores):.1f}")
print(f"Residues >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]

# Ejecutar 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 10–40x más rápido** que la canalización original de AlphaFold2 debido al servidor MSA de MMseqs2. Ideal para flujos de trabajo de investigación iterativos.
{% endhint %}

***

## Solución de problemas

### CUDA Fuera de memoria

```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 ejecutar con reciclado reducido
--num_multimer_predictions_per_model 1
```

### Errores de HHblits / Jackhmmer

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

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

### Fallas en la descarga de bases de datos

```bash
# Reanuda 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 pueda ver la GPU
python3 -c "import jax; print(jax.devices())"

# Reinstalar JAX con la versión de CUDA correcta
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 (aceleración de 10–40x)
2. **Configurar `--num-recycle 1`** para cribado rápido, usa 3 para predicciones finales
3. **Usa `--db_preset=reduced_dbs`** para trabajo exploratorio
4. **Procesa varias secuencias por lotes** en un solo archivo FASTA para ejecuciones de canalización más eficientes
5. **Habilita la relajación por GPU** (`--use_gpu_relax=True`) — mucho más rápida que la relajación por CPU
   {% endhint %}

***

## Estimación de costos en Clore.ai

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

*Los costos son aproximados y dependen del precio actual del mercado.*

***

## Recursos adicionales

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

***

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

***

## Recomendaciones de GPU en Clore.ai

| Caso de uso                    | GPU recomendada | Coste estimado en Clore.ai |
| ------------------------------ | --------------- | -------------------------- |
| Desarrollo/Pruebas             | RTX 3090 (24GB) | \~$0.12/gpu/hr             |
| Proteínas estándar             | RTX 4090 (24GB) | \~$0.70/gpu/hr             |
| Moléculas grandes / Multímeros | A100 80GB       | \~$1.20/gpu/hr             |

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


---

# Agent Instructions: 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:

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

The question should be specific, self-contained, and written in natural language.
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.