Add dataset format checking script, training configuration, and dataset files for ZamAI-Mistral-7B-Pashto

check_dataset_format.py

@@ -0,0 +1,136 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+Script to check if a dataset is properly formatted for AutoTrain
+"""
+
+import argparse
+from datasets import load_dataset
+from collections import Counter
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Check dataset format for AutoTrain compatibility")
+    parser.add_argument(
+        "--dataset_path",
+        type=str,
+        required=True,
+        help="Path to dataset (local or HF Hub)"
+    )
+    parser.add_argument(
+        "--split",
+        type=str,
+        default="train",
+        help="Split to check (train/test/validation)"
+    )
+    return parser.parse_args()
+
+def check_dataset_format(dataset):
+    """Check if dataset is properly formatted"""
+    print("\n=== Dataset Format Check ===")
+    
+    # Check columns
+    columns = dataset.column_names
+    print(f"Columns found: {columns}")
+    
+    # Check for expected columns
+    text_format = "text" in columns
+    instruction_format = "instruction" in columns and "response" in columns
+    
+    if text_format:
+        print("✅ Dataset is in TEXT format (single 'text' column)")
+    elif instruction_format:
+        print("✅ Dataset is in INSTRUCTION-RESPONSE format")
+    else:
+        print("❌ Dataset format not recognized. Expected either:")
+        print("   - 'text' column for text generation")
+        print("   - 'instruction' and 'response' columns for instruction tuning")
+        return False
+    
+    # Check dataset size
+    print(f"\nDataset size: {len(dataset)} examples")
+    
+    # Sample some examples
+    print("\n=== Sample Examples ===")
+    for i in range(min(3, len(dataset))):
+        print(f"\nExample {i+1}:")
+        example = dataset[i]
+        
+        if text_format:
+            text = example['text']
+            print(f"Text length: {len(text)} characters")
+            print(f"Preview: {text[:200]}...")
+        elif instruction_format:
+            instruction = example['instruction']
+            response = example['response']
+            print(f"Instruction: {instruction[:100]}...")
+            print(f"Response: {response[:100]}...")
+    
+    # Check for empty values
+    print("\n=== Data Quality Check ===")
+    empty_count = 0
+    short_count = 0
+    
+    for example in dataset:
+        if text_format:
+            if not example['text'] or len(example['text'].strip()) == 0:
+                empty_count += 1
+            elif len(example['text']) < 10:
+                short_count += 1
+        elif instruction_format:
+            if not example['instruction'] or not example['response']:
+                empty_count += 1
+            elif len(example['instruction']) < 5 or len(example['response']) < 5:
+                short_count += 1
+    
+    print(f"Empty examples: {empty_count}")
+    print(f"Very short examples: {short_count}")
+    
+    if empty_count > 0:
+        print("⚠️  Warning: Found empty examples. Consider removing them.")
+    if short_count > len(dataset) * 0.1:
+        print("⚠️  Warning: Many short examples found. This might affect training quality.")
+    
+    # Language detection (simple check for Pashto characters)
+    print("\n=== Language Check ===")
+    pashto_count = 0
+    sample_size = min(100, len(dataset))
+    
+    for i in range(sample_size):
+        example = dataset[i]
+        text = example.get('text', '') or example.get('instruction', '') + example.get('response', '')
+        # Check for Pashto/Arabic script characters
+        if any('\u0600' <= c <= '\u06FF' for c in text):
+            pashto_count += 1
+    
+    pashto_percentage = (pashto_count / sample_size) * 100
+    print(f"Examples with Pashto/Arabic script: {pashto_percentage:.1f}%")
+    
+    if pashto_percentage < 50:
+        print("⚠️  Warning: Less than 50% of samples contain Pashto script.")
+    
+    return True
+
+def main():
+    args = parse_args()
+    
+    print(f"Loading dataset from: {args.dataset_path}")
+    
+    try:
+        # Load dataset
+        dataset = load_dataset(args.dataset_path, split=args.split)
+        
+        # Check format
+        is_valid = check_dataset_format(dataset)
+        
+        if is_valid:
+            print("\n✅ Dataset is ready for AutoTrain!")
+        else:
+            print("\n❌ Dataset needs formatting adjustments.")
+            
+    except Exception as e:
+        print(f"Error loading dataset: {e}")
+        print("\nMake sure the dataset path is correct and accessible.")
+
+if __name__ == "__main__":
+    main()

config.json

@@ -0,0 +1,23 @@
+{
+  "model_type": "mistral",
+  "architectures": ["MistralForCausalLM"],
+  "hidden_size": 4096,
+  "intermediate_size": 14336,
+  "num_hidden_layers": 32,
+  "num_attention_heads": 32,
+  "num_key_value_heads": 8,
+  "hidden_act": "silu",
+  "max_position_embeddings": 32768,
+  "initializer_range": 0.02,
+  "rms_norm_eps": 1e-05,
+  "use_cache": true,
+  "pad_token_id": null,
+  "bos_token_id": 1,
+  "eos_token_id": 2,
+  "tie_word_embeddings": false,
+  "rope_theta": 10000.0,
+  "sliding_window": 4096,
+  "attention_dropout": 0.0,
+  "torch_dtype": "float16",
+  "transformers_version": "4.34.0"
+}

prepare_for_autotrain.py

@@ -0,0 +1,148 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+Script to prepare Pashto dataset for AutoTrain fine-tuning
+Converts data to the format expected by AutoTrain and uploads to HF Hub
+"""
+
+import argparse
+import json
+import os
+from datasets import Dataset, DatasetDict
+from huggingface_hub import HfApi, create_repo
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Prepare dataset for AutoTrain")
+    parser.add_argument(
+        "--input_file",
+        type=str,
+        default="zamai_pashto_dataset.json",
+        help="Input JSON file with the dataset"
+    )
+    parser.add_argument(
+        "--format_type",
+        type=str,
+        choices=["text", "instruction-response"],
+        default="instruction-response",
+        help="Format type for the dataset"
+    )
+    parser.add_argument(
+        "--train_split",
+        type=float,
+        default=0.9,
+        help="Proportion of data for training (rest goes to test)"
+    )
+    parser.add_argument(
+        "--push_to_hub",
+        action="store_true",
+        help="Push dataset to Hugging Face Hub"
+    )
+    parser.add_argument(
+        "--hub_dataset_name",
+        type=str,
+        default="ZamAI_Pashto_Training",
+        help="Name for the dataset on HF Hub"
+    )
+    parser.add_argument(
+        "--hf_token",
+        type=str,
+        help="Hugging Face API token"
+    )
+    return parser.parse_args()
+
+def format_for_text_generation(data, format_type):
+    """Format data for text generation training"""
+    formatted_data = []
+    
+    for item in data:
+        if format_type == "text":
+            # Simple text format - concatenate input and output
+            if 'input' in item and 'output' in item:
+                text = f"{item['input']}\n\n{item['output']}"
+                formatted_data.append({"text": text})
+        
+        elif format_type == "instruction-response":
+            # Instruction-response format
+            if 'input' in item and 'output' in item:
+                formatted_data.append({
+                    "instruction": item['input'],
+                    "response": item['output']
+                })
+    
+    return formatted_data
+
+def main():
+    args = parse_args()
+    
+    # Load the dataset
+    print(f"Loading dataset from {args.input_file}")
+    with open(args.input_file, 'r', encoding='utf-8') as f:
+        data = json.load(f)
+    
+    print(f"Loaded {len(data)} examples")
+    
+    # Format the data
+    print(f"Formatting data as {args.format_type}")
+    formatted_data = format_for_text_generation(data, args.format_type)
+    
+    # Split into train/test
+    split_idx = int(len(formatted_data) * args.train_split)
+    train_data = formatted_data[:split_idx]
+    test_data = formatted_data[split_idx:]
+    
+    print(f"Train examples: {len(train_data)}")
+    print(f"Test examples: {len(test_data)}")
+    
+    # Create datasets
+    train_dataset = Dataset.from_list(train_data)
+    test_dataset = Dataset.from_list(test_data)
+    
+    # Create DatasetDict
+    dataset_dict = DatasetDict({
+        "train": train_dataset,
+        "test": test_dataset
+    })
+    
+    # Save locally
+    local_path = f"{args.hub_dataset_name}_local"
+    dataset_dict.save_to_disk(local_path)
+    print(f"Dataset saved locally to {local_path}")
+    
+    # Push to Hub if requested
+    if args.push_to_hub:
+        if not args.hf_token:
+            print("Error: HF token required for pushing to Hub")
+            return
+        
+        print(f"Pushing dataset to Hub as tasal9/{args.hub_dataset_name}")
+        
+        # Create repo if needed
+        api = HfApi(token=args.hf_token)
+        repo_id = f"tasal9/{args.hub_dataset_name}"
+        
+        try:
+            create_repo(
+                repo_id=repo_id,
+                token=args.hf_token,
+                repo_type="dataset",
+                exist_ok=True
+            )
+        except Exception as e:
+            print(f"Note: {e}")
+        
+        # Push dataset
+        dataset_dict.push_to_hub(
+            repo_id,
+            token=args.hf_token,
+            commit_message="Upload Pashto training dataset for AutoTrain"
+        )
+        
+        print(f"Dataset uploaded to https://huggingface.co/datasets/{repo_id}")
+    
+    # Print sample
+    print("\nSample from training data:")
+    print(train_dataset[0])
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -43,3 +43,7 @@ ipykernel>=6.25.0
 black>=23.9.0
 isort>=5.12.0
 pylint>=2.17.0
+
+# Additional training dependencies
+wandb>=0.15.0
+pyyaml>=6.0

tokenizer_config.json

@@ -0,0 +1,43 @@
+{
+  "add_bos_token": true,
+  "add_eos_token": false,
+  "added_tokens_decoder": {
+    "0": {
+      "content": "<unk>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "1": {
+      "content": "<s>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "2": {
+      "content": "</s>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    }
+  },
+  "additional_special_tokens": [],
+  "bos_token": "<s>",
+  "clean_up_tokenization_spaces": false,
+  "eos_token": "</s>",
+  "legacy": true,
+  "model_max_length": 32768,
+  "pad_token": null,
+  "sp_model_kwargs": {},
+  "spaces_between_special_tokens": false,
+  "tokenizer_class": "LlamaTokenizer",
+  "unk_token": "<unk>",
+  "use_default_system_prompt": true,
+  "chat_template": "{{ bos_token }}{% for message in messages %}{% if (message['role'] == 'user') != (loop.index0 % 2 == 0) %}{{ raise_exception('Conversation roles must alternate user/assistant/user/assistant/...') }}{% endif %}{% if message['role'] == 'user' %}{{ '[INST] ' + message['content'] + ' [/INST]' }}{% elif message['role'] == 'assistant' %}{{ message['content'] + eos_token + ' ' }}{% else %}{{ raise_exception('Only user and assistant roles are supported!') }}{% endif %}{% endfor %}"
+}

train_model.py

@@ -0,0 +1,273 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+Comprehensive training script for ZamAI-Mistral-7B-Pashto
+Supports both local training and AutoTrain
+"""
+
+import argparse
+import os
+import yaml
+import torch
+from transformers import (
+    AutoModelForCausalLM,
+    AutoTokenizer,
+    TrainingArguments,
+    Trainer,
+    DataCollatorForLanguageModeling,
+    BitsAndBytesConfig
+)
+from datasets import load_dataset
+from peft import LoraConfig, get_peft_model, TaskType
+from peft.utils import prepare_model_for_kbit_training
+try:
+    import wandb
+except ImportError:
+    wandb = None
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Train ZamAI-Mistral-7B-Pashto")
+    parser.add_argument(
+        "--config",
+        type=str,
+        default="training_config.yaml",
+        help="Path to training configuration file"
+    )
+    parser.add_argument(
+        "--local",
+        action="store_true",
+        help="Run training locally instead of using AutoTrain"
+    )
+    parser.add_argument(
+        "--dataset_path",
+        type=str,
+        help="Override dataset path from config"
+    )
+    parser.add_argument(
+        "--output_dir",
+        type=str,
+        help="Override output directory from config"
+    )
+    parser.add_argument(
+        "--hf_token",
+        type=str,
+        help="Hugging Face API token"
+    )
+    return parser.parse_args()
+
+def load_config(config_path):
+    """Load training configuration from YAML file"""
+    with open(config_path, 'r') as f:
+        config = yaml.safe_load(f)
+    return config
+
+def prepare_model_and_tokenizer(config):
+    """Prepare model and tokenizer with quantization and LoRA"""
+    
+    # Quantization config
+    bnb_config = BitsAndBytesConfig(
+        load_in_4bit=config['model'].get('load_in_4bit', True),
+        bnb_4bit_use_double_quant=True,
+        bnb_4bit_quant_type="nf4",
+        bnb_4bit_compute_dtype=torch.bfloat16
+    )
+    
+    # Load model
+    model = AutoModelForCausalLM.from_pretrained(
+        config['model']['name'],
+        quantization_config=bnb_config,
+        device_map="auto",
+        trust_remote_code=True,
+        use_flash_attention_2=config['model'].get('use_flash_attention_2', True)
+    )
+    
+    # Load tokenizer
+    tokenizer = AutoTokenizer.from_pretrained(
+        config['model']['name'],
+        trust_remote_code=True
+    )
+    tokenizer.pad_token = tokenizer.eos_token
+    tokenizer.padding_side = "right"
+    
+    # Prepare model for k-bit training
+    model = prepare_model_for_kbit_training(model)
+    
+    # LoRA configuration
+    lora_config = LoraConfig(
+        r=config['lora']['r'],
+        lora_alpha=config['lora']['lora_alpha'],
+        target_modules=config['lora']['target_modules'],
+        lora_dropout=config['lora']['lora_dropout'],
+        bias=config['lora']['bias'],
+        task_type=config['lora']['task_type']
+    )
+    
+    # Apply LoRA
+    model = get_peft_model(model, lora_config)
+    model.print_trainable_parameters()
+    
+    return model, tokenizer
+
+def prepare_dataset(config, tokenizer):
+    """Load and prepare dataset for training"""
+
+    # Load train and validation splits separately
+    train_dataset = load_dataset(
+        config['dataset']['name'],
+        split=config['dataset']['train_split']
+    )
+    validation_dataset = load_dataset(
+        config['dataset']['name'],
+        split=config['dataset']['validation_split']
+    )
+
+    # Tokenization function
+    def tokenize_function(examples):
+        # Handle different dataset formats
+        if config['dataset']['text_column'] in examples:
+            texts = examples[config['dataset']['text_column']]
+        else:
+            # For instruction-response format
+            texts = [
+                f"[INST] {inst} [/INST] {resp}"
+                for inst, resp in zip(examples['instruction'], examples['response'])
+            ]
+
+        return tokenizer(
+            texts,
+            truncation=True,
+            padding="max_length",
+            max_length=config['dataset']['max_seq_length']
+        )
+
+    # Tokenize datasets
+    tokenized_train = train_dataset.map(
+        tokenize_function,
+        batched=True,
+        remove_columns=train_dataset.column_names
+    )
+    tokenized_validation = validation_dataset.map(
+        tokenize_function,
+        batched=True,
+        remove_columns=validation_dataset.column_names
+    )
+
+    # Return datasets directly
+    return tokenized_train, tokenized_validation
+
+def main():
+    args = parse_args()
+    
+    # Load configuration
+    config = load_config(args.config)
+    
+    # Override config with command line arguments
+    if args.dataset_path:
+        config['dataset']['name'] = args.dataset_path
+    if args.output_dir:
+        config['output']['output_dir'] = args.output_dir
+    if args.hf_token:
+        config['hub']['hub_token'] = args.hf_token
+    
+    # Set up wandb if configured
+    if 'wandb' in config['advanced'].get('report_to', []):
+        wandb.init(
+            project="zamai-mistral-pashto",
+            name=f"mistral-7b-pashto-{config['lora']['r']}r",
+            config=config
+        )
+    
+    print("Loading model and tokenizer...")
+    model, tokenizer = prepare_model_and_tokenizer(config)
+    
+    print("Preparing dataset...")
+    train_dataset, validation_dataset = prepare_dataset(config, tokenizer)
+    
+    # Data collator
+    data_collator = DataCollatorForLanguageModeling(
+        tokenizer=tokenizer,
+        mlm=False
+    )
+    
+    # Training arguments
+    training_args = TrainingArguments(
+        output_dir=config['output']['output_dir'],
+        num_train_epochs=config['training']['num_train_epochs'],
+        per_device_train_batch_size=config['training']['per_device_train_batch_size'],
+        per_device_eval_batch_size=config['training']['per_device_eval_batch_size'],
+        gradient_accumulation_steps=config['training']['gradient_accumulation_steps'],
+        gradient_checkpointing=config['training']['gradient_checkpointing'],
+        learning_rate=config['training']['learning_rate'],
+        lr_scheduler_type=config['training']['lr_scheduler_type'],
+        warmup_ratio=config['training']['warmup_ratio'],
+        weight_decay=config['training']['weight_decay'],
+        max_grad_norm=config['training']['max_grad_norm'],
+        optim=config['optimization']['optim'],
+        fp16=config['optimization']['fp16'],
+        bf16=config['optimization']['bf16'],
+        tf32=config['optimization']['tf32'],
+        logging_dir=config['output']['logging_dir'],
+        logging_steps=config['output']['logging_steps'],
+        save_steps=config['output']['save_steps'],
+        save_total_limit=config['output']['save_total_limit'],
+        evaluation_strategy=config['output']['evaluation_strategy'],
+        eval_steps=config['output']['eval_steps'],
+        save_strategy=config['output']['save_strategy'],
+        load_best_model_at_end=config['output']['load_best_model_at_end'],
+        metric_for_best_model=config['output']['metric_for_best_model'],
+        greater_is_better=config['output']['greater_is_better'],
+        push_to_hub=config['hub']['push_to_hub'],
+        hub_model_id=config['hub']['hub_model_id'],
+        hub_strategy=config['hub']['hub_strategy'],
+        hub_token=config['hub']['hub_token'],
+        seed=config['advanced']['seed'],
+        data_seed=config['advanced']['data_seed'],
+        report_to=config['advanced']['report_to'],
+        remove_unused_columns=config['advanced']['remove_unused_columns']
+    )
+    
+    # Initialize trainer
+    trainer = Trainer(
+        model=model,
+        args=training_args,
+        train_dataset=train_dataset,
+        eval_dataset=validation_dataset,
+        data_collator=data_collator
+    )
+    
+    # Train
+    print("Starting training...")
+    trainer.train()
+    
+    # Save the final model
+    print("Saving final model...")
+    trainer.save_model()
+    
+    # Push to hub if configured
+    if config['hub']['push_to_hub']:
+        print("Pushing to Hugging Face Hub...")
+        trainer.push_to_hub()
+    
+    print("Training completed successfully!")
+    
+    # Test the model
+    print("\nTesting the model with a sample prompt...")
+    test_prompt = "ستاسو نوم څه دی؟"
+    inputs = tokenizer(test_prompt, return_tensors="pt").to(model.device)
+    
+    with torch.no_grad():
+        outputs = model.generate(
+            **inputs,
+            max_new_tokens=config['inference']['max_new_tokens'],
+            temperature=config['inference']['temperature'],
+            top_p=config['inference']['top_p'],
+            do_sample=config['inference']['do_sample']
+        )
+    
+    response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+    print(f"Prompt: {test_prompt}")
+    print(f"Response: {response}")
+
+if __name__ == "__main__":
+    main()

training_config.yaml

@@ -0,0 +1,93 @@
+# ZamAI-Mistral-7B-Pashto Training Configuration
+
+# Model Configuration
+model:
+  name: "mistralai/Mistral-7B-Instruct-v0.1"
+  type: "causal-lm"
+  use_flash_attention_2: true
+  load_in_8bit: false
+  load_in_4bit: true  # Use 4-bit quantization for efficiency
+
+# Dataset Configuration
+dataset:
+  name: "tasal9/ZamAI_Pashto_Training"
+  text_column: "text"  # or "instruction" for instruction-response format
+  train_split: "train"
+  validation_split: "test"
+  max_seq_length: 2048
+  
+# Training Parameters
+training:
+  num_train_epochs: 3
+  per_device_train_batch_size: 4
+  per_device_eval_batch_size: 4
+  gradient_accumulation_steps: 4
+  gradient_checkpointing: true
+  learning_rate: 2e-4
+  lr_scheduler_type: "cosine"
+  warmup_ratio: 0.03
+  weight_decay: 0.001
+  max_grad_norm: 0.3
+  
+# LoRA Configuration
+lora:
+  r: 16  # LoRA attention dimension
+  lora_alpha: 32  # LoRA scaling parameter
+  lora_dropout: 0.05  # LoRA dropout
+  bias: "none"
+  task_type: "CAUSAL_LM"
+  target_modules:
+    - "q_proj"
+    - "k_proj"
+    - "v_proj"
+    - "o_proj"
+    - "gate_proj"
+    - "up_proj"
+    - "down_proj"
+    - "lm_head"
+
+# Optimization
+optimization:
+  optim: "paged_adamw_32bit"
+  fp16: false
+  bf16: true  # Use bfloat16 for better stability
+  tf32: true
+  
+# Logging and Saving
+output:
+  output_dir: "./results"
+  logging_dir: "./logs"
+  logging_steps: 10
+  save_steps: 500
+  save_total_limit: 3
+  evaluation_strategy: "steps"
+  eval_steps: 500
+  save_strategy: "steps"
+  load_best_model_at_end: true
+  metric_for_best_model: "eval_loss"
+  greater_is_better: false
+  
+# Hub Configuration
+hub:
+  push_to_hub: true
+  hub_model_id: "tasal9/ZamAI-Mistral-7B-Pashto"
+  hub_strategy: "every_save"
+  hub_token: "YOUR_HF_TOKEN"  # Replace with actual token
+  
+# Advanced Settings
+advanced:
+  seed: 42
+  data_seed: 42
+  dataloader_num_workers: 4
+  remove_unused_columns: false
+  label_names: ["labels"]
+  report_to: ["tensorboard", "wandb"]  # Optional: remove wandb if not using
+  
+# Inference Configuration (for testing)
+inference:
+  max_new_tokens: 256
+  temperature: 0.7
+  top_p: 0.9
+  top_k: 50
+  do_sample: true
+  repetition_penalty: 1.1

zamai_pashto_dataset.json

@@ -0,0 +1,42 @@
+[
+  {
+    "input": "ستاسو نوم څه دی؟",
+    "output": "زما نوم ZamAI دی. زه د مصنوعی ذکاوت پر بنسټ جوړ شوی یو ژبنی مودل یم چې په پښتو ژبه کې مرسته کولی شم."
+  },
+  {
+    "input": "د افغانستان د کلتور په اړه ماته معلومات راکړئ.",
+    "output": "د افغانستان کلتور ډیر غني او بډای دی. افغانستان د بیلابیلو قومونو، ژبو او دودونو هیواد دی. اصلي قومونه پښتانه، تاجک، هزاره، ازبک او نور دي. دا هیواد ډیرې دودیزې موسیقۍ، خواړه، لباسونه او هنرونه لري."
+  },
+  {
+    "input": "په پښتو کې سلام څنګه کوو؟",
+    "output": "په پښتو کې د سلام کولو څو لارې دي:\n- السلام علیکم (رسمي)\n- سلام ورور/خور (غیر رسمي)\n- ستړی مه شې (د ورځې په هر وخت)\n- په خیر راغلاست (د هرکلي لپاره)"
+  },
+  {
+    "input": "د کابل په اړه معلومات راکړئ.",
+    "output": "کابل د افغانستان پلازمېنه او تر ټولو لوی ښار دی. دا ښار د هندوکش غرونو په منځ کې موقعیت لري او نږدې ۴.۵ میلیونه وګړي لري. کابل یو تاریخي ښار دی چې له ۳۵۰۰ کلونو څخه زیات تاریخ لري."
+  },
+  {
+    "input": "پښتو ژبه څومره خلک خبرې کوي؟",
+    "output": "پښتو د نړۍ په کچه نږدې ۵۰-۶۰ میلیونه خلک خبرې کوي. دا د افغانستان دوه رسمي ژبو څخه یوه ده او په پاکستان کې هم په پراخه کچه ویل کیږي. پښتو د هند-اروپایي ژبو له کورنۍ څخه ده."
+  },
+  {
+    "input": "د پښتنو دودونه څه دي؟",
+    "output": "پښتانه ډیر دودونه لري چې د پښتونولي په نوم پیژندل کیږي:\n- میلمه پالنه: میلمانه ته د عزت ورکول\n- ننواتې: د بخښنې غوښتل او ورکول\n- بدل: د ښې یا بدې بدله اخیستل\n- غیرت: د کورنۍ او قوم ساتنه\n- جرګه: د ستونزو د حل لپاره ټولنیز غونډې"
+  },
+  {
+    "input": "څنګه کولی شم پښتو زده کړم؟",
+    "output": "د پښتو زده کړې لپاره:\n۱. د پښتو الفبا زده کړئ (۴۴ توري)\n۲. بنسټیزې جملې او کلمې زده کړئ\n۳. پښتو موسیقي واورئ او فلمونه وګورئ\n۴. له پښتو ویونکو سره خبرې وکړئ\n۵. پښتو کتابونه او شعرونه ولولئ\n۶. آنلاین کورسونه یا اپلیکیشنونه وکاروئ"
+  },
+  {
+    "input": "د افغانستان ملي سرود په کومه ژبه دی؟",
+    "output": "د افغانستان ملي سرود په پښتو ژبه دی. دا سرود په ۲۰۰۶ کال کې رسمي شو او د افغانستان د بیلابیلو قومونو نومونه پکې یاد شوي دي. سرود د 'دا وطن افغانستان دی' په جمله پیل کیږي."
+  },
+  {
+    "input": "پښتو شاعري څنګه ده؟",
+    "output": "پښتو شاعري ډیره بډایه ده:\n- لنډۍ: دوه کرښیزه لنډ شعرونه\n- غزل: د مینې او عرفان شعرونه\n- رباعي: څلور کرښیز شعرونه\n- قصیده: اوږد شعرونه\nمشهور شاعران: خوشحال خان خټک، رحمان بابا، حمزه شینواری"
+  },
+  {
+    "input": "د پښتو ژبې تاریخ څه دی؟",
+    "output": "پښتو یوه لرغونې ژبه ده چې له ۲۵۰۰ کلونو څخه زیات تاریخ لري. د پښتو لومړنی لیکلی اثر د امیر کروړ تذکره ده (۸ پیړۍ). پښتو د ۱۹۳۶ کال راهیسې د افغانستان رسمي ژبه ده. دا ژبه عربي الفبا کاروي او ۴۴ توري لري."
+  }
+]