コード例 #1
0
def test_calc_ice_lines_inter_multiclass(otto_data, otto_model, otto_features):
    grid_results, _data = _calc_ice_lines_inter(
        feature_grids_combo=[1, 1], data=otto_data, model=otto_model, model_features=otto_features,
        n_classes=9, feature_list=['feat_67', 'feat_32'], predict_kwds={}, data_transformer=None, unit_test=True)
    assert_array_equal(np.unique(_data[['feat_67', 'feat_32']].values, axis=0), np.array([[1, 1]]))

    expected = pd.DataFrame({'class_0_preds': {0: 0.55, 10000: 0.01, 20000: 0.0, 30000: 0.01,
                                               40000: 0.01, 50000: 0.03, 60000: 0.04},
                             'class_1_preds': {0: 0.0, 10000: 0.72, 20000: 0.19, 30000: 0.04,
                                               40000: 0.0, 50000: 0.0, 60000: 0.04},
                             'class_2_preds': {0: 0.0, 10000: 0.12, 20000: 0.7, 30000: 0.01,
                                               40000: 0.0, 50000: 0.0, 60000: 0.02},
                             'class_3_preds': {0: 0.0, 10000: 0.05, 20000: 0.03, 30000: 0.02,
                                               40000: 0.0, 50000: 0.0, 60000: 0.0},
                             'class_4_preds': {0: 0.0, 10000: 0.01, 20000: 0.0, 30000: 0.84,
                                               40000: 0.0, 50000: 0.0, 60000: 0.0},
                             'class_5_preds': {0: 0.44, 10000: 0.03, 20000: 0.04, 30000: 0.02,
                                               40000: 0.88, 50000: 0.0, 60000: 0.02},
                             'class_6_preds': {0: 0.01, 10000: 0.0, 20000: 0.03, 30000: 0.03,
                                               40000: 0.01, 50000: 0.07, 60000: 0.01},
                             'class_7_preds': {0: 0.0, 10000: 0.02, 20000: 0.01, 30000: 0.02,
                                               40000: 0.03, 50000: 0.9, 60000: 0.02},
                             'class_8_preds': {0: 0.0, 10000: 0.04, 20000: 0.0, 30000: 0.01,
                                               40000: 0.07, 50000: 0.0, 60000: 0.85},
                             'feat_32': {0: 1, 10000: 1, 20000: 1, 30000: 1, 40000: 1, 50000: 1, 60000: 1},
                             'feat_67': {0: 1, 10000: 1, 20000: 1, 30000: 1, 40000: 1, 50000: 1, 60000: 1}})

    assert_frame_equal(grid_results.iloc[[0, 10000, 20000, 30000, 40000, 50000, 60000]], expected,
                       check_like=True, check_dtype=False)
コード例 #2
0
def test_calc_ice_lines_inter_regression(ross_data, ross_model, ross_features):
    grid_results, _data = _calc_ice_lines_inter(
        feature_grids_combo=[1, 1, 0, 0, 0],
        data=ross_data,
        model=ross_model,
        model_features=ross_features,
        n_classes=0,
        feature_list=[
            "SchoolHoliday",
            "StoreType_a",
            "StoreType_b",
            "StoreType_c",
            "StoreType_d",
        ],
        predict_kwds={},
        data_transformer=None,
        unit_test=True,
    )
    assert_array_equal(
        np.unique(
            _data[[
                "SchoolHoliday",
                "StoreType_a",
                "StoreType_b",
                "StoreType_c",
                "StoreType_d",
            ]].values,
            axis=0,
        ),
        np.array([[1, 1, 0, 0, 0]]),
    )
コード例 #3
0
 def test_ice_inter_predict_kwds(self, titanic_data, titanic_model, titanic_features):
     # with predict_kwds
     grid_results, _data = _calc_ice_lines_inter(
         feature_grids_combo=[0, 10], data=titanic_data, model=titanic_model, model_features=titanic_features,
         n_classes=2,
         feature_list=['Sex', 'Fare'], predict_kwds={'ntree_limit': 10}, data_transformer=None, unit_test=True)
     expected = pd.DataFrame({'Fare': {0: 10, 150: 10, 300: 10, 450: 10, 600: 10, 750: 10},
                              'Sex': {0: 0, 150: 0, 300: 0, 450: 0, 600: 0, 750: 0},
                              'preds': {0: 0.48284032940864563, 150: 0.5588331818580627, 300: 0.5346577763557434,
                                        450: 0.5927444100379944, 600: 0.5927444100379944, 750: 0.6094712615013123}})
     assert_frame_equal(grid_results.iloc[[0, 150, 300, 450, 600, 750]], expected, check_like=True,
                        check_dtype=False)
コード例 #4
0
 def test_ice_inter_binary_numeric(self, titanic_data, titanic_model, titanic_features):
     # binary and numeric
     grid_results, _data = _calc_ice_lines_inter(
         feature_grids_combo=[0, 10], data=titanic_data, model=titanic_model, model_features=titanic_features,
         n_classes=2, feature_list=['Sex', 'Fare'], predict_kwds={}, data_transformer=None, unit_test=True)
     assert_array_equal(np.unique(_data[['Sex', 'Fare']].values, axis=0), np.array([[0, 10]]))
     expected = pd.DataFrame({'Fare': {0: 10, 150: 10, 300: 10, 450: 10, 600: 10, 750: 10},
                              'Sex': {0: 0, 150: 0, 300: 0, 450: 0, 600: 0, 750: 0},
                              'preds': {0: 0.37542039155960083, 150: 0.7539840340614319, 300: 0.6190056204795837,
                                        450: 0.8457906246185303, 600: 0.7467048764228821, 750: 0.868721067905426}})
     assert_frame_equal(grid_results.iloc[[0, 150, 300, 450, 600, 750]], expected, check_like=True,
                        check_dtype=False)
コード例 #5
0
def test_calc_ice_lines_inter_multiclass(otto_data, otto_model, otto_features):
    grid_results, _data = _calc_ice_lines_inter(
        feature_grids_combo=[1, 1],
        data=otto_data,
        model=otto_model,
        model_features=otto_features,
        n_classes=9,
        feature_list=["feat_67", "feat_32"],
        predict_kwds={},
        data_transformer=None,
        unit_test=True,
    )
    assert_array_equal(np.unique(_data[["feat_67", "feat_32"]].values, axis=0),
                       np.array([[1, 1]]))
コード例 #6
0
 def test_ice_inter_predict_kwds(self, titanic_data, titanic_model,
                                 titanic_features):
     # with predict_kwds
     grid_results, _data = _calc_ice_lines_inter(
         feature_grids_combo=[0, 10],
         data=titanic_data,
         model=titanic_model,
         model_features=titanic_features,
         n_classes=2,
         feature_list=["Sex", "Fare"],
         predict_kwds={"ntree_limit": 10},
         data_transformer=None,
         unit_test=True,
     )
コード例 #7
0
 def test_ice_inter_onehot_numeric(self, titanic_data, titanic_model, titanic_features):
     # onehot and numeric
     grid_results, _data = _calc_ice_lines_inter(
         feature_grids_combo=[0, 0, 1, 10], data=titanic_data, model=titanic_model, model_features=titanic_features,
         n_classes=2, feature_list=['Embarked_C', 'Embarked_S', 'Embarked_Q', 'Fare'], predict_kwds={},
         data_transformer=None, unit_test=True)
     assert_array_equal(np.unique(_data[['Embarked_C', 'Embarked_S', 'Embarked_Q', 'Fare']].values, axis=0),
                        np.array([[0, 0, 1, 10]]))
     expected = pd.DataFrame({'Embarked_C': {0: 0, 150: 0, 300: 0, 450: 0, 600: 0, 750: 0},
                              'Embarked_Q': {0: 1, 150: 1, 300: 1, 450: 1, 600: 1, 750: 1},
                              'Embarked_S': {0: 0, 150: 0, 300: 0, 450: 0, 600: 0, 750: 0},
                              'Fare': {0: 10, 150: 10, 300: 10, 450: 10, 600: 10, 750: 10},
                              'preds': {0: 0.14132696390151978, 150: 0.09227359294891357, 300: 0.6190056204795837,
                                        450: 0.13888351619243622, 600: 0.7998642325401306, 750: 0.8927221894264221}})
     assert_frame_equal(grid_results.iloc[[0, 150, 300, 450, 600, 750]], expected, check_like=True,
                        check_dtype=False)
コード例 #8
0
 def test_ice_inter_binary_numeric(self, titanic_data, titanic_model,
                                   titanic_features):
     # binary and numeric
     grid_results, _data = _calc_ice_lines_inter(
         feature_grids_combo=[0, 10],
         data=titanic_data,
         model=titanic_model,
         model_features=titanic_features,
         n_classes=2,
         feature_list=["Sex", "Fare"],
         predict_kwds={},
         data_transformer=None,
         unit_test=True,
     )
     assert_array_equal(np.unique(_data[["Sex", "Fare"]].values, axis=0),
                        np.array([[0, 10]]))
コード例 #9
0
 def test_ice_inter_binary_onehot(self, titanic_data, titanic_model, titanic_features):
     # binary and onehot
     grid_results, _data = _calc_ice_lines_inter(
         feature_grids_combo=[1, 0, 1, 0], data=titanic_data, model=titanic_model, model_features=titanic_features,
         n_classes=2, feature_list=['Sex', 'Embarked_C', 'Embarked_S', 'Embarked_Q'], predict_kwds={},
         data_transformer=None, unit_test=True)
     assert_array_equal(np.unique(_data[['Sex', 'Embarked_C', 'Embarked_S', 'Embarked_Q']].values, axis=0),
                        np.array([[1, 0, 1, 0]]))
     expected = pd.DataFrame({'Embarked_C': {0: 0, 150: 0, 300: 0, 450: 0, 600: 0, 750: 0},
                              'Embarked_Q': {0: 0, 150: 0, 300: 0, 450: 0, 600: 0, 750: 0},
                              'Embarked_S': {0: 1, 150: 1, 300: 1, 450: 1, 600: 1, 750: 1},
                              'Sex': {0: 1, 150: 1, 300: 1, 450: 1, 600: 1, 750: 1},
                              'preds': {0: 0.1041787713766098, 150: 0.09937939792871475, 300: 0.09760041534900665,
                                        450: 0.22834216058254242, 600: 0.14207805693149567,
                                        750: 0.8904628753662109}})
     assert_frame_equal(grid_results.iloc[[0, 150, 300, 450, 600, 750]], expected, check_like=True,
                        check_dtype=False)
コード例 #10
0
    def test_ice_inter_data_transformer(self, titanic_data, titanic_model,
                                        titanic_features):
        # with data_transformer
        def embark_change(df):
            df.loc[df["Embarked_C"] == 1, "Fare"] = 10
            df.loc[df["Embarked_S"] == 1, "Fare"] = 20
            df.loc[df["Embarked_Q"] == 1, "Fare"] = 30
            return df

        grid_results, _data = _calc_ice_lines_inter(
            feature_grids_combo=[1, 0, 1, 0],
            data=titanic_data,
            model=titanic_model,
            model_features=titanic_features,
            n_classes=2,
            feature_list=["Sex", "Embarked_C", "Embarked_S", "Embarked_Q"],
            predict_kwds={},
            data_transformer=embark_change,
            unit_test=True,
        )
        assert_array_equal(_data["Fare"].unique(), np.array([20]))
コード例 #11
0
    def test_ice_inter_data_transformer(self, titanic_data, titanic_model, titanic_features):
        # with data_transformer
        def embark_change(df):
            df.loc[df['Embarked_C'] == 1, 'Fare'] = 10
            df.loc[df['Embarked_S'] == 1, 'Fare'] = 20
            df.loc[df['Embarked_Q'] == 1, 'Fare'] = 30
            return df

        grid_results, _data = _calc_ice_lines_inter(
            feature_grids_combo=[1, 0, 1, 0], data=titanic_data, model=titanic_model, model_features=titanic_features,
            n_classes=2, feature_list=['Sex', 'Embarked_C', 'Embarked_S', 'Embarked_Q'], predict_kwds={},
            data_transformer=embark_change, unit_test=True)
        assert_array_equal(_data['Fare'].unique(), np.array([20]))
        expected = pd.DataFrame({'Embarked_C': {0: 0, 150: 0, 300: 0, 450: 0, 600: 0, 750: 0},
                                 'Embarked_Q': {0: 0, 150: 0, 300: 0, 450: 0, 600: 0, 750: 0},
                                 'Embarked_S': {0: 1, 150: 1, 300: 1, 450: 1, 600: 1, 750: 1},
                                 'Sex': {0: 1, 150: 1, 300: 1, 450: 1, 600: 1, 750: 1},
                                 'preds': {0: 0.11097385734319687, 150: 0.10733838379383087, 300: 0.12938366830348969,
                                           450: 0.18971671164035797, 600: 0.11736717820167542,
                                           750: 0.9063724279403687}})
        assert_frame_equal(grid_results.iloc[[0, 150, 300, 450, 600, 750]], expected, check_like=True,
                           check_dtype=False)
コード例 #12
0
def test_calc_ice_lines_inter_regression(ross_data, ross_model, ross_features):
    grid_results, _data = _calc_ice_lines_inter(
        feature_grids_combo=[1, 1, 0, 0, 0], data=ross_data, model=ross_model, model_features=ross_features,
        n_classes=0, feature_list=['SchoolHoliday', 'StoreType_a', 'StoreType_b', 'StoreType_c', 'StoreType_d'],
        predict_kwds={}, data_transformer=None, unit_test=True)
    assert_array_equal(np.unique(_data[['SchoolHoliday', 'StoreType_a', 'StoreType_b', 'StoreType_c',
                                        'StoreType_d']].values, axis=0), np.array([[1, 1, 0, 0, 0]]))

    expected = pd.DataFrame({'SchoolHoliday': {0: 1, 100000: 1, 200000: 1, 300000: 1, 400000: 1,
                                               500000: 1, 600000: 1, 700000: 1, 800000: 1},
                             'StoreType_a': {0: 1, 100000: 1, 200000: 1, 300000: 1, 400000: 1,
                                             500000: 1, 600000: 1, 700000: 1, 800000: 1},
                             'StoreType_b': {0: 0, 100000: 0, 200000: 0, 300000: 0, 400000: 0,
                                             500000: 0, 600000: 0, 700000: 0, 800000: 0},
                             'StoreType_c': {0: 0, 100000: 0, 200000: 0, 300000: 0, 400000: 0,
                                             500000: 0, 600000: 0, 700000: 0, 800000: 0},
                             'StoreType_d': {0: 0, 100000: 0, 200000: 0, 300000: 0, 400000: 0,
                                             500000: 0, 600000: 0, 700000: 0, 800000: 0},
                             'preds': {0: 8252.710201150694, 100000: 8293.287914628107, 200000: 5352.321273982288,
                                       300000: 5707.464798080147, 400000: 5307.592789748846, 500000: 7520.956055932758,
                                       600000: 5493.134809064146, 700000: 7040.829184296985, 800000: 4877.434213535266}})

    assert_frame_equal(grid_results.iloc[[0, 100000, 200000, 300000, 400000, 500000, 600000, 700000, 800000]],
                       expected, check_like=True, check_dtype=False)