iterative_alignment_experiment_unconditioned/create_alignment_dataset_first_round.py

import torch
import re
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import h5py
import argparse
from omegaconf import OmegaConf
from esm.tokenization.sequence_tokenizer import EsmSequenceTokenizer
from Bio.Seq import Seq

device = torch.device("cuda:0")

num_replicates = 10
campaign_number = 0 # change this according to the campaign we are interested in
dataset_size = 96 # change this according to the dataset size we are interested in

sequence_tokenizer = EsmSequenceTokenizer()

parser = parser = argparse.ArgumentParser(description="Calculating the log-likelihood of a sequence")
parser.add_argument('--target', type=str, required=True, help='Dataset as a string')
args = parser.parse_args()
data = args.target

data_root_path = "/scratch/groups/rotskoff/sebastian/era/protein_era/data"

print(data)
for i in range(num_replicates):
    cfg_filename = f"./config.yaml"
    cfg = OmegaConf.load(cfg_filename)
    sampling_temperature=1
    OmegaConf.update(cfg, "train.lightning_model_args.sampling_temperature", sampling_temperature)
    mask_token_sequence = cfg["nn"]["model_args"]["residue_token_info"]["mask"]
    bos_token_sequence = cfg["nn"]["model_args"]["residue_token_info"]["bos"]
    eos_token_sequence = cfg["nn"]["model_args"]["residue_token_info"]["eos"]
    pad_token_sequence = cfg["nn"]["model_args"]["residue_token_info"]["pad"]
    
    if data.startswith("TrpB"):
        df = pd.read_csv(f"{data_root_path}/TrpB/scale2max/{data}.csv")
        with open(f"{data_root_path}/TrpB/TrpB.fasta", "r") as file:
            parent_sequence_decoded = file.readlines()[1].strip()
        
    elif data == "DHFR":
        df = pd.read_csv(f"{data_root_path}/{data}/scale2max/{data}.csv")
        with open(f"{data_root_path}/{data}/{data}.fasta", "r") as file:
            nucleotide_seq = file.readlines()[1].strip()
        nucleotide_seq = Seq(nucleotide_seq)
        parent_sequence_decoded = str(nucleotide_seq.translate())  # Translate to amino acid sequence
        
    else:
        df = pd.read_csv(f"{data_root_path}/{data}/scale2max/{data}.csv")
        with open(f"{data_root_path}/{data}/{data}.fasta", "r") as file:
            parent_sequence_decoded = file.readlines()[1].strip()
            
    if data != "GB1":        
        muts = df["muts"].iloc[0]
    else:
        muts = df["muts"].iloc[100000]
    
    numbers = re.findall(r'\d+', muts)
    mask_indices = list(map(int, numbers))
    # mask_indices = [i-1 for i in mask_indices] #convert to 0-based indexing
    
    fitness_scores = []
    
    # Load from base_model_{dataset_size}
    trpb_base = torch.load(f"./{data}/base_model_{dataset_size}/trpb_{i}.pt")
    all_unmasked_sequences_decoded_base = trpb_base["all_unmasked_sequences_decoded"]
    all_unmasked_sequences_base = trpb_base["all_unmasked_sequences"]
    all_masked_sequences_base = trpb_base["all_masked_sequences"]
    all_unmasked_sequences_base = all_unmasked_sequences_base.reshape(-1, all_unmasked_sequences_base.shape[-1])
    all_logps_base = trpb_base["all_logps"]
    
    for unmasked_sequence_decoded, unmasked_sequence in zip(all_unmasked_sequences_decoded_base, all_unmasked_sequences_base):
        index_residue_0 = unmasked_sequence_decoded[mask_indices[0]-1]
        index_residue_1 = unmasked_sequence_decoded[mask_indices[1]-1]
        index_residue_2 = unmasked_sequence_decoded[mask_indices[2]-1]
        try:
            index_residue_3 = unmasked_sequence_decoded[mask_indices[3]-1]
            mutations = [index_residue_0, index_residue_1, index_residue_2, index_residue_3]
            muts = ''.join(mutations)
        except:
            mutations = [index_residue_0, index_residue_1, index_residue_2]
            muts = ''.join(mutations)
        
        df_filtered = df[df["AAs"] == muts]
        
        if len(df_filtered) == 0:
            if torch.any((unmasked_sequence[1:-1] > 23) | (unmasked_sequence[1:-1] < 4)):
                print(f"Invalid sequence {muts}")
                fitness_score = -2
            else:
                print(f"Invalid sequence {muts}")
                fitness_score = -2
        else:
            fitness_score = df_filtered["fitness"].values[0]
        fitness_scores.append(fitness_score)

    
    # Concatenate the sequences and logps from all models
    all_unmasked_sequences = all_unmasked_sequences_base.clone()
    all_masked_sequences = all_masked_sequences_base.clone()
    all_logps = all_logps_base.clone()

    all_fitness_scores = fitness_scores
    
    # Check for duplicates in all_unmasked_sequences
    unique_sequences, counts = torch.unique(all_unmasked_sequences, dim=0, return_counts=True)
    num_duplicates = torch.sum(counts > 1).item()
    print(f"Number of duplicate sequences: {num_duplicates}")
    
    all_fitness_scores = np.array(all_fitness_scores)
    all_fitness_scores = np.where(all_fitness_scores > 0, -np.log(all_fitness_scores), 10)
    
    sampling_temperature = 1 # hard-coding a sampling temperature of 1 for mixed-temperature alignment

    sequence_length = all_unmasked_sequences.shape[1]

    sequence_id = torch.ones((all_unmasked_sequences.shape[0], sequence_length), device=device).long() * 1

    structure_tokens = torch.ones((1, sequence_length), device=device).long() * 4096
    structure_tokens[:, 0] = 4098
    structure_tokens[:, -1] = 4097

    coords = torch.inf * torch.ones((all_unmasked_sequences.shape[0], sequence_length, 3, 3), device=device)

    average_plddt = torch.ones((1), device=device)

    per_res_plddt = torch.zeros((1, sequence_length), device=device)
    ss8_tokens = torch.zeros((1, sequence_length), device=device).long()
    sasa_tokens = torch.zeros((1, sequence_length), device=device).long()

    function_tokens = torch.zeros((1, sequence_length, 8), device=device).long()
    residue_annotation_tokens = torch.zeros((1, sequence_length, 16), device=device).long()
            
    
    with h5py.File(f"./{data}/alignment_dataset_{campaign_number}_{dataset_size}_from_ESM3_{i}.hdf5", "w") as f:
        masked_sequence_tokens = f.create_dataset("masked_sequence_tokens", data=all_masked_sequences.cpu().numpy())
        unmasked_sequence_tokens = f.create_dataset("unmasked_sequence_tokens", data=all_unmasked_sequences.cpu().numpy())
        sequence_id = f.create_dataset("sequence_id", data=sequence_id.cpu().numpy())
        structure_tokens = f.create_dataset("structural_tokens", data=structure_tokens.cpu().numpy())
        coords = f.create_dataset("bb_coords", data=coords.cpu().numpy())
        average_plddt = f.create_dataset("average_plddt", data=average_plddt.cpu().numpy())
        per_res_plddt = f.create_dataset("per_res_plddt", data=per_res_plddt.cpu().numpy())
        ss8_tokens = f.create_dataset("ss8_tokens", data=ss8_tokens.cpu().numpy())
        sasa_tokens = f.create_dataset("sasa_tokens", data=sasa_tokens.cpu().numpy())
        function_tokens = f.create_dataset("function_tokens", data=function_tokens.cpu().numpy())
        residue_annotation_tokens = f.create_dataset("residue_annotation_tokens", data=residue_annotation_tokens.cpu().numpy())

        ref_logps = f.create_dataset("ref_logps", data=all_logps.cpu().numpy())
        energies = f.create_dataset("energies", data=all_fitness_scores)


        f.attrs["num_prompts"] = 1
        f.attrs["num_examples_per_prompt"] = masked_sequence_tokens.shape[0]
        f.attrs["fixed_bb_coords"] = True
        f.attrs["fixed_average_plddt"] = True
        f.attrs["fixed_per_res_plddt"] = True
        f.attrs["fixed_ss8_tokens"] = True
        f.attrs["fixed_sasa_tokens"] = True
        f.attrs["fixed_function_tokens"] = True
        f.attrs["fixed_residue_annotation_tokens"] = True
        f.attrs["fixed_structural_tokens"] = True
        f.attrs["sampling_temperature"] = sampling_temperature