



  

albumentations 1.1.0 documentation

 .wy-side-nav-search {

 background-color: #ffffff;

 }

 .wy-side-nav-search>a, .wy-side-nav-search .wy-dropdown>a {

 color: #222;

 }

 .wy-side-nav-search>div.version {

 color: #222;

 }

 

 #documentation-link-header {

 position: static;

 top: 0;

 left: 0;

 width: 100%;

 color: white;

 font-size: 24px;

 text-align: center;

 padding: 10px 0;

 height: 50px;

 background: #448aff;

 z-index: 999999

 }

 .wy-nav-side {

 top: 50px

 }

 #documentation-link-header a {

 color: white;

 text-decoration: underline;

 }

 #documentation-link-header a:hover {

 text-decoration: none;

 }

 @media only screen and (max-width: 600px) {

 #documentation-link-header {

 font-size: 18px;

 height: 90px;

 }

 .wy-nav-side {

 top: 90px;

 }

 }

 @media only screen and (min-width: 600px) {

 #documentation-link-header {

 font-size: 20px;

 height: 75px;

 }

 .wy-nav-side {

 top: 75px;

 }

 }

 @media only screen and (min-width: 768px) {

 #documentation-link-header {

 height: 70px;

 }

 .wy-nav-side {

 top: 70px;

 }

 }

 @media only screen and (min-width: 992px) {

 #documentation-link-header {

 height: 50px;

 }

 .wy-nav-side {

 top: 50px

 }

 }

 

The updated and extended version of the documentation is available at <https://albumentations.ai/docs/>

 [albumentations

 

 

 

 ![Logo](_static/logo.png)](index.html#document-index)

 latest

 

* [albumentations](index.html#document-index)

Contents:

* [Examples](index.html#document-examples)

* [Contributing](index.html#document-contributing)

* [To create a pull request:](index.html#to-create-a-pull-request)

* [Augmentations overview](index.html#document-augs_overview/index)

* [API](index.html#document-api/index)

	+ [Core API (albumentations.core)](index.html#document-api/core)

	+ [Augmentations (albumentations.augmentations)](index.html#document-api/augmentations)

	+ [imgaug helpers (albumentations.imgaug)](index.html#document-api/imgaug)

	+ [PyTorch helpers (albumentations.pytorch)](index.html#document-api/pytorch)

* [About probabilities.](index.html#document-probabilities)

	+ [Default probability values](index.html#default-probability-values)

	+ [OneOf Block](index.html#oneof-block)

	+ [Example calculations](index.html#example-calculations)

* [Writing tests](index.html#document-writing_tests)

	+ [A first test.](index.html#a-first-test)

	+ [Test parametrization and the @pytest.mark.parametrize decorator.](index.html#test-parametrization-and-the-pytest-mark-parametrize-decorator)

	+ [Simplifying tests for functions that work with both images and masks by using helper functions.](index.html#simplifying-tests-for-functions-that-work-with-both-images-and-masks-by-using-helper-functions)

	+ [Simplifying tests for functions that work with both images and masks by using parametrization.](index.html#simplifying-tests-for-functions-that-work-with-both-images-and-masks-by-using-parametrization)

	+ [Using fixtures.](index.html#using-fixtures)

	+ [Simultaneous use of fixtures and parametrization.](index.html#simultaneous-use-of-fixtures-and-parametrization)

* [Hall of Fame](index.html#document-hall_of_fame)

	+ [Kaggle](index.html#kaggle)

	+ [Topcoder](index.html#topcoder)

	+ [CVPR](index.html#cvpr)

	+ [MICCAI](index.html#miccai)

* [Citations](index.html#document-citations)

	+ [List of papers that cite Albumentations](index.html#list-of-papers-that-cite-albumentations)

[albumentations](index.html#document-index)

* »

* albumentations 1.1.0 documentation

* [Edit on GitHub](https://github.com/albumentations-team/albumentations/blob/master/docs/index.rst)

---

albumentations[¶](#albumentations "Permalink to this headline")

===============================================================

albumentations is a fast image augmentation library and easy to use wrapper around other libraries.

Features[¶](#features "Permalink to this headline")

---------------------------------------------------

* Great fast augmentations based on highly-optimized OpenCV library.

* Super simple yet powerful interface for different tasks like (segmentation, detection, etc).

* Easy to customize.

* Easy to add other frameworks.

Project info[¶](#project-info "Permalink to this headline")

-----------------------------------------------------------

* GitHub repository: <https://github.com/albumentations-team/albumentations>

* GitHub repository with examples: <https://github.com/albumentations-team/albumentations_examples>

* License: MIT

Installation[¶](#installation "Permalink to this headline")

-----------------------------------------------------------

You can use pip to install albumentations:

```

pip install albumentations

```

If you want to get the latest version of the code before it is released on PyPI you can install the library from GitHub:

```

pip install -U git+https://github.com/albumentations-team/albumentations

```

Demo[¶](#demo "Permalink to this headline")

-------------------------------------------

You can use this [Google Colaboratory notebook](https://colab.research.google.com/drive/1JuZ23u0C0gx93kV0oJ8Mq0B6CBYhPLXy#scrollTo=GwFN-In3iagp&forceEdit=true&offline=true&sandboxMode=true)

to adjust image augmentation parameters and see the resulting images.

### Examples[¶](#examples "Permalink to this headline")

```

from albumentations import (

    HorizontalFlip, IAAPerspective, ShiftScaleRotate, CLAHE, RandomRotate90,

    Transpose, ShiftScaleRotate, Blur, OpticalDistortion, GridDistortion, HueSaturationValue,

    IAAAdditiveGaussianNoise, GaussNoise, MotionBlur, MedianBlur, IAAPiecewiseAffine,

    IAASharpen, IAAEmboss, RandomBrightnessContrast, Flip, OneOf, Compose

)

import numpy as np

def strong\_aug(p=0.5):

    return Compose([

        RandomRotate90(),

        Flip(),

        Transpose(),

        OneOf([

            IAAAdditiveGaussianNoise(),

            GaussNoise(),

        ], p=0.2),

        OneOf([

            MotionBlur(p=0.2),

            MedianBlur(blur\_limit=3, p=0.1),

            Blur(blur\_limit=3, p=0.1),

        ], p=0.2),

        ShiftScaleRotate(shift\_limit=0.0625, scale\_limit=0.2, rotate\_limit=45, p=0.2),

        OneOf([

            OpticalDistortion(p=0.3),

            GridDistortion(p=0.1),

            IAAPiecewiseAffine(p=0.3),

        ], p=0.2),

        OneOf([

            CLAHE(clip\_limit=2),

            IAASharpen(),

            IAAEmboss(),

            RandomBrightnessContrast(),

        ], p=0.3),

        HueSaturationValue(p=0.3),

    ], p=p)

image = np.ones((300, 300, 3), dtype=np.uint8)

mask = np.ones((300, 300), dtype=np.uint8)

whatever\_data = "my name"

augmentation = strong\_aug(p=0.9)

data = {"image": image, "mask": mask, "whatever\_data": whatever\_data, "additional": "hello"}

augmented = augmentation(\*\*data)

image, mask, whatever\_data, additional = augmented["image"], augmented["mask"], augmented["whatever\_data"], augmented["additional"]

```

For more examples see [repository with examples](https://github.com/albumentations-team/albumentations_examples)

and [example.ipynb](https://github.com/albumentations-team/albumentations_examples/blob/master/notebooks/example.ipynb)

and [example\_16\_bit\_tiff.ipynb](https://github.com/albumentations-team/albumentations_examples/blob/master/notebooks/example_16_bit_tiff.ipynb)

### Contributing[¶](#contributing "Permalink to this headline")

All development is done on GitHub: <https://github.com/albumentations-team/albumentations>

If you find a bug or have a feature request file an issue at <https://github.com/albumentations-team/albumentations/issues>

### To create a pull request:[¶](#to-create-a-pull-request "Permalink to this headline")

1. Fork the repository.

2. Clone it.

3. Install pre-commit hook:

```

pip install pre-commit black flake8 isort mypy

```

4. Initialize it from the folder with the repo:

```

pre-commit install

```

4. Make desired changes to the code.

5. Install the library in development mode:

```

pip install -e .[tests]

```

6. Run tests:

```

pytest

```

7. Push code to your forked repo.

8. Create pull request.

### Augmentations overview[¶](#augmentations-overview "Permalink to this headline")

You can find examples in this [repository](https://github.com/albumentations-team/albumentations_examples#augmentations-examples).

### API[¶](#api "Permalink to this headline")

#### Core API (albumentations.core)[¶](#core-api-albumentations-core "Permalink to this headline")

##### Composition[¶](#composition "Permalink to this headline")

##### Transforms interface[¶](#transforms-interface "Permalink to this headline")

##### Serialization[¶](#serialization "Permalink to this headline")

#### Augmentations (albumentations.augmentations)[¶](#augmentations-albumentations-augmentations "Permalink to this headline")

##### Transforms[¶](#transforms "Permalink to this headline")

##### Functional transforms[¶](#functional-transforms "Permalink to this headline")

##### Helper functions for working with bounding boxes[¶](#helper-functions-for-working-with-bounding-boxes "Permalink to this headline")

##### Helper functions for working with keypoints[¶](#helper-functions-for-working-with-keypoints "Permalink to this headline")

#### imgaug helpers (albumentations.imgaug)[¶](#imgaug-helpers-albumentations-imgaug "Permalink to this headline")

##### Transforms[¶](#transforms "Permalink to this headline")

#### PyTorch helpers (albumentations.pytorch)[¶](#pytorch-helpers-albumentations-pytorch "Permalink to this headline")

##### Transforms[¶](#transforms "Permalink to this headline")

### About probabilities.[¶](#about-probabilities "Permalink to this headline")

#### Default probability values[¶](#default-probability-values "Permalink to this headline")

All pre / post processing transforms: **Compose**, **PadIfNeeded**, **CenterCrop**, **RandomCrop**, **Crop**, **RandomCropNearBBox**, **RandomSizedCrop**, **RandomResizedCrop**, **RandomSizedBBoxSafeCrop**, **CropNonEmptyMaskIfExists**, **Lambda**, **Normalize**, **ToFloat**, **FromFloat**, **ToTensor**, **LongestMaxSize** have default

probability values equal to **1**. All others are equal to **0.5**

```

from albumentations import (

   RandomRotate90, IAAAdditiveGaussianNoise, GaussNoise, Compose, OneOf

)

import numpy as np

def aug(p1, p2, p3):

   return Compose([

       RandomRotate90(p=p2),

       OneOf([

           IAAAdditiveGaussianNoise(p=0.9),

           GaussNoise(p=0.6),

       ], p=p3)

   ], p=p1)

image = np.ones((300, 300, 3), dtype=np.uint8)

mask = np.ones((300, 300), dtype=np.uint8)

whatever\_data = "my name"

augmentation = aug(p1=0.9, p2=0.7, p3=0.3)

data = {"image": image, "mask": mask, "whatever\_data": whatever\_data, "additional": "hello"}

augmented = augmentation(\*\*data)

image, mask, whatever\_data, additional = augmented["image"], augmented["mask"], augmented["whatever\_data"], augmented["additional"]

```

In the above augmentation pipeline, we have three types of probabilities. Combination of them is the primary factor that

decides how often each of them will be applied.

> 

> 1. **p1**: decides if this augmentation will be applied. The most common case is **p1=1** means that we always apply the transformations from above. **p1=0** will mean that the transformation block will be ignored.

> 2. **p2**: every augmentation has an option to be applied with some probability.

> 3. **p3**: decide if **OneOf** will be applied.

> 

> 

> 

#### OneOf Block[¶](#oneof-block "Permalink to this headline")

To decide which augmentation within **OneOf** block is used the following rule is applied.

> 

> 1. We normalize all probabilities within a block to one.

> After this we pick augmentation based on the normalized probabilities.

> In the example above **IAAAdditiveGaussianNoise** has probability **0.9** and **GaussNoise** probability **0.6**.

> After normalization, they become **0.6** and **0.4**.

> Which means that we decide if we should use **IAAAdditiveGaussianNoise** with probability **0.6** and **GaussNoise** otherwise.

> 2. If we picked to consider **GaussNoise** the next step we call **GaussNoise** with flag **force\_apply=True**.

#### Example calculations[¶](#example-calculations "Permalink to this headline")

Thus, each augmentation in the example above will be applied with the probability:

> 

> 1. **RandomRotate90**: p1 \* p2

> 2. **IAAAdditiveGaussianNoise**: p1 \* p3 \* (0.9 / (0.9 + 0.6))

> 3. **GaussianNoise**: p1 \* p3 \* (0.6 / (0.9 + 0.6))

> 

> 

> 

### Writing tests[¶](#writing-tests "Permalink to this headline")

#### A first test.[¶](#a-first-test "Permalink to this headline")

We use `pytest` to run tests for albumentations. Python files with tests should be placed inside the `albumentations/tests` directory, filenames should start with `test\_`, for example `test\_bbox.py`. Names of test functions should also start with `test\_`, for example, `def test\_random\_brightness():`.

Let’s say that we want to test the `brightness\_contrast\_adjust` function. The purpose of this function is to take a NumPy array as input and multiply all the values of this array by a value specified in the argument `alpha`.

We will write a first test for this function that will check that if you pass a NumPy array with all values equal to 128 and a parameter `alpha` that equals to 1.5 as inputs the function should produce a NumPy array with all values equal to 192 as output (that’s because 128 \* 1.5 = 192).

In the directory `albumentations/tests` we will create a new file and name it `test\_example.py`

Let’s add all the necessary imports:

```

import numpy as np

import albumentations.augmentations.functional as F

```

Then let’s add the test itself:

```

def test\_random\_contrast():

    img = np.ones((100, 100, 3), dtype=np.uint8) \* 128

    img = F.brightness\_contrast\_adjust(img, alpha=1.5)

    expected\_multiplier = 192

    expected = np.ones((100, 100, 3), dtype=np.uint8) \* expected\_multiplier

    assert np.array\_equal(img, expected)

```

We can run tests from `test\_example.py` (right now it contains only one test) by executing the following command: `pytest tests/test\_example.py -v`. The `-v` flag tells pytest to produce a more verbose output.

`pytest` will show that the test has been completed successfully:

```

tests/test\_example.py::test\_random\_brightness PASSED

```

#### Test parametrization and the @pytest.mark.parametrize decorator.[¶](#test-parametrization-and-the-pytest-mark-parametrize-decorator "Permalink to this headline")

Let’s say that we also want to test that the function `brightness\_contrast\_adjust` correctly handles a situation in which after multiplying an input array by `alpha` some output values exceed 255. Because when we a pass a NumPy array with the data type `np.uint8` as input we expect that we will also get an array with the `np.uint8` data type as output and that means that output values should not exceed 255 (which is the maximum value for this data type). We also want to check that values don’t overflow, so if inside the function we get a value 256 we should clip it to 255 and not overflow to 0.

Let’s write a test:

```

def test\_random\_contrast\_2():

    img = np.ones((100, 100, 3), dtype=np.uint8) \* 128

    img = F.brightness\_contrast\_adjust(img, alpha=3)

    expected\_multiplier = 255

    expected = np.ones((100, 100, 3), dtype=np.uint8) \* expected\_multiplier

    assert np.array\_equal(img, expected)

```

Next, we will run the tests from `test\_example.py`: `pytest tests/test\_example.py -v`

Output:

```

tests/test\_example.py::test\_random\_brightness PASSED

tests/test\_example.py::test\_random\_brightness\_2 PASSED

```

As we see functions `test\_random\_brightness` and `test\_random\_brightness\_2` looks almost the same, the only difference is the values of `alpha` and `expected\_multiplier`. To get rid of code duplication we can use the `@pytest.mark.parametrize` decorator. With this decorator we can describe which values should be passed as arguments to the test and the pytest will run the test multiple times, each time passing the next value from the decorator.

We can rewrite two previous tests as a one test using parametrization:

```

import pytest

@pytest.mark.parametrize(['alpha', 'expected\_multiplier'], [(1.5, 192), (3, 255)])

def test\_random\_brightness(alpha, expected\_multiplier):

    img = np.ones((100, 100, 3), dtype=np.uint8) \* 128

    img = F.brightness\_contrast\_adjust(img, alpha=alpha)

    expected = np.ones((100, 100, 3), dtype=np.uint8) \* expected\_multiplier

    assert np.array\_equal(img, expected)

```

This test will run two times, in the first run the `alpha` argument will be equal to 1.5 and the `expected\_multiplier` argument will be equal to 192. In the second run the `alpha` argument will be equal to 3 and the `expected\_multiplier` argument will be equal to 255.

Let’s run this test:

```

tests/test\_example.py::test\_random\_brightness[1.5-192] PASSED

tests/test\_example.py::test\_random\_brightness[3-255] PASSED

```

As we see pytest prints arguments values at each run.

#### Simplifying tests for functions that work with both images and masks by using helper functions.[¶](#simplifying-tests-for-functions-that-work-with-both-images-and-masks-by-using-helper-functions "Permalink to this headline")

Let’s say that we want to test the `vflip` function. This function vertically flips an image or mask that passed as input to it.

We will start with a test that checks that this function works correctly with masks, that is with two-dimensional NumPy arrays that have shape `(height, width)`.

```

def test\_vflip\_mask():

    mask = np.array(

        [[1, 1, 1],

         [0, 1, 1],

         [0, 0, 1]], dtype=np.uint8)

    expected\_mask = np.array(

        [[0, 0, 1],

         [0, 1, 1],

         [1, 1, 1]], dtype=np.uint8)

    flipped\_mask = F.vflip(mask)

    assert np.array\_equal(flipped\_mask, expected\_mask)

```

Test running result:

```

tests/test\_example.py::test\_vflip\_mask PASSED

```

Next, we will make a test that checks how the same function works with RGB-images, that is with three-dimensional NumPy arrays that have shape `(height, width, 3)`.

```

def test\_vflip\_img():

    img = np.array(

        [[[1, 1, 1],

          [1, 1, 1],

          [1, 1, 1]],

         [[0, 0, 0],

          [1, 1, 1],

          [1, 1, 1]],

         [[0, 0, 0],

          [0, 0, 0],

          [1, 1, 1]]], dtype=np.uint8)

    expected\_img = np.array(

        [[[0, 0, 0],

          [0, 0, 0],

          [1, 1, 1]],

         [[0, 0, 0],

          [1, 1, 1],

          [1, 1, 1]],

         [[1, 1, 1],

          [1, 1, 1],

          [1, 1, 1]]], dtype=np.uint8)

    flipped\_img = F.vflip(img)

    assert np.array\_equal(flipped\_img, expected\_img)

```

In this test, the value of `img` is the same NumPy array that was assigned to the `mask` variable in `test\_vflip\_mask`, but this time it is repeated three times (one time for each of the three channels). And `expected\_img` is also a repeated three times NumPy array that was assigned to the `expected\_mask` variable in `test\_vflip\_mask`.

Let’s run the test:

```

tests/test\_example.py::test\_vflip\_img PASSED

```

In `test\_vflip\_img` we manually defined values of `img` and `expected\_img` that equal to repeated three times values of `mask` and `expected\_mask` respectively. To avoid unnecessary and duplicate code we can make a helper function that takes a NumPy array with shape `(height, width)` as input and repeats this value 3 times along a new axis to produce a NumPy array with shape `(height, width, 3)`:

```

def convert\_2d\_to\_3d(array, num\_channels=3):

    return np.repeat(array[:, :, np.newaxis], repeats=num\_channels, axis=2)

```

Next, we can use this function to rewrite `test\_vflip\_img` as follows:

```

def test\_vflip\_img\_2():

    mask = np.array(

        [[1, 1, 1],

         [0, 1, 1],

         [0, 0, 1]], dtype=np.uint8)

    expected\_mask = np.array(

        [[0, 0, 1],

         [0, 1, 1],

         [1, 1, 1]], dtype=np.uint8)

    img = convert\_2d\_to\_3d(mask)

    expected\_img = convert\_2d\_to\_3d(expected\_mask)

    flipped\_img = F.vflip(img)

    assert np.array\_equal(flipped\_img, expected\_img)

```

Let’s run the test:

```

tests/test\_example.py::test\_vflip\_img\_2 PASSED

```

#### Simplifying tests for functions that work with both images and masks by using parametrization.[¶](#simplifying-tests-for-functions-that-work-with-both-images-and-masks-by-using-parametrization "Permalink to this headline")

In the previous section we wrote two separate tests for `vflip`, the first one checked how `vflip` works with masks, the second one checked how `vflip` works with images.

Those tests share a large amount of the same code between them, so we can move common parts to a single function and use parametrization to pass information about input type as an argument to the test:

```

@pytest.mark.parametrize('target', ['mask', 'image'])

def test\_vflip\_img\_and\_mask(target):

    img = np.array(

        [[1, 1, 1],

         [0, 1, 1],

         [0, 0, 1]], dtype=np.uint8)

    expected = np.array(

        [[0, 0, 1],

         [0, 1, 1],

         [1, 1, 1]], dtype=np.uint8)

    if target == 'image':

        img = convert\_2d\_to\_3d(img)

        expected = convert\_2d\_to\_3d(expected)

    flipped\_img = F.vflip(img)

    assert np.array\_equal(flipped\_img, expected)

```

This test will run two times, in the first run the `target` argument will be equal to `'mask'`, the condition `if target == 'image':` will not be executed and the test will check how `vflip` works with masks. In the second run the `target` argument will be equal to `'image'`, the condition `if target == 'image':` will be executed and the test will check how `vflip` works with images:

```

tests/test\_example.py::test\_vflip\_img\_and\_mask[mask] PASSED

tests/test\_example.py::test\_vflip\_img\_and\_mask[image] PASSED

```

We can reduce the amount of code even further by moving logic under `if target == 'image'` to a separate function:

```

def convert\_2d\_to\_target\_format(\*arrays, target=None):

    if target == 'mask':

        return arrays[0] if len(arrays) == 1 else arrays

    elif target == 'image':

        return tuple(convert\_2d\_to\_3d(array, num\_channels=3) for array in arrays)

    else:

        raise ValueError('Unknown target {}'.format(target))

```

This function will take NumPy arrays with shape `(height, width)` as inputs and depending on the value of `target` will either return them as is or convert them to NumPy arrays with shape `(height, width, 3)`.

Using this helper function we can rewrite the test as follows:

```

@pytest.mark.parametrize('target', ['mask', 'image'])

def test\_vflip\_img\_and\_mask(target):

    img = np.array(

        [[1, 1, 1],

         [0, 1, 1],

         [0, 0, 1]], dtype=np.uint8)

    expected = np.array(

        [[0, 0, 1],

         [0, 1, 1],

         [1, 1, 1]], dtype=np.uint8)

    img, expected = convert\_2d\_to\_target\_format(img, expected, target=target)

    flipped\_img = F.vflip(img)

    assert np.array\_equal(flipped\_img, expected)

```

pytest output:

```

tests/test\_example.py::test\_vflip\_img\_and\_mask[mask] PASSED

tests/test\_example.py::test\_vflip\_img\_and\_mask[image] PASSED

```

##### Implementation notes:[¶](#implementation-notes "Permalink to this headline")

Implementations of `convert\_2d\_to\_target\_format` and `convert\_2d\_to\_3d` in albumentations slightly differ from implementations described above. We need to support both Python 2.7 and Python 3, so we can’t use a function declaration like `def convert\_2d\_to\_target\_format(\*arrays, target=None)` because it produces `SyntaxError` in Python 2 and only valid in Python 3 (see [PEP3102](https://www.python.org/dev/peps/pep-3102/) for more details). Because of this we use the following function declaration: `def convert\_2d\_to\_target\_format(arrays, target)` where the `arrays` argument should contain a list of NumPy arrays.

The test can be rewritten as follows to be compatible with the current albumentations’ test suite (note an updated call to `convert\_2d\_to\_target\_format`, we pass `img` and `expected` arguments inside a single list):

```

@pytest.mark.parametrize('target', ['mask', 'image'])

def test\_vflip\_img\_and\_mask(target):

    img = np.array(

        [[1, 1, 1],

         [0, 1, 1],

         [0, 0, 1]], dtype=np.uint8)

    expected = np.array(

        [[0, 0, 1],

         [0, 1, 1],

         [1, 1, 1]], dtype=np.uint8)

    img, expected = convert\_2d\_to\_target\_format([img, expected], target=target)

    flipped\_img = F.vflip(img)

    assert np.array\_equal(flipped\_img, expected)

```

#### Using fixtures.[¶](#using-fixtures "Permalink to this headline")

Let’s say that we want to test a situation in which we pass an image and mask with the `np.uint8` data type to the `VerticalFlip` augmentation and we expect that it won’t change data types of inputs and will produce an image and mask with the `np.uint8` data type as output.

Such a test can be written as follows:

```

from albumentations import VerticalFlip

def test\_vertical\_flip\_dtype():

    aug = VerticalFlip(p=1)

    image = np.random.randint(low=0, high=256, size=(100, 100, 3), dtype=np.uint8)

    mask = np.random.randint(low=0, high=2, size=(100, 100), dtype=np.uint8)

    data = aug(image=image, mask=mask)

    assert data['image'].dtype == np.uint8

    assert data['mask'].dtype == np.uint8

```

We generate a random image and a random mask, then we pass them as inputs to the augmentation and then we check a data type of output values.

If we want to perform this check for other augmentations as well, we will have to write code to generate a random image and mask at the beginning of each test:

```

image = np.random.randint(low=0, high=256, size=(100, 100, 3), dtype=np.uint8)

mask = np.random.randint(low=0, high=2, size=(100, 100), dtype=np.uint8)

```

To avoid this duplication we can move code that generates random values to a fixture. Fixtures work as follows:

1. In the `tests/conftest.py` file we create functions that are wrapped with the `@pytest.fixture` decorator:

```

@pytest.fixture

def image():

    return np.random.randint(low=0, high=256, size=(100, 100, 3), dtype=np.uint8)

@pytest.fixture

def mask():

    return np.random.randint(low=0, high=2, size=(100, 100), dtype=np.uint8)

```

2. In our test we use fixture names as accepted arguments:

```

def test\_vertical\_flip\_dtype(image, mask):

    ...

```

3. pytest will use arguments’ names to find fixtures with the same names, then it will execute those fixture functions and will pass the outputs of this functions as arguments to the test function.

We can rewrite `test\_vertical\_flip\_dtype` using fixtures as follows:

```

def test\_vertical\_flip\_dtype(image, mask):

    aug = VerticalFlip(p=1)

    data = aug(image=image, mask=mask)

    assert data['image'].dtype == np.uint8

    assert data['mask'].dtype == np.uint8

```

#### Simultaneous use of fixtures and parametrization.[¶](#simultaneous-use-of-fixtures-and-parametrization "Permalink to this headline")

Let’s say that besides `VerticalFlip` we also want to test that `HorizontalFlip` also returns values with the `np.uint8` data type if we passed a `np.uint8` input to it.

We can write test like this:

```

from albumentations import HorizontalFlip

def test\_horizontal\_flip\_dtype(image, mask):

    aug = HorizontalFlip(p=1)

    data = aug(image=image, mask=mask)

    assert data['image'].dtype == np.uint8

    assert data['mask'].dtype == np.uint8

```

But this test is almost completely identical to `test\_vertical\_flip\_dtype`. And to check each new augmentation we will have to copy practically almost the whole code from `test\_vertical\_flip\_dtype` and change the value of the `aug` variable, so the test will use a new augmentation. However it would be great to get rid of unnecessary copying of code in tests. For this, we could use parametrization and pass a class as a parameter.

A test that checks both VerticalFlip and HorizontalFlip can be written as follows:

```

from albumentations import VerticalFlip, HorizontalFlip

@pytest.mark.parametrize('augmentation\_cls', [

    VerticalFlip,

    HorizontalFlip,

])

def test\_multiple\_augmentations(augmentation\_cls, image, mask):

    aug = augmentation\_cls(p=1)

    data = aug(image=image, mask=mask)

    assert data['image'].dtype == np.uint8

    assert data['mask'].dtype == np.uint8

```

This test will run two times, in the first run the `augmentation\_cls` argument will be equal to `VerticalFlip`. In the second run the `augmentation\_cls` argument will be equal to `HorizontalFlip`.

pytest output:

```

tests/test\_example.py::test\_multiple\_augmentations[VerticalFlip] PASSED

tests/test\_example.py::test\_multiple\_augmentations[HorizontalFlip] PASSED

```

### Hall of Fame[¶](#hall-of-fame "Permalink to this headline")

Albumentations are widely used in Computer Vision Competitions at Kaggle an other platforms.

Here are the links to the competitions, names of the winners and to their solutions.

We follow these rules, when adding a solution to the “Hall of Fame”:

1. There should be a description of the solution: post at the forum / code / blog post / paper / pre-print.

2. Solution should have some value:

* For Kaggle: gold or silver medal solutions.

* For Topcoder and other platforms: in money.

* For competitions held as a part of the academic conferences: there is a paper or pre-print describing the solution.

#### Kaggle[¶](#kaggle "Permalink to this headline")

##### [Carvana Image Masking Challenge](https://www.kaggle.com/c/carvana-image-masking-challenge)[¶](#id1 "Permalink to this headline")

1. [Vladimir Iglovikov](https://www.linkedin.com/in/iglovikov/), [Alexander Buslaev](https://www.kaggle.com/albuslaev), [Artem Sanakoev](https://www.kaggle.com/asanakoev)

[solution](http://blog.kaggle.com/2017/12/22/carvana-image-masking-first-place-interview/)

##### [Data Science Bowl 2018](https://www.kaggle.com/c/data-science-bowl-2018)[¶](#data-science-bowl-2018 "Permalink to this headline")

1. [Alexander Buslaev](https://www.kaggle.com/albuslaev), [Selim Seferbekov](https://www.kaggle.com/selimsef), [Victor Durnov](https://www.kaggle.com/victorsd)

[solution](https://www.kaggle.com/c/data-science-bowl-2018/discussion/5474)

##### [Humpback Whale Identification](https://www.kaggle.com/c/humpback-whale-identification)[¶](#id2 "Permalink to this headline")

5. [Roman Solovyev](https://www.kaggle.com/zfturbo), [Weimin Wang](https://www.kaggle.com/weimin)

[blog post](https://weiminwang.blog/2019/03/01/whale-identification-5th-place-approach-using-siamese-networks-with-adversarial-training/),

[code](https://github.com/aaxwaz/Humpback-whale-identification-challenge)

##### [TGS Salt Identification Challenge](https://www.kaggle.com/c/tgs-salt-identification-challeng)[¶](#id3 "Permalink to this headline")

1. [b.e.s.](https://www.kaggle.com/ybabakhin), [phalanx](https://www.kaggle.com/phalanx)

[solution](https://www.kaggle.com/c/tgs-salt-identification-challenge/discussion/69291),

[code](https://github.com/ybabakhin/kaggle_salt_bes_phalanx),

[pre-print](https://arxiv.org/abs/1904.04445)

27. [Insaf Ashrapov](https://www.linkedin.com/in/iashrapov/), [Mikhail Karchevskiy](https://www.linkedin.com/in/mikhail-karchevskiy-aa46245a/), [Leonid Kozinkin](https://www.linkedin.com/in/lkozinkin/)

[blog post](https://towardsdatascience.com/kaggle-salt-identification-challenge-7fc502d1c3c3),

[code](https://github.com/K-Mike/Automatic-salt-deposits-segmentation),

[pre-print](https://arxiv.org/abs/1812.01429)

##### [APTOS 2019 Blindness Detection](https://www.kaggle.com/c/aptos2019-blindness-detection)[¶](#id4 "Permalink to this headline")

7. [Eugene Khvedchenya](https://www.kaggle.com/bloodaxe)

[solution](https://www.kaggle.com/c/aptos2019-blindness-detection/discussion/108058),

[code](https://github.com/BloodAxe/Kaggle-2019-Cellular-Image-Classification)

76. [Insaf Ashrapov](https://www.linkedin.com/in/iashrapov/), [Mamat Shamshiev](https://www.kaggle.com/mamatml/), [Mishunyayev Nikita](https://www.kaggle.com/mnikita/)

[solution](https://www.kaggle.com/c/aptos2019-blindness-detection/discussion/108057),

[code](https://github.com/MamatShamshiev/Kaggle-APTOS-2019-Blindness-Detection)

##### [SIIM-ACR Pneumothorax Segmentation](https://www.kaggle.com/c/siim-acr-pneumothorax-segmentation)[¶](#id5 "Permalink to this headline")

1. [Anuar Aimoldin](https://www.linkedin.com/in/anuar-aimoldin/)

[solution](https://www.kaggle.com/c/siim-acr-pneumothorax-segmentation/discussion/107824),

[code](https://github.com/sneddy/pneumothorax-segmentation),

[video](https://youtu.be/Wuf0wE3Mrxg),

[presentation](https://yadi.sk/i/oDYnpvMhqi8a7w)

4. [Miras Amir](https://www.linkedin.com/in/amirassov/)

[solution](https://www.kaggle.com/c/siim-acr-pneumothorax-segmentation/discussion/108397#latest-626947),

[code](https://github.com/amirassov/kaggle-pneumothorax)

33. [Renat Alimbekov](https://www.linkedin.com/in/alimbekovkz/), [Ivan Vassilenko](https://www.linkedin.com/in/ivannvassilenko/)

[solution](https://github.com/jovenwayfarer/kaggle-pneumothorax)

50. [AlexeyK](https://www.kaggle.com/akuritsyn), [wayfarer](https://www.kaggle.com/joven1997), [Kudaibergen R](https://www.kaggle.com/kudaibergenu)

[code and solution](https://github.com/jovenwayfarer/kaggle-pneumothorax)

##### [iMaterialist (Fashion) 2019 at FGVC6](https://www.kaggle.com/c/imaterialist-fashion-2019-FGVC6)[¶](#id6 "Permalink to this headline")

1. [Miras Amir](https://www.linkedin.com/in/amirassov/)

[solution](https://www.kaggle.com/c/imaterialist-fashion-2019-FGVC6/discussion/95247#latest-626701),

[code](https://github.com/amirassov/kaggle-imaterialist)

##### [Google Landmark Recognition 2019](https://www.kaggle.com/c/landmark-recognition-2019)[¶](#id7 "Permalink to this headline")

20. [Artyom Palvelev](https://www.linkedin.com/in/artyompp/)

[solution](https://www.kaggle.com/c/landmark-recognition-2019/discussion/94645#latest-549974),

[code](https://github.com/artyompal/google_landmark_2019)

##### [Inclusive Images Challenge](https://www.kaggle.com/c/inclusive-images-challenge/)[¶](#id8 "Permalink to this headline")

3. [Roman Solovyev](https://www.kaggle.com/zfturbo), [Weimin Wang](https://www.kaggle.com/weimin)

[solution](https://www.kaggle.com/c/inclusive-images-challenge/discussion/71433)

##### [Airbus Ship Detection Challenge](https://www.kaggle.com/c/airbus-ship-detection/)[¶](#id9 "Permalink to this headline")

30. [Konstantin Maksimov](https://www.kaggle.com/maksimovka)

[paper](https://ieeexplore.ieee.org/document/8783822/authors#authors)

##### [Severstal: Steel Defect Detection Challenge](https://www.kaggle.com/c/severstal-steel-defect-detection/)[¶](#id10 "Permalink to this headline")

27. [Ilia Larchenko](https://www.kaggle.com/ilialar)

[solution](https://www.kaggle.com/c/severstal-steel-defect-detection/discussion/115876)

#### Topcoder[¶](#topcoder "Permalink to this headline")

##### 2019[¶](#id12 "Permalink to this headline")

##### [Neptune - Facial Detection Marathon Match](https://www.topcoder.com/challenges/30086997)[¶](#neptune-facial-detection-marathon-match "Permalink to this headline")

2. [Miras Amir](https://www.linkedin.com/in/amirassov/)

[solution](https://github.com/amirassov/topcoder-facial-marathon)

##### [Neptune - Facial Re-Identification Marathon Match](https://www.topcoder.com/challenges/30086998)[¶](#neptune-facial-re-identification-marathon-match "Permalink to this headline")

2. [Miras Amir](https://www.linkedin.com/in/amirassov/)

[solution](https://github.com/amirassov/topcoder-facial-marathon)

##### 2018[¶](#id13 "Permalink to this headline")

##### [SpaceNet Challenge Round 4: Off-Nadir Buildings](https://spacenet.ai/off-nadir-building-detection/)[¶](#spacenet-challenge-round-4-off-nadir-buildings "Permalink to this headline")

3. [Konstantin Maksimov](https://www.linkedin.com/in/konstantin-maksimov/)

[solution](https://github.com/SpaceNetChallenge/SpaceNet_Off_Nadir_Solutions/tree/master/MaksimovKA_solution)

#### CVPR[¶](#cvpr "Permalink to this headline")

##### 2018[¶](#id14 "Permalink to this headline")

##### [DeepGlobe: Road Extraction](https://competitions.codalab.org/competitions/18467)[¶](#deepglobe-road-extraction "Permalink to this headline")

2. [Vladimir Iglovikov](https://www.linkedin.com/in/iglovikov/), [Alexander Buslaev](https://www.kaggle.com/albuslaev), [Selim Seferbekov](https://www.kaggle.com/selimsef), [Alexey Shvets](https://www.linkedin.com/in/shvetsiya/)

[paper](http://openaccess.thecvf.com/content_cvpr_2018_workshops/papers/w4/Buslaev_Fully_Convolutional_Network_CVPR_2018_paper.pdf)

##### [Deepglobe: Building detection](https://competitions.codalab.org/competitions/18544)[¶](#deepglobe-building-detection "Permalink to this headline")

2. [Vladimir Iglovikov](https://www.linkedin.com/in/iglovikov/), [Alexander Buslaev](https://www.kaggle.com/albuslaev), [Selim Seferbekov](https://www.kaggle.com/selimsef), [Alexey Shvets](https://www.linkedin.com/in/shvetsiya/)

[paper](http://openaccess.thecvf.com/content_cvpr_2018_workshops/papers/w4/Iglovikov_TernausNetV2_Fully_Convolutional_CVPR_2018_paper.pdf)

##### [Deepglobe: Land Cover Classification](https://competitions.codalab.org/competitions/18468)[¶](#deepglobe-land-cover-classification "Permalink to this headline")

3. [Vladimir Iglovikov](https://www.linkedin.com/in/iglovikov/), [Alexander Buslaev](https://www.kaggle.com/albuslaev), [Selim Seferbekov](https://www.kaggle.com/selimsef), [Alexey Shvets](https://www.linkedin.com/in/shvetsiya/)

[paper](http://openaccess.thecvf.com/content_cvpr_2018_workshops/papers/w4/Seferbekov_Feature_Pyramid_Network_CVPR_2018_paper.pdf)

#### MICCAI[¶](#miccai "Permalink to this headline")

##### 2017[¶](#id15 "Permalink to this headline")

##### [Robotic Instrument Segmentation](https://endovissub2017-roboticinstrumentsegmentation.grand-challenge.org/)[¶](#robotic-instrument-segmentation "Permalink to this headline")

1. [Vladimir Iglovikov](https://www.linkedin.com/in/iglovikov/), [Alexey Shvets](https://www.linkedin.com/in/shvetsiya/)

[paper](https://ieeexplore.ieee.org/abstract/document/8614125),

[pre-print from organizers](https://arxiv.org/abs/1902.06426)

##### [GIANA: Angiodysplasia localization](https://endovissub2017-giana.grand-challenge.org/Tasks/)[¶](#giana-angiodysplasia-localization "Permalink to this headline")

1. [Vladimir Iglovikov](https://www.linkedin.com/in/iglovikov/), [Alexey Shvets](https://www.linkedin.com/in/shvetsiya/)

[paper](https://ieeexplore.ieee.org/abstract/document/8614123)

### Citations[¶](#citations "Permalink to this headline")

Albumentations is widely used in research areas related to computer vision and deep learning.

If you find this library useful for your research, please consider citing:

```

@article{2018arXiv180906839B,

  author = {A. Buslaev, A. Parinov, E. Khvedchenya, V.~I. Iglovikov and A.~A. Kalinin},

  title = "{Albumentations: fast and flexible image augmentations}",

  journal = {ArXiv e-prints},

  eprint = {1809.06839},

  year = 2018

}

```

#### List of papers that cite Albumentations[¶](#list-of-papers-that-cite-albumentations "Permalink to this headline")

##### 1. [Camera Model Identification Using Convolutional Neural Networks](https://ieeexplore.ieee.org/abstract/document/8622031/).[¶](#id1 "Permalink to this headline")

October 2018 - [A Kuzin](https://scholar.google.com/citations?user=lHjLPBsAAAAJ&hl=en&oi=sra), A Fattakhov, I Kibardin.

##### 2. [Automatic lesion boundary detection in dermoscopy](https://arxiv.org/abs/1812.00877).[¶](#id2 "Permalink to this headline")

December 2018 - G Kechyn.

##### 3. [Automatic salt deposits segmentation: A deep learning approach](https://arxiv.org/abs/1812.01429).[¶](#id3 "Permalink to this headline")

December 2018 - M Karchevskiy, [I Ashrapov](https://scholar.google.com/citations?user=eTn5PTIAAAAJ&hl=en&oi=sra), L Kozinkin.

##### 4. [Adapting Convolutional Neural Networks for Geographical Domain Shift](https://arxiv.org/abs/1901.06345).[¶](#id4 "Permalink to this headline")

January 2019 - [P Ostyakov](https://scholar.google.com/citations?user=mREcLI8AAAAJ&hl=en&oi=sra), [SI Nikolenko](https://scholar.google.com/citations?user=_lk95cEAAAAJ&hl=en&oi=sra).

##### 5. [Cell Nuclear Morphology Analysis Using 3D Shape Modeling, Machine Learning and Visual Analytics](https://deepblue.lib.umich.edu/handle/2027.42/147598).[¶](#id5 "Permalink to this headline")

February 2019 - [A Kalinin](https://scholar.google.com/citations?user=oEHDAgMAAAAJ&hl=en&oi=sra).

##### 6. [Safe Augmentation: Learning Task-Specific Transformations from Data](https://arxiv.org/abs/1907.12896).[¶](#id6 "Permalink to this headline")

February 2019 - I Baran, [O Kupyn](https://scholar.google.com/citations?user=Yl1Lu2YAAAAJ&hl=en&oi=sra), A Kravchenko.

##### 7. [Self-supervised Learning for Dense Depth Estimation in Monocular Endoscopy](https://arxiv.org/abs/1902.07766).[¶](#id7 "Permalink to this headline")

February 2019 - [X Liu](https://scholar.google.com/citations?user=qMxRGQkAAAAJ&hl=en&oi=sra), [A Sinha](https://scholar.google.com/citations?user=RrhxYCAAAAAJ&hl=en&oi=sra), M Ishii, [GD Hager](https://scholar.google.com/citations?user=ivApfKcAAAAJ&hl=en&oi=sra), [A Reiter](https://scholar.google.com/citations?user=CxKgqz0AAAAJ&hl=en&oi=sra).

##### 8. [U-NetPlus: A Modified Encoder-Decoder U-Net Architecture for Semantic and Instance Segmentation of Surgical Instrument](https://arxiv.org/abs/1902.08994).[¶](#id8 "Permalink to this headline")

February 2019 - [SM Hasan](https://scholar.google.com/citations?user=1-n7bwMAAAAJ&hl=en&oi=sra), [CA Linte](https://scholar.google.com/citations?user=Gv4gGVsAAAAJ&hl=en&oi=sra).

##### 9. [General Purpose (GenP) Bioimage Ensemble of Handcrafted and Learned Features with Data Augmentation](https://arxiv.org/abs/1904.08084).[¶](#id9 "Permalink to this headline")

March 2019 - [L Nanni](https://scholar.google.com/citations?user=5NSGzcQAAAAJ&hl=en&oi=sra), [S Brahnam](https://scholar.google.com/citations?user=sYF3eJkAAAAJ&hl=en&oi=sra), [S Ghidoni](https://scholar.google.com/citations?user=s5PIk-4AAAAJ&hl=en&oi=sra), [G Maguolo](https://scholar.google.com/citations?user=Df9a1YkAAAAJ&hl=en&oi=sra).

##### 10. [Breast Tumor Cellularity Assessment using Deep Neural Networks](https://arxiv.org/abs/1905.01743).[¶](#id10 "Permalink to this headline")

May 2019 - [A Rakhlin](https://scholar.google.com/citations?user=TIAJg3IAAAAJ&hl=en&oi=sra), [AA Shvets](https://scholar.google.com/citations?user=_eJ5xysAAAAJ&hl=en&oi=sra), [AA Kalinin](https://scholar.google.com/citations?user=oEHDAgMAAAAJ&hl=en&oi=sra), [A Tiulpin](https://scholar.google.com/citations?user=EFE2gpQAAAAJ&hl=en&oi=sra).

##### 11. [A Deep 3D Object Pose Estimation Framework for Robots with RGB-D Sensors](https://digitalcommons.wpi.edu/etd-theses/1287/).[¶](#id11 "Permalink to this headline")

June 2019 - AY Wagh.

##### 12. [Data Augmentation From RGB to Chlorophyll Fluorescence Imaging Application to Leaf Segmentation of Arabidopsis thaliana From Top View Images](http://openaccess.thecvf.com/content_CVPRW_2019/html/CVPPP/Sapoukhina_Data_Augmentation_From_RGB_to_Chlorophyll_Fluorescence_Imaging_Application_to_CVPRW_2019_paper.html).[¶](#id12 "Permalink to this headline")

June 2019 - N Sapoukhina, [S Samiei](https://scholar.google.com/citations?user=64L4ImgAAAAJ&hl=en&oi=sra), [P Rasti](https://scholar.google.com/citations?user=hl8Jyr4AAAAJ&hl=en&oi=sra).

##### 13. [CLoDSA: a tool for augmentation in classification, localization, detection, semantic segmentation and instance segmentation tasks](https://bmcbioinformatics.biomedcentral.com/articles/10.1186/s12859-019-2931-1).[¶](#id13 "Permalink to this headline")

June 2019 - Á Casado-García, C Domínguez.

##### 14. [Urban Sound Tagging using Convolutional Neural Networks](https://arxiv.org/abs/1909.12699).[¶](#id14 "Permalink to this headline")

July 2019 - [S Adapa](https://scholar.google.com/citations?user=SJUsAwsAAAAJ&hl=en&oi=sra).

##### 15. [A Framework for Knowing Who is Doing What in Aerial Surveillance Videos](https://ieeexplore.ieee.org/abstract/document/8753491/).[¶](#id15 "Permalink to this headline")

July 2019 - [F Yang](https://scholar.google.com/citations?user=LndV87gAAAAJ&hl=en&oi=sra), [S Sakti](https://scholar.google.com/citations?user=E0uhtlkAAAAJ&hl=en&oi=sra), Y Wu, S Nakamura.

##### 16. [Visual Anomaly Detection For Automatic Quality Control](https://boa.unimib.it/handle/10281/241219).[¶](#id16 "Permalink to this headline")

July 2019 - [F Piccoli](https://scholar.google.com/citations?user=qBoFeZoAAAAJ&hl=en&oi=sra).

##### 17. [Physical Cue based Depth-Sensing by Color Coding with Deaberration Network](https://arxiv.org/abs/1908.00329).[¶](#id17 "Permalink to this headline")

August 2019 - N Mishima, T Kozakaya, A Moriya, R Okada.

##### 18. [Bayesian Feature Pyramid Networks for Automatic Multi-Label Segmentation of Chest X-rays and Assessment of Cardio-Thoratic Ratio](https://arxiv.org/abs/1908.02924).[¶](#id18 "Permalink to this headline")

August 2019 - R Solovyev, [I Melekhov](https://scholar.google.com/citations?user=BXNprrsAAAAJ&hl=en&oi=sra), T Lesonen.

##### 19. [DeblurGAN-v2: Deblurring (Orders-of-Magnitude) Faster and Better](https://arxiv.org/abs/1908.03826).[¶](#id19 "Permalink to this headline")

August 2019 - [O Kupyn](https://scholar.google.com/citations?user=Yl1Lu2YAAAAJ&hl=en&oi=sra), [T Martyniuk](https://scholar.google.com/citations?user=Ur0vgfMAAAAJ&hl=en&oi=sra), [J Wu](https://scholar.google.com/citations?user=nBbGvyEAAAAJ&hl=en&oi=sra), [Z Wang](https://scholar.google.com/citations?user=pxFyKAIAAAAJ&hl=en&oi=sra).

##### 20. [The Impact of Padding on Image Classification by Using Pre-trained Convolutional Neural Networks](https://link.springer.com/chapter/10.1007/978-3-030-30645-8_31).[¶](#id21 "Permalink to this headline")

September 2019 - H Tang, [A Ortis](https://scholar.google.com/citations?user=gcztqXgAAAAJ&hl=en&oi=sra), [S Battiato](https://scholar.google.com/citations?user=OplbtHgAAAAJ&hl=en&oi=sra).

##### 21. [A load frame for in situ tomography at PETRA III](https://www.spiedigitallibrary.org/conference-proceedings-of-spie/11113/1111318/A-load-frame-for-in-situ-tomography-at-PETRA-III/10.1117/12.2530445.short).[¶](#id22 "Permalink to this headline")

September 2019 - J Moosmann, DCF Wieland.

##### 22. [Deep convolutions for in-depth automated rock typing](https://www.sciencedirect.com/science/article/pii/S0098300419304686).[¶](#id23 "Permalink to this headline")

September 2019 - EE Baraboshkin, [LS Ismailova](https://scholar.google.com/citations?user=-ZP9a8YAAAAJ&hl=en&oi=sra), [DM Orlov](https://scholar.google.com/citations?user=jP69FIgAAAAJ&hl=en&oi=sra).

##### 23. [残差密集相对平均 CGAN 的图像配准方法](http://www.cjig.cn/jig/ch/reader/download_new_edit_content.aspx?edit_id=20190926091554001&file_no=201903270000001&journal_id=jig).[¶](#id24 "Permalink to this headline")

September 2019 - 王丽芳， 张程程， 秦品乐， 蔺素珍， 高媛， 窦杰亮.

##### 24. [Cloud Recognition and Masking of Earth Observation Imagery-An Optimized approach for Automatic Labeling of Sentinel-2 Imagery for Object Detection](https://ntnuopen.ntnu.no/ntnu-xmlui/handle/11250/2619036).[¶](#id25 "Permalink to this headline")

September 2019 - LM Ellefsen.

