IndependentValidation(Results):  # by ilja Grabovsky
    """
    Test on Idenpendent Validation - Splitter
    First the Splitter splits Input data in train_data and test_data.X. train_data will be sized to =.1
    to classify on it....erkärung.
    """

    def __init__(self, data, learner, k=2, stratified=True, random_state=0, store_data=False,
                 store_models=False, preprocessor=None, callback=None, warnings=None,
                 n_jobs=1)

    self.stratified = stratified
    train_data = train_size


if warnings is None:
    self.warnings = []
else:
    self.warnings = warnings

super().__init__(data, learners=learners, store_data=store_data,
                 store_models=store_models, preprocessor=preprocessor,
                 callback=callback, n_jobs=n_jobs)


def setup_indices(self, train_data, test_data):
    self.indices = None


if self.stratified and test_data.domain.has_discrete_class:
    try:
        splitter = skl.IndependentValidation(
            self.k, shuffle=False, random_state=self.random_state
        )
        splitter.get_n_splits(test_data.X, train_data)
        self.indices = list(splitter.split(test_data.X, train_data))
    except ValueError:
        self.warnings.append("Using non-stratified sampling.") #braucht IV Stratified S.
        self.indices = None
if self.indices is None:
    splitter = skl.IndependentValidation(
        self.k, shuffle=True, random_state=self.random_state
    )
    splitter.get_n_splits, train_size = .1(test_data.X, train_data) #train_size in Sklearn definieren
    self.indices = list(splitter.split(test_data))


# train_data=n.1 -> train.data_main, test.data.X=n.9->skl.splitter=test.data_main

class IndependentValidation(Results):  # test.data split

    # by ilja Grabovsky
    """
    Test on Idenpendent Validation second Splitter
    First the Splitter splits test_data.X in n_test_data
    n=len(list(test_data.X)) - 1
    n!=0
    to classify on it....erkärung.
    """

    def __init__(self, learner, k=n, stratified=True, random_state=0, store_data=False,
                 store_models=False, preprocessor=None, callback=None, warnings=None,
                 n_jobs=n)
        n = len(list(test_data.X)) - 1
        n != 0
        self.k = int(k)

    self.stratified = stratified
    self.random_state = random_state
    test_data.X_size = test_data.X_size


if warnings is None:
    self.warnings = []
else:
    self.warnings = warnings

super().__init__(data, learners=learners, store_data=store_data,
                 store_models=store_models, preprocessor=preprocessor,
                 callback=callback, n_jobs=n_jobs)


def setup_indices(self, test_data.


    X_data):
self.indices = None
if self.stratified and test_data.X.domain.has_discrete_class:
    try:
        splitter = skl.StratifiedKFold(
            self.k, shuffle=True, random_state=self.random_state  # entfernen
        )
        splitter.get_n_splits(test_data.n)
        self.indices = list(splitter.split(test_data.n, ))
    except ValueError:
        self.warnings.append("Using non-stratified sampling.")
        self.indices = None
if self.indices is None:
    splitter = skl.KFold(
        self.k, shuffle=True, random_state=self.random_state
    )
    splitter.get_n_splits(test_data.n)
    self.indices = list(splitter.split(test_data.X))


class IndependentValidation(Results):  # by ilja Grabovsky
    """
    Classification of train_data sized to =.1
    """

    def __init__(self, data, learners, feature, store_data=False, store_models=False,
                 preprocessor=None, callback=None,
                 n_jobs=  # len(list(test_data.X)): wenn ich das so lasse dann geht der jegliche Schritte x mal entsprechend der len(list(test_data,X)) durch
                 self.feature =

    feature
    super().__init__(data, learners=learners, store_data=store_data,
                     store_models=store_models, preprocessor=preprocessor,
                     callback=callback, n_jobs=n_jobs)

    def setup_indices(self, train_data, test_data.

        X, test_data):
    data = Table(Domain([self.feature], None), test_data)
    values = data[:, self.feature].X
    self.indices = []
    for v in range(len(self.feature.values)):
        test_index = np.where(values == v)[0]
        train_index = np.where((values != v) & (~np.isnan(values)))[0]
        if len(test_index) and len(train_index):
            self.indices.append((train_index, test_index))
    if not self.indices:
        raise ValueError("No folds could be created from the given feature.")