Есть вот такой код outputdir = contentdir / 'output' !cd {selfinstructdir} && python3 -m…
- User
Есть вот такой код output_dir = content_dir / 'output'
!cd {self_instruct_dir} && python3 -m src.train
--config-file {config_path.relative_to(self_instruct_dir)}
--train-file {content_dir / 'train.jsonl'}
--val-file {content_dir / 'val.jsonl'}
--output-dir {output_dir}assert (output_dir / 'adapter_config.json').exists()
Он выдает ошибку: AssertionError Traceback (most recent call last) in <cell line: 5>() 3 get_ipython().system("cd {self_instruct_dir} && python3 -m src.train --config-file {config_path.relative_to(self_instruct_dir)} --train-file {content_dir / 'train.jsonl'} --val-file {content_dir / 'val.jsonl'} --output-dir {output_dir}") 4 ----> 5 assert (output_dir / 'adapter_config.json').exists()
AssertionError:
В чем может быть проблема?
- Assistant
Ошибка
AssertionErrorговорит о том, что после выполнения команды в ячейке среды исполнения, файлadapter_config.jsonне обнаружен в директории, указанной в переменнойoutput_dir.Вот несколько возможных причин этой ошибки:
-
Неправильный путь в переменных: Проверьте, что переменные
content_dir,self_instruct_dir,config_pathиoutput_dirсодержат правильные пути к директориям и файлам. Также убедитесь, что все эти пути валидны в контексте среды, где исполняется код. -
Неудачное выполнение скрипта обучения: Скрипт
src.train, запускаемый через Python CLI, может завершиться с ошибкой, и в связи с этим файлadapter_config.jsonне будет создан. После запуска команды рекомендуется проверить логи на наличие ошибок. -
Ошибки доступа к файлам: Может возникать ошибка доступа при попытке записи в
output_dir. Удостоверьтесь, что среда исполнения имеет права на запись в эту директорию. -
Неверные права доступа: Если скрипт запускается на сервере или в контейнере, убедитесь, что окружение, из которого запускается скрипт, имеет соответствующие права для работы с директорией
output_dir.
Чтобы решить эту проблему:
- Проверьте вывод, который генерируется после выполнения скрипта
src.train. Возможно, там есть сообщения об ошибках, которые помогут понять, почемуadapter_config.jsonне создаётся. - Убедитесь, что все пути и переменные определены правильно и что директории существуют до начала выполнения кода.
- Проверьте логи и права доступа, если доступ к ним возможен.
Используя символ
!в Jupyter Notebook для выполнения команды через оболочку Linux, может быть полезно добавить флаг-eпослеsetв начале команды чтобы установить режим выхода при первой же ошибке:!cd {self_instruct_dir} && set -e && python3 -m src.train \ --config-file {config_path.relative_to(self_instruct_dir)} \ --train-file {content_dir / 'train.jsonl'} \ --val-file {content_dir / 'val.jsonl'} \ --output-dir {output_dir}Также можно перенаправить вывод стандартного и стандартного ошибочного потоков в файл для последующего анализа:
!cd {self_instruct_dir} && python3 -m src.train \ --config-file {config_path.relative_to(self_instruct_dir)} \ --train-file {content_dir / 'train.jsonl'} \ --val-file {content_dir / 'val.jsonl'} \ --output-dir {output_dir} > train_output.log 2>&1После этого можно будет проверить файл
train_output.logна наличие сообщений об ошибках. -
- User
Что это такое? import wandb wandb.login()
- Assistant
wandbотносится кWeights & Biases, это платформа для отслеживания и визуализации процесса машинного обучения. В частности,wandbиспользуется для логирования гиперпараметров, вывода метрик, весов, производительности модели и даже промежуточных результатов, например, изображений, генерируемых во время процесса обучения, и видео для задач компьютерного зрения.Конструкция
import wandbпозволяет импортировать библиотекуwandbв текущий скрипт Python.wandb.login()— это функция, которая авторизует пользователя и интегрирует текущий скрипт или сессию с серверами Weights & Biases, чтобы можно было начать отслеживать эксперименты и отправлять логи.При первом вызове
wandb.login(), может потребоваться ввести API ключ, который можно получить на сайте Weights & Biases, если у вас есть аккаунт. Это необходимо для аутентификации и связывания логов с вашей учетной записью на платформе. Обычно, ключ достаточно ввести один раз, после чего он будет сохранён в конфигурационном файле на вашем компьютере.После успешного входа в систему вы можете использовать различные возможности
wandbдля логирования данных. Например:import wandb # Initialize a new run wandb.init(project="my_project_name", entity="my_username") # Log some metrics for i in range(10): wandb.log({"epoch": i, "loss": loss_value})При этом в примере кода инициализируется новый "запуск" (
run), а затем в цикле записываются метрики, такие как номер эпохи и значение функции потерь. Эти данные будут автоматически отслеживаться и визуализироваться на веб-платформе Weights & Biases. - User
Что означает вот это Traceback (most recent call last): File "/usr/lib/python3.10/runpy.py", line 196, in _run_module_as_main return _run_code(code, main_globals, None, File "/usr/lib/python3.10/runpy.py", line 86, in _run_code exec(code, run_globals) File "/content/rulm/self_instruct/src/train.py", line 256, in fire.Fire(train) File "/usr/local/lib/python3.10/dist-packages/fire/core.py", line 141, in Fire component_trace = _Fire(component, args, parsed_flag_args, context, name) File "/usr/local/lib/python3.10/dist-packages/fire/core.py", line 475, in _Fire component, remaining_args = _CallAndUpdateTrace( File "/usr/local/lib/python3.10/dist-packages/fire/core.py", line 691, in _CallAndUpdateTrace component = fn(*varargs, **kwargs) File "/content/rulm/self_instruct/src/train.py", line 187, in train model = model_types[model_type].from_pretrained( File "/usr/local/lib/python3.10/dist-packages/transformers/models/auto/auto_factory.py", line 565, in from_pretrained return model_class.from_pretrained( File "/usr/local/lib/python3.10/dist-packages/transformers/modeling_utils.py", line 2614, in from_pretrained raise ImportError( ImportError: Using
load_in_8bit=Truerequires Accelerate:pip install accelerateand the latest version of bitsandbytespip install -i https://test.pypi.org/simple/ bitsandbytesor pip install bitsandbytes` - Assistant
Этот трассировочный вывод (traceback) сообщает о проблеме, возникшей при попытке запуска кода в Python. Конкретно ошибка
ImportErrorуказывает на то, что для выполнения требуемого кода необходимы определенные модули, которые не установлены в текущей среде Python.В вашем случае, вы пытаетесь использовать параметр
load_in_8bit=Trueпри загрузке предварительно обученной модели с помощью библиотекиtransformers. Этот параметр предназначен для загрузки модели с весами, которые сжимаются до 8-битных значений с помощью библиотекиbitsandbytes. Однако, чтобы использовать этот функционал, вам нужно установить два дополнительных пакета:accelerateиbitsandbytes.Чтобы устранить эту ошибку, вам нужно установить требуемые пакеты, используя инструмент управления пакетами
pip. Команды которые вы должны выполнить в командной строке:pip install accelerate pip install -i https://test.pypi.org/simple/ bitsandbytesОднако, вторая команда использует тестовый репозиторий PyPI для установки
bitsandbytes, что может быть нестабильно. Вместо этого в целом рекомендуется использовать основной PyPI репозиторий, если только вам не нужна конкретно очень новая или тестовая версияbitsandbytes:pip install bitsandbytesС установкой этих модулей, ошибка
ImportErrorдолжна исправиться, и вы сможете продолжить выполнение своего кода. - User
А если установка этих моделей не помогла, все равноо пишет тоже самое
- Assistant
Если вы уже установили требуемые пакеты
accelerateиbitsandbytesи все еще получаете ту же ошибку, есть несколько вещей, которые стоит проверить или предпринять:-
Перезапустите среду исполнения/интерпретатор Python: В некоторых случаях, особенно когда вы используете интерактивные среды, такие как Jupyter notebooks, новые пакеты могут не быть распознаны до перезапуска интерпретатора. Попробуйте закрыть и перезапустить среду исполнения.
-
Убедитесь, что используете правильное окружение Python: Если вы используете виртуальное окружение (virtualenv) или систему управления окружениями (например, conda), удостоверьтесь, что вы активировали нужное окружение и что всё установилось именно туда.
-
Проверьте версию
bitsandbytes: Возможно, вам нужна определенная версия пакетаbitsandbytes. Попробуйте установить последнюю доступную версию:pip install --upgrade bitsandbytes -
Убедитесь, что у вас последняя версия
transformers: Возможно, поддержка параметраload_in_8bit=Trueбыла добавлена в новых версияхtransformers. Убедитесь, что вы используете последнюю версию:pip install --upgrade transformers -
Проверьте наличие ошибок при установке: При установке
bitsandbytesмогут возникать ошибки, связанные с операционной системой или зависимостями. Внимательно просмотрите вывод pip во время установки на предмет ошибок. -
Прочитайте документацию пакетов: Тщательно изучите документацию библиотеки
bitsandbytesиtransformers, на предмет каких-либо специальных условий или зависимостей, которые могут повлиять на успешную установку и использование параметраload_in_8bit. -
Используйте стандартный PyPI репозиторий для установки: Если проблема остается, попробуйте использовать стандартный пакет
bitsandbytes, установленный прямо из PyPI без указания test pypi репозитория:pip install bitsandbytes
После выполнения этих шагов попробуйте снова запустить свой код. Если проблема не решается, возможно, стоит обратиться к разработчикам соответствующих библиотек за помощью или подать issue в их репозитории на GitHub с указанием всех деталей и шагов, которые вы уже предприняли.
-
- User
from tqdm import tqdm что это за библиотека
- Assistant
Библиотека
tqdmв Python – это инструмент, позволяющий легко добавить индикатор прогресса (прогресс-бар) к циклам.tqdmозначает "taqaddum" (араб. прогресс) и можно произносить как "та-кадум". Это популярная библиотека благодаря её простоте в использовании и способности работать практически с любым типом итерируемого объекта. Прогресс-барыtqdmочень полезны при длительных вычислительных операциях, поскольку они предоставляют наглядное представление о том, сколько работы уже выполнено и сколько ещё предстоит.Пример использования
tqdm:from tqdm import tqdm import time # Предположим, что у нас есть какой-то итерируемый объект как список my_iterable = range(100) # Обернём этот итерируемый объект в tqdm для отображения прогресса for i in tqdm(my_iterable): # Выполним некоторую операцию, например, "подождём" 0.01 секунды time.sleep(0.01)Во время выполнения этого кода в интерактивной консоли или в рамках Jupyter Notebook вы увидите прогресс-бар, который будет обновляться на каждой итерации цикла, показывая прогресс, скорость выполнения и остаток времени до окончания цикла.
Tqdmтакже предоставляет множество опций для настройки, такие как настройка формата отображения, вывод прогресс-бара в файл или stdout, использование в многопоточных или асинхронных задачах и многое другое. - User
Что делает эта функция def has_bad_ss(messages): for m in messages: text = m["content"].lower() if any(ss in text for ss in BAD_SS): return True return False
- Assistant
Эта функция
has_bad_ssпредназначена для проверки списка сообщенийmessagesна наличие в них нежелательных подстрок, определенных в спискеBAD_SS. Давайте разберем функцию по шагам:-
Функция принимает на вход один параметр
messages, который, вероятно, является списком словарей. Каждый словарь в этом списке представляет собой сообщение, где ключ"content"хранит текст сообщения. -
В начале функции идет цикл
for, который проходит по всем элементам спискаmessages. -
Для каждого сообщения
mв списке извлекается значение поля"content", которое затем приводится к нижнему регистру методом.lower(). Это делается для того, чтобы поиск подстроки был нечувствителен к регистру символов. -
Внутри цикла есть условная конструкция
if any(...), которая проверяет, содержит ли текст сообщения хотя бы одну из нежелательных подстрок, перечисленных в спискеBAD_SS. -
Если в тексте сообщения обнаруживается нежелательная подстрока (
ss in text), функция немедленно возвращаетTrue, что означает наличие "плохой" подстроки в одном из сообщений. -
Если после проверки всех сообщений ни одно из них не содержит нежелательных подстрок, то выполняется завершающий
return False, возвращающий значениеFalse, что означает отсутствие "плохих" подстрок во всех сообщениях.
Пример использования такой функции мог бы выглядеть так:
BAD_SS = ["плохое слово", "запрещенный термин"] messages = [ {"content": "Это пример хорошего сообщения."}, {"content": "Это сообщение содержит плохое слово."}, ] if has_bad_ss(messages): print("Найдено сообщение с нежелательным содержимым.") else: print("Все сообщения соответствуют стандартам.")В этом конкретном примере функция
has_bad_ssвернетTrue, так как во втором сообщении спискаmessagesсодержится подстрока"плохое слово", которая присутствует в спискеBAD_SS. -
- User
Что делает вот эта функция def revert_flattening(records): fixed_records = [] for key, values in records.items(): if not fixed_records: fixed_records = [{} for _ in range(len(values))] for i, value in enumerate(values): fixed_records[i][key] = value return fixed_records
- Assistant
Эта функция
revert_flatteningпреобразует словарь со списками значений в список словарей. Функция рассчитывает на то, что значения в переданном словареrecordsорганизованы так, что каждому ключу соответствует список значений. Количество элементов в каждом из этих списков должно быть одинаковым, чтобы результат был корректным.Давайте рассмотрим по шагам, что делает эта функция:
-
fixed_recordsинициализируется как пустой список. Это список, который будет содержать итоговые словари. -
Цикл
for key, values in records.items():проходит по всем ключам и значениям входного словаряrecords.key– это ключ вrecords,values– это список значений, ассоциированных с этим ключом. -
При первой итерации цикла, если
fixed_recordsещё пустой, создаётся список пустых словарей. Количество этих словарей соответствует длине спискаvalues. Это делается для того, чтобы подготовить структуру данных, в которую будут вставлены значения. -
Во внутреннем цикле
for i, value in enumerate(values):, каждое значение из списка присваивается соответствующему пустому словарю вfixed_records, используя индексiдля нахождения соответствующего словаря и ключkeyдля назначения значения. -
После выполнения всех итераций,
fixed_recordsвозвращается и содержит список словарей, сформированный из исходного словаря со списками значений.
Пример использования функции:
records = { 'name': ['Alice', 'Bob', 'Charlie'], 'age': [25, 30, 35], 'city': ['New York', 'Los Angeles', 'Chicago'] } fixed_records = revert_flattening(records) print(fixed_records)Вывод будет следующим:
[ {'name': 'Alice', 'age': 25, 'city': 'New York'}, {'name': 'Bob', 'age': 30, 'city': 'Los Angeles'}, {'name': 'Charlie', 'age': 35, 'city': 'Chicago'} ]Каждый элемент списка
fixed_records– это словарь, который представляет отдельную запись, собранную из оригинального словаря, где списки значений были "развернуты" обратно в отдельные записи. -
- User
Что делает вот эта функция def calc_max_length(records): return max([sum([len(m["content"]) for m in r["messages"]]) for r in records])
- Assistant
Функция
calc_max_lengthпредназначена для нахождения максимальной суммарной длины текстов сообщений в списке записейrecords. Каждая запись в этом списке предполагается быть словарём, имеющим ключ"messages", который ассоциируется со списком сообщений. Каждое сообщение в свою очередь тоже является словарём, где по ключу"content"можно получить его текстовое содержимое.Давайте разберём функцию по шагам:
-
Внешний генератор списков (
[ ... for r in records]) итерируется по всем записям в спискеrecords. -
Для каждой записи
rв этом списке берётся значение по ключу"messages", которое представляет собой список сообщений. -
Во внутреннем генераторе списков (
[len(m["content"]) for m in r["messages"]]) для каждого сообщенияmв списке сообщений рассчитывается длина его текстового содержимого (полученного по ключу"content"), то есть количество символов в тексте. -
Затем функция
sumсчитает суммарную длину всех текстов сообщений в рамках одной записи – то есть складывает длины всех сообщений, находящихся вr["messages"]. -
После того как для каждой записи
rвrecordsрассчитана суммарная длина текстов сообщений, на внешнем уровне функцияmaxищет и возвращает максимальное из этих суммарных значений.
В результате, данная функция
calc_max_lengthвозвращает максимальную сумму длин текстов сообщений из всех записей вrecords. Фактически это даст нам длину самого объёмного "разговора" (или какой бы термин не был применён к этим записям) по количеству символов во всех сообщениях этой записи.Пример использования функции:
records = [ {'messages': [{'content': 'Hello'}, {'content': 'World!'}]}, {'messages': [{'content': 'Python'}, {'content': 'Programming'}, {'content': 'is fun'}]}, ] max_length = calc_max_length(records) print(max_length) # Вывод: 22, так как суммарная длина текстов во второй записи - это 6 (Python) + 11 (Programming) + 5 (is fun) = 22.Таким образом, пример показывает, что во второй записи наибольшая суммарная длина текстов сообщений.
-
- User
Что делает вот эта функция def build_char_system_messages(char): name = char["name"] greeting = char["greeting"] example_dialogue = char["example_dialogue"]
context = "" if random.random() < 0.5: context += f"Ты {name}. " context += f"{char['context']}" chat = [] if random.random() < 0.2: context += f"\nПриветствие: {greeting}" chat.append({ "role": "bot", "content": greeting }) if random.random() < 0.2: mapping = { "user": "Пользователь", "char": "Персонаж" } example_messages = [f'{mapping[m["role"]]}: {m["content"]}' for m in example_dialogue] context += "\nПример диалога:\n" + "\n".join(example_messages) chat.insert(0, { "role": "system", "content": context }) return chat - Assistant
Функция
build_char_system_messagesсоздает системные сообщения для персонажа на основе предоставленной информации.В теле функции происходят следующие действия:
-
Из словаря
char, который передается в функцию в качестве аргумента, извлекаются данные персонажа: его имя (name), приветствие (greeting), а также пример диалога (example_dialogue). -
Создается пустая строка
context, которая будет служить основой для системного сообщения. -
С помощью функции
random.random()выполняется случайная выборка, чтобы с вероятностью 50% добавить сообщение вcontext, в котором упоминается имя персонажа (например, "Ты [имя_персонажа]."). -
Далее, непосредственно к
contextдобавляется информация изchar['context']. -
Создается пустой список
chat, который будет содержать системные сообщения. -
Снова используется
random.random()для выполнения случайной выборки с вероятностью 20%, и если условие выполняется, вcontextдобавляется указание приветствия (greeting), а в списокchatдобавляется словарь с приветственным сообщением от бота (вroleуказывается "bot", вcontent- приветствие). -
Далее, еще раз выполняется случайная выборка с тем же условием вероятности. Если оно выполняется, то создается строка с примером диалога, где для каждого сообщения в
example_dialogueуказывается роль (пользователь или персонаж) и текст сообщения. Этот пример диалога добавляется вcontext. -
Добавляется системное сообщение (с
role"system") в начало спискаchat, в котором содержится контекст (информация о персонаже, приветствие, пример диалога). -
Функция возвращает список
chatс системными сообщениями для данного персонажа.
Примерно так будет работать этот код, предполагая, что в
charсодержится всё необходимое:import random char = { "name": "Гарри", "greeting": "Привет, я Гарри!", "example_dialogue": [ {"role": "user", "content": "Как дела?"}, {"role": "char", "content": "Все отлично, спасибо!"} ], "context": "ты волшебник в мире волшебства." } chat = build_char_system_messages(char) print(chat)На выходе получится список
chatс системными сообщениями, которые могут содержать ту или иную информацию о персонаже в зависимости от случайной выборки. -
- User
А что выведется?
- Assistant
Точный вывод будет зависеть от случайных значений, сгенерированных функцией
random.random(), так как в приведенном коде есть три условия, влияющие на содержание системных сообщений, каждое из которых основано на рандомизированном выборе:- Имя персонажа добавляется в
contextс вероятностью 50%. - Приветствие добавляется в
contextиchatс вероятностью 20%. - Пример диалога добавляется в
contextс вероятностью 20%.
Вот примеры того, как может выглядеть вывод при разных значениях
random.random():Пример 1: (random < 0.5, < 0.2, < 0.2)
[ {"role": "system", "content": "Ты Гарри. ты волшебник в мире волшебства.\nПриветствие: Привет, я Гарри!\nПример диалога:\nПользователь: Как дела?\nПерсонаж: Все отлично, спасибо!"}, {"role": "bot", "content": "Привет, я Гарри!"} ]Пример 2: (random < 0.5, not < 0.2, < 0.2)
[ {"role": "system", "content": "Ты Гарри. ты волшебник в мире волшебства.\nПример диалога:\nПользователь: Как дела?\nПерсонаж: Все отлично, спасибо!"}, ]Пример 3: (random < 0.5, < 0.2, not < 0.2)
[ {"role": "system", "content": "Ты Гарри. ты волшебник в мире волшебства.\nПриветствие: Привет, я Гарри!"}, {"role": "bot", "content": "Привет, я Гарри!"} ]Пример 4: (random not < 0.5, not < 0.2, not < 0.2)
[ {"role": "system", "content": "ты волшебник в мире волшебства."} ]Эти примеры демонстрируют разнообразие возможного содержания
chatна основе рандомизации. Фактический вывод при вызове функцииbuild_char_system_messages(char)будет одним из таких вариантов или каким-то другим в соответствии с случайно сгенерированными значениями. - Имя персонажа добавляется в
- User
Можешь объяснить, что делается в этом коде def main(train_path, val_path): random.seed(42)
instruct_records = [] for row in tqdm(load_dataset("lksy/ru_instruct_gpt4", split="train")): if random.random() > 0.3: continue message = row["instruction"] if row["input"]: message += "\nДано: " + row["input"] output = row["full_output"] if not output: continue if has_bad_ss([{"content": output}]): continue instruct_records.append({ "messages": [ {"role": "user", "content": message}, {"role": "bot", "content": output} ], "source": "gpt4" }) print("Instruct gpt4 count:", len(instruct_records)) print("Instruct gpt4 length:", calc_max_length(instruct_records)) records = instruct_records saiga_records = [] for row in tqdm(load_dataset("IlyaGusev/ru_turbo_saiga", split="train")): messages = revert_flattening(row["messages"]) if has_bad_ss(messages): continue if row["model_name"] != "gpt-4": continue if random.random() > 0.5: continue saiga_records.append({ "messages": messages, "source": "saiga" }) print("Saiga count:", len(saiga_records)) print("Max Saiga length:", calc_max_length(saiga_records)) records += saiga_records sharegpt_records = [] for row in tqdm(load_dataset("IlyaGusev/ru_sharegpt_cleaned", split="train")): messages = revert_flattening(row["messages"]) text_length = sum([len(m["content"]) for m in messages]) while text_length > 10000 and messages: messages = messages[:-2] text_length = sum([len(m["content"]) for m in messages]) if not messages: continue sharegpt_records.append({ "messages": messages, "source": "sharegpt" }) print("ShareGPT count:", len(sharegpt_records)) print("ShareGPT max length:", calc_max_length(sharegpt_records)) records += sharegpt_records oasst_records = [] for row in tqdm(load_dataset("IlyaGusev/oasst1_ru_main_branch", split="train")): messages = revert_flattening(row["messages"]) text_length = sum([len(m["content"]) for m in messages]) while text_length > 10000 and messages: messages = messages[:-2] text_length = sum([len(m["content"]) for m in messages]) if not messages: continue oasst_records.append({ "messages": messages, "source": "oasst" }) print("OASST count:", len(oasst_records)) print("OASST max length:", calc_max_length(oasst_records)) records += oasst_records rp_records = [] for row in tqdm(load_dataset("IlyaGusev/gpt_roleplay_realm", split="ru")): for dialogue in row["dialogues"]: if dialogue["model_name"] != "gpt-4": continue chat = dialogue["chat"] for message in chat: if message["role"] == "char": message["role"] = "bot" if message["role"] == "operator": message["role"] = "user" system_messages = build_char_system_messages(row) chat = system_messages + chat rp_records.append({ "messages": chat, "source": "roleplay" }) print("Roleplay count:", len(rp_records)) print("Roleplay max length:", calc_max_length(rp_records)) records += rp_records lima_records = [] lima_role_mapping = { "human": "user", "gpt": "bot" } for row in tqdm(load_dataset("64bits/lima_vicuna_format", split="train")): chat = row["conversations"] fixed_messages = [{ "role": "system", "content": "You are a virtual assistant that wants to be helpful" }] for message in chat: fixed_messages.append({ "role": lima_role_mapping[message["from"]], "content": message["value"] }) lima_records.append({ "messages": fixed_messages, "source": "lima" }) print("LIMA count:", len(lima_records)) print("LIMA max length:", calc_max_length(lima_records)) records += lima_records print("All count:", len(records)) print("All max length:", calc_max_length(records)) cleaned_records = [] for record in records: messages = record["messages"] roles = {m["role"] for m in messages} for role in roles: assert role in ("bot", "user", "system"), role if has_bad_ss(messages): continue if not record["messages"]: continue cleaned_records.append(record) records = cleaned_records print("All count after cleaning:", len(records)) random.shuffle(records) border = int(0.95 * len(records)) train_records = records[:border] val_records = records[border:] with open(train_path, "w") as w: for record in train_records: w.write(json.dumps(record, ensure_ascii=False).strip() + "\n") with open(val_path, "w") as w: for record in val_records: w.write(json.dumps(record, ensure_ascii=False).strip() + "\n") - Assistant
Этот код выполняет несколько шагов для загрузки, обработки и разбиения датасетов на обучающую (train) и валидационную (val) выборки.
По шагам выполнение этого кода выглядит следующим образом:
-
Устанавливается фиксированный seed для генератора случайных чисел
randomдля воспроизводимости результатов. -
Загружаются и обрабатываются данные из различных источников датасетов (например,
"lksy/ru_instruct_gpt4","IlyaGusev/ru_turbo_saiga", и другие), которые касаются, вероятно, диалоговых систем, где участники взаимодействуют друг с другом, выполняя роли пользователей (user), ботов (bot) и систем (system). -
В каждом датасете итерационно обрабатываются записи (
row), причём каждая запись подвергается условиям фильтрации, например:- Отсекание записей с вероятностью 30% или 50% (в зависимости от случая).
- Проверка записей на наличие нежелательных подстрок (
has_bad_ssфункция). - Проверка содержания записей на определенные условия (например, имя модели).
-
Для некоторых датасетов проверяется и обрезается длина контента сообщений так, чтобы она не превышала 10000 символов.
-
К диалогам из датасета
"IlyaGusev/gpt_roleplay_realm"добавляются системные сообщения в начало каждого диалога с помощью функцииbuild_char_system_messages. -
Выполняется стандартизация ролей в диалогах, чтобы они соответствовали стандартному набору ("bot", "user", "system").
-
После обработки всех датасетов их рекорды объединяются в один большой список
records. -
Выполняется финальная фильтрация
records, удаляя пустые сообщения и сообщения, содержащие нежелательные подстроки. -
Список записей перемешивается для обеспечения случайной выборки.
-
Происходит разбиение всего списка на обучающую и валидационную выборки в соотношении 95% к 5% (или любом другом, определённом пользователем).
-
Результаты записываются в файлы с путями
train_pathиval_path.
Этот код предназначен для создания обучающего и валидационного наборов данных для последующего обучения или оценки диалоговой модели. Он демонстрирует, как собирать и объединять разнообразные данные, проводить их предварительную обработку и подготовку для машинного обучения.
-
- User
что такое формат .jsonl и чем он отличается от json
- Assistant
Формат
.jsonl(JSON Lines) это текстовый формат файла, в котором каждая строка содержит отдельный валидный JSON объект. Это отличается от стандартного формата JSON тем, что в стандартном JSON файле всё содержимое обычно является одним большим JSON объектом или массивом объектов. В отличие от этого, файл.jsonlсодержит несколько объектов JSON, разделённых переводами строки.Пример стандартного JSON файла:
[ { "name": "John", "age": 30 }, { "name": "Jane", "age": 25 } ]Пример файла в формате JSON Lines (.jsonl):
{"name": "John", "age": 30} {"name": "Jane", "age": 25}Основные отличия и преимущества формата
.jsonl:-
Построчное чтение: Данные могут читаться по одной записи за раз, что удобно для больших наборов данных, поскольку не требуется загружать в память весь файл целиком.
-
Удобство добавления: При добавлении новых данных достаточно записать их в новую строку файла, в то время как для стандартного JSON потребуется перезагрузка и полная перезапись файла.
-
Потоковая обработка: Формат
.jsonlпозволяет обрабатывать данные потоково, что эффективно для операций в реальном времени и для больших наборов данных, где файлы слишком велики, чтобы считываться в память полностью. -
Упрощение парсинга: Каждая строка
.jsonlфайла является валидным JSON объектом, поэтому её можно парсить независимо от остальных, что облегчает парсинг и обработку ошибок.
Формат
.jsonlчасто используется в задачах машинного обучения для хранения тренировочных данных, в логировании, где каждое событие представляется отдельным JSON объектом, и в других сценариях, где требуется удобная последовательная обработка больших объемов структурированных данных. -
- User
from huggingface_hub import snapshot_download что это за библиотека и модуль
- Assistant
huggingface_hub– это библиотека, разработанная сообществом Hugging Face, которая предназначена для работы с Hugging Face Hub – центральным репозиторием, где хранятся предобученные модели, датасеты и другие ресурсы для машинного обучения и искусственного интеллекта.Модуль
snapshot_downloadв данной библиотеке представляет функцию, которая позволяет скачивать файлы и модели непосредственно из Hugging Face Hub. Она особенно полезна для извлечения файлов, связанных с определенной моделью или набором данных, поскольку может загружать снимки (snapshots) содержимого репозитория на момент определенной ревизии.Применение
snapshot_downloadпозволяет пользователю легко и удобно скачивать ресурсы, необходимые для работы с моделями, датасетами или другими артефактами, и делать это воспроизводимым образом (за счет опции указания конкретной ревизии репозитория).Пример использования функции
snapshot_downloadвыглядит следующим образом:from huggingface_hub import snapshot_download # Ссылка на репозиторий в Hugging Face Hub и желаемая ревизия repo_id = "distilgpt2" revision = "main" # или конкретный хеш коммита # Скачивание репозитория с моделью local_folder_path = snapshot_download(repo_id=repo_id, revision=revision) print(f"Модель была скачана и сохранена локально в папке: {local_folder_path}")Таким образом, библиотека
huggingface_hub, и особенно модульsnapshot_download, служит для облегчения доступа к ресурсам Hugging Face Hub и управления ими из кода Python. - User
что делает следующий код model_dir = content_dir / "llama2-7b" base_model = "TheBloke/Llama-2-7B-fp16" #@param {type:"string"} snapshot_download(repo_id=base_model, local_dir=model_dir, ignore_patterns=["LICENSE", "README.md", ".gitattributes"])
patch_model_config = True #@param {type:"boolean"}
if patch_model_config: replacements = { "tokenizer_config.json": { "tokenizer_class": "LlamaTokenizer", "model_max_length": 4096, "padding_side": "left", "bos_token": "", "eos_token": "", "unk_token": "", "clean_up_tokenization_spaces": False, "special_tokens_map_file": "special_tokens_map.json", }, "special_tokens_map.json": { "bos_token": "", "eos_token": "", "pad_token": "", "sep_token": "", "unk_token": "", } }
print('Patching model config...') for filename, new_content in replacements.items(): print(f'{filename}:') with (model_dir / filename).open() as fp: old_content = json.load(fp) print(f' Original content: {old_content}') if old_content == new_content: print(' Already patched, skipping') print(f' Updated content: {new_content}') with (model_dir / filename).open('w') as fp: json.dump(new_content, fp, indent=4) - Assistant
Код, описанный выше, делает следующее:
-
Задается папка
model_dir, которая является целевым местоположением для скачивания предобученной модели, и идентификатор базовой моделиbase_modelиз Hugging Face Hub. -
Используя функцию
snapshot_downloadиз библиотекиhuggingface_hub, код скачивает файлы модели из репозитория с репозиториемbase_modelв локальную папкуmodel_dir. Во время скачивания игнорируются файлы лицензии, README и git атрибуты. -
Устанавливается булева переменная
patch_model_configдля определения, требуется ли изменить конфигурационные файлы модели (по умолчанию True, что означает необходимость внесения изменений). Если переменнаяpatch_model_configустановлена в True, код применяет следующие шаги: -
Определяется словарь замен
replacements, который содержит новые параметры для файловtokenizer_config.jsonиspecial_tokens_map.json. -
Следующий цикл for перебирает файлы конфигурации в указанной локальной папке
model_dirи загружает текущее содержание, сравнивая его с новым содержанием, заданным вreplacements. Если он обнаруживает, что файл уже содержит требуемые изменения, он не изменяет этот файл. В противном случае, код перезаписывает файл с новыми значениями изreplacements. -
Замена параметров в файлах конфигурации заключается в том, что задается класс токенизатора, максимальная длина модели, сторона добавления паддинга (заполнения), специальные токены, а также другие настройки токенизатора и маппинга специальных токенов.
Эта процедура используется для того, чтобы конфигурация модели соответствовала требованиям пользователя или условиям эксперимента, в котором модель будет использоваться. Такие изменения могут быть необходимы в случае, когда вы хотите использовать модель с другим токенизатором или когда предоставленная к модели конфигурация должна быть адаптирована для конкретной задачи.
-
- User
Что делает вот этот код !cd {self_instruct_dir} && python3 -m src.train
--config-file {config_path.relative_to(self_instruct_dir)}
--train-file {content_dir / 'train.jsonl'}
--val-file {content_dir / 'val.jsonl'}
--output-dir {output_dir}assert (output_dir / 'adapter_config.json').exists()
- Assistant
Этот код выполняется в среде командной строки Unix/Linux (например, в терминале или Jupyter Notebook с префиксом
!), и он состоит из двух частей: команды для обучения модели машинного обучения с использованием Python и проверки после такого обучения.-
Команда для обучения модели:
cd {self_instruct_dir} && python3 -m src.train \ --config-file {config_path.relative_to(self_instruct_dir)} \ --train-file {content_dir / 'train.jsonl'} \ --val-file {content_dir / 'val.jsonl'} \ --output-dir {output_dir}Здесь используется команда
cdдля перехода в директорию с кодом (self_instruct_dir). После этого выполняется обучение модели с помощью скрипта Python в модулеsrc.train. В эту команду включены следующие аргументы:--config-file: путь к файлу конфигурации, который используется при обучении модели, относительно директорииself_instruct_dir.--train-file: путь к файлу с обучающими данными (в формате JSON Lines).--val-file: путь к файлу с данными для валидации (в формате JSON Lines).--output-dir: директория, куда будут сохранены результаты обучения, например, обученная модель или файлы конфигурации.
content_dirиoutput_dir- это переменные Python, которые предположительно содержат пути к директориям.Знак
&&означает, чтоpython3 -m src.trainбудет выполнен только после успешного выполненияcd {self_instruct_dir}. -
Утверждение (assertion):
assert (output_dir / 'adapter_config.json').exists()После выполнения обучения код выполняет утверждение, проверяющее, существует ли файл
adapter_config.jsonв директорииoutput_dir. Если утверждение выполняется (файл существует), выполнение кода продолжается. В противном случае возникает исключениеAssertionError, указывающее на отсутствие файла, что может свидетельствовать о возникшей ошибке при обучении модели или при сохранении конфигурации адаптера.Этот файл,
adapter_config.json, видимо, является частью вывода обучения и может содержать параметры, которые указывают на то, как была сконфигурирована или настроена модель в процессе обучения.
Код использует фигурные скобки
{}для подстановки строковых переменных, что типично для Python f-строк или метода.format(). Однако, в данном случае это работает благодаря среде Jupyter Notebook, которая автоматически заменяет значения перед выполнением команды в командной строке. -
- User
Зачем нужен этот класс class TrainerNoBaseSave(Trainer): def init(self, *args, **kwargs): return super().init(*args, **kwargs)
def _save_checkpoint(self, model, trial, metrics=None): print("Running custom _save_checkpoint") checkpoint_folder = f"{PREFIX_CHECKPOINT_DIR}-{self.state.global_step}" run_dir = self._get_output_dir(trial=trial) output_dir = os.path.join(run_dir, checkpoint_folder) if metrics is not None and self.args.metric_for_best_model is not None: metric_to_check = self.args.metric_for_best_model if not metric_to_check.startswith("eval_"): metric_to_check = f"eval_{metric_to_check}" metric_value = metrics[metric_to_check] operator = np.greater if self.args.greater_is_better else np.less if ( self.state.best_metric is None or self.state.best_model_checkpoint is None or operator(metric_value, self.state.best_metric) ): self.state.best_metric = metric_value self.state.best_model_checkpoint = output_dir os.makedirs(output_dir, exist_ok=True) if self.args.should_save: self._rotate_checkpoints(use_mtime=True, output_dir=run_dir) - Assistant
Этот класс
TrainerNoBaseSaveявляется наследником классаTrainerиз библиотекиtransformersHugging Face и предназначен для переопределения стандартного поведения сохранения чекпоинтов (состояний) модели во время процесса обучения.Давайте разберем, для чего может быть нужно переопределение метода
_save_checkpointв данном наследуемом классе:-
Отложенное выполнение: Возможно, сохранение чекпоинтов нативным образом (по умолчанию) занимает много времени или пространства, и разработчик желает изменить способ или момент времени сохранения.
-
Настройка сохранения: Может быть необходимо сохранять чекпоинты модели в определенной схеме именования или выбирать местоположение сохранения на основании метрик.
-
Экономия ресурсов: Чтобы экономить дисковое пространство или вычислительные ресурсы, можно изменить логику, чтобы сохранять только определенные чекпоинты (например, содержащие наилучшие результаты).
-
Контроль лучшей модели: В приведенном коде внутренняя логика сравнивает метрику текущего чекпоинта с лучшей метрикой, чтобы определить, следует ли обновить информацию о "лучшей" модели.
Конкретно в коде происходят следующие действия:
- В функции
_save_checkpointтекст "Running custom _save_checkpoint" выводится на экран для индикации использования переопределенного метода. - Определяется путь к папке чекпоинта
output_dir, комбинируя директорию запускаrun_dir, префиксPREFIX_CHECKPOINT_DIRи шаг глобального состояния. - Если метрики доступны и задан
metric_for_best_model, то код проверяет, является ли текущая метрика лучше предыдущей записанной, и если да, обновляет информацию о лучшем чекпоинте. - Создается директория чекпоинта с помощью
os.makedirs. - Если установлен флаг
should_save, вызывается метод_rotate_checkpoints, который управляет количеством сохраняемых чекпоинтов, предотвращая переполнение дискового пространства.
Использование класса позволяет управлять процессом сохранения модели в соответствии с потребностями конкретного эксперимента или требованиями инфраструктуры.
-
- User
Для чего нужен этот класс class SavePeftModelCallback(TrainerCallback): def on_save( self, args: TrainingArguments, state: TrainerState, control: TrainerControl, **kwargs, ): checkpoint_path = f"{PREFIX_CHECKPOINT_DIR}-{state.global_step}" checkpoint_folder = os.path.join(args.output_dir, checkpoint_path) kwargs["model"].save_pretrained(checkpoint_folder) return control
- Assistant
Класс
SavePeftModelCallbackпредставляет собой пользовательский обратный вызов (callback), который интегрируется с тренировочным циклом, предоставляемым классомTrainerв библиотекеtransformersот Hugging Face. Он наследуется от базового класса обратных вызововTrainerCallback. Цель этого класса — сохранять предварительно обученную модель на определенных этапах процесса обучения.Метод
on_saveвызывается, когда тренер (Trainer) сохраняет чекпоинт. В этом методе реализованны следующие действия:-
Определяется путь до папки чекпоинта
checkpoint_folderна основе аргументов обученияargs.output_dirи шаблона имени директории чекпоинта, который включает шаг глобального состоянияstate.global_step. -
Полученный путь
checkpoint_folderиспользуется для сохранения текущей модели с помощью методаsave_pretrainedмодели, которая передается вkwargs(словарь с ключевыми аргументами, переданными в метод обратного вызова). -
Возвращается экземпляр
TrainerControl, который может быть использован для управления поведением цикла обучения (например, можно было бы передать сигнал об остановке обучения).
Применение пользовательского обратного вызова позволяет внедрить специфические для конкретной задачи операции сохранения модели в процесс обучения. Например, такой подход полезен в случаях, когда вам нужно сохранять модель в нестандартном формате имени файла или вам необходимо дополнительно сохранять другие артефакты во время чекпоинта.
В целом, этот класс позволяет контролировать, когда и как модель сохраняется во время тренировки, предоставляя дополнительный уровень гибкости по сравнению со стандартным поведением класса
Trainer.Чтобы этот обратный вызов заработал, его необходимо передать экземпляру
Trainerв параметреcallbacksпри его инициализации. -
- User
Что делает эта функция? def custom_prepare_model_for_int8_training( model, output_embedding_layer_name="lm_head", layer_norm_names=["layer_norm"] ): for name, param in model.named_parameters(): param.requires_grad = False
for name, param in model.named_parameters(): if param.ndim == 1 and any(layer_norm_name in name for layer_norm_name in layer_norm_names): param.data = param.data.to(torch.float32) if hasattr(model, "enable_input_require_grads"): model.enable_input_require_grads() else: def make_inputs_require_grad(module, input, output): output.requires_grad_(True) model.get_input_embeddings().register_forward_hook(make_inputs_require_grad) if hasattr(model, output_embedding_layer_name): output_embedding_layer = getattr(model, output_embedding_layer_name) input_dtype = output_embedding_layer.weight.dtype class CastOutputToFloat(torch.nn.Sequential): def forward(self, x): return super().forward(x.to(input_dtype)).to(torch.float32) setattr(model, output_embedding_layer_name, CastOutputToFloat(output_embedding_layer)) model.gradient_checkpointing_enable() return model - Assistant
Эта функция
custom_prepare_model_for_int8_trainingпредназначена для подготовки модели нейронных сетей, основанных на PyTorch, к обучению с использованием 8-битной целочисленной числовой точности (int8, также известной как квантизация). Вот детальный разбор её действий:-
Отключение обучения всех параметров модели: Первый цикл обходит все параметры модели, устанавливая
requires_gradвFalseдля каждого параметра. Это говорит о том, что градиенты для этих параметров не будут вычисляться во время обратного прохода, что явно свидетельствует о намерении фиксировать веса этих слоев во время обучения. -
Перевод параметров слоёв нормализации в 32-битное float представление: Второй цикл ещё раз обходит все параметры модели и проверяет, нормализуются ли параметры этого слоя (обычно это гамма и бета в BatchNorm слоях), и если это так, приводит их к 32-битному формату
torch.float32. Это необходимо, так как параметры слоев нормализации часто требуют более высокой точности, чем int8, для корректной работы в процессе обучения. -
Регистрация хука для включения градиентов на входных данных: Проверяется, есть ли у модели метод
enable_input_require_grads. Если такой метод имеется, он вызывается, что позволяет вычислять градиенты для входных данных. В противном случае регистрируется хукmake_inputs_require_grad, который вручную устанавливаетrequires_grad_(True)для выходных данных в форвардном проходе входных эмбеддингов. -
Модификация слоя выходных эмбеддингов: Проверяется, имеет ли модель атрибут с именем, заданным в
output_embedding_layer_name. Если такой атрибут существует, извлекается соответствующий слой. Далее создается вложенный классCastOutputToFloat, который наследуется отtorch.nn.Sequentialи переопределяет методforwardтак, чтобы выполнить приведение типа результата к 32-битному форматуtorch.float32после выполнения форвард прохода этого слоя. -
Активация чекпоинтирования градиентов: Вызывается метод
gradient_checkpointing_enable, чтобы активировать чекпоинтирование градиентов, что является техникой для оптимизации использования памяти при обучении модели. Градиенты для некоторых промежуточных результатов могут не сохраняться, что снижает потребление памяти за счет небольшого увеличения времени обучения, поскольку необходимо пересчитывать некоторые операции во время обратного прохода. -
Возврат подготовленной модели: Модифицированная модель возвращается из функции для дальнейшего использования.
Функция полезна в сценариях, где требуется уменьшить использование памяти при обучении сложных моделей или использовать квантизацию для ускорения обучения, ссохранив при этом большую часть точности вычислений.
-
- User
Что делает вот эта функция def train( config_file: str, train_file: str, val_file: str, output_dir: str, checkpoint: str = None, sample_rate: float = 1.0, report_to: str = "wandb", seed: int = 42, use_flash_attention_2: bool = False ): set_random_seed(seed) logging.set_verbosity_info() with open(config_file, "r") as r: config = json.load(r)
device_map = "auto" world_size = int(os.environ.get("WORLD_SIZE", 1)) ddp = world_size != 1 deepspeed_config = config.get("deepspeed") trainer_config = config.get("trainer") lora_config = config.get("lora") callbacks = [SavePeftModelCallback] if lora_config else [] training_args = TrainingArguments( output_dir=output_dir, save_total_limit=1, load_best_model_at_end=True, report_to=report_to, ddp_find_unused_parameters=False if ddp else None, deepspeed=deepspeed_config, **trainer_config ) model_name = config["model_name"] tokenizer_name = config.get("tokenizer_name", model_name) use_fast = config.get("use_fast", False) if ddp: device_map = {"": int(os.environ.get("LOCAL_RANK") or 0)} gradient_accumulation_steps = trainer_config["gradient_accumulation_steps"] gradient_accumulation_steps = gradient_accumulation_steps // world_size trainer_config["gradient_accumulation_steps"] = gradient_accumulation_steps tokenizer = AutoTokenizer.from_pretrained(tokenizer_name, use_fast=use_fast) model_config = AutoConfig.from_pretrained(model_name) tokenizer = fix_tokenizer(tokenizer, model_config) tokenizer.save_pretrained(output_dir) train_records = read_jsonl(train_file) val_records = read_jsonl(val_file) random.shuffle(train_records) print(train_records[0]) model_type = config.get("model_type", "causal") templates_path = config["templates_path"] only_target_loss = config.get("only_target_loss", True) mode = config.get("mode", "chat") assert mode == "chat", "Only chat mode is supported in new versions!" assert model_type == "causal", "Only causal models are supported in new versions!" max_tokens_count = config["max_tokens_count"] datasets = [] for records in (train_records, val_records): datasets.append(ChatDataset( records, tokenizer, max_tokens_count=max_tokens_count, sample_rate=sample_rate, templates_path=templates_path, only_target_loss=only_target_loss )) train_dataset, val_dataset = datasets data_collator = DataCollatorForTokenClassification(tokenizer, pad_to_multiple_of=8) print("INPUT_IDS") print(data_collator([train_dataset[0], train_dataset[1]])["input_ids"][0]) print("MASK") print(data_collator([train_dataset[0], train_dataset[1]])["attention_mask"][0]) print("LABELS") print(data_collator([train_dataset[0], train_dataset[1]])["labels"][0]) model_types = { "causal": AutoModelForCausalLM, } load_in_8bit = bool(config.get("load_in_8bit", False)) load_in_4bit = bool(config.get("load_in_4bit", False)) use_bf16 = bool(trainer_config.get("bf16", False)) torch_dtype = torch.bfloat16 if use_bf16 else torch.float16 if load_in_8bit: assert not load_in_4bit model = model_types[model_type].from_pretrained( model_name, load_in_8bit=True, device_map=device_map, torch_dtype=torch_dtype, use_flash_attention_2=use_flash_attention_2 ) model = fix_model(model, tokenizer, use_resize=False) model = custom_prepare_model_for_int8_training(model) elif load_in_4bit: assert not load_in_8bit model = model_types[model_type].from_pretrained( model_name, load_in_4bit=True, device_map=device_map, quantization_config=BitsAndBytesConfig( load_in_4bit=True, llm_int8_threshold=6.0, llm_int8_has_fp16_weight=False, bnb_4bit_compute_dtype=torch_dtype, bnb_4bit_use_double_quant=True, bnb_4bit_quant_type="nf4" ), torch_dtype=torch_dtype, use_flash_attention_2=use_flash_attention_2 ) model = fix_model(model, tokenizer, use_resize=False) model = prepare_model_for_kbit_training(model) else: model = model_types[model_type].from_pretrained( model_name, device_map=device_map, torch_dtype=torch_dtype, use_flash_attention_2=use_flash_attention_2 ) model = fix_model(model, tokenizer, use_resize=False) model = custom_prepare_model_for_int8_training(model) # Default model generation params model.config.num_beams = 5 model.config.max_length = max_tokens_count if not ddp and torch.cuda.device_count() > 1: model.is_parallelizable = True model.model_parallel = True if lora_config: lora_config = LoraConfig(**lora_config) model = get_peft_model(model, lora_config) trainer = TrainerNoBaseSave( model=model, args=training_args, train_dataset=train_dataset, eval_dataset=val_dataset, callbacks=callbacks, data_collator=data_collator ) if trainer_config.get("report_to", "wandb") == "wandb": wandb.init(project="rulm_self_instruct", name=config_file) trainer.train(checkpoint) model.save_pretrained(output_dir) - Assistant
Эта функция
trainпредназначена для настройки и запуска процесса обучения языковой модели. Давайте разберём её по пунктам:-
Начальная установка:
- Устанавливается фиксированный seed для воспроизводимости результатов.
- Уровень логгирования PyTorch устанавливается на информационный.
- Читается файл конфигурации модели и тренировки.
-
Определение параметров для распределенного обучения (DDP):
- Настраиваются параметры для DeepSpeed (если используется) и для распределенного обучения, включая количество устройств и настройки градиентного накопления.
-
Подготовка модели и токенизатора:
- Загружается токенизатор и модель, причём токенизатор может модифицироваться функцией
fix_tokenizer. - Если используется квантизация, модель подготавливается с помощью функции
custom_prepare_model_for_int8_trainingили других подобных функций.
- Загружается токенизатор и модель, причём токенизатор может модифицироваться функцией
-
Обработка данных:
- Читаются обучающие и валидационные данные из файлов в формате JSONL.
- Создаются наборы данных для тренировки и валидации, используя абстракцию
ChatDataset.
-
Настройка DataCollator:
- Создается объект
DataCollatorForTokenClassification, который готовит батчи данных для обучения, выполняя паддинг до определенной длины.
- Создается объект
-
Настройка тренера и обратных вызовов (callbacks):
- Собираются параметры для объекта
TrainingArguments, который определяет поведение и настройки тренера. - Инициализируется объект
TrainerNoBaseSave, а классTrainerCallbackпереопределяется для сохранения модели определенным образом.
- Собираются параметры для объекта
-
Запуск обучения:
- Опционально инициализируется интеграция с Weights & Biases (WandB) для логгирования.
- Запускается тренировка модели с предоставленным чекпоинтом
checkpoint, если он есть. - Сохраняет обученную модель в директорию
output_dir.
Функция обеспечивает богатый и настраиваемый конвейер для обучения моделей с помощью различных опций и улучшений, включая использование чекпоинтов, обработку данных, настройку модели и интеграцию с инструментами вроде DeepSpeed и WandB. Это типичная функция для исследовательских задач машинного обучения и искусственного интеллекта, основанная на возможностях библиотеки
transformersи её экосистемы. -
- User
Зачем нужны эти модули from peft import PeftModel, PeftConfig from transformers import LlamaForCausalLM
- Assistant
Эти модули представляют собой компоненты библиотеки
transformersи потенциально дополнительных библиотек, которые расширяют её функциональность, и служат для работы с моделями трансформеров, а также для их настройки и использования с определёнными конфигурациями.-
PeftModelиPeftConfig:PeftModelиPeftConfigмогут относиться к пользовательскому расширению библиотекиtransformersили отдельной библиотеке, предназначенной для работы с расширенными возможностями моделей, такими как Parameter-Efficient Fine-Tuning (PEFT), что обозначает эффективное дообучение параметров.PeftModelможет использоваться для создания экземпляров моделей, которые поддерживают или делают акцент на эффективном дообучении.PeftConfigпредсталяет собой конфигурационный объект, который содержит настройки, специфичные для данного расширения.Если данная библиотека
peftне является частью стандартной установкиtransformers, возможно, она была разработана сторонними исследователями или инженерами для конкретных экспериментальных целей. -
LlamaForCausalLM:LlamaForCausalLMпредположительно является классом из библиотекиtransformers, предназначенным для работы с моделями языкового моделирования (LM) причинной (Causal) архитектуры. НазваниеLlamaможет указывать на специфическую предобученную модель или вариант Language Model под названием LLaMA.ForCausalLMозначает, что данная модель предназначена для генерации текста в соответствии с принципом причинно-следственной связи: каждое следующее слово генерируется на основе предыдущих слов, без учёта последующего контекста.
Оба модуля важны для задач дообучения и адаптации моделей на новых наборах данных или для новых задач, а также для использования современных технологий обучения нейросетей с учётом их применимости и производительности.
-
- User
что делает вот эта функция def unpermute(w, n_heads, dim): return ( w.view(n_heads, 2, dim // n_heads // 2, dim) .transpose(1, 2) .reshape(dim, dim) )
- Assistant
Функция
unpermuteпредназначена для преобразования тензораw, который представляет собой веса (weights) некоторой матрицы или слоя нейронной сети, обычно в контексте весов внимания или линейного слоя в трансформерах. Данная функция применяется для изменения формы тензора так, чтобы он соответствовал ожидаемой структуре для работы слоя.w— исходный тензор весов.n_heads— количество голов в механизме внимания мультиголовочного трансформера.dim— общая размерность тензора (обычно это размерностьd_modelв трансформерах).Функция выполняет следующие шаги для преобразования формы тензора:
-
Использует метод
.view()для изменения формы тензора в 4-мерный тензор с размерностями (число головn_heads, 2,dim // n_heads // 2,dim). Это преобразование предполагает, что исходные веса организованы подходящим образом для разбиения по головам внимания и подразмерностям внутри каждой головы. -
Второй шаг использует
.transpose()для перестановки второй и третьей осей (оси с индексами 1 и 2). Это преобразование изменяет порядок элементов так, чтобы они соответствовали ожидаемой структуре для дальнейших вычислений механизма внимания. -
Финальный шаг,
.reshape(), используется для преобразования 4-мерного тензора обратно в 2-мерный тензор с размерностью (dim,dim), гдеdim— это общая размерность модели.
Итоговый результат этой функции — 2-мерный тензор весов c размером (
dim,dim), который теперь может быть использован в расчетах нейронной сети, таких как слой внимания в трансформере.Эта функция полезна при работе с мультиголовочным слоем внимания (multi-head attention), где веса разделены на несколько "голов", чтобы модель могла одновременно учиться на разных представлениях информации. Функция
unpermuteпомогает переходить от мультиголовочной структуры к стандартному 2-мерному представлению весов. -
- User
что такое тензор
- Assistant
Тензор – это математический объект, который может быть интерпретирован как обобщение скаляров, векторов и матриц на более высокие размерности. В контексте машинного обучения и научных вычислений тензоры обычно представляются многомерными массивами числовых данных.
В терминологии машинного обучения:
- Тензор с нулевым рангом — это скаляр (одно число).
- Тензор первого ранга — это вектор (массив чисел).
- Тензор второго ранга — это матрица (двумерный массив чисел).
- Тензоры третьего и более высоких рангов представляют собой многомерные массивы.
Тензоры широко используются в таких областях, как глубокое обучение, поскольку они позволяют эффективно представлять и обрабатывать данные с большой размерностью. Например, в глубоком обучении:
- 1D тензоры (векторы) могут использоваться для хранения данных одномерных последовательностей, таких как временные ряды.
- 2D тензоры (матрицы) обычно используются для представления входных данных для полносвязных слоев нейронных сетей.
- 3D тензоры могут представлять данные временных последовательностей для рекуррентных нейронных сетей или данные изображений для сверточных нейронных сетей (каналы изображений х ширина х высота).
- 4D тензоры часто используются для представления пакетов (батчей) изображений, например, набора обучающих примеров (количество образцов х каналы х ширина х высота).
- Тензоры более высоких размерностей могут быть использованы для представления ещё более сложных структур данных.
Библиотеки, такие как TensorFlow и PyTorch, предоставляют специальные инструменты для работы с тензорами, которые включают высокоуровневые операции и автоматическое вычисление градиентов, что делает их основой для построения и обучения нейронных сетей.
- User
Что делает следующая функция def translate_state_dict_key(k): # noqa: C901 k = k.replace('base_model.model.', '') if k == 'model.embed_tokens.weight': return 'tok_embeddings.weight' elif k == 'model.norm.weight': return 'norm.weight' elif k == 'lm_head.weight': return 'output.weight' elif k.startswith('model.layers.'): layer = k.split('.')[2] if k.endswith('.self_attn.q_proj.weight'): return f'layers.{layer}.attention.wq.weight' elif k.endswith('.self_attn.k_proj.weight'): return f'layers.{layer}.attention.wk.weight' elif k.endswith('.self_attn.v_proj.weight'): return f'layers.{layer}.attention.wv.weight' elif k.endswith('.self_attn.o_proj.weight'): return f'layers.{layer}.attention.wo.weight' elif k.endswith('.mlp.gate_proj.weight'): return f'layers.{layer}.feed_forward.w1.weight' elif k.endswith('.mlp.down_proj.weight'): return f'layers.{layer}.feed_forward.w2.weight' elif k.endswith('.mlp.up_proj.weight'): return f'layers.{layer}.feed_forward.w3.weight' elif k.endswith('.input_layernorm.weight'): return f'layers.{layer}.attention_norm.weight' elif k.endswith('.post_attention_layernorm.weight'): return f'layers.{layer}.ffn_norm.weight' elif k.endswith('rotary_emb.inv_freq') or 'lora' in k: return None else: raise NotImplementedError else: raise NotImplementedError
- Assistant
Функция
translate_state_dict_keyпредназначена для преобразования ключей в словаре состояния (state dictionary) модели для машинного обучения. Это часто требуется при загрузке весов из одной модели в другую, когда имена параметров не совпадают, но соответствуют по смыслу.State dictionary в PyTorch – это словарь, где ключи - это строки, соответствующие именам параметров в модели, а значения - тензоры с их весами.
Вот что делает каждая часть кода:
-
Удаляет префикс
'base_model.model.'из имен ключей, возможно, для упрощения и адаптации ключей к структуре новой модели, в которую нужно загрузить параметры. -
Сопоставляет оригинальные названия ключей с новыми названиями, при этом:
'embed_tokens.weight'переименовывается в'tok_embeddings.weight', что указывает на веса эмбеддингов токенов.'norm.weight'остается неизменным, лишь убирается префикс'model.'.'lm_head.weight'переименовывается в'output.weight', подразумевая веса последнего слоя модели.
-
Обрабатывает имена ключей, связанных со слоями модели (
'model.layers.'), выделяя номер слоя и переименовывая веса различных подсетей (attention, feed-forward) в этом слое. Например, веса проекций self-attention'q_proj.weight','k_proj.weight','v_proj.weight'и'o_proj.weight'преобразуются соответственно в'attention.wq.weight','attention.wk.weight','attention.wv.weight'и'attention.wo.weight'. -
При наличии в имени ключа
'rotary_emb.inv_freq'или'lora', возвращаетNone, что может означать исключение этих параметров из загрузки. -
Если встречается имя ключа, которое не удовлетворяет заданным шаблонам, выбрасывает исключение
NotImplementedError.
Функция предназначена для автоматизации процесса миграции параметров из одной структуры модели в другую при определенных условиях и структуре нейросети. Это полезно в случаях, когда веса из предобученных моделей необходимо загрузить в пользовательскую модель для дообучения или адаптации под текущую задачу.
-
- User
Что делает следующая функция def convert_to_native( model_name: str, output_path: str, device: str = "cpu", enable_offloading: bool = False ): assert output_path.endswith(".pt")
config = PeftConfig.from_pretrained(model_name) base_model_path = config.base_model_name_or_path base_model = LlamaForCausalLM.from_pretrained( base_model_path, load_in_8bit=False, torch_dtype=torch.float16, device_map={'': device}, ) lora_model = PeftModel.from_pretrained( base_model, model_name, device_map={'': device}, torch_dtype=torch.float16, ) lora_model = lora_model.merge_and_unload() lora_model.train(False) if '7b' in base_model_path.lower(): n_heads = 32 dim = 4096 elif '13b' in base_model_path.lower(): n_heads = 40 dim = 5120 elif '30b' in base_model_path.lower(): n_heads = 52 dim = 6656 else: raise NotImplementedError lora_model_sd = lora_model.state_dict() del lora_model, base_model total = len(lora_model_sd) with tqdm(list(lora_model_sd.keys())) as progress_bar: for i, k in enumerate(progress_bar): new_k = translate_state_dict_key(k) if new_k is None: continue v = lora_model_sd.pop(k) if 'wq' in new_k or 'wk' in new_k: lora_model_sd[new_k] = unpermute(v, n_heads=n_heads, dim=dim) else: lora_model_sd[new_k] = v if enable_offloading and i <= total // 2: # offload half of all tensors to RAM lora_model_sd[new_k] = lora_model_sd[new_k].cpu() print('Saving state_dict...') torch.save(lora_model_sd, f'{output_path}') - Assistant
Функция
convert_to_nativeпроектирована для конвертации предобученной модели (скорее всего в Hugging Face Transformers с клиентским расширением для PEFT-обучения) в формат, оптимизированный для native PyTorch, позволяя тем самым использовать модель в стандартных инструментах и рабочих процессах PyTorch.Вот что делает эта функция:
-
Проверка правильности пути сохранения файла: Убеждается, что
output_pathзаканчивается на ".pt", что является стандартным расширением для файлов моделей PyTorch. -
Загрузка конфигурации PEFT-модели: Получает конфигурацию модели, специфическую для использования PEFT (Parameter-Efficient Fine-Tuning), используя предобученное имя модели
model_name. -
Загрузка базовой модели LLaMA для причинного моделирования языка (Causal Language Modeling):
LlamaForCausalLMзагружается из переданного пути базовой модели (base_model_path) с заданными параметрами, включая тип данных в памяти и устройство расчета (device). -
Загрузка модели PEFT: Модель PEFT (
PeftModel) инициализируется из базовой модели и конфигурации, после чего обрабатывается и "разгружается" для последующего использования. -
Определение размерностей для конкретных моделей: Размеры голов внимания (
n_heads) и размерности (dim) выбираются на основе спецификации базовой модели (например, 7B, 13B или 30B в имени модели). -
Модификация словаря состояний модели (state dictionary): Стандартный словарь состояний модели обрабатывается, используя функцию
translate_state_dict_keyдля каждого ключа. Отдельные тензоры могут быть преобразованы с помощью функцииunpermute, если это необходимо. -
Опциональное выгрузивание (Offloading): Если включена "выгрузка" (
enable_offloading), половина тензоров выгружается в оперативную память (RAM) для оптимизации использования GPU-памяти. -
Сохранение модифицированного словаря состояний: Модифицированный словарь состояний сохраняется в указанный файл
output_path.
Эта функция полезна для преобразования моделей, использующих параметры PEFT и другие специализированные техники обучения, в формат, который более подходит для native PyTorch, что упрощает интеграцию этих моделей в обширные рабочие процессы, стандартные для PyTorch.
-
- User
Что делает эта функция def infer( model_name: str, input_path: str, output_path: str, n_ctx: int = 2000, top_k: int = 30, top_p: float = 0.9, temperature: float = 0.2, repeat_penalty: float = 1.15, max_new_tokens: Optional[int] = None, ): model = Llama( model_path=model_name, n_ctx=n_ctx, n_parts=1, use_mmap=False, )
records = read_jsonl(input_path) with open(output_path, "w") as w, tqdm(records) as progress_bar: for record in progress_bar: tokens = get_system_tokens(model)[:] tokens.append(LINEBREAK_TOKEN) if "instruction" in record and "messages" not in record: user_message = record["instruction"] if "input" in record and record["input"]: user_message += "\nДано: " + record["input"] record["messages"] = [{ "role": "user", "content": user_message }] for message in record["messages"]: message_tokens = get_message_tokens(model=model, **message) tokens.extend(message_tokens) tokens.append(LINEBREAK_TOKEN) role_tokens = [model.token_bos(), BOT_TOKEN, LINEBREAK_TOKEN] tokens.extend(role_tokens) progress_bar.write(model.detokenize(tokens).decode("utf-8", "ignore")) generator = model.generate( tokens, top_k=top_k, top_p=top_p, temp=temperature, repeat_penalty=repeat_penalty, reset=True, ) completion_tokens = [] for i, token in enumerate(generator): completion_tokens.append(token) if token == model.token_eos() or (max_new_tokens is not None and i >= max_new_tokens): break token_str = model.detokenize([token]).decode("utf-8", "ignore") progress_bar.write(token_str, end="") progress_bar.write('\n\n') record["answer"] = model.detokenize(completion_tokens).decode("utf-8") w.write(json.dumps(record, ensure_ascii=False).strip() + "\n") - Assistant
Функция
inferразработана для вычисления (инференса) модели языковой модели LLaMA (или модели схожего типа), обеспечивая генерацию текста по входным данным. Вот что делает каждый шаг этой функции:-
Инициализация модели: Загружается модель
Llamaс заданными параметрами, включая путь к модели (model_name) и максимальное количество контекстных токенов (n_ctx).n_partsиuse_mmapсвязаны с технической частью загрузки модели, гдеuse_mmap=Falseможет указывать на то, что используется стандартная загрузка в оперативную память вместо использования памяти с маппингом файла (memory-mapped file). -
Чтение входных данных: Входные данные читаются из файла
input_pathв формате JSON Lines. -
Подготовка к записи вывода: Открывается файл
output_pathдля записи результатов и создается объект прогресс-бара (tqdm) для отображения прогресса инференса. -
Обработка каждой записи: По каждой записи в данных:
- Создается начальный список токенов, который включает системные токены и разделитель.
- Если запись содержит инструкцию без диалоговых сообщений, добавляет инструкцию в список токенов.
- Для каждого сообщения в диалоге добавляет соответствующие токены в список.
- Добавляет токены для роли модели (как правило, роль бота).
-
Генерация текста моделью: Инициируется генерация текста моделью с использованием подготовленных токенов и параметров для выбора токенов (
top_k,top_p,temperature,repeat_penalty). Генератор проходит по токенам до тех пор, пока не встретит токен конца строки или не достигнет лимита новых токенов (max_new_tokens), если он задан. -
Запись вывода модели в файл: Текст, сгенерированный моделью, декодируется и подготавливается к записи. После этого результат записывается в файл
output_pathв формате JSON Lines.
В процессе работы функция регистрирует вывод и прогресс операций в прогресс-баре и в итоге сохраняет сгенерированный текст в качестве ответа (
"answer") в файле с результатами. Это позволяет использовать функцию для автоматической обработки больших объемов данных и генерации текста моделью для каждой входной записи. -
- User
Придумай, как можно формально описать, изучение работы с языковыми моделями сайга и лама
- Assistant
Изучение работы с языковыми моделями Saiga и LLaMA (или любыми другими моделями) может быть организовано в несколько этапов. Ниже приведён пример формального описания такого процесса:
Этап 1: Теория и Основы
Цель: Получить базовые знания о языковых моделях и механизме их работы.
Задачи:
- Изучить теоретические основы языковых моделей, включая их архитектуру (например, трансформеры) и принципы работы (например, внимание, эмбеддинги).
- Понять, что такое Saiga и LLaMA, и какие у них есть особенности по сравнению с другими языковыми моделями.
- Ознакомиться с документацией и ресурсами, предоставляемыми сообществом и разработчиками моделей.
Этап 2: Практический Опыт
Цель: Приобрести практический опыт работы с моделями Saiga и LLaMA.
Задачи:
- Установить необходимое программное обеспечение, включая библиотеки для работы с машинным обучением, такие как Hugging Face Transformers, если модели интегрированы в неё.
- Загрузить предобученные модели Saiga и LLaMA, используя доступные инструменты и API.
- Выполнить базовые операции с моделями, такие как токенизация входных данных и генерация текста.
- Написать простые скрипты на Python для интерактивной работы с моделями (например, для ответов на вопросы или выполнения задач на понимание текста).
Этап 3: Расширенный Уровень
Цель: Исследовать продвинутые темы и техники работы с моделями Saiga и LLaMA.
Задачи:
- Изучить методы дообучения (fine-tuning) языковых моделей на специализированных наборах данных.
- Освоить техники оптимизации, позволяющие улучшить производительность и эффективность моделей, например, через квантизацию или pruning (обрезка нейронной сети).
- Работа с возможностями моделей, такими как нулевой и одномерный шот (zero-shot and few-shot learning).
Этап 4: Проектное Применение
Цель: Применить углубленные знания для решения реальной задачи или проекта.
Задачи:
- Выбрать реальную задачу, где использование Saiga и LLaMA может принести пользу (например, разработка чат-ботов, автоматический перевод или анализ текста).
- Подготовить или собрать необходимый датасет для обучения или валидации.
- Адаптировать модели под выбранную задачу, провести fine-tuning и оценить результаты.
- Анализировать результаты, возможно, повторно настроить параметры моделей или обучения для улучшения результатов.
Этап 5: Документирование и Представление Результатов
Цель: Зафиксировать и поделиться знаниями и результатами исследования.
Задачи:
- Составить документацию по проведенной работе, включая описание проблем, методов решения, экспериментов и итогов.
- Подготовить презентацию или публикацию, если это требуется в рамках работ или исследования.
- Дать советы будущим исследователям или разработчикам, основанные на личном опыте работы с моделями.
Таким образом, весь процесс изучения работы с языковыми моделями Saiga и LLaMA предполагает последовательный переход от общего знакомства с теорией до практического применения в реальных проектах с последующим документированием опыта и результатов.
- User
тюнинг модели это
- Assistant
Тюнинг модели (fine-tuning) — это процесс адаптации предварительно обученной модели машинного обучения или глубокого обучения к конкретной задаче или набору данных. В контексте моделей глубокого обучения тюнинг обычно включает дополнительное обучение (дообучение) модели на новых данных с тем, чтобы улучшить её производительность в заданной задаче.
Процесс тюнинга предполагает следующие шаги:
-
Выбор базовой модели: Исходная модель уже имеет веса, обученные на большом наборе данных (например, изображениях или текстах). Это дает ей способность улавливать общие особенности или паттерны.
-
Подготовка данных: Необходимо подготовить данные, специфичные для задачи, на которых будет происходить тюнинг. Данные разделяют на обучающую, валидационную и тестовую выборки.
-
Настройка гиперпараметров: Часто требуется настроить новые гиперпараметры обучения, такие как скорость обучения (learning rate), количество эпох, размер пакета (batch size) и др.
-
Дообучение модели: Модель обучается на новых данных, в результате чего веса сети адаптируются к специфическим особенностям этих данных. При этом могут дообучаться все слои модели или только часть (часто последние слои).
-
Оценка производительности: Используя валидационную и тестовую выборки, оценивается, насколько хорошо модель работает на новой задаче.
Тюнинг может быть как "мягким" (fine-tuning), когда изменяются веса уже существующих слоев модели, так и "жестким" (hard-tuning), когда к модели добавляются новые слои, специализированные под конкретную задачу (например, новый классификационный слой).
Тюнинг позволяет значительно сократить ресурсы и время, необходимые для обучения модели "с нуля",так как модель уже имеет предварительное представление о признаках из большого набора данных и ей требуется только "отточить" эти знания под новую задачу.
-