Datasets:

AAAIBenchmark
/

Multi-Opthalingua

## Setup
#### Load the libaries.
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
import os

from collections import Counter
import scipy.stats as stats
import pandas as pd
from scipy.stats import chi2_contingency
import json


# Define a dictionary to map Portuguese themes to English themes
theme_mapping = {
    'anatomia': 'anatomy',
    'córnea': 'cornea',
    'embriologia': 'embryology',
    'farmacologia': 'pharmacology',
    'genética': 'genetics',
    'glaucoma': 'glaucoma',
    'oncologia': 'oncology',
    'refração': 'refraction',
    'retina': 'retina',
    'cirurgia refrativa': 'refractive surgery',
    'cirurgia refrativva': 'refractive surgery',
    'cristalino/catarata': 'lens/cataract',
    'córnea/cristalino': 'cornea/lens',
    'estrabismo': 'strabismus',
    'farmacologia/glaucoma': 'pharmacology/glaucoma',
    'glaucoma/uveíte': 'glaucoma/uveitis',
    'lentes de contato': 'contact lenses',
    'neuroftalmologia': 'neuro-ophthalmology',
    'oncologia/plástica ocular': 'oncology/ocular plastic surgery',
    'plástica ocular': 'ocular plastic surgery',
    'refração/visão subnormal': 'refraction/low vision',
    'retina/oncologia': 'retina/oncology',
    'uveíte': 'uveitis',
    'visão subnormal': 'low vision',
    'óptica': 'optics',
    'óptica/refração': 'optics/refraction'
}


### Get Responses from text
def get_response(response):
    
    # Initial check to see if response is a string and try to parse it as JSON
    if isinstance(response, str):
        try:
            response = response.replace("'", '"')
            response = json.loads(response)  # Attempt to parse the string as JSON
        except json.JSONDecodeError:
            # If JSON parsing fails, it's not a JSON string, so we just proceed with the response as is
            pass

    # If response is now a dictionary (either was initially or successfully parsed from a string)
    if isinstance(response, dict):
        if 'response' in response:
            response = response['response']
        # Look for a direct 'answer' key first
        if 'answer' in response:
            response = response['answer']
        # If 'answer' key is not present, search for any key containing 'answer'
        for key in response:
            if 'answer' in key:
                response = response[key]
                
    if response == {'a': 'falso', 'b': 'falso', 'c': 'falso', 'd': 'verdadero'}:
        return 'd'
    elif response == {'a': 'falso', 'b': 'falso', 'c': 'verdadero', 'd': 'falso'}:
        return 'c'
    elif response == {'a': 'falso', 'b': 'verdadero', 'c': 'falso', 'd': 'falso'}:
        return 'b'
    elif response == {'a': 'verdadero', 'b': 'falso', 'c': 'falso', 'd': 'falso'}:
        return 'a'
    else: 
        response = str(response)
    
    if response.lower() in ['a', 'b', 'c', 'd']:
        return response
    
    options = {'a)': 'a', 'b)':'b', 'c)': 'c', 'd)':'d', 'a,': 'a', 'b,':'b', 'c,': 'c', 'd,':'d', 'a.': 'a', 'b.':'b', 'c.': 'c', 'd.':'d'}
    
    for option in options.keys():
        try:
            if option in response:
                return options[option]
        except:
            print(response)
            return np.nan
    else:
        return response

def clean_responses(df, languages, n_repetitions):

    df['answer'] = df['answer'].str.lower()

    for language in languages:
        if n_repetitions <= 1:
            df[f'responses_{language}'] = df[f'responses_{language}'].str.lower()
            df[f'responses_{language}'] = df[f'responses_{language}'].apply(get_response)
        else:
            for n in range(n_repetitions):
                df[f'responses_{language}_{n}'] = df[f'responses_{language}_{n}'].str.lower()
                df[f'responses_{language}_{n}'] = df[f'responses_{language}_{n}'].apply(get_response)
    
    df['theme'] = df['theme'].str.lower().str.strip()
    # Map the Portuguese themes to English themes for visualization
    df['theme'] = df['theme'].map(theme_mapping)
    
    return df


def get_df(model, temperature, n_repetitions, languages):
    ### Read the csv file with the responses
    if n_repetitions > 1:
        df = pd.read_csv(f"responses/{model}_Temperature{temperature}_{n_repetitions}Repetitions.csv")
    else:
        df = pd.read_csv(f"responses/{model}_Temperature{temperature}.csv")

    # Clean the columns with the responses
    df = clean_responses(df, languages, n_repetitions)
    
    return df


# Function to calculate the most common value and confidence interval for a row
def calculate_most_common_and_ci(row):
    # Count the occurrences of each value
    value_counts = Counter(row)

    # Calculate the mode
    mode = value_counts.most_common(1)[0][0]

    # Calculate the expected frequency of the mode under the null hypothesis
    total_items = len(row)
    expected_frequency = total_items / 4  # Assuming equal probability for each value

    # Perform a chi-squared test to calculate the p-value
    observed_frequency = value_counts[mode]
    chi_squared_statistic = ((observed_frequency - expected_frequency) ** 2) / expected_frequency
    degrees_of_freedom = 4 - 1  # There are 4 possible values, so 4 - 1 degrees of freedom
    p_value = 1 - stats.chi2.cdf(chi_squared_statistic, degrees_of_freedom)

    ratio = observed_frequency / total_items

    return mode, p_value, ratio
 
def get_mode_responses(df, languages, n_repetitions, model, temperature):
    for language in languages:
        cols = [f'responses_{language}_{n}' for n in range(n_repetitions)]
        # Calculate the most common value and confidence interval for each row
        df[f'responses_{language}'], df[f'P-value_{language}'], df[f'ratio_{language}'] = zip(*df[cols].apply(calculate_most_common_and_ci, axis=1))
        
    # Create folder to save the plots and the csv file if it does not exist
    if not os.path.exists(f'results'):
        os.makedirs(f'results')
        
    if not os.path.exists(f'results/results_{model}_Temperature{temperature}_Repetitions{n_repetitions}'):
        os.makedirs(f'results/results_{model}_Temperature{temperature}_Repetitions{n_repetitions}')
    
    df.to_csv(f'results/results_{model}_Temperature{temperature}_Repetitions{n_repetitions}/df_clean_{model}.csv', index=False)
    
    return df

### Data Analysis
def generate_summary_df(df, languages, model, temperature, n_repetitions):

    # Calculate the matches between 'answer' and 'responses'
    for language in languages:
        df[f'match_{language}'] = df['answer'] == df[f'responses_{language}']

    df['Total'] = True

    # Group by 'test', 'year', and 'theme' and calculate the count of matches
    aggregations = {f'match_{language}': 'sum' for language in languages}
    aggregations['Total'] = 'sum'

    matches_by_test = df.groupby(['test', 'year', 'theme']).agg(aggregations).reset_index()

    # Create folder to save the plots and the csv file if it does not exist
    if not os.path.exists(f'results'):
        os.makedirs(f'results')
    if not os.path.exists(f'results/results_{model}_Temperature{temperature}_Repetitions{n_repetitions}'):
        os.makedirs(f'results/results_{model}_Temperature{temperature}_Repetitions{n_repetitions}')
    matches_by_test.to_csv(f'results/results_{model}_Temperature{temperature}_Repetitions{n_repetitions}/matches_results_{model}.csv', index=False)
    
    return matches_by_test

def compare_total_matches(df, languages, model, temperature, n_repetitions):
    # Create a figure with subplots
    fig, ax = plt.subplots(figsize=(8, 6))

    # Plot the total matches
    totals = [round((df[f'match_{language}'].sum()/df[f'Total'].sum())*100, 1) for language in languages]
    colors = ['lightblue', 'salmon', 'seagreen', 'orange', 'purple', 'brown', 'pink', 'gray', 'olive', 'cyan']
    colors = colors[:len(languages)]
    bars = ax.bar(languages, totals, color=colors)

    # Add labels to the bars
    for bar in bars:
        height = bar.get_height()
        ax.annotate(f'{height}%', xy=(bar.get_x() + bar.get_width() / 2, height), xytext=(0, 3),
                    textcoords="offset points", ha='center', va='bottom', fontsize=16)

    # Add titles and labels
    plt.xlabel('Language', fontsize=18)
    plt.ylabel('Total Matches (%)', fontsize=18)
    plt.title(f'Total Correct Answers by Language(%)', fontsize=20)
    
    # Set the height of the x-values (tick labels) to 16
    ax.set_xticklabels(languages, fontsize=16)

    # Customize the appearance
    ax.spines['top'].set_visible(False)
    ax.spines['right'].set_visible(False)

    plt.savefig(f'results/results_{model}_Temperature{temperature}_Repetitions{n_repetitions}/total_matches_{model}.png', bbox_inches='tight')
    plt.show()

def compare_total_matches_by_group(matches_by_test, languages, model, temperature, n_repetitions):
    aggregations = {f'match_{language}': 'sum' for language in languages}
    aggregations['Total'] = 'sum'

    matches_by_test_group = matches_by_test.groupby('theme').agg(aggregations).reset_index()

    # Calculate the percentages for each language
    for language in languages:
        match_column = f'match_{language}'
        matches_by_test_group[f'responses_{language} (%)'] = round((matches_by_test_group[match_column] / matches_by_test_group['Total']) * 100, 2)

    matches_by_test_group.to_csv(f'results/results_{model}_Temperature{temperature}_Repetitions{n_repetitions}/matches_by_theme_{model}.csv', index=False)
    
    # Plotting
    fig, ax = plt.subplots(figsize=(12, 8))
    bar_width = 0.2  # Adjust bar width as needed
    index = np.arange(len(matches_by_test_group['theme']))
    offset = bar_width * len(languages) / 2

    for i, language in enumerate(languages):
        values = matches_by_test_group[f'responses_{language} (%)']
        positions = [x + i * bar_width - offset for x in index]
        ax.bar(positions, values, bar_width, label=language)

    ax.set_xlabel('Theme', fontsize=12)
    ax.set_ylabel('Correct Answers (%)', fontsize=12)
    ax.set_title('Correct Answers by Theme for Multiple Languages')
    ax.set_xticks(index)
    ax.set_xticklabels(matches_by_test_group['theme'], rotation=45, ha='right')
    ax.legend()

    plt.tight_layout()
    plt.savefig(f'results/results_{model}_Temperature{temperature}_Repetitions{n_repetitions}/matches_by_theme_{model}.png', bbox_inches='tight')
    plt.show()
    
    
    
    for theme in matches_by_test['theme']:
        df_theme = matches_by_test[matches_by_test['theme'] == theme].groupby(['theme']).agg(aggregations).reset_index()
        
        # Calculate the ratio of matches as a percentage of the total for each language
        for language in languages:
            df_theme[f'{language}_ratio_percentage'] = (df_theme[f'match_{language}'] / df_theme['Total']) * 100
        
        print(df_theme)

        # Plot the ratio of matches for each theme
        plt.figure(figsize=(6, 6))
        totals = [df_theme[f'{language}_ratio_percentage'].sum() for language in languages]
        colors = ['blue', 'green', 'red', 'orange', 'purple', 'brown', 'pink', 'gray', 'olive', 'cyan']
        colors = colors[:len(languages)]
        
        plt.bar(languages, totals)
        plt.xlabel('Language')
        plt.ylabel('Correct Answers (%)')
        plt.title(f'Correct Answers (%) By Language in Theme: {theme}')
        
        if '/' not in theme:
            plt.savefig(f'results/results_{model}_Temperature{temperature}_Repetitions{n_repetitions}/correct_answers_{model}_{theme}.png', bbox_inches='tight')
        else:
            plt.savefig(f'results/results_{model}_Temperature{temperature}_Repetitions{n_repetitions}/correct_answers_{model}_{theme.replace("/", "-")}.png', bbox_inches='tight')
        plt.show()



        
def basic_vs_clinical(matches_by_test, languages, model, temperature, n_repetitions):
    
    # Basic VS Clinical
    test_labels = {
        "Teórica I": "Basic Science",
        "Teórica II": "Clinical/Surgical"
    }

    # Map the 'test' column to their labels
    matches_by_test['test_labels'] = matches_by_test['test'].map(test_labels)

    # Group the data by 'test_labels' and calculate the sum of 'Total' for each group
    aggregations = {f'match_{language}': 'sum' for language in languages}
    aggregations['Total'] = 'sum'

    matches_by_test_group = matches_by_test.groupby('test_labels').agg(aggregations).reset_index()

    # Plotting
    fig, ax = plt.subplots(figsize=(12, 8))
    bar_width = 0.15  # Adjust bar width as needed
    index = np.arange(len(matches_by_test_group['test_labels']))
    offset = bar_width * len(languages) / 2

    for i, language in enumerate(languages):
        values = round((matches_by_test_group[f'match_{language}'] / matches_by_test_group['Total']) * 100, 1)
        positions = [x + i * bar_width - offset for x in index]
        bars = ax.bar(positions, values, bar_width, label=language)
        
        # Annotate the values over the bars
        for bar in bars:
            height = bar.get_height()
            ax.annotate(f'{height}%', xy=(bar.get_x() + bar.get_width() / 2, height),
                        xytext=(0, 3), textcoords="offset points",
                        ha='center', va='bottom', fontsize=16)

    ax.set_xlabel('Test Type', fontsize=18)
    ax.set_ylabel('Total Correct Answers (%)', fontsize=18)
    ax.set_title('Total Correct Answers by Test Type (%)', fontsize=20)
    ax.set_xticks(index)
    ax.set_xticklabels(matches_by_test_group['test_labels'], fontsize=18)

    plt.legend(title='Language', loc='lower left', fontsize=20)
    plt.tight_layout()

    plt.savefig(f'results/results_{model}_Temperature{temperature}_Repetitions{n_repetitions}/matches_by_type_{model}.png', bbox_inches='tight')
    plt.show()

        

def run_analysis(model, temperature, n_repetitions, languages):
    
    if n_repetitions <= 0 or (n_repetitions != int(n_repetitions)):
        print(f'n_repetitions should be a positive integer, not {n_repetitions}')
        print('n_repetitions will be set to 1')
        n_repetitions = 1

    # Data Preprocessing
    df = get_df(model, temperature, n_repetitions, languages)

    # Data Analysis
    if n_repetitions > 1:
        df = get_mode_responses(df, languages, n_repetitions, model, temperature)
        

    matches_by_test = generate_summary_df(df, languages, model, temperature, n_repetitions)

    # Data Visualization
    compare_total_matches(df, languages, model, temperature, n_repetitions)

    compare_total_matches_by_group(matches_by_test, languages, model, temperature, n_repetitions)
    
    basic_vs_clinical(matches_by_test, languages, model, temperature, n_repetitions)

    
    

def main():
    # Add argparse code to handle command-line arguments
    parser = argparse.ArgumentParser(description="Evaluate Medical Tests Classification in LLMS")
    parser.add_argument("--model", default="gpt-3.5-turbo", help="GPT model to use e.g: gpt-3.5-turbo or gpt-3.4 ")
    parser.add_argument("--temperature", type=float, default=0.0, help="Temperature parameter of the model between 0 and 1. Used to modifiy the model's creativity. 0 is deterministic and 1 is the most creative")
    parser.add_argument("--n_repetitions", type=int, default=1, help="Number of repetitions to run each experiment. Used to measure the model's hallucinations")
    parser.add_argument("--languages", nargs='+', default=['english', 'portuguese'], help="List of languages")
    args = parser.parse_args()


    MODEL = args.model
    TEMPERATURE = args.temperature
    N_REPETITIONS = args.n_repetitions
    LANGUAGES = args.languages

    TEMPERATURE = str(TEMPERATURE).replace('.', '_')

    run_analysis(model=MODEL, temperature=TEMPERATURE, n_repetitions=N_REPETITIONS, languages=LANGUAGES)


if __name__ == "__main__":
    main()

	## Setup
	#### Load the libaries.
	import pandas as pd
	import numpy as np
	import matplotlib.pyplot as plt
	import seaborn as sns
	import os

	from collections import Counter
	import scipy.stats as stats
	import pandas as pd
	from scipy.stats import chi2_contingency
	import json


	# Define a dictionary to map Portuguese themes to English themes
	theme_mapping = {
	'anatomia': 'anatomy',
	'córnea': 'cornea',
	'embriologia': 'embryology',
	'farmacologia': 'pharmacology',
	'genética': 'genetics',
	'glaucoma': 'glaucoma',
	'oncologia': 'oncology',
	'refração': 'refraction',
	'retina': 'retina',
	'cirurgia refrativa': 'refractive surgery',
	'cirurgia refrativva': 'refractive surgery',
	'cristalino/catarata': 'lens/cataract',
	'córnea/cristalino': 'cornea/lens',
	'estrabismo': 'strabismus',
	'farmacologia/glaucoma': 'pharmacology/glaucoma',
	'glaucoma/uveíte': 'glaucoma/uveitis',
	'lentes de contato': 'contact lenses',
	'neuroftalmologia': 'neuro-ophthalmology',
	'oncologia/plástica ocular': 'oncology/ocular plastic surgery',
	'plástica ocular': 'ocular plastic surgery',
	'refração/visão subnormal': 'refraction/low vision',
	'retina/oncologia': 'retina/oncology',
	'uveíte': 'uveitis',
	'visão subnormal': 'low vision',
	'óptica': 'optics',
	'óptica/refração': 'optics/refraction'
	}


	### Get Responses from text
	def get_response(response):

	# Initial check to see if response is a string and try to parse it as JSON
	if isinstance(response, str):
	try:
	response = response.replace("'", '"')
	response = json.loads(response) # Attempt to parse the string as JSON
	except json.JSONDecodeError:
	# If JSON parsing fails, it's not a JSON string, so we just proceed with the response as is
	pass

	# If response is now a dictionary (either was initially or successfully parsed from a string)
	if isinstance(response, dict):
	if 'response' in response:
	response = response['response']
	# Look for a direct 'answer' key first
	if 'answer' in response:
	response = response['answer']
	# If 'answer' key is not present, search for any key containing 'answer'
	for key in response:
	if 'answer' in key:
	response = response[key]

	if response == {'a': 'falso', 'b': 'falso', 'c': 'falso', 'd': 'verdadero'}:
	return 'd'
	elif response == {'a': 'falso', 'b': 'falso', 'c': 'verdadero', 'd': 'falso'}:
	return 'c'
	elif response == {'a': 'falso', 'b': 'verdadero', 'c': 'falso', 'd': 'falso'}:
	return 'b'
	elif response == {'a': 'verdadero', 'b': 'falso', 'c': 'falso', 'd': 'falso'}:
	return 'a'
	else:
	response = str(response)

	if response.lower() in ['a', 'b', 'c', 'd']:
	return response

	options = {'a)': 'a', 'b)':'b', 'c)': 'c', 'd)':'d', 'a,': 'a', 'b,':'b', 'c,': 'c', 'd,':'d', 'a.': 'a', 'b.':'b', 'c.': 'c', 'd.':'d'}

	for option in options.keys():
	try:
	if option in response:
	return options[option]
	except:
	print(response)
	return np.nan
	else:
	return response

	def clean_responses(df, languages, n_repetitions):

	df['answer'] = df['answer'].str.lower()

	for language in languages:
	if n_repetitions <= 1:
	df[f'responses_{language}'] = df[f'responses_{language}'].str.lower()
	df[f'responses_{language}'] = df[f'responses_{language}'].apply(get_response)
	else:
	for n in range(n_repetitions):
	df[f'responses_{language}_{n}'] = df[f'responses_{language}_{n}'].str.lower()
	df[f'responses_{language}_{n}'] = df[f'responses_{language}_{n}'].apply(get_response)

	df['theme'] = df['theme'].str.lower().str.strip()
	# Map the Portuguese themes to English themes for visualization
	df['theme'] = df['theme'].map(theme_mapping)

	return df


	def get_df(model, temperature, n_repetitions, languages):
	### Read the csv file with the responses
	if n_repetitions > 1:
	df = pd.read_csv(f"responses/{model}_Temperature{temperature}_{n_repetitions}Repetitions.csv")
	else:
	df = pd.read_csv(f"responses/{model}_Temperature{temperature}.csv")

	# Clean the columns with the responses
	df = clean_responses(df, languages, n_repetitions)

	return df


	# Function to calculate the most common value and confidence interval for a row
	def calculate_most_common_and_ci(row):
	# Count the occurrences of each value
	value_counts = Counter(row)

	# Calculate the mode
	mode = value_counts.most_common(1)[0][0]

	# Calculate the expected frequency of the mode under the null hypothesis
	total_items = len(row)
	expected_frequency = total_items / 4 # Assuming equal probability for each value

	# Perform a chi-squared test to calculate the p-value
	observed_frequency = value_counts[mode]
	chi_squared_statistic = ((observed_frequency - expected_frequency) ** 2) / expected_frequency
	degrees_of_freedom = 4 - 1 # There are 4 possible values, so 4 - 1 degrees of freedom
	p_value = 1 - stats.chi2.cdf(chi_squared_statistic, degrees_of_freedom)

	ratio = observed_frequency / total_items

	return mode, p_value, ratio

	def get_mode_responses(df, languages, n_repetitions, model, temperature):
	for language in languages:
	cols = [f'responses_{language}_{n}' for n in range(n_repetitions)]
	# Calculate the most common value and confidence interval for each row
	df[f'responses_{language}'], df[f'P-value_{language}'], df[f'ratio_{language}'] = zip(*df[cols].apply(calculate_most_common_and_ci, axis=1))

	# Create folder to save the plots and the csv file if it does not exist
	if not os.path.exists(f'results'):
	os.makedirs(f'results')

	if not os.path.exists(f'results/results_{model}_Temperature{temperature}_Repetitions{n_repetitions}'):
	os.makedirs(f'results/results_{model}_Temperature{temperature}_Repetitions{n_repetitions}')

	df.to_csv(f'results/results_{model}_Temperature{temperature}_Repetitions{n_repetitions}/df_clean_{model}.csv', index=False)

	return df

	### Data Analysis
	def generate_summary_df(df, languages, model, temperature, n_repetitions):

	# Calculate the matches between 'answer' and 'responses'
	for language in languages:
	df[f'match_{language}'] = df['answer'] == df[f'responses_{language}']

	df['Total'] = True

	# Group by 'test', 'year', and 'theme' and calculate the count of matches
	aggregations = {f'match_{language}': 'sum' for language in languages}
	aggregations['Total'] = 'sum'

	matches_by_test = df.groupby(['test', 'year', 'theme']).agg(aggregations).reset_index()

	# Create folder to save the plots and the csv file if it does not exist
	if not os.path.exists(f'results'):
	os.makedirs(f'results')
	if not os.path.exists(f'results/results_{model}_Temperature{temperature}_Repetitions{n_repetitions}'):
	os.makedirs(f'results/results_{model}_Temperature{temperature}_Repetitions{n_repetitions}')
	matches_by_test.to_csv(f'results/results_{model}_Temperature{temperature}_Repetitions{n_repetitions}/matches_results_{model}.csv', index=False)

	return matches_by_test

	def compare_total_matches(df, languages, model, temperature, n_repetitions):
	# Create a figure with subplots
	fig, ax = plt.subplots(figsize=(8, 6))

	# Plot the total matches
	totals = [round((df[f'match_{language}'].sum()/df[f'Total'].sum())*100, 1) for language in languages]
	colors = ['lightblue', 'salmon', 'seagreen', 'orange', 'purple', 'brown', 'pink', 'gray', 'olive', 'cyan']
	colors = colors[:len(languages)]
	bars = ax.bar(languages, totals, color=colors)

	# Add labels to the bars
	for bar in bars:
	height = bar.get_height()
	ax.annotate(f'{height}%', xy=(bar.get_x() + bar.get_width() / 2, height), xytext=(0, 3),
	textcoords="offset points", ha='center', va='bottom', fontsize=16)

	# Add titles and labels
	plt.xlabel('Language', fontsize=18)
	plt.ylabel('Total Matches (%)', fontsize=18)
	plt.title(f'Total Correct Answers by Language(%)', fontsize=20)

	# Set the height of the x-values (tick labels) to 16
	ax.set_xticklabels(languages, fontsize=16)

	# Customize the appearance
	ax.spines['top'].set_visible(False)
	ax.spines['right'].set_visible(False)

	plt.savefig(f'results/results_{model}_Temperature{temperature}_Repetitions{n_repetitions}/total_matches_{model}.png', bbox_inches='tight')
	plt.show()

	def compare_total_matches_by_group(matches_by_test, languages, model, temperature, n_repetitions):
	aggregations = {f'match_{language}': 'sum' for language in languages}
	aggregations['Total'] = 'sum'

	matches_by_test_group = matches_by_test.groupby('theme').agg(aggregations).reset_index()

	# Calculate the percentages for each language
	for language in languages:
	match_column = f'match_{language}'
	matches_by_test_group[f'responses_{language} (%)'] = round((matches_by_test_group[match_column] / matches_by_test_group['Total']) * 100, 2)

	matches_by_test_group.to_csv(f'results/results_{model}_Temperature{temperature}_Repetitions{n_repetitions}/matches_by_theme_{model}.csv', index=False)

	# Plotting
	fig, ax = plt.subplots(figsize=(12, 8))
	bar_width = 0.2 # Adjust bar width as needed
	index = np.arange(len(matches_by_test_group['theme']))
	offset = bar_width * len(languages) / 2

	for i, language in enumerate(languages):
	values = matches_by_test_group[f'responses_{language} (%)']
	positions = [x + i * bar_width - offset for x in index]
	ax.bar(positions, values, bar_width, label=language)

	ax.set_xlabel('Theme', fontsize=12)
	ax.set_ylabel('Correct Answers (%)', fontsize=12)
	ax.set_title('Correct Answers by Theme for Multiple Languages')
	ax.set_xticks(index)
	ax.set_xticklabels(matches_by_test_group['theme'], rotation=45, ha='right')
	ax.legend()

	plt.tight_layout()
	plt.savefig(f'results/results_{model}_Temperature{temperature}_Repetitions{n_repetitions}/matches_by_theme_{model}.png', bbox_inches='tight')
	plt.show()



	for theme in matches_by_test['theme']:
	df_theme = matches_by_test[matches_by_test['theme'] == theme].groupby(['theme']).agg(aggregations).reset_index()

	# Calculate the ratio of matches as a percentage of the total for each language
	for language in languages:
	df_theme[f'{language}_ratio_percentage'] = (df_theme[f'match_{language}'] / df_theme['Total']) * 100

	print(df_theme)

	# Plot the ratio of matches for each theme
	plt.figure(figsize=(6, 6))
	totals = [df_theme[f'{language}_ratio_percentage'].sum() for language in languages]
	colors = ['blue', 'green', 'red', 'orange', 'purple', 'brown', 'pink', 'gray', 'olive', 'cyan']
	colors = colors[:len(languages)]

	plt.bar(languages, totals)
	plt.xlabel('Language')
	plt.ylabel('Correct Answers (%)')
	plt.title(f'Correct Answers (%) By Language in Theme: {theme}')

	if '/' not in theme:
	plt.savefig(f'results/results_{model}_Temperature{temperature}_Repetitions{n_repetitions}/correct_answers_{model}_{theme}.png', bbox_inches='tight')
	else:
	plt.savefig(f'results/results_{model}_Temperature{temperature}_Repetitions{n_repetitions}/correct_answers_{model}_{theme.replace("/", "-")}.png', bbox_inches='tight')
	plt.show()




	def basic_vs_clinical(matches_by_test, languages, model, temperature, n_repetitions):

	# Basic VS Clinical
	test_labels = {
	"Teórica I": "Basic Science",
	"Teórica II": "Clinical/Surgical"
	}

	# Map the 'test' column to their labels
	matches_by_test['test_labels'] = matches_by_test['test'].map(test_labels)

	# Group the data by 'test_labels' and calculate the sum of 'Total' for each group
	aggregations = {f'match_{language}': 'sum' for language in languages}
	aggregations['Total'] = 'sum'

	matches_by_test_group = matches_by_test.groupby('test_labels').agg(aggregations).reset_index()

	# Plotting
	fig, ax = plt.subplots(figsize=(12, 8))
	bar_width = 0.15 # Adjust bar width as needed
	index = np.arange(len(matches_by_test_group['test_labels']))
	offset = bar_width * len(languages) / 2

	for i, language in enumerate(languages):
	values = round((matches_by_test_group[f'match_{language}'] / matches_by_test_group['Total']) * 100, 1)
	positions = [x + i * bar_width - offset for x in index]
	bars = ax.bar(positions, values, bar_width, label=language)

	# Annotate the values over the bars
	for bar in bars:
	height = bar.get_height()
	ax.annotate(f'{height}%', xy=(bar.get_x() + bar.get_width() / 2, height),
	xytext=(0, 3), textcoords="offset points",
	ha='center', va='bottom', fontsize=16)

	ax.set_xlabel('Test Type', fontsize=18)
	ax.set_ylabel('Total Correct Answers (%)', fontsize=18)
	ax.set_title('Total Correct Answers by Test Type (%)', fontsize=20)
	ax.set_xticks(index)
	ax.set_xticklabels(matches_by_test_group['test_labels'], fontsize=18)

	plt.legend(title='Language', loc='lower left', fontsize=20)
	plt.tight_layout()

	plt.savefig(f'results/results_{model}_Temperature{temperature}_Repetitions{n_repetitions}/matches_by_type_{model}.png', bbox_inches='tight')
	plt.show()



	def run_analysis(model, temperature, n_repetitions, languages):

	if n_repetitions <= 0 or (n_repetitions != int(n_repetitions)):
	print(f'n_repetitions should be a positive integer, not {n_repetitions}')
	print('n_repetitions will be set to 1')
	n_repetitions = 1

	# Data Preprocessing
	df = get_df(model, temperature, n_repetitions, languages)

	# Data Analysis
	if n_repetitions > 1:
	df = get_mode_responses(df, languages, n_repetitions, model, temperature)


	matches_by_test = generate_summary_df(df, languages, model, temperature, n_repetitions)

	# Data Visualization
	compare_total_matches(df, languages, model, temperature, n_repetitions)

	compare_total_matches_by_group(matches_by_test, languages, model, temperature, n_repetitions)

	basic_vs_clinical(matches_by_test, languages, model, temperature, n_repetitions)




	def main():
	# Add argparse code to handle command-line arguments
	parser = argparse.ArgumentParser(description="Evaluate Medical Tests Classification in LLMS")
	parser.add_argument("--model", default="gpt-3.5-turbo", help="GPT model to use e.g: gpt-3.5-turbo or gpt-3.4 ")
	parser.add_argument("--temperature", type=float, default=0.0, help="Temperature parameter of the model between 0 and 1. Used to modifiy the model's creativity. 0 is deterministic and 1 is the most creative")
	parser.add_argument("--n_repetitions", type=int, default=1, help="Number of repetitions to run each experiment. Used to measure the model's hallucinations")
	parser.add_argument("--languages", nargs='+', default=['english', 'portuguese'], help="List of languages")
	args = parser.parse_args()


	MODEL = args.model
	TEMPERATURE = args.temperature
	N_REPETITIONS = args.n_repetitions
	LANGUAGES = args.languages

	TEMPERATURE = str(TEMPERATURE).replace('.', '_')

	run_analysis(model=MODEL, temperature=TEMPERATURE, n_repetitions=N_REPETITIONS, languages=LANGUAGES)


	if __name__ == "__main__":
	main()