Upload 5 files

ft.py

@@ -0,0 +1,184 @@
+from transformers import AutoTokenizer, AutoModelForCausalLM, DataCollatorForLanguageModeling, get_scheduler
+from huggingface_hub import HfApi, notebook_login
+from datasets import load_dataset
+from peft import LoraConfig, LoraModel, get_peft_model
+from timm.scheduler import CosineLRScheduler
+import wandb
+import os
+from accelerate import Accelerator
+import numpy as np
+import torch
+import tqdm
+import torch.nn as nn
+import torch.optim as optim
+
+acc = Accelerator()
+
+lora_conf = LoraConfig(
+    r=8,
+    lora_alpha=64,
+    lora_dropout=0.1,
+    bias="none",
+    task_type="CAUSAL_LM",
+    target_modules="all-linear",
+    modules_to_save=None,
+)
+
+model_id = "TinyLlama/TinyLlama-1.1B-Chat-v1.0"
+dataset_id = "microsoft/orca-math-word-problems-200k"
+
+model_kwargs = dict(
+    use_cache=False,
+    attn_implementation="flash_attention_2",
+    torch_dtype=torch.bfloat16,
+    device_map="sequential",
+)
+
+tokenizer = AutoTokenizer.from_pretrained(model_id)
+model = AutoModelForCausalLM.from_pretrained(model_id, **model_kwargs)
+model = get_peft_model(model, lora_conf)
+
+def count_trainable_parameters(model):
+    model_parameters = filter(lambda p: p.requires_grad, model.parameters())
+    params = sum([np.prod(p.size()) for p in model_parameters])
+    return params
+
+trainable_params = format(count_trainable_parameters(model), ",")
+
+epochs = 1
+per_dev_batch_size = 2
+gradient_accumulation_steps = 4
+dtype = torch.bfloat16
+learning_rate = 1e-5
+
+raw_dataset = load_dataset(dataset_id, split="train")
+
+def apply_chat_template(example, tokenizer):
+    chat = [
+        {"role": "user", "content": example["question"]},
+        {"role": "assistant", "content": example["answer"]},
+    ]
+    example['text'] = tokenizer.apply_chat_template(chat, add_generation_prompt=False, tokenize=True)
+    return example
+
+train_dataset = raw_dataset.select(range(150000))
+test_dataset = raw_dataset.select(range(300))
+column_names = list(train_dataset.features)
+
+processed_train_dataset = train_dataset.map(
+    apply_chat_template,
+    # batched=True,
+    # batch_size=20,
+    fn_kwargs={"tokenizer": tokenizer},
+    num_proc=10,
+    remove_columns=column_names,
+    desc="Applying chat template to train_sft",
+)
+
+processed_test_dataset = test_dataset.map(
+    apply_chat_template,
+    # batched=True,
+    # batch_size=20,
+    fn_kwargs={"tokenizer": tokenizer},
+    num_proc=10,
+    remove_columns=column_names,
+    desc="Applying chat template to test_sft",
+)
+
+data_collator = DataCollatorForLanguageModeling(tokenizer=tokenizer, mlm=False)
+
+train_dataloader = torch.utils.data.DataLoader( # 
+    processed_train_dataset['text'],
+    batch_size=per_dev_batch_size,
+    shuffle=True,
+    collate_fn=data_collator
+)
+
+test_dataloader = torch.utils.data.DataLoader(
+    processed_test_dataset['text'],
+    batch_size=per_dev_batch_size,
+    shuffle=True,
+    collate_fn=data_collator
+)
+
+global_step = 0
+num_training_steps = epochs * len(train_dataloader)
+#num_training_steps = 20000
+warmup_ratio = 0.1
+warmup_steps = int(warmup_ratio * num_training_steps)
+
+optimizer = optim.AdamW(model.parameters(), lr=learning_rate)
+cross_entropy = nn.CrossEntropyLoss()
+
+scheduler = get_scheduler(
+    name="cosine",
+    optimizer=optimizer, 
+    num_warmup_steps=warmup_steps,
+    num_training_steps=num_training_steps
+)
+
+wandb.init(
+    project="math-tiny-llama",
+
+    config={
+    "learning_rate": learning_rate,
+    "dataset": dataset_id,
+    "batch_size": per_dev_batch_size,
+    "lora_r": lora_conf.r,
+    "lora_alpha": lora_conf.lora_alpha,
+    "lora_dropout": lora_conf.lora_dropout,
+    "gradient_accumulation_steps": gradient_accumulation_steps,
+    "warmup_ratio": warmup_ratio,
+    "trainable_params": trainable_params,
+    "num_training_steps": num_training_steps, 
+    "model_name": "TinyLlama"
+    }
+)   
+
+optimizer, scheduler, train_dataloader, tokenizer, model = acc.prepare(optimizer, scheduler, train_dataloader, tokenizer, model)
+
+def calc_metrics():
+    model.eval()
+    for batch in test_dataloader:
+        pred = model(**batch)
+        loss = pred.loss
+
+        wandb.log({"eval_loss": loss.item()})
+
+    model.train()
+
+model.train()
+for epoch in range(epochs):
+    for step, batch in enumerate(train_dataloader):
+        
+        outputs = model(**batch)
+        loss = outputs.loss
+
+        loss.backward()
+
+        wandb.log({"loss": loss.item(), "learning_rate": optimizer.param_groups[0]['lr']})
+        
+        if (step + 1) % gradient_accumulation_steps == 0:
+            optimizer.step()
+            scheduler.step()
+            optimizer.zero_grad()
+            global_step += 1
+    
+        if (step + 1) % 100 == 0:
+            print(f"Loss: {loss.item()}")
+            
+        if (step + 1) % 400 == 0:
+            calc_metrics()
+
+        if global_step > num_training_steps:
+            break
+
+    if global_step > num_training_steps:
+        break
+
+wandb.finish()
+
+save_path = os.path.join("checkpoint_2_", f"step_{global_step}")
+model.module.save_pretrained(save_path)
+
+print("Saved model")

ft_hus.py

@@ -0,0 +1,192 @@
+from transformers import AutoTokenizer, AutoModelForCausalLM, DataCollatorForLanguageModeling, get_scheduler
+from huggingface_hub import HfApi, notebook_login
+from datasets import load_dataset
+from peft import LoraConfig, LoraModel, get_peft_model
+from timm.scheduler import CosineLRScheduler
+import wandb
+import os
+from accelerate import Accelerator
+import numpy as np
+import torch
+import tqdm
+import torch.nn as nn
+import torch.optim as optim
+
+lora_conf = LoraConfig(
+    r=8,
+    lora_alpha=32,
+    lora_dropout=0.05,
+    bias="none",
+    task_type="CAUSAL_LM",
+    target_modules="all-linear",
+    modules_to_save=None,
+)
+
+model_id = "Qwen/Qwen2-1.5B-Instruct"
+
+model_kwargs = dict(
+    use_cache=False,
+    #attn_implementation="flash_attention_2",
+    torch_dtype="auto",
+    device_map="sequential",
+)
+
+tokenizer = AutoTokenizer.from_pretrained(model_id)
+tokenizer.model_max_length = 4096
+model = AutoModelForCausalLM.from_pretrained(model_id, **model_kwargs)
+model = get_peft_model(model, lora_conf)
+
+def count_trainable_parameters(model):
+    model_parameters = filter(lambda p: p.requires_grad, model.parameters())
+    params = sum([np.prod(p.size()) for p in model_parameters])
+    return params
+
+trainable_params = format(count_trainable_parameters(model), ",")
+
+epochs = 2
+per_dev_batch_size = 2
+gradient_accumulation_steps = 20
+dtype = torch.bfloat16
+learning_rate = 1e-4
+
+def apply_chat_template(example, tokenizer):
+    convo = example['conversations']
+    for dic in convo:
+        dic['role'] = dic.pop('from')
+        dic['content'] = dic.pop('value')
+        if dic['role'] == 'gpt':
+            dic['role'] = 'assistant'
+        elif dic['role'] == 'human':
+            dic['role'] = 'user'
+
+    example['text'] = tokenizer.apply_chat_template(convo, tokenize=True, add_generation_prompt=False, truncation=True)
+    return example
+
+train_dataset = dataset.select(range(98000))
+test_dataset = dataset.select(range(3000))
+column_names = list(train_dataset.features)
+
+processed_train_dataset = train_dataset.map(
+    apply_chat_template,
+    fn_kwargs={"tokenizer": tokenizer},
+    num_proc=10,
+    remove_columns=column_names,
+)
+
+processed_test_dataset = test_dataset.map(
+    apply_chat_template,
+    fn_kwargs={"tokenizer": tokenizer},
+    num_proc=10,
+    remove_columns=column_names,
+)
+
+data_collator = DataCollatorForLanguageModeling(tokenizer=tokenizer, mlm=False)
+
+train_dataloader = torch.utils.data.DataLoader( # 
+    processed_train_dataset['text'],
+    batch_size=per_dev_batch_size,
+    shuffle=True,
+    collate_fn=data_collator
+)
+
+test_dataloader = torch.utils.data.DataLoader(
+    processed_test_dataset['text'],
+    batch_size=per_dev_batch_size,
+    shuffle=True,
+    collate_fn=data_collator
+)
+
+global_step = 0
+num_training_steps = epochs * len(train_dataloader)
+warmup_ratio = 0.1
+warmup_steps = 800
+#warmup_steps = int(warmup_ratio * num_training_steps)
+
+optimizer = optim.AdamW(model.parameters(), lr=learning_rate)
+cross_entropy = nn.CrossEntropyLoss()
+
+scheduler = get_scheduler(
+    name="cosine",
+    optimizer=optimizer, 
+    num_warmup_steps=warmup_steps,
+    num_training_steps=num_training_steps
+)
+
+acc = Accelerator(gradient_accumulation_steps=gradient_accumulation_steps)
+
+if acc.is_main_process:
+    wandb.init(
+        project="qwen-hus-inst",
+    
+        config={
+        "learning_rate": learning_rate,
+        "dataset": "Mix of RP and Instruct,
+        "batch_size": per_dev_batch_size,
+        "lora_r": lora_conf.r,
+        "lora_alpha": lora_conf.lora_alpha,
+        "lora_dropout": lora_conf.lora_dropout,
+        "gradient_accumulation_steps": gradient_accumulation_steps,
+        "warmup_ratio": warmup_ratio,
+        "trainable_params": trainable_params,
+        "num_training_steps": num_training_steps, 
+        "model_name": model_id
+        }
+    )   
+
+optimizer, scheduler, train_dataloader, tokenizer, model, scheduler = acc.prepare(optimizer, scheduler, train_dataloader, tokenizer, model, scheduler)
+
+def save_checkpoint():
+    if acc.is_main_process:    
+        save_path = os.path.join("checkpoint_hus", f"step_{global_step}")
+        model.module.save_pretrained(save_path)
+    
+        print(f"Saved model at step {global_step}")
+
+def calc_metrics():
+    model.eval()
+    for batch in test_dataloader:
+        pred = model(**batch)
+        loss = pred.loss
+
+        if acc.is_main_process:
+            perplexity = torch.exp(loss)
+            wandb.log({"eval_loss": loss.item(), "eval_perplexity": perplexity})
+
+    model.train()
+
+model.train()
+for epoch in range(epochs):
+    for step, batch in enumerate(train_dataloader):
+        with acc.accumulate(model):
+            outputs = model(**batch)
+            loss = outputs.loss
+            acc.backward(loss)
+            optimizer.step()
+            scheduler.step()
+            optimizer.zero_grad()
+                
+            if acc.is_main_process:
+                perplexity = torch.exp(loss)
+                wandb.log({"loss": loss.item(), "learning_rate": optimizer.param_groups[0]['lr'], "perplexity": perplexity})
+            
+            global_step += 1
+
+        if (step + 1) % 1000 == 0:
+            save_checkpoint()
+            
+        if (step + 1) % 100 == 0 and acc.is_main_process:
+            print(f"Loss: {loss.item()}")
+            
+            
+        if (step + 1) % 2000 == 0:
+            calc_metrics()
+
+        if global_step > num_training_steps:
+            break
+
+    if global_step > num_training_steps:
+        break
+
+if acc.is_main_process:
+    wandb.finish()
+    save_checkpoint()

ft_instruct.py

@@ -0,0 +1,208 @@
+from transformers import AutoTokenizer, AutoModelForCausalLM, DataCollatorForLanguageModeling, get_scheduler
+from huggingface_hub import HfApi, notebook_login
+from datasets import load_dataset
+from peft import LoraConfig, LoraModel, get_peft_model
+from timm.scheduler import CosineLRScheduler
+import wandb
+import os
+from accelerate import Accelerator
+import numpy as np
+import torch
+import tqdm
+import torch.nn as nn
+import torch.optim as optim
+
+lora_conf = LoraConfig(
+    r=8,
+    lora_alpha=64,
+    lora_dropout=0.05,
+    bias="none",
+    task_type="CAUSAL_LM",
+    target_modules="all-linear",
+    modules_to_save=None,
+)
+
+model_id = "TinyLlama/TinyLlama-1.1B-Chat-v1.0"
+dataset_id = "BAAI/Infinity-Instruct"
+
+model_kwargs = dict(
+    use_cache=False,
+    attn_implementation="flash_attention_2",
+    torch_dtype=torch.bfloat16,
+    device_map="sequential",
+)
+
+tokenizer = AutoTokenizer.from_pretrained(model_id)
+tokenizer.model_max_length = 2048
+model = AutoModelForCausalLM.from_pretrained(model_id, **model_kwargs)
+model = get_peft_model(model, lora_conf)
+
+def count_trainable_parameters(model):
+    model_parameters = filter(lambda p: p.requires_grad, model.parameters())
+    params = sum([np.prod(p.size()) for p in model_parameters])
+    return params
+
+trainable_params = format(count_trainable_parameters(model), ",")
+
+epochs = 1
+per_dev_batch_size = 1
+gradient_accumulation_steps = 30
+dtype = torch.bfloat16
+learning_rate = 1e-5
+
+raw_dataset = load_dataset(dataset_id, "0625", split="train")
+
+def apply_chat_template(example, tokenizer):
+    convo = example['conversations']
+    for dic in convo:
+        dic['role'] = dic.pop('from')
+        dic['content'] = dic.pop('value')
+        if dic['role'] == 'gpt':
+            dic['role'] = 'assistant'
+        elif dic['role'] == 'human':
+            dic['role'] = 'user'
+
+    example['text'] = tokenizer.apply_chat_template(convo, tokenize=True, add_generation_prompt=False, truncation=True)
+    return example
+
+train_dataset = raw_dataset.select(range(100000))
+test_dataset = raw_dataset.select(range(300))
+column_names = list(train_dataset.features)
+
+processed_train_dataset = train_dataset.map(
+    apply_chat_template,
+    # batched=True,
+    # batch_size=20,
+    fn_kwargs={"tokenizer": tokenizer},
+    num_proc=10,
+    remove_columns=column_names,
+)
+
+processed_test_dataset = test_dataset.map(
+    apply_chat_template,
+    # batched=True,
+    # batch_size=20,
+    fn_kwargs={"tokenizer": tokenizer},
+    num_proc=10,
+    remove_columns=column_names,
+)
+
+data_collator = DataCollatorForLanguageModeling(tokenizer=tokenizer, mlm=False)
+
+train_dataloader = torch.utils.data.DataLoader( # 
+    processed_train_dataset['text'],
+    batch_size=per_dev_batch_size,
+    shuffle=True,
+    collate_fn=data_collator
+)
+
+test_dataloader = torch.utils.data.DataLoader(
+    processed_test_dataset['text'],
+    batch_size=per_dev_batch_size,
+    shuffle=True,
+    collate_fn=data_collator
+)
+
+global_step = 0
+num_training_steps = epochs * len(train_dataloader)
+warmup_ratio = 0.1
+warmup_steps = 1000
+#warmup_steps = int(warmup_ratio * num_training_steps)
+
+optimizer = optim.AdamW(model.parameters(), lr=learning_rate)
+cross_entropy = nn.CrossEntropyLoss()
+
+scheduler = get_scheduler(
+    name="cosine",
+    optimizer=optimizer, 
+    num_warmup_steps=warmup_steps,
+    num_training_steps=num_training_steps
+)
+
+acc = Accelerator(gradient_accumulation_steps=gradient_accumulation_steps)
+
+if acc.is_main_process:
+    wandb.init(
+        project="tiny-llama-instruct",
+    
+        config={
+        "learning_rate": learning_rate,
+        "dataset": dataset_id,
+        "batch_size": per_dev_batch_size,
+        "lora_r": lora_conf.r,
+        "lora_alpha": lora_conf.lora_alpha,
+        "lora_dropout": lora_conf.lora_dropout,
+        "gradient_accumulation_steps": gradient_accumulation_steps,
+        "warmup_ratio": warmup_ratio,
+        "trainable_params": trainable_params,
+        "num_training_steps": num_training_steps, 
+        "model_name": "TinyLlama"
+        }
+    )   
+
+optimizer, scheduler, train_dataloader, tokenizer, model, scheduler = acc.prepare(optimizer, scheduler, train_dataloader, tokenizer, model, scheduler)
+
+def calc_metrics():
+    model.eval()
+    for batch in test_dataloader:
+        pred = model(**batch)
+        loss = pred.loss
+
+        if acc.is_main_process:
+            perplexity = torch.exp(loss)
+            wandb.log({"eval_loss": loss.item(), "eval_perplexity": perplexity})
+
+    model.train()
+
+device = acc.device
+
+model.train()
+for epoch in range(epochs):
+    for step, batch in enumerate(train_dataloader):
+        
+        # outputs = model(**batch)
+        # loss = outputs.loss
+        
+        # acc.backward(loss)
+        # wandb.log({"loss": loss.item(), "learning_rate": optimizer.param_groups[0]['lr'], "perplexity": perplexity})
+
+        with acc.accumulate(model):
+            batch = {k: v.to(device) for k, v in batch.items()}
+            outputs = model(**batch)
+            loss = outputs.loss
+            acc.backward(loss)
+            optimizer.step()
+            scheduler.step()
+            optimizer.zero_grad()
+
+            if acc.is_main_process:
+                perplexity = torch.exp(loss)
+                wandb.log({"loss": loss.item(), "learning_rate": optimizer.param_groups[0]['lr'], "perplexity": perplexity})
+                
+            global_step += 1
+        
+        # if (step + 1) % gradient_accumulation_steps == 0:
+        #     optimizer.step()
+        #     scheduler.step()
+        #     optimizer.zero_grad()
+        #     global_step += 1
+    
+        if (step + 1) % 100 == 0 and acc.is_main_process:
+            print(f"Loss: {loss.item()}")
+            
+        if (step + 1) % 400 == 0:
+            calc_metrics()
+
+        if global_step > num_training_steps:
+            break
+
+    if global_step > num_training_steps:
+        break
+
+if acc.is_main_process:
+    wandb.finish()
+
+    save_path = os.path.join("checkpoint_instruct_2", f"step_{global_step}")
+    model.module.save_pretrained(save_path)
+
+    print("Saved model")

ft_news.py

@@ -0,0 +1,213 @@
+from transformers import AutoTokenizer, AutoModelForCausalLM, DataCollatorForLanguageModeling, get_scheduler
+from huggingface_hub import HfApi, notebook_login
+from datasets import load_dataset
+from peft import LoraConfig, LoraModel, get_peft_model
+from timm.scheduler import CosineLRScheduler
+import wandb
+import os
+from accelerate import Accelerator
+import numpy as np
+import torch
+import tqdm
+import torch.nn as nn
+import torch.optim as optim
+
+lora_conf = LoraConfig(
+    r=8,
+    lora_alpha=32,
+    lora_dropout=0.05,
+    bias="none",
+    task_type="CAUSAL_LM",
+    target_modules="all-linear",
+    modules_to_save=None,
+)
+
+model_id = "Qwen/Qwen2-1.5B-Instruct"
+dataset_id = "GonzaloA/fake_news"
+
+model_kwargs = dict(
+    use_cache=False,
+    #attn_implementation="flash_attention_2",
+    torch_dtype="auto",
+    device_map="sequential",
+)
+
+tokenizer = AutoTokenizer.from_pretrained(model_id)
+tokenizer.model_max_length = 2048
+model = AutoModelForCausalLM.from_pretrained(model_id, **model_kwargs)
+model = get_peft_model(model, lora_conf)
+
+def count_trainable_parameters(model):
+    model_parameters = filter(lambda p: p.requires_grad, model.parameters())
+    params = sum([np.prod(p.size()) for p in model_parameters])
+    return params
+
+trainable_params = format(count_trainable_parameters(model), ",")
+
+epochs = 1
+per_dev_batch_size = 1
+gradient_accumulation_steps = 20
+dtype = torch.bfloat16
+learning_rate = 1e-4
+
+train_dataset = load_dataset(dataset_id, split="train")
+test_dataset = load_dataset(dataset_id, split="test").select(range(100))
+
+def apply_chat_template(example, tokenizer):
+    story = example['text']
+    chat = [
+        {"role": "system", "content": "Given a title, please generate a news story"},
+        {"role": "user", "content": example['title']},
+        {"role": "assistant", "content": story}
+    ]
+
+    example['text'] = tokenizer.apply_chat_template(chat, tokenize=True, add_generation_prompt=False, truncation=True)
+    #example['text'] = tokenizer([text], return_tensors="pt")
+    return example
+
+
+processed_train_dataset = train_dataset.map(
+    apply_chat_template,
+    # batched=True,
+    # batch_size=20,
+    fn_kwargs={"tokenizer": tokenizer},
+    num_proc=10,
+    #remove_columns=column_names,
+)
+
+processed_test_dataset = test_dataset.map(
+    apply_chat_template,
+    # batched=True,
+    # batch_size=20,
+    fn_kwargs={"tokenizer": tokenizer},
+    num_proc=10,
+    #remove_columns=column_names,
+)
+
+data_collator = DataCollatorForLanguageModeling(tokenizer=tokenizer, mlm=False)
+
+train_dataloader = torch.utils.data.DataLoader( # 
+    processed_train_dataset['text'],
+    batch_size=per_dev_batch_size,
+    shuffle=False,
+    collate_fn=data_collator
+)
+
+test_dataloader = torch.utils.data.DataLoader(
+    processed_test_dataset['text'],
+    batch_size=per_dev_batch_size,
+    shuffle=False,
+    collate_fn=data_collator
+)
+
+global_step = 0
+num_training_steps = epochs * len(train_dataloader)
+warmup_ratio = 0.1
+warmup_steps = 500
+#warmup_steps = int(warmup_ratio * num_training_steps)
+
+optimizer = optim.AdamW(model.parameters(), lr=learning_rate)
+cross_entropy = nn.CrossEntropyLoss()
+
+scheduler = get_scheduler(
+    name="cosine",
+    optimizer=optimizer, 
+    num_warmup_steps=warmup_steps,
+    num_training_steps=num_training_steps
+)
+
+acc = Accelerator(gradient_accumulation_steps=gradient_accumulation_steps)
+
+if acc.is_main_process:
+    wandb.init(
+        project="qwen-fake-news",
+    
+        config={
+        "learning_rate": learning_rate,
+        "dataset": dataset_id,
+        "batch_size": per_dev_batch_size,
+        "lora_r": lora_conf.r,
+        "lora_alpha": lora_conf.lora_alpha,
+        "lora_dropout": lora_conf.lora_dropout,
+        "gradient_accumulation_steps": gradient_accumulation_steps,
+        "warmup_ratio": warmup_ratio,
+        "trainable_params": trainable_params,
+        "num_training_steps": num_training_steps, 
+        "model_name": "TinyLlama"
+        }
+    )   
+
+optimizer, scheduler, train_dataloader, tokenizer, model, scheduler = acc.prepare(optimizer, scheduler, train_dataloader, tokenizer, model, scheduler)
+
+def save_checkpoint():
+    if acc.is_main_process:    
+        save_path = os.path.join("checkpoint_news", f"step_{global_step}")
+        model.module.save_pretrained(save_path)
+    
+        print(f"Saved model at step {global_step}")
+
+def calc_metrics():
+    model.eval()
+    for batch in test_dataloader:
+        pred = model(**batch)
+        loss = pred.loss
+
+        if acc.is_main_process:
+            perplexity = torch.exp(loss)
+            wandb.log({"eval_loss": loss.item(), "eval_perplexity": perplexity})
+
+    model.train()
+
+device = acc.device
+
+model.train()
+for epoch in range(epochs):
+    for step, batch in enumerate(train_dataloader):
+        #print(tokenizer.decode(batch['input_ids'][0]))
+        
+        # outputs = model(**batch)
+        # loss = outputs.loss
+        
+        # acc.backward(loss)
+        # wandb.log({"loss": loss.item(), "learning_rate": optimizer.param_groups[0]['lr'], "perplexity": perplexity})
+
+        with acc.accumulate(model):
+            #batch = {k: v.to(device) for k, v in batch.items()}
+            outputs = model(**batch)
+            loss = outputs.loss
+            acc.backward(loss)
+            optimizer.step()
+            scheduler.step()
+            optimizer.zero_grad()
+                
+            if acc.is_main_process:
+                perplexity = torch.exp(loss)
+                wandb.log({"loss": loss.item(), "learning_rate": optimizer.param_groups[0]['lr'], "perplexity": perplexity})
+            
+            global_step += 1
+
+        if (step + 1) % 1000 == 0:
+            save_checkpoint()
+        
+        # if (step + 1) % gradient_accumulation_steps == 0:
+        #     optimizer.step()
+        #     scheduler.step()
+        #     optimizer.zero_grad()
+        #     global_step += 1
+    
+        if (step + 1) % 100 == 0 and acc.is_main_process:
+            print(f"Loss: {loss.item()}")
+            
+            
+        if (step + 1) % 400 == 0:
+            calc_metrics()
+
+        if global_step > num_training_steps:
+            break
+
+    if global_step > num_training_steps:
+        break
+
+if acc.is_main_process:
+    wandb.finish()
+    save_checkpoint()

ft_skib.py

@@ -0,0 +1,223 @@
+from transformers import AutoTokenizer, AutoModelForCausalLM, DataCollatorForLanguageModeling, get_scheduler
+from huggingface_hub import HfApi, notebook_login
+from datasets import load_dataset
+from peft import LoraConfig, LoraModel, get_peft_model
+from timm.scheduler import CosineLRScheduler
+import wandb
+import os
+from accelerate import Accelerator
+import numpy as np
+import torch
+import tqdm
+import torch.nn as nn
+import torch.optim as optim
+
+lora_conf = LoraConfig(
+    r=8,
+    lora_alpha=32,
+    lora_dropout=0.05,
+    bias="none",
+    task_type="CAUSAL_LM",
+    target_modules="all-linear",
+    modules_to_save=None,
+)
+
+model_id = "Qwen/Qwen2-1.5B-Instruct"
+dataset_id = "HuggingFaceH4/orca-math-word-problems-200k"
+
+model_kwargs = dict(
+    use_cache=False,
+    #attn_implementation="flash_attention_2",
+    torch_dtype="auto",
+    device_map="sequential",
+)
+
+tokenizer = AutoTokenizer.from_pretrained(model_id)
+tokenizer.model_max_length = 2048
+model = AutoModelForCausalLM.from_pretrained(model_id, **model_kwargs)
+model = get_peft_model(model, lora_conf)
+
+def count_trainable_parameters(model):
+    model_parameters = filter(lambda p: p.requires_grad, model.parameters())
+    params = sum([np.prod(p.size()) for p in model_parameters])
+    return params
+
+trainable_params = format(count_trainable_parameters(model), ",")
+
+epochs = 1
+per_dev_batch_size = 1
+gradient_accumulation_steps = 20
+dtype = torch.bfloat16
+learning_rate = 1e-4
+
+train_dataset = load_dataset(dataset_id, split="train_sft").select(range(150000))
+test_dataset = load_dataset(dataset_id, split="test_sft").select(range(100))
+
+# def apply_chat_template(example, tokenizer):
+#     chat = []
+#     convo = example['conversations']
+#     for dic in convo:
+#         if dic['from'] == 'human':
+#             chat = [
+#                 {"role": "user", "content": dic['value']},
+#                 {"role": "assistant", "content": "skibbidy"}
+#             ]
+
+#     example['text'] = tokenizer.apply_chat_template(chat, tokenize=True, add_generation_prompt=False, truncation=True)
+#     return example
+
+# train_dataset = raw_dataset.select(range(10000))
+# test_dataset = raw_dataset.select(range(300))
+# column_names = list(train_dataset.features)
+
+def apply_chat_template(example, tokenizer):
+    example['text'] = tokenizer.apply_chat_template(example['messages'], tokenize=True, add_generation_prompt=False, truncation=True)
+    return example
+
+column_names = list(train_dataset.features)
+
+processed_train_dataset = train_dataset.map(
+    apply_chat_template,
+    # batched=True,
+    # batch_size=20,
+    fn_kwargs={"tokenizer": tokenizer},
+    num_proc=10,
+    remove_columns=column_names,
+)
+
+processed_test_dataset = test_dataset.map(
+    apply_chat_template,
+    # batched=True,
+    # batch_size=20,
+    fn_kwargs={"tokenizer": tokenizer},
+    num_proc=10,
+    remove_columns=column_names,
+)
+
+data_collator = DataCollatorForLanguageModeling(tokenizer=tokenizer, mlm=False)
+
+train_dataloader = torch.utils.data.DataLoader( # 
+    processed_train_dataset['text'],
+    batch_size=per_dev_batch_size,
+    shuffle=False,
+    collate_fn=data_collator
+)
+
+test_dataloader = torch.utils.data.DataLoader(
+    processed_test_dataset['text'],
+    batch_size=per_dev_batch_size,
+    shuffle=False,
+    collate_fn=data_collator
+)
+
+global_step = 0
+num_training_steps = epochs * len(train_dataloader)
+warmup_ratio = 0.1
+warmup_steps = 500
+#warmup_steps = int(warmup_ratio * num_training_steps)
+
+optimizer = optim.AdamW(model.parameters(), lr=learning_rate)
+cross_entropy = nn.CrossEntropyLoss()
+
+scheduler = get_scheduler(
+    name="cosine",
+    optimizer=optimizer, 
+    num_warmup_steps=warmup_steps,
+    num_training_steps=num_training_steps
+)
+
+acc = Accelerator(gradient_accumulation_steps=gradient_accumulation_steps)
+
+if acc.is_main_process:
+    wandb.init(
+        project="qwen-math",
+    
+        config={
+        "learning_rate": learning_rate,
+        "dataset": dataset_id,
+        "batch_size": per_dev_batch_size,
+        "lora_r": lora_conf.r,
+        "lora_alpha": lora_conf.lora_alpha,
+        "lora_dropout": lora_conf.lora_dropout,
+        "gradient_accumulation_steps": gradient_accumulation_steps,
+        "warmup_ratio": warmup_ratio,
+        "trainable_params": trainable_params,
+        "num_training_steps": num_training_steps, 
+        "model_name": "TinyLlama"
+        }
+    )   
+
+optimizer, scheduler, train_dataloader, tokenizer, model, scheduler = acc.prepare(optimizer, scheduler, train_dataloader, tokenizer, model, scheduler)
+
+def save_checkpoint():
+    if acc.is_main_process:    
+        save_path = os.path.join("checkpoint_math", f"step_{global_step}")
+        model.module.save_pretrained(save_path)
+    
+        print(f"Saved model at step {global_step}")
+
+def calc_metrics():
+    model.eval()
+    for batch in test_dataloader:
+        pred = model(**batch)
+        loss = pred.loss
+
+        if acc.is_main_process:
+            perplexity = torch.exp(loss)
+            wandb.log({"eval_loss": loss.item(), "eval_perplexity": perplexity})
+
+    model.train()
+
+device = acc.device
+
+model.train()
+for epoch in range(epochs):
+    for step, batch in enumerate(train_dataloader):
+        #print(tokenizer.decode(batch['input_ids'][0]))
+        
+        # outputs = model(**batch)
+        # loss = outputs.loss
+        
+        # acc.backward(loss)
+        # wandb.log({"loss": loss.item(), "learning_rate": optimizer.param_groups[0]['lr'], "perplexity": perplexity})
+
+        with acc.accumulate(model):
+            #batch = {k: v.to(device) for k, v in batch.items()}
+            outputs = model(**batch)
+            loss = outputs.loss
+            acc.backward(loss)
+            optimizer.step()
+            scheduler.step()
+            optimizer.zero_grad()
+                
+            if acc.is_main_process:
+                perplexity = torch.exp(loss)
+                wandb.log({"loss": loss.item(), "learning_rate": optimizer.param_groups[0]['lr'], "perplexity": perplexity})
+            
+            global_step += 1
+
+        if (step + 1) % 1000 == 0:
+            save_checkpoint()
+        
+        # if (step + 1) % gradient_accumulation_steps == 0:
+        #     optimizer.step()
+        #     scheduler.step()
+        #     optimizer.zero_grad()
+        #     global_step += 1
+    
+        if (step + 1) % 100 == 0 and acc.is_main_process:
+            print(f"Loss: {loss.item()}")
+            
+            
+        if (step + 1) % 400 == 0:
+            calc_metrics()
+
+        if global_step > num_training_steps:
+            break
+
+    if global_step > num_training_steps:
+        break
+
+if acc.is_main_process:
+    wandb.finish()
+    save_checkpoint()