def test_predict(self): X = np.array([[1,1], [0,0]]) y = np.array([1,2]) regression = LinearRegression() self.assertRaises(RuntimeError, regression.predict, X) regression.fit(X, y) y_pred = regression.predict(X) self.assertEqual(y_pred.shape[0], X.shape[0])
def test_predict(self):
X = np.array([[1, 1], [0, 0]])
y = np.array([1, 2])
regression = LinearRegression()
self.assertRaises(RuntimeError, regression.predict, X)
regression.fit(X, y)
y_pred = regression.predict(X)
self.assertEqual(y_pred.shape[0], X.shape[0])
def test_partial_fit(self): X = np.array([[1,1], [0,0]]) y = np.array([1,2]) regression = LinearRegression() self.assertTrue(regression.clf_ is None) self.assertEqual(regression.fitted_, False) regression.partial_fit(X, y) self.assertTrue(regression.clf_ is not None) self.assertEqual(regression.fitted_, True)
def test_partial_fit(self):
X = np.array([[1, 1], [0, 0]])
y = np.array([1, 2])
regression = LinearRegression()
self.assertTrue(regression.clf_ is None)
self.assertEqual(regression.fitted_, False)
regression.partial_fit(X, y)
self.assertTrue(regression.clf_ is not None)
self.assertEqual(regression.fitted_, True)
def test_get_params(self):
params = {
'method': 'CW',
'regularization_weight': 5.0,
'sensitivity': 1.0,
'learning_rate': 0.1,
'n_iter': 5,
'shuffle': True,
'embedded': True,
'seed': 42
}
regression = LinearRegression(**params)
self.assertDictEqual(params, regression.get_params())
regression.stop()
def test_get_params(self):
params = {
'method': 'CW',
'regularization_weight': 5.0,
'sensitivity': 1.0,
'learning_rate': 0.1,
'n_iter': 5,
'shuffle': True,
'embedded': True,
'seed': 42
}
regression = LinearRegression(**params)
self.assertDictEqual(params, regression.get_params())
regression.stop()
def test_class_params(self):
regression = LinearRegression()
params = [
'method', 'regularization_weight', 'sensitivity', 'learning_rate',
'n_iter', 'shuffle', 'embedded', 'seed'
]
for param in params:
self.assertTrue(param in regression.__dict__)
self.assertTrue('invalid_param' not in regression.__dict__)
def test_set_params(self):
params = {
'method': 'CW',
'regularization_weight': 5.0,
'sensitivity': 1.0,
'learning_rate': 0.1,
'n_iter': 5,
'shuffle': True,
'embedded': True,
'seed': 42
}
regression = LinearRegression()
regression.set_params(**params)
self.assertEqual(regression.method, params['method'])
self.assertEqual(regression.regularization_weight, params['regularization_weight'])
self.assertEqual(regression.sensitivity, params['sensitivity'])
self.assertEqual(regression.learning_rate, params['learning_rate'])
self.assertEqual(regression.n_iter, params['n_iter'])
self.assertEqual(regression.shuffle, params['shuffle'])
self.assertEqual(regression.embedded, params['embedded'])
self.assertEqual(regression.seed, params['seed'])
def test_set_params(self):
params = {
'method': 'CW',
'regularization_weight': 5.0,
'sensitivity': 1.0,
'learning_rate': 0.1,
'n_iter': 5,
'shuffle': True,
'embedded': True,
'seed': 42
}
regression = LinearRegression()
regression.set_params(**params)
self.assertEqual(regression.method, params['method'])
self.assertEqual(regression.regularization_weight,
params['regularization_weight'])
self.assertEqual(regression.sensitivity, params['sensitivity'])
self.assertEqual(regression.learning_rate, params['learning_rate'])
self.assertEqual(regression.n_iter, params['n_iter'])
self.assertEqual(regression.shuffle, params['shuffle'])
self.assertEqual(regression.embedded, params['embedded'])
self.assertEqual(regression.seed, params['seed'])
def launch_regression(method): regression = LinearRegression(method=method) regression._launch_regression()
def test_simple(self): regression = LinearRegression() regression.stop()
def test_save(self): name = 'test' regression = LinearRegression() regression.save(name)
def test_simple(self):
regression = LinearRegression()
regression.stop()
def launch_regression(method):
regression = LinearRegression(method=method)
regression._launch_regression()
def test_embedded(self):
regression = LinearRegression(embedded=True)
from sklearn.decomposition import PCA
from sklearn.preprocessing import MinMaxScaler
from sklearn.metrics import mean_squared_error
from sklearn.pipeline import Pipeline
from sklearn.utils import shuffle
# load boston housing values dataset
boston = load_boston()
# shuffle and separate the dataset
X, y = shuffle(boston.data, boston.target, random_state=42)
n_train = int(X.shape[0] / 2)
X_train, y_train = X[:n_train], y[:n_train]
X_test, y_test = X[n_train:], y[n_train:]
# launch linear regression (AROW)
clf = LinearRegression(n_iter=5, method='AROW', embedded=False, seed=42)
# scale dataset
scaled_pipeline = Pipeline([('scaler', MinMaxScaler()), ('regression', clf)])
# decompose dataset
pca_pipeline = Pipeline([('pca', PCA()), ('regression', clf)])
# evaluate each pipelines
pipelines = [clf, scaled_pipeline, pca_pipeline]
for pipeline in pipelines:
print(pipeline)
pipeline.fit(X_train, y_train)
y_pred = pipeline.predict(X_test)
print('MSE:', mean_squared_error(y_test, y_pred))
def test_save(self):
name = 'test'
regression = LinearRegression()
regression.save(name)