TransHLA is a groundbreaking tool designed to identify whether a peptide can be recognized by HLA (Human Leukocyte Antigen) as an epitope. What’s remarkable about TransHLA is that it does not require inputting HLA alleles. In essence, it can single out potential epitopes like an expert scout in a crowd, effortlessly recognizing likely candidates based on peptide characteristics. Let’s dive into the details of how to use this innovative model for your research needs.

Understanding the Different Models

TransHLA comprises two specialized models:

• TransHLA_I: Tailored for shorter peptides, ranging from 8 to 14 amino acids.
• TransHLA_II: Designed for longer peptides, with lengths between 13 to 21 amino acids.

Think of TransHLA_I as a masterful chef perfecting appetizers, while TransHLA_II crafts main dishes, accommodating the different complexities of peptide lengths.

Model Architecture

TransHLA employs a hybrid architecture, blending a transformer encoder with a deep CNN module. The model utilizes pretrained sequence embeddings from ESM2 along with structural features to accurately identify epitopes, serving as a preliminary screening tool among existing HLA-epitope binding affinity tools.

How to Use TransHLA

Before digging into the code, ensure you have the necessary packages installed:

• Pytorch
• Fair-ESM
• Transformers

Additionally, you need to have CUDA version 11.8 or higher. If your setup does not meet this requirement, the model will default to CPU operations.

pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118
pip install transformers
pip install fair-esm

Using the TransHLA_I Model

To predict whether a peptide qualifies as an epitope, follow this:

python
from transformers import AutoTokenizer
from transformers import AutoModel
import torch

def pad_inner_lists_to_length(outer_list, target_length=16):
    for inner_list in outer_list:
        padding_length = target_length - len(inner_list)
        if padding_length > 0:
            inner_list.extend([1] * padding_length)
    return outer_list

if __name__ == "__main__":
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    print(f'Using device: {device}')
    tokenizer = AutoTokenizer.from_pretrained("facebook/esm2_t33_650M_UR50D")
    model = AutoModel.from_pretrained("SkywalkerLu/TransHLA_I", trust_remote_code=True)
    model.to(device)

    peptide_examples = ["EDSAIVTPSR", "SVWEPAKAKYVFR"]
    peptide_encoding = tokenizer(peptide_examples)["input_ids"]
    peptide_encoding = pad_inner_lists_to_length(peptide_encoding)
    print(peptide_encoding)

    peptide_encoding = torch.tensor(peptide_encoding)
    outputs, representations = model(peptide_encoding.to(device))

    print(outputs)
    print(representations)

Using TransHLA_II Model

For predicting epitopes in longer peptides, use the following code:

python
from transformers import AutoTokenizer
from transformers import AutoModel
import torch

def pad_inner_lists_to_length(outer_list, target_length=23):
    for inner_list in outer_list:
        padding_length = target_length - len(inner_list)
        if padding_length > 0:
            inner_list.extend([1] * padding_length)
    return outer_list

if __name__ == "__main__":
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    print(f'Using device: {device}')
    tokenizer = AutoTokenizer.from_pretrained("facebook/esm2_t33_650M_UR50D")
    model = AutoModel.from_pretrained("SkywalkerLu/TransHLA_II", trust_remote_code=True)
    model.to(device)
    model.eval()

    peptide_examples = ["KMIYSYSSHAASSL", "ARGDFFRATSRLTTDFG"]
    peptide_encoding = tokenizer(peptide_examples)["input_ids"]
    peptide_encoding = pad_inner_lists_to_length(peptide_encoding)
    peptide_encoding = torch.tensor(peptide_encoding)

    outputs, representations = model(peptide_encoding.to(device))

    print(outputs)
    print(representations)

Troubleshooting Common Issues

As with any software tool, you may encounter obstacles while using TransHLA. Here are some common problems and their solutions:

• CUDA-Related Errors: Ensure you have CUDA 11.8 or higher. If you lack the required version, consider running the model on CPU, although this may result in slower processing times.
• Package Not Found: Double-check that all required packages (Pytorch, Fair-ESM, Transformers) are properly installed. You can reinstall them if issues persist.
• Output Confusion: The output consists of two parts: probabilities indicating whether the peptide is an epitope and the sequence embedding generated by the model. Ensure you interpret these correctly: if the probability in the second column is 0.5 or more, it’s considered an epitope.

For more insights, updates, or to collaborate on AI development projects, stay connected with fxis.ai.

Conclusion

TransHLA is a complex yet powerful model that captures the essence of peptide recognition effectively. By refining your inputs and understanding the outputs, you can leverage TransHLA for cutting-edge epitope prediction.

At fxis.ai, we believe that such advancements are crucial for the future of AI, as they enable more comprehensive and effective solutions. Our team is continually exploring new methodologies to push the envelope in artificial intelligence, ensuring that our clients benefit from the latest technological innovations.