def main(argv):
    if len(argv) not in [3, 4] or argv[1] not in ["all", "test"]:
        exit(0)
    if len(argv) == 4 and argv[3] == "-i":
        use_interactive_mode = True
    else:
        use_interactive_mode = False

    train_data, test_data, train_labels, test_labels, label_names, dataset_name = get_data(argv)

    df = runner.run(
        train_data=train_data,
        test_data=test_data,
        preproc=Preprocessor,
        preproc_params=None,
        err_root_node=get_err_root_node(),
        err_params_list=get_err_params_list(),
        model_params_dict_list=get_model_params_dict_list(train_labels, test_labels),
        use_interactive_mode=use_interactive_mode
    )

    print_results_by_model(df, dropped_columns=[
        "train_labels", "test_labels", "reduced_test_data", "confusion_matrix", "predicted_test_labels",
        "radius_generator", "missing_value", "normalized_params"
    ])
    visualize(df, dataset_name, label_names, test_data, use_interactive_mode)
示例#2
0
def main():
    imgs, _, _, img_filenames = load_coco_val_2017()

    df = runner.run(
        train_data=None,
        test_data=imgs,
        preproc=Preprocessor,
        preproc_params={"img_filenames": img_filenames},
        err_root_node=get_err_root_node(),
        err_params_list=get_err_params_list(),
        model_params_dict_list=get_model_params_dict_list(),
        n_processes=1
    )

    print_results_by_model(df, dropped_columns=["show_imgs", "mean", "radius_generator", "transparency_percentage",
                                                "range", "snowflake_alpha", "snowstorm_alpha", "tar", "range"])
    visualize(df)
def main(argv):
    # Create some fake data
    if len(argv) == 2:
        train_data, test_data = get_data(argv)
    else:
        exit(0)

    # Run the whole thing and get DataFrame for visualization
    df = runner.run(train_data=train_data,
                    test_data=test_data,
                    preproc=Preprocessor,
                    preproc_params=None,
                    err_root_node=get_err_root_node(),
                    err_params_list=get_err_params_list(),
                    model_params_dict_list=get_model_params_dict_list())

    print_results_by_model(df)
    visualize(df)
示例#4
0
def main(argv):
    if len(argv) != 3 or argv[1] not in [
            "passengers", "Jerusalem", "Eilat", "Miami", "Tel Aviv District"
    ]:
        exit(0)

    train_data, test_data, n_data, n_period, dataset_name = get_data(argv)

    df = runner.run(
        train_data=train_data,
        test_data=test_data,
        preproc=Preprocessor,
        preproc_params={},
        err_root_node=get_err_root_node(),
        err_params_list=get_err_params_list(),
        model_params_dict_list=get_model_params_dict_list(test_data, n_period),
    )

    print_results_by_model(
        df,
        dropped_columns=["err_train", "test_pred", "clean_test", "n_period"])
    visualize(df, np.concatenate([train_data, test_data], axis=0), n_data,
              dataset_name)
def main(argv):
    if len(argv) not in [3, 4
                         ] or argv[1] not in ["digits", "mnist", "fashion"]:
        exit(0)
    if len(argv) == 4 and argv[3] == "-i":
        use_interactive_mode = True
    else:
        use_interactive_mode = False

    data, labels, label_names, dataset_name = get_data(argv)

    df = runner.run(train_data=None,
                    test_data=data,
                    preproc=Preprocessor,
                    preproc_params=None,
                    err_root_node=get_err_root_node(),
                    err_params_list=get_err_params_list(data),
                    model_params_dict_list=get_model_params_dict_list(
                        data, labels),
                    use_interactive_mode=use_interactive_mode)

    print_results_by_model(
        df, ["missing_value", "min_val", "max_val", "labels", "reduced_data"])
    visualize(df, label_names, dataset_name, data, use_interactive_mode)
示例#6
0
def main(argv):
    if len(argv) != 2:
        exit(0)

    imgs, img_ids, class_names, _ = get_data(argv)
    path_to_yolov3_weights, path_to_yolov3_cfg = load_yolov3()

    df = runner.run(train_data=None,
                    test_data=imgs,
                    preproc=Preprocessor,
                    preproc_params=None,
                    err_root_node=get_err_root_node(),
                    err_params_list=get_err_params_list(),
                    model_params_dict_list=get_model_params_dict_list(
                        img_ids, class_names, path_to_yolov3_weights,
                        path_to_yolov3_cfg),
                    n_processes=1)

    print_results_by_model(df, [
        "img_ids", "class_names", "show_imgs", "mean", "radius_generator",
        "transparency_percentage", "range", "snowflake_alpha",
        "snowstorm_alpha"
    ])
    visualize(df)