CRISPR_data.py

#!/usr/bin/env python
# A mixture of data from sx, lcy, sj, ljh, lier

import re
import datasets
from typing import Callable
import os
import torch
import torch.nn.functional as F
from itertools import product
import numpy as np

# TODO: Add BibTeX citation
# Find for instance the citation on arxiv or on the dataset repo/website
# _CITATION = """\
# @InProceedings{huggingface:dataset,
# title = {A great new dataset},
# author={huggingface, Inc.
# },
# year={2020}
# }
# """

# TODO: Add a link to an official homepage for the dataset here
# _HOMEPAGE = ""

# TODO: Add the licence for the dataset here if you can find it
# _LICENSE = ""

def gc_content(seq):
    return (seq.count("G") + seq.count("C")) / len(seq)

class CRISPRDataConfig(datasets.BuilderConfig):
    def __init__(self, ref_filter: Callable | None = None, cut_filter: Callable | None = None, author_filter: Callable | None = None, file_filter: Callable | None = None, test_ratio: float = 0.05, validation_ratio: float = 0.05, seed: int = 63036, features: datasets.Features = None, ref1len: int = 127, ref2len: int = 127, DELLEN_LIMIT: int = 60, Lindel_dlen: int = 30, Lindel_mh_len: int = 4, FOREcasT_MAX_DEL_SIZE: int = 30, **kwargs):
        """BuilderConfig for CRISPR_data.
        Args:
        trans_func: *function*, transform function applied after filter.
        ref_filter: *function*, ref_filter(ref1, ref2) -> bool.
        cut_filter: *function*, cut_filter(cut1, cut2, ref1[optional], ref2[optional]) -> bool.
        author_filter: *function*, author_filter(author, ref1[optional], ref2[optional], cut1[optional], cut2[optional]) -> bool.
        file_filter: *function*, file_filter(file, ref1[optional], ref2[optional], cut1[optional], cut2[optional], author[optional]) -> bool.
        test_ratio: *float*, the ratio of data for test.
        validation_ratio: *float*, the ratio of data for validation.
        seed: *int*, the random seed.
        features: include the data structure in config (for auto generation of model card when test dataset).
        ref1len: length of ref1.
        ref2len: length of ref2.
        DELLEN_LIMIT: upper limit of inDelphi deletion size.
        Lindel_dlen: upper limit of Lindel deletion size.
        Lindel_mh_len: upper limit of Lindel micro-homology size (mh longer than Lindel_mh_len is not excluded, but cutoff to Lindel_mh_len).
        FOREcasT_MAX_DEL_SIZE: upper limit of FOREcasT deletion size.
        **kwargs: keyword arguments forwarded to super.
        """
        super().__init__(**kwargs)
        self.ref_filter = ref_filter
        self.cut_filter = cut_filter
        self.author_filter = author_filter
        self.file_filter = file_filter
        self.test_ratio = test_ratio
        self.validation_ratio = validation_ratio
        self.seed = seed
        self.features = features
        self.ref1len = ref1len
        self.ref2len = ref2len
        self.DELLEN_LIMIT = DELLEN_LIMIT
        self.Lindel_dlen = Lindel_dlen
        self.Lindel_mh_len = Lindel_mh_len
        self.FOREcasT_MAX_DEL_SIZE = FOREcasT_MAX_DEL_SIZE

class CRISPRData(datasets.GeneratorBasedBuilder):
    def __init__(self, **kargs):
        super().__init__(**kargs)
        with torch.no_grad():
            # diag_indices example for ref2len = 3 and ref1len = 2:
            # 6 9 11   row_indices 0 0 0   col_indices 0 1 2
            # 3 7 10               1 1 1               0 1 2
            # 1 4 8                2 2 2               0 1 2
            # 0 2 5                3 3 3               0 1 2
            # diag_indices = (
            #     tensor([3, 2, 3, 1, 2, 3, 0, 1, 2, 0, 1, 0]),
            #     tensor([0, 0, 1, 0, 1, 2, 0, 1, 2, 1, 2, 2])
            # )
            ref1len, ref2len = self.config.ref1len, self.config.ref2len
            row_indices = torch.arange(ref2len + 1)[:, None].expand(-1, ref1len + 1)
            col_indices = torch.arange(ref1len + 1).expand(ref2len + 1, -1)
            self.diag_indices = (
                # row index
                torch.cat([
                    row_indices.diagonal(offset)
                    for offset in range(-ref2len, ref1len + 1)
                ]),
                # col index
                torch.cat([
                    col_indices.diagonal(offset)
                    for offset in range(-ref2len, ref1len + 1)
                ])
            )
            # 'ACGT' -> '0213'
            self.nuc_code = "".join(
                str(i)
                for i in (np.frombuffer("ACGT".encode(), dtype=np.int8) % 5).clip(0, 3)
            )
            self.base_idx = [
                torch.tensor([
                    int("".join(j), base=len(self.nuc_code))
                    for j in product(*([self.nuc_code] * i))
                ])
                for i in range(1, 3)
            ]
            self.base_cutoff = [0]
            for bi in self.base_idx:
                bi += self.base_cutoff[-1]
                self.base_cutoff.append(self.base_cutoff[-1] + len(bi))
            self.base_idx = torch.cat(self.base_idx)
        

    # auxiliary methods
    def get_observations(self, ref1, ref2, cut, RANDOM_INSERT_LIMIT=99999, INSERT_LIMIT=None, count_long_insertion=False):
        assert len(ref1) == self.config.ref1len and len(ref2) == self.config.ref2len, "reference length does not fit"
        observations = torch.zeros(len(ref2) + 1, len(ref1) + 1, dtype=torch.int64)
        if INSERT_LIMIT is not None:
            assert INSERT_LIMIT < len(self.base_cutoff), "INSERT_LIMIT is beyonded"
            base = len(self.nuc_code)
            total = (base ** (INSERT_LIMIT + 1) - base) // (base - 1)
            insert_counts = torch.zeros(total, dtype=torch.int64)
            if count_long_insertion:
                insert_count_long = 0
            cut1, cut2 = cut['cut1'], cut['cut2']
        for author in cut['authors']:
            for file in author['files']:
                mask = torch.tensor([len(random_insert) <= RANDOM_INSERT_LIMIT for random_insert in file['random_insert']])
                observations[
                    torch.tensor(file['ref2_start'])[mask],
                    torch.tensor(file['ref1_end'])[mask]
                ] += torch.tensor(file['count'])[mask]
                if INSERT_LIMIT is not None:
                    for ref1_end, ref2_start, random_insert, count in zip(file['ref1_end'], file['ref2_start'], file['random_insert'], file['count']):
                        if ref1_end < cut1 or ref2_start > cut2:
                            continue
                        insert = ref1[cut1:ref1_end] + random_insert + ref2[ref2_start:cut2]
                        if len(insert) > 0:
                            if len(insert) <= INSERT_LIMIT:
                                insert_counts[
                                    self.base_cutoff[len(insert) - 1] +
                                    int("".join(str(i) for i in (np.frombuffer(insert.encode(), dtype=np.int8) % 5).clip(0, 3)), base=base)
                                ] += count
                            elif count_long_insertion:
                                insert_count_long += count
        if INSERT_LIMIT is not None:
            insert_counts = insert_counts[self.base_idx[:total]]
            if count_long_insertion:
                return observations, torch.cat([
                    insert_counts,
                    torch.tensor([insert_count_long], dtype=torch.int64) 
                ])
            else:
                return observations, insert_counts
        return observations

    def num2micro_homology(self, ref1, ref2, cut1, cut2, ext1=0, ext2=0):
        assert len(ref1) == self.config.ref1len and len(ref2) == self.config.ref2len, "reference length does not fit"
        mh_matrix = F.pad(
            torch.from_numpy(
                np.frombuffer(ref1[:cut1 + ext1].encode(), dtype=np.int8)[None, :] == np.frombuffer(ref2[cut2 - ext2:].encode(), dtype=np.int8)[:, None]
            ).to(torch.int16),
            pad=(0, len(ref1) - cut1 - ext1 + 1, cut2 - ext2, 1), value=0
        )
        rep_num = torch.cat((
            torch.tensor([-1], dtype=torch.int64),
            torch.where(mh_matrix[self.diag_indices].diff())[0],
            torch.tensor([(len(ref1) + 1) * (len(ref2) + 1) - 1], dtype=torch.int64)
        )).diff()
        rep_val = rep_num.clone()
        rep_val[0::2] = 0
        rep_num[1::2] = rep_num[1::2] + 1
        rep_num[2::2] = rep_num[2::2] - 1
        rep_val = rep_val.repeat_interleave(rep_num)
        return mh_matrix, rep_num, rep_val

    def get_input(self, ref1, ref2, cut1, cut2, mh_matrix, rep_num, rep_val, model):
        if model != "FOREcasT":
            mh_lens = rep_val.to(torch.int16)
        if model in ["inDelphi", "Lindel", "FOREcasT"]:
            mask = rep_val == 0
            if model != "FOREcasT":
                mh_idxs = rep_num.cumsum(dim=0)[1::2] - 1
            del_lens = (torch.arange(cut1, cut1 - len(ref1) - 1, -1, dtype=torch.int16)[None, :] + torch.arange(-cut2, len(ref2) - cut2 + 1, dtype=torch.int16)[:, None])[self.diag_indices]
            if model in ["Lindel", "FOREcasT"]:
                dstarts = torch.arange(-cut1, len(ref1) - cut1 + 1, dtype=torch.int16)[None, :].expand(len(ref2) + 1, -1)[self.diag_indices]
                if model == "Lindel":
                    return del_lens, mh_lens, dstarts, mh_idxs
                else:
                    return del_lens, dstarts
            elif model == "inDelphi":
                gt_poss = (torch.arange(-cut2, len(ref2) - cut2 + 1, dtype=torch.int16) + cut1)[:, None].expand(-1, len(ref1) + 1)[self.diag_indices]
                del_lens = torch.cat([del_lens[mask], del_lens[mh_idxs]])
                gt_poss = torch.cat([gt_poss[mask], gt_poss[mh_idxs]])
                mh_lens = torch.cat([mh_lens[mask], mh_lens[mh_idxs]])
            return del_lens, mh_lens, gt_poss
        mh_matrix[self.diag_indices] = mh_lens
        return mh_matrix

    def get_output(self, observations, rep_num, rep_val, model):
        if model in ["inDelphi", "Lindel", "FOREcasT"]:
            mask = rep_val == 0
            counts = torch.zeros(len(rep_num) // 2, dtype=torch.int64)
            counts = counts.scatter_add(
                dim = 0,
                index = torch.arange(len(rep_num) // 2).repeat_interleave(rep_num[1::2]),
                src = observations[self.diag_indices][~mask]
            )
            if model != "FOREcasT":
                mh_idxs = rep_num.cumsum(dim=0)[1::2] - 1
            if model in ["Lindel", "FOREcasT"]:
                if model == "Lindel":
                    observations[self.diag_indices[0][~mask], self.diag_indices[1][~mask]] = 0
                    observations[self.diag_indices[0][mh_idxs], self.diag_indices[1][mh_idxs]] = counts
                    return observations[self.diag_indices]
                else:
                    observations = observations.to(torch.float32)
                    observations[self.diag_indices[0][~mask], self.diag_indices[1][~mask]] = (counts / rep_num[1::2]).repeat_interleave(rep_num[1::2])
                    return observations[self.diag_indices]
            elif model == "inDelphi":
                counts = torch.cat([observations[self.diag_indices][mask], counts])
            return counts
        return None

    # trans_funcs
    def CRISPR_transformer_trans_func(self, examples):
        ref1s, ref2s, ob_ref1s, ob_ref2s, ob_vals = [], [], [], [], []
        for ref1, ref2, cuts in zip(examples['ref1'], examples['ref2'], examples['cuts']):
            for cut in cuts:
                # ref
                ref1s.append(ref1)
                ref2s.append(ref2)
                # output
                observations = self.get_observations(ref1, ref2, cut)
                ob_ref2, ob_ref1 = observations.nonzero(as_tuple=True)
                ob_ref1s.append(ob_ref1)
                ob_ref2s.append(ob_ref2)
                ob_vals.append(observations[ob_ref2, ob_ref1])
        return {
            'ref1': ref1s,
            'ref2': ref2s,
            'ob_ref1': ob_ref1s,
            'ob_ref2': ob_ref2s,
            'ob_val': ob_vals
        }

    def CRISPR_diffuser_trans_func(self, examples):
        ref1s, ref2s, cut1s, cut2s, mh_ref1s, mh_ref2s, mh_vals, ob_ref1s, ob_ref2s, ob_vals = [], [], [], [], [], [], [], [], [], []
        for ref1, ref2, cuts in zip(examples['ref1'], examples['ref2'], examples['cuts']):
            for cut in cuts:
                # ref and cut
                ref1s.append(ref1)
                ref2s.append(ref2)
                cut1, cut2 = cut['cut1'], cut['cut2']
                cut1s.append(cut1)
                cut2s.append(cut2)
                # input
                mh_matrix, rep_num, rep_val = self.num2micro_homology(ref1, ref2, cut1, cut2)
                mh_matrix = self.get_input(ref1, ref2, cut1, cut2, mh_matrix, rep_num, rep_val, "CRISPR_diffuser")
                mh_ref2, mh_ref1 = mh_matrix.nonzero(as_tuple=True)
                mh_ref1s.append(mh_ref1)
                mh_ref2s.append(mh_ref2)
                mh_vals.append(mh_matrix[mh_ref2, mh_ref1])
                # output
                observations = self.get_observations(ref1, ref2, cut)
                ob_ref2, ob_ref1 = observations.nonzero(as_tuple=True)
                ob_ref1s.append(ob_ref1)
                ob_ref2s.append(ob_ref2)
                ob_vals.append(observations[ob_ref2, ob_ref1])
        return {
            'ref1': ref1s,
            'ref2': ref2s,
            'cut1': cut1s,
            'cut2': cut2s,
            'mh_ref1': mh_ref1s,
            'mh_ref2': mh_ref2s,
            'mh_val': mh_vals,
            'ob_ref1': ob_ref1s,
            'ob_ref2': ob_ref2s,
            'ob_val': ob_vals
        }

    def inDelphi_trans_func(self, examples):
        refs, cut_list, mh_del_lenss, mh_mh_lenss, mh_gt_posss, mh_gc_fracss, mh_countss, mhless_countss, insert_1bpss = [], [], [], [], [], [], [], [], []
        for ref1, ref2, cuts in zip(examples['ref1'], examples['ref2'], examples['cuts']):
            for cut in cuts:
                # ref and cut
                cut1, cut2 = cut['cut1'], cut['cut2']
                refs.append(ref1[:cut1] + ref2[cut2:])
                cut_list.append(cut1)
                # input
                mh_matrix, rep_num, rep_val = self.num2micro_homology(ref1, ref2, cut1, cut2)
                del_lens, mh_lens, gt_poss = self.get_input(ref1, ref2, cut1, cut2, mh_matrix, rep_num, rep_val, "inDelphi")
                mask_del = (del_lens > 0) & (del_lens < self.config.DELLEN_LIMIT) & (gt_poss >= cut1) & (gt_poss - del_lens <= cut1)
                del_lens, mh_lens, gt_poss = del_lens[mask_del], mh_lens[mask_del], gt_poss[mask_del]
                mask_mh = mh_lens > 0
                mh_del_lenss.append(del_lens[mask_mh])
                mh_gt_posss.append(gt_poss[mask_mh])
                mh_mh_lenss.append(mh_lens[mask_mh])
                mh_gc_fracss.append([gc_content(refs[-1][gt_pos - mh_len:gt_pos]) for mh_len, gt_pos in zip(mh_mh_lenss[-1], mh_gt_posss[-1])])
                # output
                observations, insert_counts = self.get_observations(ref1, ref2, cut, INSERT_LIMIT = 1)
                insert_1bpss.append(insert_counts)                
                counts = self.get_output(observations, rep_num, rep_val, "inDelphi")
                counts = counts[mask_del]
                mh_countss.append(counts[mask_mh])
                mhless_counts = torch.zeros(self.config.DELLEN_LIMIT - 1, dtype=torch.int64)
                mhless_counts = mhless_counts.scatter_add(dim = 0, index=(del_lens[~mask_mh] - 1).to(torch.int64), src=counts[~mask_mh])
                mhless_countss.append(mhless_counts)
        return {
            'ref': refs,
            'cut': cut_list,
            'mh_gt_pos': mh_gt_posss,
            'mh_del_len': mh_del_lenss,
            'mh_mh_len': mh_mh_lenss,
            'mh_gc_frac': mh_gc_fracss,
            'mh_count': mh_countss,
            'mhless_count': mhless_countss,
            'insert_1bp': insert_1bpss
        }

    def Lindel_trans_func(self, examples):
        refs, cut_list, del_counts, ins_counts, dstarts_list, del_lens_list, mh_lens_list  = [], [], [], [], [], [], []
        for ref1, ref2, cuts in zip(examples['ref1'], examples['ref2'], examples['cuts']):
            for cut in cuts:
                # ref and cut
                cut1, cut2 = cut['cut1'], cut['cut2']
                refs.append(ref1[:cut1] + ref2[cut2:])
                cut_list.append(cut1)
                # input
                mh_matrix, rep_num, rep_val = self.num2micro_homology(ref1, ref2, cut1, cut2, ext1=2, ext2=1)
                del_lens, mh_lens, dstarts, mh_idxs = self.get_input(ref1, ref2, cut1, cut2, mh_matrix, rep_num, rep_val, "Lindel")
                mask_del_len = (del_lens > 0).logical_and(del_lens < self.config.Lindel_dlen).logical_and(dstarts < 3).logical_and(dstarts + del_lens > -2)
                mask_mh_end = torch.full(mask_del_len.shape, False)
                mask_mh_end[mh_idxs] = True
                mask = mask_del_len.logical_and((mh_lens == 0).logical_or(mask_mh_end))
                mh_lens = mh_lens[mask]
                dstarts = dstarts[mask]
                dstarts[(dstarts > 0).logical_and(dstarts <= mh_lens)] = 0
                del_lens = del_lens[mask]
                mh_lens = torch.min(del_lens, mh_lens).clamp(0, self.config.Lindel_mh_len)
                dstarts_list.append(dstarts)
                del_lens_list.append(del_lens)
                mh_lens_list.append(mh_lens)
                #output
                observations, insert_counts = self.get_observations(ref1, ref2, cut, INSERT_LIMIT=2, count_long_insertion=True)
                ins_counts.append(insert_counts)
                counts = self.get_output(observations, rep_num, rep_val, "Lindel")               
                del_counts.append(counts[mask_del_len])
        return {
            'ref': refs,
            'cut': cut_list,
            'del_count': del_counts,
            'ins_count': ins_counts,
            'dstart': dstarts_list,
            'del_len': del_lens_list,
            'mh_len': mh_lens_list
        }

    def FOREcasT_trans_func(self, examples):
        refs, cut_list, total_counts = [], [], []
        for ref1, ref2, cuts in zip(examples['ref1'], examples['ref2'], examples['cuts']):
            for cut in cuts:
                # ref and cut
                cut1, cut2 = cut["cut1"], cut["cut2"]
                refs.append(ref1[:cut1] + ref2[cut2:])
                cut_list.append(cut['cut1'])
                # input
                mh_matrix, rep_num, rep_val = self.num2micro_homology(ref1, ref2, cut1, cut2)
                del_lens, dstarts = self.get_input(ref1, ref2, cut1, cut2, mh_matrix, rep_num, rep_val, "FOREcasT")
                mask_del_len = (del_lens >= 0).logical_and(del_lens <= self.config.FOREcasT_MAX_DEL_SIZE).logical_and(dstarts <= 0).logical_and(dstarts + del_lens >= 0)
                # output
                observations, insert_counts = self.get_observations(ref1, ref2, cut, RANDOM_INSERT_LIMIT=0, INSERT_LIMIT=2)
                counts = self.get_output(observations, rep_num, rep_val, "FOREcasT")
                total_counts.append(torch.cat([
                    counts[mask_del_len],
                    insert_counts
                ]))
        return {
            'ref': refs,
            'cut': cut_list,
            'count': total_counts
        }

    # This is an example of a dataset with multiple configurations.
    # If you don't want/need to define several sub-sets in your dataset,
    # just remove the BUILDER_CONFIG_CLASS and the BUILDER_CONFIGS attributes.

    # If you need to make complex sub-parts in the datasets with configurable options
    # You can create your own builder configuration class to store attribute, inheriting from datasets.BuilderConfig
    # BUILDER_CONFIG_CLASS = MyBuilderConfig

    # You will be able to load one or the other configurations in the following list with
    # data = datasets.load_dataset('path_to_CRISPR_data', 'config_name')

    features_CRISPR_transformer = datasets.Features({
        'ref1': datasets.Value('string'),
        'ref2': datasets.Value('string'),
        'ob_ref1': datasets.Sequence(datasets.Value('int16')),
        'ob_ref2': datasets.Sequence(datasets.Value('int16')),
        'ob_val': datasets.Sequence(datasets.Value('int64'))
    })

    features_CRISPR_diffuser = datasets.Features({
        'ref1': datasets.Value('string'),
        'ref2': datasets.Value('string'),
        'cut1': datasets.Value('int16'),
        'cut2': datasets.Value('int16'),
        'mh_ref1': datasets.Sequence(datasets.Value('int16')),
        'mh_ref2': datasets.Sequence(datasets.Value('int16')),
        'mh_val': datasets.Sequence(datasets.Value('int16')),
        'ob_ref1': datasets.Sequence(datasets.Value('int16')),
        'ob_ref2': datasets.Sequence(datasets.Value('int16')),
        'ob_val': datasets.Sequence(datasets.Value('int64'))
    })

    features_inDelphi = datasets.Features({
        'ref': datasets.Value('string'),
        'cut': datasets.Value('int16'),
        'mh_gt_pos': datasets.Sequence(datasets.Value('int16')),
        'mh_del_len': datasets.Sequence(datasets.Value('int16')),
        'mh_mh_len': datasets.Sequence(datasets.Value('int16')),
        'mh_gc_frac': datasets.Sequence(datasets.Value('float32')),
        'mh_count': datasets.Sequence(datasets.Value('int64')),
        'mhless_count': datasets.Sequence(datasets.Value('int64')),
        'insert_1bp': datasets.Sequence(datasets.Value('int64'))
    })

    features_Lindel = datasets.Features({
        'ref': datasets.Value('string'),
        'cut': datasets.Value('int16'),
        'del_count': datasets.Sequence(datasets.Value('int64')),
        'ins_count': datasets.Sequence(datasets.Value('int64'))
    })

    features_FOREcasT = datasets.Features({
        'ref': datasets.Value('string'),
        'cut': datasets.Value('int16'),
        'count': datasets.Sequence(datasets.Value('float32'))
    })

    VERSION = datasets.Version("1.0.0")

    BUILDER_CONFIG_CLASS = CRISPRDataConfig

    BUILDER_CONFIGS = [
        CRISPRDataConfig(
            author_filter = lambda author, ref1, ref2, cut1, cut2: author == "SX",
            file_filter = lambda file, ref1, ref2, cut1, cut2, author: bool(re.search("^(A2-|A7-|D2-)", file)),
            features = features_CRISPR_transformer,
            name = "SX_spcas9_CRISPR_transformer",
            version = VERSION,
            description = "Data of spcas9 protein of sx and lcy for CRISPR transformer training"
        ),
        CRISPRDataConfig(
            author_filter = lambda author, ref1, ref2, cut1, cut2: author == "SX",
            file_filter = lambda file, ref1, ref2, cut1, cut2, author: bool(re.search("^(X-|x-|B2-|36t-)", file)),
            features = features_CRISPR_transformer,
            name = "SX_spymac_CRISPR_transformer",
            version = VERSION,
            description = "Data of spymac protein of sx and lcy for CRISPR transformer training"
        ),
        CRISPRDataConfig(
            author_filter = lambda author, ref1, ref2, cut1, cut2: author == "SX",
            file_filter = lambda file, ref1, ref2, cut1, cut2, author: bool(re.search("^(i10t-|i83-)", file)),
            features = features_CRISPR_transformer,
            name = "SX_ispymac_CRISPR_transformer",
            version = VERSION,
            description = "Data of ispymac protein of sx and lcy for CRISPR transformer training"
        ),

        CRISPRDataConfig(
            author_filter = lambda author, ref1, ref2, cut1, cut2: author == "SX",
            file_filter = lambda file, ref1, ref2, cut1, cut2, author: bool(re.search("^(A2-|A7-|D2-)", file)),
            features = features_CRISPR_diffuser,
            name = "SX_spcas9_CRISPR_diffuser",
            version = VERSION,
            description = "Data of spcas9 protein of sx and lcy for CRISPR diffuser training"
        ),
        CRISPRDataConfig(
            author_filter = lambda author, ref1, ref2, cut1, cut2: author == "SX",
            file_filter = lambda file, ref1, ref2, cut1, cut2, author: bool(re.search("^(X-|x-|B2-|36t-)", file)),
            features = features_CRISPR_diffuser,
            name = "SX_spymac_CRISPR_diffuser",
            version = VERSION,
            description = "Data of spymac protein of sx and lcy for CRISPR diffuser training"
        ),
        CRISPRDataConfig(
            author_filter = lambda author, ref1, ref2, cut1, cut2: author == "SX",
            file_filter = lambda file, ref1, ref2, cut1, cut2, author: bool(re.search("^(i10t-|i83-)", file)),
            features = features_CRISPR_diffuser,
            name = "SX_ispymac_CRISPR_diffuser",
            version = VERSION,
            description = "Data of ispymac protein of sx and lcy for CRISPR diffuser training"
        ),

        CRISPRDataConfig(
            author_filter = lambda author, ref1, ref2, cut1, cut2: author == "SX",
            file_filter = lambda file, ref1, ref2, cut1, cut2, author: bool(re.search("^(A2-|A7-|D2-)", file)),
            features = features_inDelphi,
            name = "SX_spcas9_inDelphi",
            version = VERSION,
            description = "Data of spcas9 protein of sx and lcy for inDelphi training"
        ),
        CRISPRDataConfig(
            author_filter = lambda author, ref1, ref2, cut1, cut2: author == "SX",
            file_filter = lambda file, ref1, ref2, cut1, cut2, author: bool(re.search("^(X-|x-|B2-|36t-)", file)),
            features = features_inDelphi,
            name = "SX_spymac_inDelphi",
            version = VERSION,
            description = "Data of spymac protein of sx and lcy for inDelphi training"
        ),
        CRISPRDataConfig(
            author_filter = lambda author, ref1, ref2, cut1, cut2: author == "SX",
            file_filter = lambda file, ref1, ref2, cut1, cut2, author: bool(re.search("^(i10t-|i83-)", file)),
            features = features_inDelphi,
            name = "SX_ispymac_inDelphi",
            version = VERSION,
            description = "Data of ispymac protein of sx and lcy for inDelphi training"
        ),

        CRISPRDataConfig(
            author_filter = lambda author, ref1, ref2, cut1, cut2: author == "SX",
            file_filter = lambda file, ref1, ref2, cut1, cut2, author: bool(re.search("^(A2-|A7-|D2-)", file)),
            features = features_Lindel,
            name = "SX_spcas9_Lindel",
            version = VERSION,
            description = "Data of spcas9 protein of sx and lcy for Lindel training"
        ),
        CRISPRDataConfig(
            author_filter = lambda author, ref1, ref2, cut1, cut2: author == "SX",
            file_filter = lambda file, ref1, ref2, cut1, cut2, author: bool(re.search("^(X-|x-|B2-|36t-)", file)),
            features = features_Lindel,
            name = "SX_spymac_Lindel",
            version = VERSION,
            description = "Data of spymac protein of sx and lcy for Lindel training"
        ),
        CRISPRDataConfig(
            author_filter = lambda author, ref1, ref2, cut1, cut2: author == "SX",
            file_filter = lambda file, ref1, ref2, cut1, cut2, author: bool(re.search("^(i10t-|i83-)", file)),
            features = features_Lindel,
            name = "SX_ispymac_Lindel",
            version = VERSION,
            description = "Data of ispymac protein of sx and lcy for Lindel training"
        ),

        CRISPRDataConfig(
            author_filter = lambda author, ref1, ref2, cut1, cut2: author == "SX",
            file_filter = lambda file, ref1, ref2, cut1, cut2, author: bool(re.search("^(A2-|A7-|D2-)", file)),
            features = features_FOREcasT,
            name = "SX_spcas9_FOREcasT",
            version = VERSION,
            description = "Data of spcas9 protein of sx and lcy for FOREcasT training"
        ),
        CRISPRDataConfig(
            author_filter = lambda author, ref1, ref2, cut1, cut2: author == "SX",
            file_filter = lambda file, ref1, ref2, cut1, cut2, author: bool(re.search("^(X-|x-|B2-|36t-)", file)),
            features = features_FOREcasT,
            name = "SX_spymac_FOREcasT",
            version = VERSION,
            description = "Data of spymac protein of sx and lcy for FOREcasT training"
        ),
        CRISPRDataConfig(
            author_filter = lambda author, ref1, ref2, cut1, cut2: author == "SX",
            file_filter = lambda file, ref1, ref2, cut1, cut2, author: bool(re.search("^(i10t-|i83-)", file)),
            features = features_FOREcasT,
            name = "SX_ispymac_FOREcasT",
            version = VERSION,
            description = "Data of ispymac protein of sx and lcy for FOREcasT training"
        ),
    ]

    # DEFAULT_CONFIG_NAME = "SX_spcas9"  # It's not mandatory to have a default configuration. Just use one if it make sense.

    def _info(self):
        return datasets.DatasetInfo(
            # This is the description that will appear on the datasets page.
            description="""\
                This dataset is used to train a DL model predicting editing results of CRISPR.
            """,
            # This defines the different columns of the dataset and their types
            # features=
            # If there's a common (input, target) tuple from the features, uncomment supervised_keys line below and
            # specify them. They'll be used if as_supervised=True in builder.as_dataset.
            # supervised_keys=("sentence", "label"),
            # Homepage of the dataset for documentation
            # homepage=_HOMEPAGE,
            # License for the dataset if available
            # license=_LICENSE,
            # Citation for the dataset
            # citation=_CITATION,
        )

    def _split_generators(self, dl_manager):
        # TODO: This method is tasked with downloading/extracting the data and defining the splits depending on the configuration
        # If several configurations are possible (listed in BUILDER_CONFIGS), the configuration selected by the user is in self.config.name

        # dl_manager is a datasets.download.DownloadManager that can be used to download and extract URLS
        # It can accept any type or nested list/dict and will give back the same structure with the url replaced with path to local files.
        # By default the archives will be extracted and a path to a cached folder where they are extracted is returned instead of the archive
        proxy_url = os.environ.get("MY_HF_DATASETS_DOWNLOAD_MANAGER_PROXY")
        if proxy_url:
            from datasets.download.download_manager import DownloadManager, DownloadConfig
            dl_manager_proxy = DownloadManager(
                download_config=DownloadConfig(
                    proxies={
                        "http": proxy_url,
                        "https": proxy_url
                    }
                )
            )
            downloaded_files = dl_manager_proxy.download("https://github.com/ljw20180420/CRISPRdata/raw/refs/heads/main/dataset.json.gz")
        else:
            downloaded_files = dl_manager.download("https://github.com/ljw20180420/CRISPRdata/raw/refs/heads/main/dataset.json.gz")
        # hf_endpoint = os.environ.get("HF_ENDPOINT", "https://" + "huggingface.co")
        # downloaded_files = dl_manager.download(f"{hf_endpoint}/datasets/ljw20180420/CRISPR_data/resolve/main/dataset.json.gz")
        # downloaded_files = dl_manager.download("./test.json.gz")
        
        ds = datasets.load_dataset('json', data_files=downloaded_files, features=datasets.Features({
            'ref1': datasets.Value('string'),
            'ref2': datasets.Value('string'),
            'cuts': [datasets.Features({
                'cut1': datasets.Value('int16'),
                'cut2': datasets.Value('int16'),
                'authors': [datasets.Features({
                    'author': datasets.Value('string'),
                    'files': [datasets.Features({
                        'file': datasets.Value('string'),
                        'ref1_end': datasets.Sequence(datasets.Value('int16')),
                        'ref2_start': datasets.Sequence(datasets.Value('int16')),
                        'random_insert': datasets.Sequence(datasets.Value('string')),
                        'count': datasets.Sequence(datasets.Value('int64'))
                    })]
                })]
            })]
        }))
        ds = ds.map(self.filter_refs, batched=True)
        if self.config.name.endswith("_CRISPR_transformer"):
            ds = ds.map(self.CRISPR_transformer_trans_func, batched=True, remove_columns=['cuts'])
        elif self.config.name.endswith("_CRISPR_diffuser"):
            ds = ds.map(self.CRISPR_diffuser_trans_func, batched=True, remove_columns=['cuts'])
        elif self.config.name.endswith("_inDelphi"):
            ds = ds.map(self.inDelphi_trans_func, batched=True, remove_columns=['ref1', 'ref2', 'cuts'])
        elif self.config.name.endswith("_Lindel"):
            ds = ds.map(self.Lindel_trans_func, batched=True, remove_columns=['ref1', 'ref2', 'cuts'])
        elif self.config.name.endswith("_FOREcasT"):
            ds = ds.map(self.FOREcasT_trans_func, batched=True, remove_columns=['ref1', 'ref2', 'cuts'])
        ds = self.split_train_valid_test(ds)
        return [
            datasets.SplitGenerator(
                name=datasets.Split.TRAIN,
                # These kwargs will be passed to _generate_examples
                gen_kwargs={
                    "dataset": ds['train'],
                },
            ),
            datasets.SplitGenerator(
                name=datasets.Split.VALIDATION,
                # These kwargs will be passed to _generate_examples
                gen_kwargs={
                    "dataset": ds['validation'],
                },
            ),
            datasets.SplitGenerator(
                name=datasets.Split.TEST,
                # These kwargs will be passed to _generate_examples
                gen_kwargs={
                    "dataset": ds['test'],
                },
            )
        ]

    # method parameters are unpacked from `gen_kwargs` as given in `_split_generators`
    def _generate_examples(self, dataset):
        # TODO: This method handles input defined in _split_generators to yield (key, example) tuples from the dataset.
        # The `key` is for legacy reasons (tfds) and is not important in itself, but must be unique for each example.
        for id, example in enumerate(dataset):
            yield id, example

    def split_train_valid_test(self, ds):
        # Divide ds's train split to validation and test splits.
        ds = ds['train'].train_test_split(test_size=self.config.test_ratio + self.config.validation_ratio, shuffle=True, seed=self.config.seed)
        ds_valid_test = ds['test'].train_test_split(test_size=self.config.test_ratio / (self.config.test_ratio + self.config.validation_ratio), shuffle=False)
        ds['validation'] = ds_valid_test.pop('train')
        ds['test'] = ds_valid_test.pop('test')
        return ds

    def filter_refs(self, examples):
        ref1s, ref2s, cutss = [], [], []
        for ref1, ref2, cuts in zip(examples['ref1'], examples['ref2'], examples['cuts']):
            if self.config.ref_filter is None or self.config.ref_filter(ref1, ref2):
                if self.config.cut_filter is not None or self.config.author_filter is not None or self.config.file_filter is not None:
                    cuts = self.filter_cuts(cuts, ref1, ref2)
                if cuts:
                    ref1s.append(ref1)
                    ref2s.append(ref2)
                    cutss.append(cuts)
        return {
            "ref1": ref1s,
            "ref2": ref2s,
            "cuts": cutss
        }

    def filter_cuts(self, cuts, ref1, ref2):
        new_cuts = []
        for cut in cuts:
            if self.config.cut_filter is None or self.config.cut_filter(cut["cut1"], cut["cut2"], ref1, ref2):
                if self.config.author_filter is not None or self.config.file_filter is not None:
                    cut["authors"] = self.filter_authors(cut["authors"], ref1, ref2, cut["cut1"], cut["cut2"])
                if cut["authors"]:
                    new_cuts.append(cut)
        return new_cuts

    def filter_authors(self, authors, ref1, ref2, cut1, cut2):
        new_authors = []
        for author in authors:
            if self.config.author_filter is None or self.config.author_filter(author["author"], ref1, ref2, cut1, cut2):
                if self.config.file_filter is not None:
                    author["files"] = self.filter_files(author["files"], ref1, ref2, cut1, cut2, author["author"])
                if author["files"]:
                    new_authors.append(author)
        return new_authors
    
    def filter_files(self, files, ref1, ref2, cut1, cut2, author):
        return [file for file in files if self.config.file_filter(file["file"], ref1, ref2, cut1, cut2, author)]