Datasets:

AAAIBenchmark
/

Multi-Opthalingua

""" Evaluate Medical Tests Classification in LLMS """
## Setup
#### Load the API key and libaries.
import json
import pandas as pd
import os
import openai
from dotenv import load_dotenv, find_dotenv
import argparse
import re
import subprocess
import time


### Download LLAMA model:
def download_and_rename(url, filename):
    """Downloads a file from the given URL and renames it to the given new file name.
    Args:
        url: The URL of the file to download.
        new_file_name: The new file name for the downloaded file.
    """

    os.makedirs(os.path.dirname(filename), exist_ok=True)

    print(f'Downloading the weights of the model: {url} ...')
    subprocess.run(["wget", "-q", "-O", filename, url])
    print(f'Done!')

def download_hugging_face_model(model_version='Llama-2-7b'):
    if model_version not in ['Llama-2-7b', 'Llama-2-13b', 'Llama-2-70b', 'Mistral-7b']:
        raise ValueError("Options for Llama model should be 7b, 13b or 70b, or Mistral-7b")

    MODEL_URL = {
        'Llama-2-7b': 'https://huggingface.co/TheBloke/Llama-2-7b-Chat-GGUF/resolve/main/llama-2-7b-chat.Q8_0.gguf', 
        'Llama-2-13b': 'https://huggingface.co/TheBloke/Llama-2-13B-chat-GGUF/resolve/main/llama-2-13b-chat.Q8_0.gguf', 
        'Llama-2-70b': 'https://huggingface.co/TheBloke/Llama-2-70B-chat-GGUF/resolve/main/llama-2-70b-chat.Q5_0.gguf',
        'Mistral-7b': 'https://huggingface.co/TheBloke/Mistral-7B-Instruct-v0.1-GGUF/resolve/main/mistral-7b-instruct-v0.1.Q8_0.gguf'
    }

    MODEL_URL = MODEL_URL[model_version]

    model_path = f'Models/{model_version}.gguf'

    if os.path.exists(model_path):
        confirmation = input(f"The model file '{model_path}' already exists. Do you want to overwrite it? (yes/no): ").strip().lower()
        if confirmation != 'yes':
            print("Model installation aborted.")
            return model_path

    download_and_rename(MODEL_URL, model_path)

    return model_path

### Model GPT:
def get_completion_from_messages(messages, 
                                 model="gpt-3.5-turbo", 
                                 temperature=0, 
                                 max_tokens=500):

    try:        
        response = openai.ChatCompletion.create(
            model=model,
            messages=messages,
            temperature=temperature, 
            max_tokens=max_tokens,
            request_timeout=10
        )
    except:
        time.sleep(60)
        response = get_completion_from_messages(messages, model=model, temperature=temperature, max_tokens=max_tokens)
        return response

    return response.choices[0].message["content"]

def get_completion_from_messages_hf(messages, 
                                    model):
    
    response = model(messages)[0]['generated_text'].replace(messages, '')
    
    return {'response': response}

#### Model Llama 2
def get_completion_from_messages_llama(messages, 
                                 model, 
                                 temperature=0, 
                                 max_tokens=500, 
                                 reasoning=False):
    # Get the response:
    response = model.create_chat_completion(
        messages,
        temperature=temperature,
        max_tokens=max_tokens
    )
    
    model.set_cache(None)
    
    response = response['choices'][0]['message']["content"]        

    # Convert the string into a JSON object
    # Due to some problems with Llama 2 generating JSON formats, the output requires more preprocessing than GPT.
    try:
        # Use regular expressions to extract JSON
        json_pattern = r'\{.*\}'  # Match everything between '{' and '}'
        match = re.search(json_pattern, response, re.DOTALL)
        response = match.group()
        

        # Define a regex pattern to identify unquoted string values
        pattern = r'("[^"]*":\s*)([A-Za-z_][A-Za-z0-9_]*)'
        # Use a lambda function to add quotes to unquoted string values
        response = re.sub(pattern, lambda m: f'{m.group(1)}"{m.group(2)}"', response)
        
        
        if not reasoning:
            # Convert from {'response': 'A' ) some text without quotes} to {'response': 'A'}
            # Use regular expression to extract the letter and surrounding characters
            match = re.search(r'"response": "([A-Da-d][^\"]*)"', response)

            if match:
                response = f'{{{match.group(0)}}}'

        # Convert
        response = json.loads(response)
        
        resp = response['response']
        
    except:
        print(f'Error converting respose to json: {response}')
        print('Generating new response...')
        response = get_completion_from_messages_llama(messages, model=model, temperature=temperature, max_tokens=max_tokens, reasoning=reasoning)
        return response

    if reasoning:
        # Iterate through the keys of the dictionary
        for key in list(response.keys()):
            if 'reas' in key.lower():
                # Update the dictionary with the new key and its corresponding value
                response['reasoning'] = response.pop(key)

    return response

#### Template for the Questions
def generate_question(question, LANGUAGES, REASONING, Responses=['A', 'B', 'C', 'D']):
    
    delimiter = "####"

    languages_text = ", ".join(LANGUAGES)

    if REASONING:
        system_message = f"""
You will be provided with medical queries in this languages: {languages_text}. \
The medical query will be delimited with {delimiter} characters.
Each question will have {len(Responses)} possible answer options.\
provide the letter with the answer and a short sentence answering why the answer was selected \
Provide your output in json format with the \
keys: response and reasoning.
Responses: {", ".join(Responses)}.
        """
    else:
        system_message = f"""
You will be provided with medical queries in this languages: {languages_text}. \
The medical query will be delimited with {delimiter} characters.
Each question will have {len(Responses)} possible answer options.\
Provide only the letter with the response.
Provide your output in json format with: 
the key: response.
Responses: {", ".join(Responses)}.
E.g. if response is 'a', the output should be: {{"response" : "a"}}   
        """

    user_message = f"""/
    {question}"""
    
    messages =  [  
    {'role':'system', 
     'content': system_message},    
    {'role':'user', 
     'content': f"{delimiter}{user_message}{delimiter}"},  
    ] 
    
    return messages

def generate_template_text_generation(question, LANGUAGES, Responses=['A', 'B', 'C', 'D']):
    
    delimiter = "####"

    languages_text = ", ".join(LANGUAGES)

    messages = f"""You will be provided with medical queries in this languages: {languages_text}. \
    The medical query will be delimited with {delimiter} characters.
    Each question will have {len(Responses)} possible answer options.Provide just the letter with the answer.
    Responses: {", ".join(Responses)}.
    Question:
    {delimiter}{question}{delimiter}
    The response is: """

    return messages

#### Template for the Questions
def generate_question_llama(question, LANGUAGES, REASONING, Responses=['A', 'B', 'C', 'D']):
    
    delimiter = "####"
    
    out_template = ""
    
    if REASONING:
        output_keys = ['response', 'reasoning']
    else:
        output_keys = ['response']
        
    for response in Responses:
        response_dict = {key: f'something describing {key}' for key in output_keys}
        response_dict[output_keys[0]] = response
        response_str = ', '.join([f"'{k}': '{v}'" for k, v in response_dict.items()])
        out_template += f"If response is {response}: {{ {response_str} }}\n"

    languages_text = ", ".join(LANGUAGES)

    if REASONING:
        system_message = f"""
You will be provided with medical queries in this languages: {languages_text}. \
The medical query will be delimited with \
{delimiter} characters.
Each question will have {len(Responses)} possible answer options.\
provide just the letter with the answer and a short sentence answering why the answer was selected.
Provide your output in json format with the \
keys: response and reasoning. Make sure to always use the those keys, do not modify the keys. 
Response option: {", ".join(Responses)}.
Always use the JSON format.
The output shoulb be: {{"response": "Response option", "", ""}}
        """
    else:
        system_message = f"""
You will be provided with medical queries in this languages: {languages_text}. \
The medical query will be delimited with \
{delimiter} characters.
Each question will have {len(Responses)} possible answer options.\
provide just the letter with the answer.
Provide your output in json format with the \
key: response. Make sure to always use the that key, do not modify the key. 
Response option: {", ".join(Responses)}.
Always use the JSON format.
The output shoulb be: {{"response": "Response option"}}
        """

    user_message = f"""/
    {question}"""
    
    messages =  [  
    {'role':'system', 
     'content': system_message},    
    {'role':'user', 
     'content': f"{delimiter}{user_message}{delimiter}"},  
    ] 
    
    return messages


def llm_language_evaluation(path='data/Portuguese.csv', model='gpt-3.5-turbo', temperature=0.0, n_repetitions=1, reasoning=False, languages=['english', 'portuguese']):
    
    # Load API key if GPT, or Model if LLAMA
    if 'gpt' in model:
        _ = load_dotenv(find_dotenv()) # read local .env file
        openai.api_key  = os.environ['OPENAI_API_KEY']
    elif 'Llama-2' in model or ('Mistral-7b' in model):                
        model_path = download_hugging_face_model(model_version=model)
        from llama_cpp import Llama
        llm = Llama(model_path=model_path, verbose=False, n_ctx=2048)
    elif 'bloom':
        from transformers import pipeline
        llm = pipeline(
            task="text-generation", 
            model=model,
            model_kwargs={"temperature": temperature, "max_length": 5})
        reasoning = False
    else:
        print('Model should be a GPT or Llama-2 model')
        return 0
    
    #### Load the Constants
    PATH = path # 'data/Portuguese.csv'
    MODEL = model # "gpt-3.5-turbo"
    TEMPERATURE = temperature # 0.0
    N_REPETITIONS = n_repetitions # 1
    REASONING = reasoning # False
    LANGUAGES = languages # ['english', 'portuguese']

    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


    ### Questions from a csv file:
    df = pd.read_csv(PATH)

    ### Evaluate the model in question answering per language:
    responses = {}
    reasoning = {}
    for language in LANGUAGES:
        responses[language] = [[] for n in range(N_REPETITIONS)]

        if REASONING:
            reasoning[language] = [[] for n in range(N_REPETITIONS)]

    for row in range(df.shape[0]):
        print('*'*50)
        print(f'Question {row+1}: ')
        for language in LANGUAGES:
            print(f'Language: {language}')
            question = df[language][row]
            print('Question: ')
            print(question)
            if 'gpt' in model: 
                messages = generate_question(question, LANGUAGES, REASONING)
            elif 'Llama-2' in model or ('Mistral-7b' in model):
                messages = generate_question_llama(question, LANGUAGES, REASONING)
            elif 'bloom' in model:
                messages = generate_template_text_generation(question, LANGUAGES)
            else:
                print('Model should be a GPT or Llama-2 model')
                return 0 

            for n in range(N_REPETITIONS): 
                print(f'Test #{n}: ')
                
                if 'gpt' in model: 
                    response = get_completion_from_messages(messages, MODEL, TEMPERATURE)
                    # Convert the string into a JSON object
                    response = json.loads(response)
                elif 'Llama-2' in model or ('Mistral-7b' in model):
                    response = get_completion_from_messages_llama(messages, llm, TEMPERATURE, reasoning=REASONING)
                elif 'bloom' in model:
                    response = get_completion_from_messages_hf(messages, llm)
                else:
                    print('Model should be a GPT or Llama-2 model')
                    return 0
                    
                print(response)
            
                # Append to the list:
                responses[language][n].append(response['response'])
                if REASONING:
                    reasoning[language][n].append(response['reasoning'])
                
        print('*'*50)

    ### Save the results in a csv file:
    for language in LANGUAGES:
        if N_REPETITIONS == 1:
            df[f'responses_{language}'] = responses[language][0]
            if REASONING:
                df[f'reasoning_{language}'] = reasoning[language][0]
                
        for n in range(N_REPETITIONS):
            df[f'responses_{language}_{n}'] = responses[language][n]
            if REASONING:
                df[f'reasoning_{language}_{n}'] = reasoning[language][n]

    if not os.path.exists('responses'):
        os.makedirs('responses')
    if N_REPETITIONS == 1:
        df.to_csv(f"responses/{MODEL}_Temperature{str(TEMPERATURE).replace('.', '_')}.csv", index=False)
    else:
        df.to_csv(f"responses/{MODEL}_Temperature{str(TEMPERATURE).replace('.', '_')}_{N_REPETITIONS}Repetitions.csv", index=False)

def main():
    # Add argparse code to handle command-line arguments
    parser = argparse.ArgumentParser(description="Evaluate Medical Tests Classification in LLMS")
    parser.add_argument("--csv_file", default="data/Portuguese.csv", help="Path to the CSV file with the questions")
    parser.add_argument("--model", default="gpt-3.5-turbo", help="LLM to use e.g: gpt-3.5-turbo, gpt-4, Llama-2-7b, Llama-2-13b, or Llama-2-70b")
    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("--reasoning", action="store_true", default=False, help="Enable reasoning mode. If set to True, the model will be asked to provide a reasoning for its answer. If set to True the model uses more tokens")
    parser.add_argument("--languages", nargs='+', default=['english', 'portuguese'], help="List of languages")
    args = parser.parse_args()


    PATH = args.csv_file
    MODEL = args.model
    TEMPERATURE = args.temperature
    N_REPETITIONS = args.n_repetitions
    REASONING = args.reasoning
    LANGUAGES = args.languages

    llm_language_evaluation(path=PATH, model=MODEL, temperature=TEMPERATURE, n_repetitions=N_REPETITIONS, reasoning=REASONING, languages=LANGUAGES)


if __name__ == "__main__":
    main()

	""" Evaluate Medical Tests Classification in LLMS """
	## Setup
	#### Load the API key and libaries.
	import json
	import pandas as pd
	import os
	import openai
	from dotenv import load_dotenv, find_dotenv
	import argparse
	import re
	import subprocess
	import time


	### Download LLAMA model:
	def download_and_rename(url, filename):
	"""Downloads a file from the given URL and renames it to the given new file name.

	Args:
	url: The URL of the file to download.
	new_file_name: The new file name for the downloaded file.
	"""

	os.makedirs(os.path.dirname(filename), exist_ok=True)

	print(f'Downloading the weights of the model: {url} ...')
	subprocess.run(["wget", "-q", "-O", filename, url])
	print(f'Done!')

	def download_hugging_face_model(model_version='Llama-2-7b'):
	if model_version not in ['Llama-2-7b', 'Llama-2-13b', 'Llama-2-70b', 'Mistral-7b']:
	raise ValueError("Options for Llama model should be 7b, 13b or 70b, or Mistral-7b")

	MODEL_URL = {
	'Llama-2-7b': 'https://huggingface.co/TheBloke/Llama-2-7b-Chat-GGUF/resolve/main/llama-2-7b-chat.Q8_0.gguf',
	'Llama-2-13b': 'https://huggingface.co/TheBloke/Llama-2-13B-chat-GGUF/resolve/main/llama-2-13b-chat.Q8_0.gguf',
	'Llama-2-70b': 'https://huggingface.co/TheBloke/Llama-2-70B-chat-GGUF/resolve/main/llama-2-70b-chat.Q5_0.gguf',
	'Mistral-7b': 'https://huggingface.co/TheBloke/Mistral-7B-Instruct-v0.1-GGUF/resolve/main/mistral-7b-instruct-v0.1.Q8_0.gguf'
	}

	MODEL_URL = MODEL_URL[model_version]

	model_path = f'Models/{model_version}.gguf'

	if os.path.exists(model_path):
	confirmation = input(f"The model file '{model_path}' already exists. Do you want to overwrite it? (yes/no): ").strip().lower()
	if confirmation != 'yes':
	print("Model installation aborted.")
	return model_path

	download_and_rename(MODEL_URL, model_path)

	return model_path

	### Model GPT:
	def get_completion_from_messages(messages,
	model="gpt-3.5-turbo",
	temperature=0,
	max_tokens=500):

	try:
	response = openai.ChatCompletion.create(
	model=model,
	messages=messages,
	temperature=temperature,
	max_tokens=max_tokens,
	request_timeout=10
	)
	except:
	time.sleep(60)
	response = get_completion_from_messages(messages, model=model, temperature=temperature, max_tokens=max_tokens)
	return response

	return response.choices[0].message["content"]

	def get_completion_from_messages_hf(messages,
	model):

	response = model(messages)[0]['generated_text'].replace(messages, '')

	return {'response': response}

	#### Model Llama 2
	def get_completion_from_messages_llama(messages,
	model,
	temperature=0,
	max_tokens=500,
	reasoning=False):
	# Get the response:
	response = model.create_chat_completion(
	messages,
	temperature=temperature,
	max_tokens=max_tokens
	)

	model.set_cache(None)

	response = response['choices'][0]['message']["content"]

	# Convert the string into a JSON object
	# Due to some problems with Llama 2 generating JSON formats, the output requires more preprocessing than GPT.
	try:
	# Use regular expressions to extract JSON
	json_pattern = r'\{.*\}' # Match everything between '{' and '}'
	match = re.search(json_pattern, response, re.DOTALL)
	response = match.group()


	# Define a regex pattern to identify unquoted string values
	pattern = r'("[^"]":\s)([A-Za-z_][A-Za-z0-9_]*)'
	# Use a lambda function to add quotes to unquoted string values
	response = re.sub(pattern, lambda m: f'{m.group(1)}"{m.group(2)}"', response)


	if not reasoning:
	# Convert from {'response': 'A' ) some text without quotes} to {'response': 'A'}
	# Use regular expression to extract the letter and surrounding characters
	match = re.search(r'"response": "([A-Da-d][^\"]*)"', response)

	if match:
	response = f'{{{match.group(0)}}}'

	# Convert
	response = json.loads(response)

	resp = response['response']

	except:
	print(f'Error converting respose to json: {response}')
	print('Generating new response...')
	response = get_completion_from_messages_llama(messages, model=model, temperature=temperature, max_tokens=max_tokens, reasoning=reasoning)
	return response

	if reasoning:
	# Iterate through the keys of the dictionary
	for key in list(response.keys()):
	if 'reas' in key.lower():
	# Update the dictionary with the new key and its corresponding value
	response['reasoning'] = response.pop(key)

	return response

	#### Template for the Questions
	def generate_question(question, LANGUAGES, REASONING, Responses=['A', 'B', 'C', 'D']):

	delimiter = "####"

	languages_text = ", ".join(LANGUAGES)

	if REASONING:
	system_message = f"""
	You will be provided with medical queries in this languages: {languages_text}. \
	The medical query will be delimited with {delimiter} characters.
	Each question will have {len(Responses)} possible answer options.\
	provide the letter with the answer and a short sentence answering why the answer was selected \

	Provide your output in json format with the \
	keys: response and reasoning.

	Responses: {", ".join(Responses)}.
	"""
	else:
	system_message = f"""
	You will be provided with medical queries in this languages: {languages_text}. \
	The medical query will be delimited with {delimiter} characters.
	Each question will have {len(Responses)} possible answer options.\
	Provide only the letter with the response.

	Provide your output in json format with:
	the key: response.

	Responses: {", ".join(Responses)}.

	E.g. if response is 'a', the output should be: {{"response" : "a"}}
	"""

	user_message = f"""/
	{question}"""

	messages = [
	{'role':'system',
	'content': system_message},
	{'role':'user',
	'content': f"{delimiter}{user_message}{delimiter}"},
	]

	return messages

	def generate_template_text_generation(question, LANGUAGES, Responses=['A', 'B', 'C', 'D']):

	delimiter = "####"

	languages_text = ", ".join(LANGUAGES)

	messages = f"""You will be provided with medical queries in this languages: {languages_text}. \
	The medical query will be delimited with {delimiter} characters.
	Each question will have {len(Responses)} possible answer options.Provide just the letter with the answer.

	Responses: {", ".join(Responses)}.

	Question:
	{delimiter}{question}{delimiter}

	The response is: """

	return messages

	#### Template for the Questions
	def generate_question_llama(question, LANGUAGES, REASONING, Responses=['A', 'B', 'C', 'D']):

	delimiter = "####"

	out_template = ""

	if REASONING:
	output_keys = ['response', 'reasoning']
	else:
	output_keys = ['response']

	for response in Responses:
	response_dict = {key: f'something describing {key}' for key in output_keys}
	response_dict[output_keys[0]] = response
	response_str = ', '.join([f"'{k}': '{v}'" for k, v in response_dict.items()])
	out_template += f"If response is {response}: {{ {response_str} }}\n"

	languages_text = ", ".join(LANGUAGES)

	if REASONING:
	system_message = f"""
	You will be provided with medical queries in this languages: {languages_text}. \
	The medical query will be delimited with \
	{delimiter} characters.
	Each question will have {len(Responses)} possible answer options.\
	provide just the letter with the answer and a short sentence answering why the answer was selected.

	Provide your output in json format with the \
	keys: response and reasoning. Make sure to always use the those keys, do not modify the keys.

	Response option: {", ".join(Responses)}.

	Always use the JSON format.

	The output shoulb be: {{"response": "Response option", "", ""}}
	"""
	else:
	system_message = f"""
	You will be provided with medical queries in this languages: {languages_text}. \
	The medical query will be delimited with \
	{delimiter} characters.
	Each question will have {len(Responses)} possible answer options.\
	provide just the letter with the answer.

	Provide your output in json format with the \
	key: response. Make sure to always use the that key, do not modify the key.

	Response option: {", ".join(Responses)}.

	Always use the JSON format.

	The output shoulb be: {{"response": "Response option"}}
	"""

	user_message = f"""/
	{question}"""

	messages = [
	{'role':'system',
	'content': system_message},
	{'role':'user',
	'content': f"{delimiter}{user_message}{delimiter}"},
	]

	return messages


	def llm_language_evaluation(path='data/Portuguese.csv', model='gpt-3.5-turbo', temperature=0.0, n_repetitions=1, reasoning=False, languages=['english', 'portuguese']):

	# Load API key if GPT, or Model if LLAMA
	if 'gpt' in model:
	_ = load_dotenv(find_dotenv()) # read local .env file
	openai.api_key = os.environ['OPENAI_API_KEY']
	elif 'Llama-2' in model or ('Mistral-7b' in model):
	model_path = download_hugging_face_model(model_version=model)
	from llama_cpp import Llama
	llm = Llama(model_path=model_path, verbose=False, n_ctx=2048)
	elif 'bloom':
	from transformers import pipeline
	llm = pipeline(
	task="text-generation",
	model=model,
	model_kwargs={"temperature": temperature, "max_length": 5})
	reasoning = False
	else:
	print('Model should be a GPT or Llama-2 model')
	return 0

	#### Load the Constants
	PATH = path # 'data/Portuguese.csv'
	MODEL = model # "gpt-3.5-turbo"
	TEMPERATURE = temperature # 0.0
	N_REPETITIONS = n_repetitions # 1
	REASONING = reasoning # False
	LANGUAGES = languages # ['english', 'portuguese']

	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


	### Questions from a csv file:
	df = pd.read_csv(PATH)

	### Evaluate the model in question answering per language:
	responses = {}
	reasoning = {}
	for language in LANGUAGES:
	responses[language] = [[] for n in range(N_REPETITIONS)]

	if REASONING:
	reasoning[language] = [[] for n in range(N_REPETITIONS)]

	for row in range(df.shape[0]):
	print(''50)
	print(f'Question {row+1}: ')
	for language in LANGUAGES:
	print(f'Language: {language}')
	question = df[language][row]
	print('Question: ')
	print(question)
	if 'gpt' in model:
	messages = generate_question(question, LANGUAGES, REASONING)
	elif 'Llama-2' in model or ('Mistral-7b' in model):
	messages = generate_question_llama(question, LANGUAGES, REASONING)
	elif 'bloom' in model:
	messages = generate_template_text_generation(question, LANGUAGES)
	else:
	print('Model should be a GPT or Llama-2 model')
	return 0

	for n in range(N_REPETITIONS):
	print(f'Test #{n}: ')

	if 'gpt' in model:
	response = get_completion_from_messages(messages, MODEL, TEMPERATURE)
	# Convert the string into a JSON object
	response = json.loads(response)
	elif 'Llama-2' in model or ('Mistral-7b' in model):
	response = get_completion_from_messages_llama(messages, llm, TEMPERATURE, reasoning=REASONING)
	elif 'bloom' in model:
	response = get_completion_from_messages_hf(messages, llm)
	else:
	print('Model should be a GPT or Llama-2 model')
	return 0

	print(response)

	# Append to the list:
	responses[language][n].append(response['response'])
	if REASONING:
	reasoning[language][n].append(response['reasoning'])

	print(''50)

	### Save the results in a csv file:
	for language in LANGUAGES:
	if N_REPETITIONS == 1:
	df[f'responses_{language}'] = responses[language][0]
	if REASONING:
	df[f'reasoning_{language}'] = reasoning[language][0]

	for n in range(N_REPETITIONS):
	df[f'responses_{language}_{n}'] = responses[language][n]
	if REASONING:
	df[f'reasoning_{language}_{n}'] = reasoning[language][n]

	if not os.path.exists('responses'):
	os.makedirs('responses')
	if N_REPETITIONS == 1:
	df.to_csv(f"responses/{MODEL}_Temperature{str(TEMPERATURE).replace('.', '_')}.csv", index=False)
	else:
	df.to_csv(f"responses/{MODEL}_Temperature{str(TEMPERATURE).replace('.', '_')}_{N_REPETITIONS}Repetitions.csv", index=False)

	def main():
	# Add argparse code to handle command-line arguments
	parser = argparse.ArgumentParser(description="Evaluate Medical Tests Classification in LLMS")
	parser.add_argument("--csv_file", default="data/Portuguese.csv", help="Path to the CSV file with the questions")
	parser.add_argument("--model", default="gpt-3.5-turbo", help="LLM to use e.g: gpt-3.5-turbo, gpt-4, Llama-2-7b, Llama-2-13b, or Llama-2-70b")
	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("--reasoning", action="store_true", default=False, help="Enable reasoning mode. If set to True, the model will be asked to provide a reasoning for its answer. If set to True the model uses more tokens")
	parser.add_argument("--languages", nargs='+', default=['english', 'portuguese'], help="List of languages")
	args = parser.parse_args()


	PATH = args.csv_file
	MODEL = args.model
	TEMPERATURE = args.temperature
	N_REPETITIONS = args.n_repetitions
	REASONING = args.reasoning
	LANGUAGES = args.languages

	llm_language_evaluation(path=PATH, model=MODEL, temperature=TEMPERATURE, n_repetitions=N_REPETITIONS, reasoning=REASONING, languages=LANGUAGES)


	if __name__ == "__main__":
	main()