Update dataset.py

updates for split folder and removed local dir

dataset.py

@@ -1,86 +1,88 @@
-
 import os
 import json
-import time
 from PIL import Image
 from torch.utils.data import Dataset, DataLoader
 from torchvision import transforms
 
 class RQADataset(Dataset):
-    def __init__(self, data_config, transform=None):
+    def __init__(self, data_dir, split='train', transform=None):
         """
         Initializes the dataset.
 
         Args:
-            data_config: Configuration object containing paths and settings.
+            data_dir: Base directory of the dataset on the Hugging Face Hub.
+            split: Split of the dataset ('train' or 'test').
             transform: Optional transform to be applied on a sample.
         """
-        self.img_dir = data_config.img_dir
-        self.json_dir = data_config.json_dir
-        self.filter_list_file = data_config.filter_list
-        self.train = data_config.train
+        self.data_dir = data_dir
+        self.split = split
         self.transform = transform or transforms.Compose([
-            transforms.Resize((512, 512))
+            transforms.Resize((512, 512)),
+            transforms.ToTensor()
         ])
 
+        # Initialize lists to hold image and question data
         self.questions = []
-
-        # Load file names for testing or use all files for training
         self.file_names = self._load_file_names()
         self._create_questions()
         print(f"Total Questions Loaded: {len(self.questions)}")
 
     def _load_file_names(self):
         """
-        Loads the list of file names to be processed.
+        Loads the list of file names to be processed based on the split.
 
         Returns:
             A list of file names without extensions.
         """
-        if not self.train and self.filter_list_file:
-            with open(self.filter_list_file, 'r') as f:
+        if self.split == 'test':
+            # Load test file names from the list provided on Hugging Face
+            filter_list_file = os.path.join(self.data_dir, 'test_filenames.txt')
+            with open(filter_list_file, 'r') as f:
                 file_names = [line.strip() for line in f]
-            print(f"Loaded {len(file_names)} test files from {self.filter_list_file}")
-            return file_names
+            print(f"Loaded {len(file_names)} test files from {filter_list_file}")
         else:
-            # Use all files for training
-            return [os.path.splitext(file)[0] for file in os.listdir(self.json_dir) if file.endswith('.json')]
+            # For training, use all JSON files from all directories
+            file_names = []
+            for json_dir in ['jsons', 'jsons2', 'jsons3']:
+                json_dir_path = os.path.join(self.data_dir, json_dir)
+                json_files = [os.path.splitext(file)[0] for file in os.listdir(json_dir_path) if file.endswith('.json')]
+                file_names.extend(json_files)
+        return file_names
 
     def _create_questions(self):
         """
         Creates the list of questions from JSON files.
         """
-        start_time = time.time()
         unused_count = 0
-
         for file_name in self.file_names:
-            json_path = os.path.join(self.json_dir, file_name + '.json')
-            if not os.path.exists(json_path):
-                unused_count += 1
-                continue
-
+            # Determine which folder contains the current JSON file
+            if file_name in os.listdir(os.path.join(self.data_dir, 'jsons')):
+                json_path = os.path.join(self.data_dir, 'jsons', f"{file_name}.json")
+                img_dir = 'images'
+            elif file_name in os.listdir(os.path.join(self.data_dir, 'jsons2')):
+                json_path = os.path.join(self.data_dir, 'jsons2', f"{file_name}.json")
+                img_dir = 'images2'
+            else:
+                json_path = os.path.join(self.data_dir, 'jsons3', f"{file_name}.json")
+                img_dir = 'images3'
+
+            # Load questions from the JSON file
             with open(json_path, 'r') as f:
                 json_data = json.load(f)
                 for item in json_data:
                     if 'PMC_ID' not in item or 'qa_id' not in item:
                         continue  # Ensure all necessary fields are present
-                    item['image_path'] = os.path.join(self.img_dir, item['PMC_ID'] + '.jpg')
+                    item['image_path'] = os.path.join(self.data_dir, img_dir, f"{item['PMC_ID']}.jpg")
                     if os.path.exists(item['image_path']):
                         self.questions.append(item)
                     else:
                         unused_count += 1
-
-        elapsed_time = time.time() - start_time
-        print(f"Elapsed time to create questions: {elapsed_time:.2f} seconds = {elapsed_time/60:.2f} minutes")
-        print(f'Total unused/used images: {unused_count} / {len(self.file_names) - unused_count}')
+        print(f"Total unused/used images: {unused_count} / {len(self.file_names) - unused_count}")
 
     def __len__(self):
         return len(self.questions)
 
     def __getitem__(self, idx):
-        return self._load_data(idx)
-
-    def _load_data(self, idx):
         """
         Loads a single data point.
 
@@ -132,37 +134,8 @@ class RQADataset(Dataset):
         }
 
 if __name__ == "__main__":
-    # Define a simple data structure to hold the paths
-    class DataConfig:
-        img_dir = '/home/jupyter/RealCQA/code/data/RQA_V0/images'
-        json_dir = '/home/jupyter/RealCQA/code/data/RQA_V0/qa'
-        filter_list = '/home/jupyter/RealCQA/code/data/RQA_V0/test_filenames.txt'
-        train = False  # Set to False to prepare the test files
-
-    # Initialize dataset
-    dataset = RQADataset(DataConfig)
-
-    # Test loading a single item
-    print(f"Number of samples in dataset: {len(dataset)}")
-    sample = dataset[0]
-    print("Sample data:", sample)
-
-    # Initialize DataLoader
-    dataloader = DataLoader(dataset, batch_size=4, collate_fn=RQADataset.custom_collate)
-
-    # Test DataLoader
-    for batch in dataloader:
-        print("Batch data:", batch)
-        break  # Load only one batch for testing
-    
-    class DataConfig:
-        img_dir = '/home/jupyter/RealCQA/code/data/RQA_V0/images'
-        json_dir = '/home/jupyter/RealCQA/code/data/RQA_V0/qa'
-        filter_list = '/home/jupyter/RealCQA/code/data/RQA_V0/test_filenames.txt'
-        train = True  # Set to False to prepare the test files
-
-    # Initialize dataset
-    dataset = RQADataset(DataConfig)
+    # Initialize dataset for training
+    dataset = RQADataset(data_dir='.', split='train')
 
     # Test loading a single item
     print(f"Number of samples in dataset: {len(dataset)}")