From ffb45ffdafcf250ec2282685d757bd108c7b7f8f Mon Sep 17 00:00:00 2001 From: Dokholyan Date: Wed, 7 Oct 2020 18:49:32 +0300 Subject: [PATCH 01/13] add DynamicBalanceClassSampler --- catalyst/data/sampler.py | 95 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 95 insertions(+) diff --git a/catalyst/data/sampler.py b/catalyst/data/sampler.py index 86e9fc2cb3..a070f93300 100644 --- a/catalyst/data/sampler.py +++ b/catalyst/data/sampler.py @@ -195,6 +195,100 @@ def __iter__(self) -> Iterator[int]: return iter(inds) +class DynamicBalanceClassSampler(Sampler): + """ + This kind of sampler can be used for classification tasks with significant + class imbalance. + + The idea of this sampler that we start with the original class distribution + and gradually move to uniform class distribution like with downsampling. + + Let's define D_i = #C_i/ #C_min where #C_i is a size of class i and #C_min + is a size of the rarest class, so D_i define class distribution. + Also define g(n_epoch) is a exponential scheduler. On each epoch + current D_i calculated as currend D_i = D_i ^ g(n_epoch), + after this data samples according this distribution. + + Sampler was inspired by https://arxiv.org/pdf/1901.06783.pdf + """ + + def __init__( + self, labels: List[Union[int, str]], exp_lambda=0.9, epoch=0, max_d=200 + ): + """ + Args: + labels: list of classes labeles for each elem in the dataset + exp_lambda: exponent figure for schedule + epoch: start epoch number can be useful for many stage experiments + max_d: limit on the difference between the most frequent and the + rarest classes, heuristic + """ + assert isinstance(epoch, int) and isinstance(max_d, int) + assert 0 < exp_lambda < 1, "exp_lambda must be in (0, 1)" + super().__init__(labels) + self.exp_lambda = exp_lambda + self.max_d = max_d + self.epoch = epoch + labels = np.array(labels) + samples_per_class = Counter(labels) + self.min_class_size = min(list(samples_per_class.values())) + + self.original_d = { + key: value / self.min_class_size + for key, value in samples_per_class.items() + } + self.label2idxes = { + label: np.arange(len(labels))[labels == label].tolist() + for label in set(labels) + } + self.labels = labels + self._update() + + def _update(self) -> None: + """ + Update d coefficients + Returns: None + """ + current_d = { + key: min(value ** self._exp_scheduler(), self.max_d) + for key, value in self.original_d.items() + } + samples_per_classes = { + key: int(value * self.min_class_size) + for key, value in current_d.items() + } + self.samples_per_classes = samples_per_classes + self.length = np.sum(list(samples_per_classes.values())) + self.epoch += 1 + + def _exp_scheduler(self) -> float: + return self.exp_lambda ** self.epoch + + def __iter__(self) -> Iterator[int]: + """ + Yields: + indices of stratified sample + """ + indices = [] + for key in sorted(self.label2idxes): + samples_per_class = self.samples_per_classes[key] + replace_flag = samples_per_class > len(self.label2idxes[key]) + indices += np.random.choice( + self.label2idxes[key], samples_per_class, replace=replace_flag + ).tolist() + assert len(indices) == self.length + np.random.shuffle(indices) + self._update() + return iter(indices) + + def __len__(self) -> int: + """ + Returns: + length of result sample + """ + return self.length + + class MiniEpochSampler(Sampler): """ Sampler iterates mini epochs from the dataset used by ``mini_epoch_len``. @@ -424,4 +518,5 @@ def __iter__(self): "MiniEpochSampler", "DistributedSamplerWrapper", "DynamicLenBatchSampler", + "DynamicBalanceClassSampler", ] From 2146b89c9fcb71855841f4b01313c4bf5c90c307 Mon Sep 17 00:00:00 2001 From: Dokholyan Date: Sun, 11 Oct 2020 17:16:14 +0300 Subject: [PATCH 02/13] add DynamicBalanceClassSampler: add usage example --- catalyst/data/sampler.py | 19 ++++++++++++++++++- 1 file changed, 18 insertions(+), 1 deletion(-) diff --git a/catalyst/data/sampler.py b/catalyst/data/sampler.py index a070f93300..f5d82bef03 100644 --- a/catalyst/data/sampler.py +++ b/catalyst/data/sampler.py @@ -208,6 +208,23 @@ class imbalance. Also define g(n_epoch) is a exponential scheduler. On each epoch current D_i calculated as currend D_i = D_i ^ g(n_epoch), after this data samples according this distribution. + Usage example: + + >>> import torch + >>> import numpy as np + + >>> from catalyst.data.sampler import DynamicBalanceClassSampler + >>> from torch.utils import data + + >>> features = torch.Tensor(np.random.random((200, 100))) + >>> labels = np.random.randint(0, 4, size=(200,)) + >>> sampler = DynamicBalanceClassSampler(labels) + >>> labels = torch.LongTensor(labels) + >>> dataset = data.TensorDataset(features, labels) + >>> loader = data.dataloader.DataLoader(dataset, batch_size=8) + + >>> for batch in loader: + >>> b_features, b_labels = batch Sampler was inspired by https://arxiv.org/pdf/1901.06783.pdf """ @@ -217,7 +234,7 @@ def __init__( ): """ Args: - labels: list of classes labeles for each elem in the dataset + labels: list of labels for each elem in the dataset exp_lambda: exponent figure for schedule epoch: start epoch number can be useful for many stage experiments max_d: limit on the difference between the most frequent and the From 93a9d9245d33160f51c1e385b9f9a5d660592a09 Mon Sep 17 00:00:00 2001 From: Dokholyan Date: Sun, 11 Oct 2020 17:16:53 +0300 Subject: [PATCH 03/13] add DynamicBalanceClassSampler: add tests --- catalyst/data/tests/test_sampler.py | 65 ++++++++++++++++++++++++++++- 1 file changed, 64 insertions(+), 1 deletion(-) diff --git a/catalyst/data/tests/test_sampler.py b/catalyst/data/tests/test_sampler.py index d726ffd623..b4c10ba2eb 100644 --- a/catalyst/data/tests/test_sampler.py +++ b/catalyst/data/tests/test_sampler.py @@ -3,9 +3,13 @@ from operator import itemgetter from random import randint, shuffle +import numpy as np import pytest -from catalyst.data.sampler import BalanceBatchSampler +from catalyst.data.sampler import ( + BalanceBatchSampler, + DynamicBalanceClassSampler, +) TLabelsPK = List[Tuple[List[int], int, int]] @@ -122,3 +126,62 @@ def test_balance_batch_sampler( """ for labels, p, k in input_for_balance_batch_sampler: check_balance_batch_sampler_epoch(labels=labels, p=p, k=k) + + +@pytest.fixture() +def input_for_dynamic_balance_class_sampler() -> List[Tuple[list, float]]: + """ + This function generates some valid inputs for DynamicBalanceClassSampler + + Returns: + inputs in the folowing order: (labels, exp_l) + """ + labels = [ + # class imbalance + np.array([0] * 100 + [1] * 10 + [2] * 20), + # uniform class distribution + np.array([0] * 10 + [1] * 10 + [2] * 10), + # random class distribution + np.random.randint(0, 4, size=(200,)), + ] + exp_lambda = np.linspace(0.1, 0.95, 11) + input_cases = np.transpose( + [np.tile(labels, len(exp_lambda)), np.repeat(exp_lambda, len(labels))] + ) + return input_cases + + +def check_dynamic_balance_class_sampler(labels: List, exp_l: float) -> None: + """ + Check DynamicBalanceClassSampler on certain inputs + + Args: + labels: list of labels + exp_l: exponent figure for schedule + """ + sampler = DynamicBalanceClassSampler(labels, exp_l) + n_labels = len(np.unique(labels)) + labels_counter = Counter(labels) + min_class_key, min_class_size = labels_counter.most_common(n_labels)[-1] + current_d = { + key: value / min_class_size for key, value in Counter(labels).items() + } + for _epoch in range(10): + new_counter = Counter(labels[list(sampler.__iter__())]) + new_d = { + key: value / min_class_size for key, value in new_counter.items() + } + for key, value in new_d.items(): + assert value <= current_d[key] + assert new_d[min_class_key] == 1 + current_d = new_d + + +def test_dynamic_balance_class_sampler() -> None: + """ + Tests for DynamicBalanceClassSampler + """ + inputs = input_for_dynamic_balance_class_sampler() + + for labels, exp_l in inputs: + check_dynamic_balance_class_sampler(labels, exp_l) From 857367655e72114b8b61bd61c8098a77fadaad57 Mon Sep 17 00:00:00 2001 From: Sergey Kolesnikov Date: Tue, 13 Oct 2020 21:16:45 +0300 Subject: [PATCH 04/13] Update catalyst/data/tests/test_sampler.py --- catalyst/data/tests/test_sampler.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/catalyst/data/tests/test_sampler.py b/catalyst/data/tests/test_sampler.py index b4c10ba2eb..b277818b00 100644 --- a/catalyst/data/tests/test_sampler.py +++ b/catalyst/data/tests/test_sampler.py @@ -166,7 +166,7 @@ def check_dynamic_balance_class_sampler(labels: List, exp_l: float) -> None: current_d = { key: value / min_class_size for key, value in Counter(labels).items() } - for _epoch in range(10): + for _ in range(10): new_counter = Counter(labels[list(sampler.__iter__())]) new_d = { key: value / min_class_size for key, value in new_counter.items() From f4b21aebb1febe4e508346b34d45182843571215 Mon Sep 17 00:00:00 2001 From: Sergey Kolesnikov Date: Tue, 13 Oct 2020 21:59:55 +0300 Subject: [PATCH 05/13] Update catalyst/data/tests/test_sampler.py --- catalyst/data/tests/test_sampler.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/catalyst/data/tests/test_sampler.py b/catalyst/data/tests/test_sampler.py index b277818b00..436ecf00a4 100644 --- a/catalyst/data/tests/test_sampler.py +++ b/catalyst/data/tests/test_sampler.py @@ -166,7 +166,7 @@ def check_dynamic_balance_class_sampler(labels: List, exp_l: float) -> None: current_d = { key: value / min_class_size for key, value in Counter(labels).items() } - for _ in range(10): + for _ in range(10): # noqa: WPS122 new_counter = Counter(labels[list(sampler.__iter__())]) new_d = { key: value / min_class_size for key, value in new_counter.items() From a12a05c6a1039a4f9e85cda34559feacffe26c40 Mon Sep 17 00:00:00 2001 From: Dokholyan Date: Thu, 15 Oct 2020 20:02:53 +0300 Subject: [PATCH 06/13] add DynamicBalanceClassSampler: debag tests --- catalyst/data/tests/test_sampler.py | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/catalyst/data/tests/test_sampler.py b/catalyst/data/tests/test_sampler.py index 436ecf00a4..24035f45ff 100644 --- a/catalyst/data/tests/test_sampler.py +++ b/catalyst/data/tests/test_sampler.py @@ -177,11 +177,14 @@ def check_dynamic_balance_class_sampler(labels: List, exp_l: float) -> None: current_d = new_d -def test_dynamic_balance_class_sampler() -> None: +def test_dynamic_balance_class_sampler( + input_for_dynamic_balance_class_sampler, # noqa: WPS442 +) -> None: """ Tests for DynamicBalanceClassSampler - """ - inputs = input_for_dynamic_balance_class_sampler() - for labels, exp_l in inputs: + Args: + input_for_dynamic_balance_class_sampler: list of (labels, exp_l) + """ + for labels, exp_l in input_for_dynamic_balance_class_sampler: check_dynamic_balance_class_sampler(labels, exp_l) From 79332e119950ad39320ff6fcaeb393398fcd6b03 Mon Sep 17 00:00:00 2001 From: Dokholyan Date: Sat, 7 Nov 2020 17:20:44 +0300 Subject: [PATCH 07/13] update sampler: add mode --- catalyst/data/sampler.py | 40 +++++++++++++++++++++++++++++++++++----- 1 file changed, 35 insertions(+), 5 deletions(-) diff --git a/catalyst/data/sampler.py b/catalyst/data/sampler.py index f5d82bef03..594a955046 100644 --- a/catalyst/data/sampler.py +++ b/catalyst/data/sampler.py @@ -2,6 +2,7 @@ from collections import Counter from operator import itemgetter from random import choices, sample +import warnings import numpy as np @@ -206,8 +207,13 @@ class imbalance. Let's define D_i = #C_i/ #C_min where #C_i is a size of class i and #C_min is a size of the rarest class, so D_i define class distribution. Also define g(n_epoch) is a exponential scheduler. On each epoch - current D_i calculated as currend D_i = D_i ^ g(n_epoch), + current D_i calculated as current D_i = D_i ^ g(n_epoch), after this data samples according this distribution. + + Note: In the end of the training, epochs will contain only + min_size_class * n_classes examples. So, possible it will not necessary to + do validation on each epoch. For this reason use ControlFlowCallback. + Usage example: >>> import torch @@ -230,26 +236,46 @@ class imbalance. """ def __init__( - self, labels: List[Union[int, str]], exp_lambda=0.9, epoch=0, max_d=200 + self, + labels: List[Union[int, str]], + exp_lambda=0.9, + epoch: int = 0, + max_d: int = None, + mode: int = None, + ignore_warning: bool = False, ): """ Args: labels: list of labels for each elem in the dataset exp_lambda: exponent figure for schedule epoch: start epoch number can be useful for many stage experiments - max_d: limit on the difference between the most frequent and the - rarest classes, heuristic + max_d: if not None, limit on the difference between the most + frequent and the rarest classes, heuristic + mode: if not None, it means the final class size in training. + Before change it, make sure that you understand how does it work + ignore_warning: ignore warning about min class size """ - assert isinstance(epoch, int) and isinstance(max_d, int) + assert isinstance(epoch, int) assert 0 < exp_lambda < 1, "exp_lambda must be in (0, 1)" super().__init__(labels) self.exp_lambda = exp_lambda + if max_d is None: + max_d = np.inf self.max_d = max_d self.epoch = epoch labels = np.array(labels) samples_per_class = Counter(labels) self.min_class_size = min(list(samples_per_class.values())) + if self.min_class_size < 100 and not ignore_warning: + warnings.warn( + f"the smallest class contains only" + f" {self.min_class_size} examples. At the end of" + f" training, epochs will contain only" + f" {self.min_class_size * len(samples_per_class)}" + f" examples" + ) + self.original_d = { key: value / self.min_class_size for key, value in samples_per_class.items() @@ -258,6 +284,10 @@ def __init__( label: np.arange(len(labels))[labels == label].tolist() for label in set(labels) } + if mode is not None: + assert isinstance(mode, int) + self.min_class_size = mode + self.labels = labels self._update() From ef33956c003e71ae2c250cafb9b2a2b887aa192e Mon Sep 17 00:00:00 2001 From: Dokholyan Date: Sat, 7 Nov 2020 17:32:34 +0300 Subject: [PATCH 08/13] add example notebook --- .../DynamicBalanceClassSampler-example.ipynb | 361 ++++++++++++++++++ 1 file changed, 361 insertions(+) create mode 100644 examples/notebooks/DynamicBalanceClassSampler-example.ipynb diff --git a/examples/notebooks/DynamicBalanceClassSampler-example.ipynb b/examples/notebooks/DynamicBalanceClassSampler-example.ipynb new file mode 100644 index 0000000000..76bd679c08 --- /dev/null +++ b/examples/notebooks/DynamicBalanceClassSampler-example.ipynb @@ -0,0 +1,361 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### DynamicBalanceClassSampler" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[![Catalyst logo](https://raw.githubusercontent.com/catalyst-team/catalyst-pics/master/pics/catalyst_logo.png)](https://github.com/catalyst-team/catalyst)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This Notebook try to show the idea of DynamicBalanceClassSampler" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import catalyst\n", + "import torch\n", + "import sys\n", + "import os\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import random\n", + "\n", + "from catalyst.data.sampler import DynamicBalanceClassSampler\n", + "from catalyst.data.cv import ToTensor\n", + "from catalyst.contrib.datasets import MNIST\n", + "from collections import Counter\n", + "from typing import List, Any, Tuple\n", + "from catalyst.utils import set_global_seed\n", + "\n", + "set_global_seed(42)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Utils\n", + "\n", + "Some usefull functions to plot distributions" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def bar_chart(keys: List[Any], values: List[Any], figsize=None, ylabel=None,\n", + " title=None, log_scale=False, *args):\n", + " all_colors = list(plt.cm.colors.cnames.keys())\n", + " random.seed(100)\n", + " c = random.choices(all_colors, k=len(keys))\n", + " \n", + " if figsize:\n", + " plt.figure(figsize=figsize, dpi=80)\n", + " plt.bar(keys, values, color=c, width=.5)\n", + " for i, val in enumerate(values):\n", + " plt.text(i, val, float(val), horizontalalignment='center',\n", + " verticalalignment='bottom',\n", + " fontdict={'fontweight': 500, 'size': 12})\n", + " plt.gca().set_xticklabels(keys, rotation=60, horizontalalignment= 'right', *args)\n", + " \n", + " if title:\n", + " plt.title(title, fontsize=22)\n", + " if log_scale:\n", + " plt.yscale('log')\n", + " if ylabel:\n", + " plt.ylabel(ylabel)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def show_distribution(labels: np.array, figsize=None, title=None) -> None:\n", + " distribution = Counter(labels)\n", + " examples_per_class = [distribution[label] for label in range(10)]\n", + " label_names = [f'class_{label}' for label in range(10)]\n", + " bar_chart(label_names, examples_per_class, figsize, ylabel='examples', title=title)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "__Problem__: Unfortunately, often datasets don't have uniform class distribution. Let's consider such a situation. The MNIST dataset was taken and made disbalance. " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "class DisbalanceMNIST(MNIST):\n", + " def __init__(self, *args, **kwargs):\n", + " super().__init__(*args, **kwargs)\n", + " length = super().__len__()\n", + " labels = []\n", + " for idx in range(length):\n", + " labels.append(super().__getitem__(idx)[1])\n", + " labels = np.array(labels)\n", + " \n", + " label2idxes = {\n", + " label: np.arange(len(labels))[labels == label].tolist()\n", + " for label in set(labels)\n", + " }\n", + " \n", + " label_0_size = len(label2idxes[0])\n", + " label2example = {label: label_0_size // (2 * label + 1) for label in np.arange(10)}\n", + " \n", + " self.new_indexes = []\n", + " for label, n_examples in label2example.items():\n", + " self.new_indexes.extend(np.random.choice(label2idxes[label],\n", + " size=n_examples,\n", + " replace=False))\n", + " \n", + " def __len__(self) -> int:\n", + " return len(self.new_indexes)\n", + " \n", + " def __getitem__(self, idx: int) -> Tuple[torch.Tensor, int]:\n", + " new_idx = self.new_indexes[idx]\n", + " return super().__getitem__(new_idx)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "train_dataset = DisbalanceMNIST(root=os.getcwd(), train=True, download=True, transform=ToTensor())\n", + "train_labels = np.array([example[1] for example in train_dataset])\n", + "show_distribution(train_labels, (10, 5), title='Original Distribution')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Some classes are much larger than others, so if the model is trained using such dataset, it will cause overfitting. There are some common techniques: \"downsampling\", \"upsampling\". But they have some drawbacks:\n", + "\n", + "1) If \"upsampling\" is used all examples will be used but the model will see rare class (many times one example durion one epoch) too often, which can cause overfitting.\n", + "\n", + "2) If \"downsampling\" is used, there will be no overfitting, but the model will not see a great number of examples, which can be very useful\n", + "\n", + "DynamicBalanceClassSampler combines the advantages of these approaches. We start with the original distribution and step by step are going to a uniform distribution. On the one hand, the model will see all examples, and on the other hand at the end of the training there will be uniform distribution, so it will be no overfitting" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "__A Little Math explanation__:\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Define schedule $S_{exp}(epoch) = \\lambda^{epoch}$, and $0 < \\lambda < 1$. So this function is going from 1 on(epoch 0) to 0. \n", + "\n", + "After that calculate distribution coefficients $D_i = \\dfrac{Size(C_i)}{Size(C_{min})}$, where $C_i$ defien $i$ class and $C_{min}$ define the rarest class. So all $D_i \\geq 1$ and $D_{min} = 1$ \n", + "\n", + "On each epoch currecnt D are calculated: $D_{currecnt_i} = D_i^{S_{exp}(epoch)}$, as $S_{exp}(epoch) < 1$, $D_{currecnt_i} \\leq D_{previous_i} \\leq D_i$. It means that all $D_i$ are going to 1.\n", + "\n", + "On each epoch we sample example by currecn $D$, using with formula: $D_{currecnt_i} \\times Size(C_{min})$\n", + "\n", + "__Some Notes:__\n", + "\n", + "1) $\\lambda$ - determines the rate of decrease\n", + "\n", + "2) In the end of the training, epochs will contain only $Size(C_{min}) \\times n_{classes}$ examples. So, possible it will not necessary to do validation on each epoch. For this reason use ControlFlowCallback." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's create it and see the result with our own eyes. Consider class distribution on different epochs" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "sampler = DynamicBalanceClassSampler(train_labels, exp_lambda=0.9, )" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "epoch_to_show = [1, 5, 15, 50]\n", + "epoch2labels = {}\n", + "for epoch in range(1, 51):\n", + " epoch_indexes = np.array(list(sampler.__iter__()))\n", + " if epoch in epoch_to_show:\n", + " epoch2labels[epoch] = train_labels[np.array(epoch_indexes)]" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig = plt.figure(figsize = (20, 10))\n", + "\n", + "for idx, (epoch, labels) in enumerate(epoch2labels.items(), start=1):\n", + " plt.subplot(2, 2, idx)\n", + " show_distribution(labels, None, title=f'{epoch} Epoch Distribution')\n", + " plt.tight_layout(w_pad=1, h_pad=1)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's take a closer look at the parameters of this sampler:\n", + "\n", + "__max_d:__ You can use it to control class imbalance. If it is not None, $D_{currecnt_i} = min(D_i^{S_{exp}(epoch)}, max_d)$, so you can avoid too strong disbalance\n", + "\n", + "__mode:__ In some cases, you may want a different target class size for them to aim for. You can specify it explicitly\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "sampler = DynamicBalanceClassSampler(train_labels, exp_lambda=0.9, max_d=5, mode=500)\n", + "\n", + "epoch_to_show = [1, 5, 15, 50]\n", + "epoch2labels = {}\n", + "for epoch in range(1, 51):\n", + " epoch_indexes = np.array(list(sampler.__iter__()))\n", + " if epoch in epoch_to_show:\n", + " epoch2labels[epoch] = train_labels[np.array(epoch_indexes)]\n", + "\n", + "fig = plt.figure(figsize = (20, 10))\n", + "\n", + "for idx, (epoch, labels) in enumerate(epoch2labels.items(), start=1):\n", + " plt.subplot(2, 2, idx)\n", + " show_distribution(labels, None, title=f'{epoch} Epoch Distribution')\n", + " plt.tight_layout(w_pad=1, h_pad=1)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We see that:\n", + "\n", + "1) the most popular class is only 5 times larger than the smallest.\n", + "\n", + "2) All classes go to a new balance of 500" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We hope that this notebook will be useful for you!" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From d61fc8f591f9d3c32398f44ed870d76e7cd9e04a Mon Sep 17 00:00:00 2001 From: Dokholyan Date: Sun, 8 Nov 2020 14:07:30 +0300 Subject: [PATCH 09/13] sampler: fixes --- catalyst/data/__init__.py | 1 + catalyst/data/sampler.py | 26 +++++++++++++++----------- 2 files changed, 16 insertions(+), 11 deletions(-) diff --git a/catalyst/data/__init__.py b/catalyst/data/__init__.py index 70c382009f..df68d7db61 100644 --- a/catalyst/data/__init__.py +++ b/catalyst/data/__init__.py @@ -22,6 +22,7 @@ BalanceBatchSampler, DistributedSamplerWrapper, DynamicLenBatchSampler, + DynamicBalanceClassSampler, MiniEpochSampler, ) from catalyst.data.sampler_inbatch import ( diff --git a/catalyst/data/sampler.py b/catalyst/data/sampler.py index 2a0f63657e..c37b46bea2 100644 --- a/catalyst/data/sampler.py +++ b/catalyst/data/sampler.py @@ -216,7 +216,7 @@ class imbalance. >>> import torch >>> import numpy as np - >>> from catalyst.data.sampler import DynamicBalanceClassSampler + >>> from catalyst.data import DynamicBalanceClassSampler >>> from torch.utils import data >>> features = torch.Tensor(np.random.random((200, 100))) @@ -236,30 +236,32 @@ def __init__( self, labels: List[Union[int, str]], exp_lambda=0.9, - epoch: int = 0, + start_epoch: int = 0, max_d: int = None, - mode: int = None, + mode: Union[str, int] = "downsampling", ignore_warning: bool = False, ): """ Args: labels: list of labels for each elem in the dataset exp_lambda: exponent figure for schedule - epoch: start epoch number can be useful for many stage experiments + start_epoch: start epoch number, can be useful for multi-stage + experiments max_d: if not None, limit on the difference between the most frequent and the rarest classes, heuristic - mode: if not None, it means the final class size in training. - Before change it, make sure that you understand how does it work + mode: number of samples per class in the end of training. Must be + "downsampling" or number. Before change it, make sure that you + understand how does it work ignore_warning: ignore warning about min class size """ - assert isinstance(epoch, int) + assert isinstance(start_epoch, int) assert 0 < exp_lambda < 1, "exp_lambda must be in (0, 1)" super().__init__(labels) self.exp_lambda = exp_lambda if max_d is None: max_d = np.inf self.max_d = max_d - self.epoch = epoch + self.epoch = start_epoch labels = np.array(labels) samples_per_class = Counter(labels) self.min_class_size = min(list(samples_per_class.values())) @@ -281,9 +283,11 @@ def __init__( label: np.arange(len(labels))[labels == label].tolist() for label in set(labels) } - if mode is not None: - assert isinstance(mode, int) + + if isinstance(mode, int): self.min_class_size = mode + else: + assert mode == "downsampling" self.labels = labels self._update() @@ -565,6 +569,6 @@ def __iter__(self): "BalanceBatchSampler", "MiniEpochSampler", "DistributedSamplerWrapper", - "DynamicLenBatchSampler", "DynamicBalanceClassSampler", + "DynamicLenBatchSampler", ] From 2be40b3a9c6ef89a5e7c015a062bf6626d159f44 Mon Sep 17 00:00:00 2001 From: Dokholyan Date: Sun, 8 Nov 2020 14:08:09 +0300 Subject: [PATCH 10/13] samler: docs --- docs/api/data.rst | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/docs/api/data.rst b/docs/api/data.rst index e17c49ff81..50c5f1c42c 100644 --- a/docs/api/data.rst +++ b/docs/api/data.rst @@ -234,6 +234,13 @@ DistributedSamplerWrapper :undoc-members: :special-members: __iter__, __len__ +DynamicBalanceClassSampler +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +.. autoclass:: catalyst.data.sampler.DynamicBalanceClassSampler + :members: + :undoc-members: + :special-members: __iter__, __len__ + DynamicLenBatchSampler ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ .. autoclass:: catalyst.data.sampler.DynamicLenBatchSampler From 7c6a68e7e4732d2937ac56a87094d6eeae144ed4 Mon Sep 17 00:00:00 2001 From: Dokholyan Date: Mon, 9 Nov 2020 17:24:47 +0300 Subject: [PATCH 11/13] DynamicBalanceClassSampler: fixes --- catalyst/data/sampler.py | 34 +++++++++++++++++++--------------- 1 file changed, 19 insertions(+), 15 deletions(-) diff --git a/catalyst/data/sampler.py b/catalyst/data/sampler.py index c37b46bea2..4155e531c0 100644 --- a/catalyst/data/sampler.py +++ b/catalyst/data/sampler.py @@ -2,9 +2,9 @@ from collections import Counter from operator import itemgetter from random import choices, sample -import warnings import numpy as np +import logging import torch from torch.utils.data import DistributedSampler @@ -201,17 +201,20 @@ class imbalance. The idea of this sampler that we start with the original class distribution and gradually move to uniform class distribution like with downsampling. - Let's define D_i = #C_i/ #C_min where #C_i is a size of class i and #C_min - is a size of the rarest class, so D_i define class distribution. - Also define g(n_epoch) is a exponential scheduler. On each epoch - current D_i calculated as current D_i = D_i ^ g(n_epoch), + Let's define :math: D_i = #C_i/ #C_min where :math: #C_i is a size of class + i and :math: #C_min is a size of the rarest class, so :math: D_i define + class distribution. Also define :math: g(n_epoch) is a exponential + scheduler. On each epoch current :math: D_i calculated as + :math: current D_i = D_i ^ g(n_epoch), after this data samples according this distribution. - Note: In the end of the training, epochs will contain only - min_size_class * n_classes examples. So, possible it will not necessary to - do validation on each epoch. For this reason use ControlFlowCallback. + Notes: + In the end of the training, epochs will contain only + min_size_class * n_classes examples. So, possible it will not + necessary to do validation on each epoch. For this reason use + ControlFlowCallback. - Usage example: + Examples: >>> import torch >>> import numpy as np @@ -229,15 +232,15 @@ class imbalance. >>> for batch in loader: >>> b_features, b_labels = batch - Sampler was inspired by https://arxiv.org/pdf/1901.06783.pdf + Sampler was inspired by https://arxiv.org/abs/1901.06783 """ def __init__( self, labels: List[Union[int, str]], - exp_lambda=0.9, + exp_lambda: float = 0.9, start_epoch: int = 0, - max_d: int = None, + max_d: Optional[int] = None, mode: Union[str, int] = "downsampling", ignore_warning: bool = False, ): @@ -246,7 +249,7 @@ def __init__( labels: list of labels for each elem in the dataset exp_lambda: exponent figure for schedule start_epoch: start epoch number, can be useful for multi-stage - experiments + experiments max_d: if not None, limit on the difference between the most frequent and the rarest classes, heuristic mode: number of samples per class in the end of training. Must be @@ -264,10 +267,11 @@ def __init__( self.epoch = start_epoch labels = np.array(labels) samples_per_class = Counter(labels) - self.min_class_size = min(list(samples_per_class.values())) + self.min_class_size = min(samples_per_class.values()) if self.min_class_size < 100 and not ignore_warning: - warnings.warn( + logger = logging.getLogger(__name__) + logger.warning( f"the smallest class contains only" f" {self.min_class_size} examples. At the end of" f" training, epochs will contain only" From f5dafe49c1ca94328ff1794e91354db03038ca37 Mon Sep 17 00:00:00 2001 From: Dokholyan Date: Mon, 9 Nov 2020 21:04:10 +0300 Subject: [PATCH 12/13] change import order --- catalyst/data/sampler.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/catalyst/data/sampler.py b/catalyst/data/sampler.py index 4155e531c0..c0ee9d7a68 100644 --- a/catalyst/data/sampler.py +++ b/catalyst/data/sampler.py @@ -3,8 +3,8 @@ from operator import itemgetter from random import choices, sample -import numpy as np import logging +import numpy as np import torch from torch.utils.data import DistributedSampler From 070a4ad147a2143d6d4945d8aa3edc91c13d2794 Mon Sep 17 00:00:00 2001 From: Dokholyan Date: Mon, 9 Nov 2020 21:25:24 +0300 Subject: [PATCH 13/13] change import order --- catalyst/data/sampler.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/catalyst/data/sampler.py b/catalyst/data/sampler.py index c0ee9d7a68..57e920dd7e 100644 --- a/catalyst/data/sampler.py +++ b/catalyst/data/sampler.py @@ -1,9 +1,9 @@ from typing import Iterator, List, Optional, Union from collections import Counter +import logging from operator import itemgetter from random import choices, sample -import logging import numpy as np import torch