utils/Dataloader.py

from easyfsl.samplers import TaskSampler
from torch.utils.data import DataLoader
from torch.utils.data import DataLoader
from utils.Dataset import Jammer_Dataset
from torch.utils.data import DataLoader, random_split
from pathlib import Path
from utils.Dataset import augment_sample,augment_data,balance_data
from statistics import mean
import warnings
import torchvision.transforms as transforms
from utils.utils import *

warnings.filterwarnings("ignore")

warnings.filterwarnings("default")


transform = transforms.Compose([
    transforms.RandomHorizontalFlip(),
    transforms.RandomVerticalFlip(),
    transforms.RandomHorizontalFlip(),
    transforms.RandomVerticalFlip(),
])


def create_datasets_and_loaders(
    root_dir,
    train_test_split_dir,
    permutations,
    n_way,
    n_shot,
    n_query,
    n_tasks_per_epoch,
    n_validation_tasks,
    n_workers,
    env_no,
    transforms=None,
    
):
    # train_loaders = []
    # valid_loaders = []

    permutations_str = "_".join(map(str, permutations))
    env_str = "_".join(map(str, env_no))
    train_data = load_data_from_csv(f'train_data_{permutations_str}_env{env_str}.csv')
    valid_data = load_data_from_csv(f'valid_data_{permutations_str}_env{env_str}.csv')

    train_dataset = Jammer_Dataset(root_dir, train_data, transform=transforms)
    valid_dataset = Jammer_Dataset(root_dir, valid_data, transform=transforms)

    # Create TaskSamplers for training and validation
    train_sampler = TaskSampler(
        train_dataset, n_way=n_way, n_shot=n_shot, n_query=n_query, n_tasks=n_tasks_per_epoch
    )
    val_sampler = TaskSampler(
        valid_dataset, n_way=n_way, n_shot=n_shot, n_query=n_query, n_tasks=n_validation_tasks
    )

    # Create DataLoader for training
    train_loader = DataLoader(
        train_dataset,
        batch_sampler=train_sampler,
        num_workers=n_workers,
        pin_memory=True,
        collate_fn=train_sampler.episodic_collate_fn,
    )

    # Create DataLoader for validation
    val_loader = DataLoader(
        valid_dataset,
        batch_sampler=val_sampler,
        num_workers=n_workers,
        pin_memory=True,
        collate_fn=val_sampler.episodic_collate_fn,
    )

    return train_loader, val_loader