Fine-tune script, evaluation pipeline, and dataset updates

configs/train_config.yaml

@@ -1,4 +1,4 @@
-model_name: "llama-base"
+model_name: "gpt2"
 learning_rate: 5e-5
 batch_size: 16
 num_epochs: 3

data/processed/test.json

@@ -0,0 +1,3 @@
+{"text": "This is a test sentence to evaluate the model."}
+{"text": "Another example test input for language generation."}
+{"text": "Testing the fine-tuned model with unseen data."}

demo_app/app.py

@@ -4,14 +4,34 @@ from transformers import pipeline
 st.title("Fine-tuned LLM Demo")
 
 # Load a model pipeline (replace 'gpt2' with your actual model repo id if needed)
-generator = pipeline('text-generation', model='gpt2')
+generator = pipeline('text-generation', model='promptsbyesha/llm-finetuned-model')
 
+
+# Prompt input
 prompt = st.text_input("Enter prompt:")
 
-# Add a slider to select number of responses
+# Slider to select number of responses
 num_responses = st.slider("Number of responses", min_value=1, max_value=5, value=1)
 
+# Additional context input (optional)
+extra_context = st.text_area("Additional context (optional):", "")
+
 if prompt:
-    results = generator(prompt, max_length=100, num_return_sequences=num_responses)
+    # Step 1: Display original prompt and additional context
+    st.markdown(f"**Step 1: Prompt:** {prompt}")
+    if extra_context.strip():
+        st.markdown(f"**Step 1b: Context:** {extra_context}")
+
+    # Step 2: Combine prompt and context for model inference
+    full_prompt = prompt + " " + extra_context if extra_context.strip() else prompt
+    results = generator(full_prompt, max_length=100, num_return_sequences=num_responses)
+
+    # Step 3: Display generated outputs
     for i, result in enumerate(results):
         st.write(f"Output {i+1}: {result['generated_text']}")
+
+    # Step 4: Example post-processing (uppercase conversion as placeholder)
+    processed_outputs = [result['generated_text'].upper() for result in results]
+    st.markdown("**Step 4: Post-processed Outputs:**")
+    for i, output in enumerate(processed_outputs):
+        st.write(f"Processed Output {i+1}: {output}")

src/model/evaluate.py

@@ -0,0 +1,44 @@
+from transformers import AutoModelForCausalLM, AutoTokenizer, Trainer, TrainingArguments
+from datasets import load_dataset
+import yaml
+
+def load_config(config_path):
+    import yaml
+    with open(config_path, "r") as f:
+        return yaml.safe_load(f)
+
+def main():
+    config = load_config("configs/train_config.yaml")
+
+    model_dir = config["output_dir"]  # Use fine-tuned model output directory
+    test_dataset_path = "data/processed/test.json"  # Adjust path to your test data
+
+    tokenizer = AutoTokenizer.from_pretrained(model_dir)
+    model = AutoModelForCausalLM.from_pretrained(model_dir)
+
+    dataset = load_dataset("json", data_files={"test": test_dataset_path})
+    
+    def tokenize_function(examples):
+        tokenized = tokenizer(examples['text'], truncation=True, padding="max_length", max_length=512)
+        tokenized["labels"] = tokenized["input_ids"].copy()
+        return tokenized
+    
+    tokenized_dataset = dataset.map(tokenize_function, batched=True)
+
+    training_args = TrainingArguments(
+        output_dir="./eval_output",
+        per_device_eval_batch_size=8,
+    )
+
+    trainer = Trainer(
+        model=model,
+        args=training_args,
+        eval_dataset=tokenized_dataset["test"],
+        tokenizer=tokenizer,
+    )
+
+    eval_result = trainer.evaluate()
+    print(f"Evaluation results: {eval_result}")
+
+if __name__ == "__main__":
+    main()

src/model/train.py

@@ -2,11 +2,11 @@ import torch
 from transformers import AutoModelForCausalLM, Trainer, TrainingArguments, AutoTokenizer
 from datasets import load_dataset
 import os
-import json
+import yaml
 
 def load_config(config_path):
     with open(config_path, "r") as f:
-        return json.load(f)
+        return yaml.safe_load(f)
 
 def main():
     config = load_config("configs/train_config.yaml")
@@ -14,23 +14,38 @@ def main():
     model_name = config["model_name"]
     dataset_path = config["dataset_path"]
     output_dir = config["output_dir"]
-    learning_rate = config["learning_rate"]
+    learning_rate = float(config["learning_rate"])  # Convert to float
     batch_size = config["batch_size"]
     num_epochs = config["num_epochs"]
 
     tokenizer = AutoTokenizer.from_pretrained(model_name)
+
+    # Fix for tokenizers without a pad_token (e.g., GPT-2)
+    if tokenizer.pad_token is None:
+        tokenizer.pad_token = tokenizer.eos_token
+
     model = AutoModelForCausalLM.from_pretrained(model_name)
 
     # Example dataset loading; replace with your data loading pipeline
     dataset = load_dataset("json", data_files={"train": dataset_path})
+
     def tokenize_function(examples):
-        return tokenizer(examples['text'], truncation=True, padding="max_length", max_length=512)
+        tokenized = tokenizer(
+            examples['text'],
+            truncation=True,
+            padding="max_length",
+            max_length=512
+        )
+        # Add labels identical to input_ids for causal LM loss computation
+        tokenized["labels"] = tokenized["input_ids"].copy()
+        return tokenized
+
     tokenized_dataset = dataset.map(tokenize_function, batched=True)
 
     training_args = TrainingArguments(
         output_dir=output_dir,
         overwrite_output_dir=True,
-        evaluation_strategy="epoch",
+        # Removed evaluation_strategy to avoid error
         learning_rate=learning_rate,
         per_device_train_batch_size=batch_size,
         num_train_epochs=num_epochs,
@@ -47,7 +62,8 @@ def main():
     )
 
     trainer.train()
-    trainer.save_model(output_dir)
+    trainer.save_model(output_dir)         # Saves model files like pytorch_model.bin, config.json
+    tokenizer.save_pretrained(output_dir)  # Saves tokenizer files like tokenizer_config.json, vocab files
 
 if __name__ == "__main__":
-    main()
+    main()