Update app.py

app.py

@@ -1,20 +1,282 @@
+from unsloth import FastLanguageModel
+import torch
 import gradio as gr
+model,tokenizer = FastLanguageModel.from_pretrained('./unified_model')
 
-def generate_response(instruction):
-    """Generates a response using your fine-tuned model."""
-    ##FastLanguageModel.for_inference(model) # Enable native 2x faster inference within the function
+def generate_response_true_false(instruction):
+    """
+    Generates a response using your fine-tuned model based on the provided instruction.
+
+    This function enables faster inference through the `FastLanguageModel` and prepares a
+    prompt for the model to determine whether the given statement is "True" or "False".
+
+    Args:
+        instruction (str): A string containing the statement and instructions to be evaluated.
+
+    Returns:
+        str: "True" or "False" based on the model's response, or "Unable to determine" if the
+             response cannot be parsed reliably.
+    """
+    FastLanguageModel.for_inference(model) # Enable native 2x faster inference within the function
+    prompt = f"""### Instruction:
+Determine if the following statement is true or false. Respond only with "True" or "False".
+
+### Statement:
+{instruction}
+
+### Answer:"""
+
+    inputs = tokenizer(prompt, return_tensors="pt").to("cuda")
+    with torch.no_grad():
+        outputs = model.generate(**inputs, max_new_tokens=50)
+
+    response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+    response = response.split("### Answer:")[-1].strip()
+
+    # Extract True/False from response
+    if response.lower() == "true":
+        return "True"
+    elif response.lower() == "false":
+        return "False"
+    else:
+        # Try to identify the answer even if it's not perfectly formatted
+        if "true" in response.lower():
+            return "True"
+        elif "false" in response.lower():
+            return "False"
+        else:
+            return "Unable to determine."
+
+def generate_response_open_ended(instruction):
+    """
+    Generates a response using your fine-tuned model based on the provided instruction.
+
+    This function enables faster inference through the `FastLanguageModel` and prepares a
+    prompt for the model to determine whether the given statement is "True" or "False".
+
+    Args:
+        instruction (str): A string containing the statement and instructions to be evaluated.
+
+    Returns:
+        str: A response from the model to the provided question or "Unable to determine" if the
+             response cannot be parsed reliably.
+    """
+    FastLanguageModel.for_inference(model) # Enable native 2x faster inference within the function
     prompt = f"""### Instruction:
 Answer the provided question with the knowledge provided to you
 ### Question:
 {instruction}
+
 ### Answer:
 """
-    return prompt
 
+    inputs = tokenizer(prompt, return_tensors="pt").to("cuda")
+    with torch.no_grad():
+        outputs = model.generate(**inputs,early_stopping=False,min_length=50,length_penalty=2,max_length=300)
+    response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+    return response
+
+def generate_response_multiple_choice(instruction,choice_A,choice_B,choice_C,choice_D):
+    """
+    Generates a response using a fine-tuned language model for multiple-choice questions.
+
+    Args:
+        instruction (str): A string containing the question and its options.
+
+    Returns:
+        dict: A dictionary with the selected choice and its justification.
+              Example:
+              {
+                  "choice": "A",
+                  "justification": "Explanation for why Option A is correct."
+              }
+              If the model fails to provide a valid response, defaults to:
+              {
+                  "choice": "None",
+                  "justification": "Could not parse JSON"
+              }
+    """
+    # Enable native faster inference for the model
+    FastLanguageModel.for_inference(model)
+
+    # Define the prompt with a detailed instruction for the model
+    prompt = f"""### Instruction:
+    In the following question, you are provided with 4 choices. Select the best choice based on the knowledge provided and provide a justification for that choice.
+
+    **You must return only your response with the following keys:**
+      - "choice": The best choice letter
+      - "justification": The justification for your choice
+
+    **Example Response:**
+      **choice**: A
+      **justification**: Explanation for why Option A is correct
+
+    ### Question:
+    {instruction}
+
+    ### Choices:
+    A) {choice_A}
+    B) {choice_B}
+    C) {choice_C}
+    D) {choice_D}
+
+    ### Answer:
+    """
+
+    # Tokenize the prompt and move it to GPU for inference
+    inputs = tokenizer(prompt, return_tensors="pt").to("cuda")
+
+    # Generate a response from the model
+    with torch.no_grad():
+        outputs = model.generate(
+            **inputs,
+            early_stopping=True,
+            min_length=50,
+            length_penalty=2,
+            do_sample=True,
+            max_new_tokens=300,
+            top_p=0.95,
+            top_k=50,
+            temperature=0.7,
+            num_return_sequences=1
+        )
+
+    # Decode the response into text
+    response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+    return response
+
+def true_false_greet(question):
+    if question == "":
+        # Return a default response if no input is given
+        return "No question was given to answer"
+    else:
+        # Call a placeholder function (must be implemented separately)
+        response = generate_response_true_false(question)  # Note: This function is not defined in this code
+        return f"{response}!"
+
+def open_ended_greet(question):
+    """
+    Processes the user's question and returns a response.
+
+    Args:
+        question (str): The input text provided by the user.
+
+    Returns:
+        str: A processed response. If no input is given, a default message is returned.
+    """
+    if question == "":
+        # Return a default response if no question is provided
+        return "No question was given to answer"
+    else:
+        # Call a placeholder function (must be implemented separately) to generate a response
+        response = generate_response_open_ended(question)  # Note: generate_response is not defined in this snippet
+        
+        # Extract the answer from the generated response by splitting on "### Answer:"
+        response = response.split('### Answer:')[1]
+        
+        # Return the formatted response
+        return f"{response}!"
+
+def multiple_choice_greet(question, choice_A, choice_B, choice_C, choice_D):
+    """
+    Processes the user's question and multiple-choice options to generate a response.
+
+    Args:
+        question (str): The input question provided by the user.
+        choice_A (str): Option A for the question.
+        choice_B (str): Option B for the question.
+        choice_C (str): Option C for the question.
+        choice_D (str): Option D for the question.
+
+    Returns:
+        str: A response based on the input. 
+             If no question is provided, returns a default message.
+             If no choices are provided, returns a default message.
+    """
+    if question == "":
+        # Return a default response if no question is provided
+        return "No question was given to answer"
+    if choice_A == "" and choice_B == "" and choice_C == "" and choice_D == "":
+        # Return a default response if no choices are provided
+        return "No choice was given"
+    else:
+        # Call a placeholder function (must be implemented separately) to generate a response
+        response = generate_response_multiple_choice(question, choice_A, choice_B, choice_C, choice_D)
+        
+        # Extract the answer from the generated response by splitting on "### Answer:"
+        response = response.split('### Answer:')[1]
+        
+        # Return the formatted response
+        return f"{response}"
+
+def show_true_false_interface():
+    return gr.update(visible=True), gr.update(visible=False), gr.update(visible=False)
+
+def show_open_ended_interface():
+    return gr.update(visible=False), gr.update(visible=True), gr.update(visible=False)
+
+def show_multiple_choice_interface():
+    return gr.update(visible=False), gr.update(visible=False), gr.update(visible=True)
+
+with gr.Blocks() as demo:
+
+    with gr.Row():
+        btn_t_f = gr.Button('True/False questions')
+        btn_open_ended = gr.Button('Open-Ended questions')
+        btn_m_c = gr.Button('Multiple-Choice questions')
+
+    with gr.Column(visible=True) as true_false_interface:
+        gr.Markdown("## True-False Template")
+        question_simple = gr.Textbox(label="Enter your question")
+        simple_output = gr.Textbox(label="Output", interactive=False)
+        submit_simple = gr.Button("Submit")
+        submit_simple.click(true_false_greet, inputs=question_simple, outputs=simple_output)
+
+    with gr.Column(visible=False) as open_ended_interface:
+        gr.Markdown("## Open Ended Template")
+        question_simple = gr.Textbox(label="Enter your question")
+        simple_output = gr.Textbox(label="Output", interactive=False)
+        submit_simple = gr.Button("Submit")
+        submit_simple.click(open_ended_greet, inputs=question_simple, outputs=simple_output)
+
+    
+    with gr.Column(visible=False) as mc_interface:
+        gr.Markdown("## Multiple-Choice Template")
+        question_mc = gr.Textbox(label="Enter your question")
+        choice_A = gr.Textbox(label="Choice A")
+        choice_B = gr.Textbox(label="Choice B")
+        choice_C = gr.Textbox(label="Choice C")
+        choice_D = gr.Textbox(label="Choice D")
+        mc_output = gr.Textbox(label="Output", interactive=False)
+        submit_mc = gr.Button("Submit")
+        submit_mc.click(multiple_choice_greet, inputs=[question_mc, choice_A, choice_B, choice_C, choice_D], outputs=mc_output)
+
+    btn_t_f.click(show_true_false_interface, outputs=[true_false_interface, open_ended_interface, mc_interface])
+    btn_open_ended.click(show_open_ended_interface, outputs=[true_false_interface, open_ended_interface, mc_interface])
+    btn_m_c.click(show_multiple_choice_interface, outputs=[true_false_interface, open_ended_interface, mc_interface])
+
+# def generate_response(instruction):
+#     """Generates a response using your fine-tuned model."""
+#     FastLanguageModel.for_inference(model) # Enable native 2x faster inference within the function
+#     prompt = f"""### Instruction:
+# Answer the provided question with the knowledge provided to you
+# ### Question:
+# {instruction}
+
+# ### Answer:
+# """
+
+#     inputs = tokenizer(prompt, return_tensors="pt").to("cuda")
+#     with torch.no_grad():
+#         outputs = model.generate(**inputs,early_stopping=False,min_length=50,length_penalty=2,max_length=300)
+#     response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+#     return response
+
+# def greet(user_question):
+#     response = generate_response(user_question)
+#     return f"{response}!"
 
-def greet(user_question):
-    response = generate_response(user_question)
-    return f"{response}!"
+# # Create a Gradio interface with text input and output
+# gr.Interface(fn=greet, inputs="text", outputs="text", title = 'Test on Multiple Choice Questions').launch()
 
-# Create a Gradio interface with text input and output
-gr.Interface(fn=greet, inputs="text", outputs="text").launch(debug=True)
+demo.launch(debug=True)