Дообучение saiga2_7b_lora

Всем привет дорогие читатели!

В данном руководстве я бы хотел рассказать и показать вам, как дообучить 7-миллиардную модель Сайги Ильи Гусева @Takagi под свои задачи. Данная статья является своеобразным туториалом по дообучению модели на Kaggle. Однако в наше время написано много статей про дообучение LLM, но все они в большинстве англоязычные или авторы используют свои вычислительные мощности загоняя в тупик тех, у кого возможности обучать на своём «железе» нет. 

Начнём пожалуй с вопроса «Почему Kaggle, а не Google Collab?»

Преимущество Kaggle над Google Collab для меня заключается в том, что вычислительные мощности, которые представляет данная платформа, выдаются на 30 часов каждую неделю (если говорить про GPU). Плюс Notebook, в котором вы сейчас работаете, не завершит свою работу в течении 12 часов (если какой-то код там выполняется), в отличие от Collab`а, который может вам завершить работу если вы решили отдохнуть и запустили код на обучение.

Выделенного времени более чем достаточно если вы изначально создадите все скрипты для обучения вашей модели.

Датасет

Как должен выглядеть свой датасет для обучения? Этим вопросом я задавался постоянно, когда приходилось обучать любую LLM. И в один момент пришло осознание.

Для начала разберём, что на вход подаётся модели. Важный момент! Не то, какой промт вы ей передаёте, а то какой формат имеет системный, пользовательский промт и ответ модели.

Для этого я использовал код, который был предложен на Hugging Face для модели Сайги от Ильи Гусева. По хорошему можно было разобраться в файлах обучения LLama на GitHub проекта rulm и посмотреть как был «предобработан» датасет для обучения модели, но спасибо автору, что он в карточке модели предоставил код для её запуска.

Итак, нас интересует строка 9 в методе generate.

def generate(model, tokenizer, prompt, generation_config):     data = tokenizer(prompt, return_tensors="pt")     data = {k: v.to(model.device) for k, v in data.items()}     output_ids = model.generate(         **data,         generation_config=generation_config     )[0]     output_ids = output_ids[len(data["input_ids"][0]):]     output = tokenizer.decode(output_ids, skip_special_tokens=True)     return output.strip()

А именно output и параметр skip_special_tokens, который отвечает за вывод специальных токенов (о них поговорим ниже). Изменяем значение на False. Далее для наглядности напишем метод для взаимодействия с классом Conversation.

def get_message(inputs):     conversation = Conversation()     conversation.add_user_message(inputs)     prompt = conversation.get_prompt(tokenizer)     print('Промт', '\n', '*'*100)     print(prompt)     print('*'*100)     output = generate(model, tokenizer, prompt, generation_config)     return output

В данном методе мы создаем объект класса, вызываем добавление пользовательского промта и получаем промт, который передается в модель, но мы его перед этим выведем.

Теперь нам нужно сформировать любой запрос, чтобы посмотреть формат промта для модели и ответа модели.

На рисунке видно, что мы не просто передаем запрос и разделяем все промты специальными токенами.

• bos_token_id (Beginning of Sequence token ID) — начало последовательности.

• eos_token_id (End of Sequence token ID) — конец последовательности.

На рисунке 1 видно что предобработанная строка с запросом заканчивается на “… </s><s>bot”, а ответ модели заканчивается на “… </s>”. Именно поэтому модель понимает, где начать генерировать текст (с токена “bos_token_id”) и в конце своей генерации ставит токен “eos_token_id”.

Данные токены заложены в конфигурации токенизатора, это можно проверить с помощью кода ниже.

print(tokenizer.bos_token_id) print(tokenizer.eos_token_id) print(tokenizer.decode([1])) print(tokenizer.decode([2]))

На выходе мы получаем

В промте также присутствуют слова “system”, “user” и “bot”, которые идут сразу же после токена “bos”. Их тоже надо будет учитывать при создании датасета. Токенизация представлена на рисунке 3.

Теперь подытожим и соберём всё вместе, чтобы понять на каких строках будет обучатся наша модель.

"""<s>system Тут какой-то системный промт</s><s>user Тут мы задаём запрос</s><s>bot Тут модель генерирует текст</s>"""

Вот и всё, пример одного экземпляра датасета уже сделан (шутка нет).

Осталось подготовить наши данные в определенном формате и уже можно создавать методы для предобработки датасета.

Какой формат датасета можно использовать?

Для удобства можно составить «неправильный” json, в котором будут записаны все наши данные.

Формат датасета в двух словах. Это json в котором каждая новая строка представляет собой словарь с ключами “system”, “user” и “bot”. Значение для каждого ключа заполняем системным, пользовательским и ответом бота соответственно.

В конечном итоге у вас должен получится примерно такой вид

Я же создал датасет разделил его на 2 файла: train.json и val.json. Файл валидации служит для оценки модели на i-ой эпохе и проверки переобучения модели.

Подготовим ноутбук для предобработки и обучения модели

Для начала загружаем модель LLama2 и адаптер LoRa (обязательно ставим параметр  is_trainable = True)

MODEL_NAME = "IlyaGusev/saiga2_7b_lora" device = torch.device("cuda" if torch.cuda.is_available() else "cpu")  st_time = time.time()  # bnb_config = BitsAndBytesConfig( #     load_in_4bit=True, #     bnb_4bit_quant_type="nf4", #     bnb_4bit_compute_dtype= torch.float16, #     bnb_4bit_use_double_quant=False, # )   config = PeftConfig.from_pretrained(MODEL_NAME) model = AutoModelForCausalLM.from_pretrained(     config.base_model_name_or_path,     load_in_8bit = True,     torch_dtype=torch.float16,     device_map="auto", #     quantization_config=bnb_config ) model = PeftModel.from_pretrained(     model,     MODEL_NAME,     torch_dtype=torch.float16, #      torch_dtype=torch.bfloat16,     is_trainable = True, #     device_map="auto" ).to(device)   model.eval()  tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME, use_fast=False) generation_config = GenerationConfig.from_pretrained(MODEL_NAME) print(generation_config) print(f'Прошло времени {time.time() - st_time}')

Теперь загрузим наши данные с помощью метода load_dataset

data = load_dataset(     "json",      data_files={                 'train' : '/kaggle/input/fine-tunning-llama/train.json' ,                 'validation' : '/kaggle/input/fine-tunning-llama/val.json'     } ) data

Cоставим метод для предобработки данных, чтобы каждый элемент датасета был словарём с ключами input_ids, attention_mask, labels

CUTOFF_LEN = 3584  def generate_prompt(data_point):     promt = f"""<s>system {data_point['system']}</s><s>user {data_point['user']}</s><s>bot {data_point['bot']}</s>"""     #     print(promt)     return promt        def tokenize (prompt, add_eos_token=True):     result = tokenizer(         prompt,         truncation=True,         max_length=CUTOFF_LEN,         padding=False,         return_tensors=None,     )     if (         result["input_ids"][-1] != tokenizer.eos_token_id and len(result["input_ids"]) < CUTOFF_LEN         and add_eos_token     ):                  result["input_ids"].append(tokenizer.eos_token_id)         result["attention_mask"].append(1)                            result["labels"] = result["input_ids"].copy()      return result   def generate_and_tokenize_prompt(data_point):     full_prompt = generate_prompt(data_point)     tokenized_full_prompt = tokenize(full_prompt) #     print(tokenized_full_prompt)     return tokenized_full_prompt

Сделаем предобработку для каждого элемента

train_data = (     data["train"].map(generate_and_tokenize_prompt) )  val_data = (     data["validation"].map(generate_and_tokenize_prompt) )

Далее задаём параметры обучения

• per_device_train_batch_size  — размер батча на каждую видеокарту (так как у нас она одна, все вычесления будут происходить на ней)

• gradient_accumulation_steps — накапливание градиента для экономии видеопамяти

• max_steps — количество шагов обучения

• learning_rate — скорость обучения

• fp16 — используем точность fp16. О этом параметре можно почитать тут

• logging_steps — вывод метрики потерь через данное количество шагов, которое здесь зададим

• optim — оптимизатор

• evaluation_strategy — стратегия вычислений, так как у нас стоят шаги (steps), то записываем steps

• eval_steps — подсчет метрики потерь каждые N шагов, которые здесь укажем

• save_steps — параметр сохранения чекпоинтов обучения через каждые N раз, которые здесь задаём

• output_dir — параметр для сохранения модели и чекпоинтов 

• save_total_limit — количество сохранённых чекпоинтов

• load_best_model_at_end — загрузка лучшей модели после обучения

• report_to — сохранить историю обучения на какой-либо сервис

• overwrite_output_dir — перезапись директории для сохранения модели

BATCH_SIZE = 4 MICRO_BATCH_SIZE = 2 GRADIENT_ACCUMULATION_STEPS = BATCH_SIZE // MICRO_BATCH_SIZE LEARNING_RATE = 3e-4 TRAIN_STEPS = 100 OUTPUT_DIR = "/kaggle/working/tmp"  training_arguments = transformers.TrainingArguments(             per_device_train_batch_size=MICRO_BATCH_SIZE,             gradient_accumulation_steps=GRADIENT_ACCUMULATION_STEPS, #             warmup_steps=200,             max_steps=TRAIN_STEPS,             learning_rate=LEARNING_RATE,             fp16=True,             logging_steps=10,             optim="adamw_torch",             evaluation_strategy="steps",             save_strategy="steps",             eval_steps=10,             save_steps=10,             output_dir=OUTPUT_DIR,             save_total_limit=10,             load_best_model_at_end=True,             report_to=None,             overwrite_output_dir=True, # Overwrite the content of the output dir )

Далее выбираем data_collator для пакетной обработки наших данных (DataCollatorForSeq2Seq). И в конечном итоге запускаем обучение

data_collator = transformers.DataCollatorForSeq2Seq(     tokenizer, pad_to_multiple_of=8, return_tensors="pt", padding=True )  trainer = transformers.Trainer(     model=model,     train_dataset=train_data,     eval_dataset=val_data,     args=training_arguments,     data_collator=data_collator ) model = torch.compile(model) trainer.train() model.save_pretrained(OUTPUT_DIR)

Готово!!

Обучение завершено и можно запушить наш дообученный адаптер на Hugging Face

from huggingface_hub import notebook_login  notebook_login()  model.push_to_hub("Your project", use_auth_token=True)

Конвертирование модели в GGUF формат или как запустить модель на «калькуляторе»

Если вы хотите чтобы ваша модель работала и занимала меньше памяти и чтобы она запускалась у вас на «калькуляторе» с 6 гигабайтами RAM, то для этого необходимо будет квантовать вашу модель.

Важно упомянуть, что квантование модели будет означать небольшую потерю точности. В данном случае будем квантовать модель до 4 бит. О том как квантовать модель оставлю ссылку в конце статьи.

Для начала мы должны склеить наши дообученные слои LoRa с нашей моделью. 

Клонируем репозитории rulm и llama.cpp

Далее прописываем необходимые пути:

1. self_instruct_dir — путь до self_instruct в проекте rulm

2. checkpoint — чекпоинт нашей лучшей модели

3. merged_model_name — куда мы хотим сохранить итоговую модель в формате PyTorch

Далее переходим в папку self_instruct_dir  и вызываем скрипт convert_to_native нашими параметрами

self_instruct_dir = '/kaggle/working/rulm/self_instruct' checkpoint = "/kaggle/working/tmp/checkpoint-40" merged_model_name = '/kaggle/tmp/merged_test_model.pt'  %cd {self_instruct_dir}

!python -m src.tools.convert_to_native {checkpoint} {merged_model_name} --device=cuda --enable_offloading

Конвертируем модель в GGUF формат

Перед конвертацией нам нужно сохранить Tokenizer в любую папку. Tokenizer берём той же самой модели Saiga

from transformers import AutoTokenizer tokenizer = AutoTokenizer.from_pretrained("IlyaGusev/saiga2_7b_lora", use_fast=False) tokenizer.save_pretrained('/kaggle/working/tmp/checkpoint-40/')

Далее переходим в папку llama.cpp и задаём необходимые параметры для конвертирования модели.

1. model_dir — путь до «склеенной» модели

2. checkpoint (можно было назвать tokenizer_path) — путь до сохранённого токенизатора

3. output_model — куда сохраняем нашу модель

4. ctx — количество tokens на входном слое (лучше оставить такое же значение как и у оригинальной модели)

model_dir = '/kaggle/tmp/merged_test_model.pt' checkpoint = "/kaggle/working/tmp/checkpoint-40" output_model = "/kaggle/tmp/model-f16.gguf"

Далее запускаем скрипт convert.py

!python convert.py {model_dir} --vocab-dir {checkpoint} --outfile {output_model} --outtype f16 --ctx 4096

Квантование модели до 4 бит

Для начала вызываем !make quantize

Далее также задаём параметры

1. model_gguf — наша 16 битная модель gguf

2. quant_model — куда сохраняем модель + название

3. quantization_type — тип квантования (используем q4_0)

После объявления параметров запускаем скрипт

! ./quantize {model_gguf} {quant_model} {quantization_type}

Проверяем нашу модель

%cd ~ !git clone --recursive https://github.com/ggerganov/llama.cpp.git %cd llama.cpp !make LLAMA_CUBLAS=1 -j libllama.so  # HACK: Use custom compiled libllama.so %cp ~/llama.cpp/libllama.so /opt/conda/lib/python3.10/site-packages/llama_cpp/libllama.so

from llama_cpp import Llama from tqdm import tqdm  SYSTEM_PROMPT = "Ты извлекаешь термины и определения из текста" SYSTEM_TOKEN = 1788 USER_TOKEN = 1404 BOT_TOKEN = 9225 LINEBREAK_TOKEN = 13  top_k=40 top_p=0.5 temperature=0.01 repeat_penalty=1.1   ROLE_TOKENS = {     "user": USER_TOKEN,     "bot": BOT_TOKEN,     "system": SYSTEM_TOKEN }   def get_message_tokens(model, role, content):     message_tokens = model.tokenize(content.encode("utf-8"))     message_tokens.insert(1, ROLE_TOKENS[role])     message_tokens.insert(2, LINEBREAK_TOKEN)     message_tokens.append(model.token_eos())     return message_tokens   def get_system_tokens(model):     system_message = {         "role": "system",         "content": SYSTEM_PROMPT     }     return get_message_tokens(model, **system_message)  def chat_saiga(message, model):     system_tokens = get_system_tokens(model)     tokens = system_tokens     # model.eval(tokens)          message_tokens = get_message_tokens(model=model, role="user", content=message)     role_tokens = [model.token_bos(), BOT_TOKEN, LINEBREAK_TOKEN]     tokens += message_tokens + role_tokens     # print(tokens)     # detokenize = model.detokenize(tokens)     # print(model.tokenize(full_prompt))     generator = model.generate(         tokens,         top_k = top_k,         top_p = top_p,         temp = temperature,         repeat_penalty = repeat_penalty,         reset = True     )     # print(len([token for token in generator]))          result_list = []          for token in generator:         token_str = model.detokenize([token]).decode("utf-8", errors="ignore")         tokens.append(token)         if token == model.token_eos():             break         print(token_str, end="", flush=True)         result_list.append(token_str)     return ''.join(result_list)  try:     del model except:     pass  # model_path = '/kaggle/working/model-q4_0.gguf' model_path = '/kaggle/working/model-q4_0.gguf' n_ctx = 3096 #  model = Llama(         model_path = model_path,         n_ctx = n_ctx,         n_gpu_layers=-1 )

В итоге модель неплохо обучилась и выводит строку в нужном формате. Датасет для обучения был составлен с помощью GPT. Всего экземпляров данных было 28

• train — 22 экземпляра

• val — 6 экземпляров

Причина по которой создан данный туториал

Этот туториал появился, когда мы в AI-команде Инлайн работали над интеграцией Сайги с вызовом функций и для обращения к внешним API, чтобы LLM могла запрашивать внешнюю информацию для ответов на вопросы.

И мы хотели бы, чтобы каждый мог при желании сам попробовать дообучить и оценить свою модель LLM

Ссылки на полезные источники

1. Ссылка на Kaggle для полного цикла обучения

2. Ссылка на Kaggle для запуска модели Saiga2_7b

3. Ссылка на проект rulm

4. Ссылка на проект llama.cpp

Отдельно хочу поблагодарить за проделанную работу автора Saiga Илью Гусева и автора llama.cpp Георгия Герганова