def fit(self):
        seed = self.random_state.randint(1000000)
        for outer_fold in range(self.outer_cv_folds):
            # First perform the fit for the outer cross validation
            outer_train_indices, outer_test_indices = \
                get_CV_fold(self.X_train, self.Y_train, fold=outer_fold,
                            folds=self.outer_cv_folds, shuffle=True,
                            random_state=seed)
            self.outer_indices[outer_fold] = ((outer_train_indices,
                                               outer_test_indices))

            model = self.model_class(self.configuration, self.random_state)
            self.outer_models[outer_fold] = model
            self.outer_models[outer_fold].fit(self.X_train[outer_train_indices],
                                              self.Y_train[outer_train_indices])

            # Then perform the fit for the inner cross validation
            for inner_fold in range(self.inner_cv_folds):
                X_train = self.X_train[outer_train_indices]
                Y_train = self.Y_train[outer_train_indices]
                inner_train_indices, inner_test_indices = \
                    get_CV_fold(X_train, Y_train,
                                fold=inner_fold, folds=self.inner_cv_folds,
                                shuffle=True, random_state=seed)
                inner_train_indices = outer_train_indices[inner_train_indices]
                inner_test_indices = outer_train_indices[inner_test_indices]
                X_train = self.X_train[inner_train_indices]
                Y_train = self.Y_train[inner_train_indices]

                self.inner_indices[outer_fold][inner_fold] = \
                    ((inner_train_indices, inner_test_indices))
                model = self.model_class(self.configuration, self.random_state)
                model = model.fit(X_train, Y_train)
                self.inner_models[outer_fold][inner_fold] = model
    def fit(self):
        seed = self.random_state.randint(1000000)
        for outer_fold in range(self.outer_cv_folds):
            # First perform the fit for the outer cross validation
            outer_train_indices, outer_test_indices = \
                get_CV_fold(self.X_train, self.Y_train, fold=outer_fold,
                            folds=self.outer_cv_folds, shuffle=True,
                            random_state=seed)
            self.outer_indices[outer_fold] = ((outer_train_indices,
                                               outer_test_indices))

            model = self.model_class(self.configuration, self.random_state)
            self.outer_models[outer_fold] = model
            self.outer_models[outer_fold].fit(
                self.X_train[outer_train_indices],
                self.Y_train[outer_train_indices])

            # Then perform the fit for the inner cross validation
            for inner_fold in range(self.inner_cv_folds):
                X_train = self.X_train[outer_train_indices]
                Y_train = self.Y_train[outer_train_indices]
                inner_train_indices, inner_test_indices = \
                    get_CV_fold(X_train, Y_train,
                                fold=inner_fold, folds=self.inner_cv_folds,
                                shuffle=True, random_state=seed)
                inner_train_indices = outer_train_indices[inner_train_indices]
                inner_test_indices = outer_train_indices[inner_test_indices]
                X_train = self.X_train[inner_train_indices]
                Y_train = self.Y_train[inner_train_indices]

                self.inner_indices[outer_fold][inner_fold] = \
                    ((inner_train_indices, inner_test_indices))
                model = self.model_class(self.configuration, self.random_state)
                model = model.fit(X_train, Y_train)
                self.inner_models[outer_fold][inner_fold] = model
示例#3
0
    def partial_fit(self, fold):
        model = self.model_class(self.configuration, self.seed)

        train_indices, test_indices = \
            get_CV_fold(self.X_train, self.Y_train, fold=fold,
                        folds=self.cv_folds, shuffle=True, random_state=self.seed)

        self.indices[fold] = ((train_indices, test_indices))

        self.models[fold] = model
        self.models[fold].fit(self.X_train[train_indices],
                              self.Y_train[train_indices])