Skip to content

armgit / dspy

Public Imported from GitHub
0

DSPy: The framework for programming—not prompting—language models

Python

Port BootstrapFinetune and other related changes

Omar Khattabbc23a70f8f05
diff --git a/.gitignore b/.gitignore
index 52f96898a..b1676ba65 100644
--- a/.gitignore
+++ b/.gitignore
@@ -35,4 +35,8 @@ build/
!/data/*.json
/dist/
# **/*.pkl
-checklist.md
\ No newline at end of file
+checklist.md
+examples/
+finetuning_ckpts/
+cache/
+* copy*
\ No newline at end of file
diff --git a/README.md b/README.md
index 1de70ed68..25fc94d4d 100644
--- a/README.md
+++ b/README.md
@@ -242,12 +242,12 @@ Or open it directly in free Google Colab: [<img align="center" src="https://cola
- `dspy.OpenAI`
- `dspy.Cohere`
- `dspy.TGI`
-- `dspy.VLLM` [porting soon]
+- `dspy.VLLM`
#### Retrieval Model Clients
- `dspy.ColBERTv2`
-- `dspy.AzureCognitiveSearch` [porting soon]
+- `dspy.AzureCognitiveSearch`
#### Signatures
@@ -261,7 +261,7 @@ Or open it directly in free Google Colab: [<img align="center" src="https://cola
- `dspy.Predict`
- `dspy.Retrieve`
- `dspy.ChainOfThought`
-- `dspy.SelfConsistency` [coming soon; use functional `dspy.majority` now]
+- `dspy.SelfConsistency` [use functional `dspy.majority` now]
- `dspy.MultiChainReasoning` [coming soon]
- `dspy.SelfCritique` [coming soon]
- `dspy.SelfRevision` [coming soon]
@@ -272,7 +272,7 @@ Or open it directly in free Google Colab: [<img align="center" src="https://cola
- `dspy.teleprompt.LabeledFewShot`
- `dspy.teleprompt.BootstrapFewShot`
- `dspy.teleprompt.BootstrapFewShotWithRandomSearch`
-- `dspy.teleprompt.BootstrapFinetune` [porting soon]
+- `dspy.teleprompt.BootstrapFinetune`
</details>
diff --git a/dsp/modules/finetuning/__init__.py b/dsp/modules/finetuning/__init__.py
new file mode 100644
index 000000000..f0ef12e8d
--- /dev/null
+++ b/dsp/modules/finetuning/__init__.py
@@ -0,0 +1 @@
+from .finetune_hf import *
\ No newline at end of file
diff --git a/dsp/modules/finetuning/finetune_hf.py b/dsp/modules/finetuning/finetune_hf.py
new file mode 100644
index 000000000..e899c4c29
--- /dev/null
+++ b/dsp/modules/finetuning/finetune_hf.py
@@ -0,0 +1,374 @@
+# Adapted from: https://www.philschmid.de/fine-tune-flan-t5#3-fine-tune-and-evaluate-flan-t5
+
+import os
+import json
+import copy
+import glob
+import torch
+import random
+import warnings
+import evaluate
+import numpy as np
+from datasets import Dataset
+from dataclasses import dataclass
+from transformers import (
+ set_seed,
+ AutoConfig,
+ AutoModelForSeq2SeqLM,
+ AutoModelForCausalLM,
+ AutoTokenizer,
+ PreTrainedTokenizer,
+ Trainer,
+ Seq2SeqTrainer,
+ TrainingArguments,
+ Seq2SeqTrainingArguments,
+ DataCollatorForSeq2Seq,
+)
+# from peft import get_peft_model, LoraConfig, TaskType
+from transformers.trainer_callback import TrainerCallback
+
+# from dsp.modules.finetuning.fid import *
+
+
+warnings.filterwarnings("ignore")
+
+IGNORE_INDEX = -100
+DEFAULT_SEP_TOKEN = "[SEP]"
+DEFAULT_PAD_TOKEN = "[PAD]"
+DEFAULT_EOS_TOKEN = "</s>"
+DEFAULT_BOS_TOKEN = "<s>"
+DEFAULT_UNK_TOKEN = "</s>"
+SPECIAL_TOKENS_DICT = {
+ "sep_token": DEFAULT_SEP_TOKEN,
+ "pad_token": DEFAULT_PAD_TOKEN,
+ # "eos_token": DEFAULT_EOS_TOKEN,
+ # "bos_token": DEFAULT_BOS_TOKEN,
+ "unk_token": DEFAULT_UNK_TOKEN,
+}
+
+
+def _freeze_model_layers(model, unfreeze_last_n):
+ # Freeze all layers
+ for parameter in model.parameters():
+ parameter.requires_grad = False
+
+ # Unfreeze the last n transformer blocks in the decoder
+ NUM_DECODER_LAYERS = len(model.transformer.h)
+ for i, m in enumerate(model.transformer.h):
+ if i >= NUM_DECODER_LAYERS - unfreeze_last_n:
+ for parameter in m.parameters():
+ parameter.requires_grad = True
+
+ # Unfreeze parameters after decoder block
+ for parameter in model.transformer.ln_f.parameters():
+ parameter.requires_grad = True
+ for parameter in model.lm_head.parameters():
+ parameter.requires_grad = True
+ return model
+
+
+def _load_data(path):
+ # dataset = Dataset.from_json(path)
+ L = []
+ import ujson
+ with open(path) as f:
+ for line in f:
+ L.append(ujson.loads(line))
+
+ dataset = Dataset.from_list(L)
+ return dataset
+
+
+def preprocess_prompt(text, tokenizer, encoder_decoder_model, decoder_only_model, rationale):
+ text = f'{text} ' if encoder_decoder_model else f'{text} {tokenizer.sep_token}'
+ return text
+
+
+def preprocess_completion(text, tokenizer, encoder_decoder_model, decoder_only_model, rationale):
+ text = text if encoder_decoder_model else f'{text}{tokenizer.eos_token}'
+ return text.lstrip()
+
+
+def _preprocess_data(dataset, tokenizer, encoder_decoder_model, decoder_only_model, config):
+ dataset = dataset.map(lambda x: {
+ "prompt": preprocess_prompt(x["prompt"], tokenizer, encoder_decoder_model, decoder_only_model, config['rationale']),
+ "completion": preprocess_completion(x["completion"], tokenizer, encoder_decoder_model, decoder_only_model, config['rationale']),
+ })
+ skipped = [x for x in dataset if x["completion"] is None]
+ print(f'# examples skipped due to parsing error: {len(skipped)} / {len(dataset)}')
+ dataset = dataset.filter(lambda x: x["completion"])
+ return dataset
+
+
+def _tokenize_dataset(dataset, tokenizer, encoder_decoder_model, decoder_only_model):
+ def get_dataset_stats(dataset, tokenizer, column):
+ tokenized_inputs = dataset.map(lambda x: tokenizer(x[column]), batched=True)
+ max_length = max([len(x) for x in tokenized_inputs["input_ids"]])
+ return max_length
+
+ def get_tokens_seq2seq(sample, max_source_length, max_target_length, padding="max_length"):
+ # Tokenize inputs
+ model_inputs = tokenizer(sample["prompt"], max_length=max_source_length, padding=padding, truncation=True)
+
+ # Tokenize targets
+ labels = tokenizer(text_target=sample["completion"], max_length=max_target_length, padding=padding, truncation=True)
+ labels = labels["input_ids"]
+
+ # Replace all tokenizer.pad_token_id in the labels by IGNORE_INDEX when we want to ignore padding in the loss.
+ if padding == "max_length":
+ labels = [[(l if l != tokenizer.pad_token_id else IGNORE_INDEX) for l in label] for label in labels]
+
+ model_inputs["labels"] = labels
+ return model_inputs
+
+ def get_tokens_causal(sample, max_length, padding="max_length"):
+ # Tokenize inputs
+ model_inputs = tokenizer(sample["combined"], max_length=max_length, padding=padding, truncation=True)
+
+ # Create targets
+ labels = copy.deepcopy(model_inputs["input_ids"])
+ prompts = tokenizer(sample["prompt"], max_length=max_length, truncation=True)
+ prompt_lens = [len(tokens) for tokens in prompts["input_ids"]]
+ for label, source_len in zip(labels, prompt_lens):
+ label[:source_len] = [IGNORE_INDEX] * source_len
+
+ # Replace all tokenizer.pad_token_id in the labels by IGNORE_INDEX when we want to ignore padding in the loss.
+ if padding == "max_length":
+ labels = [[(l if l != tokenizer.pad_token_id else IGNORE_INDEX) for l in label] for label in labels]
+
+ model_inputs["labels"] = labels
+ return model_inputs
+
+ if encoder_decoder_model:
+ max_source_length = get_dataset_stats(dataset, tokenizer, "prompt")
+ max_target_length = get_dataset_stats(dataset, tokenizer, "completion")
+ kwargs = {"max_source_length" : max_source_length, "max_target_length" : max_target_length}
+ tokenized_dataset = dataset.map(get_tokens_seq2seq, batched=True, fn_kwargs=kwargs)
+
+ elif decoder_only_model:
+ dataset = dataset.map(lambda example: {"combined": example["prompt"] + " " + example["completion"]})
+ dataset = dataset.filter(lambda x: len(tokenizer(x["combined"])["input_ids"]) <= tokenizer.model_max_length)
+ max_length = get_dataset_stats(dataset, tokenizer, "combined")
+ kwargs = {"max_length" : max_length}
+ tokenized_dataset = dataset.map(get_tokens_causal, batched=True, fn_kwargs=kwargs)
+
+ print(f"Dataset statistics: {kwargs}")
+ print(f"Keys of tokenized dataset: {list(tokenized_dataset.features)}")
+ return tokenized_dataset
+
+
+def _compute_metrics(metric, eval_preds, tokenizer):
+ preds, labels = eval_preds
+ if isinstance(preds, tuple):
+ preds = preds[0]
+ decoded_preds = tokenizer.batch_decode(preds, skip_special_tokens=True)
+
+ # Replace IGNORE_INDEX in the labels as we can't decode them.
+ labels = np.where(labels != IGNORE_INDEX, labels, tokenizer.pad_token_id)
+ decoded_labels = tokenizer.batch_decode(labels, skip_special_tokens=True)
+
+ result = metric.compute(predictions=decoded_preds, references=decoded_labels, use_stemmer=True)
+ result = {k: round(v * 100, 4) for k, v in result.items()}
+ prediction_lens = [np.count_nonzero(pred != tokenizer.pad_token_id) for pred in preds]
+ result["gen_len"] = np.mean(prediction_lens)
+ return result
+
+
+class PeftSavingCallback(TrainerCallback):
+ def on_train_end(self, args, state, control, **kwargs):
+ peft_model_path = state.best_model_checkpoint
+ kwargs["model"].save_pretrained(peft_model_path)
+
+ pytorch_model_path = os.path.join(state.best_model_checkpoint, "pytorch_model.bin")
+ os.remove(pytorch_model_path) if os.path.exists(pytorch_model_path) else None
+
+
+def _train_seq2seq(model, tokenizer, tokenized_dataset, metric, config):
+ # Define data collator
+ data_collator = DataCollatorForSeq2Seq(tokenizer=tokenizer, model=model)
+
+ # Define training args
+ training_args = Seq2SeqTrainingArguments(
+ output_dir=config['output_dir'],
+ per_device_train_batch_size=config['batch_size'],
+ gradient_accumulation_steps=config['gradient_accumulation_steps'],
+ per_device_eval_batch_size=config['batch_size'],
+ predict_with_generate=True,
+ learning_rate=config['lr'], #1e-4, # 5e-5
+ num_train_epochs=config['epochs'],
+ # logging & evaluation strategies
+ log_level="error",
+ logging_dir=f"{config['output_dir']}/logs",
+ logging_strategy="steps",
+ logging_steps=500,
+ evaluation_strategy="epoch",
+ save_strategy="epoch",
+ save_total_limit=config['epochs'],
+ load_best_model_at_end=True,
+ report_to="tensorboard",
+ fp16=config['fp16'],
+ bf16=config['bf16'],
+ )
+
+ # Create trainer instance
+ trainer = Seq2SeqTrainer(
+ model=model,
+ tokenizer=tokenizer,
+ args=training_args,
+ train_dataset=tokenized_dataset["train"],
+ eval_dataset=tokenized_dataset["test"],
+ data_collator=data_collator,
+ compute_metrics=lambda x: _compute_metrics(metric, x, tokenizer),
+ callbacks=[PeftSavingCallback] if config['peft'] else None,
+ )
+
+ trainer.train()
+
+ return trainer.state.best_model_checkpoint
+
+
+def smart_tokenizer_and_embedding_resize(special_tokens_dict, tokenizer, model):
+ """
+ Resize tokenizer and embedding.
+ Note: This is the unoptimized version that may make your embedding size not be divisible by 64.
+ """
+ num_new_tokens = tokenizer.add_special_tokens(special_tokens_dict)
+ model.resize_token_embeddings(len(tokenizer))
+
+ if num_new_tokens > 0:
+ input_embeddings = model.get_input_embeddings().weight.data
+ output_embeddings = model.get_output_embeddings().weight.data
+
+ input_embeddings_avg = input_embeddings[:-num_new_tokens].mean(dim=0, keepdim=True)
+ output_embeddings_avg = output_embeddings[:-num_new_tokens].mean(dim=0, keepdim=True)
+
+ input_embeddings[-num_new_tokens:] = input_embeddings_avg
+ output_embeddings[-num_new_tokens:] = output_embeddings_avg
+
+
+@dataclass
+class DataCollatorForSupervisedDataset(object):
+ """
+ Collate examples for supervised fine-tuning.
+ """
+ tokenizer: PreTrainedTokenizer
+
+ def __call__(self, instances):
+ pad_token_id = self.tokenizer.pad_token_id
+
+ input_ids, labels = tuple([instance[key] for instance in instances] for key in ("input_ids", "labels"))
+ input_ids, labels = torch.tensor(input_ids), torch.tensor(labels)
+
+ input_ids = torch.nn.utils.rnn.pad_sequence(input_ids, batch_first=True, padding_value=pad_token_id)
+
+ labels = torch.nn.utils.rnn.pad_sequence(labels, batch_first=True, padding_value=IGNORE_INDEX)
+ return dict(input_ids=input_ids, labels=labels, attention_mask=input_ids.ne(pad_token_id))
+
+
+def _train_causal(model, tokenizer, tokenized_dataset, metric, config):
+ # Define data collator
+ data_collator = DataCollatorForSupervisedDataset(tokenizer=tokenizer)
+
+ # Define training args
+ training_args = TrainingArguments(
+ output_dir=config['output_dir'],
+ per_device_train_batch_size=config['batch_size'],
+ gradient_accumulation_steps=config['gradient_accumulation_steps'],
+ per_device_eval_batch_size=config['batch_size'],
+ learning_rate=config['lr'], #1e-4,# 5e-5
+ num_train_epochs=config['epochs'],
+ # logging & evaluation strategies
+ log_level="error",
+ logging_dir=f"{config['output_dir']}/logs",
+ logging_strategy="steps",
+ logging_steps=500,
+ evaluation_strategy="epoch",
+ save_strategy="epoch",
+ save_total_limit=config['epochs'],
+ load_best_model_at_end=True,
+ report_to="tensorboard",
+ fp16=config['fp16'],
+ bf16=config['bf16'],
+ )
+
+ # Create trainer instance
+ trainer = Trainer(
+ model=model,
+ tokenizer=tokenizer,
+ args=training_args,
+ train_dataset=tokenized_dataset["train"],
+ eval_dataset=tokenized_dataset["test"],
+ data_collator=data_collator,
+ callbacks=[PeftSavingCallback] if config['peft'] else None,
+ )
+
+ trainer.train()
+
+ return trainer.state.best_model_checkpoint
+
+
+def finetune_hf(data_path, target, config):
+ set_seed(42)
+
+ output_dir = os.path.join('../finetuning_ckpts', config['save'])
+
+ if os.path.exists(output_dir):
+ # training completed, load best model
+ ckpts = glob.glob(f'{output_dir}/checkpoint*')
+ final_ckpt = sorted(ckpts, key=lambda x: int(x.split('-')[-1]))[-1]
+ with open(os.path.join(final_ckpt, 'trainer_state.json'), 'r') as f:
+ state = json.load(f)
+ best_model_checkpoint = state['best_model_checkpoint']
+
+ else:
+ os.makedirs(output_dir, exist_ok=True)
+ config['target'] = target
+ config['output_dir'] = output_dir
+ with open(os.path.join(config['output_dir'], 'compiler_config.json'), 'w') as f:
+ json.dump(config, f)
+
+ architecture = AutoConfig.from_pretrained(target).__dict__["architectures"][0]
+ encoder_decoder_model = ("ConditionalGeneration" in architecture) or ("T5WithLMHeadModel" in architecture)
+ decoder_only_model = ("CausalLM" in architecture) or ("GPT2LMHeadModel" in architecture)
+ assert encoder_decoder_model or decoder_only_model, f"Unknown HuggingFace model class: {target}"
+ assert not config['fid'] or encoder_decoder_model, f"Model must be encoder-decoder for Fusion in Decoder"
+ assert not config['fid'] or not config['peft'], f"FiD and PEFT can't be trained together"
+
+ # load model
+ AutoModelClass = AutoModelForSeq2SeqLM if encoder_decoder_model else AutoModelForCausalLM
+ if config['peft']:
+ model = AutoModelClass.from_pretrained(target, device_map='auto')
+ task_type = TaskType.SEQ_2_SEQ_LM if encoder_decoder_model else TaskType.CAUSAL_LM
+ peft_config = LoraConfig(task_type=task_type, inference_mode=False, r=8, lora_alpha=32, lora_dropout=0.1)
+ model = get_peft_model(model, peft_config)
+ model.print_trainable_parameters()
+ else:
+ if config['fid']:
+ t5 = AutoModelClass.from_pretrained(target)
+ model = FiDT5(t5.config)
+ model.load_t5(t5.state_dict())
+ else:
+ model = AutoModelClass.from_pretrained(target)
+ # model = _freeze_model_layers(model, unfreeze_last_n=2)
+
+ # load tokenizer
+ tokenizer = AutoTokenizer.from_pretrained(target)
+ if decoder_only_model:
+ smart_tokenizer_and_embedding_resize(SPECIAL_TOKENS_DICT, tokenizer, model)
+
+ # load data
+ dataset = _load_data(data_path)
+ dataset = _preprocess_data(dataset, tokenizer, encoder_decoder_model, decoder_only_model, config)
+ tokenized_dataset = _tokenize_dataset(dataset, tokenizer, encoder_decoder_model, decoder_only_model)
+ tokenized_dataset = tokenized_dataset.train_test_split(test_size=0.1)
+ print(f'Finetuning dataset: {tokenized_dataset}')
+
+ # start training
+ metric = evaluate.load("rouge")
+ if encoder_decoder_model:
+ best_model_checkpoint = _train_seq2seq(model, tokenizer, tokenized_dataset, metric, config)
+ elif decoder_only_model:
+ best_model_checkpoint = _train_causal(model, tokenizer, tokenized_dataset, metric, config)
+
+ print(f'Best checkpoint of model: {best_model_checkpoint}')
+ return best_model_checkpoint
diff --git a/dsp/modules/lm.py b/dsp/modules/lm.py
index 592d0585e..4f845d021 100644
--- a/dsp/modules/lm.py
+++ b/dsp/modules/lm.py
@@ -80,4 +80,7 @@ class LM(ABC):
def copy(self, **kwargs):
"""Returns a copy of the language model with the same parameters."""
- return self.__class__(self.kwargs['model'], **{**self.kwargs, **kwargs})
+ kwargs = {**self.kwargs, **kwargs}
+ model = kwargs.pop('model')
+
+ return self.__class__(model, **kwargs)
diff --git a/dsp/templates/template_v2.py b/dsp/templates/template_v2.py
index 0a5e73fec..5d42aec62 100644
--- a/dsp/templates/template_v2.py
+++ b/dsp/templates/template_v2.py
@@ -182,6 +182,9 @@ class TemplateV2:
def __call__(self, example, show_guidelines=True) -> str:
example = dsp.Example(example)
+ if hasattr(dsp.settings, 'query_only') and dsp.settings.query_only:
+ return self.query(example)
+
# The training data should not contain the output variable
if self.fields[-1].input_variable in example:
del example[self.fields[-1].input_variable]
diff --git a/dsp/templates/template_v3.py b/dsp/templates/template_v3.py
index 9fec3c036..4ae0a9c3e 100644
--- a/dsp/templates/template_v3.py
+++ b/dsp/templates/template_v3.py
@@ -14,6 +14,9 @@ class Type:
kwargs = {**self.__dict__, **kwargs}
return Type(**kwargs)
+ def __eq__(self, __value: object) -> bool:
+ return isinstance(__value, Type) and self.__dict__ == __value.__dict__
+
class Template(TemplateV2):
"""A template datatype that represents the structure of communicate with the LM."""
@@ -44,3 +47,19 @@ class Template(TemplateV2):
if value.format:
self.format_handlers[key] = value.format
+
+
+ # equality
+ def __eq__(self, other):
+ if set(self.kwargs.keys()) != set(other.kwargs.keys()):
+ print('here2')
+ return False
+
+ for k in self.kwargs.keys():
+ v1, v2 = self.kwargs[k], other.kwargs[k]
+ if not v1 == v2:
+ print(k, v1, v2)
+
+
+ # print("here?", self.instructions == other.instructions, self.kwargs == other.kwargs)
+ return self.instructions == other.instructions and self.kwargs == other.kwargs
diff --git a/dspy/datasets/colors.py b/dspy/datasets/colors.py
index cc04315d3..265badf27 100644
--- a/dspy/datasets/colors.py
+++ b/dspy/datasets/colors.py
@@ -5,7 +5,7 @@ from dspy.datasets.dataset import Dataset
all_colors = ['alice blue', 'dodger blue', 'light sky blue', 'deep sky blue', 'sky blue', 'steel blue', 'light steel blue', 'medium blue', 'navy blue', 'blue', 'royal blue', 'cadet blue', 'cornflower blue', 'medium slate blue', 'slate blue', 'dark slate blue', 'powder blue', 'turquoise', 'dark turquoise', 'medium turquoise', 'pale turquoise', 'light sea green', 'medium sea green', 'sea green', 'forest green', 'green yellow', 'lime green', 'dark green', 'green', 'lime', 'chartreuse', 'lawn green', 'yellow green', 'olive green', 'dark olive green', 'medium spring green', 'spring green', 'medium aquamarine', 'aquamarine', 'aqua', 'cyan', 'dark cyan', 'teal', 'medium orchid', 'dark orchid', 'orchid', 'blue violet', 'violet', 'dark violet', 'plum', 'thistle', 'magenta', 'fuchsia', 'dark magenta', 'medium purple', 'purple', 'rebecca purple', 'dark red', 'fire brick', 'indian red', 'light coral', 'dark salmon', 'light salmon', 'salmon', 'red', 'crimson', 'tomato', 'coral', 'orange red', 'dark orange', 'orange', 'yellow', 'gold', 'light goldenrod yellow', 'pale goldenrod', 'goldenrod', 'dark goldenrod', 'beige', 'moccasin', 'blanched almond', 'navajo white', 'antique white', 'bisque', 'burlywood', 'dark khaki', 'khaki', 'tan', 'wheat', 'snow', 'floral white', 'old lace', 'ivory', 'linen', 'seashell', 'honeydew', 'mint cream', 'azure', 'lavender', 'ghost white', 'white smoke', 'gainsboro', 'light gray', 'silver', 'dark gray', 'gray', 'dim gray', 'slate gray', 'light slate gray', 'dark slate gray', 'black', 'medium violet red', 'pale violet red', 'deep pink', 'hot pink', 'light pink', 'pink', 'peach puff', 'rosy brown', 'saddle brown', 'sandy brown', 'chocolate', 'peru', 'sienna', 'brown', 'maroon', 'white', 'misty rose', 'lavender blush', 'papaya whip', 'lemon chiffon', 'light yellow', 'corn silk', 'pale green', 'light green', 'olive drab', 'olive', 'dark sea green']
class Colors(Dataset):
- def __init__(self, sort_by_suffix=False, *args, **kwargs) -> None:
+ def __init__(self, sort_by_suffix=True, *args, **kwargs) -> None:
super().__init__(*args, **kwargs)
self.sort_by_suffix = sort_by_suffix
diff --git a/dspy/evaluate/evaluate.py b/dspy/evaluate/evaluate.py
index 0d0e6729f..651bacfb4 100644
--- a/dspy/evaluate/evaluate.py
+++ b/dspy/evaluate/evaluate.py
@@ -13,18 +13,8 @@ from dsp.utils import EM, F1, HotPotF1
from dsp.evaluation.utils import *
"""
-TODO: The interface would be cleaner if display_progress=False, display_table=False was
-at __init__ time, along with the metric.
-
-But the program and devset (and maybe optional **kwargs to override the __init__ args)
-are given at __call__ time.
-
-That way we can reuse the Evaluate object within a program/notebook.
-
TODO: Counting failures and having a max_failure count. When that is exceeded (also just at the end),
we print the number of failures, the first N examples that failed, and the first N exceptions raised.
-
-TODO: When num_threads=1 don't create a thread pool. Just run the program in the main thread.
"""
@@ -204,3 +194,5 @@ def configure_dataframe_display(df, metric_name):
'word-wrap': 'break-word',
'max-width': '400px'
})
+
+# FIXME: TODO: The merge_dicts stuff above is way too quick and dirty.
diff --git a/dspy/predict/predict.py b/dspy/predict/predict.py
index 5181a60e7..96735261d 100644
--- a/dspy/predict/predict.py
+++ b/dspy/predict/predict.py
@@ -76,7 +76,13 @@ class Predict(Parameter):
# All of the other kwargs are presumed to fit a prefix of the signature.
x = dsp.Example(demos=demos, **kwargs)
- x, C = dsp.generate(signature, **config)(x, stage=self.stage)
+
+ if self.lm is None:
+ x, C = dsp.generate(signature, **config)(x, stage=self.stage)
+ else:
+ with dsp.settings.context(lm=self.lm, query_only=True):
+ print(f"using lm = {self.lm} !")
+ x, C = dsp.generate(signature, **config)(x, stage=self.stage)
completions = []
diff --git a/dspy/signatures/field.py b/dspy/signatures/field.py
index aa1793b6f..848439b6d 100644
--- a/dspy/signatures/field.py
+++ b/dspy/signatures/field.py
@@ -18,6 +18,9 @@ class Field:
def __repr__(self):
return f"{self.__class__.__name__}(prefix={self.prefix}, desc={self.desc})"
+
+ def __eq__(self, __value: object) -> bool:
+ return self.__dict__ == __value.__dict__
class InputField(Field):
def __init__(self, *, prefix=None, desc=None, format=None):
diff --git a/dspy/teleprompt/__init__.py b/dspy/teleprompt/__init__.py
index 3ceb081e3..f784f6266 100644
--- a/dspy/teleprompt/__init__.py
+++ b/dspy/teleprompt/__init__.py
@@ -1,4 +1,5 @@
from .teleprompt import *
from .bootstrap import *
from .vanilla import *
-from .random_search import *
\ No newline at end of file
+from .random_search import *
+from .finetune import *
\ No newline at end of file
diff --git a/dspy/teleprompt/bootstrap.py b/dspy/teleprompt/bootstrap.py
index b6d1e1822..fa584d339 100644
--- a/dspy/teleprompt/bootstrap.py
+++ b/dspy/teleprompt/bootstrap.py
@@ -26,13 +26,13 @@ from dspy.evaluate.evaluate import Evaluate
class BootstrapFewShot(Teleprompter):
- def __init__(self, metric=None, teacher_settings={}, max_bootstrapped_demos=4, max_labeled_demos=16):
+ def __init__(self, metric=None, teacher_settings={}, max_bootstrapped_demos=4, max_labeled_demos=16, max_rounds=1):
self.metric = metric
self.teacher_settings = teacher_settings
self.max_bootstrapped_demos = max_bootstrapped_demos
self.max_labeled_demos = max_labeled_demos
- self.max_rounds = 1
+ self.max_rounds = max_rounds
def compile(self, student, *, teacher=None, trainset, valset=None):
self.trainset = trainset
@@ -49,7 +49,7 @@ class BootstrapFewShot(Teleprompter):
def _prepare_student_and_teacher(self, student, teacher):
self.student = student.reset_copy()
- self.teacher = teacher.reset_copy() if teacher is not None else student.reset_copy()
+ self.teacher = teacher.deepcopy() if teacher is not None else student.reset_copy()
assert self.student._compiled is False, "Student must be uncompiled."
@@ -81,15 +81,16 @@ class BootstrapFewShot(Teleprompter):
for round_idx in range(self.max_rounds):
for example_idx, example in enumerate(tqdm.tqdm(self.trainset)):
+ if len(bootstrapped) >= max_bootsraps:
+ break
+
if example_idx not in bootstrapped:
- success = self._bootstrap_one_example(example)
+ success = self._bootstrap_one_example(example, round_idx)
- if success:
- bootstrapped[example_idx] = True
+ if success:
+ bootstrapped[example_idx] = True
- if len(bootstrapped) >= max_bootsraps:
- print(f'Bootstrapped {len(bootstrapped)} full traces after {example_idx+1} examples in round {round_idx}.')
- break
+ print(f'Bootstrapped {len(bootstrapped)} full traces after {example_idx+1} examples in round {round_idx}.')
# Unbootstrapped training examples
@@ -102,24 +103,30 @@ class BootstrapFewShot(Teleprompter):
# evaluate = Evaluate(program=self.teacher, metric=self.metric, num_threads=12)
# score = evaluate(self.metric, display_table=False, display_progress=True)
- def _bootstrap_one_example(self, example):
+ def _bootstrap_one_example(self, example, round_idx=0):
name2traces = self.name2traces
teacher = self.teacher #.deepcopy()
predictor_cache = {}
with dsp.settings.context(trace=[], **self.teacher_settings):
- for name, predictor in teacher.named_predictors():
- predictor_cache[name] = predictor.demos
- predictor.demos = [x for x in predictor.demos if x != example]
+ lm = dsp.settings.lm
+ lm = lm.copy(temperature=0.7 + 0.001 * round_idx) if round_idx > 0 else lm
+ new_settings = dict(lm=lm) if round_idx > 0 else {}
+
+ with dsp.settings.context(**new_settings):
+ for name, predictor in teacher.named_predictors():
+ predictor_cache[name] = predictor.demos
+ predictor.demos = [x for x in predictor.demos if x != example]
- prediction = teacher(**example.inputs())
- trace = dsp.settings.trace
+ prediction = teacher(**example.inputs())
+ trace = dsp.settings.trace
- for name, predictor in teacher.named_predictors():
- predictor.demos = predictor_cache[name]
+ for name, predictor in teacher.named_predictors():
+ predictor.demos = predictor_cache[name]
try:
success = (self.metric is None) or self.metric(example, prediction, trace)
+ # print(success, example, prediction)
except Exception as e:
success = False
print(f'Failed to evaluate example {example.dspy_uuid} with {self.metric} due to {e}.')
@@ -153,7 +160,11 @@ class BootstrapFewShot(Teleprompter):
for name, predictor in self.student.named_predictors():
augmented_demos = self.name2traces[name][:self.max_bootstrapped_demos]
- raw_demos = rng.sample(raw_demos, min(self.max_labeled_demos - len(augmented_demos), len(raw_demos)))
+
+ sample_size = min(self.max_labeled_demos - len(augmented_demos), len(raw_demos))
+ sample_size = max(0, sample_size)
+
+ raw_demos = rng.sample(raw_demos, sample_size)
predictor.demos = augmented_demos + raw_demos
return self.student
diff --git a/dspy/teleprompt/finetune.py b/dspy/teleprompt/finetune.py
new file mode 100644
index 000000000..4c7e9571b
--- /dev/null
+++ b/dspy/teleprompt/finetune.py
@@ -0,0 +1,158 @@
+import os
+import time
+import dsp
+import tqdm
+import random
+
+import ujson
+from datasets.fingerprint import Hasher
+
+# from dspy.primitives import Example
+
+from .teleprompt import Teleprompter
+from .bootstrap import BootstrapFewShot
+# from .vanilla import LabeledFewShot
+
+# from dspy.evaluate.evaluate import Evaluate
+
+
+if os.environ.get('DSP_NOTEBOOK_CACHEDIR'):
+ training_data_directory = os.path.join(os.environ.get('DSP_NOTEBOOK_CACHEDIR'), 'compiler')
+ print(training_data_directory)
+else:
+ training_data_directory = 'local_cache/compiler'
+
+if not os.path.exists(training_data_directory):
+ os.makedirs(training_data_directory)
+
+
+"""
+TODO: Reduce and document the dependencies.
+
+# !pip install evaluate
+# !pip install tensorboardX
+# !pip install transformers[torch]
+# !pip install accelerate -U
+# !pip install rouge_score
+
+
+fewshot_teleprompter = BootstrapFewShot(metric=lambda gold, prediction, trace: gold.answer == prediction.answer,
+ max_bootstrapped_demos=3, max_labeled_demos=16,
+ teacher_settings=dict(lm=turbo))
+
+fewshot = fewshot_teleprompter.compile(MyMultiHop(passages_per_hop=2), trainset=trainset)
+
+"""
+
+
+class BootstrapFinetune(Teleprompter):
+ def __init__(self, metric=None, teacher_settings={}, multitask=True):
+ self.metric = metric
+ self.teacher_settings = teacher_settings
+ self.multitask = multitask
+
+ metric = metric or (lambda *args: True)
+ self.teleprompter = BootstrapFewShot(metric=metric,
+ max_bootstrapped_demos=999999,
+ max_labeled_demos=0, # FIXME: TODO: Make this zero? or param, 16 by default?
+ teacher_settings=teacher_settings)
+
+
+ def compile(self, student, *, teacher=None, trainset, valset=None,
+ target='t5-large', bsize=12, accumsteps=1, lr=5e-5, epochs=1, bf16=False):
+
+ # It's usually better to supply a few-shot teacher, rather than uncompiled module (the student).
+ if teacher is None:
+ print("WARNING: Using a vanilla teacher. "
+ "Are you sure you want to use BootstrapFinetune without a compiled teacher?")
+
+ # Dummy compilation to get bootstraps.
+ compiled = self.teleprompter.compile(student, teacher=teacher, trainset=trainset)
+ multitask = self.multitask
+
+ #
+ # Prepare finetune <prompt, completion> pairs.
+ #
+ finetune_data = {}
+
+ for name, predictor in compiled.named_predictors():
+ name_ = 'all' if multitask else name
+ finetune_data[name_] = [] if name_ not in finetune_data else finetune_data[name_]
+
+ for demo in predictor.demos:
+ demo = dict(demo)
+ completion = demo.pop(predictor.signature.fields[-1].output_variable)
+ prompt = predictor.signature.query(dsp.Example(demos=[], **demo)).strip()
+
+ finetune_data[name_].append(dict(prompt=prompt, completion=completion))
+
+ for name_ in finetune_data:
+ random.Random(0).shuffle(finetune_data[name_])
+ print(name_, len(finetune_data[name_]))
+
+
+ #
+ # Dump as files.
+ #
+ finetune_paths = {}
+
+ for name in finetune_data:
+ data = finetune_data[name]
+ hashed_name = name + '.' + Hasher.hash(data)
+ output_path = os.path.join(training_data_directory, f'{hashed_name}.jsonl')
+ print(output_path)
+
+ with open(output_path, 'w') as f:
+ for line in data:
+ f.write(ujson.dumps(line) + '\n')
+
+ finetune_paths[name] = output_path
+
+
+ #
+ # Train!
+ #
+ import string
+ compiler_config = {
+ 'save': ''.join(random.Random(time.time()).choices(string.ascii_uppercase + string.digits, k=13)), # https://stackoverflow.com/a/2257449/1493011
+ 'peft': False,
+ 'fp16': False,
+ 'bf16': bf16,
+ 'fid': False,
+ 'rationale': False,
+ 'batch_size': bsize,
+ 'epochs': epochs,
+ 'gradient_accumulation_steps': accumsteps, # 2,
+ 'lr': lr
+ }
+
+ from dsp.modules.finetuning import finetune_hf
+
+ target = target
+ finetune_models = {}
+
+ for name in finetune_data:
+ training_data_path = finetune_paths[name]
+ compiler_config_ = dict(compiler_config)
+ compiler_config_['save'] = compiler_config['save'] + '.' + name
+ best_ckpt_path = finetune_hf(training_data_path, target, compiler_config_)
+ finetune_models[name] = dsp.HFModel(model=target, checkpoint=best_ckpt_path) # best_ckpt_path
+
+ #
+ # Set the LMs to the finetuned ones, per module
+ #
+ compiled2 = compiled.reset_copy()
+
+ assert len(compiled.named_predictors()) == len(compiled2.named_predictors())
+
+ for (name, predictor), (name2, predictor2) in zip(compiled.named_predictors(), compiled2.named_predictors()):
+ assert name == name2
+ name = 'all' if multitask else name
+
+ # TODO: FIXME: When we assign .lm, the Predict.forward will also set only_query=True.
+ # This is correct for here but we may want to make it more explicitly restricted to finetuned models.
+ predictor2.lm = finetune_models[name]
+ assert predictor2.demos == []
+
+ return compiled2
+