ahmet / multilayer-perceptron

import argparse
import sys

import numpy as np

from train import MALIGNANT, METRICS, compute_metrics, forward, load_data, split_xy


def parse_args():
    parser = argparse.ArgumentParser(
        description="Predict with a trained multilayer perceptron"
    )
    parser.add_argument("--dataset", default="data_validation.csv")
    parser.add_argument("--model", default="model.npz")
    return parser.parse_args()


def load_model(path: str):
    try:
        params = np.load(path)
        n_layers = len(params["layers"]) - 1
        weights = [params[f"W{i}"] for i in range(n_layers)]
        biases = [params[f"b{i}"] for i in range(n_layers)]
    except (OSError, ValueError, KeyError) as e:
        print(f"Error: cannot load model '{path}': {e}", file=sys.stderr)
        sys.exit(1)
    return weights, biases, params["mean"], params["std"]


def binary_cross_entropy(y, p):
    """E = -1/N * sum[ y*log(p) + (1-y)*log(1-p) ]"""
    p = np.clip(p, 1e-12, 1.0 - 1e-12)
    return -np.mean(y * np.log(p) + (1 - y) * np.log(1 - p))


def main():
    args = parse_args()
    X, Y = split_xy(load_data(args.dataset))
    weights, biases, mean, std = load_model(args.model)

    n_features = weights[0].shape[0]
    if X.shape[1] != n_features:
        print(f"Error: model expects {n_features} features, "
              f"'{args.dataset}' has {X.shape[1]}", file=sys.stderr)
        sys.exit(1)

    A = forward((X - mean) / std, weights, biases)[-1]
    y, p = Y[:, MALIGNANT], A[:, MALIGNANT]
    n_malignant = int((p >= 0.5).sum())

    print(f"{args.dataset}: {len(X)} samples "
          f"(predicted M: {n_malignant}, B: {len(X) - n_malignant})")
    print(f"binary cross-entropy: {binary_cross_entropy(y, p):.4f}")
    metrics = compute_metrics(Y, A)
    print(" - ".join(f"{k}: {metrics[k]:.4f}" for k in METRICS if k != "loss"))


if __name__ == "__main__":
    main()