In the realm of artificial intelligence, particularly in natural language processing, the ability of language models to comprehend and generate human-like responses has significantly advanced. One pivotal technique is known as Instruction Pre-Training, which serves as a bridge to enhance the efficacy of these models. In this article, we will dive into how you can implement this framework using the context-based instruction synthesizer, as outlined in our [Instruction Pre-Training: Language Models are Supervised Multitask Learners](https://huggingface.co/papers/2406.14491) paper.

What is Instruction Pre-Training?

Instruction Pre-Training involves augmenting raw text corpora with instruction-response pairs to pre-train language models. This approach not only helps in bolstering the model’s understanding across instructional tasks but also shows a marked improvement over traditional methods. To illustrate this, imagine teaching a child various subjects like math, science, and history using specific instructions and questions. Just like the child, a language model learns better when provided structured guidance, enhancing its learning capabilities.

Setting Up the Environment

Before you jump in, ensure you have the following libraries installed:

• transformers
• vllm

To install these, simply run:

pip install transformers vllm

1. Basic Usage: Synthesize Instruction-Response Pairs

First, let’s work with a simple demonstration using the instruction synthesizer. You can use it to synthesize instruction-response pairs based on any raw text, which creates a more interactive learning experience for the model.

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...'''

def parse_pred(pred):
    """Extract the list of instruction-response pairs from the prediction"""
    QA_str_list = pred.split('')
    if not pred.endswith(''):
        QA_str_list = QA_str_list[:-1]
    QA_list = []
    raw_questions = []  
    for QA_str in QA_str_list:
        try:
            assert len(QA_str.split('')) == 2, f'invalid QA string: {QA_str}'
            Q_str, A_str = QA_str.split('')
            Q_str, A_str = Q_str.strip(), A_str.strip()
            assert Q_str.startswith(''), 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('', '').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'  {context} \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 pairs
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')

git clone https://github.com/microsoft/LMOps.git
cd LMOps/instruction_pretrain
pip install vllm
# Your code to process raw texts...