kchemorion/Constitution_of_Kenya_2010_LLM_Fine-tuning_Dataset

Constitution of Kenya 2010 - LLM Fine-tuning Dataset

This dataset was generated from the Constitution of Kenya 2010 PDF for fine-tuning large language models.

Dataset Overview

• Source: Constitution of Kenya 2010
• Total Examples: ~100+ instruction-response pairs
• Format: Alpaca/Instruction format and Chat format
• Language: English
• Task Type: Question-Answering, Constitutional Knowledge

Files Included

1. kenya_constitution_alpaca.json - Alpaca instruction format (recommended for Unsloth)
2. kenya_constitution_alpaca.jsonl - JSONL version (one example per line)
3. kenya_constitution_chat.json - Chat/conversation format
4. kenya_constitution_chat.jsonl - JSONL version of chat format
5. train_unsloth.py - Example training script
6. README.md - This file

Dataset Format

Alpaca Format

{
  "instruction": "What does Article 27 of the Constitution of Kenya say?",
  "input": "",
  "output": "Article 27 addresses equality and freedom from discrimination..."
}

Chat Format

{
  "messages": [
    {"role": "user", "content": "What does Article 27 say?"},
    {"role": "assistant", "content": "Article 27 addresses equality..."}
  ]
}

Question Types

The dataset includes diverse question types:

1. Direct Article Queries: "What does Article X say?"
2. Topic-Based: "Explain freedom of expression in Kenyan law"
3. Contextual: "What does Chapter Four cover?"
4. Summarization: "Summarize Article X"
5. General Knowledge: "What is the Constitution of Kenya 2010?"

Training with Unsloth

Installation

pip install "unsloth[colab-new] @ git+https://github.com/unslothai/unsloth.git"
pip install --no-deps xformers trl peft accelerate bitsandbytes

Quick Start

from unsloth import FastLanguageModel
from datasets import load_dataset
from trl import SFTTrainer

# Load model
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/Phi-3-mini-4k-instruct",
    max_seq_length=2048,
    load_in_4bit=True,
)

# Configure LoRA
model = FastLanguageModel.get_peft_model(
    model,
    r=16,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
                    "gate_proj", "up_proj", "down_proj"],
    lora_alpha=16,
)

# Load dataset
dataset = load_dataset("json", data_files="kenya_constitution_alpaca.json")

# Train (see train_unsloth.py for full script)
trainer = SFTTrainer(model=model, train_dataset=dataset["train"], ...)
trainer.train()

Recommended Models

• Llama 3 8B: unsloth/llama-3-8b-bnb-4bit
• Mistral 7B: unsloth/mistral-7b-v0.3-bnb-4bit
• Phi-3 Mini: unsloth/Phi-3-mini-4k-instruct (good for testing)

Training Parameters

Recommended settings:

• Learning rate: 2e-4
• LoRA rank (r): 16
• Batch size: 2-4
• Max steps: 100-500 (adjust based on dataset size)
• Max sequence length: 2048

Use Cases

Fine-tuned models can:

• Answer questions about Kenyan constitutional law
• Explain specific articles and provisions
• Provide context on constitutional rights and procedures
• Assist with legal research and education
• Support civic education initiatives

Dataset Statistics

• Covers multiple chapters of the Constitution
• Focus on Bill of Rights, Citizenship, Sovereignty, and key provisions
• Includes both specific article content and general constitutional knowledge
• Balanced question types for robust training

Limitations

• Dataset is derived from the official Constitution text
• May not include latest amendments (check official sources)
• Responses are educational; not legal advice
• Limited to content explicitly in the Constitution

Citation

If you use this dataset, please cite:

• Source Document: Constitution of Kenya, 2010
• Published by: National Council for Law Reporting, Kenya
• Available at: www.kenyalaw.org

License

The Constitution of Kenya is a public document. This dataset is provided for educational and research purposes.

Additional Resources

• Official Kenya Law: https://www.kenyalaw.org
• Unsloth Documentation: https://github.com/unslothai/unsloth
• TRL (Transformer Reinforcement Learning): https://github.com/huggingface/trl

Training Tips

1. Start small: Test with Phi-3 Mini before larger models
2. Monitor loss: Should decrease steadily during training
3. Use validation: Split dataset 90/10 train/val
4. Adjust batch size: Based on GPU memory
5. Save checkpoints: Save every 25-50 steps
6. Test inference: Validate responses after training

Example Inference

FastLanguageModel.for_inference(model)

prompt = """Below is an instruction that describes a task.

### Instruction:
What does Article 27 of the Constitution of Kenya say?

### Response:
"""

inputs = tokenizer(prompt, return_tensors="pt").to("cuda")
outputs = model.generate(**inputs, max_new_tokens=256)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))

Disclaimer: This dataset is for educational purposes. For official legal guidance, consult qualified legal professionals and refer to official government sources.