Ejemplo n.º 1
0
 def test_RobustLinearRegression_warm_start(self):
     """...Test RobustLinearRegression warm start
     """
     X, y, weights0, interc0, sample_intercepts0 = self.get_train_data(True)
     fit_intercepts = [True, False]
     cases = itertools.product(RobustLinearRegression._solvers.keys(),
                               fit_intercepts)
     for solver, fit_intercept in cases:
         solver_kwargs = {
             'C_sample_intercepts': Test.n_samples / Test.noise_level,
             'solver': solver,
             'max_iter': 2,
             'verbose': False,
             'fit_intercept': fit_intercept,
             'warm_start': True,
             'tol': 0
         }
         learner = RobustLinearRegression(**solver_kwargs)
         learner.fit(X, y)
         coeffs_1 = learner.coeffs
         learner.fit(X, y)
         coeffs_2 = learner.coeffs
         # Thanks to warm start objective should have decreased
         self.assertLess(learner._solver_obj.objective(coeffs_2),
                         learner._solver_obj.objective(coeffs_1))
Ejemplo n.º 2
0
    def test_RobustLinearRegression_fit(self):
        """...Test RobustLinearRegression fit with different solvers and penalties
        """
        X, y, weights0, interc0, sample_intercepts0 = self.get_train_data(True)

        solvers = RobustLinearRegression._solvers.keys()
        for i, solver in enumerate(solvers):
            learner_keywords = {
                'C_sample_intercepts': Test.n_samples / Test.noise_level,
                'fit_intercept': True,
                'fdr': Test.target_fdr,
                'max_iter': 3000,
                'tol': 1e-7,
                'solver': solver,
                'penalty': 'none',
                'verbose': False
            }

            learner = RobustLinearRegression(**learner_keywords)
            learner.fit(X, y)

            weights = [
                1.82145051, 2.32011366, 2.6886905, 2.53289584, 2.86991904
            ]
            interc = -2.9877245464563931
            fdp_ = 0.23076923076923078
            power = 1.0

            np.testing.assert_array_almost_equal(weights, learner.weights, 2)
            self.assertAlmostEqual(interc, learner.intercept, 2)
            self.assertAlmostEqual(
                fdp_, support_fdp(sample_intercepts0,
                                  learner.sample_intercepts), 4)
            self.assertAlmostEqual(
                power,
                support_recall(sample_intercepts0, learner.sample_intercepts),
                4)

        X, y, weights0, interc0, sample_intercepts0 = self.get_train_data(
            False)
        for i, solver in enumerate(solvers):
            learner_keywords = {
                'C_sample_intercepts': Test.n_samples / Test.noise_level,
                'fit_intercept': False,
                'fdr': Test.target_fdr,
                'max_iter': 3000,
                'tol': 1e-7,
                'solver': solver,
                'verbose': False
            }
            learner = RobustLinearRegression(**learner_keywords)
            learner.fit(X, y)
            weights = [
                1.82341444, 2.3226882, 2.68081823, 2.53942366, 2.86439685
            ]
            interc = None
            fdp_ = 0.23076923076923078
            power = 1.0

            np.testing.assert_array_almost_equal(weights, learner.weights, 2)
            self.assertEqual(interc, learner.intercept)
            self.assertAlmostEqual(
                fdp_, support_fdp(sample_intercepts0,
                                  learner.sample_intercepts), 4)
            self.assertAlmostEqual(
                power,
                support_recall(sample_intercepts0, learner.sample_intercepts),
                4)
Ejemplo n.º 3
0
sample_intercepts0[idx_nnz] = outliers_intensity * np.sqrt(2 * log_linspace) \
    * np.sign(sample_intercepts0[idx_nnz])

X = features_normal_cov_toeplitz(n_samples, n_features, 0.5)

y = X.dot(weights0) + noise_level * np.random.randn(n_samples) \
    + intercept0 + sample_intercepts0

target_fdr = 0.1
noise_level = std_iqr(y)
learner = RobustLinearRegression(C_sample_intercepts=2 * n_samples /
                                 noise_level,
                                 penalty='none',
                                 fdr=target_fdr,
                                 verbose=False)
learner.fit(X, y)

fdp_ = support_fdp(sample_intercepts0, learner.sample_intercepts)
power_ = support_recall(sample_intercepts0, learner.sample_intercepts)

fig = plt.figure(figsize=(7, 6))
titles = [
    'Model weights', 'Learned weights', 'Sample intercepts',
    'Learned intercepts'
]
vectors = [
    weights0, learner.weights, sample_intercepts0, learner.sample_intercepts
]
for idx_plot, title, vector in zip(range(221, 225), titles, vectors):
    ax = fig.add_subplot(idx_plot)
    ax.stem(vector)