it

app.py

@@ -3,7 +3,8 @@ import gradio as gr
 from typo_check import css, process_input,MODEL_OPTIONS_TYPO
 from title_gen import generate_title, MODEL_OPTIONS_TITLE
 from content_gen import generate_content, MODEL_OPTIONS_CONTENT, get_default_prompt
-from instruct_dv import generate_response, MODEL_OPTIONS_INSTRUCT 
+from instruct_dv import generate_response, MODEL_OPTIONS_INSTRUCT
+from instruct_dv_tuned import generate_response_tuned, MODEL_OPTIONS_INSTRUCT_TUNED
 from en_dv_latin import translate, MODEL_OPTIONS_TRANSLATE
 
 def update_textbox_direction(direction):
@@ -216,14 +217,15 @@ All outputs generated are synthetic, created using fine-tuned models for experim
             with gr.Row():
                 model_choice = gr.Dropdown(choices=list(MODEL_OPTIONS_INSTRUCT.keys()), value=list(MODEL_OPTIONS_INSTRUCT.keys())[0], label="Model")
             with gr.Row():
+                max_tokens_slider = gr.Slider(10, 512, value=256, label="Max New Tokens")
                 seed = gr.Slider(0, 10000, value=42, step=1, label="Random Seed")
-                use_sampling = gr.Checkbox(label="Use Sampling (Creative/Random)", value=True)
+                use_sampling = gr.Checkbox(label="Use Sampling (Creative/Random)", value=False)
             with gr.Row():
                 generated_response = gr.Textbox(label="Model Response", rtl=True, elem_classes="textbox1")
             generate_btn = gr.Button("Generate Response")
             generate_btn.click(
                 fn=generate_response,
-                inputs=[instruction, input_text, seed, use_sampling, model_choice],
+                inputs=[instruction, input_text, seed, use_sampling, model_choice,max_tokens_slider,num_beams_slider],
                 outputs=generated_response
             )
             gr.Examples(
@@ -240,6 +242,49 @@ All outputs generated are synthetic, created using fine-tuned models for experim
 - This tab allows you to give instructions to the model, optionally with input text, for general-purpose generation or task following in Dhivehi.
 - Try different seeds or enable sampling for more creative outputs.
 - The model is experimental and may not always follow instructions perfectly.
+""")
+
+        with gr.Tab("Instruction Tuned"):
+            gr.Markdown("# <center>Dhivehi Instruction-Tuned Model</center>")
+            gr.Markdown("Generate answers by providing a custom instruction and optional input. This instruction-tuned model is designed for better format awareness, task generalization, and stronger alignment with user intent.")
+            with gr.Row():
+                instruction = gr.Textbox(lines=2, label="Instruction", rtl=True, elem_classes="textbox1")
+            with gr.Row():
+                input_text = gr.Textbox(lines=2, label="Input Text (optional)", rtl=True, elem_classes="textbox1")
+            with gr.Row():
+                model_choice = gr.Dropdown(choices=list(MODEL_OPTIONS_INSTRUCT_TUNED.keys()), value=list(MODEL_OPTIONS_INSTRUCT_TUNED.keys())[0], label="Model")
+            with gr.Row():
+                max_tokens = gr.Slider(64, 1024, value=768, step=16, label="Max New Tokens")
+                temperature = gr.Slider(0.0, 1.5, value=0.7, step=0.1, label="Temperature")
+                num_beams = gr.Slider(1, 8, value=4, step=1, label="Number of Beams")
+            with gr.Row():
+                generated_response = gr.Textbox(label="Model Response", rtl=True, elem_classes="textbox1")
+            generate_btn = gr.Button("Generate Response")
+            generate_btn.click(
+                fn=generate_response_tuned,
+                inputs=[instruction, input_text, seed, model_choice,max_tokens,temperature,num_beams],
+                outputs=generated_response
+            )
+            gr.Examples(
+                examples=[
+                    ["ދީފައިވާ މައުޟޫޢާ ބެހޭގޮތުން ކުރު ޕެރެގްރާފެއް ލިޔެލާށެވެ.","އިއާދަކުރަނިވި ހަކަތަ ބޭނުންކުރުމުގެ މުހިންމުކަން"],
+                    ["ދިގުމިނުގެ މިންވަރުތައް ބަދަލުކުރުން.","1 ކިލޯމީޓަރ"],
+                    ["ދެ މޯބައިލް ފޯނެއްގެ ފީޗާސް އަޅާކިޔާށެވެ.","އައިފޯން 11 ޕްރޯ އަދި ސެމްސަންގް ގެލެކްސީ އެސް20 އަލްޓްރާ"],
+                    ["މަސައްކަތްތައް ފައިދާހުރި ގޮތެއްގައި ހަވާލުކުރުމަށް އަޅަންޖެހޭ ފިޔަވަޅުތައް ބަޔާންކުރުން.",""],
+                    ["އާ މޯބައިލް އެޕް ޕްރޮމޯޓް ކުރުމަށް މާކެޓިންގ ސްޓްރެޓެޖީތަކުގެ ލިސްޓެއް އުފެއްދުން.",""],
+                    ["ދިގުމިނުގައި 10ސެންޓިމީޓަރު އަދި ފުޅާމިނަކީ 5ސެންޓިމީޓަރު ހުންނަ ރެކްޓަންގްލަރެއްގެ ސަރަހައްދު ހިސާބުކުރުން.",""],
+                    ["ތިރީގައިވާ ބަސްފުޅު ތެދެއް ނުވަތަ ދޮގުގެ ގޮތުގައި ގިންތިކުރުން.","ސުޕްރީމް ކޯޓަކީ އެމެރިކާގެ އެންމެ މަތީ ކޯޓެވެ."],
+                ],
+                inputs=[instruction, input_text],
+            )
+            gr.Markdown("""
+### 📝 Notes:
+- This model is **instruction-tuned** using Dhivehi data, designed to follow a wide variety of instructions.
+- Provide both an instruction and input for best results, but input is optional for tasks like open-ended generation.
+- Use **temperature** > 0 for more diverse outputs, or set to **0** for deterministic answers.
+- **Number of beams** increases quality at the cost of speed.
+- Assuming the model will have **better format awareness**, can handle **multiple task types**, and often **align more closely with your intent**. (Have to test)
+- This model is experimental and may not always follow instructions perfectly. 
 """)
 
         with gr.Tab("Translation Tasks"):

instruct_dv.py

@@ -1,7 +1,7 @@
 import random
 import numpy as np
 import torch
-from transformers import T5Tokenizer, T5ForConditionalGeneration
+from transformers import AutoTokenizer, T5ForConditionalGeneration
 import spaces
 
 
@@ -17,7 +17,7 @@ MODEL_CACHE = {}
 def get_model_and_tokenizer(model_dir):
     if model_dir not in MODEL_CACHE:
         print(f"Loading model: {model_dir}")
-        tokenizer = T5Tokenizer.from_pretrained(model_dir)
+        tokenizer = AutoTokenizer.from_pretrained(model_dir)
         model = T5ForConditionalGeneration.from_pretrained(model_dir)
         device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
         print(f"Moving model to device: {device}")
@@ -29,7 +29,7 @@ max_input_length = 256
 max_output_length = 256
 
 @spaces.GPU()
-def generate_response(instruction, input_text, seed, use_sampling, model_choice):
+def generate_response(instruction, input_text, seed, use_sampling, model_choice,max_tokens,num_beams):
     random.seed(seed)
     np.random.seed(seed)
     torch.manual_seed(seed)
@@ -52,6 +52,7 @@ def generate_response(instruction, input_text, seed, use_sampling, model_choice)
     gen_kwargs = {
         "input_ids": inputs["input_ids"],
         "attention_mask": inputs["attention_mask"],
+        "max_new_tokens":max_tokens,
         "max_length": max_output_length,
         "no_repeat_ngram_size": 3,
         "repetition_penalty": 1.5,

instruct_dv_tuned.py

@@ -0,0 +1,68 @@
+import random
+import numpy as np
+import torch
+from transformers import AutoTokenizer, T5ForConditionalGeneration
+import spaces
+
+
+# Available models
+MODEL_OPTIONS_INSTRUCT_TUNED = {
+    "EXT1 Model": "alakxender/flan-t5-base-alpaca-dv-ext"
+}
+
+# Cache for loaded models/tokenizers
+MODEL_CACHE = {}
+
+def get_model_and_tokenizer(model_dir):
+    if model_dir not in MODEL_CACHE:
+        print(f"Loading model: {model_dir}")
+        tokenizer = AutoTokenizer.from_pretrained(model_dir)
+        model = T5ForConditionalGeneration.from_pretrained(model_dir)
+        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        print(f"Moving model to device: {device}")
+        model.to(device)
+        MODEL_CACHE[model_dir] = (tokenizer, model)
+    return MODEL_CACHE[model_dir]
+
+@spaces.GPU()
+def generate_response_tuned(instruction, input_text, seed, model_choice,max_tokens, temperature, num_beams):
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed_all(seed) 
+
+    model_dir = MODEL_OPTIONS_INSTRUCT_TUNED[model_choice]
+    tokenizer, model = get_model_and_tokenizer(model_dir)
+
+    combined_input = f"{instruction.strip()} {input_text.strip()}" if input_text else instruction.strip()
+    inputs = tokenizer(
+        combined_input,
+        return_tensors="pt",
+        truncation=True
+    )
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    inputs = {k: v.to(device) for k, v in inputs.items()}
+
+    gen_kwargs = {
+        **inputs,
+        "max_length":max_tokens,
+        "num_beams":num_beams,
+        "do_sample":(temperature > 0.0),
+        "temperature":temperature,
+        "repetition_penalty":1.2,
+        "top_p":0.95,
+        "top_k":50
+    }
+
+    with torch.no_grad():
+        outputs = model.generate(**gen_kwargs)
+    decoded_output = tokenizer.decode(outputs[0], skip_special_tokens=True)
+    
+    # Trim to the last period
+    if '.' in decoded_output:
+        last_period = decoded_output.rfind('.')
+        decoded_output = decoded_output[:last_period+1]
+
+    decoded_output = ' '.join(decoded_output.split())
+    return decoded_output