new version with secret passed through hugging face repo

.python-version

@@ -0,0 +1 @@
+streamlit

README.md

@@ -1,10 +1,10 @@
 ---
-title: Pl Asr Leaderboard
-emoji: 🔥
-colorFrom: gray
-colorTo: indigo
+title: AMU ASR Leaderboard (PL)
+emoji: 📊
+colorFrom: blue
+colorTo: gray
 sdk: streamlit
-sdk_version: 1.36.0
+sdk_version: 1.32.0
 app_file: app.py
 pinned: false
 license: cc-by-nc-sa-4.0

app-backup.py

@@ -0,0 +1,1063 @@
+import os
+import streamlit as st
+import pandas as pd
+from constants import BIGOS_INFO, PELCRA_INFO, ANALYSIS_INFO, ABOUT_INFO, INSPECTION_INFO
+from utils import read_latest_results, basic_stats_per_dimension, retrieve_asr_systems_meta_from_the_catalog, box_plot_per_dimension, get_total_audio_duration, check_impact_of_normalization, calculate_wer_per_meta_category, calculate_wer_per_audio_feature
+from app_utils import calculate_height_to_display, filter_dataframe
+import matplotlib.pyplot as plt
+import numpy as np
+from datasets import load_dataset
+
+hf_token = os.getenv('HF_TOKEN')
+if hf_token is None:
+    raise ValueError("HF_TOKEN environment variable is not set. Please check your secrets settings.")
+
+# Tabs
+# About - Description, references, contact points
+# Analysis and insights - questions and answers about the benchmark results
+# Leaderboard - BIGOS
+# Leaderboard - PELCRA
+# TODO - add other tabs for other datasets e.g. Hallucinations, Children speech, etc.
+
+st.set_page_config(layout="wide")
+
+about, lead_bigos, lead_bigos_diagnostic, lead_bigos_synth, lead_pelcra, analysis, inspection = st.tabs(["About BIGOS benchmark", "AMU BIGOS-v2 leaderboard", "AMU BIGOS-diagnostic leaderboard", "AMU BIGOS-med leaderboard", "PELCRA4BIGOS leaderboard", "Analysis", "Data and results inspection"])
+
+cols_to_select_all = ["system", "subset", "ref_type", "norm_type", "SER", "MER", "WER", "CER"]
+
+def plot_performance(systems_to_plot, df_per_system_with_type):
+    # Get unique subsets
+    subsets = df_per_system_with_type['subset'].unique()
+
+    # Create a color and label map
+    color_label_map = {
+        free_system_with_best_wer: ('blue', 'Best Free'),
+        free_system_with_worst_wer: ('red', 'Worst Free'),
+        commercial_system_with_best_wer: ('green', 'Best Paid'),
+        commercial_system_with_worst_wer: ('orange', 'Worst Paid')
+    }
+
+    # Plot the data
+    fig, ax = plt.subplots(figsize=(14, 7))
+
+    bar_width = 0.3
+    index = np.arange(len(subsets))
+
+    for i, system in enumerate(systems_to_plot):
+        subset_wer = df_per_system_with_type[df_per_system_with_type['system'] == system].set_index('subset')['WER']
+        color, label = color_label_map[system]
+        ax.bar(index + i * bar_width, subset_wer.loc[subsets], bar_width, label=label + ' - ' + system, color=color)
+
+    # Adding labels and title
+    ax.set_xlabel('Subset')
+    ax.set_ylabel('WER (%)')
+    ax.set_title('Comparison of performance of ASR systems.')
+    ax.set_xticks(index + bar_width * 1.5)
+    ax.set_xticklabels(subsets, rotation=90, ha='right')
+    ax.legend()
+
+    st.pyplot(fig)
+
+def round_to_nearest(value, multiple):
+    return multiple * round(value / multiple)
+
+def create_bar_chart(df, systems, metric, norm_type, ref_type='orig', orientation='vertical'):
+    df = df[df['norm_type'] == norm_type]
+    df = df[df['ref_type'] == ref_type]
+
+    # Prepare the data for the bar chart
+    subsets = df['subset'].unique()
+    num_vars = len(subsets)
+    bar_width = 0.2  # Width of the bars
+
+    fig, ax = plt.subplots(figsize=(10, 10))
+    
+    max_value_all_systems = 0
+    for i, system in enumerate(systems):
+        system_data = df[df['system'] == system]
+        max_value_for_system = max(system_data[metric])
+        if max_value_for_system > max_value_all_systems:
+            max_value_all_systems = round_to_nearest(max_value_for_system + 2, 10)
+        
+        # Ensure the system data is in the same order as subsets
+        values = []
+        for subset in subsets:
+            subset_value = system_data[system_data['subset'] == subset][metric].values
+            if len(subset_value) > 0:
+                values.append(subset_value[0])
+            else:
+                values.append(0)  # Append 0 if the subset value is missing
+        
+        if orientation == 'vertical':
+            # Plot each system's bars with an offset for vertical orientation
+            x_pos = np.arange(len(subsets)) + i * bar_width
+            ax.bar(x_pos, values, bar_width, label=system)
+            # Add value labels
+            for j, value in enumerate(values):
+                ax.text(x_pos[j], value + max(values) * 0.03, f'{value}', ha='center', va='bottom',fontsize=6)
+        else:
+            # Plot each system's bars with an offset for horizontal orientation
+            y_pos = np.arange(len(subsets)) + i * bar_width
+            ax.barh(y_pos, values, bar_width, label=system)
+            # Add value labels
+            for j, value in enumerate(values):
+                ax.text(value + max(values) * 0.03, y_pos[j], f'{value}', ha='left', va='center', fontsize=6)
+    
+    if orientation == 'vertical':
+        ax.set_xticks(np.arange(len(subsets)) + bar_width * (len(systems) - 1) / 2)
+        ax.set_xticklabels(subsets, rotation=45, ha='right')
+        ax.set_ylabel(metric)
+    else:
+        ax.set_yticks(np.arange(len(subsets)) + bar_width * (len(systems) - 1) / 2)
+        ax.set_yticklabels(subsets)
+        ax.set_xlabel(metric)
+    
+    # Add grid values for the vertical and horizontal bar plots
+    if orientation == 'vertical':
+        ax.set_yticks(np.linspace(0, max_value_all_systems, 5))
+    else:
+        ax.set_xticks(np.linspace(0, max_value_all_systems, 5))
+    
+    # Put legend on the right side outside of the plot
+    plt.legend(loc='upper right', bbox_to_anchor=(1.2, 1), shadow=True, ncol=1)
+
+    st.pyplot(fig)
+
+def create_radar_plot(df, enable_labels, systems, metric, norm_type, ref_type='orig'):
+
+    df = df[df['norm_type'] == norm_type]
+    df = df[df['ref_type'] == ref_type]
+
+    # Prepare the data for the radar plot
+    #systems = df['system'].unique()
+    subsets = df['subset'].unique()
+    num_vars = len(subsets)
+    
+    angles = np.linspace(0, 2 * np.pi, num_vars, endpoint=False).tolist()
+    angles += angles[:1]  # Complete the loop
+    
+    fig, ax = plt.subplots(figsize=(10, 10), subplot_kw=dict(polar=True))
+    
+    max_value_all_systems = 0
+    for system in systems:
+        system_data = df[df['system'] == system]
+        max_value_for_system =  max(system_data[metric])
+        if max_value_for_system > max_value_all_systems:
+            max_value_all_systems = round_to_nearest(max_value_for_system + 2, 10)
+        
+        # Ensure the system data is in the same order as subsets
+        values = []
+        for subset in subsets:
+            subset_value = system_data[system_data['subset'] == subset][metric].values
+            if len(subset_value) > 0:
+                values.append(subset_value[0])
+            else:
+                values.append(0)  # Append 0 if the subset value is missing
+        
+        values += values[:1]  # Complete the loop
+        
+        # Plot each system
+        ax.plot(angles, values, label=system)
+        ax.fill(angles, values, alpha=0.25)
+        
+        # Add value labels
+        for angle, value in zip(angles, values):
+            ax.text(angle, value + max(values) * 0.01, f'{value}', ha='center', va='center', fontsize=6)
+    
+    ax.set_xticklabels(subsets)
+
+    ax.set_yticks(np.linspace(0, max_value_all_systems, 5))
+    
+    # put legend at the bottom of the page
+    plt.legend(loc='upper right', bbox_to_anchor=(1.2, 1), shadow=True, ncol=1)
+
+    st.pyplot(fig)
+
+with about:
+    st.title("About BIGOS benchmark")
+    st.markdown(ABOUT_INFO, unsafe_allow_html=True)
+    # TODO - load and display about BIGOS benchmark
+
+    # Table - evaluated systems # TODO - change to concatenated table
+    st.header("Evaluated ASR systems")
+    dataset = "amu-cai/pl-asr-bigos-v2-secret"
+    split = "test"
+    df_per_sample, df_per_dataset = read_latest_results(dataset, split, codename_to_shortname_mapping=None)
+    evaluated_systems_list = df_per_sample["system"].unique()
+    #print("ASR systems available in the eval results for dataset {}: ".format(dataset), evaluated_systems_list )
+    
+    df_evaluated_systems = retrieve_asr_systems_meta_from_the_catalog(evaluated_systems_list)
+    codename_to_shortname_mapping = dict(zip(df_evaluated_systems["Codename"],df_evaluated_systems["Shortname"]))
+    #print(codename_to_shortname_mapping)
+
+    h_df_systems = calculate_height_to_display(df_evaluated_systems)
+
+    df_evaluated_systems_types_and_count = df_evaluated_systems["Type"].value_counts().reset_index()
+    df_evaluated_systems_types_and_count.columns = ["Type", "Count"]
+    st.write("Evaluated ASR systems types")
+
+    st.dataframe(df_evaluated_systems_types_and_count, hide_index=True, use_container_width=False)
+    
+    st.write("Evaluated ASR systems details")
+
+    #TODO - add info who created the system (company, institution, team, etc.)
+    st.dataframe(df_evaluated_systems, hide_index=True, height = h_df_systems, use_container_width=True)
+
+    # Table - evaluation datasets
+    # Table - evaluation metrics
+    # Table - evaluation metadata
+    # List - references
+    # List - contact points     
+    # List - acknowledgements
+    # List - changelog
+    # List - FAQ
+    # List - TODOs
+
+with lead_bigos:
+
+    # configuration for tab
+    dataset = "amu-cai/pl-asr-bigos-v2-secret"
+    dataset_short_name = "BIGOS"
+    dataset_version = "V2"
+    eval_date = "March 2024"
+    split = "test"
+    norm_type = "all"
+    ref_type = "orig"
+    
+    # common, reusable part for all tabs presenting leaderboards for specific datasets
+    #### DATA LOADING AND AUGMENTATION ####
+    df_per_sample_all, df_per_dataset_all = read_latest_results(dataset, split, codename_to_shortname_mapping)
+    
+    
+    # filter only the ref_type and norm_type we want to analyze
+    df_per_sample = df_per_sample_all[(df_per_sample_all["ref_type"] == ref_type) & (df_per_sample_all["norm_type"] == norm_type)]
+    # filter only the ref_type and norm_type we want to analyze
+    df_per_dataset = df_per_dataset_all[(df_per_dataset_all["ref_type"] == ref_type) & (df_per_dataset_all["norm_type"] == norm_type)]
+
+    ##### PARAMETERS CALCULATION ####
+    evaluated_systems_list = df_per_sample["system"].unique()
+    no_of_evaluated_systems = len(evaluated_systems_list)
+    no_of_eval_subsets = len(df_per_dataset["subset"].unique())
+    no_of_test_cases = len(df_per_sample)
+    no_of_unique_recordings = len(df_per_sample["id"].unique())
+    total_audio_duration_hours = get_total_audio_duration(df_per_sample)
+    no_of_unique_speakers = len(df_per_sample["speaker_id"].unique())
+
+    df_per_dataset_with_asr_systems_meta = pd.merge(df_per_dataset, df_evaluated_systems, how="left", left_on="system", right_on="Shortname")
+          
+    ########### EVALUATION PARAMETERS PRESENTATION ################
+    st.title("Leaderboard for {} {}".format(dataset_short_name, dataset_version))
+    st.markdown(BIGOS_INFO, unsafe_allow_html=True)
+    st.markdown("**Evaluation date:** {}".format(eval_date))
+    st.markdown("**Number of evaluated system-model variants:** {}".format(no_of_evaluated_systems))
+    st.markdown("**Number of evaluated subsets:** {}".format(no_of_eval_subsets))
+    st.markdown("**Number of evaluated system-model-subsets combinations**: {}".format(len(df_per_dataset)))
+    st.markdown("**Number of unique speakers**: {}".format(no_of_unique_speakers))
+    st.markdown("**Number of unique recordings used for evaluation:** {}".format(no_of_unique_recordings))
+    st.markdown("**Total size of the dataset:** {:.2f} hours".format(total_audio_duration_hours))
+    st.markdown("**Total number of test cases (audio-hypothesis pairs):** {}".format(no_of_test_cases))
+    st.markdown("**Dataset:** {}".format(dataset))
+    st.markdown("**Dataset version:** {}".format(dataset_version))
+    st.markdown("**Split:** {}".format(split))
+    st.markdown("**Text reference type:** {}".format(ref_type))
+    st.markdown("**Normalization steps:** {}".format(norm_type))
+
+    ########### RESULTS ################    
+    st.header("WER (Word Error Rate) analysis")
+    st.subheader("Average WER for the whole dataset")
+    df_wer_avg = basic_stats_per_dimension(df_per_dataset, "WER", "dataset")
+    st.dataframe(df_wer_avg)
+
+    st.subheader("Comparison of average WER for free and commercial systems")
+    df_wer_avg_free_commercial = basic_stats_per_dimension(df_per_dataset_with_asr_systems_meta, "WER", "Type")
+    st.dataframe(df_wer_avg_free_commercial)
+
+
+    ##################### PER SYSTEM ANALYSIS ######################### 
+    analysis_dim = "system"
+    metric = "WER"
+    st.subheader("Table showing {} per {} sorted by median values".format(metric, analysis_dim))
+    df_wer_per_system_from_per_dataset = basic_stats_per_dimension(df_per_dataset, metric, analysis_dim)
+    h_df_per_system_per_dataset = calculate_height_to_display(df_wer_per_system_from_per_dataset)
+    st.dataframe(df_wer_per_system_from_per_dataset, height = h_df_per_system_per_dataset )
+
+    st.subheader("Boxplot showing {} per {} sorted by median values".format(metric, analysis_dim))
+    fig = box_plot_per_dimension(df_per_dataset, metric, analysis_dim, "{} per {}".format(metric, analysis_dim), analysis_dim, metric + "[%]")
+    st.pyplot(fig, clear_figure=True, use_container_width=True)
+
+    ##################### PER SUBSET ANALYSIS ######################### 
+    analysis_dim = "subset"
+    metric = "WER"
+    st.subheader("Table showing {} per {} sorted by median values".format(metric, analysis_dim))
+    df_wer_per_system_from_per_dataset = basic_stats_per_dimension(df_per_dataset, metric, analysis_dim)
+    h_df_per_system_per_dataset = calculate_height_to_display(df_wer_per_system_from_per_dataset)
+    st.dataframe(df_wer_per_system_from_per_dataset, height = h_df_per_system_per_dataset )
+
+    st.subheader("Boxplot showing {} per {} sorted by median values".format(metric, analysis_dim))
+    fig = box_plot_per_dimension(df_per_dataset, metric, analysis_dim, "{} per {}".format(metric, analysis_dim), analysis_dim, metric + "[%]")
+    st.pyplot(fig, clear_figure=True, use_container_width=True)
+
+    ### IMPACT OF NORMALIZATION ON ERROR RATES ##### 
+    # Calculate the average impact of various norm_types for all datasets and systems
+    df_per_dataset_selected_cols = df_per_dataset_all[cols_to_select_all]
+    diff_in_metrics = check_impact_of_normalization(df_per_dataset_selected_cols)
+    st.subheader("Impact of normalization of references and hypothesis on evaluation metrics")
+    st.dataframe(diff_in_metrics, use_container_width=False)
+
+  # Visualizing the differences in metrics graphically with data labels
+    # Visualizing the differences in metrics graphically with data labels
+    fig, axs = plt.subplots(3, 2, figsize=(12, 12))
+    fig.subplots_adjust(hspace=0.6, wspace=0.6)
+
+    #remove the sixth subplot
+    fig.delaxes(axs[2,1])
+
+    metrics = ['SER', 'WER', 'MER', 'CER', "Average"]
+    colors = ['blue', 'orange', 'green', 'red', 'purple']
+
+    for ax, metric, color in zip(axs.flatten(), metrics, colors):
+        bars = ax.bar(diff_in_metrics.index, diff_in_metrics[metric], color=color)
+        ax.set_title(f'Normalization impact on {metric}')
+        if metric == 'Average':
+            ax.set_title('Average normalization impact on all metrics')
+        ax.set_xlabel('Normalization Type')
+        ax.set_ylabel(f'Difference in {metric}')
+        ax.grid(True)
+        ax.set_xticklabels(diff_in_metrics.index, rotation=45, ha='right')
+        min_val = diff_in_metrics[metric].min()
+        ax.set_ylim([min_val * 1.1, diff_in_metrics[metric].max() * 1.1])
+   
+        for bar in bars:
+            height = bar.get_height()
+            ax.annotate(f'{height:.2f}',
+                        xy=(bar.get_x() + bar.get_width() / 2, height),
+                        xytext=(0, -12),  # 3 points vertical offset
+                        textcoords="offset points",
+                        ha='center', va='bottom')
+
+
+    # Display the plot in Streamlit
+    st.pyplot(fig)
+
+    ##################### APPENDIX #########################       
+    st.header("Appendix - Full evaluation results per subset for all evaluated systems")
+    # select only the columns we want to plot
+    st.dataframe(df_per_dataset_selected_cols, hide_index=True, use_container_width=False)
+
+with lead_bigos_diagnostic:
+
+    # configuration for tab
+    dataset = "amu-cai/pl-asr-bigos-v2-diagnostic"
+    dataset_short_name = "BIGOS DIAGNOSTIC"
+    dataset_version = "V2"
+    eval_date = "March 2024"
+    split = "test"
+    norm_type = "all"
+    ref_type = "orig"
+    
+    # common, reusable part for all tabs presenting leaderboards for specific datasets
+    #### DATA LOADING AND AUGMENTATION ####
+    df_per_sample_all, df_per_dataset_all = read_latest_results(dataset, split, codename_to_shortname_mapping)
+    
+    
+    # filter only the ref_type and norm_type we want to analyze
+    df_per_sample = df_per_sample_all[(df_per_sample_all["ref_type"] == ref_type) & (df_per_sample_all["norm_type"] == norm_type)]
+    # filter only the ref_type and norm_type we want to analyze
+    df_per_dataset = df_per_dataset_all[(df_per_dataset_all["ref_type"] == ref_type) & (df_per_dataset_all["norm_type"] == norm_type)]
+
+    ##### PARAMETERS CALCULATION ####
+    evaluated_systems_list = df_per_sample["system"].unique()
+    no_of_evaluated_systems = len(evaluated_systems_list)
+    no_of_eval_subsets = len(df_per_dataset["subset"].unique())
+    no_of_test_cases = len(df_per_sample)
+    no_of_unique_recordings = len(df_per_sample["id"].unique())
+    total_audio_duration_hours = get_total_audio_duration(df_per_sample)
+    #no_of_unique_speakers = len(df_per_sample["speaker_id"].unique())
+    no_of_unique_speakers="N/A"
+    df_per_dataset_with_asr_systems_meta = pd.merge(df_per_dataset, df_evaluated_systems, how="left", left_on="system", right_on="Shortname")
+          
+    ########### EVALUATION PARAMETERS PRESENTATION ################
+    st.title("Leaderboard for {} {}".format(dataset_short_name, dataset_version))
+    st.markdown(BIGOS_INFO, unsafe_allow_html=True)
+    st.markdown("**Evaluation date:** {}".format(eval_date))
+    st.markdown("**Number of evaluated system-model variants:** {}".format(no_of_evaluated_systems))
+    st.markdown("**Number of evaluated subsets:** {}".format(no_of_eval_subsets))
+    st.markdown("**Number of evaluated system-model-subsets combinations**: {}".format(len(df_per_dataset)))
+    st.markdown("**Number of unique speakers**: {}".format(no_of_unique_speakers))
+    st.markdown("**Number of unique recordings used for evaluation:** {}".format(no_of_unique_recordings))
+    st.markdown("**Total size of the dataset:** {:.2f} hours".format(total_audio_duration_hours))
+    st.markdown("**Total number of test cases (audio-hypothesis pairs):** {}".format(no_of_test_cases))
+    st.markdown("**Dataset:** {}".format(dataset))
+    st.markdown("**Dataset version:** {}".format(dataset_version))
+    st.markdown("**Split:** {}".format(split))
+    st.markdown("**Text reference type:** {}".format(ref_type))
+    st.markdown("**Normalization steps:** {}".format(norm_type))
+
+    ########### RESULTS ################    
+    st.header("WER (Word Error Rate) analysis")
+    st.subheader("Average WER for the whole dataset")
+    df_wer_avg = basic_stats_per_dimension(df_per_dataset, "WER", "dataset")
+    st.dataframe(df_wer_avg)
+
+    st.subheader("Comparison of average WER for free and commercial systems")
+    df_wer_avg_free_commercial = basic_stats_per_dimension(df_per_dataset_with_asr_systems_meta, "WER", "Type")
+    st.dataframe(df_wer_avg_free_commercial)
+
+
+    ##################### PER SYSTEM ANALYSIS ######################### 
+    analysis_dim = "system"
+    metric = "WER"
+    st.subheader("Table showing {} per {} sorted by median values".format(metric, analysis_dim))
+    df_wer_per_system_from_per_dataset = basic_stats_per_dimension(df_per_dataset, metric, analysis_dim)
+    h_df_per_system_per_dataset = calculate_height_to_display(df_wer_per_system_from_per_dataset)
+    st.dataframe(df_wer_per_system_from_per_dataset, height = h_df_per_system_per_dataset )
+
+    st.subheader("Boxplot showing {} per {} sorted by median values".format(metric, analysis_dim))
+    fig = box_plot_per_dimension(df_per_dataset, metric, analysis_dim, "{} per {}".format(metric, analysis_dim), analysis_dim, metric + "[%]")
+    st.pyplot(fig, clear_figure=True, use_container_width=True)
+
+    ##################### PER SUBSET ANALYSIS ######################### 
+    analysis_dim = "subset"
+    metric = "WER"
+    st.subheader("Table showing {} per {} sorted by median values".format(metric, analysis_dim))
+    df_wer_per_system_from_per_dataset = basic_stats_per_dimension(df_per_dataset, metric, analysis_dim)
+    h_df_per_system_per_dataset = calculate_height_to_display(df_wer_per_system_from_per_dataset)
+    st.dataframe(df_wer_per_system_from_per_dataset, height = h_df_per_system_per_dataset )
+
+    st.subheader("Boxplot showing {} per {} sorted by median values".format(metric, analysis_dim))
+    fig = box_plot_per_dimension(df_per_dataset, metric, analysis_dim, "{} per {}".format(metric, analysis_dim), analysis_dim, metric + "[%]")
+    st.pyplot(fig, clear_figure=True, use_container_width=True)
+
+    ##################### APPENDIX #########################       
+    st.header("Appendix - Full evaluation results per subset for all evaluated systems")
+    # select only the columns we want to plot
+    df_per_dataset_selected_cols = df_per_dataset_all[cols_to_select_all]   
+    st.dataframe(df_per_dataset_selected_cols, hide_index=True, use_container_width=False)
+
+with lead_bigos_synth:
+
+    # configuration for tab
+    dataset = "amu-cai/pl-asr-bigos-synth"
+    dataset_short_name = "BIGOS synthetic"
+    dataset_version = "V1"
+    eval_date = "March 2024"
+    split = "test"
+    norm_type = "all"
+    ref_type = "orig"
+    
+    # common, reusable part for all tabs presenting leaderboards for specific datasets
+    #### DATA LOADING AND AUGMENTATION ####
+    df_per_sample_all, df_per_dataset_all = read_latest_results(dataset, split, codename_to_shortname_mapping)
+        
+    # filter only the ref_type and norm_type we want to analyze
+    df_per_sample = df_per_sample_all[(df_per_sample_all["ref_type"] == ref_type) & (df_per_sample_all["norm_type"] == norm_type)]
+    # filter only the ref_type and norm_type we want to analyze
+    df_per_dataset = df_per_dataset_all[(df_per_dataset_all["ref_type"] == ref_type) & (df_per_dataset_all["norm_type"] == norm_type)]
+
+    ##### PARAMETERS CALCULATION ####
+    evaluated_systems_list = df_per_sample["system"].unique()
+    no_of_evaluated_systems = len(evaluated_systems_list)
+    no_of_eval_subsets = len(df_per_dataset["subset"].unique())
+    no_of_test_cases = len(df_per_sample)
+    no_of_unique_recordings = len(df_per_sample["id"].unique())
+    total_audio_duration_hours = get_total_audio_duration(df_per_sample)
+    #no_of_unique_speakers = len(df_per_sample["speaker_id"].unique())
+    no_of_unique_speakers="N/A"
+
+    df_evaluated_systems = retrieve_asr_systems_meta_from_the_catalog(evaluated_systems_list)
+
+    df_per_dataset_with_asr_systems_meta = pd.merge(df_per_dataset, df_evaluated_systems, how="left", left_on="system", right_on="Shortname")
+
+    ########### EVALUATION PARAMETERS PRESENTATION ################
+    st.title("Leaderboard for {} {}".format(dataset_short_name, dataset_version))
+    st.markdown(BIGOS_INFO, unsafe_allow_html=True)
+    st.markdown("**Evaluation date:** {}".format(eval_date))
+    st.markdown("**Number of evaluated system-model variants:** {}".format(no_of_evaluated_systems))
+    st.markdown("**Number of evaluated subsets:** {}".format(no_of_eval_subsets))
+    st.markdown("**Number of evaluated system-model-subsets combinations**: {}".format(len(df_per_dataset)))
+    st.markdown("**Number of unique speakers**: {}".format(no_of_unique_speakers))
+    st.markdown("**Number of unique recordings used for evaluation:** {}".format(no_of_unique_recordings))
+    st.markdown("**Total size of the dataset:** {:.2f} hours".format(total_audio_duration_hours))
+    st.markdown("**Total number of test cases (audio-hypothesis pairs):** {}".format(no_of_test_cases))
+    st.markdown("**Dataset:** {}".format(dataset))
+    st.markdown("**Dataset version:** {}".format(dataset_version))
+    st.markdown("**Split:** {}".format(split))
+    st.markdown("**Text reference type:** {}".format(ref_type))
+    st.markdown("**Normalization steps:** {}".format(norm_type))
+
+    ########### RESULTS ################    
+    st.header("WER (Word Error Rate) analysis")
+    st.subheader("Average WER for the whole dataset")
+    df_wer_avg = basic_stats_per_dimension(df_per_dataset, "WER", "dataset")
+    st.dataframe(df_wer_avg)
+
+    st.subheader("Comparison of average WER for free and commercial systems")
+    df_wer_avg_free_commercial = basic_stats_per_dimension(df_per_dataset_with_asr_systems_meta, "WER", "Type")
+    st.dataframe(df_wer_avg_free_commercial)
+
+
+    ##################### PER SYSTEM ANALYSIS ######################### 
+    analysis_dim = "system"
+    metric = "WER"
+    st.subheader("Table showing {} per {} sorted by median values".format(metric, analysis_dim))
+    df_wer_per_system_from_per_dataset = basic_stats_per_dimension(df_per_dataset, metric, analysis_dim)
+    h_df_per_system_per_dataset = calculate_height_to_display(df_wer_per_system_from_per_dataset)
+    st.dataframe(df_wer_per_system_from_per_dataset, height = h_df_per_system_per_dataset )
+
+    st.subheader("Boxplot showing {} per {} sorted by median values".format(metric, analysis_dim))
+    fig = box_plot_per_dimension(df_per_dataset, metric, analysis_dim, "{} per {}".format(metric, analysis_dim), analysis_dim, metric + "[%]")
+    st.pyplot(fig, clear_figure=True, use_container_width=True)
+
+    ##################### PER SUBSET ANALYSIS ######################### 
+    analysis_dim = "subset"
+    metric = "WER"
+    st.subheader("Table showing {} per {} sorted by median values".format(metric, analysis_dim))
+    df_wer_per_system_from_per_dataset = basic_stats_per_dimension(df_per_dataset, metric, analysis_dim)
+    h_df_per_system_per_dataset = calculate_height_to_display(df_wer_per_system_from_per_dataset)
+    st.dataframe(df_wer_per_system_from_per_dataset, height = h_df_per_system_per_dataset )
+
+    st.subheader("Boxplot showing {} per {} sorted by median values".format(metric, analysis_dim))
+    fig = box_plot_per_dimension(df_per_dataset, metric, analysis_dim, "{} per {}".format(metric, analysis_dim), analysis_dim, metric + "[%]")
+    st.pyplot(fig, clear_figure=True, use_container_width=True)
+    
+    ### IMPACT OF NORMALIZATION ON ERROR RATES ##### 
+    # Calculate the average impact of various norm_types for all datasets and systems
+    df_per_dataset_selected_cols = df_per_dataset_all[cols_to_select_all]
+    diff_in_metrics = check_impact_of_normalization(df_per_dataset_selected_cols)
+    st.subheader("Impact of normalization of references and hypothesis on evaluation metrics")
+    st.dataframe(diff_in_metrics, use_container_width=False)
+
+    ##################### APPENDIX #########################       
+    st.header("Appendix - Full evaluation results per subset for all evaluated systems")
+    # select only the columns we want to plot
+    df_per_dataset_selected_cols = df_per_dataset[cols_to_select_all]   
+    st.dataframe(df_per_dataset_selected_cols, hide_index=True, use_container_width=False)
+
+with lead_pelcra:
+    st.title("PELCRA Leaderboard")
+    st.markdown(PELCRA_INFO, unsafe_allow_html=True)
+
+    # configuration for tab
+    dataset = "pelcra/pl-asr-pelcra-for-bigos-secret"
+    dataset_short_name = "PELCRA"
+    dataset_version = "V1"
+    eval_date = "March 2024"
+    split = "test"
+    norm_type = "all"
+    ref_type = "orig"
+    
+     # common, reusable part for all tabs presenting leaderboards for specific datasets
+    #### DATA LOADING AND AUGMENTATION ####
+    df_per_sample_all, df_per_dataset_all = read_latest_results(dataset, split, codename_to_shortname_mapping)
+    
+    
+    # filter only the ref_type and norm_type we want to analyze
+    df_per_sample = df_per_sample_all[(df_per_sample_all["ref_type"] == ref_type) & (df_per_sample_all["norm_type"] == norm_type)]
+    # filter only the ref_type and norm_type we want to analyze
+    df_per_dataset = df_per_dataset_all[(df_per_dataset_all["ref_type"] == ref_type) & (df_per_dataset_all["norm_type"] == norm_type)]
+
+    ##### PARAMETERS CALCULATION ####
+    evaluated_systems_list = df_per_sample["system"].unique()
+    no_of_evaluated_systems = len(evaluated_systems_list)
+    no_of_eval_subsets = len(df_per_dataset["subset"].unique())
+    no_of_test_cases = len(df_per_sample)
+    no_of_unique_recordings = len(df_per_sample["id"].unique())
+    total_audio_duration_hours = get_total_audio_duration(df_per_sample)
+    no_of_unique_speakers = len(df_per_sample["speaker_id"].unique())
+
+    df_per_dataset_with_asr_systems_meta = pd.merge(df_per_dataset, df_evaluated_systems, how="left", left_on="system", right_on="Shortname")
+          
+    ########### EVALUATION PARAMETERS PRESENTATION ################
+    st.title("Leaderboard for {} {}".format(dataset_short_name, dataset_version))
+    st.markdown(BIGOS_INFO, unsafe_allow_html=True)
+    st.markdown("**Evaluation date:** {}".format(eval_date))
+    st.markdown("**Number of evaluated system-model variants:** {}".format(no_of_evaluated_systems))
+    st.markdown("**Number of evaluated subsets:** {}".format(no_of_eval_subsets))
+    st.markdown("**Number of evaluated system-model-subsets combinations**: {}".format(len(df_per_dataset)))
+    st.markdown("**Number of unique speakers**: {}".format(no_of_unique_speakers))
+    st.markdown("**Number of unique recordings used for evaluation:** {}".format(no_of_unique_recordings))
+    st.markdown("**Total size of the dataset:** {:.2f} hours".format(total_audio_duration_hours))
+    st.markdown("**Total number of test cases (audio-hypothesis pairs):** {}".format(no_of_test_cases))
+    st.markdown("**Dataset:** {}".format(dataset))
+    st.markdown("**Dataset version:** {}".format(dataset_version))
+    st.markdown("**Split:** {}".format(split))
+    st.markdown("**Text reference type:** {}".format(ref_type))
+    st.markdown("**Normalization steps:** {}".format(norm_type))
+
+    ########### RESULTS ################
+    st.header("WER (Word Error Rate) analysis")
+    st.subheader("Average WER for the whole dataset")
+    df_wer_avg = basic_stats_per_dimension(df_per_dataset, "WER", "dataset")
+    st.dataframe(df_wer_avg)
+
+    st.subheader("Comparison of average WER for free and commercial systems")
+    df_wer_avg_free_commercial = basic_stats_per_dimension(df_per_dataset_with_asr_systems_meta, "WER", "Type")
+    st.dataframe(df_wer_avg_free_commercial)
+
+    ##################### PER SYSTEM ANALYSIS ######################### 
+    analysis_dim = "system"
+    metric = "WER"
+    st.subheader("Table showing {} per {} sorted by median values".format(metric, analysis_dim))
+    df_wer_per_system_from_per_dataset = basic_stats_per_dimension(df_per_dataset, metric, analysis_dim)
+    h_df_per_system_per_dataset = calculate_height_to_display(df_wer_per_system_from_per_dataset)
+    st.dataframe(df_wer_per_system_from_per_dataset, height = h_df_per_system_per_dataset )
+
+    st.subheader("Boxplot showing {} per {} sorted by median values".format(metric, analysis_dim))
+    fig = box_plot_per_dimension(df_per_dataset, metric, analysis_dim, "{} per {}".format(metric, analysis_dim), analysis_dim, metric + "[%]")
+    st.pyplot(fig, clear_figure=True, use_container_width=True)
+
+    ##################### PER SUBSET ANALYSIS ######################### 
+    analysis_dim = "subset"
+    metric = "WER"
+    st.subheader("Table showing {} per {} sorted by median values".format(metric, analysis_dim))
+    df_wer_per_system_from_per_dataset = basic_stats_per_dimension(df_per_dataset, metric, analysis_dim)
+    h_df_per_system_per_dataset = calculate_height_to_display(df_wer_per_system_from_per_dataset)
+    st.dataframe(df_wer_per_system_from_per_dataset, height = h_df_per_system_per_dataset )
+
+    st.subheader("Boxplot showing {} per {} sorted by median values".format(metric, analysis_dim))
+    fig = box_plot_per_dimension(df_per_dataset, metric, analysis_dim, "{} per {}".format(metric, analysis_dim), analysis_dim, metric + "[%]")
+    st.pyplot(fig, clear_figure=True, use_container_width=True)
+
+    ### IMPACT OF NORMALIZATION ON ERROR RATES ##### 
+    # Calculate the average impact of various norm_types for all datasets and systems
+    df_per_dataset_selected_cols = df_per_dataset_all[cols_to_select_all]
+    diff_in_metrics = check_impact_of_normalization(df_per_dataset_selected_cols)
+    st.subheader("Impact of normalization on WER")
+    st.dataframe(diff_in_metrics, use_container_width=False)
+    
+    # Visualizing the differences in metrics graphically with data labels
+    # Visualizing the differences in metrics graphically with data labels
+    fig, axs = plt.subplots(3, 2, figsize=(12, 12))
+    fig.subplots_adjust(hspace=0.6, wspace=0.6)
+
+    #remove the sixth subplot
+    fig.delaxes(axs[2,1])
+
+    metrics = ['SER', 'WER', 'MER', 'CER', "Average"]
+    colors = ['blue', 'orange', 'green', 'red', 'purple']
+
+    for ax, metric, color in zip(axs.flatten(), metrics, colors):
+            bars = ax.bar(diff_in_metrics.index, diff_in_metrics[metric], color=color)
+            ax.set_title(f'Normalization impact on {metric}')
+            if metric == 'Average':
+                ax.set_title('Average normalization impact on all metrics')
+            ax.set_xlabel('Normalization Type')
+            ax.set_ylabel(f'Difference in {metric}')
+            ax.grid(True)
+            ax.set_xticklabels(diff_in_metrics.index, rotation=45, ha='right')
+            min_val = diff_in_metrics[metric].min()
+            ax.set_ylim([min_val * 1.1, diff_in_metrics[metric].max() * 1.1])
+    
+            for bar in bars:
+                height = bar.get_height()
+                ax.annotate(f'{height:.2f}',
+                            xy=(bar.get_x() + bar.get_width() / 2, height),
+                            xytext=(0, -12),  # 3 points vertical offset
+                            textcoords="offset points",
+                            ha='center', va='bottom')
+
+    # Display the plot in Streamlit
+    st.pyplot(fig)
+
+    ##################### APPENDIX #########################       
+    st.header("Appendix - Full evaluation results per subset for all evaluated systems")
+    # select only the columns we want to plot
+    df_per_dataset_selected_cols = df_per_dataset_all[cols_to_select_all]   
+    st.dataframe(df_per_dataset_selected_cols, hide_index=True, use_container_width=False)
+
+with analysis:
+    
+    datasets = [
+        "amu-cai/pl-asr-bigos-v2-secret",
+        "pelcra/pl-asr-pelcra-for-bigos-secret",
+        "amu-cai/pl-asr-bigos-v2-diagnostic",
+        "amu-cai/pl-asr-bigos-v2-med"]
+    
+    
+    st.title("Analysis and insights")
+    st.markdown(ANALYSIS_INFO, unsafe_allow_html=True)
+
+    st.title("Plots for analyzing ASR Systems performance")
+    
+    # select the dataset to display results
+    dataset = st.selectbox("Select Dataset", datasets, index=datasets.index('amu-cai/pl-asr-bigos-v2-secret'))
+
+    # read the latest results for the selected dataset
+    print("Reading the latest results for dataset: ", dataset)
+    df_per_sample_all, df_per_dataset_all = read_latest_results(dataset, split, codename_to_shortname_mapping)
+    # filter only the ref_type and norm_type we want to analyze
+    df_per_sample = df_per_sample_all[(df_per_sample_all["ref_type"] == ref_type) & (df_per_sample_all["norm_type"] == norm_type)]
+    # filter only the ref_type and norm_type we want to analyze
+    df_per_dataset = df_per_dataset_all[(df_per_dataset_all["ref_type"] == ref_type) & (df_per_dataset_all["norm_type"] == norm_type)]
+
+    evaluated_systems_list = df_per_sample["system"].unique()
+    print(evaluated_systems_list)
+    df_evaluated_systems = retrieve_asr_systems_meta_from_the_catalog(evaluated_systems_list)
+    print(df_evaluated_systems)
+
+    # read available options to analyze for specific dataset
+    splits = list(df_per_dataset_all['subset'].unique()) # Get the unique splits
+    norm_types = list(df_per_dataset_all['norm_type'].unique()) # Get the unique norm_types
+    ref_types = list(df_per_dataset_all['ref_type'].unique()) # Get the unique ref_types
+    systems = list(df_per_dataset_all['system'].unique()) # Get the unique systems
+    metrics = list(df_per_dataset_all.columns[7:]) # Get the unique metrics
+
+    # Select the system to display. More than 1 system can be selected.
+    systems_selected = st.multiselect("Select ASR Systems", systems) 
+    
+    # Select the metric to display
+    metric = st.selectbox("Select Metric", metrics, index=metrics.index('WER'))
+
+    # Select the normalization type
+    norm_type = st.selectbox("Select Normalization Type", norm_types, index=norm_types.index('all'))
+    # Select the reference type
+    ref_type = st.selectbox("Select Reference Type", ref_types, index=ref_types.index('orig'))
+
+    enable_labels = st.checkbox("Enable labels on radar plot", value=True)
+
+    enable_bar_chart = st.checkbox("Enable bar chart", value=True)
+    enable_polar_plot = st.checkbox("Enable radar plot", value=True)
+
+    orientation = st.selectbox("Select orientation", ["vertical", "horizontal"], index=0)
+
+    if enable_polar_plot:
+        if metric:
+            if systems_selected:
+                create_radar_plot(df_per_dataset_all, enable_labels, systems_selected, metric, norm_type, ref_type)
+
+    if enable_bar_chart:
+        if metric:
+            if systems_selected:
+                create_bar_chart(df_per_dataset_all, systems_selected , metric, norm_type, ref_type, orientation)
+
+
+    ##### ANALYSIS - COMMERCIAL VS FREE SYSTEMS #####
+    # Generate dataframe with columns as follows System Type Subset Avg_WER
+    df_per_dataset_with_asr_systems_meta = pd.merge(df_per_dataset, df_evaluated_systems, how="left", left_on="system", right_on="Shortname")
+
+    df_wer_avg_per_system_all_subsets_with_type = df_per_dataset_with_asr_systems_meta.groupby(['system', 'Type', 'subset'])['WER'].mean().reset_index()
+    print(df_wer_avg_per_system_all_subsets_with_type)
+
+    # Select the best and worse system for free and commercial systems
+    free_systems = df_wer_avg_per_system_all_subsets_with_type[df_wer_avg_per_system_all_subsets_with_type['Type'] == 'free']['system'].unique()
+    commercial_systems = df_wer_avg_per_system_all_subsets_with_type[df_wer_avg_per_system_all_subsets_with_type['Type'] == 'commercial']['system'].unique()
+    free_system_with_best_wer = df_wer_avg_per_system_all_subsets_with_type[df_wer_avg_per_system_all_subsets_with_type['system'].isin(free_systems)].groupby('system')['WER'].mean().idxmin()
+    free_system_with_worst_wer = df_wer_avg_per_system_all_subsets_with_type[df_wer_avg_per_system_all_subsets_with_type['system'].isin(free_systems)].groupby('system')['WER'].mean().idxmax()
+    commercial_system_with_best_wer = df_wer_avg_per_system_all_subsets_with_type[df_wer_avg_per_system_all_subsets_with_type['system'].isin(commercial_systems)].groupby('system')['WER'].mean().idxmin()
+    commercial_system_with_worst_wer = df_wer_avg_per_system_all_subsets_with_type[df_wer_avg_per_system_all_subsets_with_type['system'].isin(commercial_systems)].groupby('system')['WER'].mean().idxmax()
+    
+    #print(f"Best free system: {free_system_with_best_wer}")
+    #print(f"Worst free system: {free_system_with_worst_wer}")
+    #print(f"Best commercial system: {commercial_system_with_best_wer}")
+    #print(f"Worst commercial system: {commercial_system_with_worst_wer}")
+
+    st.subheader("Comparison of WER for free and commercial systems")
+    # Best and worst system for free and commercial systems - print table
+    header = ["Type", "Best System", "Worst System"]
+    data = [
+        ["Free", free_system_with_best_wer, free_system_with_worst_wer],
+        ["Commercial", commercial_system_with_best_wer, commercial_system_with_worst_wer]
+    ]
+
+    st.subheader("Best and worst systems for dataset {}".format(dataset))
+    df_best_worse_systems = pd.DataFrame(data, columns=header)
+    # do not display index
+    st.dataframe(df_best_worse_systems)
+    
+    st.subheader("Comparison of average WER for best systems")
+    df_per_dataset_best_systems = df_per_dataset_with_asr_systems_meta[df_per_dataset_with_asr_systems_meta['system'].isin([free_system_with_best_wer, commercial_system_with_best_wer])]
+    df_wer_avg_best_free_commercial = basic_stats_per_dimension(df_per_dataset_best_systems, "WER", "Type")
+    st.dataframe(df_wer_avg_best_free_commercial)
+
+    # Create lookup table to get system type based on its name
+    #system_type_lookup = dict(zip(df_wer_avg_per_system_all_subsets_with_type['system'], df_wer_avg_per_system_all_subsets_with_type['Type']))
+
+    systems_to_plot_best= [free_system_with_best_wer, commercial_system_with_best_wer]
+    plot_performance(systems_to_plot_best, df_wer_avg_per_system_all_subsets_with_type)
+
+    st.subheader("Comparison of average WER for the worst systems")
+    df_per_dataset_worst_systems = df_per_dataset_with_asr_systems_meta[df_per_dataset_with_asr_systems_meta['system'].isin([free_system_with_worst_wer, commercial_system_with_worst_wer])]
+    df_wer_avg_worst_free_commercial = basic_stats_per_dimension(df_per_dataset_worst_systems, "WER", "Type")
+    st.dataframe(df_wer_avg_worst_free_commercial)  
+
+    systems_to_plot_worst=[free_system_with_worst_wer, commercial_system_with_worst_wer]
+    plot_performance(systems_to_plot_worst, df_wer_avg_per_system_all_subsets_with_type)
+
+    # WER in function of model size
+    st.subheader("WER in function of model size for dataset {}".format(dataset))
+
+    # select only free systems for the analysis from df_wer_avg_per_system_all_subsets_with_type dataframe
+    free_systems_wer_per_subset = df_per_dataset_with_asr_systems_meta.groupby(['system', 'Parameters [M]', 'subset'])['WER'].mean().reset_index()
+    # sort by model size
+    # change column type Parameters [M] to integer
+    free_systems_wer_per_subset['Parameters [M]'] = free_systems_wer_per_subset['Parameters [M]'].astype(int)
+
+    free_systems_wer_per_subset = free_systems_wer_per_subset.sort_values(by='Parameters [M]')
+
+    free_systems_wer_average_across_all_subsets = free_systems_wer_per_subset.groupby(['system', 'Parameters [M]'])['WER'].mean().reset_index()
+    # change column type Parameters [M] to integer
+    free_systems_wer_average_across_all_subsets['Parameters [M]'] = free_systems_wer_average_across_all_subsets['Parameters [M]'].astype(int)
+
+    # sort by model size
+    free_systems_wer_average_across_all_subsets = free_systems_wer_average_across_all_subsets.sort_values(by='Parameters [M]')
+
+    free_systems_wer = free_systems_wer_average_across_all_subsets
+    
+    # use system name as index
+    free_systems_wer_to_show = free_systems_wer.set_index('system')
+
+    # sort by WER and round WER by value to 2 decimal places
+    free_systems_wer_to_show = free_systems_wer_to_show.sort_values(by='WER').round({'WER': 2})
+    
+    # print dataframe in streamlit with average WER, system name and model size
+    st.dataframe(free_systems_wer_to_show)
+
+    # plot scatter plot with values of WER
+    # X axis is the model size (parameters [M])
+    # Y is thw average WER
+    # make each point a different color 
+    # provide legend with system names
+    fig, ax = plt.subplots()
+    for system in free_systems_wer['system'].unique():
+        subset = free_systems_wer[free_systems_wer['system'] == system]
+        ax.scatter(subset['Parameters [M]'], subset['WER'], label=system)
+        # Add text annotation for each point
+        for i, point in subset.iterrows():
+            ax.annotate(point['system'], (point['Parameters [M]'], point['WER']), textcoords="offset points", xytext=(-10,-10), ha='left', rotation=-30, fontsize=5)
+    ax.set_xlabel('Model Size [M]')
+    ax.set_ylabel('WER (%)')
+    ax.set_title('WER in function of model size')
+    # decrease font size of the legend and place it outside the plot
+    ax.legend(title='System', bbox_to_anchor=(1.05, 1), loc='upper left')
+
+    st.pyplot(fig)
+
+    ##################################################################################################################################################
+    # WER per audio duration
+        
+    # calculate average WER per audio duration bucket for the best and worse commercial and free systems
+    selected_systems = [free_system_with_best_wer, commercial_system_with_best_wer]
+    
+    # filter out results for selected systems
+    df_per_sample_selected_systems = df_per_sample[df_per_sample['system'].isin(selected_systems)]
+    
+    # calculate average WER per audio duration for the best system
+    # add column with audio duration in seconds rounded to nearest integer value.
+    audio_duration_buckets = [1,2,3,4,5,10,15,20,30,40,50,60]
+    # map audio duration to the closest bucket
+    df_per_sample_selected_systems['audio_duration_buckets'] = df_per_sample_selected_systems['audio_duration'].apply(lambda x: min(audio_duration_buckets, key=lambda y: abs(x-y)))
+
+
+    # calculate average WER per audio duration bucket
+    df_per_sample_wer_audio = df_per_sample_selected_systems.groupby(['system', 'audio_duration_buckets'])['WER'].mean().reset_index()
+    # add column with number of samples for specific audio bucket size
+    df_per_sample_wer_audio['number_of_samples'] = df_per_sample_selected_systems.groupby(['system', 'audio_duration_buckets'])['WER'].count().values
+
+    df_per_sample_wer_audio = df_per_sample_wer_audio.sort_values(by='audio_duration_buckets')
+    # round values in WER column in df_per_sample_wer to 2 decimal places
+    df_per_sample_wer_audio['WER'].round(2)
+    # transform df_per_sample_wer. Use system values as columns, while audio_duration_buckets as main index
+    df_per_sample_wer_audio_pivot = df_per_sample_wer_audio.pivot(index='audio_duration_buckets', columns='system', values='WER')
+    df_per_sample_wer_audio_pivot = df_per_sample_wer_audio_pivot.round(2)
+    
+    df_per_sample_wer_audio_pivot['number_of_samples'] = df_per_sample_wer_audio[df_per_sample_wer_audio['system']==free_system_with_best_wer].groupby('audio_duration_buckets')['number_of_samples'].sum().values
+    
+    # put number_of_samples as the first column after index
+    df_per_sample_wer_audio_pivot = df_per_sample_wer_audio_pivot[['number_of_samples'] + [col for col in df_per_sample_wer_audio_pivot.columns if col != 'number_of_samples']]
+
+    # print dataframe in streamlit
+    st.dataframe(df_per_sample_wer_audio_pivot)
+
+    # plot scatter plot with values from df_per_sample_wer_pivot. 
+    # each system should have a different color
+    # the size of the point should be proportional to the number of samples in the bucket
+    # the x axis should be the audio duration bucket
+    # the y axis should be the average WER
+    fig, ax = plt.subplots()
+    for system in selected_systems:
+        subset = df_per_sample_wer_audio[df_per_sample_wer_audio['system'] == system]
+        ax.scatter(subset['audio_duration_buckets'], subset['WER'], label=system, s=subset['number_of_samples']*0.5)
+    ax.set_xlabel('Audio Duration [s]')
+    ax.set_ylabel('WER (%)')
+    ax.set_title('WER in function of audio duration.')
+
+    # place legend outside the plot on the right
+    ax.legend(title='System', bbox_to_anchor=(1.05, 1), loc='upper left')
+    st.pyplot(fig)
+
+    ##################################################################################################################################################
+    # WER per speech rate
+
+    
+    # speech rate chars unique values
+    audio_feature_to_analyze = 'speech_rate_words'
+    audio_feature_unit = ' [words/s]'
+    metric = 'WER'
+    metric_unit = ' [%]'
+    no_of_buckets = 10
+    # calculate average WER per audio duration bucket for the best and worse commercial and free systems
+    selected_systems = [free_system_with_best_wer, commercial_system_with_best_wer]
+
+    df_per_sample_wer_feature_pivot, df_per_sample_wer_feature = calculate_wer_per_audio_feature(df_per_sample, selected_systems, audio_feature_to_analyze, metric, no_of_buckets)
+
+    # print dataframe in streamlit
+    st.dataframe(df_per_sample_wer_feature_pivot)
+
+    # plot scatter plot with values from df_per_sample_wer_pivot. 
+    # each system should have a different color
+    # the size of the point should be proportional to the number of samples in the bucket
+    # the x axis should be the audio duration bucket
+    # the y axis should be the average WER
+    fig, ax = plt.subplots()
+    for system in selected_systems:
+        subset = df_per_sample_wer_feature[df_per_sample_wer_feature['system'] == system]
+        ax.scatter(subset[audio_feature_to_analyze], subset[metric], label=system, s=subset['number_of_samples']*0.5)
+    ax.set_xlabel(audio_feature_to_analyze.replace('_',' ').capitalize() + audio_feature_unit)
+    ax.set_ylabel(metric  + metric_unit)
+    ax.set_title('WER in function of speech rate.'.format(audio_feature_to_analyze))
+
+    # place legend outside the plot on the right
+    ax.legend(title='System', loc='best')
+    st.pyplot(fig)
+
+
+    ################################################################################################################################################
+    # WER PER GENDER
+
+    #selected_systems = [free_system_with_best_wer, commercial_system_with_best_wer, free_system_with_worst_wer, commercial_system_with_worst_wer]
+    selected_systems = df_per_sample['system'].unique()
+
+    df_per_sample_wer_gender_pivot, df_available_samples_per_category_per_system, no_samples_per_category = calculate_wer_per_meta_category(df_per_sample, selected_systems, 'WER', 'speaker_gender')
+    #print(df_per_sample_wer_gender_pivot)
+    #print(no_samples_per_category)
+
+    # print dataframe in streamlit
+    st.write("Number of samples per category")
+    for system in selected_systems:
+        st.write(f"System: {system}")
+        df_available_samples_per_category = df_available_samples_per_category_per_system[system]
+        st.dataframe(df_available_samples_per_category)
+
+    st.write("Number of samples analyzed per category - {}".format(no_samples_per_category))
+    st.dataframe(df_per_sample_wer_gender_pivot)
+    
+
+    #print(difference_values)
+    #print(selected_systems)
+
+    # create the scatter plot
+    # the x axis should be the systems from selected_systems
+    # the y axis should be the difference from difference_values
+    # each system should have a different color
+    fig, ax = plt.subplots()
+    difference_values = df_per_sample_wer_gender_pivot['Difference'][:-3]
+    selected_systems = df_per_sample_wer_gender_pivot.index[:-3]
+    ax.scatter(difference_values, selected_systems, c=range(len(selected_systems)), cmap='viridis')
+    ax.set_ylabel('ASR System')
+    ax.set_xlabel('Difference in WER across speaker gender')
+    ax.set_title('ASR systems perfomance bias for genders.')
+    # add labels with difference in WER values
+    for i, txt in enumerate(difference_values):
+        ax.annotate(txt, (difference_values[i], selected_systems[i]), fontsize=5, ha='right')
+    st.pyplot(fig)
+    
+    #####################################################################################################################################################################################
+    # WER per age
+    df_per_sample_wer_age_pivot, df_available_samples_per_category_per_system, no_samples_per_category = calculate_wer_per_meta_category(df_per_sample, selected_systems,'WER','speaker_age')
+    #print(df_per_sample_wer_age_pivot)
+    #print(no_samples_per_category)
+
+    # print dataframe in streamlit
+    st.write("Number of samples per category")
+    for system in selected_systems:
+        st.write(f"System: {system}")
+        df_available_samples_per_category = df_available_samples_per_category_per_system[system]
+        st.dataframe(df_available_samples_per_category)
+
+    st.write("Number of samples analyzed per category - {}".format(no_samples_per_category))
+
+    st.write("WER per age")
+    st.dataframe(df_per_sample_wer_age_pivot)
+    
+    # extract columns from df_per_sample_wer_age_pivot for selected_systems (skip  the last 3 values corresponding to median, average and std values)
+
+    #print(selected_systems)
+
+    # create the scatter plot
+    # the x axis should be the systems from selected_systems
+    # the y axis should be the difference from difference_values
+    # each system should have a different color
+    fig, ax = plt.subplots()
+    difference_values = df_per_sample_wer_age_pivot['Std Dev'][:-3]
+    selected_systems = df_per_sample_wer_age_pivot.index[:-3]
+    ax.scatter(difference_values,selected_systems , c=range(len(selected_systems)), cmap='viridis')
+    ax.set_ylabel('ASR System')
+    ax.set_xlabel('Standard Deviation in WER across speaker age')
+    ax.set_title('ASR systems perfomance bias for age groups')
+    # add labels with difference in WER values
+    for i, txt in enumerate(difference_values):
+        ax.annotate(txt, (difference_values[i], selected_systems[i]), fontsize=5, ha='right')
+    st.pyplot(fig)
+
+    # READ vs CONVERSIONAL SPEECH AVERAGE WER
+
+    # Hallucinations rate per system
+
+
+
+with inspection:
+    st.title("Browse and manually inspect evaluation corpora and ASR results")
+    st.markdown(INSPECTION_INFO, unsafe_allow_html=True)
+    # TODO - load and display analysis and insights
+    # filter dataset by audio id, type, ref/hyp content, ref/hyp length, words/chars per second etc.
+    # playback audio
+    # https://docs.streamlit.io/library/api-reference/media/st.audio
+
+    datasets = [
+        "amu-cai/pl-asr-bigos-v2-secret",
+        "pelcra/pl-asr-pelcra-for-bigos-secret",
+        "amu-cai/pl-asr-bigos-v2-diagnostic",
+        "amu-cai/pl-asr-bigos-v2-med"]
+    
+    st.title("Data for qualitative analysis")
+
+    # select the dataset to display results
+    dataset = st.selectbox("Select Dataset", datasets, key="dataset_inspection")
+
+    # read the latest results for the selected dataset
+    df_per_sample_all, df_per_dataset_all = read_latest_results(dataset, split, codename_to_shortname_mapping)
+
+    # read available options to analyze for specific dataset
+    splits = list(df_per_dataset_all['subset'].unique()) # Get the unique splits
+    norm_types = list(df_per_dataset_all['norm_type'].unique()) # Get the unique norm_types
+    ref_types = list(df_per_dataset_all['ref_type'].unique()) # Get the unique ref_types
+    systems = list(df_per_dataset_all['system'].unique()) # Get the unique systems
+    metrics = list(df_per_dataset_all.columns[7:]) # Get the unique metrics
+
+    # Select the system to display. More than 1 system can be selected.
+    systems_selected = st.multiselect("Select ASR Systems", systems, key="systems_inspection", default=systems[:2]) 
+    
+    # Select the metric to display
+    metric = st.selectbox("Select Metric", metrics, index=metrics.index('WER'), key="metric_inspection")
+
+    # Select the normalization type
+    norm_type = st.selectbox("Select Normalization Type", norm_types, index=norm_types.index('all'), key="norm_type_inspection")
+    # Select the reference type
+    ref_type = st.selectbox("Select Reference Type", ref_types, index=ref_types.index('orig'), key="ref_type_inspection")
+
+    num_of_samples = st.slider("Select number of samples to display", 1, 100, 10)
+
+    df_per_sample = df_per_sample_all[(df_per_sample_all["ref_type"] == ref_type) & (df_per_sample_all["norm_type"] == norm_type) & (df_per_sample_all["system"].isin(systems_selected))]
+    # drop columns dataset
+    #df_per_sample = df_per_sample.drop(columns=['dataset'])
+
+     # print 20 refs and hyps with the worse WER per sample
+    st.subheader("Samples with the worst WER per sample")
+    df_per_sample_worst_wer = df_per_sample.sort_values(by='WER', ascending=False).head(num_of_samples)
+    # use full width of the screen to display dataframe
+    st.dataframe(df_per_sample_worst_wer, use_container_width=True)
+
+    
+# ALL as the concatenation
+# common functions, difference only in the input TSV
+

app.py

@@ -0,0 +1,840 @@
+import os
+import streamlit as st
+import pandas as pd
+from constants import BIGOS_INFO, PELCRA_INFO, ANALYSIS_INFO, ABOUT_INFO, INSPECTION_INFO, COMPARISON_INFO
+from utils import read_latest_results, basic_stats_per_dimension, retrieve_asr_systems_meta_from_the_catalog, box_plot_per_dimension, get_total_audio_duration, check_impact_of_normalization, calculate_wer_per_meta_category, calculate_wer_per_audio_feature
+from app_utils import calculate_height_to_display, filter_dataframe
+import matplotlib.pyplot as plt
+import numpy as np
+
+hf_token = os.getenv('HF_TOKEN')
+if hf_token is None:
+    raise ValueError("HF_TOKEN environment variable is not set. Please check your secrets settings.")
+
+# Tabs
+# About (description of the benchmark) - methodology
+# Leaderboards
+# Interactive analysis
+# Acknowledgements
+
+# select the dataset to display results
+datasets_secret = [
+    "amu-cai/pl-asr-bigos-v2-secret",
+    "pelcra/pl-asr-pelcra-for-bigos-secret"]
+
+datasets_public = []
+    #["amu-cai/pl-asr-bigos-synth-med"]
+    #amu-cai/pl-asr-bigos-v2-diagnostic"
+
+st.set_page_config(layout="wide")
+
+about, lead_bigos,  lead_pelcra, analysis, interactive_comparison = st.tabs(["About", "ASR Leaderboard - BIGOS corpora", "ASR Leaderboard - PELCRA corpora", "ASR evaluation scenarios", "Interactive comparison of ASR accuracy"])
+# "Results inspection""Results inspection"
+# inspection
+# acknowledgements, changelog, faq, todos = st.columns(4)
+#lead_bigos_diagnostic, lead_bigos_synth
+
+cols_to_select_all = ["system", "subset", "ref_type", "norm_type", "SER", "MER", "WER", "CER"]
+
+def plot_performance(systems_to_plot, df_per_system_with_type):
+    # Get unique subsets
+    subsets = df_per_system_with_type['subset'].unique()
+
+    # Create a color and label map
+    color_label_map = {
+        free_system_with_best_wer: ('blue', 'Best Free'),
+        free_system_with_worst_wer: ('red', 'Worst Free'),
+        commercial_system_with_best_wer: ('green', 'Best Paid'),
+        commercial_system_with_worst_wer: ('orange', 'Worst Paid')
+    }
+
+    # Plot the data
+    fig, ax = plt.subplots(figsize=(14, 7))
+
+    bar_width = 0.3
+    index = np.arange(len(subsets))
+
+    for i, system in enumerate(systems_to_plot):
+        subset_wer = df_per_system_with_type[df_per_system_with_type['system'] == system].set_index('subset')['WER']
+        color, label = color_label_map[system]
+        ax.bar(index + i * bar_width, subset_wer.loc[subsets], bar_width, label=label + ' - ' + system, color=color)
+
+    # Adding labels and title
+    ax.set_xlabel('Subset')
+    ax.set_ylabel('WER (%)')
+    ax.set_title('Comparison of performance of ASR systems.')
+    ax.set_xticks(index + bar_width * 1.5)
+    ax.set_xticklabels(subsets, rotation=90, ha='right')
+    ax.legend()
+
+    st.pyplot(fig)
+
+def round_to_nearest(value, multiple):
+    return multiple * round(value / multiple)
+
+def create_bar_chart(df, systems, metric, norm_type, ref_type='orig', orientation='vertical'):
+    df = df[df['norm_type'] == norm_type]
+    df = df[df['ref_type'] == ref_type]
+
+    # Prepare the data for the bar chart
+    subsets = df['subset'].unique()
+    num_vars = len(subsets)
+    bar_width = 0.2  # Width of the bars
+
+    fig, ax = plt.subplots(figsize=(10, 10))
+    
+    max_value_all_systems = 0
+    for i, system in enumerate(systems):
+        system_data = df[df['system'] == system]
+        max_value_for_system = max(system_data[metric])
+        if max_value_for_system > max_value_all_systems:
+            max_value_all_systems = round_to_nearest(max_value_for_system + 2, 10)
+        
+        # Ensure the system data is in the same order as subsets
+        values = []
+        for subset in subsets:
+            subset_value = system_data[system_data['subset'] == subset][metric].values
+            if len(subset_value) > 0:
+                values.append(subset_value[0])
+            else:
+                values.append(0)  # Append 0 if the subset value is missing
+        
+        if orientation == 'vertical':
+            # Plot each system's bars with an offset for vertical orientation
+            x_pos = np.arange(len(subsets)) + i * bar_width
+            ax.bar(x_pos, values, bar_width, label=system)
+            # Add value labels
+            for j, value in enumerate(values):
+                ax.text(x_pos[j], value + max(values) * 0.03, f'{value}', ha='center', va='bottom',fontsize=6)
+        else:
+            # Plot each system's bars with an offset for horizontal orientation
+            y_pos = np.arange(len(subsets)) + i * bar_width
+            ax.barh(y_pos, values, bar_width, label=system)
+            # Add value labels
+            for j, value in enumerate(values):
+                ax.text(value + max(values) * 0.03, y_pos[j], f'{value}', ha='left', va='center', fontsize=6)
+    
+    if orientation == 'vertical':
+        ax.set_xticks(np.arange(len(subsets)) + bar_width * (len(systems) - 1) / 2)
+        ax.set_xticklabels(subsets, rotation=45, ha='right')
+        ax.set_ylabel(metric)
+    else:
+        ax.set_yticks(np.arange(len(subsets)) + bar_width * (len(systems) - 1) / 2)
+        ax.set_yticklabels(subsets)
+        ax.set_xlabel(metric)
+    
+    # Add grid values for the vertical and horizontal bar plots
+    if orientation == 'vertical':
+        ax.set_yticks(np.linspace(0, max_value_all_systems, 5))
+    else:
+        ax.set_xticks(np.linspace(0, max_value_all_systems, 5))
+    
+    # Put legend on the right side outside of the plot
+    plt.legend(loc='upper right', bbox_to_anchor=(1.2, 1), shadow=True, ncol=1)
+
+    st.pyplot(fig)
+
+def create_radar_plot(df, enable_labels, systems, metric, norm_type, ref_type='orig'):
+
+    df = df[df['norm_type'] == norm_type]
+    df = df[df['ref_type'] == ref_type]
+
+    # Prepare the data for the radar plot
+    #systems = df['system'].unique()
+    subsets = df['subset'].unique()
+    num_vars = len(subsets)
+    
+    angles = np.linspace(0, 2 * np.pi, num_vars, endpoint=False).tolist()
+    angles += angles[:1]  # Complete the loop
+    
+    fig, ax = plt.subplots(figsize=(10, 10), subplot_kw=dict(polar=True))
+    
+    max_value_all_systems = 0
+    for system in systems:
+        system_data = df[df['system'] == system]
+        max_value_for_system =  max(system_data[metric])
+        if max_value_for_system > max_value_all_systems:
+            max_value_all_systems = round_to_nearest(max_value_for_system + 2, 10)
+        
+        # Ensure the system data is in the same order as subsets
+        values = []
+        for subset in subsets:
+            subset_value = system_data[system_data['subset'] == subset][metric].values
+            if len(subset_value) > 0:
+                values.append(subset_value[0])
+            else:
+                values.append(0)  # Append 0 if the subset value is missing
+        
+        values += values[:1]  # Complete the loop
+        
+        # Plot each system
+        ax.plot(angles, values, label=system)
+        ax.fill(angles, values, alpha=0.25)
+        
+        # Add value labels
+        for angle, value in zip(angles, values):
+            ax.text(angle, value + max(values) * 0.01, f'{value}', ha='center', va='center', fontsize=6)
+    
+    ax.set_xticklabels(subsets)
+
+    ax.set_yticks(np.linspace(0, max_value_all_systems, 5))
+    
+    # put legend at the bottom of the page
+    plt.legend(loc='upper right', bbox_to_anchor=(1.2, 1), shadow=True, ncol=1)
+
+    st.pyplot(fig)
+
+with about:
+    st.title("About BIGOS benchmark")
+    st.markdown(ABOUT_INFO, unsafe_allow_html=True)
+    # TODO - load and display about BIGOS benchmark
+
+    # Table - evaluated systems # TODO - change to concatenated table
+    st.header("Evaluated ASR systems")
+    dataset = "amu-cai/pl-asr-bigos-v2-secret"
+    split = "test"
+    df_per_sample, df_per_dataset = read_latest_results(dataset, split, codename_to_shortname_mapping=None)
+    evaluated_systems_list = df_per_sample["system"].unique()
+    #print("ASR systems available in the eval results for dataset {}: ".format(dataset), evaluated_systems_list )
+    
+    df_evaluated_systems = retrieve_asr_systems_meta_from_the_catalog(evaluated_systems_list)
+    codename_to_shortname_mapping = dict(zip(df_evaluated_systems["Codename"],df_evaluated_systems["Shortname"]))
+    #print(codename_to_shortname_mapping)
+
+    h_df_systems = calculate_height_to_display(df_evaluated_systems)
+
+    df_evaluated_systems_types_and_count = df_evaluated_systems["Type"].value_counts().reset_index()
+    df_evaluated_systems_types_and_count.columns = ["Type", "Count"]
+    st.write("Evaluated ASR systems types")
+
+    st.dataframe(df_evaluated_systems_types_and_count, hide_index=True, use_container_width=False)
+    
+    st.write("Evaluated ASR systems details")
+
+    #TODO - add info who created the system (company, institution, team, etc.)
+    st.dataframe(df_evaluated_systems, hide_index=True, height = h_df_systems, use_container_width=True)
+
+    # Table - evaluation datasets
+    # Table - evaluation metrics
+    # Table - evaluation metadata
+    # List - references
+    # List - contact points     
+    # List - acknowledgements
+    # List - changelog
+    # List - FAQ
+    # List - TODOs
+
+with lead_bigos:
+
+    # configuration for tab
+    dataset = "amu-cai/pl-asr-bigos-v2-secret"
+    dataset_short_name = "BIGOS"
+    dataset_version = "V2"
+    eval_date = "March 2024"
+    split = "test"
+    norm_type = "all"
+    ref_type = "orig"
+    
+    # common, reusable part for all tabs presenting leaderboards for specific datasets
+    #### DATA LOADING AND AUGMENTATION ####
+    df_per_sample_all, df_per_dataset_all = read_latest_results(dataset, split, codename_to_shortname_mapping)
+    
+    
+    # filter only the ref_type and norm_type we want to analyze
+    df_per_sample = df_per_sample_all[(df_per_sample_all["ref_type"] == ref_type) & (df_per_sample_all["norm_type"] == norm_type)]
+    # filter only the ref_type and norm_type we want to analyze
+    df_per_dataset = df_per_dataset_all[(df_per_dataset_all["ref_type"] == ref_type) & (df_per_dataset_all["norm_type"] == norm_type)]
+
+    ##### PARAMETERS CALCULATION ####
+    evaluated_systems_list = df_per_sample["system"].unique()
+    no_of_evaluated_systems = len(evaluated_systems_list)
+    no_of_eval_subsets = len(df_per_dataset["subset"].unique())
+    no_of_test_cases = len(df_per_sample)
+    no_of_unique_recordings = len(df_per_sample["id"].unique())
+    total_audio_duration_hours = get_total_audio_duration(df_per_sample)
+    no_of_unique_speakers = len(df_per_sample["speaker_id"].unique())
+
+    df_per_dataset_with_asr_systems_meta = pd.merge(df_per_dataset, df_evaluated_systems, how="left", left_on="system", right_on="Shortname")
+          
+    ########### EVALUATION PARAMETERS PRESENTATION ################
+    st.title("Leaderboard for {} {}".format(dataset_short_name, dataset_version))
+    st.markdown(BIGOS_INFO, unsafe_allow_html=True)
+    st.markdown("**Evaluation date:** {}".format(eval_date))
+    st.markdown("**Number of evaluated system-model variants:** {}".format(no_of_evaluated_systems))
+    st.markdown("**Number of evaluated subsets:** {}".format(no_of_eval_subsets))
+    st.markdown("**Number of evaluated system-model-subsets combinations**: {}".format(len(df_per_dataset)))
+    st.markdown("**Number of unique speakers**: {}".format(no_of_unique_speakers))
+    st.markdown("**Number of unique recordings used for evaluation:** {}".format(no_of_unique_recordings))
+    st.markdown("**Total size of the dataset:** {:.2f} hours".format(total_audio_duration_hours))
+    st.markdown("**Total number of test cases (audio-hypothesis pairs):** {}".format(no_of_test_cases))
+    st.markdown("**Dataset:** {}".format(dataset))
+    st.markdown("**Dataset version:** {}".format(dataset_version))
+    st.markdown("**Split:** {}".format(split))
+    st.markdown("**Text reference type:** {}".format(ref_type))
+    st.markdown("**Normalization steps:** {}".format(norm_type))
+
+    ########### RESULTS ################    
+    st.header("WER (Word Error Rate) analysis")
+    st.subheader("Average WER for the whole dataset")
+    df_wer_avg = basic_stats_per_dimension(df_per_dataset, "WER", "dataset")
+    st.dataframe(df_wer_avg)
+
+    st.subheader("Comparison of average WER for free and commercial systems")
+    df_wer_avg_free_commercial = basic_stats_per_dimension(df_per_dataset_with_asr_systems_meta, "WER", "Type")
+    st.dataframe(df_wer_avg_free_commercial)
+
+
+    ##################### PER SYSTEM ANALYSIS ######################### 
+    analysis_dim = "system"
+    metric = "WER"
+    st.subheader("Table showing {} per {} sorted by median values".format(metric, analysis_dim))
+    df_wer_per_system_from_per_dataset = basic_stats_per_dimension(df_per_dataset, metric, analysis_dim)
+    h_df_per_system_per_dataset = calculate_height_to_display(df_wer_per_system_from_per_dataset)
+    st.dataframe(df_wer_per_system_from_per_dataset, height = h_df_per_system_per_dataset )
+
+    st.subheader("Boxplot showing {} per {} sorted by median values".format(metric, analysis_dim))
+    fig = box_plot_per_dimension(df_per_dataset, metric, analysis_dim, "{} per {}".format(metric, analysis_dim), analysis_dim, metric + "[%]")
+    st.pyplot(fig, clear_figure=True, use_container_width=True)
+
+    ##################### PER SUBSET ANALYSIS ######################### 
+    analysis_dim = "subset"
+    metric = "WER"
+    st.subheader("Table showing {} per {} sorted by median values".format(metric, analysis_dim))
+    df_wer_per_system_from_per_dataset = basic_stats_per_dimension(df_per_dataset, metric, analysis_dim)
+    h_df_per_system_per_dataset = calculate_height_to_display(df_wer_per_system_from_per_dataset)
+    st.dataframe(df_wer_per_system_from_per_dataset, height = h_df_per_system_per_dataset )
+
+    st.subheader("Boxplot showing {} per {} sorted by median values".format(metric, analysis_dim))
+    fig = box_plot_per_dimension(df_per_dataset, metric, analysis_dim, "{} per {}".format(metric, analysis_dim), analysis_dim, metric + "[%]")
+    st.pyplot(fig, clear_figure=True, use_container_width=True)
+
+    ### IMPACT OF NORMALIZATION ON ERROR RATES ##### 
+    # Calculate the average impact of various norm_types for all datasets and systems
+    df_per_dataset_selected_cols = df_per_dataset_all[cols_to_select_all]
+    diff_in_metrics = check_impact_of_normalization(df_per_dataset_selected_cols)
+    st.subheader("Impact of normalization of references and hypothesis on evaluation metrics")
+    st.dataframe(diff_in_metrics, use_container_width=False)
+
+  # Visualizing the differences in metrics graphically with data labels
+    # Visualizing the differences in metrics graphically with data labels
+    fig, axs = plt.subplots(3, 2, figsize=(12, 12))
+    fig.subplots_adjust(hspace=0.6, wspace=0.6)
+
+    #remove the sixth subplot
+    fig.delaxes(axs[2,1])
+
+    metrics = ['SER', 'WER', 'MER', 'CER', "Average"]
+    colors = ['blue', 'orange', 'green', 'red', 'purple']
+
+    for ax, metric, color in zip(axs.flatten(), metrics, colors):
+        bars = ax.bar(diff_in_metrics.index, diff_in_metrics[metric], color=color)
+        ax.set_title(f'Normalization impact on {metric}')
+        if metric == 'Average':
+            ax.set_title('Average normalization impact on all metrics')
+        ax.set_xlabel('Normalization Type')
+        ax.set_ylabel(f'Difference in {metric}')
+        ax.grid(True)
+        ax.set_xticklabels(diff_in_metrics.index, rotation=45, ha='right')
+        min_val = diff_in_metrics[metric].min()
+        ax.set_ylim([min_val * 1.1, diff_in_metrics[metric].max() * 1.1])
+   
+        for bar in bars:
+            height = bar.get_height()
+            ax.annotate(f'{height:.2f}',
+                        xy=(bar.get_x() + bar.get_width() / 2, height),
+                        xytext=(0, -12),  # 3 points vertical offset
+                        textcoords="offset points",
+                        ha='center', va='bottom')
+
+
+    # Display the plot in Streamlit
+    st.pyplot(fig)
+
+    ##################### APPENDIX #########################       
+    st.header("Appendix - Full evaluation results per subset for all evaluated systems")
+    # select only the columns we want to plot
+    st.dataframe(df_per_dataset_selected_cols, hide_index=True, use_container_width=False)
+
+with lead_pelcra:
+    st.title("PELCRA Leaderboard")
+    st.markdown(PELCRA_INFO, unsafe_allow_html=True)
+
+    # configuration for tab
+    dataset = "pelcra/pl-asr-pelcra-for-bigos-secret"
+    dataset_short_name = "PELCRA"
+    dataset_version = "V1"
+    eval_date = "March 2024"
+    split = "test"
+    norm_type = "all"
+    ref_type = "orig"
+    
+     # common, reusable part for all tabs presenting leaderboards for specific datasets
+    #### DATA LOADING AND AUGMENTATION ####
+    df_per_sample_all, df_per_dataset_all = read_latest_results(dataset, split, codename_to_shortname_mapping)
+    
+    
+    # filter only the ref_type and norm_type we want to analyze
+    df_per_sample = df_per_sample_all[(df_per_sample_all["ref_type"] == ref_type) & (df_per_sample_all["norm_type"] == norm_type)]
+    # filter only the ref_type and norm_type we want to analyze
+    df_per_dataset = df_per_dataset_all[(df_per_dataset_all["ref_type"] == ref_type) & (df_per_dataset_all["norm_type"] == norm_type)]
+
+    ##### PARAMETERS CALCULATION ####
+    evaluated_systems_list = df_per_sample["system"].unique()
+    no_of_evaluated_systems = len(evaluated_systems_list)
+    no_of_eval_subsets = len(df_per_dataset["subset"].unique())
+    no_of_test_cases = len(df_per_sample)
+    no_of_unique_recordings = len(df_per_sample["id"].unique())
+    total_audio_duration_hours = get_total_audio_duration(df_per_sample)
+    no_of_unique_speakers = len(df_per_sample["speaker_id"].unique())
+
+    df_per_dataset_with_asr_systems_meta = pd.merge(df_per_dataset, df_evaluated_systems, how="left", left_on="system", right_on="Shortname")
+          
+    ########### EVALUATION PARAMETERS PRESENTATION ################
+    st.title("Leaderboard for {} {}".format(dataset_short_name, dataset_version))
+    st.markdown(BIGOS_INFO, unsafe_allow_html=True)
+    st.markdown("**Evaluation date:** {}".format(eval_date))
+    st.markdown("**Number of evaluated system-model variants:** {}".format(no_of_evaluated_systems))
+    st.markdown("**Number of evaluated subsets:** {}".format(no_of_eval_subsets))
+    st.markdown("**Number of evaluated system-model-subsets combinations**: {}".format(len(df_per_dataset)))
+    st.markdown("**Number of unique speakers**: {}".format(no_of_unique_speakers))
+    st.markdown("**Number of unique recordings used for evaluation:** {}".format(no_of_unique_recordings))
+    st.markdown("**Total size of the dataset:** {:.2f} hours".format(total_audio_duration_hours))
+    st.markdown("**Total number of test cases (audio-hypothesis pairs):** {}".format(no_of_test_cases))
+    st.markdown("**Dataset:** {}".format(dataset))
+    st.markdown("**Dataset version:** {}".format(dataset_version))
+    st.markdown("**Split:** {}".format(split))
+    st.markdown("**Text reference type:** {}".format(ref_type))
+    st.markdown("**Normalization steps:** {}".format(norm_type))
+
+    ########### RESULTS ################
+    st.header("WER (Word Error Rate) analysis")
+    st.subheader("Average WER for the whole dataset")
+    df_wer_avg = basic_stats_per_dimension(df_per_dataset, "WER", "dataset")
+    st.dataframe(df_wer_avg)
+
+    st.subheader("Comparison of average WER for free and commercial systems")
+    df_wer_avg_free_commercial = basic_stats_per_dimension(df_per_dataset_with_asr_systems_meta, "WER", "Type")
+    st.dataframe(df_wer_avg_free_commercial)
+
+    ##################### PER SYSTEM ANALYSIS ######################### 
+    analysis_dim = "system"
+    metric = "WER"
+    st.subheader("Table showing {} per {} sorted by median values".format(metric, analysis_dim))
+    df_wer_per_system_from_per_dataset = basic_stats_per_dimension(df_per_dataset, metric, analysis_dim)
+    h_df_per_system_per_dataset = calculate_height_to_display(df_wer_per_system_from_per_dataset)
+    st.dataframe(df_wer_per_system_from_per_dataset, height = h_df_per_system_per_dataset )
+
+    st.subheader("Boxplot showing {} per {} sorted by median values".format(metric, analysis_dim))
+    fig = box_plot_per_dimension(df_per_dataset, metric, analysis_dim, "{} per {}".format(metric, analysis_dim), analysis_dim, metric + "[%]")
+    st.pyplot(fig, clear_figure=True, use_container_width=True)
+
+    ##################### PER SUBSET ANALYSIS ######################### 
+    analysis_dim = "subset"
+    metric = "WER"
+    st.subheader("Table showing {} per {} sorted by median values".format(metric, analysis_dim))
+    df_wer_per_system_from_per_dataset = basic_stats_per_dimension(df_per_dataset, metric, analysis_dim)
+    h_df_per_system_per_dataset = calculate_height_to_display(df_wer_per_system_from_per_dataset)
+    st.dataframe(df_wer_per_system_from_per_dataset, height = h_df_per_system_per_dataset )
+
+    st.subheader("Boxplot showing {} per {} sorted by median values".format(metric, analysis_dim))
+    fig = box_plot_per_dimension(df_per_dataset, metric, analysis_dim, "{} per {}".format(metric, analysis_dim), analysis_dim, metric + "[%]")
+    st.pyplot(fig, clear_figure=True, use_container_width=True)
+
+    ### IMPACT OF NORMALIZATION ON ERROR RATES ##### 
+    # Calculate the average impact of various norm_types for all datasets and systems
+    df_per_dataset_selected_cols = df_per_dataset_all[cols_to_select_all]
+    diff_in_metrics = check_impact_of_normalization(df_per_dataset_selected_cols)
+    st.subheader("Impact of normalization on WER")
+    st.dataframe(diff_in_metrics, use_container_width=False)
+    
+    # Visualizing the differences in metrics graphically with data labels
+    # Visualizing the differences in metrics graphically with data labels
+    fig, axs = plt.subplots(3, 2, figsize=(12, 12))
+    fig.subplots_adjust(hspace=0.6, wspace=0.6)
+
+    #remove the sixth subplot
+    fig.delaxes(axs[2,1])
+
+    metrics = ['SER', 'WER', 'MER', 'CER', "Average"]
+    colors = ['blue', 'orange', 'green', 'red', 'purple']
+
+    for ax, metric, color in zip(axs.flatten(), metrics, colors):
+            bars = ax.bar(diff_in_metrics.index, diff_in_metrics[metric], color=color)
+            ax.set_title(f'Normalization impact on {metric}')
+            if metric == 'Average':
+                ax.set_title('Average normalization impact on all metrics')
+            ax.set_xlabel('Normalization Type')
+            ax.set_ylabel(f'Difference in {metric}')
+            ax.grid(True)
+            ax.set_xticklabels(diff_in_metrics.index, rotation=45, ha='right')
+            min_val = diff_in_metrics[metric].min()
+            ax.set_ylim([min_val * 1.1, diff_in_metrics[metric].max() * 1.1])
+    
+            for bar in bars:
+                height = bar.get_height()
+                ax.annotate(f'{height:.2f}',
+                            xy=(bar.get_x() + bar.get_width() / 2, height),
+                            xytext=(0, -12),  # 3 points vertical offset
+                            textcoords="offset points",
+                            ha='center', va='bottom')
+
+    # Display the plot in Streamlit
+    st.pyplot(fig)
+
+    ##################### APPENDIX #########################       
+    st.header("Appendix - Full evaluation results per subset for all evaluated systems")
+    # select only the columns we want to plot
+    df_per_dataset_selected_cols = df_per_dataset_all[cols_to_select_all]   
+    st.dataframe(df_per_dataset_selected_cols, hide_index=True, use_container_width=False)
+
+with analysis:
+    datasets = datasets_secret + datasets_public
+  
+    dataset = st.selectbox("Select Dataset", datasets, index=datasets.index('amu-cai/pl-asr-bigos-v2-secret'),  key="select_dataset_scenarios")
+
+    # read the latest results for the selected dataset
+    print("Reading the latest results for dataset: ", dataset)
+    df_per_sample_all, df_per_dataset_all = read_latest_results(dataset, split, codename_to_shortname_mapping)
+    # filter only the ref_type and norm_type we want to analyze
+    df_per_sample = df_per_sample_all[(df_per_sample_all["ref_type"] == ref_type) & (df_per_sample_all["norm_type"] == norm_type)]
+    # filter only the ref_type and norm_type we want to analyze
+    df_per_dataset = df_per_dataset_all[(df_per_dataset_all["ref_type"] == ref_type) & (df_per_dataset_all["norm_type"] == norm_type)]
+
+    evaluated_systems_list = df_per_sample["system"].unique()
+    print(evaluated_systems_list)
+    df_evaluated_systems = retrieve_asr_systems_meta_from_the_catalog(evaluated_systems_list)
+    print(df_evaluated_systems)
+
+
+    ##### ANALYSIS - COMMERCIAL VS FREE SYSTEMS #####
+    # Generate dataframe with columns as follows System Type Subset Avg_WER
+    df_per_dataset_with_asr_systems_meta = pd.merge(df_per_dataset, df_evaluated_systems, how="left", left_on="system", right_on="Shortname")
+
+    df_wer_avg_per_system_all_subsets_with_type = df_per_dataset_with_asr_systems_meta.groupby(['system', 'Type', 'subset'])['WER'].mean().reset_index()
+    print(df_wer_avg_per_system_all_subsets_with_type)
+
+    # Select the best and worse system for free and commercial systems
+    free_systems = df_wer_avg_per_system_all_subsets_with_type[df_wer_avg_per_system_all_subsets_with_type['Type'] == 'free']['system'].unique()
+    commercial_systems = df_wer_avg_per_system_all_subsets_with_type[df_wer_avg_per_system_all_subsets_with_type['Type'] == 'commercial']['system'].unique()
+    free_system_with_best_wer = df_wer_avg_per_system_all_subsets_with_type[df_wer_avg_per_system_all_subsets_with_type['system'].isin(free_systems)].groupby('system')['WER'].mean().idxmin()
+    free_system_with_worst_wer = df_wer_avg_per_system_all_subsets_with_type[df_wer_avg_per_system_all_subsets_with_type['system'].isin(free_systems)].groupby('system')['WER'].mean().idxmax()
+    commercial_system_with_best_wer = df_wer_avg_per_system_all_subsets_with_type[df_wer_avg_per_system_all_subsets_with_type['system'].isin(commercial_systems)].groupby('system')['WER'].mean().idxmin()
+    commercial_system_with_worst_wer = df_wer_avg_per_system_all_subsets_with_type[df_wer_avg_per_system_all_subsets_with_type['system'].isin(commercial_systems)].groupby('system')['WER'].mean().idxmax()
+    
+    #print(f"Best free system: {free_system_with_best_wer}")
+    #print(f"Worst free system: {free_system_with_worst_wer}")
+    #print(f"Best commercial system: {commercial_system_with_best_wer}")
+    #print(f"Worst commercial system: {commercial_system_with_worst_wer}")
+
+    st.subheader("Comparison of WER for free and commercial systems")
+    # Best and worst system for free and commercial systems - print table
+    header = ["Type", "Best System", "Worst System"]
+    data = [
+        ["Free", free_system_with_best_wer, free_system_with_worst_wer],
+        ["Commercial", commercial_system_with_best_wer, commercial_system_with_worst_wer]
+    ]
+
+    st.subheader("Best and worst systems for dataset {}".format(dataset))
+    df_best_worse_systems = pd.DataFrame(data, columns=header)
+    # do not display index
+    st.dataframe(df_best_worse_systems)
+    
+    st.subheader("Comparison of average WER for best systems")
+    df_per_dataset_best_systems = df_per_dataset_with_asr_systems_meta[df_per_dataset_with_asr_systems_meta['system'].isin([free_system_with_best_wer, commercial_system_with_best_wer])]
+    df_wer_avg_best_free_commercial = basic_stats_per_dimension(df_per_dataset_best_systems, "WER", "Type")
+    st.dataframe(df_wer_avg_best_free_commercial)
+
+    # Create lookup table to get system type based on its name
+    #system_type_lookup = dict(zip(df_wer_avg_per_system_all_subsets_with_type['system'], df_wer_avg_per_system_all_subsets_with_type['Type']))
+
+    systems_to_plot_best= [free_system_with_best_wer, commercial_system_with_best_wer]
+    plot_performance(systems_to_plot_best, df_wer_avg_per_system_all_subsets_with_type)
+
+    st.subheader("Comparison of average WER for the worst systems")
+    df_per_dataset_worst_systems = df_per_dataset_with_asr_systems_meta[df_per_dataset_with_asr_systems_meta['system'].isin([free_system_with_worst_wer, commercial_system_with_worst_wer])]
+    df_wer_avg_worst_free_commercial = basic_stats_per_dimension(df_per_dataset_worst_systems, "WER", "Type")
+    st.dataframe(df_wer_avg_worst_free_commercial)  
+
+    systems_to_plot_worst=[free_system_with_worst_wer, commercial_system_with_worst_wer]
+    plot_performance(systems_to_plot_worst, df_wer_avg_per_system_all_subsets_with_type)
+
+    # WER in function of model size
+    st.subheader("WER in function of model size for dataset {}".format(dataset))
+
+    # select only free systems for the analysis from df_wer_avg_per_system_all_subsets_with_type dataframe
+    free_systems_wer_per_subset = df_per_dataset_with_asr_systems_meta.groupby(['system', 'Parameters [M]', 'subset'])['WER'].mean().reset_index()
+    # sort by model size
+    # change column type Parameters [M] to integer
+    free_systems_wer_per_subset['Parameters [M]'] = free_systems_wer_per_subset['Parameters [M]'].astype(int)
+
+    free_systems_wer_per_subset = free_systems_wer_per_subset.sort_values(by='Parameters [M]')
+
+    free_systems_wer_average_across_all_subsets = free_systems_wer_per_subset.groupby(['system', 'Parameters [M]'])['WER'].mean().reset_index()
+    # change column type Parameters [M] to integer
+    free_systems_wer_average_across_all_subsets['Parameters [M]'] = free_systems_wer_average_across_all_subsets['Parameters [M]'].astype(int)
+
+    # sort by model size
+    free_systems_wer_average_across_all_subsets = free_systems_wer_average_across_all_subsets.sort_values(by='Parameters [M]')
+
+    free_systems_wer = free_systems_wer_average_across_all_subsets
+    
+    # use system name as index
+    free_systems_wer_to_show = free_systems_wer.set_index('system')
+
+    # sort by WER and round WER by value to 2 decimal places
+    free_systems_wer_to_show = free_systems_wer_to_show.sort_values(by='WER').round({'WER': 2})
+    
+    # print dataframe in streamlit with average WER, system name and model size
+    st.dataframe(free_systems_wer_to_show)
+
+    # plot scatter plot with values of WER
+    # X axis is the model size (parameters [M])
+    # Y is thw average WER
+    # make each point a different color 
+    # provide legend with system names
+    fig, ax = plt.subplots()
+    for system in free_systems_wer['system'].unique():
+        subset = free_systems_wer[free_systems_wer['system'] == system]
+        ax.scatter(subset['Parameters [M]'], subset['WER'], label=system)
+        # Add text annotation for each point
+        for i, point in subset.iterrows():
+            ax.annotate(point['system'], (point['Parameters [M]'], point['WER']), textcoords="offset points", xytext=(-10,-10), ha='left', rotation=-30, fontsize=5)
+    ax.set_xlabel('Model Size [M]')
+    ax.set_ylabel('WER (%)')
+    ax.set_title('WER in function of model size')
+    # decrease font size of the legend and place it outside the plot
+    ax.legend(title='System', bbox_to_anchor=(1.05, 1), loc='upper left')
+
+    st.pyplot(fig)
+
+    ##################################################################################################################################################
+    # WER per audio duration
+        
+    # calculate average WER per audio duration bucket for the best and worse commercial and free systems
+    selected_systems = [free_system_with_best_wer, commercial_system_with_best_wer]
+    
+    # filter out results for selected systems
+    df_per_sample_selected_systems = df_per_sample[df_per_sample['system'].isin(selected_systems)]
+    
+    # calculate average WER per audio duration for the best system
+    # add column with audio duration in seconds rounded to nearest integer value.
+    audio_duration_buckets = [1,2,3,4,5,10,15,20,30,40,50,60]
+    # map audio duration to the closest bucket
+    df_per_sample_selected_systems['audio_duration_buckets'] = df_per_sample_selected_systems['audio_duration'].apply(lambda x: min(audio_duration_buckets, key=lambda y: abs(x-y)))
+
+
+    # calculate average WER per audio duration bucket
+    df_per_sample_wer_audio = df_per_sample_selected_systems.groupby(['system', 'audio_duration_buckets'])['WER'].mean().reset_index()
+    # add column with number of samples for specific audio bucket size
+    df_per_sample_wer_audio['number_of_samples'] = df_per_sample_selected_systems.groupby(['system', 'audio_duration_buckets'])['WER'].count().values
+
+    df_per_sample_wer_audio = df_per_sample_wer_audio.sort_values(by='audio_duration_buckets')
+    # round values in WER column in df_per_sample_wer to 2 decimal places
+    df_per_sample_wer_audio['WER'].round(2)
+    # transform df_per_sample_wer. Use system values as columns, while audio_duration_buckets as main index
+    df_per_sample_wer_audio_pivot = df_per_sample_wer_audio.pivot(index='audio_duration_buckets', columns='system', values='WER')
+    df_per_sample_wer_audio_pivot = df_per_sample_wer_audio_pivot.round(2)
+    
+    df_per_sample_wer_audio_pivot['number_of_samples'] = df_per_sample_wer_audio[df_per_sample_wer_audio['system']==free_system_with_best_wer].groupby('audio_duration_buckets')['number_of_samples'].sum().values
+    
+    # put number_of_samples as the first column after index
+    df_per_sample_wer_audio_pivot = df_per_sample_wer_audio_pivot[['number_of_samples'] + [col for col in df_per_sample_wer_audio_pivot.columns if col != 'number_of_samples']]
+
+    # print dataframe in streamlit
+    st.dataframe(df_per_sample_wer_audio_pivot)
+
+    # plot scatter plot with values from df_per_sample_wer_pivot. 
+    # each system should have a different color
+    # the size of the point should be proportional to the number of samples in the bucket
+    # the x axis should be the audio duration bucket
+    # the y axis should be the average WER
+    fig, ax = plt.subplots()
+    for system in selected_systems:
+        subset = df_per_sample_wer_audio[df_per_sample_wer_audio['system'] == system]
+        ax.scatter(subset['audio_duration_buckets'], subset['WER'], label=system, s=subset['number_of_samples']*0.5)
+    ax.set_xlabel('Audio Duration [s]')
+    ax.set_ylabel('WER (%)')
+    ax.set_title('WER in function of audio duration.')
+
+    # place legend outside the plot on the right
+    ax.legend(title='System', bbox_to_anchor=(1.05, 1), loc='upper left')
+    st.pyplot(fig)
+
+    ##################################################################################################################################################
+    # WER per speech rate
+
+    
+    # speech rate chars unique values
+    audio_feature_to_analyze = 'speech_rate_words'
+    audio_feature_unit = ' [words/s]'
+    metric = 'WER'
+    metric_unit = ' [%]'
+    no_of_buckets = 10
+    # calculate average WER per audio duration bucket for the best and worse commercial and free systems
+    selected_systems = [free_system_with_best_wer, commercial_system_with_best_wer]
+
+    df_per_sample_wer_feature_pivot, df_per_sample_wer_feature = calculate_wer_per_audio_feature(df_per_sample, selected_systems, audio_feature_to_analyze, metric, no_of_buckets)
+
+    # print dataframe in streamlit
+    st.dataframe(df_per_sample_wer_feature_pivot)
+
+    # plot scatter plot with values from df_per_sample_wer_pivot. 
+    # each system should have a different color
+    # the size of the point should be proportional to the number of samples in the bucket
+    # the x axis should be the audio duration bucket
+    # the y axis should be the average WER
+    fig, ax = plt.subplots()
+    for system in selected_systems:
+        subset = df_per_sample_wer_feature[df_per_sample_wer_feature['system'] == system]
+        ax.scatter(subset[audio_feature_to_analyze], subset[metric], label=system, s=subset['number_of_samples']*0.5)
+    ax.set_xlabel(audio_feature_to_analyze.replace('_',' ').capitalize() + audio_feature_unit)
+    ax.set_ylabel(metric  + metric_unit)
+    ax.set_title('WER in function of speech rate.'.format(audio_feature_to_analyze))
+
+    # place legend outside the plot on the right
+    ax.legend(title='System', loc='best')
+    st.pyplot(fig)
+
+
+    ################################################################################################################################################
+    # WER PER GENDER
+
+    #selected_systems = [free_system_with_best_wer, commercial_system_with_best_wer, free_system_with_worst_wer, commercial_system_with_worst_wer]
+    selected_systems = df_per_sample['system'].unique()
+
+    df_per_sample_wer_gender_pivot, df_available_samples_per_category_per_system, no_samples_per_category = calculate_wer_per_meta_category(df_per_sample, selected_systems, 'WER', 'speaker_gender')
+    #print(df_per_sample_wer_gender_pivot)
+    #print(no_samples_per_category)
+
+    # print dataframe in streamlit
+    st.write("Number of samples per category")
+    for system in selected_systems:
+        st.write(f"System: {system}")
+        df_available_samples_per_category = df_available_samples_per_category_per_system[system]
+        st.dataframe(df_available_samples_per_category)
+
+    st.write("Number of samples analyzed per category - {}".format(no_samples_per_category))
+    st.dataframe(df_per_sample_wer_gender_pivot)
+    
+
+    #print(difference_values)
+    #print(selected_systems)
+
+    # create the scatter plot
+    # the x axis should be the systems from selected_systems
+    # the y axis should be the difference from difference_values
+    # each system should have a different color
+    fig, ax = plt.subplots()
+    difference_values = df_per_sample_wer_gender_pivot['Difference'][:-3]
+    selected_systems = df_per_sample_wer_gender_pivot.index[:-3]
+    ax.scatter(difference_values, selected_systems, c=range(len(selected_systems)), cmap='viridis')
+    ax.set_ylabel('ASR System')
+    ax.set_xlabel('Difference in WER across speaker gender')
+    ax.set_title('ASR systems perfomance bias for genders.')
+    # add labels with difference in WER values
+    for i, txt in enumerate(difference_values):
+        ax.annotate(txt, (difference_values[i], selected_systems[i]), fontsize=5, ha='right')
+    st.pyplot(fig)
+    
+    #####################################################################################################################################################################################
+    # WER per age
+    df_per_sample_wer_age_pivot, df_available_samples_per_category_per_system, no_samples_per_category = calculate_wer_per_meta_category(df_per_sample, selected_systems,'WER','speaker_age')
+    #print(df_per_sample_wer_age_pivot)
+    #print(no_samples_per_category)
+
+    # print dataframe in streamlit
+    st.write("Number of samples per category")
+    for system in selected_systems:
+        st.write(f"System: {system}")
+        df_available_samples_per_category = df_available_samples_per_category_per_system[system]
+        st.dataframe(df_available_samples_per_category)
+
+    st.write("Number of samples analyzed per category - {}".format(no_samples_per_category))
+
+    st.write("WER per age")
+    st.dataframe(df_per_sample_wer_age_pivot)
+    
+    # extract columns from df_per_sample_wer_age_pivot for selected_systems (skip  the last 3 values corresponding to median, average and std values)
+
+    #print(selected_systems)
+
+    # create the scatter plot
+    # the x axis should be the systems from selected_systems
+    # the y axis should be the difference from difference_values
+    # each system should have a different color
+    fig, ax = plt.subplots()
+    difference_values = df_per_sample_wer_age_pivot['Std Dev'][:-3]
+    selected_systems = df_per_sample_wer_age_pivot.index[:-3]
+    ax.scatter(difference_values,selected_systems , c=range(len(selected_systems)), cmap='viridis')
+    ax.set_ylabel('ASR System')
+    ax.set_xlabel('Standard Deviation in WER across speaker age')
+    ax.set_title('ASR systems perfomance bias for age groups')
+    # add labels with difference in WER values
+    for i, txt in enumerate(difference_values):
+        ax.annotate(txt, (difference_values[i], selected_systems[i]), fontsize=5, ha='right')
+    st.pyplot(fig)
+
+    # READ vs CONVERSIONAL SPEECH AVERAGE WER
+
+    # Hallucinations rate per system
+
+with interactive_comparison:
+
+
+    
+    st.title("Interactive comparison of ASR Systems performance")
+    st.markdown(COMPARISON_INFO, unsafe_allow_html=True)
+
+    st.title("Plots for analyzing ASR Systems performance")
+    
+    datasets = datasets_secret + datasets_public
+
+    dataset = st.selectbox("Select Dataset", datasets, index=datasets.index('amu-cai/pl-asr-bigos-v2-secret'), key="select_dataset_interactive_comparison")
+
+    # read the latest results for the selected dataset
+    print("Reading the latest results for dataset: ", dataset)
+    df_per_sample_all, df_per_dataset_all = read_latest_results(dataset, split, codename_to_shortname_mapping)
+    # filter only the ref_type and norm_type we want to analyze
+    df_per_sample = df_per_sample_all[(df_per_sample_all["ref_type"] == ref_type) & (df_per_sample_all["norm_type"] == norm_type)]
+    # filter only the ref_type and norm_type we want to analyze
+    df_per_dataset = df_per_dataset_all[(df_per_dataset_all["ref_type"] == ref_type) & (df_per_dataset_all["norm_type"] == norm_type)]
+
+    evaluated_systems_list = df_per_sample["system"].unique()
+    print(evaluated_systems_list)
+    df_evaluated_systems = retrieve_asr_systems_meta_from_the_catalog(evaluated_systems_list)
+    print(df_evaluated_systems)
+
+    # read available options to analyze for specific dataset
+    splits = list(df_per_dataset_all['subset'].unique()) # Get the unique splits
+    norm_types = list(df_per_dataset_all['norm_type'].unique()) # Get the unique norm_types
+    ref_types = list(df_per_dataset_all['ref_type'].unique()) # Get the unique ref_types
+    systems = list(df_per_dataset_all['system'].unique()) # Get the unique systems
+    metrics = list(df_per_dataset_all.columns[7:]) # Get the unique metrics
+
+    # Select the system to display. More than 1 system can be selected.
+    systems_selected = st.multiselect("Select ASR Systems", systems) 
+    
+    # Select the metric to display
+    metric = st.selectbox("Select Metric", metrics, index=metrics.index('WER'))
+
+    # Select the normalization type
+    norm_type = st.selectbox("Select Normalization Type", norm_types, index=norm_types.index('all'))
+    # Select the reference type
+    ref_type = st.selectbox("Select Reference Type", ref_types, index=ref_types.index('orig'))
+
+    enable_labels = st.checkbox("Enable labels on radar plot", value=True)
+
+    enable_bar_chart = st.checkbox("Enable bar chart", value=True)
+    enable_polar_plot = st.checkbox("Enable radar plot", value=True)
+
+    orientation = st.selectbox("Select orientation", ["vertical", "horizontal"], index=0)
+
+    if enable_polar_plot:
+        if metric:
+            if systems_selected:
+                create_radar_plot(df_per_dataset_all, enable_labels, systems_selected, metric, norm_type, ref_type)
+
+    if enable_bar_chart:
+        if metric:
+            if systems_selected:
+                create_bar_chart(df_per_dataset_all, systems_selected , metric, norm_type, ref_type, orientation)

app_utils.py

@@ -0,0 +1,98 @@
+import pandas as pd
+import streamlit as st
+
+from pandas.api.types import (
+    is_categorical_dtype,
+    is_datetime64_any_dtype,
+    is_numeric_dtype,
+    is_object_dtype,
+)
+
+def calculate_height_to_display(df):
+    # Calculate the height of the DataFrame display area
+    num_rows = df.shape[0]
+    row_height = 35  # Estimate of row height in pixels, adjust based on your layout/theme
+    header_height = 35  # Estimate of header height in pixels
+    calculated_height = num_rows * row_height + header_height
+
+    return calculated_height
+
+def filter_dataframe(df: pd.DataFrame, target) -> pd.DataFrame:
+    """
+    Adds a UI on top of a dataframe to let viewers filter columns
+
+    Args:
+        df (pd.DataFrame): Original dataframe
+
+    Returns:
+        pd.DataFrame: Filtered dataframe
+    """
+    if(target == "datasets"):
+        modify = st.checkbox("Enable filters to browse ASR speech data catalog")
+    elif(target == "benchmarks"):
+        modify = st.checkbox("Enable filters to browse ASR benchmarks catalog")
+    else:
+        print("Invalid target")
+
+    if not modify:
+        return df
+
+    df = df.copy()
+
+    # Try to convert datetimes into a standard format (datetime, no timezone)
+    for col in df.columns:
+        if is_object_dtype(df[col]):
+            try:
+                df[col] = pd.to_datetime(df[col])
+            except Exception:
+                pass
+
+        if is_datetime64_any_dtype(df[col]):
+            df[col] = df[col].dt.tz_localize(None)
+
+    modification_container = st.container()
+
+    with modification_container:
+        to_filter_columns = st.multiselect("Filter dataframe on", df.columns)
+        for column in to_filter_columns:
+            left, right = st.columns((1, 20))
+            # Treat columns with < 10 unique values as categorical
+            if is_categorical_dtype(df[column]) or df[column].nunique() < 10:
+                user_cat_input = right.multiselect(
+                    f"Values for {column}",
+                    df[column].unique(),
+                    default=list(df[column].unique()),
+                )
+                df = df[df[column].isin(user_cat_input)]
+            elif is_numeric_dtype(df[column]):
+                _min = float(df[column].min())
+                _max = float(df[column].max())
+                step = (_max - _min) / 100
+                user_num_input = right.slider(
+                    f"Values for {column}",
+                    min_value=_min,
+                    max_value=_max,
+                    value=(_min, _max),
+                    step=step,
+                )
+                df = df[df[column].between(*user_num_input)]
+            elif is_datetime64_any_dtype(df[column]):
+                user_date_input = right.date_input(
+                    f"Values for {column}",
+                    value=(
+                        df[column].min(),
+                        df[column].max(),
+                    ),
+                )
+                if len(user_date_input) == 2:
+                    user_date_input = tuple(map(pd.to_datetime, user_date_input))
+                    start_date, end_date = user_date_input
+                    df = df.loc[df[column].between(start_date, end_date)]
+            else:
+                user_text_input = right.text_input(
+                    f"Substring or regex in {column}",
+                )
+                if user_text_input:
+                    df = df[df[column].astype(str).str.contains(user_text_input)]
+
+    return df

constants.py

@@ -0,0 +1,15 @@
+ABOUT_INFO = "BIGOS (Benchmark Intended Grouping of Open Speech) represents the most extensive evaluation of Polish ASR (Automatic Speech Recognition) systems to date.<br> \
+\This benchmark is a collaborative effort by the [AMU-CAI team](https://huggingface.co/amu-cai), aimed at providing a thorough and comprehensive assessment of various Polish ASR systems."
+ 
+
+BIGOS_INFO = "BIGOS (Benchmark Intended Grouping of Open Speech) is the collection of freely available speech datasets curated by the [AMU-CAI team](https://huggingface.co/amu-cai). \
+More details can be found [here](https://huggingface.co/datasets/amu-cai/pl-asr-bigos-v2)"
+
+PELCRA_INFO = "PELCRA for BIGOS is the subset of speech corpora created by the [PELCRA group](http://pelcra.pl/new/), curated for the BIGOS benchmark by the [AMU-CAI team](https://huggingface.co/amu-cai). \
+More details can be found [here](https://huggingface.co/datasets/pelcra/pl-asr-pelcra-for-bigos)"
+
+ANALYSIS_INFO = "Under construction"
+
+INSPECTION_INFO = "Under construction"
+
+COMPARISON_INFO = "Under construction"

requirements.txt

@@ -0,0 +1,2 @@
+seaborn
+

utils.py

@@ -0,0 +1,370 @@
+import pandas as pd
+import streamlit as st
+import seaborn as sns
+import matplotlib.pyplot as plt
+import os
+import requests
+import numpy as np  
+from datasets import Dataset
+from huggingface_hub import hf_hub_download
+
+def download_tsv_from_google_sheet(sheet_url):
+    # Modify the Google Sheet URL to export it as TSV
+    tsv_url = sheet_url.replace('/edit#gid=', '/export?format=tsv&gid=')
+    
+    # Send a GET request to download the TSV file
+    response = requests.get(tsv_url)
+    response.encoding = 'utf-8'
+
+    # Check if the request was successful
+    if response.status_code == 200:
+        # Read the TSV content into a pandas DataFrame
+        from io import StringIO
+        tsv_content = StringIO(response.text)
+        df = pd.read_csv(tsv_content, sep='\t', encoding='utf-8')
+        return df
+    else:
+        print("Failed to download the TSV file.")
+        return None
+    
+def generate_path_to_latest_tsv(dataset_name, split, type_of_result):
+    fn = os.path.join("./data", dataset_name, split, "eval_results-{}-latest.tsv".format(type_of_result))
+    #print(fn)
+    return(fn)
+
+@st.cache_data
+def read_latest_results(dataset_name, split, codename_to_shortname_mapping):
+
+    # Set your Hugging Face API token as an environment variable
+    # Define the path to your dataset directory
+    repo_id = os.getenv('HF_SECRET_REPO_ID')
+    #"michaljunczyk/bigos-eval-results-secret"
+
+    dataset = dataset_name
+    
+    dataset_path = os.path.join("leaderboard_input", dataset, split)
+    print(dataset_path)
+
+    fn_results_per_dataset = 'eval_results-per_dataset-latest.tsv'
+    fn_results_per_sample = 'eval_results-per_sample-latest.tsv'
+
+    fp_results_per_dataset_repo = os.path.join(dataset_path, fn_results_per_dataset)
+    print(fp_results_per_dataset_repo)
+    fp_results_per_sample_repo = os.path.join(dataset_path, fn_results_per_sample)
+
+    # Download the file from the Hugging Face Hub
+    local_fp_per_dataset = hf_hub_download(repo_id=repo_id, repo_type='dataset', filename=fp_results_per_dataset_repo, use_auth_token=os.getenv('HF_TOKEN'))
+    local_fp_per_sample = hf_hub_download(repo_id=repo_id, repo_type='dataset', filename=fp_results_per_sample_repo, use_auth_token=os.getenv('HF_TOKEN'))
+
+    # Read the TSV file into a pandas DataFrame
+    df_per_dataset = pd.read_csv(local_fp_per_dataset, delimiter='\t')
+    df_per_sample = pd.read_csv(local_fp_per_sample, delimiter='\t')
+
+    # Print the DataFrame
+    print(df_per_dataset)
+    print(df_per_sample)
+
+    #replace column system with Shortname
+    if (codename_to_shortname_mapping):
+        df_per_sample['system'] = df_per_sample['system'].replace(codename_to_shortname_mapping)
+        df_per_dataset['system'] = df_per_dataset['system'].replace(codename_to_shortname_mapping)
+
+    return df_per_sample, df_per_dataset
+
+@st.cache_data
+def retrieve_asr_systems_meta_from_the_catalog(asr_systems_list):
+    #print("Retrieving ASR systems metadata for systems: ", asr_systems_list)
+    #print("Number of systems: ", len(asr_systems_list))
+
+    #print("Reading ASR systems catalog")
+    asr_systems_cat_url = "https://docs.google.com/spreadsheets/d/1fVsE98Ulmt-EIEe4wx8sUdo7RLigDdAVjQxNpAJIrH8/edit#gid=681521237"
+    #print("Reading the catalog from: ", asr_systems_cat_url)
+    catalog = download_tsv_from_google_sheet(asr_systems_cat_url)
+    #print("ASR systems catalog read")
+    #print("Catalog contains information about {} ASR systems".format(len(catalog)))
+    ##print("Catalog columns: ", catalog.columns)
+    ##print("ASR systems available in the catalog: ", catalog["Codename"] )
+
+    #print("Filter only the systems we are interested in")
+    catalog = catalog[(catalog["Codename"].isin(asr_systems_list)) | (catalog["Shortname"].isin(asr_systems_list))]
+
+    return catalog
+
+def basic_stats_per_dimension(df_input, metric, dimension):
+    
+    #Median value
+    df_median = df_input.groupby(dimension)[metric].median().sort_values().round(2)
+
+    #Average value 
+    df_avg = df_input.groupby(dimension)[metric].mean().sort_values().round(2)
+
+    #Standard deviation 
+    df_std = df_input.groupby(dimension)[metric].std().sort_values().round(2)
+
+    # Min
+    df_min = df_input.groupby(dimension)[metric].min().sort_values().round(2)
+    
+    # Max
+    df_max = df_input.groupby(dimension)[metric].max().sort_values().round(2)
+
+    # concatanate all WER statistics
+    df_stats = pd.concat([df_median, df_avg, df_std, df_min, df_max], axis=1)
+    df_stats.columns = ["med_{}".format(metric), "avg_{}".format(metric), "std_{}".format(metric), "min_{}".format(metric), "max_{}".format(metric)]
+
+    # sort by median values
+    df_stats = df_stats.sort_values(by="med_{}".format(metric))
+
+    return df_stats
+
+def ser_from_per_sample_results(df_per_sample, dimension):
+    # group by dimension e.g dataset or sample and calculate fraction of samples with WER equal to 0
+    df_ser = df_per_sample.groupby(dimension)["WER"].apply(lambda x: (x != 0).mean()*100).sort_values().round(2)
+    # change column names
+    df_ser.name = "SER"
+    return df_ser
+
+def get_total_audio_duration(df_per_sample):
+    # filter the df_per_sample dataframe to leave only unique audio recordings
+    df_per_sample_unique_audio = df_per_sample.drop_duplicates(subset='id')
+    # calculate the total size of the dataset in hours based on the list of unique audio recordings
+    total_duration_hours = df_per_sample_unique_audio['audio_duration'].sum() / 3600
+    #print(f"Total duration of the dataset: {total_duration_hours:.2f} hours")
+    return total_duration_hours
+
+def extend_meta_per_sample_words_chars(df_per_sample):
+
+    # extend the results with the number of words in the reference and hypothesis
+    df_per_sample['ref_words'] = df_per_sample['ref'].apply(lambda x: len(x.split()))
+    df_per_sample['hyp_words'] = df_per_sample['hyp'].apply(lambda x: len(x.split()))
+
+    # extend the df_per_sample with the number of words per seconds (based on duration column) for reference and hypothesis
+    df_per_sample['ref_wps'] = df_per_sample['ref_words'] / df_per_sample['audio_duration'].round(2)
+    df_per_sample['hyp_wps'] = df_per_sample['hyp_words'] / df_per_sample['audio_duration'].round(2)
+
+    # extend the df_per_sample with the number of characters per seconds (based on duration column) for reference and hypothesis
+    df_per_sample['ref_cps'] = df_per_sample['ref'].apply(lambda x: len(x)) / df_per_sample['audio_duration'].round(2)
+    df_per_sample['hyp_cps'] = df_per_sample['hyp'].apply(lambda x: len(x)) / df_per_sample['audio_duration'].round(2)
+
+    # extend the df_per_sample with the number of characters per words for reference and hypothesis
+    df_per_sample['ref_cpw'] = df_per_sample['ref'].apply(lambda x: len(x)) / df_per_sample['ref_words'].round(2)
+    df_per_sample['hyp_cpw'] = df_per_sample['hyp'].apply(lambda x: len(x)) / df_per_sample['hyp_words'].round(2)
+
+    # extend metadata with number of words and characters
+    return df_per_sample
+
+def filter_top_outliers(df_input, metric, max_threshold):
+    # filter out outliers exceeding max_threshold
+    df_filtered = df_input[df_input[metric] < max_threshold]
+    return df_filtered
+
+def filter_bottom_outliers(df_input, metric, min_threshold):
+    # filter out outliers below min_threshold
+    df_filtered = df_input[df_input[metric] > min_threshold]
+    return df_filtered
+
+def box_plot_per_dimension(df_input, metric, dimension, title, xlabel, ylabel):
+    # Box plot for WER per dataset
+    plt.figure(figsize=(20, 10))
+
+    # generate box plot without outliers    
+    sns.boxplot(x=dimension, y=metric, data=df_input, order=df_input.groupby(dimension)[metric].median().sort_values().index, showfliers=False)
+    
+    plt.title(title)
+    plt.xlabel(xlabel)
+    plt.ylabel(ylabel)
+    plt.xticks(rotation=90)
+    #return figure
+    return plt
+
+    
+def check_impact_of_normalization(data_in, ref_type='orig'):
+
+    # Filter the data to include only the specific reference type
+    data_ref_type = data_in[data_in['ref_type'] == ref_type]
+
+    data = data_ref_type.drop(columns=['system','subset', 'ref_type'])
+
+    # Calculate the average impact of each normalization type on the metrics
+    average_impact = data.groupby('norm_type').mean()
+    baseline_metrics = average_impact.loc['none']
+
+    # Calculate the difference in metrics compared to the baseline
+    difference_metrics = average_impact.subtract(baseline_metrics)
+
+    # Removing the baseline row for clarity
+    difference_metrics = difference_metrics.drop(index='none')
+
+    # Rounding the results to 2 decimal places
+    difference_metrics_rounded = difference_metrics.round(2)
+
+    # add column with average impact on error reduction for all metric types
+    difference_metrics_rounded['Average'] = difference_metrics_rounded.mean(axis=1).round(2)
+
+    # Sorting the results based on the average impact on error reduction. The lower the absolute value, the higher the impact
+    difference_metrics_sorted_abs = difference_metrics_rounded.sort_values(by='Average', key=abs)
+
+    # Display the resulting differences
+    return(difference_metrics_sorted_abs)
+
+
+
+def calculate_wer_per_meta_category(df_per_sample, selected_systems, metric, analysis_dimension = 'speaker_gender'):
+    # filter out from df_per_sample rows where analysis_dimension is null
+    df_per_sample_dimension = df_per_sample[df_per_sample[analysis_dimension].notnull()]
+    #print(df_per_sample_dimension)
+
+    meta_values = df_per_sample_dimension[analysis_dimension].unique()
+
+    if (analysis_dimension == 'speaker_age'):
+        # sort values in the meta_values list, so the order of the values is consistent, starting from teens, twenties, thirties, fourties, fifties, sixties, seventies, eighties, nineties
+        # Example usage:
+        sorted_values = sort_age_categories(meta_values)
+        #print(sorted_values)
+        print("meta values sorted:", sorted_values)
+        meta_values = sorted_values
+
+    # calculate number of available systems for specific category
+    #print(df_per_sample_dimension)
+    # create table with number of samples in df_per_sample_single_system for each meta category from meta_values
+    df_per_sample_single_system = df_per_sample_dimension[df_per_sample['system'] == selected_systems[0]]
+
+    # select the value with the smallest number of available samples for all systems
+    min_samples = 0
+    df_available_samples_per_category_per_system = {}
+    for system in selected_systems:
+        df_per_sample_single_system = df_per_sample_dimension[df_per_sample['system'] == system]
+        df_available_samples_per_category_per_system[system] = df_per_sample_single_system.groupby(analysis_dimension)[metric].count().reset_index()
+        df_available_samples_per_category_per_system[system] = df_available_samples_per_category_per_system[system].rename(columns={metric: 'available_samples'})
+        # replace index with values from analysis_dimension
+        df_available_samples_per_category_per_system[system] = df_available_samples_per_category_per_system[system].set_index(analysis_dimension)    
+        #print(df_available_samples_per_category_per_system[system])
+
+        min_samples_system = df_available_samples_per_category_per_system[system]['available_samples'].min()
+        if (min_samples_system < min_samples) or (min_samples == 0):
+            min_samples = min_samples_system
+            #print(min_samples)
+
+    # get the subset of the df_per_sample_dimension with results for all systems to analyze
+    df_per_sample_selected_systems = df_per_sample_dimension[df_per_sample['system'].isin(selected_systems)]
+    #print(df_per_sample_selected_systems)
+    
+    # select equal number of samples for each system and analysis_dimension equal to the number of samples for the dimension with the smallest number of samples (min_samples)
+    df_per_sample_selected_systems = df_per_sample_selected_systems.groupby(['system',analysis_dimension]).apply(lambda x: x.sample(min_samples)).reset_index(drop=True)
+    
+    #print(df_per_sample_selected_systems)
+
+    df_per_sample_metric_dimension = df_per_sample_selected_systems.groupby(['system', analysis_dimension])[metric].mean().round(2).reset_index()
+
+
+
+    df_per_sample_metric_dimension_pivot = df_per_sample_metric_dimension.pivot(index=analysis_dimension, columns='system', values=metric)
+    df_per_sample_metric_dimension_pivot = df_per_sample_metric_dimension_pivot.round(2)
+
+
+    # add row with the difference between the male and female metric values for values. Add "Difference" row at the end of the dataframe to the index
+    # calculate the difference between the smallest and largest metric values
+    # if there are only two values in the analysis_dimension, calculate the difference between them
+    if len(meta_values) == 2:
+        gap_metrics = ['Difference']
+        df_per_sample_metric_dimension_pivot.loc[gap_metrics[0]] = df_per_sample_metric_dimension_pivot.loc[meta_values[0]] - df_per_sample_metric_dimension_pivot.loc[meta_values[1]]
+        
+    # if there are more than two values in the analysis_dimension, calculate the difference between the smallest and the largest value
+    elif len(meta_values) > 2:
+        gap_metrics = ['Std Dev', 'MAD', 'Range']
+  
+        metrics = pd.DataFrame([])
+        df = df_per_sample_metric_dimension_pivot
+
+        print(df)
+        # calculate the standard deviation of the metric values
+        metrics[gap_metrics[0]] = df.std()
+        # calculate the mean absolute deviation of the metric values
+        metrics[gap_metrics[1]] = df.apply(lambda x: np.mean(np.abs(x - np.mean(x))), axis=0)
+
+        # calculate the difference between the smallest and largest metric values
+        metrics[gap_metrics[2]] = df.max() - df.min()
+
+        metrics_t = metrics.round(2).transpose()
+        print(metrics_t)
+
+        #concatante the metrics dataframe to the df_per_sample_metric_dimension_pivot
+        df_per_sample_metric_dimension_pivot = pd.concat([df_per_sample_metric_dimension_pivot, metrics_t], axis=0)
+
+    
+    print(df_per_sample_metric_dimension_pivot)
+
+    # transpose the dataframe to have systems as rows
+    # sort by the average difference from the smallest to the largest value
+    df_per_sample_metric_dimension_pivot = df_per_sample_metric_dimension_pivot.transpose()
+    df_per_sample_metric_dimension_pivot = df_per_sample_metric_dimension_pivot.sort_values(by=gap_metrics[0], axis=0)
+
+    # add average, median and standard deviation as the last 3 rows to the dataframe
+    # calculate average, median, and standard deviation of the difference between the smallest and largest metric values
+    avg_difference = df_per_sample_metric_dimension_pivot.mean().round(2)
+    median_difference = df_per_sample_metric_dimension_pivot.median().round(2)
+    std_difference = df_per_sample_metric_dimension_pivot.std().round(2)
+    
+    # add average, median, and standard deviation as the last 3 rows to the dataframe
+    df_per_sample_metric_dimension_pivot.loc['median'] = median_difference
+    df_per_sample_metric_dimension_pivot.loc['average'] = avg_difference
+    df_per_sample_metric_dimension_pivot.loc['std'] = std_difference
+    
+    analyzed_samples_per_category = min_samples
+
+    # round all values to 2 decimal places
+    df_per_sample_metric_dimension_pivot = df_per_sample_metric_dimension_pivot.round(2)
+
+    # keep the order of columns as in the meta_values list
+    columns = list(meta_values) + gap_metrics
+    print(columns)
+    df_per_sample_metric_dimension_pivot = df_per_sample_metric_dimension_pivot[columns]
+
+    return df_per_sample_metric_dimension_pivot, df_available_samples_per_category_per_system, analyzed_samples_per_category
+
+def sort_age_categories(meta_values):
+    order = ["teens", "twenties", "thirties", "fourties", "fifties", "sixties", "seventies", "eighties", "nineties"]
+    order_dict = {age: index for index, age in enumerate(order)}
+
+    sorted_values = sorted(meta_values, key=lambda x: order_dict.get(x, float('inf')))
+    return sorted_values
+
+
+def calculate_wer_per_audio_feature(df_per_sample, selected_systems, audio_feature_to_analyze, metric, no_of_buckets):
+    # filter out results for selected systems
+    print(df_per_sample)
+
+    feature_values_uniq = df_per_sample[audio_feature_to_analyze].unique()
+    df_per_sample_selected_systems = df_per_sample[df_per_sample['system'].isin(selected_systems)]
+
+    # create buckets based on speech rate words unique values (min, max,step)
+    min_feature_value = round(min(feature_values_uniq), 1)
+    max_feature_value = round(max(feature_values_uniq), 1)
+    step = max_feature_value / no_of_buckets
+    audio_feature_buckets = [min_feature_value + i * step for i in range(no_of_buckets)]
+
+    # add column with speech_rate_words rounded to nearest bucket value.
+    # map audio duration to the closest bucket
+    df_per_sample[audio_feature_to_analyze + '_bucket'] = df_per_sample[audio_feature_to_analyze].apply(
+        lambda x: min(audio_feature_buckets, key=lambda y: abs(x - y)))
+
+    # calculate average WER per audio duration bucket
+    df_per_sample_wer_feature = df_per_sample_selected_systems.groupby(['system', audio_feature_to_analyze])[metric].mean().reset_index()
+    # add column with number of samples for specific audio bucket size
+    df_per_sample_wer_feature['number_of_samples'] = df_per_sample_selected_systems.groupby(['system', audio_feature_to_analyze])[metric].count().values
+
+    df_per_sample_wer_feature = df_per_sample_wer_feature.sort_values(by=audio_feature_to_analyze)
+    # round values in WER column in df_per_sample_wer to 2 decimal places
+    df_per_sample_wer_feature[metric].round(2)
+    # transform df_per_sample_wer. Use system values as columns, while audio_duration_buckets as main index
+    df_per_sample_wer_feature_pivot = df_per_sample_wer_feature.pivot(index=audio_feature_to_analyze, columns='system', values=metric)
+    df_per_sample_wer_feature_pivot = df_per_sample_wer_feature_pivot.round(2)
+
+    df_per_sample_wer_feature_pivot['number_of_samples'] = df_per_sample_wer_feature[
+        df_per_sample_wer_feature['system'] == selected_systems[0]].groupby(audio_feature_to_analyze)[
+        'number_of_samples'].sum().values
+
+    # put number_of_samples as the first column after index
+    df_per_sample_wer_feature_pivot = df_per_sample_wer_feature_pivot[
+        ['number_of_samples'] + [col for col in df_per_sample_wer_feature_pivot.columns if col != 'number_of_samples']]
+
+    return df_per_sample_wer_feature_pivot, df_per_sample_wer_feature