<reponame>samlaf/self-ensemble-visual-domain-adapt-photo
import numpy as np
import cv2
from sklearn.model_selection import StratifiedShuffleSplit, ShuffleSplit


class ImageDataset (object):
    class ImageAccessor (object):
        def __init__(self, dataset):
            self.dataset = dataset

        def __len__(self):
            return len(self.dataset.paths)

        def __getitem__(self, item):
            if isinstance(item, int):
                return self.dataset.load_image(self.dataset.paths[item])
            else:
                xs = []
                if isinstance(item, slice):
                    indices = range(*item.indices(len(self)))
                elif isinstance(item, np.ndarray):
                    indices = item
                else:
                    raise TypeError('item should be an int/long, a slice or an array, not a {}'.format(
                        type(item)
                    ))
                for i in indices:
                    img = self.dataset.load_image(self.dataset.paths[i])
                    xs.append(img)
                return xs


    def __init__(self, img_size, range01, rgb_order, class_names, n_classes, names, paths, y,
                 dummy=False):
        self.img_size = img_size

        self.range01 = range01
        self.rgb_order = rgb_order

        self.dummy = dummy

        self.images = self.ImageAccessor(self)

        self.class_names = class_names
        self.n_classes = n_classes
        self.names = names
        self.paths = paths
        if y is not None:
            self.y = np.array(y, dtype=np.int32)
            self.has_ground_truth = True
        else:
            self.has_ground_truth = False


    def load_image(self, path):
        if self.dummy:
            return np.random.randint(0, 256, size=self.img_size + (3,)).astype(np.uint8)
        else:
            img = cv2.imread(path)
            if self.rgb_order:
                img = img[:, :, ::-1]
            return img


    def prediction_evaluator(self, sample_indices=None):
        if not self.has_ground_truth:
            raise ValueError('Cannot create evaluator; dataset has no ground truth')

        if sample_indices is None:
            return PredictionEvaluator(self.y, self.n_classes, self.class_names)
        else:
            return PredictionEvaluator(self.y[sample_indices], self.n_classes, self.class_names)


class PredictionEvaluator (object):
    def __init__(self, y, n_classes, class_names):
        self.y = y
        self.n_classes = n_classes
        self.class_names = class_names
        self.hist = np.bincount(y, minlength=self.n_classes)


    def evaluate(self, tgt_pred_prob_y):
        tgt_pred_y = np.argmax(tgt_pred_prob_y, axis=1)
        aug_class_true_pos = np.zeros((self.n_classes,))

        # Compute per-class accuracy
        for cls_i in range(self.n_classes):
            aug_class_true_pos[cls_i] = ((self.y == cls_i) & (tgt_pred_y == cls_i)).sum()

        aug_cls_acc = aug_class_true_pos.astype(float) / np.maximum(self.hist.astype(float), 1.0)

        mean_aug_class_acc = aug_cls_acc.mean()

        aug_cls_acc_str = ',  '.join(['{}: {:.3%}'.format(self.class_names[cls_i], aug_cls_acc[cls_i])
                                      for cls_i in range(self.n_classes)])

        return mean_aug_class_acc, aug_cls_acc_str


def subset_indices(d_source, d_target, subsetsize, subsetseed):
    if subsetsize > 0:
        if subsetseed != 0:
            subset_rng = np.random.RandomState(subsetseed)
        else:
            subset_rng = np.random
        strat = StratifiedShuffleSplit(n_splits=1, test_size=subsetsize, random_state=subset_rng)
        shuf = ShuffleSplit(n_splits=1, test_size=subsetsize, random_state=subset_rng)
        _, source_indices = next(strat.split(d_source.y, d_source.y))
        n_src = source_indices.shape[0]
        if d_target.has_ground_truth:
            _, target_indices = next(strat.split(d_target.y, d_target.y))
        else:
            _, target_indices = next(shuf.split(np.arange(len(d_target.images))))
        n_tgt = target_indices.shape[0]
    else:
        source_indices = None
        target_indices = None
        n_src = len(d_source.images)
        n_tgt = len(d_target.images)

    return source_indices, target_indices, n_src, n_tgt

import numpy as np
import cv2
from sklearn.model_selection import StratifiedShuffleSplit, ShuffleSplit


class ImageDataset (object):
    class ImageAccessor (object):
        def __init__(self, dataset):
            self.dataset = dataset

        def __len__(self):
            return len(self.dataset.paths)

        def __getitem__(self, item):
            if isinstance(item, int):
                return self.dataset.load_image(self.dataset.paths[item])
            else:
                xs = []
                if isinstance(item, slice):
                    indices = range(*item.indices(len(self)))
                elif isinstance(item, np.ndarray):
                    indices = item
                else:
                    raise TypeError('item should be an int/long, a slice or an array, not a {}'.format(
                        type(item)
                    ))
                for i in indices:
                    img = self.dataset.load_image(self.dataset.paths[i])
                    xs.append(img)
                return xs


    def __init__(self, img_size, range01, rgb_order, class_names, n_classes, names, paths, y,
                 dummy=False):
        self.img_size = img_size

        self.range01 = range01
        self.rgb_order = rgb_order

        self.dummy = dummy

        self.images = self.ImageAccessor(self)

        self.class_names = class_names
        self.n_classes = n_classes
        self.names = names
        self.paths = paths
        if y is not None:
            self.y = np.array(y, dtype=np.int32)
            self.has_ground_truth = True
        else:
            self.has_ground_truth = False


    def load_image(self, path):
        if self.dummy:
            return np.random.randint(0, 256, size=self.img_size + (3,)).astype(np.uint8)
        else:
            img = cv2.imread(path)
            if self.rgb_order:
                img = img[:, :, ::-1]
            return img


    def prediction_evaluator(self, sample_indices=None):
        if not self.has_ground_truth:
            raise ValueError('Cannot create evaluator; dataset has no ground truth')

        if sample_indices is None:
            return PredictionEvaluator(self.y, self.n_classes, self.class_names)
        else:
            return PredictionEvaluator(self.y[sample_indices], self.n_classes, self.class_names)


class PredictionEvaluator (object):
    def __init__(self, y, n_classes, class_names):
        self.y = y
        self.n_classes = n_classes
        self.class_names = class_names
        self.hist = np.bincount(y, minlength=self.n_classes)


    def evaluate(self, tgt_pred_prob_y):
        tgt_pred_y = np.argmax(tgt_pred_prob_y, axis=1)
        aug_class_true_pos = np.zeros((self.n_classes,))

        # Compute per-class accuracy
        for cls_i in range(self.n_classes):
            aug_class_true_pos[cls_i] = ((self.y == cls_i) & (tgt_pred_y == cls_i)).sum()

        aug_cls_acc = aug_class_true_pos.astype(float) / np.maximum(self.hist.astype(float), 1.0)

        mean_aug_class_acc = aug_cls_acc.mean()

        aug_cls_acc_str = ',  '.join(['{}: {:.3%}'.format(self.class_names[cls_i], aug_cls_acc[cls_i])
                                      for cls_i in range(self.n_classes)])

        return mean_aug_class_acc, aug_cls_acc_str


def subset_indices(d_source, d_target, subsetsize, subsetseed):
    if subsetsize > 0:
        if subsetseed != 0:
            subset_rng = np.random.RandomState(subsetseed)
        else:
            subset_rng = np.random
        strat = StratifiedShuffleSplit(n_splits=1, test_size=subsetsize, random_state=subset_rng)
        shuf = ShuffleSplit(n_splits=1, test_size=subsetsize, random_state=subset_rng)
        _, source_indices = next(strat.split(d_source.y, d_source.y))
        n_src = source_indices.shape[0]
        if d_target.has_ground_truth:
            _, target_indices = next(strat.split(d_target.y, d_target.y))
        else:
            _, target_indices = next(shuf.split(np.arange(len(d_target.images))))
        n_tgt = target_indices.shape[0]
    else:
        source_indices = None
        target_indices = None
        n_src = len(d_source.images)
        n_tgt = len(d_target.images)

    return source_indices, target_indices, n_src, n_tgt
# Compute per-class accuracy