### Display directory structure

Source: https://github.com/lucidrains/alphafold3-pytorch/blob/main/README.md

Example of the expected directory structure after downloading PDB files.

```bash
00/
01/
02/
..
zz/
```

--------------------------------

### Install Alphafold 3 Pytorch

Source: https://github.com/lucidrains/alphafold3-pytorch/blob/main/README.md

Use pip to install the package.

```bash
$ pip install alphafold3-pytorch
```

--------------------------------

### Configure Training with Trainer

Source: https://context7.com/lucidrains/alphafold3-pytorch/llms.txt

Set up the model and PDB datasets for training, utilizing the Trainer class for managing the training loop.

```python
from alphafold3_pytorch import Alphafold3, Trainer
from alphafold3_pytorch.inputs import PDBDataset

# Initialize model
model = Alphafold3(
    dim_atom_inputs=77,
    dim_template_feats=108,
    num_dist_bins=64,
    num_plddt_bins=50,
    num_pae_bins=64,
    num_pde_bins=64,
    sigma_data=16,
    diffusion_num_augmentations=48,
    loss_confidence_weight=1e-4,
    loss_distogram_weight=1e-2,
    loss_diffusion_weight=4.0,
)

# Create datasets from PDB files
train_dataset = PDBDataset(folder="./data/train_pdbs/")
valid_dataset = PDBDataset(folder="./data/valid_pdbs/")
```

--------------------------------

### Initialize and Run Trainer

Source: https://context7.com/lucidrains/alphafold3-pytorch/llms.txt

Configures the training loop with hyperparameters and executes the training process.

```python
# Initialize trainer
trainer = Trainer(
    model=model,
    dataset=train_dataset,
    valid_dataset=valid_dataset,
    num_train_steps=100000,
    batch_size=1,
    grad_accum_every=16,  # Effective batch size = 16
    valid_every=1000,
    lr=1.8e-3,
    ema_decay=0.999,
    clip_grad_norm=10.0,
    checkpoint_every=1000,
    checkpoint_folder="./checkpoints",
    accelerator="gpu",
    use_ema=True,
    fp16=True,  # Mixed precision training
)

# Run training
trainer()

# Save final model
trainer.save("./final_model.pt")
```

--------------------------------

### Download PDB mmCIF files

Source: https://github.com/lucidrains/alphafold3-pytorch/blob/main/README.md

Use AWS CLI or rsync to download assembly and asymmetric unit complexes into the local data directory.

```bash
# For `assembly1` complexes, use the PDB's `20240101` AWS snapshot:
aws s3 sync s3://pdbsnapshots/20240101/pub/pdb/data/assemblies/mmCIF/divided/ ./data/pdb_data/unfiltered_assembly_mmcifs
# Or as a fallback, use rsync:
rsync -rlpt -v -z --delete --port=33444 \
rsync.rcsb.org::ftp_data/assemblies/mmCIF/divided/ ./data/pdb_data/unfiltered_assembly_mmcifs/

# For asymmetric unit complexes, also use the PDB's `20240101` AWS snapshot:
aws s3 sync s3://pdbsnapshots/20240101/pub/pdb/data/structures/divided/mmCIF/ ./data/pdb_data/unfiltered_asym_mmcifs
# Or as a fallback, use rsync:
rsync -rlpt -v -z --delete --port=33444 \
rsync.rcsb.org::ftp_data/structures/divided/mmCIF/ ./data/pdb_data/unfiltered_asym_mmcifs/
```

--------------------------------

### Build Docker Container with Custom Versions

Source: https://github.com/lucidrains/alphafold3-pytorch/blob/main/README.md

Build the Docker container using build arguments to specify PyTorch and Git tags for custom software versions.

```bash
docker build --build-arg "PYTORCH_TAG=2.2.1-cuda12.1-cudnn8-devel" --build-arg "GIT_TAG=0.1.15" -t af3 .
```

--------------------------------

### Run Docker Container

Source: https://github.com/lucidrains/alphafold3-pytorch/blob/main/README.md

Run the AlphaFold3-PyTorch Docker container with GPU support and mount a local volume for training data.

```bash
docker run -v .:/data --gpus all -it af3
```

--------------------------------

### Download Chemical Component Dictionary

Source: https://github.com/lucidrains/alphafold3-pytorch/blob/main/README.md

Download the latest PDB Chemical Component Dictionary and structural models.

```bash
wget -P ./data/ccd_data/ https://files.wwpdb.org/pub/pdb/data/monomers/components.cif.gz
wget -P ./data/ccd_data/ https://files.wwpdb.org/pub/pdb/data/component-models/complete/chem_comp_model.cif.gz
```

--------------------------------

### Initialize and Train AlphaFold3 with Alphafold3Input

Source: https://github.com/lucidrains/alphafold3-pytorch/blob/main/README.md

Initializes the AlphaFold3 model with specific dimensions and module configurations, then performs a training step using `Alphafold3Input`.

```python
# training

alphafold3 = Alphafold3(
    dim_atom_inputs = 3,
    dim_atompair_inputs = 5,
    atoms_per_window = 27,
    dim_template_feats = 108,
    num_molecule_mods = 0,
    confidence_head_kwargs = dict(
        pairformer_depth = 1
    ),
    template_embedder_kwargs = dict(
        pairformer_stack_depth = 1
    ),
    msa_module_kwargs = dict(
        depth = 1
    ),
    pairformer_stack = dict(
        depth = 2
    ),
    diffusion_module_kwargs = dict(
        atom_encoder_depth = 1,
        token_transformer_depth = 1,
        atom_decoder_depth = 1,
    )
)

loss = alphafold3.forward_with_alphafold3_inputs([train_alphafold3_input])
loss.backward()
```

--------------------------------

### YAML Configuration Management

Source: https://context7.com/lucidrains/alphafold3-pytorch/llms.txt

Uses YAML files to define model and trainer parameters for reproducible experiments.

```python
from alphafold3_pytorch.configs import (
    Alphafold3Config,
    TrainerConfig,
    create_alphafold3_from_yaml,
    create_trainer_from_yaml,
)

# Create model from YAML config file
# config.yaml should contain model parameters under 'model' key
model = create_alphafold3_from_yaml(
    path="./config.yaml",
    dotpath="model"  # Path within YAML to model config
)

# Create trainer from YAML config file
trainer = create_trainer_from_yaml(
    path="./config.yaml",
    dotpath="trainer"
)

# Example YAML structure (config.yaml):
"""
model:
  dim_atom_inputs: 77
  dim_template_feats: 108
  dim_template_model: 64
  atoms_per_window: 27
  dim_atom: 128
  dim_single: 384
  dim_pairwise: 128
  dim_token: 768
  num_dist_bins: 64
  num_plddt_bins: 50
  num_pae_bins: 64
  num_pde_bins: 64
  sigma_data: 16
  diffusion_num_augmentations: 48
  loss_confidence_weight: 0.0001
  loss_distogram_weight: 0.01
  loss_diffusion_weight: 4.0

trainer:
  num_train_steps: 100000
  batch_size: 1
  grad_accum_every: 16
  valid_every: 1000
  lr: 0.0018
  ema_decay: 0.999
  clip_grad_norm: 10.0
  checkpoint_every: 1000
  checkpoint_folder: ./checkpoints
  accelerator: gpu
"""

# Or load config programmatically
config = Alphafold3Config.from_yaml_file("./config.yaml", dotpath="model")
model = config.create_instance()
```

--------------------------------

### PDBInput for mmCIF Files

Source: https://context7.com/lucidrains/alphafold3-pytorch/llms.txt

Loads structural data from mmCIF files and prepares datasets for training.

```python
from alphafold3_pytorch.inputs import PDBInput, pdb_input_to_molecule_input

# Load from mmCIF file
pdb_input = PDBInput(
    mmcif_filepath="./data/structures/7q5b.cif",
    msa_dir="./data/msa/7q5b/",  # Optional MSA alignments
    templates_dir="./data/templates/7q5b/",  # Optional templates
    cropping_config={
        "contiguous_weight": 0.2,
        "spatial_weight": 0.4,
        "spatial_interface_weight": 0.4,
        "n_res": 384,  # Crop to this many residues
    },
)

# Convert to molecule input for model
molecule_input = pdb_input_to_molecule_input(pdb_input)

# Or use PDBDataset for training
from alphafold3_pytorch.inputs import PDBDataset

dataset = PDBDataset(
    folder="./data/mmcif_files/",
    # Optionally specify cropping config
)

# Iterate over dataset
for sample in dataset:
    # sample is an AtomInput ready for the model
    pass
```

--------------------------------

### Initialize and Manage AlphaFold3 Models

Source: https://context7.com/lucidrains/alphafold3-pytorch/llms.txt

Load models from checkpoints and manage training states using the Trainer class.

```python
loaded_model = Alphafold3.init_and_load("./model_checkpoint.pt")

from alphafold3_pytorch import Trainer

trainer = Trainer(model=model, dataset=dataset, ...)

trainer.save("./trainer_checkpoint.pt")

trainer.load_from_checkpoint_folder()

trainer.load("./trainer_checkpoint.pt", reset_steps=False)
```

--------------------------------

### Contribute to AlphaFold3-PyTorch

Source: https://github.com/lucidrains/alphafold3-pytorch/blob/main/README.md

Run the contribution script at the project root. Add modules to `alphafold3_pytorch/alphafold3.py` and tests to `tests/test_af3.py` before submitting a pull request.

```bash
sh ./contribute.sh
```

--------------------------------

### Initialize and Run Inference with Alphafold3

Source: https://context7.com/lucidrains/alphafold3-pytorch/llms.txt

Configure the Alphafold3 model architecture and execute inference using high-level inputs to generate 3D atomic coordinates.

```python
import torch
from alphafold3_pytorch import Alphafold3, Alphafold3Input

# Initialize the model with default architecture
model = Alphafold3(
    dim_atom_inputs=77,
    dim_template_feats=108,
    dim_template_model=64,
    atoms_per_window=27,
    dim_atom=128,
    dim_atompair_inputs=5,
    dim_atompair=16,
    dim_input_embedder_token=384,
    dim_single=384,
    dim_pairwise=128,
    dim_token=768,
    num_dist_bins=64,
    num_plddt_bins=50,
    num_pae_bins=64,
    num_pde_bins=64,
    sigma_data=16,
    diffusion_num_augmentations=48,
    loss_confidence_weight=1e-4,
    loss_distogram_weight=1e-2,
    loss_diffusion_weight=4.0,
)

# Move to GPU
model = model.cuda()

# For inference with high-level inputs
alphafold3_input = Alphafold3Input(
    proteins=["MKTVRQERLKSIVRILERSKEPVSGAQLAEELSVSRQVIVQDIAYLRSLGYNIVATPRGYVLAGG"],
    ligands=["CC(=O)OC1=CC=CC=C1C(=O)O"],
)

# Run inference - returns predicted 3D coordinates
with torch.no_grad():
    predicted_coords = model.forward_with_alphafold3_inputs(
        alphafold3_input,
        num_sample_steps=20,  # Number of diffusion steps
        num_recycling_steps=3,  # Number of recycling iterations
    )  # Returns Float['b m 3'] tensor of atom positions
```

--------------------------------

### Saving and Loading Models

Source: https://context7.com/lucidrains/alphafold3-pytorch/llms.txt

Persists model state and weights to disk, allowing for checkpointing and resumption.

```python
import torch
from alphafold3_pytorch import Alphafold3

# Initialize and train model
model = Alphafold3(
    dim_atom_inputs=77,
    dim_template_feats=108,
    dim_single=384,
    dim_pairwise=128,
    # ... other parameters
)

# Save model with initialization arguments
model.save("./model_checkpoint.pt", overwrite=True)

# Load model weights into existing instance
model.load("./model_checkpoint.pt", strict=False)
```

--------------------------------

### Initialize Alphafold 3 Model

Source: https://github.com/lucidrains/alphafold3-pytorch/blob/main/README.md

Import the necessary modules and initialize the Alphafold3 model with specific input dimensions.

```python
import torch
from alphafold3_pytorch import Alphafold3
from alphafold3_pytorch.utils.model_utils import exclusive_cumsum

alphafold3 = Alphafold3(
    dim_atom_inputs = 77,
    dim_template_feats = 108
)
```

--------------------------------

### Generate Mock Inputs for AlphaFold3 Training

Source: https://github.com/lucidrains/alphafold3-pytorch/blob/main/README.md

Sets up mock input tensors for training the AlphaFold3 model. Includes atom, atom-pair, molecule, MSA, and template features.

```python
import torch

seq_len = 16

molecule_atom_indices = torch.randint(0, 2, (2, seq_len)).long()
molecule_atom_lens = torch.full((2, seq_len), 2).long()

atom_seq_len = molecule_atom_lens.sum(dim=-1).amax()
atom_offsets = exclusive_cumsum(molecule_atom_lens)

atom_inputs = torch.randn(2, atom_seq_len, 77)
atompair_inputs = torch.randn(2, atom_seq_len, atom_seq_len, 5)

additional_molecule_feats = torch.randint(0, 2, (2, seq_len, 5))
additional_token_feats = torch.randn(2, seq_len, 33)
is_molecule_types = torch.randint(0, 2, (2, seq_len, 5)).bool()
is_molecule_mod = torch.randint(0, 2, (2, seq_len, 4)).bool()
molecule_ids = torch.randint(0, 32, (2, seq_len))

template_feats = torch.randn(2, 2, seq_len, seq_len, 108)
template_mask = torch.ones((2, 2)).bool()

msa = torch.randn(2, 7, seq_len, 32)
msa_mask = torch.ones((2, 7)).bool()

additional_msa_feats = torch.randn(2, 7, seq_len, 2)

# required for training, but omitted on inference

atom_pos = torch.randn(2, atom_seq_len, 3)

distogram_atom_indices = molecule_atom_lens - 1

distance_labels = torch.randint(0, 37, (2, seq_len, seq_len))
resolved_labels = torch.randint(0, 2, (2, atom_seq_len))

# offset indices correctly

distogram_atom_indices += atom_offsets
molecule_atom_indices += atom_offsets
```

--------------------------------

### Run PDB dataset filtering scripts

Source: https://github.com/lucidrains/alphafold3-pytorch/blob/main/README.md

Execute the training, validation, and test filtering scripts with appropriate directory paths.

```bash
python scripts/filter_pdb_train_mmcifs.py --mmcif_assembly_dir <pdb_assembly_dir> --mmcif_asym_dir <pdb_asym_dir> --ccd_dir <ccd_dir> --output_dir <mmcif_output_dir>
python scripts/filter_pdb_val_mmcifs.py --mmcif_assembly_dir <pdb_assembly_dir> --mmcif_asym_dir <pdb_asym_dir> --output_dir <mmcif_output_dir>
python scripts/filter_pdb_test_mmcifs.py --mmcif_assembly_dir <pdb_assembly_dir> --mmcif_asym_dir <pdb_asym_dir> --output_dir <mmcif_output_dir>
```

--------------------------------

### AlphaFold3 Input Handling with Alphafold3Input

Source: https://github.com/lucidrains/alphafold3-pytorch/blob/main/README.md

Demonstrates using the `Alphafold3Input` class for simplified input preparation for training and evaluation. Handles protein sequences and atom positions.

```python
import torch
from alphafold3_pytorch import Alphafold3, Alphafold3Input

contrived_protein = 'AG'

mock_atompos = [
    torch.randn(5, 3),   # alanine has 5 non-hydrogen atoms
    torch.randn(4, 3)    # glycine has 4 non-hydrogen atoms
]

train_alphafold3_input = Alphafold3Input(
    proteins = [contrived_protein],
    atom_pos = mock_atompos
)

eval_alphafold3_input = Alphafold3Input(
    proteins = [contrived_protein]
)
```

--------------------------------

### Process MSA and Template Features

Source: https://context7.com/lucidrains/alphafold3-pytorch/llms.txt

Prepare MSA and template inputs for the model or use PDBInput for automated file processing.

```python
import torch
from alphafold3_pytorch import Alphafold3, Alphafold3Input

# MSA features shape: [batch, num_sequences, seq_len, features]
# The model expects preprocessed MSA features
msa_features = torch.randn(1, 512, 100, 49)  # 512 MSA sequences
msa_mask = torch.ones(1, 512).bool()

# Template features shape: [batch, num_templates, seq_len, seq_len, features]
template_features = torch.randn(1, 4, 100, 100, 108)  # 4 templates
template_mask = torch.ones(1, 4).bool()

# These can be provided directly to the model
model = Alphafold3(
    dim_atom_inputs=77,
    dim_template_feats=108,
    msa_module_kwargs=dict(
        depth=4,
        dim_msa=64,
        outer_product_mean_dim_hidden=32,
        msa_pwa_dropout_row_prob=0.15,
        msa_pwa_heads=8,
        msa_pwa_dim_head=32,
    ),
    template_embedder_kwargs=dict(
        pairformer_stack_depth=2,
        layerscale_output=True,
    ),
)

# Or use PDBInput with MSA/template directories
from alphafold3_pytorch.inputs import PDBInput

pdb_input = PDBInput(
    mmcif_filepath="./structure.cif",
    msa_dir="./msa_alignments/",  # Contains .a3m or .sto files
    templates_dir="./templates/",  # Contains template structures
)
```

--------------------------------

### Extract CCD files

Source: https://github.com/lucidrains/alphafold3-pytorch/blob/main/README.md

Decompress the downloaded CCD files.

```bash
find data/ccd_data/ -type f -name "*.gz" -exec gzip -d {} \;
```

--------------------------------

### Sample Atom Positions with AlphaFold3

Source: https://github.com/lucidrains/alphafold3-pytorch/blob/main/README.md

Samples atom positions using the AlphaFold3 model after training. Configurable with `num_sample_steps` for sampling quality.

```python
# after much training ...

sampled_atom_pos = alphafold3(
    num_recycling_steps = 4,
    num_sample_steps = 16,
    atom_inputs = atom_inputs,
    atompair_inputs = atompair_inputs,
    molecule_ids = molecule_ids,
    molecule_atom_lens = molecule_atom_lens,
    additional_molecule_feats = additional_molecule_feats,
    additional_msa_feats = additional_msa_feats,
    additional_token_feats = additional_token_feats,
    is_molecule_types = is_molecule_types,
    is_molecule_mod = is_molecule_mod,
    msa = msa,
    msa_mask = msa_mask,
    templates = template_feats,
    template_mask = template_mask
)

sampled_atom_pos.shape # (2, <atom_seqlen>, 3)
```

--------------------------------

### Build Docker Container

Source: https://github.com/lucidrains/alphafold3-pytorch/blob/main/README.md

Build the Docker container for AlphaFold3-PyTorch. The default image uses PyTorch 2.3.0 with CUDA 12.1.

```bash
docker build -t af3 .
```

--------------------------------

### AtomInput and Batched Processing

Source: https://context7.com/lucidrains/alphafold3-pytorch/llms.txt

Handles low-level atom data structures and prepares them for model forward passes using batching.

```python
import torch
from alphafold3_pytorch.inputs import (
    AtomInput,
    BatchedAtomInput,
    collate_inputs_to_batched_atom_input,
)

# Create individual AtomInput instances
atom_input = AtomInput(
    atom_inputs=torch.randn(100, 77),  # 100 atoms, 77 features each
    atompair_inputs=torch.randn(100, 100, 5),  # Pairwise features
    molecule_atom_lens=torch.tensor([50, 30, 20]),  # 3 molecules
    molecule_ids=torch.randint(0, 32, (3,)),  # Molecule type IDs
    additional_molecule_feats=torch.randint(0, 10, (3, 5)),
    is_molecule_types=torch.zeros(3, 5).bool(),  # [protein, rna, dna, ligand, metal]
)
atom_input.is_molecule_types[:, 0] = True  # Mark as proteins

# Batch multiple inputs together
inputs = [atom_input, atom_input]  # Two samples
batched_input = collate_inputs_to_batched_atom_input(
    inputs,
    atoms_per_window=27,
)

# Get dictionary for model forward pass
model_kwargs = batched_input.model_forward_dict()

# Forward pass with batched input
model = Alphafold3(dim_atom_inputs=77, dim_template_feats=108, ...)
output = model(**model_kwargs)
```

--------------------------------

### Configure Diffusion Sampling

Source: https://context7.com/lucidrains/alphafold3-pytorch/llms.txt

Perform structure generation using the ElucidatedAtomDiffusion module with configurable sampling parameters.

```python
import torch
from alphafold3_pytorch import Alphafold3

model = Alphafold3(
    dim_atom_inputs=77,
    dim_template_feats=108,
    # EDM (Elucidated Diffusion Model) parameters
    edm_kwargs=dict(
        sigma_min=0.002,
        sigma_max=80,
        rho=7,
        P_mean=-1.2,
        P_std=1.2,
        S_churn=80,
        S_tmin=0.05,
        S_tmax=50,
        S_noise=1.003,
    ),
    sigma_data=16,
    num_rollout_steps=20,
)

# During inference, control sampling
with torch.no_grad():
    # Get all intermediate diffusion steps
    all_coords = model.forward_with_alphafold3_inputs(
        alphafold3_input,
        num_sample_steps=50,  # More steps = higher quality
        return_all_diffused_atom_pos=True,
    )  # Returns Float['timesteps b m 3']

    # Final predicted coordinates
    final_coords = all_coords[-1]
```

--------------------------------

### Run Local Tests

Source: https://github.com/lucidrains/alphafold3-pytorch/blob/main/README.md

Execute local tests for the AlphaFold3-PyTorch project using pytest.

```bash
pytest tests/
```

--------------------------------

### Train AlphaFold3 Model

Source: https://github.com/lucidrains/alphafold3-pytorch/blob/main/README.md

Performs a training step using the AlphaFold3 model with generated mock inputs. Calculates and backpropagates the loss.

```python
# train

loss = alphafold3(
    num_recycling_steps = 2,
    atom_inputs = atom_inputs,
    atompair_inputs = atompair_inputs,
    molecule_ids = molecule_ids,
    molecule_atom_lens = molecule_atom_lens,
    additional_molecule_feats = additional_molecule_feats,
    additional_msa_feats = additional_msa_feats,
    additional_token_feats = additional_token_feats,
    is_molecule_types = is_molecule_types,
    is_molecule_mod = is_molecule_mod,
    msa = msa,
    msa_mask = msa_mask,
    templates = template_feats,
    template_mask = template_mask,
    atom_pos = atom_pos,
    distogram_atom_indices = distogram_atom_indices,
    molecule_atom_indices = molecule_atom_indices,
    distance_labels = distance_labels,
    resolved_labels = resolved_labels
)

loss.backward()
```

--------------------------------

### Unzip PDB mmCIF files

Source: https://github.com/lucidrains/alphafold3-pytorch/blob/main/README.md

Recursively find and decompress all .gz files within the PDB data directories.

```bash
find ./data/pdb_data/unfiltered_assembly_mmcifs/ -type f -name "*.gz" -exec gzip -d {} \;
find ./data/pdb_data/unfiltered_asym_mmcifs/ -type f -name "*.gz" -exec gzip -d {} \;
```

--------------------------------

### Cluster PDB Training Data

Source: https://github.com/lucidrains/alphafold3-pytorch/blob/main/README.md

Use these scripts to cluster PDB mmCIF files for training. Ensure to replace placeholders with your local directory paths. The `--clustering_filtered_pdb_dataset` flag is recommended for PDB datasets.

```bash
python scripts/cluster_pdb_train_mmcifs.py --mmcif_dir <mmcif_dir> --output_dir <train_clustering_output_dir> --clustering_filtered_pdb_dataset
```

```bash
python scripts/cluster_pdb_val_mmcifs.py --mmcif_dir <mmcif_dir> --reference_clustering_dir <train_clustering_output_dir> --output_dir <val_clustering_output_dir> --clustering_filtered_pdb_dataset
```

```bash
python scripts/cluster_pdb_test_mmcifs.py --mmcif_dir <mmcif_dir> --reference_1_clustering_dir <train_clustering_output_dir> --reference_2_clustering_dir <val_clustering_output_dir> --output_dir <test_clustering_output_dir> --clustering_filtered_pdb_dataset
```

--------------------------------

### Compute Confidence Scores

Source: https://context7.com/lucidrains/alphafold3-pytorch/llms.txt

Calculate pLDDT, pTM, and ipTM metrics from model outputs using confidence and ranking scorers.

```python
import torch
from alphafold3_pytorch.alphafold3 import ComputeConfidenceScore, ComputeRankingScore

# Initialize confidence score calculator
confidence_scorer = ComputeConfidenceScore(
    pae_breaks=torch.arange(0, 31.5, 0.5),
    pde_breaks=torch.arange(0, 31.5, 0.5),
)

# Compute confidence scores from model outputs
# confidence_head_logits comes from model forward pass
confidence_score = confidence_scorer(
    confidence_head_logits=confidence_logits,
    asym_id=asym_id,  # Chain IDs [b, n]
    has_frame=has_frame,  # Valid residue frames [b, n]
    multimer_mode=True,
)

print(f"pLDDT: {confidence_score.plddt.mean():.2f}")  # Per-atom confidence
print(f"pTM: {confidence_score.ptm:.4f}")  # Global structure confidence
print(f"ipTM: {confidence_score.iptm:.4f}")  # Interface confidence

# Full ranking score calculation
ranking_scorer = ComputeRankingScore()
ranking_score = ranking_scorer.compute_full_complex_metric(
    confidence_head_logits=confidence_logits,
    asym_id=asym_id,
    has_frame=has_frame,
    molecule_atom_lens=molecule_atom_lens,
    atom_pos=predicted_coords,
    atom_mask=atom_mask,
    is_molecule_types=is_molecule_types,
)
```

--------------------------------

### Evaluate AlphaFold3 with Alphafold3Input

Source: https://github.com/lucidrains/alphafold3-pytorch/blob/main/README.md

Sets the AlphaFold3 model to evaluation mode and samples atom positions using `Alphafold3Input` for inference.

```python
# sampling

alphafold3.eval()
sampled_atom_pos = alphafold3.forward_with_alphafold3_inputs(eval_alphafold3_input)

assert sampled_atom_pos.shape == (1, (5 + 4), 3)
```

--------------------------------

### Define Molecular Inputs with Alphafold3Input

Source: https://context7.com/lucidrains/alphafold3-pytorch/llms.txt

Use the Alphafold3Input dataclass to specify proteins, nucleic acids, ligands, and metal ions for structure prediction.

```python
from alphafold3_pytorch import Alphafold3Input

# Define a protein-ligand complex
alphafold3_input = Alphafold3Input(
    proteins=["MKTVRQERLKSIVRILERSKEPVSGAQLAEELSVSRQVIVQDIAYLRSLGYNIVATPRGYVLAGG"],
    ligands=["CC(=O)OC1=CC=CC=C1C(=O)O"],  # Aspirin SMILES
    ds_dna=["ATGCGATCGATCGATCGA"],  # Double-stranded DNA
    metal_ions=["MG", "ZN"],  # Magnesium and Zinc ions
)

# For protein-only prediction
protein_input = Alphafold3Input(
    proteins=[
        "MKTVRQERLKSIVRILERSKEPVSGAQ",  # Chain A
        "LAEELSVSRQVIVQDIAYLRSLGYNI"   # Chain B
    ]
)

# RNA-protein complex
rna_protein_input = Alphafold3Input(
    proteins=["MKTVRQERLKSIVRILERSKEPVSGAQLAEELSVSRQVIVQDIAYLRSLGYNIVATPRGYVLAGG"],
    ss_rna=["AUGCUAGCUAGCUAGCUA"]  # Single-stranded RNA
)
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.