src/negbiodb/models/deepdta.py

"""DeepDTA: Drug-Target Affinity Prediction via CNNs.

Reference: Öztürk et al., 2018 (arXiv:1801.10193).
Architecture: Dual 1D-CNN encoders for SMILES and protein sequence.
"""

from __future__ import annotations

import numpy as np
import torch
import torch.nn as nn

# Vocabulary for SMILES characters (75 unique + 1 padding index 0).
# Note: Öztürk et al. 2018 used 64 chars; we use 75 to cover a broader chemical space.
SMILES_CHARS = (
    "#%()+-./0123456789=@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]abcdefghijklmnopqrstuvwxyz"
)
SMILES_VOCAB: dict[str, int] = {c: i + 1 for i, c in enumerate(SMILES_CHARS)}
SMILES_VOCAB_SIZE = len(SMILES_VOCAB) + 1  # +1 for padding index 0

# Vocabulary for amino acid single-letter codes (20 standard + X = 21, + 1 padding index 0)
AA_CHARS = "ACDEFGHIKLMNPQRSTVWXY"
AA_VOCAB: dict[str, int] = {c: i + 1 for i, c in enumerate(AA_CHARS)}
AA_VOCAB_SIZE = len(AA_VOCAB) + 1  # +1 for padding index 0

# Max sequence lengths (from original DeepDTA Davis benchmark)
MAX_SMILES_LEN = 85
MAX_SEQ_LEN = 1200

# ASCII lookup tables for fast vectorised tokenisation (size 256 covers all byte values).
# Non-vocab characters map to 0 (padding index) by default.
_SMILES_LUT: np.ndarray = np.zeros(256, dtype=np.int64)
for _c, _idx in SMILES_VOCAB.items():
    _SMILES_LUT[ord(_c)] = _idx

_AA_LUT: np.ndarray = np.zeros(256, dtype=np.int64)
for _c, _idx in AA_VOCAB.items():
    _AA_LUT[ord(_c)] = _idx


def smiles_to_tensor(smiles: list[str], max_len: int = MAX_SMILES_LEN) -> torch.Tensor:
    """Encode SMILES strings to integer tensor (batch × max_len).

    Uses numpy vectorised indexing (~50x faster than element-wise Python loops).
    Non-ASCII or unknown characters map to 0 (padding).
    """
    result = np.zeros((len(smiles), max_len), dtype=np.int64)
    for i, smi in enumerate(smiles):
        s = smi[:max_len]
        codes = np.frombuffer(s.encode("ascii", errors="replace"), dtype=np.uint8)
        result[i, : len(codes)] = _SMILES_LUT[codes]
    # torch.frombuffer bypasses the broken torch-numpy bridge (torch 2.2.2 + NumPy 2.x).
    return torch.frombuffer(result.tobytes(), dtype=torch.int64).reshape(len(smiles), max_len).clone()


def seq_to_tensor(seqs: list[str], max_len: int = MAX_SEQ_LEN) -> torch.Tensor:
    """Encode amino acid sequences to integer tensor (batch × max_len).

    Uses numpy vectorised indexing (~50x faster than element-wise Python loops).
    Non-ASCII or unknown amino acid characters map to 0 (padding).
    """
    result = np.zeros((len(seqs), max_len), dtype=np.int64)
    for i, seq in enumerate(seqs):
        s = seq[:max_len]
        codes = np.frombuffer(s.encode("ascii", errors="replace"), dtype=np.uint8)
        result[i, : len(codes)] = _AA_LUT[codes]
    # torch.frombuffer bypasses the broken torch-numpy bridge (torch 2.2.2 + NumPy 2.x).
    return torch.frombuffer(result.tobytes(), dtype=torch.int64).reshape(len(seqs), max_len).clone()


class _CNNEncoder(nn.Module):
    """1D-CNN encoder for sequential inputs (SMILES or protein sequence)."""

    def __init__(
        self,
        vocab_size: int,
        embed_dim: int = 128,
        num_filters: tuple[int, int, int] = (32, 64, 96),
        kernel_sizes: tuple[int, int, int] = (4, 6, 8),
    ) -> None:
        super().__init__()
        self.embed = nn.Embedding(vocab_size, embed_dim, padding_idx=0)
        layers: list[nn.Module] = []
        in_ch = embed_dim
        for n_filters, k in zip(num_filters, kernel_sizes):
            layers += [nn.Conv1d(in_ch, n_filters, kernel_size=k), nn.ReLU()]
            in_ch = n_filters
        layers.append(nn.AdaptiveMaxPool1d(1))
        self.conv = nn.Sequential(*layers)

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        # x: (B, L) → embed → (B, L, D) → permute → (B, D, L)
        h = self.embed(x).permute(0, 2, 1)
        h = self.conv(h)          # (B, C, 1)
        return h.squeeze(-1)      # (B, C)


class DeepDTA(nn.Module):
    """DeepDTA model for binary DTI prediction.

    Args:
        drug_embed_dim: Embedding dimension for SMILES characters.
        target_embed_dim: Embedding dimension for amino acid characters.
        drug_filters: Tuple of (n_filters_1, n_filters_2, n_filters_3) for drug CNN.
        drug_kernels: Tuple of kernel sizes for drug CNN.
        target_filters: Tuple of filter counts for target CNN.
        target_kernels: Tuple of kernel sizes for target CNN.
        fc_dims: Sizes of fully-connected layers after concat.
        dropout: Dropout rate in FC layers.
    """

    def __init__(
        self,
        drug_embed_dim: int = 128,
        target_embed_dim: int = 128,
        drug_filters: tuple[int, int, int] = (32, 64, 96),
        drug_kernels: tuple[int, int, int] = (4, 6, 8),
        target_filters: tuple[int, int, int] = (32, 64, 96),
        target_kernels: tuple[int, int, int] = (4, 8, 12),
        fc_dims: tuple[int, int, int] = (1024, 1024, 512),
        dropout: float = 0.1,
    ) -> None:
        super().__init__()
        self.drug_encoder = _CNNEncoder(
            SMILES_VOCAB_SIZE, drug_embed_dim, drug_filters, drug_kernels
        )
        self.target_encoder = _CNNEncoder(
            AA_VOCAB_SIZE, target_embed_dim, target_filters, target_kernels
        )

        drug_out_dim = drug_filters[-1]
        target_out_dim = target_filters[-1]
        concat_dim = drug_out_dim + target_out_dim

        fc_layers: list[nn.Module] = []
        in_dim = concat_dim
        for out_dim in fc_dims:
            fc_layers += [nn.Linear(in_dim, out_dim), nn.ReLU(), nn.Dropout(dropout)]
            in_dim = out_dim
        fc_layers.append(nn.Linear(in_dim, 1))
        self.fc = nn.Sequential(*fc_layers)

    def forward(
        self, drug_tokens: torch.Tensor, target_tokens: torch.Tensor
    ) -> torch.Tensor:
        """
        Args:
            drug_tokens: (B, MAX_SMILES_LEN) integer token ids.
            target_tokens: (B, MAX_SEQ_LEN) integer token ids.

        Returns:
            (B,) raw logits (before sigmoid; use BCEWithLogitsLoss for training).
        """
        d = self.drug_encoder(drug_tokens)      # (B, 96)
        t = self.target_encoder(target_tokens)  # (B, 96)
        h = torch.cat([d, t], dim=1)            # (B, 192)
        return self.fc(h).squeeze(-1)           # (B,)