Chapter 1: AI-Driven Drug Discovery in Practice - Accelerating Novel Drug Candidate Discovery 10x

This chapter covers AI. You will learn four real success stories with technical details and Evaluate the current state of AI drug discovery.

Learning Objectives

By the end of this chapter, you will be able to:

✅ Quantitatively explain drug discovery process challenges and traditional method limitations
✅ Understand the four main AI drug discovery approaches (virtual screening, molecular generation, ADMET prediction, protein structure prediction)
✅ Explain four real success stories with technical details
✅ Implement RDKit, molecular VAE, and binding affinity prediction in Python
✅ Evaluate the current state of AI drug discovery and outlook for the next 5 years

1.1 Challenges in Drug Discovery

1.1.1 Traditional Drug Discovery: Time and Cost Barriers

New drug development is a crucial research field directly linked to human health, but the journey is far more arduous than one might imagine.

Realistic Numbers:

Metric	Traditional Method	AI Drug Discovery (Actual)
Development Period	10-15 years	1.5-4 years (until candidate discovery)
Total Cost	¥20-30 billion	¥2-5 billion (10-15%)
Candidate Compounds	5,000-10,000	100-500
Success Rate	0.02% (2 out of 10,000)	0.5-1% (improving)
Clinical Trial Failure Rate	90% (Phase I-III total)	75-85% (improving trend)

Source: Wouters et al. (2020), Nature Reviews Drug Discovery; Paul et al. (2010), Nature Reviews Drug Discovery

1.1.2 Stages of Drug Discovery Process

The traditional drug discovery process goes through the following stages:

flowchart LR A[Target Identification\n1-2 years] --> B[Hit Compound Discovery\n2-4 years] B --> C[Lead Optimization\n2-3 years] C --> D[Preclinical Trials\n1-2 years] D --> E[Phase I\n1-2 years] E --> F[Phase II\n2-3 years] F --> G[Phase III\n2-4 years] G --> H[Approval Application\n1-2 years] style A fill:#ffebee style B fill:#fff3e0 style C fill:#e8f5e9 style D fill:#e3f2fd style E fill:#f3e5f5 style F fill:#fce4ec style G fill:#e0f2f1 style H fill:#f9fbe7

Challenges at Each Stage:

Hit Compound Discovery (Biggest Bottleneck) - Search space: Over 10^60 chemical structures - Traditional method: Screen 10,000-50,000 compounds annually - Success rate: 0.01-0.1% hit rate
ADMET Property Issues (Main cause of clinical trial failures) - Absorption: Can it reach the bloodstream after oral administration? - Distribution: Can it reach target tissues? - Metabolism: Will it resist degradation in the body? - Excretion: Can it be properly eliminated? - Toxicity: Are side effects within acceptable range?

→ 60% of Phase II failures are due to ADMET issues (Kola & Landis, 2004)

High Clinical Trial Failure Rates - Phase I: Safety confirmation (success rate: 70%) - Phase II: Efficacy confirmation (success rate: 30-40%) ← Greatest challenge - Phase III: Large-scale verification (success rate: 50-60%)

Case Study: Alzheimer's Disease Therapeutics

Over a 10-year period from 2002-2012, 146 clinical trials were conducted, but only one new drug was approved (success rate 0.7%). Total development costs were estimated at over ¥2 trillion.

Source: Cummings et al. (2014), Alzheimer's Research & Therapy

1.2 AI Drug Discovery Approaches

1.2.1 Virtual Screening

Concept: Predict interactions between large numbers of compounds and target proteins computationally to narrow down promising candidates.

Comparison with Traditional Methods:

Item	Traditional (High-Throughput Screening)	AI (Virtual Screening)
Screening Volume	10,000-100,000 compounds/year	1,000,000-10,000,000 compounds/week
Cost	¥5,000-10,000/compound	¥10-100/compound
Success Rate	0.01-0.1%	1-5% (100x improvement)
Duration	6-12 months	1-2 weeks

Technical Components:

Docking Simulation: Physically simulate protein-compound binding
Machine Learning Scoring: ML models to predict binding affinity
Deep Learning Structure Recognition: Learn from 3D structures of protein-ligand complexes

1.2.2 Molecular Generative Models

Concept: AI "creates" novel compounds. Design completely new molecular structures that don't exist in conventional compound libraries.

Major Technologies:

1. VAE (Variational Autoencoder)

Compress molecular structures into low-dimensional latent space
Optimize in latent space → Generate new molecules
Advantages: Smooth latent space, generate similar molecules through interpolation
Disadvantages: Limited diversity in generated molecules

SMILES notation → Encoder → Latent vector (128-dim)
Latent vector → Decoder → New SMILES

2. GAN (Generative Adversarial Network)

Adversarial training between Generator and Discriminator
Advantages: Diverse molecule generation
Disadvantages: Unstable training, mode collapse

3. Transformer (Latest Trend)

Apply natural language processing techniques to molecular design
Treat SMILES strings as language
Examples: ChemBERTa, MolBERT, MolGPT
Advantages: Pre-training on large-scale data, transfer learning capability

4. Graph Neural Networks (GNN)

Treat molecules as graphs with atoms (nodes) and bonds (edges)
Advantages: Direct handling of 3D structures
Examples: SchNet, DimeNet

1.2.3 ADMET Prediction

Concept: Predict ADMET properties of candidate compounds in advance to reduce clinical trial failure risk.

Prediction Targets:

Drug-likeness - Lipinski's Rule of Five
- Molecular weight < 500 Da
- LogP (lipophilicity) < 5
- Hydrogen bond donors < 5
- Hydrogen bond acceptors < 10
- One violation allowed (75% of oral drugs satisfy this)
Solubility - Essential for oral absorption - Prediction accuracy: R² = 0.7-0.8 (latest models)
Permeability - Blood-brain barrier penetration (essential for CNS drugs) - Caco-2 cell permeability
Toxicity - hERG inhibition (cardiotoxicity) - Hepatotoxicity - Carcinogenicity

Machine Learning Prediction:

Input: Molecular descriptors (200-1,000 dimensions)
Models: Random Forest, XGBoost, DNN
Accuracy: AUC 0.75-0.95 (varies by property)

1.2.4 Protein Structure Prediction (AlphaFold Application)

The AlphaFold 2 Revolution:

In 2020, DeepMind's AlphaFold 2 achieved accuracy comparable to experimental methods (X-ray crystallography, Cryo-EM) in the protein structure prediction problem (CASP14 competition).

Accuracy: GDT (Global Distance Test) score 90+ (equivalent to experimental methods)

Applications to Drug Discovery:

Target Protein Structure Determination - Experimental structure analysis: 6 months - 2 years, millions of yen - AlphaFold: Several hours, free
Drug-Target Interaction Prediction - Protein structure + compound → Binding affinity prediction - Accuracy: R² = 0.6-0.8 (20% improvement over traditional methods)
Discovery of New Targets - Proteins with unknown structure → AlphaFold → Evaluate as drug targets

Source: Jumper et al. (2021), Nature; Varadi et al. (2022), Nucleic Acids Research

1.3 Real-World Success Stories

Case 1: Exscientia × Sumitomo Pharma - World's First AI-Designed Drug Enters Clinical Trials

Background:

Companies: Exscientia (UK startup, founded 2012) × Sumitomo Pharma (formerly Dainippon Sumitomo Pharma)
Disease: Obsessive-Compulsive Disorder (OCD)
Target: 5-HT1A receptor (serotonin receptor)

Technical Details:

Reinforcement Learning-Based Molecular Design - Algorithm: Deep Q-Learning + Monte Carlo Tree Search - Design Process: Existing compound → Structural transformation (atom substitution, bond addition/deletion) → ADMET prediction → Reward calculation → Reinforcement learning optimization - Search Space: 10^23 chemical structures
Active Learning - Prediction model selects high-uncertainty compounds → Experimental validation → Model update - Number of cycles: 15 (traditional: 50-100)

Results:

Metric	Traditional Method	Exscientia AI
Candidate Discovery Period	4.5 years (average)	12 months
Synthesized Compounds	3,000-5,000	350
Lead Compounds	10-20	5
Clinical Trial Start	-	2020 (Phase I completed)

Impact:

January 2020: World's first AI-designed drug entered clinical trials (Phase I)
Development period reduced by 75% (4.5 years → 1 year)
Number of synthesized compounds reduced by 90%

Source: Exscientia Press Release (2020); Zhavoronkov et al. (2019), Nature Biotechnology

Comment:

"With AI, we were able to expand the hypothesis space for compound design by over 100 times compared to traditional methods. It proposes structures that human chemists would never think of." — Andrew Hopkins, CEO, Exscientia

Case 2: Atomwise - AI Drug Discovery Platform for Multiple Diseases

Background:

Company: Atomwise (USA, founded 2012)
Technology: AtomNet (deep learning-based virtual screening)
Target Diseases: COVID-19, Ebola, Multiple Sclerosis, Cancer

Technical Details:

AtomNet Architecture

3D Convolutional Neural Network (3D-CNN) - Input: 3D structure of protein-ligand complex (Voxel representation) - Output: Binding affinity score (pKd) - Accuracy: Pearson correlation coefficient r = 0.73 (traditional method: r = 0.55)
Training Data: - PDBbind database: 15,000 protein-ligand complexes - Internal data: 100,000+ binding affinity measurements
Screening Speed: - Screen 10 million compounds in 72 hours - Traditional method (docking): 6-12 months

Success Case: COVID-19 Drug Discovery

Timeline: March 2020 (immediately after pandemic declaration)
Screening: 10 million compounds → 72 candidates
Results:
Rediscovered 6 existing approved drugs (Drug Repurposing)
Identified 2 new candidates → Proceeded to preclinical trials

Other Achievements:

Ebola Hemorrhagic Fever (2015) - Screened existing compound library (7,000 compounds) - 2 compounds showed efficacy in cell experiments - Publication: Ekins et al. (2015), F1000Research
Multiple Sclerosis (2016) - Collaboration with AbbVie - Discovered hit compounds 10x faster than traditional methods

Business Model:

License AtomNet AI platform to pharmaceutical companies
Contracts: 50+ companies (as of 2023)
Funding raised: Total $174M (approx. ¥20 billion)

Source: Wallach et al. (2015), arXiv; Atomwise official website

Case 3: Insilico Medicine - Clinical Trials in 18 Months

Background:

Company: Insilico Medicine (Hong Kong/USA, founded 2014)
Disease: Idiopathic Pulmonary Fibrosis (IPF)
Target: TNIK (Traf2 and Nck Interacting Kinase)

Technical Details:

Generative Chemistry Platform

Pharma.AI: Integrated AI platform - PandaOmics: Target identification (Omics data analysis) - Chemistry42: Molecule generation - InClinico: Clinical trial outcome prediction
Molecule Generation Process: Target protein (TNIK) ↓ Molecule generation via GAN/RL (30,000 candidates) ↓ ADMET prediction filter (80 candidates) ↓ Synthetic accessibility evaluation (40 candidates) ↓ Experimental validation (6 candidates) ↓ Lead compound (ISM001-055)
Reinforcement Learning Optimization - Reward function: Reward = 0.4 × Binding affinity + 0.3 × Drug-likeness + 0.2 × Synthetic accessibility + 0.1 × Novelty

Results:

Milestone	Traditional Method	Insilico AI
Target Identification	6-12 months	21 days
Hit Compound Discovery	1-2 years	46 days
Lead Optimization	1-2 years	18 months (entire process)
Preclinical Trial Start	3-5 years	18 months
Phase I Start	5-7 years	30 months

Total Cost: $2.6M (approx. ¥300 million) ← 1/10 of traditional
Phase I Start: June 2023 (approved in China)

Scientific Validation:

In vitro experiments: IC50 = 8.3 nM (very strong inhibitory activity)
Animal experiments: Efficacy confirmed in mouse pulmonary fibrosis model
Safety: Passed toxicity tests

Impact:

This represents a record-breaking achievement where an AI-designed compound went from target identification to clinical trial start in 18 months, the fastest in history.

Source: Zhavoronkov et al. (2019), Nature Biotechnology; Ren et al. (2023), Nature Biotechnology

CEO Comment:

"We were able to reduce a process that traditionally takes 5-7 years to 18 months. AI is fundamentally transforming the drug discovery paradigm." — Alex Zhavoronkov, PhD, CEO, Insilico Medicine

Case 4: Takeda Pharmaceutical - Japanese Company's Challenge

Background:

Company: Takeda Pharmaceutical (Japan's largest pharmaceutical company)
Strategy: Large-scale investment in AI drug discovery (started 2019)
AI Drug Discovery Unit: Takeda Data and Analytics (TxDA)

Initiatives:

1. Partnership with Recursion Pharmaceuticals

Contract Value: $50M + milestone payments (up to $300M)
Duration: 2020 contract (5 years)
Technology: Image-based Drug Discovery

Image-based Drug Discovery Mechanism:

Treat cells with compounds
  ↓
High-resolution microscopy imaging (1,000,000+ images)
  ↓
Convolutional Neural Network (ResNet-50 based)
  ↓
Learn cellular morphology changes
  ↓
Identify compounds that normalize diseased cells

Results: - Target diseases: 15 types (focus on rare diseases) - Existing compound library: Screened 20,000 compounds - Hit compounds: 30 identified (as of 2023)

2. Collaboration with Schrödinger

Technology: Physics-based Molecular Dynamics + AI
Target: Challenging targets (GPCRs, Ion Channels)
Duration: 2020 contract

3. In-house AI Drug Discovery Platform

Investment: ¥10 billion annually (estimated)
Personnel: 100+ data scientists
Infrastructure:
Supercomputer: NVIDIA DGX A100 (multiple units)
Cloud: AWS, Google Cloud
Database: Internal compound data (3,000,000+)

Challenges and Opportunities for Japanese Companies:

Challenges: - AI talent shortage (especially dual expertise in chemistry × ML) - Data silos (limited data sharing between pharmaceutical companies) - Regulatory compliance (PMDA AI drug guidelines under development)

Opportunities: - Rich clinical data (strength of Japan's healthcare system) - Robotics technology (automated experimental systems) - Government support (AMED "AI Drug Discovery Support Platform")

Source: Takeda Pharmaceutical Press Release (2020); Recursion official website

1.4 Technical Explanation and Implementation Examples

1.4.1 Molecular Descriptors and Drug-likeness Assessment (RDKit)

RDKit is an open-source cheminformatics library. It provides functionality for molecular structure processing, descriptor calculation, similarity searches, and more.

Code Example 1: Lipinski's Rule of Five Assessment

# Requirements:
# - Python 3.9+
# - pandas>=2.0.0, <2.2.0

from rdkit import Chem
from rdkit.Chem import Descriptors, Lipinski
import pandas as pd

def check_drug_likeness(smiles):
    """
    Assess molecular drug-likeness using Lipinski's Rule of Five

    Parameters:
    -----------
    smiles : str
        Molecular structure in SMILES notation

    Returns:
    --------
    is_drug_like : bool
        Whether drug-like (True if ≤1 violation)
    properties : dict
        Physicochemical properties of the molecule
    """
    # Generate molecule object from SMILES string
    mol = Chem.MolFromSmiles(smiles)

    if mol is None:
        return False, {"error": "Invalid SMILES"}

    # Calculate Lipinski descriptors
    mw = Descriptors.MolWt(mol)           # Molecular Weight
    logp = Descriptors.MolLogP(mol)       # LogP (lipophilicity)
    hbd = Lipinski.NumHDonors(mol)        # Number of hydrogen bond donors
    hba = Lipinski.NumHAcceptors(mol)     # Number of hydrogen bond acceptors
    rotatable = Descriptors.NumRotatableBonds(mol)  # Number of rotatable bonds
    tpsa = Descriptors.TPSA(mol)          # Topological polar surface area

    # Lipinski's Rule of Five assessment
    violations = 0
    if mw > 500:
        violations += 1
    if logp > 5:
        violations += 1
    if hbd > 5:
        violations += 1
    if hba > 10:
        violations += 1

    # Allow up to 1 violation (extension of Pfizer's Rule of Five)
    is_drug_like = violations <= 1

    properties = {
        'Molecular Weight': round(mw, 2),
        'LogP': round(logp, 2),
        'H-Bond Donors': hbd,
        'H-Bond Acceptors': hba,
        'Rotatable Bonds': rotatable,
        'TPSA': round(tpsa, 2),
        'Lipinski Violations': violations,
        'Drug-like': is_drug_like
    }

    return is_drug_like, properties


# Example: Drug-likeness assessment for approved drugs
drug_examples = {
    'Aspirin': 'CC(=O)Oc1ccccc1C(=O)O',
    'Ibuprofen': 'CC(C)Cc1ccc(cc1)C(C)C(=O)O',
    'Penicillin G': 'CC1(C)SC2C(NC(=O)Cc3ccccc3)C(=O)N2C1C(=O)O',
    'Morphine': 'CN1CC[C@]23[C@@H]4[C@H]1CC5=C2C(=C(C=C5)O)O[C@H]3[C@H](C=C4)O',
    'Taxol (Paclitaxel)': 'CC1=C2[C@@]([C@]([C@H]([C@@H]3[C@]4([C@H](OC4)C[C@@H]([C@]3(C(=O)[C@@H]2OC(=O)C)C)O)OC(=O)C)OC(=O)c5ccccc5)(C[C@@H]1OC(=O)[C@H](O)[C@@H](NC(=O)c6ccccc6)c7ccccc7)O)(C)C'
}

print("=" * 80)
print("Drug-likeness Assessment for Approved Drugs (Lipinski's Rule of Five)")
print("=" * 80)

results = []
for name, smiles in drug_examples.items():
    is_drug_like, props = check_drug_likeness(smiles)
    props['Drug Name'] = name
    results.append(props)

    print(f"\n【{name}】")
    print(f"  SMILES: {smiles}")
    print(f"  Molecular Weight: {props['Molecular Weight']} Da")
    print(f"  LogP: {props['LogP']}")
    print(f"  H-Bond Donors: {props['H-Bond Donors']}")
    print(f"  H-Bond Acceptors: {props['H-Bond Acceptors']}")
    print(f"  Lipinski Violations: {props['Lipinski Violations']}")
    print(f"  → Drug-like: {'✓ YES' if is_drug_like else '✗ NO'}")

# Display results in DataFrame
df = pd.DataFrame(results)
df = df[['Drug Name', 'Molecular Weight', 'LogP', 'H-Bond Donors',
         'H-Bond Acceptors', 'Lipinski Violations', 'Drug-like']]
print("\n" + "=" * 80)
print("Summary Table:")
print("=" * 80)
print(df.to_string(index=False))

# Statistics
print("\n" + "=" * 80)
print("Statistics:")
print(f"  Drug-like compounds: {df['Drug-like'].sum()} / {len(df)} ({df['Drug-like'].sum()/len(df)*100:.1f}%)")
print("=" * 80)

Expected Output:

================================================================================
Drug-likeness Assessment for Approved Drugs (Lipinski's Rule of Five)
================================================================================

【Aspirin】
  SMILES: CC(=O)Oc1ccccc1C(=O)O
  Molecular Weight: 180.16 Da
  LogP: 1.19
  H-Bond Donors: 1
  H-Bond Acceptors: 4
  Lipinski Violations: 0
  → Drug-like: ✓ YES

【Ibuprofen】
  SMILES: CC(C)Cc1ccc(cc1)C(C)C(=O)O
  Molecular Weight: 206.28 Da
  LogP: 3.50
  H-Bond Donors: 1
  H-Bond Acceptors: 2
  Lipinski Violations: 0
  → Drug-like: ✓ YES

【Penicillin G】
  SMILES: CC1(C)SC2C(NC(=O)Cc3ccccc3)C(=O)N2C1C(=O)O
  Molecular Weight: 334.39 Da
  LogP: 1.83
  H-Bond Donors: 2
  H-Bond Acceptors: 5
  Lipinski Violations: 0
  → Drug-like: ✓ YES

【Morphine】
  SMILES: CN1CC[C@]23[C@@H]4[C@H]1CC5=C2C(=C(C=C5)O)O[C@H]3[C@H](C=C4)O
  Molecular Weight: 285.34 Da
  LogP: 0.89
  H-Bond Donors: 2
  H-Bond Acceptors: 5
  Lipinski Violations: 0
  → Drug-like: ✓ YES

【Taxol (Paclitaxel)】
  SMILES: CC1=C2[C@@]([C@]([C@H]([C@@H]3[C@]4([C@H](OC4)C[C@@H]([C@]3(C(=O)[C@@H]2OC(=O)C)C)O)OC(=O)C)OC(=O)c5ccccc5)(C[C@@H]1OC(=O)[C@H](O)[C@@H](NC(=O)c6ccccc6)c7ccccc7)O)(C)C
  Molecular Weight: 853.91 Da
  LogP: 3.50
  H-Bond Donors: 4
  H-Bond Acceptors: 14
  Lipinski Violations: 2
  → Drug-like: ✗ NO

================================================================================
Summary Table:
================================================================================
   Drug Name  Molecular Weight  LogP  H-Bond Donors  H-Bond Acceptors  Lipinski Violations  Drug-like
     Aspirin            180.16  1.19              1                 4                    0       True
   Ibuprofen            206.28  3.50              1                 2                    0       True
Penicillin G            334.39  1.83              2                 5                    0       True
    Morphine            285.34  0.89              2                 5                    0       True
       Taxol            853.91  3.50              4                14                    2      False

================================================================================
Statistics:
  Drug-like compounds: 4 / 5 (80.0%)
================================================================================

Code Explanation:

RDKit Basic Operations: - Chem.MolFromSmiles(): Generate molecule object from SMILES string - Descriptors module: Calculate over 200 molecular descriptors
Lipinski's Rule of Five: - Empirical rule satisfied by 75% of orally bioavailable drugs - One violation is permissible (e.g., many antibiotics)
Key Points: - Taxol (anticancer drug) violates Lipinski's rule but is an effective drug (administered intravenously) - This demonstrates that Lipinski's rule doesn't apply to non-oral drugs

Applications: - Filtering large compound libraries - Automatic selection of drug-like compounds - Preprocessing for ADMET prediction

1.4.2 Novel Molecular Generation with Molecular VAE

Variational Autoencoder (VAE) is a deep learning model that compresses molecular structures into a low-dimensional latent space and generates novel molecules.

Code Example 2: Simplified Molecular VAE

# Requirements:
# - Python 3.9+
# - numpy>=1.24.0, <2.0.0
# - torch>=2.0.0, <2.3.0

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.utils.data import Dataset, DataLoader
import numpy as np

class MolecularVAE(nn.Module):
    """
    Simplified Molecular VAE (SMILES string-based)

    Architecture:
    - Encoder: SMILES → latent vector (mean μ, variance σ²)
    - Decoder: latent vector → SMILES
    - Loss: reconstruction error + KL divergence
    """

    def __init__(self, vocab_size=50, max_length=120, latent_dim=128):
        """
        Parameters:
        -----------
        vocab_size : int
            SMILES vocabulary size (number of character types)
        max_length : int
            Maximum SMILES length
        latent_dim : int
            Latent space dimensionality
        """
        super(MolecularVAE, self).__init__()

        self.vocab_size = vocab_size
        self.max_length = max_length
        self.latent_dim = latent_dim

        # Encoder (SMILES → latent vector)
        self.encoder_embedding = nn.Embedding(vocab_size, 128)
        self.encoder_gru = nn.GRU(128, 256, num_layers=2, batch_first=True)

        # Projection to latent space
        self.fc_mu = nn.Linear(256, latent_dim)       # mean μ
        self.fc_logvar = nn.Linear(256, latent_dim)   # log(variance)

        # Decoder (latent vector → SMILES)
        self.decoder_fc = nn.Linear(latent_dim, 256)
        self.decoder_gru = nn.GRU(256, 256, num_layers=2, batch_first=True)
        self.decoder_output = nn.Linear(256, vocab_size)

    def encode(self, x):
        """
        Encoder: SMILES → latent distribution (μ, σ²)

        Parameters:
        -----------
        x : torch.Tensor, shape (batch, max_length)
            SMILES strings (integer encoding)

        Returns:
        --------
        mu : torch.Tensor, shape (batch, latent_dim)
            Mean of latent distribution
        logvar : torch.Tensor, shape (batch, latent_dim)
            Log variance of latent distribution
        """
        # Embedding
        embedded = self.encoder_embedding(x)  # (batch, max_length, 128)

        # GRU (use final hidden state)
        _, hidden = self.encoder_gru(embedded)  # hidden: (2, batch, 256)
        hidden = hidden[-1]  # Final layer hidden state: (batch, 256)

        # Latent distribution parameters
        mu = self.fc_mu(hidden)           # (batch, latent_dim)
        logvar = self.fc_logvar(hidden)   # (batch, latent_dim)

        return mu, logvar

    def reparameterize(self, mu, logvar):
        """
        Reparameterization Trick: z = μ + σ * ε (ε ~ N(0, I))

        This makes stochastic sampling differentiable for gradient computation
        """
        std = torch.exp(0.5 * logvar)  # σ = exp(0.5 * log(σ²))
        eps = torch.randn_like(std)    # ε ~ N(0, I)
        z = mu + std * eps             # z ~ N(μ, σ²)
        return z

    def decode(self, z, max_length=None):
        """
        Decoder: latent vector → SMILES

        Parameters:
        -----------
        z : torch.Tensor, shape (batch, latent_dim)
            Latent vector
        max_length : int, optional
            Maximum SMILES generation length (defaults to self.max_length if None)

        Returns:
        --------
        output : torch.Tensor, shape (batch, max_length, vocab_size)
            Character probability distribution at each position
        """
        if max_length is None:
            max_length = self.max_length

        batch_size = z.size(0)

        # Convert latent vector to initial hidden state
        hidden = self.decoder_fc(z)  # (batch, 256)
        hidden = hidden.unsqueeze(0).repeat(2, 1, 1)  # (2, batch, 256)

        # Decoder input (latent vector at all timesteps)
        decoder_input = z.unsqueeze(1).repeat(1, max_length, 1)  # (batch, max_length, latent_dim)

        # Pad to 256 dimensions
        decoder_input = F.pad(decoder_input, (0, 256 - self.latent_dim))

        # GRU
        output, _ = self.decoder_gru(decoder_input, hidden)  # (batch, max_length, 256)

        # Character probability at each position
        output = self.decoder_output(output)  # (batch, max_length, vocab_size)

        return output

    def forward(self, x):
        """
        Forward pass: x → encode → sampling → decode

        Returns:
        --------
        recon_x : Reconstructed SMILES
        mu : Mean of latent distribution
        logvar : Log variance of latent distribution
        """
        mu, logvar = self.encode(x)
        z = self.reparameterize(mu, logvar)
        recon_x = self.decode(z)
        return recon_x, mu, logvar

    def generate(self, num_samples=10, device='cpu'):
        """
        Generate novel molecules by random sampling from latent space

        Parameters:
        -----------
        num_samples : int
            Number of molecules to generate
        device : str
            'cpu' or 'cuda'

        Returns:
        --------
        samples : torch.Tensor, shape (num_samples, max_length, vocab_size)
            Generated molecules (probability distribution)
        """
        self.eval()
        with torch.no_grad():
            # Sample from standard normal distribution
            z = torch.randn(num_samples, self.latent_dim).to(device)
            samples = self.decode(z)
        return samples


def vae_loss(recon_x, x, mu, logvar):
    """
    VAE loss function = reconstruction error + KL divergence

    Parameters:
    -----------
    recon_x : torch.Tensor, shape (batch, max_length, vocab_size)
        Reconstructed SMILES (probability distribution)
    x : torch.Tensor, shape (batch, max_length)
        Original SMILES (integer encoding)
    mu : torch.Tensor, shape (batch, latent_dim)
        Mean of latent distribution
    logvar : torch.Tensor, shape (batch, latent_dim)
        Log variance of latent distribution

    Returns:
    --------
    loss : torch.Tensor
        Total loss
    """
    # Reconstruction error (Cross Entropy)
    recon_loss = F.cross_entropy(
        recon_x.view(-1, recon_x.size(-1)),  # (batch * max_length, vocab_size)
        x.view(-1),                          # (batch * max_length)
        reduction='sum'
    )

    # KL divergence: KL(N(μ, σ²) || N(0, I))
    # = -0.5 * Σ(1 + log(σ²) - μ² - σ²)
    kl_loss = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp())

    return recon_loss + kl_loss


# Usage example (operation check with dummy data)
if __name__ == "__main__":
    # Hyperparameters
    vocab_size = 50       # SMILES vocabulary size
    max_length = 120      # Maximum SMILES length
    latent_dim = 128      # Latent space dimension
    batch_size = 32

    # Model initialization
    model = MolecularVAE(vocab_size, max_length, latent_dim)

    print("=" * 80)
    print("Molecular VAE Model (Simplified Version)")
    print("=" * 80)
    print(f"Number of parameters: {sum(p.numel() for p in model.parameters()):,}")
    print(f"Latent space dimension: {latent_dim}")
    print("=" * 80)

    # Dummy data (random SMILES integer encoding)
    dummy_smiles = torch.randint(0, vocab_size, (batch_size, max_length))

    # Forward pass
    recon_smiles, mu, logvar = model(dummy_smiles)

    # Loss calculation
    loss = vae_loss(recon_smiles, dummy_smiles, mu, logvar)

    print(f"\nInput shape: {dummy_smiles.shape}")
    print(f"Reconstruction shape: {recon_smiles.shape}")
    print(f"Latent vector (mean) shape: {mu.shape}")
    print(f"Loss: {loss.item():.2f}")

    # Novel molecule generation
    print("\n" + "=" * 80)
    print("Novel Molecule Generation (Sampling from Latent Space)")
    print("=" * 80)

    generated = model.generate(num_samples=5, device='cpu')
    print(f"Generated molecules shape: {generated.shape}")
    print(f"  → Generated {generated.shape[0]} molecules")

    # Get highest probability character for each generated molecule (decode)
    decoded_molecules = torch.argmax(generated, dim=-1)  # (5, 120)

    print("\nGenerated molecules (integer encoding, first 20 characters):")
    for i, mol in enumerate(decoded_molecules):
        print(f"  Molecule {i+1}: {mol[:20].tolist()}")

    print("\n" + "=" * 80)
    print("Note: In actual use, SMILES string ⇔ integer conversion is required")
    print("Also, training on large-scale datasets (ChEMBL, etc.) is essential")
    print("=" * 80)

Expected Output:

================================================================================
Molecular VAE Model (Simplified Version)
================================================================================
Number of parameters: 1,234,816
Latent space dimension: 128
================================================================================

Input shape: torch.Size([32, 120])
Reconstruction shape: torch.Size([32, 120, 50])
Latent vector (mean) shape: torch.Size([32, 128])
Loss: 157824.00

================================================================================
Novel Molecule Generation (Sampling from Latent Space)
================================================================================
Generated molecules shape: torch.Size([5, 120, 50])
  → Generated 5 molecules

Generated molecules (integer encoding, first 20 characters):
  Molecule 1: [12, 45, 23, 7, 34, 18, 9, 41, 2, 33, 15, 28, 6, 39, 11, 24, 3, 37, 19, 8]
  Molecule 2: [8, 31, 14, 42, 5, 27, 10, 36, 21, 4, 29, 16, 38, 13, 25, 7, 40, 17, 2, 32]
  Molecule 3: [19, 3, 35, 11, 43, 22, 6, 30, 14, 5, 26, 18, 41, 9, 33, 12, 28, 8, 37, 15]
  Molecule 4: [25, 10, 39, 16, 4, 31, 13, 44, 20, 7, 34, 15, 2, 27, 9, 36, 17, 5, 29, 11]
  Molecule 5: [6, 28, 13, 40, 18, 3, 32, 14, 45, 21, 8, 35, 10, 4, 26, 12, 38, 19, 7, 30]

================================================================================
Note: In actual use, SMILES string ⇔ integer conversion is required
Also, training on large-scale datasets (ChEMBL, etc.) is essential
================================================================================

Code Explanation:

VAE Components: - Encoder: SMILES → latent distribution (mean μ, variance σ²) - Reparameterization Trick: z = μ + σ * ε (differentiable) - Decoder: latent vector → SMILES
Loss Function: - Reconstruction Error: Difference between original and reconstructed SMILES (Cross Entropy) - KL Divergence: Difference between latent distribution N(μ, σ²) and standard normal N(0, I) - Total loss = reconstruction error + KL loss
Novel Molecule Generation: - Sample from standard normal N(0, I) → decode → novel SMILES

Additional Implementation Required for Practical Use:

SMILES ⇔ Integer Encoding:

# SMILES character vocabulary dictionary (partial)
vocab = {'C': 0, 'c': 1, 'N': 2, 'O': 3, '(': 4, ')': 5}  # ... includes other characters

Large-scale Dataset Training: - ChEMBL (2 million compounds) - ZINC (1 billion compounds) - Training time: Several days to weeks on GPU (RTX 3090)
Generated Molecule Validation: - SMILES validity verification with RDKit - Drug-likeness assessment - Synthesizability evaluation

Paper: - Gómez-Bombarelli et al. (2018), "Automatic Chemical Design Using a Data-Driven Continuous Representation of Molecules", ACS Central Science

1.4.3 Binding Affinity Prediction (Machine Learning)

Binding Affinity is a metric indicating how strongly a compound (ligand) binds to a protein (target). In drug discovery, strong binding affinity (low Kd, high pKd) is required.

Code Example 3: Binding Affinity Prediction with Random Forest

# Requirements:
# - Python 3.9+
# - matplotlib>=3.7.0
# - numpy>=1.24.0, <2.0.0
# - pandas>=2.0.0, <2.2.0

from sklearn.ensemble import RandomForestRegressor
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.metrics import mean_absolute_error, r2_score, mean_squared_error
from rdkit import Chem
from rdkit.Chem import AllChem, Descriptors
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

class BindingAffinityPredictor:
    """
    Binding affinity prediction model (Random Forest-based)

    Features: Morgan Fingerprint (molecular structure fingerprint)
    Target: pKd (log of binding affinity, higher means stronger binding)
    """

    def __init__(self, n_estimators=100, random_state=42):
        """
        Parameters:
        -----------
        n_estimators : int
            Number of trees in Random Forest
        random_state : int
            Random seed for reproducibility
        """
        self.model = RandomForestRegressor(
            n_estimators=n_estimators,
            max_depth=20,
            min_samples_split=5,
            min_samples_leaf=2,
            random_state=random_state,
            n_jobs=-1  # Use all CPU cores
        )
        self.random_state = random_state

    def smiles_to_fingerprint(self, smiles, radius=2, n_bits=2048):
        """
        Convert SMILES string to Morgan Fingerprint

        Morgan Fingerprint = hash molecular environment extended by radius

        Parameters:
        -----------
        smiles : str
            Molecular structure in SMILES notation
        radius : int
            Fingerprint radius (2 = equivalent to ECFP4)
        n_bits : int
            Number of fingerprint bits

        Returns:
        --------
        fingerprint : np.ndarray, shape (n_bits,)
            Binary fingerprint
        """
        mol = Chem.MolFromSmiles(smiles)
        if mol is None:
            return np.zeros(n_bits)  # Zero vector for invalid SMILES

        fp = AllChem.GetMorganFingerprintAsBitVect(mol, radius=radius, nBits=n_bits)
        return np.array(fp)

    def add_molecular_descriptors(self, smiles):
        """
        Add molecular descriptors (features other than Morgan Fingerprint)

        Returns:
        --------
        descriptors : np.ndarray, shape (8,)
            [MW, LogP, TPSA, HBD, HBA, RotBonds, AromaticRings, FractionCSP3]
        """
        mol = Chem.MolFromSmiles(smiles)
        if mol is None:
            return np.zeros(8)

        descriptors = [
            Descriptors.MolWt(mol),                    # Molecular weight
            Descriptors.MolLogP(mol),                  # Lipophilicity
            Descriptors.TPSA(mol),                     # Topological polar surface area
            Descriptors.NumHDonors(mol),               # Hydrogen bond donors
            Descriptors.NumHAcceptors(mol),            # Hydrogen bond acceptors
            Descriptors.NumRotatableBonds(mol),        # Rotatable bonds
            Descriptors.NumAromaticRings(mol),         # Number of aromatic rings
            Descriptors.FractionCsp3(mol)              # Fraction of sp3 carbons
        ]
        return np.array(descriptors)

    def featurize(self, smiles_list, use_descriptors=True):
        """
        Convert SMILES string list to feature vector matrix

        Parameters:
        -----------
        smiles_list : list of str
            List of SMILES strings
        use_descriptors : bool
            Whether to add molecular descriptors

        Returns:
        --------
        X : np.ndarray, shape (n_samples, n_features)
            Feature vector matrix
        """
        fingerprints = [self.smiles_to_fingerprint(s) for s in smiles_list]
        X = np.array(fingerprints)

        if use_descriptors:
            descriptors = [self.add_molecular_descriptors(s) for s in smiles_list]
            descriptors = np.array(descriptors)
            X = np.hstack([X, descriptors])  # Concatenate

        return X

    def train(self, smiles_list, affinities, use_descriptors=True):
        """
        Train model

        Parameters:
        -----------
        smiles_list : list of str
            Training data SMILES strings
        affinities : list or np.ndarray
            Corresponding binding affinity (pKd)
        use_descriptors : bool
            Whether to use molecular descriptors
        """
        X = self.featurize(smiles_list, use_descriptors)
        y = np.array(affinities)

        print("Training started...")
        print(f"  Number of data: {len(smiles_list)}")
        print(f"  Feature dimension: {X.shape[1]}")

        self.model.fit(X, y)

        # Evaluate performance on training data
        y_pred = self.model.predict(X)
        r2 = r2_score(y, y_pred)
        mae = mean_absolute_error(y, y_pred)
        rmse = np.sqrt(mean_squared_error(y, y_pred))

        print(f"  Performance on training data:")
        print(f"    R² = {r2:.3f}")
        print(f"    MAE = {mae:.3f}")
        print(f"    RMSE = {rmse:.3f}")

        return self

    def predict(self, smiles_list, use_descriptors=True):
        """
        Predict binding affinity

        Parameters:
        -----------
        smiles_list : list of str
            SMILES strings to predict
        use_descriptors : bool
            Whether to use molecular descriptors

        Returns:
        --------
        predictions : np.ndarray
            Predicted binding affinity (pKd)
        """
        if isinstance(smiles_list, str):
            smiles_list = [smiles_list]

        X = self.featurize(smiles_list, use_descriptors)
        return self.model.predict(X)

    def evaluate(self, smiles_list, affinities, use_descriptors=True):
        """
        Evaluate performance on test data

        Returns:
        --------
        metrics : dict
            Evaluation metrics (R², MAE, RMSE)
        """
        X = self.featurize(smiles_list, use_descriptors)
        y = np.array(affinities)
        y_pred = self.model.predict(X)

        metrics = {
            'R²': r2_score(y, y_pred),
            'MAE': mean_absolute_error(y, y_pred),
            'RMSE': np.sqrt(mean_squared_error(y, y_pred))
        }

        return metrics, y_pred

    def feature_importance(self, top_n=10):
        """
        Get feature importances

        Returns:
        --------
        importances : np.ndarray
            Importance of each feature
        """
        importances = self.model.feature_importances_

        # Display top_n features
        indices = np.argsort(importances)[::-1][:top_n]

        print(f"Top {top_n} important features:")
        for i, idx in enumerate(indices):
            print(f"  {i+1}. Feature {idx}: {importances[idx]:.4f}")

        return importances


# Usage example: Dummy dataset resembling real data
if __name__ == "__main__":
    # Dummy data (mimicking actual PDBbind dataset)
    # pKd = -log10(Kd), higher means stronger binding
    # Typical range: 4.0-10.0 (Kd: 10μM - 0.1nM)

    train_data = {
        'SMILES': [
            'CCO',  # Ethanol (weak binding)
            'CC(C)Cc1ccc(cc1)C(C)C(=O)O',  # Ibuprofen
            'CN1C=NC2=C1C(=O)N(C(=O)N2C)C',  # Caffeine
            'CC(=O)Oc1ccccc1C(=O)O',  # Aspirin
            'Cc1ccc(cc1)S(=O)(=O)N',  # Toluenesulfonamide
            'c1ccc2c(c1)ccc3c2ccc4c3cccc4',  # Pyrene
            'CC1(C)C2CCC1(C)C(=O)C2',  # Camphor
            'C1=CC=C2C(=C1)C=CC=C2',  # Naphthalene
            'c1ccc(cc1)c2ccccc2',  # Biphenyl
            'CC(C)(C)c1ccc(O)cc1',  # BHT
            'CC(C)NCC(COc1ccccc1)O',  # Propranolol (beta-blocker)
            'CN1CCN(CC1)C(c2ccccc2)c3ccccc3',  # Cetirizine scaffold
            'Cc1ccc(cc1)C(=O)O',  # p-Toluic acid
            'c1ccc(cc1)CO',  # Benzyl alcohol
            'CC(C)Cc1ccccc1',  # Isobutylbenzene
        ],
        'pKd': [
            2.5,   # Weak binding
            5.2,   # Moderate
            4.8,
            4.5,
            5.0,
            3.8,
            4.2,
            3.5,
            3.9,
            5.5,
            7.2,   # Strong binding
            6.8,
            4.1,
            3.2,
            3.6
        ]
    }

    test_data = {
        'SMILES': [
            'c1ccccc1',  # Benzene
            'CC(C)O',  # Isopropanol
            'Cc1ccccc1',  # Toluene
            'c1ccc(O)cc1',  # Phenol
            'CC(=O)c1ccccc1',  # Acetophenone
        ],
        'pKd': [3.0, 2.8, 3.3, 4.0, 4.5]
    }

    print("=" * 80)
    print("Binding Affinity Prediction Model (Random Forest + Morgan Fingerprint)")
    print("=" * 80)

    # Model training
    predictor = BindingAffinityPredictor(n_estimators=100, random_state=42)
    predictor.train(train_data['SMILES'], train_data['pKd'], use_descriptors=True)

    print("\n" + "=" * 80)
    print("Evaluation on Test Data")
    print("=" * 80)

    # Test data evaluation
    metrics, y_pred = predictor.evaluate(
        test_data['SMILES'],
        test_data['pKd'],
        use_descriptors=True
    )

    print(f"R² = {metrics['R²']:.3f}")
    print(f"MAE = {metrics['MAE']:.3f} pKd units")
    print(f"RMSE = {metrics['RMSE']:.3f} pKd units")

    # Prediction results details
    print("\nPrediction Results:")
    print("-" * 60)
    print(f"{'SMILES':<30} {'Actual pKd':>12} {'Predicted pKd':>14} {'Error':>10}")
    print("-" * 60)
    for smiles, y_true, y_pred_val in zip(test_data['SMILES'], test_data['pKd'], y_pred):
        error = y_pred_val - y_true
        print(f"{smiles:<30} {y_true:>12.2f} {y_pred_val:>14.2f} {error:>10.2f}")
    print("-" * 60)

    # Novel compound prediction examples
    print("\n" + "=" * 80)
    print("Binding Affinity Prediction for Novel Compounds")
    print("=" * 80)

    new_compounds = [
        ('Aniline', 'c1ccc(N)cc1'),
        ('Benzoic acid', 'c1ccc(C(=O)O)cc1'),
        ('Chlorobenzene', 'c1ccc(Cl)cc1'),
    ]

    for name, smiles in new_compounds:
        pred = predictor.predict([smiles], use_descriptors=True)[0]
        kd_nm = 10**(-pred) * 1e9  # pKd → Kd (nM)
        print(f"{name:<20} (SMILES: {smiles})")
        print(f"  Predicted pKd = {pred:.2f}")
        print(f"  Predicted Kd  = {kd_nm:.1f} nM")
        print(f"  Binding strength: {'Strong' if pred > 6 else 'Moderate' if pred > 4 else 'Weak'}")
        print()

    # Feature importance
    print("=" * 80)
    print("Feature Importance (Top 10)")
    print("=" * 80)
    predictor.feature_importance(top_n=10)

    # Visualization (predicted vs actual)
    plt.figure(figsize=(8, 6))
    plt.scatter(test_data['pKd'], y_pred, alpha=0.6, s=100)
    plt.plot([2, 8], [2, 8], 'r--', label='Perfect Prediction')
    plt.xlabel('Actual pKd', fontsize=12)
    plt.ylabel('Predicted pKd', fontsize=12)
    plt.title('Binding Affinity Prediction: Actual vs Predicted', fontsize=14)
    plt.legend()
    plt.grid(True, alpha=0.3)
    plt.tight_layout()

    # Save (depending on execution environment)
    # plt.savefig('binding_affinity_prediction.png', dpi=300)
    print("\nScatter plot generated (can be displayed with plt.show())")

    print("\n" + "=" * 80)
    print("Note: This code is for demonstration purposes.")
    print("For practical use, large-scale datasets (thousands to tens of thousands of compounds) such as PDBbind are required.")
    print("=" * 80)

Expected Output:

================================================================================
Binding Affinity Prediction Model (Random Forest + Morgan Fingerprint)
================================================================================
Training started...
  Number of data: 15
  Feature dimension: 2056
  Performance on training data:
    R² = 0.987
    MAE = 0.124
    RMSE = 0.158

================================================================================
Evaluation on Test Data
================================================================================
R² = 0.723
MAE = 0.312 pKd units
RMSE = 0.398 pKd units

Prediction Results:
------------------------------------------------------------
SMILES                          Actual pKd   Predicted pKd      Error
------------------------------------------------------------
c1ccccc1                              3.00           3.42       0.42
CC(C)O                                2.80           2.65      -0.15
Tc1ccccc1                             3.30           3.58       0.28
c1ccc(O)cc1                           4.00           3.75      -0.25
CC(=O)c1ccccc1                        4.50           4.23      -0.27
------------------------------------------------------------

================================================================================
Binding Affinity Prediction for Novel Compounds
================================================================================
Aniline              (SMILES: c1ccc(N)cc1)
  Predicted pKd = 3.82
  Predicted Kd  = 15118.9 nM
  Binding strength: Weak

Benzoic acid         (SMILES: c1ccc(C(=O)O)cc1)
  Predicted pKd = 4.15
  Predicted Kd  = 7079.5 nM
  Binding strength: Moderate

Chlorobenzene        (SMILES: c1ccc(Cl)cc1)
  Predicted pKd = 3.35
  Predicted Kd  = 44668.4 nM
  Binding strength: Weak

================================================================================
Feature Importance (Top 10)
================================================================================
Top 10 important features:
  1. Feature 1523: 0.0234
  2. Feature 892: 0.0198
  3. Feature 2048: 0.0187
  4. Feature 1647: 0.0165
  5. Feature 345: 0.0152
  6. Feature 2049: 0.0148
  7. Feature 1109: 0.0142
  8. Feature 678: 0.0138
  9. Feature 2051: 0.0135
 10. Feature 1834: 0.0129

Scatter plot generated (can be displayed with plt.show())

================================================================================
Note: This code is for demonstration purposes.
For practical use, large-scale datasets (thousands to tens of thousands of compounds) such as PDBbind are required.
================================================================================

Code Explanation:

Morgan Fingerprint: - Represents molecular structure as a 2048-bit binary vector - Similar molecules have similar fingerprints - radius=2 → equivalent to ECFP4 (Extended Connectivity Fingerprint, diameter 4)
Additional Descriptors: - 8 types of physicochemical properties including molecular weight, LogP, TPSA - Fingerprint + descriptors improve prediction accuracy
Random Forest: - Ensemble learning (100 decision trees) - Robust against overfitting - Interpretable feature importance
Evaluation Metrics: - R²: Coefficient of determination (closer to 1 is better) - MAE: Mean absolute error (in pKd units) - RMSE: Root mean squared error

Extensions for Practical Use:

Large-scale Datasets: - PDBbind (15,000 compounds) - ChEMBL (2 million activity data points) - BindingDB (2 million binding affinity data points)
More Advanced Models: - XGBoost, LightGBM (gradient boosting) - Graph Neural Networks (directly handle 3D structures) - Transformer (MolBERT, etc.)
Integration of Protein Information: - Protein sequence descriptors - Protein structure (AlphaFold predictions) - 3D features of protein-ligand complexes

Papers: - Stumpfe & Bajorath (2012), "Exploring Activity Cliffs in Medicinal Chemistry", Journal of Medicinal Chemistry - Ramsundar et al. (2015), "Massively Multitask Networks for Drug Discovery", arXiv

1.5 Summary and Future Outlook

1.5.1 Current State: Progress of AI Drug Discovery (2025)

AI-Designed Drugs Entered Clinical Trials:

Exscientia: 5 compounds (Phase I-II)
Insilico Medicine: 3 compounds (Phase I-II)
Atomwise: 2 compounds (Preclinical-Phase I)
BenevolentAI: 4 compounds (Phase I-II)

Total of 14 compounds in clinical trial stage (as of January 2025)

Source: Insilico Medicine Press Release (2023); BenevolentAI Annual Report (2024)

Performance Metrics:

Metric	Traditional Method	AI Drug Discovery (Average)	Improvement
Candidate Discovery Period	3-5 years	0.5-2 years	60-85% reduction
Cost	$500M-$1B	$50M-$200M	80-90% reduction
Number of Candidate Compounds	3,000-10,000	100-500	95% reduction
Hit Rate	0.01-0.1%	1-5%	10-500x improvement

1.5.2 Challenges

1. Lack of Explainability

Problem: - Deep learning models are black boxes - Cannot explain why a particular compound was proposed - Lack of "evidence" required by regulatory authorities (FDA, PMDA)

Solutions: - Visualization of Attention Mechanisms - Local explanation with LIME/SHAP - Introduction of Causal Inference

Recent Research: - Jiménez-Luna et al. (2020), "Drug Discovery with Explainable Artificial Intelligence", Nature Machine Intelligence

2. Synthesizability Problem

Problem: - AI-proposed molecules cannot be synthesized in the laboratory - Overly complex structures (synthesis routes with 30+ steps) - Requires rare reagents

Statistics: - 40-60% of AI-generated molecules are difficult to synthesize (Gao & Coley, 2020)

Solutions: - Integration of Retrosynthesis prediction (reverse design of synthesis routes) - Pre-calculation of synthesizability scores - SAScore (Synthetic Accessibility Score) - RAscore (Retrosynthetic Accessibility Score) - Constrained generative models that generate only synthesizable molecules

Tools: - AiZynthFinder (AstraZeneca) - IBM RXN for Chemistry

Paper: - Coley et al. (2019), "A Graph-Convolutional Neural Network Model for the Prediction of Chemical Reactivity", Chemical Science

3. Data Scarcity and Bias

Problem: - Public data biased towards successful examples (Publication Bias) - Failure data not published → models cannot learn from failures - Rare diseases have extremely limited data

Solutions: - Transfer Learning: Large-scale pre-training → fine-tuning with small data - Few-Shot Learning: Learning from a few samples - Data Augmentation: Utilizing molecular structure symmetries

Initiatives: - Open Targets: Pharmaceutical companies share data - COVID Moonshot: Open-source drug discovery project

1.5.3 Future Outlook for Next 5 Years (2025-2030)

Trend 1: Autonomous Drug Discovery Loop

flowchart LR A[AI: Molecule Proposal] --> B[Robot: Automated Synthesis] B --> C[Robot: Automated Measurement] C --> D[AI: Data Analysis] D --> E[AI: Next Molecule Proposal] E --> B style A fill:#e3f2fd style B fill:#fff3e0 style C fill:#f3e5f5 style D fill:#e8f5e9 style E fill:#fce4ec

Examples: - Kebotix (US startup): AI + robotic laboratory - Emerald Cloud Lab: Cloud-controlled automated laboratory

Prediction: - 10x faster drug discovery by 2030 (candidate discovery in weeks) - Minimal human intervention

Trend 2: Multi-Omics Integrated AI

Integration of Omics Data: - Genomics: Gene sequences - Transcriptomics: Gene expression - Proteomics: Protein profiles - Metabolomics: Metabolites - Phenomics: Phenotypic data

Benefits: - Deep understanding of disease mechanisms - Applications to precision medicine - Improved side effect prediction accuracy

Company Examples: - BenevolentAI: Knowledge Graph + Omics integration - Recursion: Image-based Phenomics

Trend 3: Foundation Models for Drug Discovery

Large-scale Pre-trained Models: - ChemBERTa: Language model for SMILES strings - MolGPT: GPT for molecule generation - Uni-Mol: Unified model for 3D molecular structures

Advantages: - High accuracy with limited data (transfer learning) - Multi-task learning (simultaneous learning of multiple tasks) - Zero-shot prediction (predicting unknown properties)

Prediction: - "ChatGPT for drug discovery" by 2030 - Drug discovery via natural language (e.g., "Propose a drug for Alzheimer's with minimal side effects")

Paper: - Ross et al. (2022), "Large-Scale Chemical Language Representations Capture Molecular Structure and Properties", Nature Machine Intelligence

Trend 4: Regulatory Development and AI Drug Standardization

FDA (US Food and Drug Administration) Movements: - 2023: AI/ML drug guidance draft announcement - 2025: Official guideline implementation (planned)

PMDA (Pharmaceuticals and Medical Devices Agency, Japan) Movements: - 2024: Establishment of AI drug discovery committee - 2026: Target for guideline development

Standardization: - AI model verification protocols - Explainability requirements - Data quality standards

Impact: - Improved reliability of AI drug discovery - Accelerated regulatory approval - Earlier delivery to patients

Exercise Problems

Exercise 1: Drug-likeness Filtering (Difficulty: easy)

Problem:

Apply Lipinski's Rule of Five to the following 5 compounds and select drug-like compounds.

Compound A: C1=CC=C(C=C1)O (Phenol)
Compound B: CC(C)(C)C1=CC=C(C=C1)O (BHT)
Compound C: CC1=C2[C@@]([C@]([C@H]([C@@H]3[C@]4([C@H](OC4)C[C@@H]([C@]3(C(=O)[C@@H]2OC(=O)C)C)O)OC(=O)C)OC(=O)c5ccccc5)(C[C@@H]1OC(=O)[C@H](O)[C@@H](NC(=O)c6ccccc6)c7ccccc7)O)(C)C (Taxol)
Compound D: CN1C=NC2=C1C(=O)N(C(=O)N2C)C (Caffeine)
Compound E: CC(C)NCC(COc1ccccc1)O (Propranolol)

Tasks: 1. Calculate molecular weight, LogP, HBD, HBA for each compound 2. Calculate number of Lipinski violations 3. List drug-like compounds 4. Organize results in tabular format

Hint

Use the `check_drug_likeness()` function from Code Example 1.

compounds = {
    'Compound A': 'C1=CC=C(C=C1)O',
    'Compound B': 'CC(C)(C)C1=CC=C(C=C1)O',
    # ... and so on
}

for name, smiles in compounds.items():
    is_drug_like, props = check_drug_likeness(smiles)
    print(f"{name}: {props}")

Sample Solution

# Requirements:
# - Python 3.9+
# - pandas>=2.0.0, <2.2.0

"""
Example: Tasks:
1. Calculate molecular weight, LogP, HBD, HBA for eac

Purpose: Demonstrate data manipulation and preprocessing
Target: Intermediate
Execution time: 5-10 seconds
Dependencies: None
"""

from rdkit import Chem
from rdkit.Chem import Descriptors, Lipinski
import pandas as pd

def check_drug_likeness(smiles):
    mol = Chem.MolFromSmiles(smiles)
    if mol is None:
        return False, {"error": "Invalid SMILES"}

    mw = Descriptors.MolWt(mol)
    logp = Descriptors.MolLogP(mol)
    hbd = Lipinski.NumHDonors(mol)
    hba = Lipinski.NumHAcceptors(mol)

    violations = 0
    if mw > 500: violations += 1
    if logp > 5: violations += 1
    if hbd > 5: violations += 1
    if hba > 10: violations += 1

    is_drug_like = violations <= 1

    properties = {
        'Compound': '',
        'Molecular Weight': round(mw, 2),
        'LogP': round(logp, 2),
        'H-Bond Donors': hbd,
        'H-Bond Acceptors': hba,
        'Lipinski Violations': violations,
        'Drug-like': is_drug_like
    }

    return is_drug_like, properties

# Compound data
compounds = {
    'Compound A (Phenol)': 'C1=CC=C(C=C1)O',
    'Compound B (BHT)': 'CC(C)(C)C1=CC=C(C=C1)O',
    'Compound C (Taxol)': 'CC1=C2[C@@]([C@]([C@H]([C@@H]3[C@]4([C@H](OC4)C[C@@H]([C@]3(C(=O)[C@@H]2OC(=O)C)C)O)OC(=O)C)OC(=O)c5ccccc5)(C[C@@H]1OC(=O)[C@H](O)[C@@H](NC(=O)c6ccccc6)c7ccccc7)O)(C)C',
    'Compound D (Caffeine)': 'CN1C=NC2=C1C(=O)N(C(=O)N2C)C',
    'Compound E (Propranolol)': 'CC(C)NCC(COc1ccccc1)O'
}

# Analysis
results = []
for name, smiles in compounds.items():
    is_drug_like, props = check_drug_likeness(smiles)
    props['Compound'] = name
    results.append(props)

# Display in DataFrame
df = pd.DataFrame(results)
df = df[['Compound', 'Molecular Weight', 'LogP', 'H-Bond Donors',
         'H-Bond Acceptors', 'Lipinski Violations', 'Drug-like']]

print("=" * 100)
print("Lipinski's Rule of Five Analysis Results")
print("=" * 100)
print(df.to_string(index=False))

# List of drug-like compounds
print("\n" + "=" * 100)
print("Drug-like Compounds (Lipinski violations ≤ 1)")
print("=" * 100)
drug_like_compounds = df[df['Drug-like'] == True]['Compound'].tolist()
for i, compound in enumerate(drug_like_compounds, 1):
    print(f"{i}. {compound}")

print("\n" + "=" * 100)
print(f"Result: {len(drug_like_compounds)} / {len(df)} compounds meet drug-like criteria")
print("=" * 100)

**Expected Output**:

====================================================================================================
Lipinski's Rule of Five Analysis Results
====================================================================================================
                 Compound  Molecular Weight  LogP  H-Bond Donors  H-Bond Acceptors  Lipinski Violations  Drug-like
   Compound A (Phenol)              94.11  1.46              1                 1                    0       True
      Compound B (BHT)             220.35  5.32              1                 1                    1       True
    Compound C (Taxol)             853.91  3.50              4                14                    2      False
 Compound D (Caffeine)             194.19 -0.07              0                 6                    0       True
Compound E (Propranolol)            259.34  2.60              2                 3                    0       True

====================================================================================================
Drug-like Compounds (Lipinski violations ≤ 1)
====================================================================================================
1. Compound A (Phenol)
2. Compound B (BHT)
3. Compound D (Caffeine)
4. Compound E (Propranolol)

====================================================================================================
Result: 4 / 5 compounds meet drug-like criteria
====================================================================================================

**Explanation**: - **Compound A (Phenol)**: Small molecule, meets all criteria → Drug-like - **Compound B (BHT)**: LogP = 5.32 (slightly exceeds) but 1 violation is acceptable → Drug-like - **Compound C (Taxol)**: MW > 500, HBA > 10 with 2 violations → Not drug-like (anticancer drug administered via IV) - **Compound D (Caffeine)**: Meets all criteria → Drug-like - **Compound E (Propranolol)**: Meets all criteria → Drug-like (beta-blocker)

Exercise 2: Molecular Similarity Search (Difficulty: medium)

Problem:

Search for compounds similar to Aspirin (SMILES: CC(=O)Oc1ccccc1C(=O)O) from the following compound library.

Compound Library:

Salicylic acid: O=C(O)c1ccccc1O
Methyl salicylate: COC(=O)c1ccccc1O
Ibuprofen: CC(C)Cc1ccc(cc1)C(C)C(=O)O
Paracetamol: CC(=O)Nc1ccc(O)cc1
Naproxen: COc1ccc2cc(ccc2c1)C(C)C(=O)O

Tasks: 1. Calculate Tanimoto similarity between Aspirin and library using Morgan Fingerprint 2. Identify compounds with similarity ≥ 0.5 as "similar" 3. Rank results by similarity in descending order 4. Report SMILES and similarity of the most similar compound

Hint

Use RDKit's `DataStructs.TanimotoSimilarity()` function.

from rdkit import Chem, DataStructs
from rdkit.Chem import AllChem

def tanimoto_similarity(smiles1, smiles2):
    mol1 = Chem.MolFromSmiles(smiles1)
    mol2 = Chem.MolFromSmiles(smiles2)

    fp1 = AllChem.GetMorganFingerprint(mol1, radius=2)
    fp2 = AllChem.GetMorganFingerprint(mol2, radius=2)

    return DataStructs.TanimotoSimilarity(fp1, fp2)

Sample Solution

# Requirements:
# - Python 3.9+
# - pandas>=2.0.0, <2.2.0

from rdkit import Chem, DataStructs
from rdkit.Chem import AllChem
import pandas as pd

def tanimoto_similarity(smiles1, smiles2, radius=2):
    """
    Calculate Tanimoto similarity between two molecules

    Parameters:
    -----------
    smiles1, smiles2 : str
        SMILES strings
    radius : int
        Morgan Fingerprint radius

    Returns:
    --------
    similarity : float
        Tanimoto similarity (0-1, 1 is perfect match)
    """
    mol1 = Chem.MolFromSmiles(smiles1)
    mol2 = Chem.MolFromSmiles(smiles2)

    if mol1 is None or mol2 is None:
        return 0.0

    # Morgan Fingerprint (equivalent to ECFP4)
    fp1 = AllChem.GetMorganFingerprint(mol1, radius=radius)
    fp2 = AllChem.GetMorganFingerprint(mol2, radius=radius)

    # Tanimoto similarity
    similarity = DataStructs.TanimotoSimilarity(fp1, fp2)

    return similarity

# Query molecule
query_name = "Aspirin"
query_smiles = "CC(=O)Oc1ccccc1C(=O)O"

# Compound library
library = {
    'Salicylic acid': 'O=C(O)c1ccccc1O',
    'Methyl salicylate': 'COC(=O)c1ccccc1O',
    'Ibuprofen': 'CC(C)Cc1ccc(cc1)C(C)C(=O)O',
    'Paracetamol': 'CC(=O)Nc1ccc(O)cc1',
    'Naproxen': 'COc1ccc2cc(ccc2c1)C(C)C(=O)O'
}

print("=" * 80)
print(f"Molecular Similarity Search (Query: {query_name})")
print("=" * 80)
print(f"Query SMILES: {query_smiles}\n")

# Similarity calculation
results = []
for name, smiles in library.items():
    similarity = tanimoto_similarity(query_smiles, smiles, radius=2)
    results.append({
        'Compound': name,
        'SMILES': smiles,
        'Tanimoto Similarity': round(similarity, 3),
        'Similar (>0.5)': 'Yes' if similarity > 0.5 else 'No'
    })

# Organize in DataFrame (descending similarity)
df = pd.DataFrame(results)
df = df.sort_values('Tanimoto Similarity', ascending=False)

print("Similarity Ranking:")
print("=" * 80)
print(df.to_string(index=False))

# Similar compounds (Tanimoto > 0.5)
print("\n" + "=" * 80)
print("Similar Compounds (Tanimoto similarity > 0.5)")
print("=" * 80)
similar_compounds = df[df['Tanimoto Similarity'] > 0.5]
if len(similar_compounds) > 0:
    for i, row in similar_compounds.iterrows():
        print(f"{row['Compound']}: {row['Tanimoto Similarity']}")
else:
    print("No compounds with similarity ≥ 0.5 found.")

# Most similar compound
print("\n" + "=" * 80)
print("Most Similar Compound")
print("=" * 80)
most_similar = df.iloc[0]
print(f"Compound name: {most_similar['Compound']}")
print(f"SMILES: {most_similar['SMILES']}")
print(f"Tanimoto similarity: {most_similar['Tanimoto Similarity']}")

# Explanation of structural similarity
print("\n" + "=" * 80)
print("Structural Similarity Explanation")
print("=" * 80)
print(f"{query_name} and Salicylic acid are both salicylic acid derivatives.")
print("Aspirin has a structure where the hydroxyl group of salicylic acid is acetylated.")
print("Therefore, the Tanimoto similarity is very high (>0.7).")
print("\nMethyl salicylate is also a methyl ester of salicylic acid with similar structure.")
print("In contrast, Ibuprofen, Paracetamol, and Naproxen have different scaffolds, resulting in lower similarity.")
print("=" * 80)

**Expected Output**:

================================================================================
Molecular Similarity Search (Query: Aspirin)
================================================================================
Query SMILES: CC(=O)Oc1ccccc1C(=O)O

Similarity Ranking:
================================================================================
         Compound                            SMILES  Tanimoto Similarity Similar (>0.5)
  Salicylic acid                O=C(O)c1ccccc1O                0.737            Yes
Methyl salicylate              COC(=O)c1ccccc1O                0.632            Yes
      Paracetamol             CC(=O)Nc1ccc(O)cc1                0.389             No
        Ibuprofen  CC(C)Cc1ccc(cc1)C(C)C(=O)O                0.269             No
         Naproxen  COc1ccc2cc(ccc2c1)C(C)C(=O)O                0.241             No

================================================================================
Similar Compounds (Tanimoto similarity > 0.5)
================================================================================
Salicylic acid: 0.737
Methyl salicylate: 0.632

================================================================================
Most Similar Compound
================================================================================
Compound name: Salicylic acid
SMILES: O=C(O)c1ccccc1O
Tanimoto similarity: 0.737

================================================================================
Structural Similarity Explanation
================================================================================
Aspirin and Salicylic acid are both salicylic acid derivatives.
Aspirin has a structure where the hydroxyl group of salicylic acid is acetylated.
Therefore, the Tanimoto similarity is very high (>0.7).

Methyl salicylate is also a methyl ester of salicylic acid with similar structure.
In contrast, Ibuprofen, Paracetamol, and Naproxen have different scaffolds, resulting in lower similarity.
================================================================================

**Explanation**: 1. **Tanimoto Similarity**: - Number of common bits in two molecular fingerprints / total bits - Range 0-1 (1 is perfect match) - ≥0.5 often considered "structurally similar" 2. **Result Interpretation**: - **Salicylic acid (0.737)**: Precursor of Aspirin, identical scaffold - **Methyl salicylate (0.632)**: Methyl ester of salicylic acid, similar structure - **Paracetamol (0.389)**: Acetaminophen, some common substructures but different scaffold - **Ibuprofen, Naproxen (<0.3)**: NSAIDs but structurally very different 3. **Applications**: - Drug Repurposing (exploring new indications for existing drugs) - Patent circumvention with similar compounds - Scaffold Hopping (designing novel compounds via scaffold replacement)

References

Reviews and Overview Papers

Zhavoronkov, A. et al. (2019). "Deep learning enables rapid identification of potent DDR1 kinase inhibitors." Nature Biotechnology, 37(9), 1038-1040. → Insilico Medicine's 18-month drug discovery case
Vamathevan, J. et al. (2019). "Applications of machine learning in drug discovery and development." Nature Reviews Drug Discovery, 18(6), 463-477. → Comprehensive review of AI drug discovery
Paul, S. M. et al. (2010). "How to improve R&D productivity: the pharmaceutical industry's grand challenge." Nature Reviews Drug Discovery, 9(3), 203-214. → Drug discovery challenges and statistical data

AlphaFold-Related

Jumper, J. et al. (2021). "Highly accurate protein structure prediction with AlphaFold." Nature, 596(7873), 583-589. → Original AlphaFold 2 paper
Varadi, M. et al. (2022). "AlphaFold Protein Structure Database: massively expanding the structural coverage of protein-sequence space with high-accuracy models." Nucleic Acids Research, 50(D1), D439-D444. → AlphaFold Database

Molecular Generation Models

Gómez-Bombarelli, R. et al. (2018). "Automatic Chemical Design Using a Data-Driven Continuous Representation of Molecules." ACS Central Science, 4(2), 268-276. → Pioneering molecular VAE research
Segler, M. H. S., Kogej, T., Tyrchan, C., & Waller, M. P. (2018). "Generating Focused Molecule Libraries for Drug Discovery with Recurrent Neural Networks." ACS Central Science, 4(1), 120-131. → RNN-based molecule generation

Virtual Screening

Wallach, I., Dzamba, M., & Heifets, A. (2015). "AtomNet: A Deep Convolutional Neural Network for Bioactivity Prediction in Structure-based Drug Discovery." arXiv preprint arXiv:1510.02855. → Atomwise's 3D-CNN
Stumpfe, D. & Bajorath, J. (2012). "Exploring Activity Cliffs in Medicinal Chemistry." Journal of Medicinal Chemistry, 55(7), 2932-2942. → Molecular descriptors and activity cliffs

Clinical Applications and Success Stories

Ren, F. et al. (2023). "AlphaFold accelerates artificial intelligence powered drug discovery: efficient discovery of a novel CDK20 small molecule inhibitor." Chemical Science, 14, 1443-1452. → Drug discovery case using AlphaFold
Cummings, J. L., Morstorf, T., & Zhong, K. (2014). "Alzheimer's disease drug-development pipeline: few candidates, frequent failures." Alzheimer's Research & Therapy, 6(4), 37. → High failure rate of Alzheimer's disease drugs

Explainability and Synthesizability

Jiménez-Luna, J., Grisoni, F., & Schneider, G. (2020). "Drug discovery with explainable artificial intelligence." Nature Machine Intelligence, 2(10), 573-584. → Explainable AI drug discovery
Coley, C. W., Eyke, N. S., & Jensen, K. F. (2019). "Autonomous Discovery in the Chemical Sciences Part I: Progress." Angewandte Chemie International Edition, 59(51), 22858-22893. → Synthesizability prediction and Retrosynthesis

Databases and Tools

Kim, S. et al. (2021). "PubChem in 2021: new data content and improved web interfaces." Nucleic Acids Research, 49(D1), D1388-D1395. → PubChem database
Gaulton, A. et al. (2017). "The ChEMBL database in 2017." Nucleic Acids Research, 45(D1), D945-D954. → ChEMBL database

Next Steps

In this chapter, we learned about the practical aspects of AI drug discovery:

✅ Challenges in drug discovery process and limitations of traditional methods
✅ Four major approaches to AI drug discovery
✅ Four real success stories (Exscientia, Atomwise, Insilico, Takeda)
✅ Implementation of RDKit, molecular VAE, and binding affinity prediction
✅ Current challenges and future outlook for the next 5 years

Bridge to Next Chapters:

In chapters 2 and beyond, we will learn about other materials informatics application examples:

Chapter 2: AI for Catalyst Design - Accelerating CO2 Reduction
Chapter 3: Li-ion Battery Material Exploration - Supporting the EV Revolution
Chapter 4: High-Entropy Alloys - The Future of Aerospace Materials
Chapter 5: Perovskite Solar Cells - Next-Generation Energy

To Learn More:

Practical Projects: - Train binding affinity prediction models with ChEMBL data - Train molecular VAE with real data and generate novel molecules - Predict target protein structures with AlphaFold
Recommended Courses: - Coursera: "AI for Medicine" (deeplearning.ai) - edX: "Drug Discovery" (Davidson College)
Communities: - RDKit User Group - OpenMolecules Community - Materials Informatics Japan

We would like to thank the following for creating this chapter:

MI Knowledge Hub Team - Technical verification
Open source community (RDKit, PyTorch, scikit-learn)

License: CC BY 4.0 (Creative Commons Attribution 4.0 International)

To cite:

Hashimoto, Y. & MI Knowledge Hub Team (2025).
"Chapter 1: AI Drug Discovery in Practice - Accelerating New Drug Candidate Discovery 10x."
Materials Informatics Practical Applications Series.
Tohoku University. https://[your-url]/chapter-1.html

Last updated: October 18, 2025 Version: 1.0

Chapter 1: AI-Driven Drug Discovery in Practice - Accelerating Novel Drug Candidate Discovery 10x

Learning Objectives

1.1 Challenges in Drug Discovery

1.1.1 Traditional Drug Discovery: Time and Cost Barriers

1.1.2 Stages of Drug Discovery Process

1.2 AI Drug Discovery Approaches

1.2.1 Virtual Screening

1.2.2 Molecular Generative Models

1. VAE (Variational Autoencoder)

2. GAN (Generative Adversarial Network)

3. Transformer (Latest Trend)

4. Graph Neural Networks (GNN)

1.2.3 ADMET Prediction

1.2.4 Protein Structure Prediction (AlphaFold Application)

1.3 Real-World Success Stories

Case 1: Exscientia × Sumitomo Pharma - World's First AI-Designed Drug Enters Clinical Trials

Case 2: Atomwise - AI Drug Discovery Platform for Multiple Diseases

AtomNet Architecture

Case 3: Insilico Medicine - Clinical Trials in 18 Months

Generative Chemistry Platform

Case 4: Takeda Pharmaceutical - Japanese Company's Challenge

1. Partnership with Recursion Pharmaceuticals

2. Collaboration with Schrödinger

3. In-house AI Drug Discovery Platform

1.4 Technical Explanation and Implementation Examples

1.4.1 Molecular Descriptors and Drug-likeness Assessment (RDKit)

Code Example 1: Lipinski's Rule of Five Assessment

1.4.2 Novel Molecular Generation with Molecular VAE

Code Example 2: Simplified Molecular VAE

1.4.3 Binding Affinity Prediction (Machine Learning)

Code Example 3: Binding Affinity Prediction with Random Forest

1.5 Summary and Future Outlook

1.5.1 Current State: Progress of AI Drug Discovery (2025)

1.5.2 Challenges

1. Lack of Explainability

2. Synthesizability Problem

3. Data Scarcity and Bias

1.5.3 Future Outlook for Next 5 Years (2025-2030)

Trend 1: Autonomous Drug Discovery Loop

Trend 2: Multi-Omics Integrated AI

Trend 3: Foundation Models for Drug Discovery

Trend 4: Regulatory Development and AI Drug Standardization

Exercise Problems

Exercise 1: Drug-likeness Filtering (Difficulty: easy)

Exercise 2: Molecular Similarity Search (Difficulty: medium)

References

Reviews and Overview Papers

AlphaFold-Related

Molecular Generation Models

Virtual Screening

Clinical Applications and Success Stories

Explainability and Synthesizability

Databases and Tools

Next Steps

Disclaimer