Ejemplo n.º 1
0
class ColumnModelTest(test_util.PWLFitTest, parameterized.TestCase):

  def test_simple_properties(self):
    model = model_util.ColumnModel('x1')
    self.assertEqual('x1', model.name)
    self.assertEqual('x1', model.feature_name)

  @parameterized.named_parameters((
      'simple ',
      model_util.ColumnModel('x1'),
      model_util.ColumnModel('x1'),
      True,
  ), (
      'not a ColumnModel',
      model_util.ColumnModel('x1'),
      's',
      False,
  ), (
      'different columns',
      model_util.ColumnModel('x1'),
      model_util.ColumnModel('x2'),
      False,
  ))
  def test_eq(self, m1, m2, expected):
    self.assertEqual(expected, m1 == m2)

  def test_eval(self):
    model = model_util.ColumnModel('x1')
    self.assert_allclose(
        np.array([1.0, 2.0, 3.0]),
        model.eval(pd.DataFrame({'x1': [1.0, 2.0, 3.0]})))

  def test_expr(self):
    model = model_util.ColumnModel('x1')
    self.assertEqual('Column("x1")', model.expr())

  @parameterized.named_parameters((
      'simple',
      'Column("x1")',
  ), (
      'extra spaces',
      'Column( "x1"   )',
  ))
  def test_from_expr(self, s):
    model = model_util.ColumnModel('x1')
    self.assertEqual(model, model_util.ColumnModel.from_expr(s))
Ejemplo n.º 2
0
 def test_from_expr(self, expr):
     model = model_util.AdditiveModel([
         model_util.PWLCurveModel('x1', [(1, 1), (2, 2)]),
         model_util.EnumCurveModel('x2', {
             1: 1,
             2: 2
         }),
         model_util.ColumnModel('x3')
     ], 'my_model')
     self.assertEqual(model,
                      model_util.AdditiveModel.from_expr(expr, 'my_model'))
Ejemplo n.º 3
0
 def test_eval(self):
     model = model_util.AdditiveModel([
         model_util.PWLCurveModel('x1', [(1, 1), (2, 2)]),
         model_util.EnumCurveModel('x2', {
             1: 10,
             2: 20
         }),
         model_util.ColumnModel('x3')
     ], 'my_model')
     df = pd.DataFrame({'x1': [1, 1, 2], 'x2': [1, 1, 2], 'x3': [3, 3, 3]})
     self.assert_allclose(np.array([14, 14, 25]), model.eval(df))
Ejemplo n.º 4
0
 def test_simple_properties(self):
     model = model_util.AdditiveModel([
         model_util.PWLCurveModel('x1', [(1, 1), (2, 2)]),
         model_util.EnumCurveModel('x2', {
             1: 1,
             2: 2
         }),
         model_util.ColumnModel('x3')
     ], 'my_model')
     self.assertEqual('my_model', model.name)
     self.assertEqual(['x1', 'x2', 'x3'], model.feature_names)
Ejemplo n.º 5
0
    def test_expr(self):
        model = model_util.AdditiveModel([
            model_util.PWLCurveModel('x1', [(1, 1), (2, 2)]),
            model_util.EnumCurveModel('x2', {
                1: 1,
                2: 2
            }),
            model_util.ColumnModel('x3')
        ], 'my_model')
        expr = """score = sum([
  PWLCurve("x1", [(1, 1), (2, 2)]),
  EnumCurve("x2", {1: 1, 2: 2}),
  Column("x3"),
])"""
        self.assertEqual(expr, model.expr())
Ejemplo n.º 6
0
 def test_no_duplicate_features_allowed(self):
     with self.assertRaisesRegex(ValueError, 'Duplicate submodels'):
         model_util.AdditiveModel([
             model_util.ColumnModel('x1'),
             model_util.PWLCurveModel('x1', [(1, 1), (2, 2)])
         ], 'my_model')
Ejemplo n.º 7
0
class AdditiveModelTest(test_util.PWLFitTest, parameterized.TestCase):
    def test_simple_properties(self):
        model = model_util.AdditiveModel([
            model_util.PWLCurveModel('x1', [(1, 1), (2, 2)]),
            model_util.EnumCurveModel('x2', {
                1: 1,
                2: 2
            }),
            model_util.ColumnModel('x3')
        ], 'my_model')
        self.assertEqual('my_model', model.name)
        self.assertEqual(['x1', 'x2', 'x3'], model.feature_names)

    @parameterized.named_parameters((
        'not too sensitive ',
        model_util.AdditiveModel([
            model_util.ColumnModel('x1'),
            model_util.ColumnModel('x2'),
        ], 'my_model'),
        model_util.AdditiveModel([
            model_util.ColumnModel('x2'),
            model_util.ColumnModel('x1'),
        ], 'my_model'),
        True,
    ), (
        'not an AdditiveModel',
        model_util.AdditiveModel([
            model_util.ColumnModel('x1'),
            model_util.ColumnModel('x2'),
        ], 'my_model'),
        's',
        False,
    ), (
        'different submodels',
        model_util.AdditiveModel([
            model_util.ColumnModel('x1'),
        ], 'my_model'),
        model_util.AdditiveModel([
            model_util.ColumnModel('x2'),
        ], 'my_model'),
        False,
    ), (
        'different names',
        model_util.AdditiveModel([
            model_util.ColumnModel('x1'),
        ], 'my_model1'),
        model_util.AdditiveModel([
            model_util.ColumnModel('x1'),
        ], 'my_model2'),
        False,
    ))
    def test_eq(self, m1, m2, expected):
        self.assertEqual(expected, m1 == m2)

    def test_eval(self):
        model = model_util.AdditiveModel([
            model_util.PWLCurveModel('x1', [(1, 1), (2, 2)]),
            model_util.EnumCurveModel('x2', {
                1: 10,
                2: 20
            }),
            model_util.ColumnModel('x3')
        ], 'my_model')
        df = pd.DataFrame({'x1': [1, 1, 2], 'x2': [1, 1, 2], 'x3': [3, 3, 3]})
        self.assert_allclose(np.array([14, 14, 25]), model.eval(df))

    def test_expr(self):
        model = model_util.AdditiveModel([
            model_util.PWLCurveModel('x1', [(1, 1), (2, 2)]),
            model_util.EnumCurveModel('x2', {
                1: 1,
                2: 2
            }),
            model_util.ColumnModel('x3')
        ], 'my_model')
        expr = """score = sum([
  PWLCurve("x1", [(1, 1), (2, 2)]),
  EnumCurve("x2", {1: 1, 2: 2}),
  Column("x3"),
])"""
        self.assertEqual(expr, model.expr())

    @parameterized.named_parameters((
        'simple',
        """score = sum([
        PWLCurve("x1", [(1, 1), (2, 2)]),
        EnumCurve("x2", {1: 1, 2: 2}),
        Column("x3"),
      ])
     """,
    ), (
        'flexible',
        """score = sum([PWLCurve("x1", [(1, 1), (2, 2)]),

        EnumCurve("x2", {1: 1, 2: 2}),

        Column(  "x3"  ),
      ])
     """,
    ))
    def test_from_expr(self, expr):
        model = model_util.AdditiveModel([
            model_util.PWLCurveModel('x1', [(1, 1), (2, 2)]),
            model_util.EnumCurveModel('x2', {
                1: 1,
                2: 2
            }),
            model_util.ColumnModel('x3')
        ], 'my_model')
        self.assertEqual(model,
                         model_util.AdditiveModel.from_expr(expr, 'my_model'))

    def test_no_duplicate_features_allowed(self):
        with self.assertRaisesRegex(ValueError, 'Duplicate submodels'):
            model_util.AdditiveModel([
                model_util.ColumnModel('x1'),
                model_util.PWLCurveModel('x1', [(1, 1), (2, 2)])
            ], 'my_model')
Ejemplo n.º 8
0
 def test_from_expr(self, s):
     model = model_util.ColumnModel('x1')
     self.assertEqual(model, model_util.ColumnModel.from_expr(s))
Ejemplo n.º 9
0
 def test_expr(self):
     model = model_util.ColumnModel('x1')
     self.assertEqual('Column("x1")', model.expr())
Ejemplo n.º 10
0
 def test_eval(self):
     model = model_util.ColumnModel('x1')
     self.assert_allclose(np.array([1.0, 2.0, 3.0]),
                          model.eval(pd.DataFrame({'x1': [1.0, 2.0, 3.0]})))
Ejemplo n.º 11
0
 def test_simple_properties(self):
     model = model_util.ColumnModel('x1')
     self.assertEqual('x1', model.name)
     self.assertEqual('x1', model.feature_name)