def __init__(self): super(Container, self).__init__() self.basis = Basis(self.X.shape[1]) self.parent = ConstantBasisFunction() self.bf1 = HingeBasisFunction(self.parent, 1.0, 10, 1, False) self.bf2 = HingeBasisFunction(self.parent, 1.0, 4, 2, True) self.bf3 = HingeBasisFunction(self.bf2, 1.0, 4, 3, True) self.bf4 = LinearBasisFunction(self.parent, 2) self.bf5 = HingeBasisFunction(self.parent, 1.5, 8, 2, True) self.basis.append(self.parent) self.basis.append(self.bf1) self.basis.append(self.bf2) self.basis.append(self.bf3) self.basis.append(self.bf4) self.basis.append(self.bf5)
import numpy from scipy.sparse import csr_matrix from pyearth._types import BOOL from pyearth._basis import (Basis, ConstantBasisFunction, HingeBasisFunction, LinearBasisFunction) from pyearth import Earth import pyearth from numpy.testing.utils import assert_array_almost_equal regenerate_target_files = False numpy.random.seed(1) basis = Basis(10) constant = ConstantBasisFunction() basis.append(constant) bf1 = HingeBasisFunction(constant, 0.1, 10, 1, False, 'x1') bf2 = HingeBasisFunction(constant, 0.1, 10, 1, True, 'x1') bf3 = LinearBasisFunction(bf1, 2, 'x2') basis.append(bf1) basis.append(bf2) basis.append(bf3) X = numpy.random.normal(size=(1000, 10)) missing = numpy.zeros_like(X, dtype=BOOL) B = numpy.empty(shape=(1000, 4), dtype=numpy.float64) basis.transform(X, missing, B) beta = numpy.random.normal(size=4) y = numpy.empty(shape=1000, dtype=numpy.float64) y[:] = numpy.dot(B, beta) + numpy.random.normal(size=1000) default_params = {"penalty": 1}
def __init__(self): super(Container, self).__init__() self.parent = ConstantBasisFunction() self.bf = HingeBasisFunction(self.parent, 1.0, 10, 1, False)
def __init__(self): super(Container, self).__init__() self.parent = ConstantBasisFunction() self.bf = MissingnessBasisFunction(self.parent, 1, True) self.child = HingeBasisFunction(self.bf, 1.0, 10, 1, False)
def __init__(self): super(self.__class__, self).__init__() self.parent = ConstantBasisFunction() self.bf = HingeBasisFunction(self.parent, 1.0, 10, 1, False)
class TestHingeBasisFunction(BaseTestClass): def __init__(self): super(self.__class__, self).__init__() self.parent = ConstantBasisFunction() self.bf = HingeBasisFunction(self.parent, 1.0, 10, 1, False) def test_getters(self): assert not self.bf.get_reverse() assert self.bf.get_knot() == 1.0 assert self.bf.get_variable() == 1 assert self.bf.get_knot_idx() == 10 assert self.bf.get_parent() == self.parent def test_apply(self): m, _ = self.X.shape B = numpy.ones(shape=(m, 10)) self.bf.apply(self.X, B[:, 0]) numpy.testing.assert_almost_equal( B[:, 0], (self.X[:, 1] - 1.0) * (self.X[:, 1] > 1.0) ) def test_apply_deriv(self): m, _ = self.X.shape b = numpy.empty(shape=m) j = numpy.empty(shape=m) self.bf.apply_deriv(self.X, b, j, 1) numpy.testing.assert_almost_equal( (self.X[:, 1] - 1.0) * (self.X[:, 1] > 1.0), b ) numpy.testing.assert_almost_equal(1.0 * (self.X[:, 1] > 1.0), j) def test_degree(self): assert_equal(self.bf.degree(), 1) def test_pickle_compatibility(self): bf_copy = pickle.loads(pickle.dumps(self.bf)) assert_true(self.bf == bf_copy) def test_smoothed_version(self): knot_dict = {self.bf: (.5, 1.5)} translation = {self.parent: self.parent._smoothed_version(None, {}, {})} smoothed = self.bf._smoothed_version(self.parent, knot_dict, translation) assert_true(type(smoothed) is SmoothedHingeBasisFunction) assert_true(translation[self.parent] is smoothed.get_parent()) assert_equal(smoothed.get_knot_minus(), 0.5) assert_equal(smoothed.get_knot_plus(), 1.5) assert_equal(smoothed.get_knot(), self.bf.get_knot()) assert_equal(smoothed.get_variable(), self.bf.get_variable())