QuantFactory/instruction-synthesizer-GGUF

This is quantized version of instruction-pretrain/instruction-synthesizer created using llama.cpp

Model Description

Instruction Pre-Training: Language Models are Supervised Multitask Learners

This repo contains the context-based instruction synthesizer in our paper Instruction Pre-Training: Language Models are Supervised Multitask Learners.

We explore supervised multitask pre-training by proposing Instruction Pre-Training, a framework that scalably augments massive raw corpora with instruction-response pairs to pre-train language models. The instruction-response pairs are generated by an efficient instruction synthesizer built on open-source models. In our experiments, we synthesize 200M instruction-response pairs covering 40+ task categories to verify the effectiveness of Instruction Pre-Training. Instruction Pre-Training outperforms Vanilla Pre-training in both general pre-training from scratch and domain-adaptive continual pre-training. In pre-training from scratch, Instruction Pre-Training not only improves pre-trained base models but also benefits more from further instruction tuning. In continual pre-training, Instruction Pre-Training enables Llama3-8B to be comparable to or even outperform Llama3-70B.

👁 Image

Resources

🤗 We share our data and models with example usages, feel free to open any issues or discussions! 🤗

• Context-Based Instruction Synthesizer: instruction-synthesizer
• Fine-Tuning Data for the Synthesizer: ft-instruction-synthesizer-collection
• General Models Pre-Trained from Scratch:
  • InstructLM-500M
  • InstructLM-1.3B
• Domain-Specific Models Pre-Trained from Llama3-8B:
  • Finance-Llama3-8B
  • Biomedicine-Llama3-8B

Synthesize Instruction-Response Pairs to Augment Any Raw Corpora

We conduct multitask fine-tuning on a language model to develop an instruction synthesizer capable of generating instruction-response pairs from any raw text. The fine-tuning data are available at ft-instruction-synthesizer-collection

👁 Image

Basic Usage: Synthesize instruction-response pairs based on a given raw text

💗 Here is an amazing demo that implements our approach: davanstrien/instruction-synthesizer 💗

from transformers import AutoModelForCausalLM, AutoTokenizer

model = AutoModelForCausalLM.from_pretrained("instruction-pretrain/instruction-synthesizer")
tokenizer = AutoTokenizer.from_pretrained("instruction-pretrain/instruction-synthesizer")

# Put your raw text here:
context = '''Free Fishing Weekend in NYS Slated
This weekend (June 28th-29th) New Yorkers may fish for free without a license in any of the state's 7,500 lakes and ponds or 50,000 miles of rivers and streams. In addition, there are a number of free events and fishing clinics taking place across the state to encourage New Yorkers to enjoy the great outdoors. For more information, visit'''

def parse_pred(pred):
 """Extract the list of instruction-response pairs from the prediction"""
 QA_str_list = pred.split('</END>')
 if not pred.endswith('</END>'):
 QA_str_list = QA_str_list[:-1]

 QA_list = []
 raw_questions = []
 for QA_str in QA_str_list:
 try:
 assert len(QA_str.split('<ANS>')) == 2, f'invalid QA string: {QA_str}'
 Q_str, A_str = QA_str.split('<ANS>')
 Q_str, A_str = Q_str.strip(), A_str.strip()
 assert Q_str.startswith('<QUE>'), f'invalid question string: {Q_str} in QA_str: {QA_str}'
 assert len(A_str) > 0, f'invalid answer string in QA_str: {QA_str}'
 Q_str = Q_str.replace('<QUE>', '').strip()
 assert Q_str.lower() not in raw_questions, f'duplicate question: {Q_str}'
 QA_list.append({'Q': Q_str, 'A': A_str})
 raw_questions.append(Q_str.lower())
 except:
 pass

 return QA_list

def get_instruction_response_pairs(context):
 '''Prompt the synthesizer to generate instruction-response pairs based on the given context'''
 prompt = f'<s> <CON> {context} </CON>\n\n'
 inputs = tokenizer(prompt, add_special_tokens=False, return_tensors="pt").input_ids.to(model.device)
 outputs = model.generate(input_ids=inputs, max_new_tokens=400, do_sample=False)[0]

 pred_start = int(inputs.shape[-1])
 pred = tokenizer.decode(outputs[pred_start:], skip_special_tokens=True)
 return parse_pred(pred)

# Get the generated instruction-response paris
instruction_response_pairs = get_instruction_response_pairs(context)

# Print out the results
print(f'# Context:\n{context}\n')
for index, pair in enumerate(instruction_response_pairs):
 print(f'## Instruction {index + 1}:\n{pair["Q"]}\n## Response {index + 1}:\n{pair["A"]}\n')

Advanced Usage: Synthesize Few-shot Examples

A one-shot example consists of a piece of raw text followed by its instruction-response pairs. You can conduct multi-round inferece to synthesize a few-shot example: the instruction-response pairs of different raw texts share the same pattern.

To accelerate synthesis, we use the vLLM framework:

Model Citation

If you find our work helpful, please cite us:

AdaptLLM

@inproceedings{
cheng2024adapting,
title={Adapting Large Language Models via Reading Comprehension},
author={Daixuan Cheng and Shaohan Huang and Furu Wei},
booktitle={The Twelfth International Conference on Learning Representations},
year={2024},
url={https://openreview.net/forum?id=y886UXPEZ0}
}

Base model

instruction-pretrain/instruction-synthesizer

(6)