def utt_scores(scores, scp, utt2label):
    """return predictions and labels per utterance
    """
    utt2label = ako.read_key_label(utt2label)
    key_list = ako.read_all_key(scp)

    preds, labels = [], []
    idx = 0
    for key in key_list:
        preds.append(scores[idx])
        idx += 1
        labels.append(utt2label[key])

    return np.array(preds), np.array(labels)
Esempio n. 2
0
def utt_scores(scores, scp, utt2label):
    """return predictions and labels per utterance
    """
    utt2len   = ako.read_key_len(scp)
    utt2label = ako.read_key_label(utt2label)
    key_list  = ako.read_all_key(scp)

    preds, labels = [], []
    idx = 0
    for key in key_list:
        frames_per_utt = utt2len[key]
        avg_scores = np.average(scores[idx:idx+frames_per_utt])
        idx = idx + frames_per_utt
        preds.append(avg_scores)
        labels.append(utt2label[key])

    return np.array(preds), np.array(labels)
def prediction(args, model, device, eval_loader, eval_scp, eval_utt2label,
               opti_threshold):
    logger.info("Starting evaluation")
    utt2len = ako.read_key_len(eval_scp)
    utt2label = ako.read_key_label(eval_utt2label)
    key_list = ako.read_all_key(eval_scp)
    eval_loss, eval_scores, eval_correct = compute_loss(
        model, device, eval_loader)
    eval_eer = utt_eer(eval_scores, utt2len, utt2label, key_list,
                       opti_threshold)

    logger.info("===> Final predictions done. Here is a snippet")
    logger.info(
        '===> evalidation set: Average loss: {:.4f}\tEER: {:.4f}\n'.format(
            eval_loss, eval_eer))

    return eval_loss, eval_eer
Esempio n. 4
0
def validation(args, model, device, train_loader, val_loader, val_scp,
               val_utt2label):
    logger.info("Starting Validation")
    utt2len = ako.read_key_len(val_scp)
    utt2label = ako.read_key_label(val_utt2label)
    key_list = ako.read_all_key(val_scp)
    train_loss, _, train_correct = compute_loss(model, device, train_loader)
    val_loss, val_scores, val_correct = compute_loss(model, device, val_loader)
    val_eer, threshold = best_eer(val_scores, utt2len, utt2label, key_list)

    logger.info(
        '\n===> Training set: Average loss: {:.4f}\tAccuracy: {}/{} ({:.0f}%)\n'
        .format(train_loss, train_correct, len(train_loader.dataset),
                100. * train_correct / len(train_loader.dataset)))
    logger.info(
        '===> Validation set: Average loss: {:.4f}\tEER: {:.4f}\tThreshold: {}\n'
        .format(val_loss, val_eer, threshold))
    return val_loss, val_eer, threshold
def compute_utt_eer(scores, scp, utt2label, threshold):
    """utterance-based eer
    """
    utt2len = ako.read_key_len(scp)
    utt2label = ako.read_key_label(utt2label)
    key_list = ako.read_all_key(scp)

    preds, labels = [], []
    idx = 0
    for key in key_list:
        frames_per_utt = utt2len[key]
        avg_scores = np.average(scores[idx:idx + frames_per_utt])
        idx = idx + frames_per_utt
        if avg_scores < threshold:
            preds.append(0)
        else:
            preds.append(1)
        labels.append(utt2label[key])

    eer = compute_eer(labels, preds)
    confuse_mat = compute_confuse(labels, preds)
    return eer, confuse_mat