//  [python]
def __init__(self, data_path, use_one_hot=False, validation_size=0,
                 use_torch_augmentation=False, use_cutout=False,
                 include_train_extra=False):
        super().__init__()

        # Actual data path
        data_path = os.path.join(data_path, SVHNData._SUBFOLDER)
        if not os.path.exists(data_path):
            os.makedirs(data_path)

        svhn_train = SVHN(data_path, split='train', download=True)
        svhn_test = SVHN(data_path, split='test', download=True)
        svhn_extra = None
        if include_train_extra:
            svhn_extra = SVHN(data_path, split='extra', download=True)

        assert np.all(np.equal(svhn_train.data.shape, [73257, 3, 32, 32]))
        assert np.all(np.equal(svhn_test.data.shape, [26032, 3, 32, 32]))
        assert not include_train_extra or \
               np.all(np.equal(svhn_extra.data.shape, [531131, 3, 32, 32]))

        train_inputs = svhn_train.data
        test_inputs = svhn_test.data
        train_labels = svhn_train.labels
        test_labels = svhn_test.labels
        if include_train_extra:
            train_inputs = np.concatenate([train_inputs, svhn_extra.data],
                                          axis=0)
            train_labels = np.concatenate([train_labels, svhn_extra.labels],
                                          axis=0)

        images = np.concatenate([train_inputs, test_inputs], axis=0)
        labels = np.concatenate([train_labels, test_labels], axis=0)

        # Note, images are currently encoded in a way, that their shape
        # corresponds to (3, 32, 32). For consistency reasons, we would like to
        # change that to (32, 32, 3).
        images = np.rollaxis(images, 1, 4)
        # Scale images into a range between 0 and 1.
        images = images / 255.

        images = images.reshape(-1, 32 * 32 * 3)
        labels = labels.reshape(-1, 1)

        val_inds = None
        train_inds = np.arange(train_labels.size)
        test_inds = np.arange(train_labels.size,
                              train_labels.size + test_labels.size)

        if validation_size > 0:
            if validation_size >= train_inds.size:
                raise ValueError('Validation set must contain less than %d ' \
                                 % (train_inds.size) + 'samples!')

            val_inds = np.arange(validation_size)
            train_inds = np.arange(validation_size, train_inds.size)

        # Bring everything into the internal structure of the Dataset class.
        self._data['classification'] = True
        self._data['sequence'] = False
        self._data['num_classes'] = 10
        self._data['is_one_hot'] = use_one_hot
        self._data['in_data'] = images
        self._data['in_shape'] = [32, 32, 3]
        self._data['out_shape'] = [10 if use_one_hot else 1]
        self._data['val_inds'] = val_inds
        self._data['train_inds'] = train_inds
        self._data['test_inds'] = test_inds

        if use_one_hot:
            labels = self._to_one_hot(labels)

        self._data['out_data'] = labels

        # Dataset specific attributes.
        self._data['svhn'] = dict()
        # 0 - original train, 1 - extra train, 2 - test
        # Note, independent of whether samples are now in the validation set.
        self._data['svhn']['type'] = np.zeros(self._data['in_data'].shape[0])
        if include_train_extra:
            self._data['svhn']['type'][svhn_train.labels.size:] = 1
        self._data['svhn']['type'][test_inds] = 2

        # Initialize PyTorch data augmentation.
        self._augment_inputs = False
        if use_torch_augmentation:
            self._augment_inputs = True
            # Note, horizontal flips change the meaning of digits!
            self._train_transform, self._test_transform = \
                CIFAR10Data.torch_input_transforms(apply_rand_hflips=False,
                    apply_cutout=use_cutout, cutout_length=20)

        print('Created %s.' % (str(self)))