• Search by Module
• Search by Words
• Search Projects

• Java
• Python
• JavaScript
• TypeScript
• C++
• Scala
• Blog

• pandas-ml-master
  • requirements_test.txt
  • examples
    • kaggle_otto_xgboost.ipynb
    • kaggle_titanic.ipynb
  • LICENSE
  • pandas_ml
    • imbaccessors
      • test
        • test_imbalance.py
        • __init__.py
      • __init__.py
      • base.py
    • version.py
    • test
      • test_frame.py
      • test_groupby.py
      • __init__.py
      • test_series.py
    • snsaccessors
      • test
        • __init__.py
        • test_sns.py
      • __init__.py
      • base.py
    • util
      • testing.py
      • _util.py
      • __init__.py
    • misc
      • patsy_wraps.py
      • test
        • __init__.py
        • test_patsy.py
      • __init__.py
    • tools.py
    • xgboost
      • test
        • test_base.py
        • __init__.py
      • __init__.py
      • base.py
    • smaccessors
      • test
        • test_base.py
        • __init__.py
        • test_datasets.py
      • __init__.py
      • base.py
    • __init__.py
    • core
      • groupby.py
      • accessor.py
      • frame.py
      • generic.py
      • series.py
      • __init__.py
      • base.py
    • confusion_matrix
      • cm.py
      • test
        • test_confusion_matrix.py
        • __init__.py
      • stats.py
      • __init__.py
      • abstract.py
      • bcm.py
    • compat.py
    • skaccessors
      • pipeline.py
      • gaussian_process.py
      • ensemble.py
      • metrics.py
      • test
        • test_decomposition.py
        • test_calibration.py
        • test_base.py
        • test_neighbors.py
        • test_cluster.py
        • test_feature_selection.py
        • test_covariance.py
        • test_discriminant_analysis.py
        • test_random_projection.py
        • test_gaussian_process.py
        • test_preprocessing.py
        • test_ensemble.py
        • test_manifold.py
        • test_multiclass.py
        • test_svm.py
        • test_linear_model.py
        • test_isotonic.py
        • test_naive_bayes.py
        • test_multioutput.py
        • test_dummy.py
        • test_cross_decomposition.py
        • test_mixture.py
        • test_feature_extraction.py
        • test_kernel_approximation.py
        • __init__.py
        • test_metrics.py
        • test_pipeline.py
        • test_datasets.py
        • test_tree.py
        • test_kernel_ridge.py
        • test_semi_supervised.py
        • test_model_selection.py
        • test_neural_network.py
      • linear_model.py
      • preprocessing.py
      • feature_extraction.py
      • model_selection.py
      • decomposition.py
      • manifold.py
      • __init__.py
      • cluster.py
      • svm.py
      • feature_selection.py
      • covariance.py
      • neighbors.py
      • cross_decomposition.py
      • isotonic.py
      • base.py
  • README.rst
  • setup.py
  • .travis.yml
  • scripts
    • build_travis.sh
  • requirements.txt
  • LICENSES
    • SEABORN_LICENSE
    • SKLEARN_LICENSE
    • PANDAS_LICENSE
    • XGBOOST_LICENSE
  • .gitignore
  • MANIFEST.in
  • doc
    • Makefile
    • source
      • whatsnew.rst
      • patsy.rst
      • modelframe.rst
      • sklearn.rst
      • imbalance.rst
      • screenshots
      • index.rst
      • conf.py
      • conf_mat.rst
      • xgboost.rst
    • make.bat

#!/usr/bin/env python
import pytest

import numpy as np
import sklearn.datasets as datasets
import statsmodels.api as sm

import pandas_ml.smaccessors.base as base
import pandas_ml.util.testing as tm


class TestBaseRegressor(tm.TestCase):

    def test_methods(self):
        from sklearn.base import clone
        obj = base.StatsModelsRegressor(sm.OLS, missing='raise')
        cloned = clone(obj)
        self.assertIsInstance(cloned, base.StatsModelsRegressor)
        self.assertTrue(cloned.statsmodel is sm.OLS)

        params = cloned.get_params()
        self.assertEqual(params, {'statsmodel': sm.OLS, 'missing': 'raise'})

        setted = cloned.set_params(statsmodel=sm.GLM, missing='none')
        self.assertIsInstance(setted, base.StatsModelsRegressor)
        self.assertEqual(setted.get_params(), {'statsmodel': sm.GLM, 'missing': 'none'})

    def test_OLS(self):
        diabetes = datasets.load_diabetes()
        estimator = base.StatsModelsRegressor(sm.OLS)
        fitted = estimator.fit(diabetes.data, diabetes.target)
        result = estimator.predict(diabetes.data)

        # estimator.score(diabetes.data, diabetes.target)

        import statsmodels.regression.linear_model as lm
        self.assertIsInstance(fitted, lm.RegressionResultsWrapper)

        fitted2 = sm.OLS(diabetes.target, diabetes.data).fit()
        expected = fitted2.predict(diabetes.data)
        self.assert_numpy_array_almost_equal(result, expected)

    def test_precict(self):
        diabetes = datasets.load_diabetes()
        estimator = base.StatsModelsRegressor(sm.OLS)
        with pytest.raises(ValueError, match='StatsModelsRegressor is not fitted to data'):
            estimator.predict(diabetes.data)

    def test_Regressions(self):
        diabetes = datasets.load_diabetes()
        models = ['OLS', 'GLS', 'WLS', 'GLSAR', 'QuantReg', 'GLM', 'RLM']

        for model in models:
            klass = getattr(sm, model)

            estimator = base.StatsModelsRegressor(klass)
            estimator.fit(diabetes.data, diabetes.target)
            result = estimator.predict(diabetes.data)

            expected = klass(diabetes.target, diabetes.data).fit().predict(diabetes.data)
            self.assert_numpy_array_almost_equal(result, expected)

    def test_GEE(self):
        import statsmodels.genmod.generalized_estimating_equations as geq
        diabetes = datasets.load_diabetes()
        models = ['GEE']            # 'OrdinalGEE', 'NominalGEE']
        data = diabetes.data[:100, :]
        target = diabetes.target[:100]
        groups = np.array([0] * 50 + [1] * 50)
        for model in models:
            klass = getattr(sm, model)

            estimator = base.StatsModelsRegressor(klass, groups=groups)
            fitted = estimator.fit(data, target)
            result = estimator.predict(diabetes.data)
            self.assertIsInstance(fitted, geq.GEEResultsWrapper)

            expected = klass(target, data, groups=groups).fit().predict(diabetes.data)
            self.assert_numpy_array_almost_equal(result, expected)

    def test_MixedLM(self):
        import statsmodels.regression.mixed_linear_model as mlm
        diabetes = datasets.load_diabetes()
        models = ['MixedLM']
        data = diabetes.data[:100, :]
        target = diabetes.target[:100]
        groups = np.array([0] * 50 + [1] * 50)
        for model in models:
            klass = getattr(sm, model)

            estimator = base.StatsModelsRegressor(klass, groups=groups)
            fitted = estimator.fit(data, target)
            # result = estimator.predict(diabetes.data)
            # NotImplementedError
            self.assertIsInstance(fitted, mlm.MixedLMResultsWrapper)

            # expected = klass(target, data, groups=groups).fit().predict(diabetes.data)
            # self.assert_numpy_array_almost_equal(result, expected)

    def test_pipeline(self):
        from sklearn.feature_selection import SelectKBest
        from sklearn.feature_selection import f_regression
        from sklearn.pipeline import Pipeline

        diabetes = datasets.load_diabetes()
        models = ['OLS', 'GLS', 'WLS', 'GLSAR', 'QuantReg', 'GLM', 'RLM']

        for model in models:
            klass = getattr(sm, model)

            selector = SelectKBest(f_regression, k=5)
            estimator = Pipeline([('selector', selector),
                                  ('reg', base.StatsModelsRegressor(klass))])

            estimator.fit(diabetes.data, diabetes.target)
            result = estimator.predict(diabetes.data)

            data = SelectKBest(f_regression, k=5).fit_transform(diabetes.data, diabetes.target)
            expected = klass(diabetes.target, data).fit().predict(data)
            self.assert_numpy_array_almost_equal(result, expected)

    def test_gridsearch(self):
        import sklearn.model_selection as ms
        tuned_parameters = {'statsmodel': [sm.OLS, sm.GLS]}
        diabetes = datasets.load_diabetes()

        cv = ms.GridSearchCV(base.StatsModelsRegressor(sm.OLS), tuned_parameters, cv=5, scoring=None)
        fitted = cv.fit(diabetes.data, diabetes.target)
        self.assertTrue(fitted.best_estimator_.statsmodel is sm.OLS)