def post_process_instances()

in modelling/src/neuraldb/convert_spj_to_predictions.py [0:0]

• 87 lines of code
• 12 McCabe index (conditional complexity)

def post_process_instances(instances, use_predicted_type=True):
    predicted_types = list(map(itemgetter("predicted_type"), instances))
    new_instance = {
        "metadata": instances[0]["metadata"],
        "predicted_type": majority_vote(predicted_types),
    }

    if new_instance["predicted_type"] == "null":
        logger.error(instances)

    derivations = list(
        filter(
            lambda inst: "NULL_ANSWER" not in inst,
            reduce(lambda a, b: a + b, map(itemgetter("prediction"), instances)),
        )
    )
    derivations = (
        reduce(
            lambda a, b: a + b,
            map(
                lambda derv: derv.split("[LIST]"),
                map(maybe_split_qtype, set(derivations)),
            ),
        )
        if len(derivations)
        else []
    )
    derivations = list(derivations)

    try:
        pred_answer = generate_answers(
            new_instance["predicted_type"]
            if use_predicted_type
            else new_instance["metadata"]["type"],
            [
                {
                    "generated": {"derivation": q},
                    "symmetric": True
                    if new_instance["metadata"]["relation"] in {"P47"}
                    else False,
                }
                for q in derivations
            ],
        )

    except Exception:
        return None

    new_instance["prediction"] = pred_answer

    if len(extra_dervs):

        derivations = extra_dervs[
            (
                new_instance["metadata"]["database_idx"],
                new_instance["metadata"]["question_idx"],
            )
        ]
    else:
        derivations = reduce(lambda a, b: a + b, map(itemgetter("actual"), instances))
    derivations = (
        reduce(
            lambda a, b: a + b,
            map(
                lambda derv: process_lists(derv, instance["metadata"]["type"]),
                map(maybe_split_qtype, derivations),
            ),
        )
        if len(derivations)
        else []
    )

    derivations = list(derivations)

    try:
        actual_answer = generate_answers(
            new_instance["metadata"]["type"],
            [
                {
                    "generated": {"derivation": q},
                    "symmetric": True
                    if new_instance["metadata"]["relation"] in {"P47"}
                    else False,
                }
                for q in derivations
            ],
        )

        new_instance["actual"] = actual_answer
        return new_instance
    except Exception:
        print("actual error")
        print(
            instance["metadata"]["database_idx"], instance["metadata"]["question_idx"]
        )
        print(derivations)
        # raise e
        return None