How We Developed ML Models for HIV-1 Drug Resistance and Subtype Classification: A Technical Deep Dive

The fight against HIV-1 has always been a race against viral evolution. Drug resistance remains one of the biggest obstacles in antiretroviral therapy, and identifying the correct subtype is critical for treatment efficacy. Recently, a team of researchers from MIPT and their partners published a groundbreaking article on Habr detailing their journey in developing machine learning models that tackle both challenges simultaneously. This article summarizes their approach, the technical hurdles they overcame, and the practical outcomes — all based on the original source material.

The Problem: Why Traditional Methods Fall Short

HIV-1 is notorious for its high mutation rate. Standard genotypic resistance testing relies on comparing viral sequences to a database of known resistance mutations. This works for well-characterized variants, but fails when new mutations emerge or when the virus belongs to a rare subtype. The same applies to subtype classification — traditional phylogenetic trees are slow and require expert interpretation.

The authors of the source article recognized that machine learning could offer a faster, more scalable solution. Their goal was to build models that could:
- Predict resistance to common antiretroviral drugs from viral genetic sequences.
- Classify the HIV-1 subtype with high accuracy, even for underrepresented lineages.

Data Collection and Preprocessing

The team started by assembling a comprehensive dataset. They sourced sequences from public repositories like the Los Alamos HIV Database and the Stanford HIV Drug Resistance Database. The raw data included:

One major challenge was data quality. Many sequences had gaps, ambiguous nucleotides, or inconsistent labeling. The developers implemented a rigorous preprocessing pipeline:
1. Alignment: Using MAFFT to align sequences to a reference genome.
2. Quality filtering: Removing sequences with >10% ambiguous bases.
3. Normalization: Converting sequences to a fixed-length vector representation (e.g., one-hot encoding of nucleotides).
4. Augmentation: For rare subtypes, they used synthetic minority oversampling (SMOTE) to balance the dataset.

Model Architecture: Two Heads, One Network

Rather than building separate models for resistance prediction and subtype classification, the team designed a multi-task neural network. This approach allowed the model to learn shared representations from the same input sequences, improving generalization.

The architecture consisted of:
- Input layer: A 2D convolutional layer (Conv1D) to capture local sequence motifs (e.g., mutations at specific codon positions).
- Shared layers: Two dense layers with ReLU activation and dropout (rate 0.3) for regularization.
- Task-specific heads:
- Resistance head: A sigmoid output layer with multiple nodes — one for each drug class (e.g., NNRTIs, NRTIs, PIs). Each node outputs a probability of resistance (0 to 1).
- Subtype head: A softmax output layer with nodes for the most common subtypes (A, B, C, D, F, G, CRF01_AE, and a catch-all "other").

Training was performed using the Adam optimizer with a learning rate of 0.001. The loss function combined binary cross-entropy for resistance and categorical cross-entropy for subtype, weighted by a hyperparameter λ (lambda) to balance the two tasks. After tuning, λ=0.7 gave the best performance.

Results and Validation

The model was evaluated on a held-out test set of 5,000 sequences. The key metrics:

These results significantly outperformed traditional rule-based methods. For example, the Stanford HIVdb algorithm achieved an AUC-ROC of 0.87 for NNRTIs — the ML model improved this by 7 percentage points.

Practical Deployment Challenges

The developers faced several real-world issues when moving from prototype to production:

1. Latency: The deep learning model required GPU inference, which was not always available in low-resource clinics. They solved this by quantizing the model (converting weights to 8-bit integers) and deploying it on edge devices like NVIDIA Jetson Nano. Inference time dropped from 500ms to 50ms per sequence.

2. Interpretability: Clinicians needed to understand why a model predicted resistance. The team implemented SHAP (SHapley Additive exPlanations) to highlight which codons contributed most to the prediction. For example, for an NNRTI resistance prediction, the model might highlight codon 103 (K103N mutation).

3. Data drift: Over time, new viral variants emerge. The team set up a continuous monitoring system that tracked model performance on incoming sequences. If accuracy dropped below a threshold, the model would be retrained on new data.

Code Snippet: Inference Pipeline

The authors shared a simplified version of their inference code (adapted from the source):

import numpy as np
from tensorflow import keras

# Load the pre-trained model
model = keras.models.load_model('hiv_multi_task_model.h5')

def preprocess_sequence(seq):
    """Convert a DNA sequence string to one-hot encoding."""
    mapping = {'A': [1,0,0,0], 'C': [0,1,0,0], 
               'G': [0,0,1,0], 'T': [0,0,0,1]}
    # Handle ambiguous bases as uniform distribution
    default = [0.25, 0.25, 0.25, 0.25]
    one_hot = [mapping.get(base.upper(), default) for base in seq]
    # Pad or truncate to fixed length (e.g., 1300 bp)
    max_len = 1300
    if len(one_hot) < max_len:
        one_hot += [[0,0,0,0]] * (max_len - len(one_hot))
    else:
        one_hot = one_hot[:max_len]
    return np.array(one_hot)

# Example usage
sequence = "ATGGA..."  # truncated for brevity
X = preprocess_sequence(sequence)
X = np.expand_dims(X, axis=0)  # add batch dimension

# Predict
resistance_probs, subtype_probs = model.predict(X)
print(f"NNRTI resistance: {resistance_probs[0][0]:.2f}")
print(f"Subtype: {np.argmax(subtype_probs)}")

Industry Impact and Future Directions

The project demonstrates the power of multi-task learning in bioinformatics. According to the source article, the model is now being tested in two partner clinics in Russia, where it helps doctors choose the optimal drug regimen in under 10 minutes — a process that previously took days.

For developers interested in replicating this work, the team emphasized three lessons:
- Start with clean data: 80% of the effort was in preprocessing.
- Use transfer learning: Pre-train on large unlabeled sequence data (e.g., using autoencoders) to boost performance.
- Involve domain experts: Virologists helped identify which features were biologically meaningful.

The article also notes that the model is open-source (link in the original Habr post), allowing the community to adapt it for other viruses like hepatitis C or SARS-CoV-2.

Conclusion

The development of ML models for HIV-1 drug resistance and subtype classification is a prime example of how deep learning can solve real-world medical problems. The authors of the source article have shown that with careful data curation, a well-designed architecture, and pragmatic deployment strategies, it is possible to create tools that are both accurate and practical. As viral evolution continues, such models will become indispensable for personalized medicine.

For a complete technical description and access to the code, refer to the original article: Source.