Update README.md

README.md

@@ -16,12 +16,13 @@ license_link: https://ai.google.dev/gemma/terms
 This is an adapter prepared to return True or False depending on whether the student's answer ("student_answer") is correct based on the question ("question") and comparing it with a given answer ("best_answer").
 The prompt has the following structure:
 ```
-<s>[INST]Analyze the question, the expected answer, and the student's response.
-Determine if the student's answer is correct or not. It only returns True if the student's answer is correct with respect to the expected answer or False otherwise.
-Add a brief comment explaining why the answer is correct or incorrect.\n\n
-Question: {question}\n
-Expected Answer: {best_answer}\n
-Student Answer: {student_answer}[/INST]"
+<start_of_turn>user\n
+Analyze the question, the expected answer, and the student's response. Determine if the student's answer is conceptually correct in relation to the expected answer, regardless of the exact wording. An answer will be considered correct if it accurately identifies the key information requested in the question, even if expressed differently. Return True if the student's answer is correct or False otherwise. Add a brief comment explaining the rationale behind the answer being correct or incorrect.
+
+Question: {question}
+Expected Answer: {best_answer}
+Student Answer: {student_answer}<end_of_turn>\n
+<start_of_turn>model"
 ```
 
 
@@ -29,64 +30,72 @@ Student Answer: {student_answer}[/INST]"
 In Google Colab:
 ```
 
-!pip install -q -U transformers peft accelerate optimum
-!pip install datasets==2.15.0
-!pip install auto-gptq --extra-index-url https://huggingface.github.io/autogptq-index/whl/cu117/
+!pip install -q -U bitsandbytes
+!pip install -q -U git+https://github.com/huggingface/transformers.git
+!pip install -q -U git+https://github.com/huggingface/peft.git
+!pip install -q -U git+https://github.com/huggingface/accelerate.git
+!pip install -q -U gradio
 
+from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig, GemmaTokenizer
 from peft import AutoPeftModelForCausalLM
-from rich import print
-from transformers import GenerationConfig, AutoTokenizer
-
 import torch
+import re
+
+# Carga el modelo y el tokenizer
+model_id = "google/gemma-7b-it"
+adapter = "nmarafo/Gemma-7B-it-4bit-TrueFalse-Feedback"
+
+bnb_config = BitsAndBytesConfig(
+    load_in_4bit=True,
+    bnb_4bit_quant_type="nf4",
+    bnb_4bit_compute_dtype=torch.bfloat16
+)
 
-model_id = "TheBloke/Mistral-7B-Instruct-v0.2-GPTQ"
-adapter = "nmarafo/Mistral-7B-Instruct-v0.2-TrueFalse-Feedback-GPTQ"
+tokenizer = AutoTokenizer.from_pretrained(model_id)
 
-tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True, return_token_type_ids=False)
-tokenizer.pad_token = tokenizer.eos_token
+model = AutoPeftModelForCausalLM.from_pretrained(adapter, quantization_config=bnb_config, device_map={"":0})
 
-model = AutoPeftModelForCausalLM.from_pretrained(adapter, low_cpu_mem_usage=True, return_dict=True, torch_dtype=torch.float16, device_map="cuda")
+def predict(question, best_answer, student_answer, language, temperature, top_p, top_k):
+    if language == "English":
+        system_message = "Analyze the question, the expected answer, and the student's response. Determine if the student's answer is conceptually correct in relation to the expected answer, regardless of the exact wording. Return True if the student's answer is correct or False otherwise. Add a brief comment explaining the rationale behind the answer being correct or incorrect."
+    else:  # Asumimos que cualquier otra opción será Español
+        system_message = "Analiza la pregunta, la respuesta esperada y la respuesta del estudiante. Determina si la respuesta del estudiante es conceptualmente correcta en relación con la respuesta esperada, independientemente de la redacción exacta. Devuelve Verdadero si la respuesta del estudiante es correcta o Falso en caso contrario. Añade un breve comentario explicando el razonamiento detrás de la corrección o incorrección de la respuesta."
 
-def predict(question, best_answer, student_answer):
-    system_message = "Analyze the question, the expected answer, and the student's response. Determine if the student's answer is conceptually correct in relation to the expected answer, regardless of the exact wording. Return True if the student's answer is correct or False otherwise. Add a brief comment explaining the rationale behind the answer being correct or incorrect."
-    prompt = f"{system_message}\n\nQuestion: {question}\nBest Answer: {best_answer}\nStudent Answer: {student_answer}"
-    prompt_template=f"<s>[INST]{prompt}[/INST]"
+    prompt = f"{system_message}\n\nQuestion: {question}\nExpected Answer: {best_answer}\nStudent Answer: {student_answer}"
+    prompt_template=f"<start_of_turn>user\n{prompt}<end_of_turn>\n<start_of_turn>model"
 
-    encoding = tokenizer(prompt_template, return_tensors='pt', padding=True, truncation=True, max_length=512)
+    encoding = tokenizer(prompt_template, return_tensors='pt', padding=True, truncation=True, max_length=256)
     input_ids = encoding['input_ids'].cuda()
     attention_mask = encoding['attention_mask'].cuda()
 
-    output = model.generate(input_ids, attention_mask=attention_mask, 
-                            temperature=0.7, do_sample=True, top_p=0.95, 
-                            top_k=40, max_new_tokens=512, pad_token_id=tokenizer.eos_token_id)
+    output = model.generate(input_ids, attention_mask=attention_mask,
+                            temperature=temperature, do_sample=True, top_p=top_p,
+                            top_k=top_k, max_new_tokens=256, pad_token_id=tokenizer.eos_token_id)
     response = tokenizer.decode(output[0], skip_special_tokens=True)
-    return response
-
-question="Mention all the Canary Island"
-best_answer="Tenerife, Fuerteventura, Gran Canaria, Lanzarote, La Palma, La Gomera, El Hierro, La Graciosa"
-student_answer="Tenerife"
-
-print(predict(question, best_answer, student_answer))    
+    pattern = r"\[INST\].*?\[\/INST\]\s*(True|False)"
+    cleaned_response = re.sub(pattern, r"\1", response, flags=re.DOTALL)
+
+    return
+
+import gradio as gr
+
+iface = gr.Interface(
+    fn=predict,
+    inputs=[
+        gr.Textbox(lines=2, placeholder="Pregunta"),
+        gr.Textbox(lines=2, placeholder="Mejor Respuesta"),
+        gr.Textbox(lines=2, placeholder="Respuesta del Estudiante"),
+        gr.Radio(choices=["English", "Español"], label="Idioma"),
+        gr.Slider(minimum=0.1, maximum=1.0, step=0.1, value=0.5, label="Temperature"),
+        gr.Slider(minimum=0.1, maximum=1.0, step=0.01, value=0.49, label="Top P"),
+        gr.Slider(minimum=0, maximum=100, step=1, value=40, label="Top K")
+    ],
+    outputs=gr.Textbox(label="Respuesta del Modelo")
+)
+iface.launch(share=True,debug=True)    
 
 ```
 
-# To perform inference on the test dataset example load the model from the checkpoint
-persisted_model = AutoPeftModelForCausalLM.from_pretrained(
-    adapter,
-    low_cpu_mem_usage=True,
-    return_dict=True,
-    torch_dtype=torch.float16,
-    device_map="cuda")
-# Some gen config knobs
-generation_config = GenerationConfig(
-    penalty_alpha=0.6, 
-    do_sample = True, 
-    top_k=5, 
-    temperature=0.5, 
-    repetition_penalty=1.2,
-    max_new_tokens=512
-)
-
 
 ### Framework versions