def test_all_metrics(): """Check all supported metrics work""" params = {'function_set': ['add2', 'sub2', 'mul2', 'div2'], 'arities': {2: ['add2', 'sub2', 'mul2', 'div2']}, 'init_depth': (2, 6), 'init_method': 'half and half', 'n_features': 10, 'const_range': (-1.0, 1.0), 'metric': 'mean absolute error', 'p_point_replace': 0.05, 'parsimony_coefficient': 0.1} random_state = check_random_state(415) # Test for a small program test_gp = ['mul2', 'div2', 8, 1, 'sub2', 9, .5] gp = _Program(random_state=random_state, program=test_gp, **params) X = np.reshape(random_state.uniform(size=50), (5, 10)) y = random_state.uniform(size=5) sample_weight = np.ones(5) expected = [1.48719809776, 1.82389179833, 1.76013763179, 0.98663772258, -0.2928200724, -0.5] result = [] for m in ['mean absolute error', 'mse', 'rmse', 'rmsle', 'pearson', 'spearman']: gp.metric = m gp.raw_fitness_ = gp.raw_fitness(X, y, sample_weight) result.append(gp.fitness()) assert_array_almost_equal(result, expected) # And check a fake one gp.metric = 'the larch' assert_raises(ValueError, gp.raw_fitness, X, y, sample_weight)
def check_regressors_train(name, Regressor): X, y = _boston_subset() y = StandardScaler().fit_transform(y) # X is already scaled y = multioutput_estimator_convert_y_2d(name, y) rnd = np.random.RandomState(0) # catch deprecation warnings with warnings.catch_warnings(record=True): regressor = Regressor() set_fast_parameters(regressor) if not hasattr(regressor, 'alphas') and hasattr(regressor, 'alpha'): # linear regressors need to set alpha, but not generalized CV ones regressor.alpha = 0.01 if name == 'PassiveAggressiveRegressor': regressor.C = 0.01 # raises error on malformed input for fit assert_raises(ValueError, regressor.fit, X, y[:-1]) # fit if name in CROSS_DECOMPOSITION: y_ = np.vstack([y, 2 * y + rnd.randint(2, size=len(y))]) y_ = y_.T else: y_ = y set_random_state(regressor) regressor.fit(X, y_) regressor.fit(X.tolist(), y_.tolist()) regressor.predict(X) # TODO: find out why PLS and CCA fail. RANSAC is random # and furthermore assumes the presence of outliers, hence # skipped if name not in ('PLSCanonical', 'CCA', 'RANSACRegressor'): print(regressor) assert_greater(regressor.score(X, y_), 0.5)
def check_transformers_unfitted(name, Transformer): X, y = _boston_subset() with warnings.catch_warnings(record=True): transformer = Transformer() assert_raises(NotFittedError, transformer.transform, X)
def test_transformer_iterable(): """Check that the transformer is iterable""" random_state = check_random_state(415) X = np.reshape(random_state.uniform(size=50), (5, 10)) y = random_state.uniform(size=5) est = SymbolicTransformer(generations=2, random_state=0) # Check unfitted unfitted_len = len(est) unfitted_iter = [gp.length_ for gp in est] expected_iter = [] assert_true(unfitted_len == 0) assert_true(unfitted_iter == expected_iter) # Check fitted est.fit(X, y) fitted_len = len(est) fitted_iter = [gp.length_ for gp in est] expected_iter = [15, 19, 19, 12, 9, 10, 7, 14, 6, 21] assert_true(fitted_len == 10) assert_true(fitted_iter == expected_iter) # Check IndexError assert_raises(IndexError, est.__getitem__, 10)
def test_transformer_iterable(): """Check that the transformer is iterable""" random_state = check_random_state(415) X = np.reshape(random_state.uniform(size=50), (5, 10)) y = random_state.uniform(size=5) function_set = [ 'add', 'sub', 'mul', 'div', 'sqrt', 'log', 'abs', 'neg', 'inv', 'max', 'min' ] est = SymbolicTransformer(population_size=500, generations=2, function_set=function_set, random_state=0) # Check unfitted unfitted_len = len(est) unfitted_iter = [gp.length_ for gp in est] expected_iter = [] assert_true(unfitted_len == 0) assert_true(unfitted_iter == expected_iter) # Check fitted est.fit(X, y) fitted_len = len(est) fitted_iter = [gp.length_ for gp in est] expected_iter = [15, 19, 19, 12, 9, 10, 7, 14, 6, 21] assert_true(fitted_len == 10) assert_true(fitted_iter == expected_iter) # Check IndexError assert_raises(IndexError, est.__getitem__, 10)
def test_validate_program(): """Check that valid programs are accepted & invalid ones raise error""" function_set = ['add2', 'sub2', 'mul2', 'div2', 'sqrt1', 'log1', 'abs1', 'max2', 'min2'] arities = {1: ['sqrt1', 'log1', 'abs1'], 2: ['add2', 'sub2', 'mul2', 'div2', 'max2', 'min2']} init_depth = (2, 6) init_method = 'half and half' n_features = 10 const_range = (-1.0, 1.0) metric = 'mean absolute error' p_point_replace = 0.05 parsimony_coefficient = 0.1 random_state = check_random_state(415) test_gp = ['sub2', 'abs1', 'sqrt1', 'log1', 'log1', 'sqrt1', 7, 'abs1', 'abs1', 'abs1', 'log1', 'sqrt1', 2] # This one should be fine _ = _Program(function_set, arities, init_depth, init_method, n_features, const_range, metric, p_point_replace, parsimony_coefficient, random_state, test_gp) # Now try a couple that shouldn't be assert_raises(ValueError, _Program, function_set, arities, init_depth, init_method, n_features, const_range, metric, p_point_replace, parsimony_coefficient, random_state, test_gp[:-1]) assert_raises(ValueError, _Program, function_set, arities, init_depth, init_method, n_features, const_range, metric, p_point_replace, parsimony_coefficient, random_state, test_gp + [1])
def test_make_rng(): # Check the check_random_state utility function behavior assert_true(check_random_state(None) is np.random.mtrand._rand) assert_true(check_random_state(np.random) is np.random.mtrand._rand) rng_42 = np.random.RandomState(42) assert_true(check_random_state(42).randint(100) == rng_42.randint(100)) rng_42 = np.random.RandomState(42) assert_true(check_random_state(rng_42) is rng_42) rng_42 = np.random.RandomState(42) assert_true(check_random_state(43).randint(100) != rng_42.randint(100)) assert_raises(ValueError, check_random_state, "some invalid seed")
def check_estimators_empty_data_messages(name, Estimator): e = Estimator() set_fast_parameters(e) set_random_state(e, 1) X_zero_samples = np.empty(0).reshape(0, 3) # The precise message can change depending on whether X or y is # validated first. Let us test the type of exception only: assert_raises(ValueError, e.fit, X_zero_samples, []) X_zero_features = np.empty(0).reshape(3, 0) # the following y should be accepted by both classifiers and regressors # and ignored by unsupervised models y = multioutput_estimator_convert_y_2d(name, np.array([1, 0, 1])) msg = "0 feature(s) (shape=(3, 0)) while a minimum of 1 is required." assert_raise_message(ValueError, msg, e.fit, X_zero_features, y)
def check_estimators_partial_fit_n_features(name, Alg): # check if number of features changes between calls to partial_fit. if not hasattr(Alg, 'partial_fit'): return X, y = make_blobs(n_samples=50, random_state=1) X -= X.min() with warnings.catch_warnings(record=True): alg = Alg() set_fast_parameters(alg) if isinstance(alg, ClassifierMixin): classes = np.unique(y) alg.partial_fit(X, y, classes=classes) else: alg.partial_fit(X, y) assert_raises(ValueError, alg.partial_fit, X[:, :-1], y)
def test_input_shape(): """Check changed dimensions cause failure""" random_state = check_random_state(415) X = np.reshape(random_state.uniform(size=50), (5, 10)) y = random_state.uniform(size=5) X2 = np.reshape(random_state.uniform(size=45), (5, 9)) # Check the regressor est = SymbolicRegressor(generations=2, random_state=0) est.fit(X, y) assert_raises(ValueError, est.predict, X2) # Check the transformer est = SymbolicTransformer(generations=2, random_state=0) est.fit(X, y) assert_raises(ValueError, est.transform, X2)
def check_classifiers_pickle(name, Classifier): X, y = make_blobs(random_state=0) X, y = shuffle(X, y, random_state=7) X -= X.min() # catch deprecation warnings with warnings.catch_warnings(record=True): classifier = Classifier() set_fast_parameters(classifier) # raises error on malformed input for fit assert_raises(ValueError, classifier.fit, X, y[:-1]) # fit classifier.fit(X, y) y_pred = classifier.predict(X) pickled_classifier = pickle.dumps(classifier) unpickled_classifier = pickle.loads(pickled_classifier) pickled_y_pred = unpickled_classifier.predict(X) assert_array_almost_equal(pickled_y_pred, y_pred)
def test_column_or_1d(): EXAMPLES = [ ("binary", ["spam", "egg", "spam"]), ("binary", [0, 1, 0, 1]), ("continuous", np.arange(10) / 20.), ("multiclass", [1, 2, 3]), ("multiclass", [0, 1, 2, 2, 0]), ("multiclass", [[1], [2], [3]]), ("multilabel-indicator", [[0, 1, 0], [0, 0, 1]]), ("multiclass-multioutput", [[1, 2, 3]]), ("multiclass-multioutput", [[1, 1], [2, 2], [3, 1]]), ("multiclass-multioutput", [[5, 1], [4, 2], [3, 1]]), ("multiclass-multioutput", [[1, 2, 3]]), ("continuous-multioutput", np.arange(30).reshape((-1, 3))), ] for y_type, y in EXAMPLES: if y_type in ["binary", 'multiclass', "continuous"]: assert_array_equal(column_or_1d(y), np.ravel(y)) else: assert_raises(ValueError, column_or_1d, y)
def test_validate_functions(): """Check that valid functions are accepted & invalid ones raise error""" random_state = check_random_state(415) X = np.reshape(random_state.uniform(size=50), (5, 10)) y = random_state.uniform(size=5) for Symbolic in (SymbolicRegressor, SymbolicTransformer): # These should be fine est = Symbolic(generations=2, random_state=0, function_set=(add2, sub2, mul2, div2)) est.fit(boston.data, boston.target) est = Symbolic(generations=2, random_state=0, function_set=('add', 'sub', 'mul', div2)) est.fit(boston.data, boston.target) # These should fail est = Symbolic(generations=2, random_state=0, function_set=('ni', 'sub', 'mul', div2)) assert_raises(ValueError, est.fit, boston.data, boston.target) est = Symbolic(generations=2, random_state=0, function_set=(7, 'sub', 'mul', div2)) assert_raises(ValueError, est.fit, boston.data, boston.target) est = Symbolic(generations=2, random_state=0, function_set=()) assert_raises(ValueError, est.fit, boston.data, boston.target)
def test_indices(): """Check that indices are stable when generated on the fly.""" params = { 'function_set': [add2, sub2, mul2, div2], 'arities': { 2: [add2, sub2, mul2, div2] }, 'init_depth': (2, 6), 'init_method': 'half and half', 'n_features': 10, 'const_range': (-1.0, 1.0), 'metric': 'mean absolute error', 'p_point_replace': 0.05, 'parsimony_coefficient': 0.1 } random_state = check_random_state(415) test_gp = [mul2, div2, 8, 1, sub2, 9, .5] gp = _Program(random_state=random_state, program=test_gp, **params) assert_raises(ValueError, gp.get_all_indices) assert_raises(ValueError, gp._indices) def get_indices_property(): return gp.indices_ assert_raises(ValueError, get_indices_property) indices, _ = gp.get_all_indices(10, 7, random_state) assert_array_equal(indices, gp.get_all_indices()[0]) assert_array_equal(indices, gp._indices()) assert_array_equal(indices, gp.indices_)
def test_all_metrics(): """Check all supported metrics work""" params = { 'function_set': [add2, sub2, mul2, div2], 'arities': { 2: [add2, sub2, mul2, div2] }, 'init_depth': (2, 6), 'init_method': 'half and half', 'n_features': 10, 'const_range': (-1.0, 1.0), 'metric': 'mean absolute error', 'p_point_replace': 0.05, 'parsimony_coefficient': 0.1 } random_state = check_random_state(415) # Test for a small program test_gp = [mul2, div2, 8, 1, sub2, 9, .5] gp = _Program(random_state=random_state, program=test_gp, **params) X = np.reshape(random_state.uniform(size=50), (5, 10)) y = random_state.uniform(size=5) sample_weight = np.ones(5) expected = [ 1.48719809776, 1.82389179833, 1.76013763179, 0.98663772258, -0.2928200724, -0.5 ] result = [] for m in [ 'mean absolute error', 'mse', 'rmse', 'rmsle', 'pearson', 'spearman' ]: gp.metric = m gp.raw_fitness_ = gp.raw_fitness(X, y, sample_weight) result.append(gp.fitness()) assert_array_almost_equal(result, expected) # And check a fake one gp.metric = 'the larch' assert_raises(ValueError, gp.raw_fitness, X, y, sample_weight)
def check_estimators_unfitted(name, Estimator): """Check if NotFittedError is raised when calling predict and related functions""" # Common test for Regressors as well as Classifiers X, y = _boston_subset() with warnings.catch_warnings(record=True): est = Estimator() assert_raises(NotFittedError, est.predict, X) if hasattr(est, 'predict'): assert_raises(NotFittedError, est.predict, X) if hasattr(est, 'decision_function'): assert_raises(NotFittedError, est.decision_function, X) if hasattr(est, 'predict_proba'): assert_raises(NotFittedError, est.predict_proba, X) if hasattr(est, 'predict_log_proba'): assert_raises(NotFittedError, est.predict_log_proba, X)
def test_validate_program(): """Check that valid programs are accepted & invalid ones raise error""" function_set = [add2, sub2, mul2, div2, sqrt1, log1, abs1, max2, min2] arities = { 1: [sqrt1, log1, abs1], 2: [add2, sub2, mul2, div2, max2, min2] }, init_depth = (2, 6) init_method = 'half and half' n_features = 10 const_range = (-1.0, 1.0) metric = 'mean absolute error' p_point_replace = 0.05 parsimony_coefficient = 0.1 random_state = check_random_state(415) test_gp = [ sub2, abs1, sqrt1, log1, log1, sqrt1, 7, abs1, abs1, abs1, log1, sqrt1, 2 ] # This one should be fine _ = _Program(function_set, arities, init_depth, init_method, n_features, const_range, metric, p_point_replace, parsimony_coefficient, random_state, test_gp) # Now try a couple that shouldn't be assert_raises(ValueError, _Program, function_set, arities, init_depth, init_method, n_features, const_range, metric, p_point_replace, parsimony_coefficient, random_state, test_gp[:-1]) assert_raises(ValueError, _Program, function_set, arities, init_depth, init_method, n_features, const_range, metric, p_point_replace, parsimony_coefficient, random_state, test_gp + [1])
def test_validate_fitness(): """Check that valid fitness measures are accepted & invalid raise error""" # Check arg count checks fun = make_fitness(function=_mean_square_error, greater_is_better=True) # non-bool greater_is_better assert_raises(ValueError, make_fitness, _mean_square_error, 'Sure') assert_raises(ValueError, make_fitness, _mean_square_error, 1) # Check arg count tests def bad_fun1(x1, x2): return 1.0 assert_raises(ValueError, make_fitness, bad_fun1, True) # Check return type tests def bad_fun2(x1, x2, w): return 'ni' assert_raises(ValueError, make_fitness, bad_fun2, True)
def test_program_input_validation(): """Check that guarded input validation raises errors""" for Symbolic in (SymbolicRegressor, SymbolicTransformer): # Check too much proba est = Symbolic(p_point_mutation=.5) assert_raises(ValueError, est.fit, boston.data, boston.target) # Check invalid init_method est = Symbolic(init_method='ni') assert_raises(ValueError, est.fit, boston.data, boston.target) # Check invalid const_ranges est = Symbolic(const_range=2) assert_raises(ValueError, est.fit, boston.data, boston.target) est = Symbolic(const_range=[2, 2]) assert_raises(ValueError, est.fit, boston.data, boston.target) est = Symbolic(const_range=(2, 2, 2)) assert_raises(ValueError, est.fit, boston.data, boston.target) est = Symbolic(const_range='ni') assert_raises(ValueError, est.fit, boston.data, boston.target) # And check acceptable, but strange, representations of init_depth est = Symbolic(const_range=(2, 2)) est.fit(boston.data, boston.target) est = Symbolic(const_range=(4, 2)) est.fit(boston.data, boston.target) # Check invalid init_depth est = Symbolic(init_depth=2) assert_raises(ValueError, est.fit, boston.data, boston.target) est = Symbolic(init_depth=2) assert_raises(ValueError, est.fit, boston.data, boston.target) est = Symbolic(init_depth=[2, 2]) assert_raises(ValueError, est.fit, boston.data, boston.target) est = Symbolic(init_depth=(2, 2, 2)) assert_raises(ValueError, est.fit, boston.data, boston.target) est = Symbolic(init_depth='ni') assert_raises(ValueError, est.fit, boston.data, boston.target) est = Symbolic(init_depth=(4, 2)) assert_raises(ValueError, est.fit, boston.data, boston.target) # And check acceptable, but strange, representations of init_depth est = Symbolic(init_depth=(2, 2)) est.fit(boston.data, boston.target) # Check hall_of_fame and n_components for transformer est = SymbolicTransformer(hall_of_fame=1000) assert_raises(ValueError, est.fit, boston.data, boston.target) est = SymbolicTransformer(n_components=1000) assert_raises(ValueError, est.fit, boston.data, boston.target) est = SymbolicTransformer(hall_of_fame=0) assert_raises(ValueError, est.fit, boston.data, boston.target) est = SymbolicTransformer(n_components=0) assert_raises(ValueError, est.fit, boston.data, boston.target) # Check regressor metrics for m in ['mean absolute error', 'mse', 'rmse', 'rmsle']: est = SymbolicRegressor(generations=2, metric=m) est.fit(boston.data, boston.target) # And check the transformer metrics as well as a fake one for m in ['pearson', 'spearman', 'the larch']: est = SymbolicRegressor(generations=2, metric=m) assert_raises(ValueError, est.fit, boston.data, boston.target) # Check transformer metrics for m in ['pearson', 'spearman']: est = SymbolicTransformer(generations=2, metric=m) est.fit(boston.data, boston.target) # And check the regressor metrics as well as a fake one for m in ['mean absolute error', 'mse', 'rmse', 'rmsle', 'the larch']: est = SymbolicTransformer(generations=2, metric=m) assert_raises(ValueError, est.fit, boston.data, boston.target)
def test_resample_value_errors(): # Check that invalid arguments yield ValueError assert_raises(ValueError, resample, [0], [0, 1]) assert_raises(ValueError, resample, [0, 1], [0, 1], n_samples=3) assert_raises(ValueError, resample, [0, 1], [0, 1], meaning_of_life=42)
def check_classifiers_train(name, Classifier): X_m, y_m = make_blobs(random_state=0) X_m, y_m = shuffle(X_m, y_m, random_state=7) X_m = StandardScaler().fit_transform(X_m) # generate binary problem from multi-class one y_b = y_m[y_m != 2] X_b = X_m[y_m != 2] for (X, y) in [(X_m, y_m), (X_b, y_b)]: # catch deprecation warnings classes = np.unique(y) n_classes = len(classes) n_samples, n_features = X.shape with warnings.catch_warnings(record=True): classifier = Classifier() if name in ['BernoulliNB', 'MultinomialNB']: X -= X.min() set_fast_parameters(classifier) set_random_state(classifier) # raises error on malformed input for fit assert_raises(ValueError, classifier.fit, X, y[:-1]) # fit classifier.fit(X, y) # with lists classifier.fit(X.tolist(), y.tolist()) assert_true(hasattr(classifier, "classes_")) y_pred = classifier.predict(X) assert_equal(y_pred.shape, (n_samples,)) # training set performance if name not in ['BernoulliNB', 'MultinomialNB']: assert_greater(accuracy_score(y, y_pred), 0.83) # raises error on malformed input for predict assert_raises(ValueError, classifier.predict, X.T) if hasattr(classifier, "decision_function"): try: # decision_function agrees with predict decision = classifier.decision_function(X) if n_classes is 2: assert_equal(decision.shape, (n_samples,)) dec_pred = (decision.ravel() > 0).astype(np.int) assert_array_equal(dec_pred, y_pred) if n_classes is 3: assert_equal(decision.shape, (n_samples, n_classes)) assert_array_equal(np.argmax(decision, axis=1), y_pred) # raises error on malformed input assert_raises(ValueError, classifier.decision_function, X.T) # raises error on malformed input for decision_function assert_raises(ValueError, classifier.decision_function, X.T) except NotImplementedError: pass if hasattr(classifier, "predict_proba"): # predict_proba agrees with predict y_prob = classifier.predict_proba(X) assert_equal(y_prob.shape, (n_samples, n_classes)) assert_array_equal(np.argmax(y_prob, axis=1), y_pred) # check that probas for all classes sum to one assert_array_almost_equal(np.sum(y_prob, axis=1), np.ones(n_samples)) # raises error on malformed input assert_raises(ValueError, classifier.predict_proba, X.T) # raises error on malformed input for predict_proba assert_raises(ValueError, classifier.predict_proba, X.T)
def _check_transformer(name, Transformer, X, y): if name in ('CCA', 'LocallyLinearEmbedding', 'KernelPCA') and _is_32bit(): # Those transformers yield non-deterministic output when executed on # a 32bit Python. The same transformers are stable on 64bit Python. # FIXME: try to isolate a minimalistic reproduction case only depending # on numpy & scipy and/or maybe generate a test dataset that does not # cause such unstable behaviors. msg = name + ' is non deterministic on 32bit Python' raise SkipTest(msg) n_samples, n_features = np.asarray(X).shape # catch deprecation warnings with warnings.catch_warnings(record=True): transformer = Transformer() set_random_state(transformer) set_fast_parameters(transformer) # fit if name in CROSS_DECOMPOSITION: y_ = np.c_[y, y] y_[::2, 1] *= 2 else: y_ = y transformer.fit(X, y_) X_pred = transformer.fit_transform(X, y=y_) if isinstance(X_pred, tuple): for x_pred in X_pred: assert_equal(x_pred.shape[0], n_samples) else: assert_equal(X_pred.shape[0], n_samples) if hasattr(transformer, 'transform'): if name in CROSS_DECOMPOSITION: X_pred2 = transformer.transform(X, y_) X_pred3 = transformer.fit_transform(X, y=y_) else: X_pred2 = transformer.transform(X) X_pred3 = transformer.fit_transform(X, y=y_) if isinstance(X_pred, tuple) and isinstance(X_pred2, tuple): for x_pred, x_pred2, x_pred3 in zip(X_pred, X_pred2, X_pred3): assert_array_almost_equal( x_pred, x_pred2, 2, "fit_transform and transform outcomes not consistent in %s" % Transformer) assert_array_almost_equal( x_pred, x_pred3, 2, "consecutive fit_transform outcomes not consistent in %s" % Transformer) else: assert_array_almost_equal( X_pred, X_pred2, 2, "fit_transform and transform outcomes not consistent in %s" % Transformer) assert_array_almost_equal( X_pred, X_pred3, 2, "consecutive fit_transform outcomes not consistent in %s" % Transformer) # raises error on malformed input for transform if hasattr(X, 'T'): # If it's not an array, it does not have a 'T' property assert_raises(ValueError, transformer.transform, X.T)
def test_compute_class_weight_not_present(): # Raise error when y does not contain all class labels classes = np.arange(4) y = np.asarray([0, 0, 0, 1, 1, 2]) assert_raises(ValueError, compute_class_weight, "auto", classes, y)
def test_compute_sample_weight_errors(): # Test compute_sample_weight raises errors expected. # Invalid preset string y = np.asarray([1, 1, 1, 2, 2, 2]) y_ = np.asarray([[1, 0], [1, 0], [1, 0], [2, 1], [2, 1], [2, 1]]) assert_raises(ValueError, compute_sample_weight, "ni", y) assert_raises(ValueError, compute_sample_weight, "ni", y, range(4)) assert_raises(ValueError, compute_sample_weight, "ni", y_) assert_raises(ValueError, compute_sample_weight, "ni", y_, range(4)) # Not "auto" for subsample assert_raises(ValueError, compute_sample_weight, {1: 2, 2: 1}, y, range(4)) # Not a list or preset for multi-output assert_raises(ValueError, compute_sample_weight, {1: 2, 2: 1}, y_) # Incorrect length list for multi-output assert_raises(ValueError, compute_sample_weight, [{1: 2, 2: 1}], y_)
def test_validate_function(): """Check that valid functions are accepted & invalid ones raise error""" # Check arity tests fun = make_function(function=_protected_sqrt, name='sqrt', arity=1) # non-integer arity assert_raises(ValueError, make_function, _protected_sqrt, 'sqrt', '1') assert_raises(ValueError, make_function, _protected_sqrt, 'sqrt', 1.0) # non-matching arity assert_raises(ValueError, make_function, _protected_sqrt, 'sqrt', 2) assert_raises(ValueError, make_function, maximum, 'max', 1) # Check name test assert_raises(ValueError, make_function, _protected_sqrt, 2, 1) # Check return type tests def bad_fun1(x1, x2): return 'ni' assert_raises(ValueError, make_function, bad_fun1, 'ni', 2) # Check return shape tests def bad_fun2(x1): return np.ones((2, 1)) assert_raises(ValueError, make_function, bad_fun2, 'ni', 1) # Check closure for negatives test def _unprotected_sqrt(x1): with np.errstate(divide='ignore', invalid='ignore'): return np.sqrt(x1) assert_raises(ValueError, make_function, _unprotected_sqrt, 'sqrt', 1) # Check closure for zeros test def _unprotected_div(x1, x2): with np.errstate(divide='ignore', invalid='ignore'): return np.divide(x1, x2) assert_raises(ValueError, make_function, _unprotected_div, 'div', 2)
def test_program_input_validation(): """Check that guarded input validation raises errors""" for Symbolic in (SymbolicRegressor, SymbolicTransformer): # Check too much proba est = Symbolic(p_point_mutation=.5) assert_raises(ValueError, est.fit, boston.data, boston.target) # Check invalid init_method est = Symbolic(init_method='ni') assert_raises(ValueError, est.fit, boston.data, boston.target) # Check invalid const_ranges est = Symbolic(const_range=2) assert_raises(ValueError, est.fit, boston.data, boston.target) est = Symbolic(const_range=[2, 2]) assert_raises(ValueError, est.fit, boston.data, boston.target) est = Symbolic(const_range=(2, 2, 2)) assert_raises(ValueError, est.fit, boston.data, boston.target) est = Symbolic(const_range='ni') assert_raises(ValueError, est.fit, boston.data, boston.target) # And check acceptable, but strange, representations of init_depth est = Symbolic(const_range=(2, 2)) est.fit(boston.data, boston.target) est = Symbolic(const_range=(4, 2)) est.fit(boston.data, boston.target) # Check invalid init_depth est = Symbolic(init_depth=2) assert_raises(ValueError, est.fit, boston.data, boston.target) est = Symbolic(init_depth=2) assert_raises(ValueError, est.fit, boston.data, boston.target) est = Symbolic(init_depth=[2, 2]) assert_raises(ValueError, est.fit, boston.data, boston.target) est = Symbolic(init_depth=(2, 2, 2)) assert_raises(ValueError, est.fit, boston.data, boston.target) est = Symbolic(init_depth='ni') assert_raises(ValueError, est.fit, boston.data, boston.target) est = Symbolic(init_depth=(4, 2)) assert_raises(ValueError, est.fit, boston.data, boston.target) # And check acceptable, but strange, representations of init_depth est = Symbolic(init_depth=(2, 2)) est.fit(boston.data, boston.target) # Check hall_of_fame and n_components for transformer est = SymbolicTransformer(hall_of_fame=2000) assert_raises(ValueError, est.fit, boston.data, boston.target) est = SymbolicTransformer(n_components=2000) assert_raises(ValueError, est.fit, boston.data, boston.target) est = SymbolicTransformer(hall_of_fame=0) assert_raises(ValueError, est.fit, boston.data, boston.target) est = SymbolicTransformer(n_components=0) assert_raises(ValueError, est.fit, boston.data, boston.target) # Check regressor metrics for m in ['mean absolute error', 'mse', 'rmse', 'rmsle']: est = SymbolicRegressor(generations=2, metric=m) est.fit(boston.data, boston.target) # And check the transformer metrics as well as a fake one for m in ['pearson', 'spearman', 'the larch']: est = SymbolicRegressor(generations=2, metric=m) assert_raises(ValueError, est.fit, boston.data, boston.target) # Check transformer metrics for m in ['pearson', 'spearman']: est = SymbolicTransformer(generations=2, metric=m) est.fit(boston.data, boston.target) # And check the regressor metrics as well as a fake one for m in ['mean absolute error', 'mse', 'rmse', 'rmsle', 'the larch']: est = SymbolicTransformer(generations=2, metric=m) assert_raises(ValueError, est.fit, boston.data, boston.target)