Alphafold basic details explanation with script
AlphaFold protein structure prediction basic details explained
https://www.ebi.ac.uk/training/online/courses/alphafold/an-i…
mkdir -p /home/daytona/workspace/alphafold-demo && cat > /home/daytona/workspace/alphafold-demo/alphafold_basics.py << 'PYEOF' """ ============================================================= AlphaFold Basics — Demonstration Script Covers: protein folding problem, AlphaFold pipeline concepts, MSA simulation, pLDDT confidence, and structure output ============================================================= """ # ───────────────────────────────────────────────────────────── # SECTION 0 – Dependencies # ───────────────────────────────────────────────────────────── import numpy as np import random import textwrap from collections import defaultdict # ───────────────────────────────────────────────────────────── # SECTION 1 – What is the Protein Folding Problem? # ───────────────────────────────────────────────────────────── AMINO_ACIDS = list("ACDEFGHIKLMNPQRSTVWY") # 20 standard residues AA_PROPERTIES = { "hydrophobic": set("AILMFWV"), "polar": set("STNQ"), "charged_pos": set("KRH"), "charged_neg": set("DE"), "special": set("CGP"), # cysteine, glycine, proline } def classify_residue(aa: str) -> str: for group, members in AA_PROPERTIES.items(): if aa in members: return group return "other" def print_section(title: str): print("\n" + "=" * 60) print(f" {title}") print("=" * 60) print_section("1. The Protein Folding Problem") print(textwrap.dedent("""\ Proteins are chains of amino acids (polypeptides). Their biological FUNCTION is determined by their 3D SHAPE. Challenge: Given only the 1D amino-acid sequence, predict the 3D structure. Levinthal's Paradox (1969): A 100-residue protein has ~10^47 possible conformations. Random search would take longer than the age of the universe. Yet proteins fold in microseconds → evolution found shortcuts. AlphaFold's answer: Learn those shortcuts from ~200,000 experimentally determined structures in the Protein Data Bank. """)) # ───────────────────────────────────────────────────────────── # SECTION 2 – Simulating a Protein Sequence # ───────────────────────────────────────────────────────────── print_section("2. Protein Sequence Representation") def generate_sequence(length: int = 30, seed: int = 42) -> str: random.seed(seed) return "".join(random.choices(AMINO_ACIDS, k=length)) def describe_sequence(seq: str): counts = defaultdict(int) for aa in seq: counts[classify_residue(aa)] += 1 total = len(seq) print(f" Sequence ({total} residues): {seq}") print(f" Composition:") for group, cnt in sorted(counts.items()): bar = "█" * cnt print(f" {group:<15} {cnt:>3} ({cnt/total*100:4.1f}%) {bar}") seq = generate_sequence(30) describe_sequence(seq) # ───────────────────────────────────────────────────────────── # SECTION 3 – Multiple Sequence Alignment (MSA) — Core Input # ───────────────────────────────────────────────────────────── print_section("3. Multiple Sequence Alignment (MSA)") print(textwrap.dedent("""\ AlphaFold searches databases for homologous sequences — related proteins that share evolutionary ancestry. Co-evolution principle: If positions i and j mutate together across species, they are likely in PHYSICAL CONTACT in the 3D structure. """)) def simulate_msa(query: str, n_seqs: int = 6, mutation_rate: float = 0.15, seed: int = 7) -> list[str]: """Generate a toy MSA by randomly mutating the query sequence.""" random.seed(seed) msa = [query] for _ in range(n_seqs - 1): mutated = list(query) for i in range(len(mutated)): if random.random() < mutation_rate: mutated[i] = random.choice(AMINO_ACIDS) msa.append("".join(mutated)) return msa msa = simulate_msa(seq[:20]) # use first 20 residues for display print(" Simulated MSA (query + 5 homologs):") print(f" {'Seq':<8} Sequence") print(f" {'-'*8} {'-'*20}") for i, s in enumerate(msa): label = "Query" if i == 0 else f"Homolog{i}" print(f" {label:<8} {s}") # Co-evolution: count columns where ≥50% sequences agree def coevolution_signal(msa: list[str]) -> np.ndarray: L = len(msa[0]) N = len(msa) conservation = np.zeros(L) for col in range(L): column = [msa[row][col] for row in range(N)] most_common = max(set(column), key=column.count) conservation[col] = column.count(most_common) / N return conservation cons = coevolution_signal(msa) print("\n Conservation per position (1.0 = fully conserved):") print(" Pos: " + " ".join(f"{i+1:>3}" for i in range(len(cons)))) print(" Val: " + " ".join(f"{v:>3.1f}" for v in cons)) # ───────────────────────────────────────────────────────────── # SECTION 4 – Pairwise Distance / Contact Map Concept # ───────────────────────────────────────────────────────────── print_section("4. Contact / Distance Map") print(textwrap.dedent("""\ AlphaFold builds a 2D matrix: for every pair (i, j) of residues, it predicts the distance between them in 3D space. This 'distance map' is the bridge between 1D sequence → 3D structure. Residues < 8 Å apart are considered 'in contact'. """)) def mock_distance_map(n: int = 10, seed: int = 3) -> np.ndarray: """Toy symmetric distance map (Angstroms).""" rng = np.random.default_rng(seed) base = rng.uniform(4, 20, (n, n)) dist = (base + base.T) / 2 # make symmetric np.fill_diagonal(dist, 0.0) # self-distance = 0 # force nearby residues to be physically close for i in range(n): for j in range(i, min(i + 3, n)): dist[i, j] = dist[j, i] = rng.uniform(3.8, 6.0) return dist dmap = mock_distance_map(10) contact_threshold = 8.0 # Angstroms print(f"\n Mock distance map (Å) — 10-residue fragment:") print(" " + "".join(f"{i+1:>5}" for i in range(10))) for i in range(10): row = "".join( f"{' C ' if (dmap[i, j] < contact_threshold and i != j) else f'{dmap[i,j]:>5.1f}'}" for j in range(10) ) print(f" R{i+1:>2}: {row}") print(f"\n (C = contact, i.e. predicted distance < {contact_threshold} Å)") # ───────────────────────────────────────────────────────────── # SECTION 5 – pLDDT Confidence Score # ───────────────────────────────────────────────────────────── print_section("5. pLDDT — Per-Residue Confidence Score") print(textwrap.dedent("""\ AlphaFold outputs a confidence score for each residue: pLDDT = predicted Local Distance Difference Test Range: 0 – 100 Band Score Interpretation ───── ───── ────────────────────────────────────── Blue > 90 Very high confidence (rigid structure) Cyan 70–90 Confident Yellow 50–70 Low confidence (may be disordered) Orange < 50 Very low (likely intrinsically disordered) Low pLDDT ≠ wrong prediction — it often flags disordered regions that genuinely lack a fixed 3D structure in solution. """)) def simulate_plddt(n: int = 30, seed: int = 99) -> np.ndarray: rng = np.random.default_rng(seed) scores = rng.uniform(45, 98, n) # introduce a 'disordered loop' region in the middle scores[10:16] = rng.uniform(20, 50, 6) return scores.clip(0, 100) plddt = simulate_plddt(30) def confidence_band(score: float) -> str: if score > 90: return "Very High" if score > 70: return "Confident" if score > 50: return "Low" return "Very Low" print(f" {'Res':>4} {'pLDDT':>6} {'Band':<12} Indicator") print(f" {'---':>4} {'------':>6} {'----':<12} ---------") for i, s in enumerate(plddt): band = confidence_band(s) bar = "█" * int(s / 5) print(f" {i+1:>4} {s:>6.1f} {band:<12} {bar}") mean_plddt = plddt.mean() print(f"\n Mean pLDDT: {mean_plddt:.1f} → {'Reliable overall' if mean_plddt > 70 else 'Interpret cautiously'}") # ───────────────────────────────────────────────────────────── # SECTION 6 – AlphaFold Architecture Overview (Text Diagram) # ───────────────────────────────────────────────────────────── print_section("6. AlphaFold2 Architecture Overview") print(textwrap.dedent("""\ INPUT ┌──────────────────────────────────────────────────────┐ │ Amino-acid sequence + MSA (homologous sequences) │ │ + Optional template structures │ └──────────────────────────────────────────────────────┘ │ ▼ ┌──────────────────────────────────────────────────────┐ │ Embedding Layer │ │ • MSA representation (N_seq × L matrix — "red") │ │ • Pair representation (L × L matrix — "green") │ └──────────────────────────────────────────────────────┘ │ ▼ (×48 iterations) ┌──────────────────────────────────────────────────────┐ │ Evoformer Block │ │ • MSA attention — shares information across seqs │ │ • Outer product mean — updates pair from MSA │ │ • Triangular attention — enforces 3D geometry │ │ (triangle inequality: d_ij ≤ d_ik + d_kj) │ └──────────────────────────────────────────────────────┘ │ ▼ ┌──────────────────────────────────────────────────────┐ │ Structure Module │ │ • 8 × Invariant Point Attention (IPA) layers │ │ • Predicts rotation + translation per residue │ │ • Outputs Cα, N, C, O backbone + side-chain angles │ └──────────────────────────────────────────────────────┘ │ ▼ ┌──────────────────────────────────────────────────────┐ │ Amber Relaxation (post-processing) │ │ • Energy minimization to fix steric clashes │ └──────────────────────────────────────────────────────┘ │ ▼ OUTPUT: PDB file + pLDDT scores + PAE matrix """)) # ───────────────────────────────────────────────────────────── # SECTION 7 – AlphaFold3 Key Additions # ───────────────────────────────────────────────────────────── print_section("7. AlphaFold 3 — What Changed?") print(textwrap.dedent("""\ Released May 2024 by Google DeepMind. Feature AlphaFold 2 AlphaFold 3 ───────────────── ───────────── ────────────────────── Molecule types Proteins only Proteins, DNA, RNA, small molecules, ions Core architecture Evoformer Pairformer (simpler) Structure decoder IPA (geometric) Diffusion model Protein accuracy CASP14 winner +50% improvement on protein complexes Training data PDB (~200k structs) PDB + more diverse data Server access AlphaFold DB alphafoldserver.com Open source Yes (GitHub) Server free, code limited """)) # ───────────────────────────────────────────────────────────── # SECTION 8 – How to Use AlphaFold (Practical) # ───────────────────────────────────────────────────────────── print_section("8. Practical: How to Run AlphaFold2 (ColabFold)") print(textwrap.dedent("""\ Option A — AlphaFold Database (pre-computed, instant) URL: https://alphafold.ebi.ac.uk Coverage: ~214 million proteins (UniProt) Use when: you have a known UniProt accession Option B — ColabFold (Google Colab, free GPU) URL: https://colab.research.google.com/github/sokrypton/ColabFold Input: paste your FASTA sequence Time: ~5–30 min depending on protein length Option C — AlphaFold3 Server (complexes, ligands) URL: https://alphafoldserver.com Input: multiple chains, small molecules Option D — Local installation (large-scale) GitHub: github.com/google-deepmind/alphafold Requires: GPU (≥40 GB VRAM), ~2 TB database storage FASTA format example: >MyProtein MKTIIALSYIFCLVFA... """)) # ───────────────────────────────────────────────────────────── # SECTION 9 – Output Files Explained # ───────────────────────────────────────────────────────────── print_section("9. AlphaFold Output Files") print(textwrap.dedent("""\ File Contents ────────────────────────────── ─────────────────────────────────── ranked_0.pdb (best model) 3D coordinates (PDB format) ranked_1.pdb … ranked_4.pdb 4 alternative models result_model_1_*.pkl Raw network output (NumPy arrays) relax_metrics.json Amber relaxation statistics Inside the PDB file: ATOM records — one per heavy atom, including: • Residue name, chain ID, residue number • x, y, z Cartesian coordinates (Å) • B-factor column → repurposed for pLDDT score Confidence metrics stored separately: pLDDT — per residue (0–100) pTM — global fold confidence (0–1; >0.5 = good) PAE — Predicted Aligned Error matrix L×L (Å) Low PAE between two domains → reliable relative positioning of those domains """)) # ───────────────────────────────────────────────────────────── # SECTION 10 – Limitations # ───────────────────────────────────────────────────────────── print_section("10. Known Limitations") print(textwrap.dedent("""\ ✗ Static snapshot — cannot predict conformational dynamics ✗ Intrinsically disordered regions → low pLDDT (by design) ✗ Membrane proteins — historically harder (improving in AF3) ✗ Novel folds with no homologs → less reliable ✗ Does NOT predict: • Binding affinity (Kd) • Post-translational modifications • Protein–protein binding specificity ✗ Multimer accuracy varies; always validate with experiments Golden rule: High pLDDT + low PAE = trustworthy prediction. Always cross-validate with functional data. """)) print("\n" + "=" * 60) print(" Script complete. All sections demonstrated successfully.") print("=" * 60 + "\n") PYEOF echo "File written successfully" python3 /home/daytona/workspace/alphafold-demo/alphafold_basics.py
AlphaFold — Basic Details
What Problem Does It Solve?
The 10 Core Concepts Covered in the Script
| # | Topic | What It Explains |
|---|---|---|
| 1 | Protein Folding Problem | Levinthal's paradox, why folding is hard |
| 2 | Sequence Representation | 20 amino acids, properties, composition |
| 3 | Multiple Sequence Alignment (MSA) | How co-evolution reveals 3D contacts |
| 4 | Contact / Distance Map | The L×L matrix bridging sequence → structure |
| 5 | pLDDT Confidence Score | Per-residue reliability (0–100 scale) |
| 6 | AlphaFold2 Architecture | Full pipeline diagram: Evoformer → IPA → PDB |
| 7 | AlphaFold3 Changes | Pairformer, diffusion decoder, DNA/RNA/ligands |
| 8 | Practical Usage | EBI database, ColabFold, AF3 server, local install |
| 9 | Output Files | PDB, pLDDT, pTM, PAE matrix explained |
| 10 | Limitations | What AlphaFold cannot do |
Architecture in Brief (AlphaFold2)
Sequence + MSA + Templates
↓
Embedding (MSA matrix + Pair matrix)
↓ ×48
Evoformer Blocks
• MSA attention (shares info across homologs)
• Triangular attention (enforces geometry: d_ij ≤ d_ik + d_kj)
↓
Structure Module (IPA layers)
• Predicts rotation + translation per residue
↓
Amber Relaxation (energy minimization)
↓
OUTPUT: PDB file + pLDDT + PAE
pLDDT Score Quick Reference
| Score | Colour | Meaning |
|---|---|---|
| > 90 | Blue | Very high confidence |
| 70–90 | Cyan | Confident |
| 50–70 | Yellow | Low — possible disorder |
| < 50 | Orange | Very low — likely disordered |
AlphaFold2 vs AlphaFold3
| Feature | AF2 | AF3 |
|---|---|---|
| Molecules | Proteins only | Protein, DNA, RNA, ligands, ions |
| Core module | Evoformer | Pairformer |
| Decoder | IPA (geometric) | Diffusion model |
| Accuracy gain | CASP14 champion | +50% on complexes |
Script Download
alphafold basics
Python File · PY
python3 alphafold_basics.py
numpy (pre-installed everywhere).In word file
ls /home/daytona/workspace/alphafold-demo/
~/alphafold-demo/create_alphafold_doc.js
const {
Document, Packer, Paragraph, TextRun, Table, TableRow, TableCell,
HeadingLevel, AlignmentType, LevelFormat, BorderStyle, WidthType,
VerticalAlign, ShadingType, Header, PageNumber, Footer,
UnderlineType
} = require('docx');
const fs = require('fs');
// ── Colour palette ──────────────────────────────────────────
const DARK_BLUE = "1F3864";
const MID_BLUE = "2E74B5";
const LIGHT_BLUE = "D6E4F0";
const ACCENT = "1ABC9C";
const GREY_BG = "F2F2F2";
const CODE_BG = "1E1E1E";
const CODE_FG = "D4D4D4";
// ── Helper: section heading ─────────────────────────────────
function h1(text) {
return new Paragraph({
heading: HeadingLevel.HEADING_1,
children: [new TextRun({ text, color: DARK_BLUE, bold: true, size: 32, font: "Arial" })],
spacing: { before: 400, after: 160 },
});
}
function h2(text) {
return new Paragraph({
heading: HeadingLevel.HEADING_2,
children: [new TextRun({ text, color: MID_BLUE, bold: true, size: 26, font: "Arial" })],
spacing: { before: 280, after: 120 },
});
}
function h3(text) {
return new Paragraph({
heading: HeadingLevel.HEADING_3,
children: [new TextRun({ text, color: MID_BLUE, bold: true, size: 24, font: "Arial" })],
spacing: { before: 200, after: 80 },
});
}
function para(text, opts = {}) {
return new Paragraph({
children: [new TextRun({ text, font: "Arial", size: 22, ...opts })],
spacing: { before: 60, after: 80 },
});
}
function bullet(text, bold_prefix = "") {
return new Paragraph({
numbering: { reference: "bullets", level: 0 },
children: [
...(bold_prefix ? [new TextRun({ text: bold_prefix, bold: true, font: "Arial", size: 22 })] : []),
new TextRun({ text, font: "Arial", size: 22 }),
],
spacing: { before: 40, after: 40 },
});
}
function codeBlock(lines) {
return lines.map(line =>
new Paragraph({
children: [new TextRun({ text: line, font: "Courier New", size: 18, color: CODE_FG })],
spacing: { before: 0, after: 0 },
shading: { type: ShadingType.SOLID, color: CODE_BG, fill: CODE_BG },
indent: { left: 360, right: 360 },
})
);
}
function emptyLine() {
return new Paragraph({ children: [new TextRun("")], spacing: { before: 0, after: 60 } });
}
function divider() {
return new Paragraph({
border: { bottom: { style: BorderStyle.SINGLE, size: 6, color: MID_BLUE } },
children: [new TextRun("")],
spacing: { before: 200, after: 200 },
});
}
// ── Table helper ────────────────────────────────────────────
function makeTable(headers, rows, colWidths) {
const headerCells = headers.map((h, i) =>
new TableCell({
width: { size: colWidths[i], type: WidthType.DXA },
shading: { type: ShadingType.SOLID, color: DARK_BLUE, fill: DARK_BLUE },
verticalAlign: VerticalAlign.CENTER,
children: [new Paragraph({
alignment: AlignmentType.CENTER,
children: [new TextRun({ text: h, bold: true, color: "FFFFFF", font: "Arial", size: 20 })],
})],
})
);
const dataRows = rows.map((row, ri) =>
new TableRow({
children: row.map((cell, ci) =>
new TableCell({
width: { size: colWidths[ci], type: WidthType.DXA },
shading: { type: ShadingType.SOLID, color: ri % 2 === 0 ? "FFFFFF" : GREY_BG, fill: ri % 2 === 0 ? "FFFFFF" : GREY_BG },
verticalAlign: VerticalAlign.CENTER,
children: [new Paragraph({
children: [new TextRun({ text: cell, font: "Arial", size: 20 })],
spacing: { before: 40, after: 40 },
indent: { left: 80 },
})],
})
),
})
);
return new Table({
rows: [new TableRow({ children: headerCells, tableHeader: true }), ...dataRows],
width: { size: 100, type: WidthType.PERCENTAGE },
margins: { top: 60, bottom: 60, left: 80, right: 80 },
});
}
// ── Shaded info box ─────────────────────────────────────────
function infoBox(lines, bg = LIGHT_BLUE) {
return lines.map(line =>
new Paragraph({
children: [new TextRun({ text: line, font: "Arial", size: 20, color: DARK_BLUE })],
shading: { type: ShadingType.SOLID, color: bg, fill: bg },
indent: { left: 360, right: 360 },
spacing: { before: 40, after: 40 },
})
);
}
// ────────────────────────────────────────────────────────────
// DOCUMENT
// ────────────────────────────────────────────────────────────
const doc = new Document({
numbering: {
config: [
{
reference: "bullets",
levels: [{
level: 0, format: LevelFormat.BULLET, text: "•",
alignment: AlignmentType.LEFT,
style: { paragraph: { indent: { left: 720, hanging: 360 } } },
}],
},
{
reference: "numbers",
levels: [{
level: 0, format: LevelFormat.DECIMAL, text: "%1.",
alignment: AlignmentType.LEFT,
style: { paragraph: { indent: { left: 720, hanging: 360 } } },
}],
},
],
},
styles: {
default: { document: { run: { font: "Arial", size: 22 } } },
paragraphStyles: [
{
id: "Heading1", name: "Heading 1", basedOn: "Normal", next: "Normal", quickFormat: true,
run: { size: 32, bold: true, color: DARK_BLUE, font: "Arial" },
paragraph: { spacing: { before: 400, after: 160 }, outlineLevel: 0 },
},
{
id: "Heading2", name: "Heading 2", basedOn: "Normal", next: "Normal", quickFormat: true,
run: { size: 26, bold: true, color: MID_BLUE, font: "Arial" },
paragraph: { spacing: { before: 280, after: 120 }, outlineLevel: 1 },
},
{
id: "Heading3", name: "Heading 3", basedOn: "Normal", next: "Normal", quickFormat: true,
run: { size: 24, bold: true, color: MID_BLUE, font: "Arial" },
paragraph: { spacing: { before: 200, after: 80 }, outlineLevel: 2 },
},
],
},
sections: [
{
properties: {
page: {
margin: { top: 1080, bottom: 1080, left: 1080, right: 1080 },
},
},
headers: {
default: new Header({
children: [
new Paragraph({
alignment: AlignmentType.RIGHT,
children: [new TextRun({ text: "AlphaFold — Protein Structure Prediction", font: "Arial", size: 18, color: "888888" })],
border: { bottom: { style: BorderStyle.SINGLE, size: 4, color: MID_BLUE } },
}),
],
}),
},
footers: {
default: new Footer({
children: [
new Paragraph({
alignment: AlignmentType.CENTER,
children: [
new TextRun({ text: "Page ", font: "Arial", size: 18, color: "888888" }),
new TextRun({ children: [PageNumber.CURRENT], font: "Arial", size: 18, color: "888888" }),
new TextRun({ text: " of ", font: "Arial", size: 18, color: "888888" }),
new TextRun({ children: [PageNumber.TOTAL_PAGES], font: "Arial", size: 18, color: "888888" }),
],
border: { top: { style: BorderStyle.SINGLE, size: 4, color: MID_BLUE } },
}),
],
}),
},
children: [
// ── TITLE PAGE ────────────────────────────────────────
new Paragraph({
alignment: AlignmentType.CENTER,
children: [new TextRun({ text: "AlphaFold", font: "Arial", size: 72, bold: true, color: DARK_BLUE })],
spacing: { before: 800, after: 120 },
}),
new Paragraph({
alignment: AlignmentType.CENTER,
children: [new TextRun({ text: "Basic Details & Demonstration Script", font: "Arial", size: 36, color: MID_BLUE })],
spacing: { before: 0, after: 80 },
}),
new Paragraph({
alignment: AlignmentType.CENTER,
children: [new TextRun({ text: "Google DeepMind's AI System for Protein Structure Prediction", font: "Arial", size: 24, color: "555555", italics: true })],
spacing: { before: 0, after: 600 },
}),
...infoBox([
" AlphaFold2 — Published in Nature, July 2021 (Jumper et al.)",
" AlphaFold3 — Published in Nature, May 2024",
" Nobel Prize in Chemistry 2024 — David Baker, Demis Hassabis, John Jumper",
], LIGHT_BLUE),
emptyLine(),
divider(),
// ── SECTION 1 – THE PROBLEM ──────────────────────────
h1("1. The Protein Folding Problem"),
para("Proteins are chains of amino acids (polypeptides). Their biological function is determined entirely by their 3D shape. The central challenge: given only the 1D amino acid sequence, predict the 3D structure."),
emptyLine(),
h3("Levinthal's Paradox (1969)"),
bullet("A 100-residue protein has ~10⁴⁷ possible conformations."),
bullet("Exhaustive random search would take longer than the age of the universe."),
bullet("Yet proteins fold correctly in microseconds to milliseconds."),
bullet("Conclusion: evolution has encoded folding pathways in the sequence itself."),
emptyLine(),
h3("Why It Matters"),
bullet("Proteins drive every biological process: enzymes, receptors, structural scaffolds, signalling."),
bullet("Drug design requires knowing a target protein's exact 3D shape."),
bullet("Experimental structure determination (X-ray crystallography, cryo-EM) takes months and significant cost per protein."),
bullet("AlphaFold predicts structures in minutes — for free."),
divider(),
// ── SECTION 2 – WHAT IS ALPHAFOLD ───────────────────
h1("2. What Is AlphaFold?"),
para("AlphaFold is a deep learning system developed by Google DeepMind that predicts the 3D atomic structure of a protein from its amino acid sequence alone. It is not a homology modelling tool — it can predict entirely novel protein folds with no known template."),
emptyLine(),
makeTable(
["Property", "AlphaFold 2 (2020)", "AlphaFold 3 (2024)"],
[
["Molecule types", "Proteins only", "Proteins, DNA, RNA, small molecules, ions"],
["Core architecture", "Evoformer (transformer-based)", "Pairformer (simpler transformer)"],
["Structure decoder", "IPA — Invariant Point Attention", "Diffusion model (iterative refinement)"],
["Training data", "~200,000 PDB structures", "PDB + diverse biomolecular data"],
["Accuracy (CASP)", "CASP14 — declared winner", "+50% improvement on protein complexes"],
["Open source", "Yes — github.com/google-deepmind/alphafold", "Server free; code restricted"],
["Database", "alphafold.ebi.ac.uk (~214M proteins)", "alphafoldserver.com"],
],
[2600, 3000, 3400]
),
divider(),
// ── SECTION 3 – INPUTS ───────────────────────────────
h1("3. Inputs to AlphaFold"),
h2("3.1 Amino Acid Sequence (FASTA format)"),
para("The primary input is the protein sequence — a string of one-letter codes for the 20 standard amino acids:"),
emptyLine(),
...codeBlock([
">MyProtein_example",
"MKTIIALSYIFCLVFADYKDDDDK...",
"",
"20 standard amino acids:",
"A C D E F G H I K L M N P Q R S T V W Y",
]),
emptyLine(),
h2("3.2 Multiple Sequence Alignment (MSA)"),
para("AlphaFold searches large sequence databases (UniRef90, MGnify, BFD) for homologous proteins — evolutionarily related sequences from other species. The result is a Multiple Sequence Alignment (MSA)."),
emptyLine(),
h3("Co-evolution Principle"),
para("If amino acid positions i and j mutate together across many species, they are likely in physical contact in the 3D structure. This co-evolutionary signal is the primary geometric information AlphaFold extracts."),
emptyLine(),
...infoBox([
" MSA example (query + homologs):",
" Query : PAGFRQVCKAFMAEPMFNTA",
" Homolog1 : PAGVWTVQDAWIAEWMFFTE",
" Homolog2 : PAGWRQVCKAFMAEPMFNLA",
" Homolog3 : PAQFRQVCKAFMAEPMQNTA",
" Conservation: ↑↑↑ high ↑↑↑ (positions 1-3 perfectly conserved)",
], LIGHT_BLUE),
emptyLine(),
h2("3.3 Optional Template Structures"),
para("AlphaFold can optionally use known 3D structures from the PDB as templates, but it does NOT require them. It can predict de novo folds with no template."),
divider(),
// ── SECTION 4 – ARCHITECTURE ─────────────────────────
h1("4. AlphaFold 2 — Architecture"),
para("AlphaFold 2 consists of four major stages:"),
emptyLine(),
makeTable(
["Stage", "Component", "Role"],
[
["1", "Embedding Layer", "Converts sequence + MSA into two learned matrices:\n• MSA representation (N_seqs × L)\n• Pair representation (L × L)"],
["2", "Evoformer (×48 blocks)", "Iteratively refines both matrices using:\n• MSA row/column attention\n• Outer product mean (MSA → Pair update)\n• Triangular attention (enforces geometry)"],
["3", "Structure Module (×8 IPA)", "Converts pair representation → 3D coordinates\nPredicts rotation + translation per residue"],
["4", "Amber Relaxation", "Energy minimisation to resolve steric clashes\n(AMBER force field, post-processing only)"],
],
[1500, 2500, 5000]
),
emptyLine(),
h3("Architecture Diagram"),
...codeBlock([
"INPUT",
"┌──────────────────────────────────────────────────────┐",
"│ Amino-acid sequence + MSA + Optional templates │",
"└──────────────────────────────────────────────────────┘",
" │",
" ▼",
"┌──────────────────────────────────────────────────────┐",
"│ EMBEDDING LAYER │",
"│ • MSA representation (N_seq × L) — 'red array' │",
"│ • Pair representation (L × L) — 'green array' │",
"└──────────────────────────────────────────────────────┘",
" │",
" ▼ (×48 iterations)",
"┌──────────────────────────────────────────────────────┐",
"│ EVOFORMER BLOCK │",
"│ • MSA attention — shares info across homologs │",
"│ • Outer product mean — updates pair from MSA │",
"│ • Triangular attention — enforces triangle law: │",
"│ d_ij ≤ d_ik + d_kj (3D geometry constraint) │",
"└──────────────────────────────────────────────────────┘",
" │",
" ▼",
"┌──────────────────────────────────────────────────────┐",
"│ STRUCTURE MODULE (×8 IPA layers) │",
"│ • Invariant Point Attention │",
"│ • Predicts rotation + translation per residue │",
"│ • Outputs Cα, N, C, O + side-chain torsion angles │",
"└──────────────────────────────────────────────────────┘",
" │",
" ▼",
"┌──────────────────────────────────────────────────────┐",
"│ AMBER RELAXATION (post-processing) │",
"│ • Energy minimisation to fix steric clashes │",
"└──────────────────────────────────────────────────────┘",
" │",
" ▼",
"OUTPUT: PDB file + pLDDT scores + PAE matrix",
]),
divider(),
// ── SECTION 5 – CONFIDENCE SCORES ───────────────────
h1("5. Confidence Scores"),
h2("5.1 pLDDT — Per-Residue Confidence"),
para("pLDDT (predicted Local Distance Difference Test) is a score from 0–100 assigned to every residue. It measures how confidently AlphaFold has placed that residue in 3D space."),
emptyLine(),
makeTable(
["pLDDT Score", "Colour (PyMOL)", "Interpretation"],
[
["> 90", "Blue", "Very high confidence — well-defined rigid structure"],
["70 – 90", "Cyan", "Confident — generally reliable"],
["50 – 70", "Yellow", "Low confidence — may be disordered region"],
["< 50", "Orange", "Very low — likely intrinsically disordered"],
],
[2000, 2000, 5000]
),
emptyLine(),
...infoBox([
" Important: Low pLDDT does NOT always mean a wrong prediction.",
" It often correctly identifies regions that are genuinely disordered in solution",
" and lack a fixed 3D structure. These are biologically meaningful!",
], "FFF3CD"),
emptyLine(),
h2("5.2 pTM — Global Fold Confidence"),
bullet("pTM (predicted Template Modelling score) is a single number from 0 to 1."),
bullet("pTM > 0.5: the predicted global fold is likely correct."),
bullet("Used to assess overall reliability before analysing details."),
emptyLine(),
h2("5.3 PAE — Predicted Aligned Error"),
bullet("An L×L matrix (L = sequence length) showing the expected position error (Å) between every pair of residues."),
bullet("Low PAE between two domains = their relative orientation is reliably predicted."),
bullet("High PAE between domains = their relative positioning is uncertain (common for flexible linkers)."),
bullet("Essential for evaluating multi-domain proteins and complexes."),
divider(),
// ── SECTION 6 – DISTANCE / CONTACT MAP ──────────────
h1("6. Distance Map — Bridging Sequence to Structure"),
para("A core intermediate in AlphaFold is the pairwise distance map: a matrix where entry (i, j) is the predicted Euclidean distance (in Ångströms) between residues i and j in 3D space."),
bullet("Diagonal entries = 0 (self-distance)."),
bullet("Nearest neighbours in sequence are constrained to be physically close (peptide bond ~3.8 Å)."),
bullet("Residues < 8 Å apart are considered 'in contact'."),
bullet("The entire 3D structure can be reconstructed from an accurate distance map."),
emptyLine(),
...codeBlock([
"Distance map example (10 residues, Å):",
" R1 R2 R3 R4 R5 R6 R7 R8 R9 R10",
"R1: 0.0 C C 11.7 11.4 11.3 9.3 10.1 10.9 10.3",
"R2: C 0.0 C C 15.2 12.8 12.2 17.0 11.9 9.3",
"R3: C C 0.0 C C 14.3 13.8 16.5 8.2 14.4",
"...",
"C = contact (distance < 8 Å)",
]),
divider(),
// ── SECTION 7 – OUTPUT FILES ─────────────────────────
h1("7. Output Files Explained"),
makeTable(
["File", "Contents"],
[
["ranked_0.pdb", "Best predicted model — 3D atomic coordinates (PDB format)"],
["ranked_1.pdb … ranked_4.pdb", "4 alternative models ranked by confidence"],
["result_model_*.pkl", "Raw network output — NumPy arrays (pLDDT, PAE, etc.)"],
["relax_metrics.json", "Amber relaxation statistics"],
],
[3500, 5500]
),
emptyLine(),
h3("Inside a PDB File"),
...codeBlock([
"ATOM 1 N MET A 1 38.295 15.423 12.001 1.00 95.23 N",
"ATOM 2 CA MET A 1 37.901 14.087 12.418 1.00 95.23 C",
"ATOM 3 C MET A 1 36.421 13.812 12.176 1.00 94.87 C",
" ^---record ^--residue ^--x ^--y ^--z ^--B-factor = pLDDT",
]),
emptyLine(),
para("Note: AlphaFold repurposes the B-factor column in PDB files to store the pLDDT score for each atom."),
divider(),
// ── SECTION 8 – HOW TO USE ───────────────────────────
h1("8. How to Use AlphaFold"),
h2("Option A — AlphaFold Database (Pre-computed, Instant)"),
bullet("URL: https://alphafold.ebi.ac.uk"),
bullet("Coverage: ~214 million proteins (nearly all of UniProt)"),
bullet("Use when: you have a UniProt accession number"),
bullet("No computational resources needed — results are instant"),
emptyLine(),
h2("Option B — ColabFold (Google Colab, Free GPU)"),
bullet("URL: colab.research.google.com/github/sokrypton/ColabFold"),
bullet("Input: paste your FASTA sequence into the notebook"),
bullet("Time: ~5–30 minutes depending on protein length"),
bullet("Best option for novel sequences not in the database"),
emptyLine(),
h2("Option C — AlphaFold 3 Server (Complexes & Ligands)"),
bullet("URL: https://alphafoldserver.com"),
bullet("Supports: protein-protein, protein-DNA, protein-RNA, protein-ligand complexes"),
bullet("Free for non-commercial research"),
emptyLine(),
h2("Option D — Local Installation (Large Scale)"),
bullet("GitHub: github.com/google-deepmind/alphafold"),
bullet("Requirements: GPU with ≥40 GB VRAM, ~2 TB storage for databases"),
bullet("Use for: batch processing of hundreds/thousands of sequences"),
emptyLine(),
h3("FASTA Input Format"),
...codeBlock([
">ProteinName_identifier",
"MKTIIALSYIFCLVFADYKDDDDK...",
"",
"Rules:",
"• Header line starts with '>'",
"• Sequence follows on next line(s)",
"• Use standard 1-letter amino acid codes",
"• Maximum recommended: 2,500 residues for ColabFold",
]),
divider(),
// ── SECTION 9 – PYTHON SCRIPT ────────────────────────
h1("9. Demonstration Python Script"),
para("The following Python script demonstrates AlphaFold concepts computationally — simulating MSA generation, contact maps, and pLDDT confidence scoring using only NumPy (no GPU required)."),
emptyLine(),
h2("9.1 Run the Script"),
...codeBlock([
"# Prerequisites: Python 3.10+ with NumPy",
"# No GPU or AlphaFold installation needed",
"",
"python alphafold_basics.py",
]),
emptyLine(),
h2("9.2 Script Structure"),
makeTable(
["Section", "Topic", "Demonstrates"],
[
["1", "Protein Folding Problem", "Levinthal's paradox, search space size"],
["2", "Sequence Representation", "20 amino acids, physicochemical properties, composition"],
["3", "MSA Simulation", "Homolog generation, co-evolution, conservation scoring"],
["4", "Contact / Distance Map", "Pairwise distances, contact threshold (8 Å)"],
["5", "pLDDT Confidence", "Per-residue scoring with band classification"],
["6", "Architecture Diagram", "Full AF2 pipeline: Evoformer → IPA → Amber"],
["7", "AlphaFold 3 Changes", "Pairformer, diffusion decoder, molecule types"],
["8", "Practical Usage", "Database, ColabFold, AF3 server, local install"],
["9", "Output Files", "PDB format, pLDDT, pTM, PAE matrix"],
["10", "Limitations", "What AlphaFold cannot predict"],
],
[900, 2000, 6100]
),
emptyLine(),
h2("9.3 Key Code Snippets"),
h3("Amino Acid Classification"),
...codeBlock([
"AMINO_ACIDS = list('ACDEFGHIKLMNPQRSTVWY') # 20 standard residues",
"",
"AA_PROPERTIES = {",
" 'hydrophobic': set('AILMFWV'),",
" 'polar': set('STNQ'),",
" 'charged_pos': set('KRH'),",
" 'charged_neg': set('DE'),",
" 'special': set('CGP'), # cysteine, glycine, proline",
"}",
]),
emptyLine(),
h3("MSA Simulation"),
...codeBlock([
"def simulate_msa(query, n_seqs=6, mutation_rate=0.15):",
" \"\"\"Generate toy MSA by randomly mutating query sequence.\"\"\"",
" msa = [query]",
" for _ in range(n_seqs - 1):",
" mutated = list(query)",
" for i in range(len(mutated)):",
" if random.random() < mutation_rate:",
" mutated[i] = random.choice(AMINO_ACIDS)",
" msa.append(''.join(mutated))",
" return msa",
]),
emptyLine(),
h3("pLDDT Confidence Classification"),
...codeBlock([
"def confidence_band(score: float) -> str:",
" if score > 90: return 'Very High (Blue)'",
" if score > 70: return 'Confident (Cyan)'",
" if score > 50: return 'Low (Yellow)'",
" return 'Very Low (Orange)'",
]),
divider(),
// ── SECTION 10 – LIMITATIONS ─────────────────────────
h1("10. Limitations of AlphaFold"),
...infoBox([
" AlphaFold predicts structure — not dynamics, binding affinity, or function.",
" Always validate computationally predicted structures with experimental data.",
], "FFF3CD"),
emptyLine(),
makeTable(
["Limitation", "Details"],
[
["Static snapshot", "Predicts one low-energy conformation; cannot model conformational dynamics or multiple states"],
["Intrinsically disordered regions", "Low pLDDT is correct — these regions genuinely lack fixed structure in solution"],
["Novel folds", "Accuracy drops for proteins with no evolutionary homologs (sparse MSA)"],
["Membrane proteins", "Historically harder; improving in AF3 but still challenging"],
["Does NOT predict binding affinity", "No Kd, Ki, or IC50 values; use docking tools (AutoDock, Glide) separately"],
["Post-translational modifications", "Phosphorylation, glycosylation, ubiquitination not modelled"],
["Multimer reliability varies", "Protein complex accuracy improving but requires cross-validation"],
["No functional annotation", "Predicting structure does not automatically reveal function or substrate"],
],
[3000, 6000]
),
divider(),
// ── SECTION 11 – QUICK REFERENCE ─────────────────────
h1("11. Quick Reference Summary"),
makeTable(
["Concept", "Key Fact"],
[
["Developer", "Google DeepMind"],
["AF2 published", "Nature, July 2021 (Jumper et al.)"],
["AF3 published", "Nature, May 2024"],
["Nobel Prize", "Chemistry 2024 — Hassabis & Jumper (AlphaFold)"],
["Training data", "Protein Data Bank (PDB) — ~200,000 experimental structures"],
["Database size", "~214 million protein structure predictions (UniProt)"],
["Prediction time", "Minutes (ColabFold) to tens of minutes (large complexes)"],
["pLDDT range", "0–100; > 90 = very high confidence"],
["pTM range", "0–1; > 0.5 = reliable global fold"],
["Output format", "PDB files + JSON confidence files"],
["Best free access", "alphafold.ebi.ac.uk (database) or ColabFold (custom sequences)"],
],
[3000, 6000]
),
emptyLine(),
divider(),
new Paragraph({
alignment: AlignmentType.CENTER,
children: [new TextRun({ text: "End of Document", font: "Arial", size: 20, color: "888888", italics: true })],
spacing: { before: 200, after: 200 },
}),
],
},
],
});
// Write the file
Packer.toBuffer(doc).then(buffer => {
fs.writeFileSync('/home/daytona/workspace/alphafold-demo/AlphaFold_Basics.docx', buffer);
console.log('SUCCESS: AlphaFold_Basics.docx written');
}).catch(err => {
console.error('ERROR:', err);
process.exit(1);
});
cd /home/daytona/workspace/alphafold-demo && node create_alphafold_doc.js
python3 /home/daytona/skills/docx/scripts/office/validate.py /home/daytona/workspace/alphafold-demo/AlphaFold_Basics.docx
# Validate by checking file size and opening with python-docx ls -lh /home/daytona/workspace/alphafold-demo/AlphaFold_Basics.docx # Also try to unzip and check internal XML is valid python3 -c " import zipfile, os path = '/home/daytona/workspace/alphafold-demo/AlphaFold_Basics.docx' with zipfile.ZipFile(path, 'r') as z: names = z.namelist() print('Files inside docx:', len(names)) for n in names[:10]: print(' ', n) # Check document.xml exists if 'word/document.xml' in names: content = z.read('word/document.xml').decode('utf-8') print('document.xml size:', len(content), 'chars') print('Valid XML start:', content[:80]) "
Word Document Ready
AlphaFold Basics
Word Document · DOCX
What's Inside the Document
.docx is fully formatted with:| Feature | Details |
|---|---|
| Header | "AlphaFold — Protein Structure Prediction" on every page |
| Footer | Page X of Y numbering |
| Title page | Title, subtitle, Nobel Prize note |
| 11 Sections | Complete content with H1/H2/H3 headings |
| 5 Tables | AF2 vs AF3 comparison, architecture stages, pLDDT bands, output files, quick reference |
| Code blocks | Dark-background code snippets for architecture diagram, PDB format, Python snippets |
| Info boxes | Highlighted callouts for key warnings and tips |
| Colour scheme | Navy + blue headings, alternating-row tables, yellow caution boxes |
Sections Covered
- The Protein Folding Problem
- What Is AlphaFold? (AF2 vs AF3 table)
- Inputs — Sequence, MSA, Templates
- AlphaFold 2 Architecture (Evoformer → IPA → Amber)
- Confidence Scores (pLDDT, pTM, PAE)
- Distance / Contact Map
- Output Files
- How to Use AlphaFold (4 options)
- Python Demonstration Script (with code)
- Limitations
- Quick Reference Summary