Update multi-model-plant-genome-corpus.py

multi-model-plant-genome-corpus.py

@@ -1,14 +1,4 @@
-"""
-Script for the plant multi-species genomes dataset. 
-This dataset contains the genomes from 11 different species.
-
-Added functionality:
-- `split_mode` argument in load_dataset. 
-  "chromosome" (default): Original splitting by chromosome records.
-  "genome": Split by genome size (smallest 2 -> val, next 2 -> test, rest -> train).
-"""
-
-from typing import List
+from typing import List, Dict
 import datasets
 from Bio import SeqIO
 import os
@@ -57,12 +47,11 @@ def clean_sequence(seq: str) -> str:
 
 class PlantMultiSpeciesGenomesConfig(datasets.BuilderConfig):
     """BuilderConfig for the Plant Multi Species Pre-training Dataset."""
-    def __init__(self, *args, chunk_length: int, overlap: int = 100, split_mode: str = "chromosome", **kwargs):
+    def __init__(self, *args, chunk_length: int, overlap: int = 100, **kwargs):
         """
         Args:
             chunk_length (int): length of each chunk
             overlap (int): overlap size (defaults to 100)
-            split_mode (str): "chromosome" or "genome"
         """
         num_kbp = int(chunk_length/1000)
         super().__init__(
@@ -72,24 +61,20 @@ class PlantMultiSpeciesGenomesConfig(datasets.BuilderConfig):
         )
         self.chunk_length = chunk_length
         self.overlap = overlap
-        self.split_mode = split_mode
 
 class PlantMultiSpeciesGenomes(datasets.GeneratorBasedBuilder):
     VERSION = datasets.Version("1.1.0")
     BUILDER_CONFIG_CLASS = PlantMultiSpeciesGenomesConfig
-    # Allow user to specify split_mode via load_dataset(..., split_mode="chromosome" or "genome")
     BUILDER_CONFIGS = [
-        PlantMultiSpeciesGenomesConfig(chunk_length=chunk_length, split_mode="chromosome") for chunk_length in _CHUNK_LENGTHS
+        PlantMultiSpeciesGenomesConfig(chunk_length=chunk_length) for chunk_length in _CHUNK_LENGTHS
     ]
-
     DEFAULT_CONFIG_NAME = "1kbp"
 
     @classmethod
-    def from_config(cls, chunk_length=1000, overlap=100, split_mode="chromosome", **kwargs):
+    def from_config(cls, chunk_length=1000, overlap=100, **kwargs):
         return cls(PlantMultiSpeciesGenomesConfig(
             chunk_length=chunk_length,
             overlap=overlap,
-            split_mode=split_mode,
             **kwargs
         ))
 
@@ -110,6 +95,51 @@ class PlantMultiSpeciesGenomes(datasets.GeneratorBasedBuilder):
             citation=_CITATION,
         )
 
+    def _calculate_split_ratio(self, size: int, total_size: int) -> float:
+        """
+        Calculate the split ratio for validation and test sets based on genome size.
+        Args:
+            size: Size of the current genome
+            total_size: Total size of all genomes
+        Returns:
+            float: Ratio to use for validation and test sets
+        """
+        size_ratio = size / total_size
+        
+        if size_ratio > 0.2:  # Very large genomes (>20% of total)
+            return 0.002  # 0.2%
+        elif size_ratio > 0.1:  # Large genomes (10-20% of total)
+            return 0.005  # 0.5%
+        elif size_ratio > 0.05:  # Medium genomes (5-10% of total)
+            return 0.01  # 1%
+        else:  # Small genomes (<5% of total)
+            return 0.02  # 2%
+
+    def _split_genome(self, records: List, ratio: float) -> Dict[str, List]:
+        """
+        Split a genome's records into train, validation, and test sets.
+        Args:
+            records: List of genome records
+            ratio: Ratio to use for validation and test sets
+        Returns:
+            Dict containing split records
+        """
+        total_records = len(records)
+        n_val = max(1, int(total_records * ratio))
+        n_test = max(1, int(total_records * ratio))
+        
+        # Cap at total 10% for validation + test
+        if n_val + n_test > total_records * 0.1:
+            scale = total_records * 0.1 / (n_val + n_test)
+            n_val = int(n_val * scale)
+            n_test = int(n_test * scale)
+        
+        return {
+            'val': records[:n_val],
+            'test': records[n_val:n_val+n_test],
+            'train': records[n_val+n_test:]
+        }
+
     def _split_generators(self, dl_manager: datasets.DownloadManager) -> List[datasets.SplitGenerator]:
         # Download filepaths
         filepaths_txt = dl_manager.download_and_extract('plant_genome_file_names.txt')
@@ -117,160 +147,78 @@ class PlantMultiSpeciesGenomes(datasets.GeneratorBasedBuilder):
             filepaths = [os.path.join("plant_genomes", filepath.rstrip()) for filepath in f]
 
         genome_files = [dl_manager.download_and_extract(f) for f in filepaths]
-
-        if self.config.split_mode == "chromosome":
-            # Chromosome-based splitting as before
-            genome_chromos = []
-            for file in genome_files:
-                with open(file, 'rt') as f:
-                    records = list(SeqIO.parse(f, 'fasta'))
-                    n_val = max(1, len(records) // 10)
-                    n_test = max(1, len(records) // 10)
-
-                    genome_chromos.append({
-                        'val': records[-n_val:],
-                        'test': records[-(n_val+n_test):-n_val],
-                        'train': records[:-(n_val+n_test)]
-                    })
-
-            splits = {'train': [], 'val': [], 'test': []}
-            for i, file in enumerate(genome_files):
+        
+        # Calculate total genome size and individual sizes
+        genome_sizes = {}
+        total_size = 0
+        for file in genome_files:
+            with open(file, 'rt') as f:
+                size = sum(len(str(record.seq)) for record in SeqIO.parse(f, 'fasta'))
+                genome_sizes[file] = size
+                total_size += size
+
+        # Split each genome and store records
+        split_records = {'train': [], 'val': [], 'test': []}
+        for file in genome_files:
+            with open(file, 'rt') as f:
+                records = list(SeqIO.parse(f, 'fasta'))
+                ratio = self._calculate_split_ratio(genome_sizes[file], total_size)
+                splits = self._split_genome(records, ratio)
+                
                 for split_type in ['train', 'val', 'test']:
-                    if len(genome_chromos[i][split_type]) > 0:
-                        splits[split_type].append(file)
-
-            return [
-                datasets.SplitGenerator(
-                    name=datasets.Split.TRAIN,
-                    gen_kwargs={
-                        "files": splits['train'],
-                        "chunk_length": self.config.chunk_length,
-                        "chromo_splits": genome_chromos,
-                        "split_type": "train"
-                    }
-                ),
-                datasets.SplitGenerator(
-                    name=datasets.Split.VALIDATION,
-                    gen_kwargs={
-                        "files": splits['val'],
-                        "chunk_length": self.config.chunk_length,
-                        "chromo_splits": genome_chromos,
-                        "split_type": "val"
-                    }
-                ),
-                datasets.SplitGenerator(
-                    name=datasets.Split.TEST,
-                    gen_kwargs={
-                        "files": splits['test'],
-                        "chunk_length": self.config.chunk_length,
-                        "chromo_splits": genome_chromos,
-                        "split_type": "test"
-                    }
-                ),
-            ]
-        else:
-            file_lengths = []
-            for file in genome_files:
-                with open(file, 'rt') as f:
-                    length_sum = 0
-                    for rec in SeqIO.parse(f, 'fasta'):
-                        length_sum += len(rec.seq)
-                    file_lengths.append((file, length_sum))
-
-            file_lengths.sort(key=lambda x: x[1])  # smallest first
-
-            val_files = [fl[0] for fl in file_lengths[:1]]
-            test_files = [fl[0] for fl in file_lengths[1:2]]
-            train_files = [fl[0] for fl in file_lengths[2:]]
-
-            return [
-                datasets.SplitGenerator(
-                    name=datasets.Split.TRAIN,
-                    gen_kwargs={
-                        "files": train_files,
-                        "chunk_length": self.config.chunk_length,
-                        "chromo_splits": None,  # not used
-                        "split_type": "train"
-                    }
-                ),
-                datasets.SplitGenerator(
-                    name=datasets.Split.VALIDATION,
-                    gen_kwargs={
-                        "files": val_files,
-                        "chunk_length": self.config.chunk_length,
-                        "chromo_splits": None,
-                        "split_type": "val"
-                    }
-                ),
-                datasets.SplitGenerator(
-                    name=datasets.Split.TEST,
-                    gen_kwargs={
-                        "files": test_files,
-                        "chunk_length": self.config.chunk_length,
-                        "chromo_splits": None,
-                        "split_type": "test"
-                    }
-                ),
-            ]
-
-
-    def _generate_examples(self, files, chunk_length, chromo_splits, split_type):
+                    if len(splits[split_type]) > 0:
+                        split_records[split_type].append((file, splits[split_type]))
+
+        return [
+            datasets.SplitGenerator(
+                name=datasets.Split.TRAIN,
+                gen_kwargs={
+                    "split_records": split_records['train'],
+                    "chunk_length": self.config.chunk_length,
+                    "overlap": self.config.overlap
+                }
+            ),
+            datasets.SplitGenerator(
+                name=datasets.Split.VALIDATION,
+                gen_kwargs={
+                    "split_records": split_records['val'],
+                    "chunk_length": self.config.chunk_length,
+                    "overlap": self.config.overlap
+                }
+            ),
+            datasets.SplitGenerator(
+                name=datasets.Split.TEST,
+                gen_kwargs={
+                    "split_records": split_records['test'],
+                    "chunk_length": self.config.chunk_length,
+                    "overlap": self.config.overlap
+                }
+            ),
+        ]
+
+    def _generate_examples(self, split_records, chunk_length, overlap):
         key = 0
-        if self.config.split_mode == "chromosome":
-            for file_idx, file in enumerate(files):
-                with open(file, 'rt') as f:
-                    records = list(SeqIO.parse(f, 'fasta'))
-                    target_chromos = chromo_splits[file_idx][split_type]
+        for file, records in split_records:
+            for record in records:
+                sequence = clean_sequence(str(record.seq))
+                seq_length = len(sequence)
+                num_chunks = (seq_length - 2 * overlap) // chunk_length
+                
+                if num_chunks < 1:
+                    continue
                     
-                    for record in records:
-                        if any(record.id == target.id for target in target_chromos):
-                            sequence = clean_sequence(str(record.seq))
-                            seq_length = len(sequence)
-                            num_chunks = (seq_length - 2 * self.config.overlap) // chunk_length
-                            
-                            if num_chunks < 1:
-                                continue
-                                
-                            sequence = sequence[:(chunk_length * num_chunks + 2 * self.config.overlap)]
-                            seq_length = len(sequence)
-                            
-                            for i in range(num_chunks):
-                                start_pos = i * chunk_length
-                                end_pos = min(seq_length, (i+1) * chunk_length + 2 * self.config.overlap)
-                                chunk_sequence = sequence[start_pos:end_pos]
-                                
-                                yield key, {
-                                    'sequence': chunk_sequence,
-                                    'description': record.description,
-                                    'start_pos': start_pos,
-                                    'end_pos': end_pos,
-                                }
-                                key += 1
-        else:
-            for file in files:
-                with open(file, 'rt') as f:
-                    fasta_sequences = SeqIO.parse(f, 'fasta')
-
-                    for record in fasta_sequences:
-                        sequence = clean_sequence(str(record.seq))
-                        seq_length = len(sequence)
-                        num_chunks = (seq_length - 2 * self.config.overlap) // chunk_length
-
-                        if num_chunks < 1:
-                            continue
-
-                        sequence = sequence[:(chunk_length * num_chunks + 2 * self.config.overlap)]
-                        seq_length = len(sequence)
-
-                        for i in range(num_chunks):
-                            start_pos = i * chunk_length
-                            end_pos = min(seq_length, (i+1) * chunk_length + 2 * self.config.overlap)
-                            chunk_sequence = sequence[start_pos:end_pos]
-
-                            yield key, {
-                                'sequence': chunk_sequence,
-                                'description': record.description,
-                                'start_pos': start_pos,
-                                'end_pos': end_pos,
-                            }
-                            key += 1
+                sequence = sequence[:(chunk_length * num_chunks + 2 * overlap)]
+                seq_length = len(sequence)
+                
+                for i in range(num_chunks):
+                    start_pos = i * chunk_length
+                    end_pos = min(seq_length, (i+1) * chunk_length + 2 * overlap)
+                    chunk_sequence = sequence[start_pos:end_pos]
+                    
+                    yield key, {
+                        'sequence': chunk_sequence,
+                        'description': record.description,
+                        'start_pos': start_pos,
+                        'end_pos': end_pos,
+                    }
+                    key += 1