source_code/utilities.py

import numpy as np
from glob import glob
import json


def get_training_data(dataset, rseed=0, reduce_to_binary=False):
    # Splits each class in the dataset into 80/20 for training/validation and returns a list of training and validation files aswell as their labels
    np.random.seed(rseed)
    np.random.shuffle(dataset)
    x_files = np.array([x[0] for x in dataset])
    y_classes = np.array([int(x[1]) for x in dataset])
    un_classes = np.unique(y_classes)
    classes_map = {x: i for i, x in enumerate(un_classes)}
    train_data_files = []
    valid_data_files = []
    train_classes = []
    valid_classes = []
    for c in un_classes:
        cm = classes_map[c]
        cinds = np.where(y_classes == c)[0]
        tinds = int(0.8 * len(cinds))
        train_data_files.extend(x_files[cinds[:tinds]])
        valid_data_files.extend(x_files[cinds[tinds:]])
        train_classes.extend([cm] * tinds)
        valid_classes.extend([cm] * (len(cinds) - tinds))
    if reduce_to_binary:
        train_classes = np.array(train_classes)
        train_classes[train_classes <= 2] = 0
        train_classes[train_classes > 2] = 1
        train_classes = train_classes.tolist()
        valid_classes = np.array(valid_classes)
        valid_classes[valid_classes <= 2] = 0
        valid_classes[valid_classes > 2] = 1
        valid_classes = valid_classes.tolist()
        un_classes = np.array([0, 1])
    return train_data_files, valid_data_files, train_classes, valid_classes, len(un_classes)

def load_test(cfile, cclass, time_size, norm_vals=None, use_norm=False, norm_type=1):
    cur_x_data = np.load(cfile)
    if use_norm:
        if norm_type == 1:
            cur_x_data -= norm_vals[0]
        elif norm_type == 2:
            cur_x_data = 10 ** (cur_x_data / 10.0)
    x_data = [cur_x_data, cur_x_data[::-1], cur_x_data[:, ::-1], cur_x_data[::-1, ::-1]]
    y_data = np.array([cclass, cclass, cclass, cclass]).astype("int")
    return np.asarray(x_data).astype("float32"), y_data

def gen_data_batch_test(file_list, file_classes, time_size, batchSize, norm=None, norm_type=1):
    # Expands each sample by horizontal and vertical flipping and yields them
    if norm != None:
        norm_vals = norm
        unorm = True
    else:
        unorm = False
    cur_batch_size = 0
    cur_batch_x = []
    cur_batch_y = []
    cur_batch_inds = []
    for ifl, fl in enumerate(file_list):
        data_x, data_y = load_test(fl, file_classes[ifl], time_size, norm_vals=norm_vals, use_norm=unorm, norm_type=norm_type)
        if cur_batch_size == batchSize:
            yield np.repeat(np.asarray(cur_batch_x).astype("float32")[:, np.newaxis, :, :], 3, 1), np.asarray(cur_batch_y).astype("int"), np.asarray(cur_batch_inds).astype("int")
            # Prep next batch
            cur_batch_x = []
            cur_batch_y = []
            cur_batch_x.extend(data_x)
            cur_batch_y.extend(data_y)
            cur_batch_inds = [ifl] * len(data_x)
            cur_batch_size = len(data_x)
            # ------------- #
        elif cur_batch_size + len(data_x) > batchSize:
            cur_batch_x.extend(data_x[:batchSize - cur_batch_size])
            cur_batch_y.extend(data_y[:batchSize - cur_batch_size])
            cur_batch_inds.extend([ifl] * (batchSize - cur_batch_size))
            yield np.repeat(np.asarray(cur_batch_x).astype("float32")[:, np.newaxis, :, :], 3, 1), np.asarray(cur_batch_y).astype("int"), np.asarray(cur_batch_inds).astype("int")
            # Prep next batch
            cur_batch_x = []
            cur_batch_y = []
            cur_batch_x.extend(data_x[batchSize - cur_batch_size:])
            cur_batch_y.extend(data_y[batchSize - cur_batch_size:])
            cur_batch_size = len(cur_batch_x)
            cur_batch_inds = [ifl] * cur_batch_size
            # ------------- #
        else:
            cur_batch_x.extend(data_x)
            cur_batch_y.extend(data_y)
            cur_batch_inds.extend([ifl] * len(data_x))
            cur_batch_size += len(data_x)
    if cur_batch_size > 0:
        yield np.repeat(np.asarray(cur_batch_x).astype("float32")[:, np.newaxis, :, :], 3, 1), np.asarray(cur_batch_y).astype("int"), np.asarray(cur_batch_inds).astype("int")

def get_support_data(sup_list, time_size, norm=None, norm_type=1):
    if norm != None:
        norm_vals = norm
        use_norm = True
    else:
        use_norm = False
    sup_x = []
    sup_y = []
    for isu, su in enumerate(sup_list[0]):
        cur_x_data = np.load(su)
        if use_norm:
            if norm_type == 1:
                cur_x_data -= norm_vals[0]
            elif norm_type == 2:
                cur_x_data = 10 ** (cur_x_data / 10.0)
        sup_x.append(cur_x_data)
        sup_y.append(sup_list[1][isu])
    return np.repeat(np.asarray(sup_x).astype("float32")[:, np.newaxis, :, :], 3, 1), np.asarray(sup_y).astype("int")

# For FeShot Evaluation
from abc import abstractmethod
from typing import List, Tuple

import torch
from torch import Tensor
from torch.utils.data import Dataset


class FewShotDataset(Dataset):
    """
    Abstract class for all datasets used in a context of Few-Shot Learning.
    The tools we use in few-shot learning, especially TaskSampler, expect an
    implementation of FewShotDataset.
    Compared to PyTorch's Dataset, FewShotDataset forces a method get_labels.
    This exposes the list of all items labels and therefore allows to sample
    items depending on their label.
    """

    @abstractmethod
    def __getitem__(self, item: int) -> Tuple[Tensor, int]:
        raise NotImplementedError(
            "All PyTorch datasets, including few-shot datasets, need a __getitem__ method."
        )

    @abstractmethod
    def __len__(self) -> int:
        raise NotImplementedError(
            "All PyTorch datasets, including few-shot datasets, need a __len__ method."
        )

    @abstractmethod
    def get_labels(self) -> List[int]:
        raise NotImplementedError(
            "Implementations of FewShotDataset need a get_labels method."
        )

class val_set(FewShotDataset):
    def __init__(self, file_list, label_list, time_size, norm=None, norm_type=1):
        self.norm_vals = norm
        if norm_type == 1:
            self.use_norm = True
        else:
            self.use_norm = False
        self.norm_type = norm_type
        self.images = file_list
        self.labels = label_list
        self.class_names = [str(x) for x in np.unique(self.labels)]
        self.time_size = time_size

    def __getitem__(self, item: int):
        cfile = self.images[item][0]
        cur_aug = int(self.images[item][1])
        cur_x_data = np.load(cfile)
        if cur_aug == 1:
            cur_x_data = cur_x_data[::-1]
        elif cur_aug == 2:
            cur_x_data = cur_x_data[:, ::-1]
        elif cur_aug == 3:
            cur_x_data = cur_x_data[::-1, ::-1]
        if self.use_norm:
            if self.norm_type == 1:
                cur_x_data -= self.norm_vals[0]
            elif self.norm_type == 2:
                cur_x_data = 10 ** (cur_x_data / 10.0)
        return torch.from_numpy(np.repeat(cur_x_data[np.newaxis, :, :], 3, 0).astype("float32")), self.labels[item]

    def __len__(self) -> int:
        return len(self.labels)

    def get_labels(self) -> List[int]:
        return self.labels

    def number_of_classes(self):
        return len(self.class_names)