Metrics

from versa.metrics import STR_METRIC

# String metrics are excluded from numerical aggregation
if metric_name in STR_METRIC:
    # Handle as text output
    pass
else:
    # Compute numerical average
    avg = sum(scores) / len(scores)

from versa.metrics import NUM_METRIC

# Only numerical metrics are included in summary statistics
if metric_name in NUM_METRIC:
    average_score = sum(values) / len(values)

from versa.metrics import STR_METRIC, NUM_METRIC

def process_scores(scores):
    """Separate numerical and string metrics."""
    numerical_scores = {}
    text_outputs = {}
    
    for key, value in scores.items():
        if key in STR_METRIC:
            text_outputs[key] = value
        elif key in NUM_METRIC:
            numerical_scores[key] = value
    
    return numerical_scores, text_outputs

from versa.metrics import NUM_METRIC, STR_METRIC

def compute_summary(score_list):
    """Compute average scores across utterances."""
    summary = {}
    
    # Get all metric keys from first utterance
    for key in score_list[0].keys():
        if key == 'key' or key in STR_METRIC:
            continue  # Skip utterance IDs and string metrics
        
        # Sum scores
        total = sum(utt[key] for utt in score_list if key in utt)
        
        # Average for most metrics, sum for WER/CER
        if '_wer' in key or '_cer' in key:
            summary[key] = total  # Total errors
        else:
            summary[key] = total / len(score_list)  # Average
    
    return summary

from versa.metrics import NUM_METRIC

def validate_metric(metric_name):
    """Check if a metric is recognized."""
    if metric_name in NUM_METRIC:
        return True, "numerical"
    elif metric_name in STR_METRIC:
        return True, "string"
    else:
        return False, "unknown"

isValid, metricType = validate_metric("utmos")
print(f"UTMOS is {metricType}: {isValid}")
# Output: UTMOS is numerical: True