# File: alignment-handbook-main/src/alignment/__init__.py __version__ = '0.3.0.dev0' from .configs import DataArguments, DPOConfig, H4ArgumentParser, ModelArguments, SFTConfig from .data import apply_chat_template, get_datasets from .decontaminate import decontaminate_humaneval from .model_utils import get_checkpoint, get_kbit_device_map, get_peft_config, get_quantization_config, get_tokenizer, is_adapter_model __all__ = ['DataArguments', 'DPOConfig', 'H4ArgumentParser', 'ModelArguments', 'SFTConfig', 'apply_chat_template', 'get_datasets', 'decontaminate_humaneval', 'get_checkpoint', 'get_kbit_device_map', 'get_peft_config', 'get_quantization_config', 'get_tokenizer', 'is_adapter_model'] # File: alignment-handbook-main/src/alignment/configs.py import dataclasses import os import sys from dataclasses import dataclass, field from typing import Any, Dict, List, NewType, Optional, Tuple from transformers import MODEL_FOR_CAUSAL_LM_MAPPING, HfArgumentParser import trl MODEL_CONFIG_CLASSES = list(MODEL_FOR_CAUSAL_LM_MAPPING.keys()) MODEL_TYPES = tuple((conf.model_type for conf in MODEL_CONFIG_CLASSES)) DataClassType = NewType('DataClassType', Any) class H4ArgumentParser(HfArgumentParser): def parse_yaml_and_args(self, yaml_arg: str, other_args: Optional[List[str]]=None) -> List[dataclass]: arg_list = self.parse_yaml_file(os.path.abspath(yaml_arg)) outputs = [] other_args = {arg.split('=')[0].strip('-'): arg.split('=')[1] for arg in other_args} used_args = {} for (data_yaml, data_class) in zip(arg_list, self.dataclass_types): keys = {f.name for f in dataclasses.fields(data_yaml) if f.init} inputs = {k: v for (k, v) in vars(data_yaml).items() if k in keys} for (arg, val) in other_args.items(): if arg in keys: base_type = data_yaml.__dataclass_fields__[arg].type inputs[arg] = val if base_type in [int, float]: inputs[arg] = base_type(val) if base_type == List[str]: inputs[arg] = [str(v) for v in val.split(',')] if base_type is bool: if val in ['true', 'True']: inputs[arg] = True else: inputs[arg] = False if arg not in used_args: used_args[arg] = val else: raise ValueError(f'Duplicate argument provided: {arg}, may cause unexpected behavior') obj = data_class(**inputs) outputs.append(obj) return outputs def parse(self) -> DataClassType | Tuple[DataClassType]: if len(sys.argv) == 2 and sys.argv[1].endswith('.yaml'): output = self.parse_yaml_file(os.path.abspath(sys.argv[1])) elif len(sys.argv) > 2 and sys.argv[1].endswith('.yaml'): output = self.parse_yaml_and_args(os.path.abspath(sys.argv[1]), sys.argv[2:]) else: output = self.parse_args_into_dataclasses() if len(output) == 1: output = output[0] return output @dataclass class ModelArguments: base_model_revision: Optional[str] = field(default=None, metadata={'help': 'The base model checkpoint for weights initialization with PEFT adapters.'}) model_name_or_path: Optional[str] = field(default=None, metadata={'help': "The model checkpoint for weights initialization. Don't set if you want to train a model from scratch."}) model_revision: str = field(default='main', metadata={'help': 'The specific model version to use (can be a branch name, tag name or commit id).'}) model_code_revision: str = field(default=None, metadata={'help': 'The branch of the IFT model'}) torch_dtype: Optional[str] = field(default=None, metadata={'help': "Override the default `torch.dtype` and load the model under this dtype. If `auto` is passed, the dtype will be automatically derived from the model's weights.", 'choices': ['auto', 'bfloat16', 'float16', 'float32']}) tokenizer_name_or_path: Optional[str] = field(default=None, metadata={'help': 'The path to the tokenizer. Useful if you want to use a different tokenizer to the one stored in `model_name_or_path`.'}) trust_remote_code: bool = field(default=False, metadata={'help': 'Trust remote code when loading a model.'}) attn_implementation: Optional[str] = field(default=None, metadata={'help': 'Which attention implementation to use; you can use --attn_implementation=flash_attention_2, in which case you must install this manually by running `pip install flash-attn --no-build-isolation`'}) use_peft: bool = field(default=False, metadata={'help': 'Whether to use PEFT or not for training.'}) lora_r: Optional[int] = field(default=16, metadata={'help': 'LoRA R value.'}) lora_alpha: Optional[int] = field(default=32, metadata={'help': 'LoRA alpha.'}) lora_dropout: Optional[float] = field(default=0.05, metadata={'help': 'LoRA dropout.'}) lora_target_modules: Optional[List[str]] = field(default=None, metadata={'help': 'LoRA target modules.'}) lora_modules_to_save: Optional[List[str]] = field(default=None, metadata={'help': 'Model layers to unfreeze & train'}) load_in_8bit: bool = field(default=False, metadata={'help': 'use 8 bit precision'}) load_in_4bit: bool = field(default=False, metadata={'help': 'use 4 bit precision'}) bnb_4bit_quant_type: Optional[str] = field(default='nf4', metadata={'help': 'precise the quantization type (fp4 or nf4)'}) use_bnb_nested_quant: bool = field(default=False, metadata={'help': 'use nested quantization'}) bnb_4bit_quant_storage: Optional[str] = field(default='uint8', metadata={'help': 'storage type to pack the quanitzed 4-bit prarams.'}) def __post_init__(self): if self.load_in_8bit and self.load_in_4bit: raise ValueError("You can't use 8 bit and 4 bit precision at the same time") @dataclass class DataArguments: chat_template: Optional[str] = field(default=None, metadata={'help': 'The chat template to use.'}) dataset_mixer: Optional[Dict[str, float]] = field(default=None, metadata={'help': 'Datasets and their proportions to be used for training ift/rl.'}) text_column: Optional[str] = field(default='text', metadata={'help': 'The column name to use for the text in the dataset (only used for continued pretraining).'}) dataset_splits: Optional[List[str]] = field(default_factory=lambda : ['train', 'test'], metadata={'help': 'List of train test splits to use in the dataset'}) dataset_configs: Optional[List[str]] = field(default=None, metadata={'help': "List of dataset config names. If given must be the same length as 'dataset_mixer' keys."}) preprocessing_num_workers: Optional[int] = field(default=None, metadata={'help': 'The number of processes to use for the preprocessing.'}) truncation_side: Optional[str] = field(default=None, metadata={'help': 'Truncation side to use for the tokenizer.'}) auto_insert_empty_system_msg: bool = field(default=True, metadata={'help': 'Whether to automatically insert an empty system message as the first message if `system` is mentioned in the chat template.'}) @dataclass class SFTConfig(trl.SFTConfig): hub_model_revision: Optional[str] = field(default='main', metadata={'help': 'The Hub model branch to push the model to.'}) logging_first_step: bool = field(default=True, metadata={'help': 'Whether to log and evaluate the first global_step or not.'}) @dataclass class DPOConfig(trl.DPOConfig): hub_model_revision: Optional[str] = field(default='main', metadata={'help': 'The Hub model branch to push the model to.'}) logging_first_step: bool = field(default=True, metadata={'help': 'Whether to log and evaluate the first global_step or not.'}) optim: Optional[str] = field(default='rmsprop') remove_unused_columns: bool = field(default=False) # File: alignment-handbook-main/src/alignment/data.py import os from typing import Any, List, Literal, Optional from datasets import DatasetDict, concatenate_datasets, load_dataset, load_from_disk from datasets.builder import DatasetGenerationError from .configs import DataArguments DEFAULT_CHAT_TEMPLATE = "{% for message in messages %}\n{% if message['role'] == 'user' %}\n{{ '<|user|>\n' + message['content'] + eos_token }}\n{% elif message['role'] == 'system' %}\n{{ '<|system|>\n' + message['content'] + eos_token }}\n{% elif message['role'] == 'assistant' %}\n{{ '<|assistant|>\n' + message['content'] + eos_token }}\n{% endif %}\n{% if loop.last and add_generation_prompt %}\n{{ '<|assistant|>' }}\n{% endif %}\n{% endfor %}" def maybe_insert_system_message(messages, tokenizer): if messages[0]['role'] == 'system': return chat_template = tokenizer.chat_template if chat_template is None: chat_template = tokenizer.get_chat_template() if 'system' in chat_template or '<|im_start|>' in chat_template: messages.insert(0, {'role': 'system', 'content': ''}) def apply_chat_template(example, tokenizer, task: Literal['sft', 'generation', 'rm', 'dpo'], auto_insert_empty_system_msg: bool=True): if task in ['sft', 'generation']: messages = example['messages'] if auto_insert_empty_system_msg: maybe_insert_system_message(messages, tokenizer) example['text'] = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True if task == 'generation' else False) elif task == 'rm': if all((k in example.keys() for k in ('chosen', 'rejected'))): chosen_messages = example['chosen'] rejected_messages = example['rejected'] if auto_insert_empty_system_msg: maybe_insert_system_message(chosen_messages, tokenizer) maybe_insert_system_message(rejected_messages, tokenizer) example['text_chosen'] = tokenizer.apply_chat_template(chosen_messages, tokenize=False) example['text_rejected'] = tokenizer.apply_chat_template(rejected_messages, tokenize=False) else: raise ValueError(f'Could not format example as dialogue for `rm` task! Require `[chosen, rejected]` keys but found {list(example.keys())}') elif task in ['dpo', 'orpo']: if all((k in example.keys() for k in ('chosen', 'rejected'))): if not is_openai_format(example['chosen']) or not is_openai_format(example['rejected']): raise ValueError(f'Could not format example as dialogue for `{task}` task! Require OpenAI format for all messages') if 'prompt' in example and is_openai_format(example['prompt']): prompt_messages = example['prompt'] chosen_messages = example['chosen'] rejected_messages = example['rejected'] else: prompt_messages = example['chosen'][:-1] chosen_messages = example['chosen'][-1:] rejected_messages = example['rejected'][-1:] if auto_insert_empty_system_msg: maybe_insert_system_message(prompt_messages, tokenizer) example['text_prompt'] = tokenizer.apply_chat_template(prompt_messages, tokenize=False) example['text_chosen'] = tokenizer.apply_chat_template(chosen_messages, tokenize=False) example['text_rejected'] = tokenizer.apply_chat_template(rejected_messages, tokenize=False) else: raise ValueError(f'Could not format example as dialogue for `{task}` task! Require either the `[chosen, rejected]` or `[prompt, chosen, rejected]` keys but found {list(example.keys())}') else: raise ValueError(f"Task {task} not supported, please ensure that the provided task is one of ['sft', 'generation', 'rm', 'dpo', 'orpo']") return example def is_openai_format(messages: Any) -> bool: if isinstance(messages, list) and all((isinstance(message, dict) for message in messages)): return all(('role' in message and 'content' in message for message in messages)) return False def get_datasets(data_config: DataArguments | dict, splits: Optional[List[str]]=None, configs: Optional[List[str]]=None, columns_to_keep: Optional[List[str]]=None, shuffle: bool=True) -> DatasetDict: if type(data_config) is DataArguments: dataset_mixer = data_config.dataset_mixer elif isinstance(data_config, dict): dataset_mixer = data_config else: raise ValueError(f'Data config {data_config} not recognized.') raw_datasets = mix_datasets(dataset_mixer, splits=splits, configs=configs, columns_to_keep=columns_to_keep, shuffle=shuffle) return raw_datasets def mix_datasets(dataset_mixer: dict, splits: Optional[List[str]]=None, configs: Optional[List[str]]=None, columns_to_keep: Optional[List[str]]=None, shuffle=True) -> DatasetDict: splits = ['train', 'test'] if splits is None else splits configs = [None] * len(dataset_mixer) if not configs else configs columns_to_keep = [] if columns_to_keep is None else columns_to_keep if configs is not None and len(configs) != len(dataset_mixer): raise ValueError('The number of given dataset config names must be the same as the given number of datasets.') raw_datasets = DatasetDict() raw_train_datasets = [] raw_val_datasets = [] fracs = [] for ((ds, frac), ds_config) in zip(dataset_mixer.items(), configs): fracs.append(frac) for split in splits: try: dataset = load_dataset(ds, ds_config, split=split) except DatasetGenerationError: dataset = load_from_disk(os.path.join(ds, split)) dataset = dataset.remove_columns([col for col in dataset.column_names if col not in columns_to_keep]) if 'train' in split: raw_train_datasets.append(dataset) elif 'test' in split: raw_val_datasets.append(dataset) else: raise ValueError(f'Split type {split} not recognized as one of test or train.') if any((frac < 0 for frac in fracs)): raise ValueError('Dataset fractions cannot be negative.') if len(raw_train_datasets) > 0: train_subsets = [] for (dataset, frac) in zip(raw_train_datasets, fracs): train_subset = dataset.select(range(int(frac * len(dataset)))) train_subsets.append(train_subset) if shuffle: raw_datasets['train'] = concatenate_datasets(train_subsets).shuffle(seed=42) else: raw_datasets['train'] = concatenate_datasets(train_subsets) if len(raw_val_datasets) > 0: if shuffle: raw_datasets['test'] = concatenate_datasets(raw_val_datasets).shuffle(seed=42) else: raw_datasets['test'] = concatenate_datasets(raw_val_datasets) if len(raw_datasets) == 0: raise ValueError(f'Dataset {dataset_mixer} not recognized with splits {splits}. Check the dataset has been correctly formatted.') return raw_datasets # File: alignment-handbook-main/src/alignment/decontaminate.py from typing import Any, Dict, List from datasets import load_dataset HUMAN_EVAL_STRINGS_OK = ['return x + y', 'return len(string)', 'return n**2', 'return .join(strings)'] def extract_docstring(prompt: str) -> str: if '"""' in prompt: if prompt.count('"""') == 2: return prompt.split('"""')[1].strip() elif prompt.count('"""') == 4: return prompt.split('"""')[3].strip() else: raise ValueError() elif "'''" in prompt: assert prompt.count("'''") == 2 return prompt.split("'''")[1].strip() else: raise ValueError() def human_eval_docstrings() -> List[str]: ds = load_dataset('openai_humaneval', split='test') docstrings = [extract_docstring(v['prompt']) for v in ds] return docstrings def load_dataset_column(dataset: str, column: str, split: str, name=None) -> List[str]: ds = load_dataset(dataset, split=split, name=name) res = [sample[column].strip() for sample in ds] return [sample for sample in res if len(sample) > 0] FILTER_OUT = {'human_eval_docstrings': human_eval_docstrings(), 'human_eval_solutions': [s for s in load_dataset_column('openai_humaneval', 'canonical_solution', 'test') if s not in HUMAN_EVAL_STRINGS_OK]} def normalize_whitespace(text: str) -> str: return ' '.join(text.split()) def decontaminate_humaneval(samples: List[Dict[str, Any]], text_column: str='text', filter_out: Dict[str, List[str]]=FILTER_OUT) -> List[Dict[str, Any]]: output = [] for content in samples[text_column]: content = normalize_whitespace(content.lower()) matched = False for (_, substrings) in filter_out.items(): for substring in substrings: if normalize_whitespace(substring.lower()) in content: matched = True break if matched: break output.append(not matched) return output # File: alignment-handbook-main/src/alignment/model_utils.py import os from pathlib import Path from typing import Dict import torch from transformers import AutoTokenizer, BitsAndBytesConfig, PreTrainedTokenizer from transformers.trainer_utils import get_last_checkpoint from accelerate import Accelerator from huggingface_hub import list_repo_files from huggingface_hub.utils._errors import RepositoryNotFoundError from huggingface_hub.utils._validators import HFValidationError from peft import LoraConfig, PeftConfig from .configs import DataArguments, DPOConfig, ModelArguments, SFTConfig from .data import DEFAULT_CHAT_TEMPLATE def get_current_device() -> int: return Accelerator().local_process_index if torch.cuda.is_available() else 'cpu' def get_kbit_device_map() -> Dict[str, int] | None: return {'': get_current_device()} if torch.cuda.is_available() else None def get_quantization_config(model_args: ModelArguments) -> BitsAndBytesConfig | None: if model_args.load_in_4bit: compute_dtype = torch.float16 if model_args.torch_dtype not in {'auto', None}: compute_dtype = getattr(torch, model_args.torch_dtype) quantization_config = BitsAndBytesConfig(load_in_4bit=True, bnb_4bit_compute_dtype=compute_dtype, bnb_4bit_quant_type=model_args.bnb_4bit_quant_type, bnb_4bit_use_double_quant=model_args.use_bnb_nested_quant, bnb_4bit_quant_storage=model_args.bnb_4bit_quant_storage).to_dict() elif model_args.load_in_8bit: quantization_config = BitsAndBytesConfig(load_in_8bit=True).to_dict() else: quantization_config = None return quantization_config def get_tokenizer(model_args: ModelArguments, data_args: DataArguments, auto_set_chat_template: bool=True) -> PreTrainedTokenizer: tokenizer = AutoTokenizer.from_pretrained(model_args.model_name_or_path if model_args.tokenizer_name_or_path is None else model_args.tokenizer_name_or_path, revision=model_args.model_revision, trust_remote_code=model_args.trust_remote_code) if tokenizer.pad_token_id is None: tokenizer.pad_token_id = tokenizer.eos_token_id if data_args.truncation_side is not None: tokenizer.truncation_side = data_args.truncation_side if tokenizer.model_max_length > 100000: tokenizer.model_max_length = 2048 if data_args.chat_template is not None: tokenizer.chat_template = data_args.chat_template elif auto_set_chat_template and tokenizer.get_chat_template() is None: tokenizer.chat_template = DEFAULT_CHAT_TEMPLATE return tokenizer def get_peft_config(model_args: ModelArguments) -> PeftConfig | None: if model_args.use_peft is False: return None peft_config = LoraConfig(r=model_args.lora_r, lora_alpha=model_args.lora_alpha, lora_dropout=model_args.lora_dropout, bias='none', task_type='CAUSAL_LM', target_modules=model_args.lora_target_modules, modules_to_save=model_args.lora_modules_to_save) return peft_config def is_adapter_model(model_name_or_path: str, revision: str='main') -> bool: try: repo_files = list_repo_files(model_name_or_path, revision=revision) except (HFValidationError, RepositoryNotFoundError): repo_files = os.listdir(model_name_or_path) return 'adapter_model.safetensors' in repo_files or 'adapter_model.bin' in repo_files def get_checkpoint(training_args: SFTConfig | DPOConfig) -> Path | None: last_checkpoint = None if os.path.isdir(training_args.output_dir): last_checkpoint = get_last_checkpoint(training_args.output_dir) return last_checkpoint # File: alignment-handbook-main/src/alignment/release.py import argparse import re import packaging.version REPLACE_PATTERNS = {'init': (re.compile('^__version__\\s+=\\s+"([^"]+)"\\s*$', re.MULTILINE), '__version__ = "VERSION"\n'), 'setup': (re.compile('^(\\s*)version\\s*=\\s*"[^"]+",', re.MULTILINE), '\\1version="VERSION",'), 'citation': (re.compile('^version:\\s+[^ ]+', re.MULTILINE), 'version: VERSION'), 'readme': (re.compile('version\\s+=\\s+\\{[^}]+\\}', re.MULTILINE), 'version = {VERSION}')} README_FILE = 'README.md' REPLACE_FILES = {'init': 'src/alignment/__init__.py', 'setup': 'setup.py', 'citation': 'CITATION.cff', 'readme': README_FILE} def update_version_in_file(fname, version, pattern): with open(fname, 'r', encoding='utf-8', newline='\n') as f: code = f.read() (re_pattern, replace) = REPLACE_PATTERNS[pattern] replace = replace.replace('VERSION', version) code = re_pattern.sub(replace, code) with open(fname, 'w', encoding='utf-8', newline='\n') as f: f.write(code) def global_version_update(version, patch=False): for (pattern, fname) in REPLACE_FILES.items(): update_version_in_file(fname, version, pattern) def get_version(): with open(REPLACE_FILES['init'], 'r') as f: code = f.read() default_version = REPLACE_PATTERNS['init'][0].search(code).groups()[0] return packaging.version.parse(default_version) def pre_release_work(patch=False): default_version = get_version() if patch and default_version.is_devrelease: raise ValueError("Can't create a patch version from the dev branch, checkout a released version!") if default_version.is_devrelease: default_version = default_version.base_version elif patch: default_version = f'{default_version.major}.{default_version.minor}.{default_version.micro + 1}' else: default_version = f'{default_version.major}.{default_version.minor + 1}.0' version = input(f'Which version are you releasing? [{default_version}]') if len(version) == 0: version = default_version print(f'Updating version to {version}.') global_version_update(version, patch=patch) def post_release_work(): current_version = get_version() dev_version = f'{current_version.major}.{current_version.minor + 1}.0.dev0' current_version = current_version.base_version version = input(f'Which version are we developing now? [{dev_version}]') if len(version) == 0: version = dev_version print(f'Updating version to {version}.') global_version_update(version) if __name__ == '__main__': parser = argparse.ArgumentParser() parser.add_argument('--post_release', action='store_true', help='Whether this is pre or post release.') parser.add_argument('--patch', action='store_true', help='Whether or not this is a patch release.') args = parser.parse_args() if not args.post_release: pre_release_work(patch=args.patch) elif args.patch: print('Nothing to do after a patch :-)') else: post_release_work()