Skip to content
TheChatArchiveThe Chat Archive
gpt-4-1106-preview· OpenAIAi2 WildChat-4.8M (AI2)

Есть вот такой код outputdir = contentdir / 'output' !cd {selfinstructdir} && python3 -m…

  1. 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:

    В чем может быть проблема?

  2. Assistant

    Ошибка AssertionError говорит о том, что после выполнения команды в ячейке среды исполнения, файл adapter_config.json не обнаружен в директории, указанной в переменной output_dir.

    Вот несколько возможных причин этой ошибки:

    1. Неправильный путь в переменных: Проверьте, что переменные content_dir, self_instruct_dir, config_path и output_dir содержат правильные пути к директориям и файлам. Также убедитесь, что все эти пути валидны в контексте среды, где исполняется код.

    2. Неудачное выполнение скрипта обучения: Скрипт src.train, запускаемый через Python CLI, может завершиться с ошибкой, и в связи с этим файл adapter_config.json не будет создан. После запуска команды рекомендуется проверить логи на наличие ошибок.

    3. Ошибки доступа к файлам: Может возникать ошибка доступа при попытке записи в output_dir. Удостоверьтесь, что среда исполнения имеет права на запись в эту директорию.

    4. Неверные права доступа: Если скрипт запускается на сервере или в контейнере, убедитесь, что окружение, из которого запускается скрипт, имеет соответствующие права для работы с директорией 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 на наличие сообщений об ошибках.

  3. User

    Что это такое? import wandb wandb.login()

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

  5. 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=True requires Accelerate: pip install accelerate and the latest version of bitsandbytes pip install -i https://test.pypi.org/simple/ bitsandbytes or pip install bitsandbytes`

  6. 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 должна исправиться, и вы сможете продолжить выполнение своего кода.

  7. User

    А если установка этих моделей не помогла, все равноо пишет тоже самое

  8. Assistant

    Если вы уже установили требуемые пакеты accelerate и bitsandbytes и все еще получаете ту же ошибку, есть несколько вещей, которые стоит проверить или предпринять:

    1. Перезапустите среду исполнения/интерпретатор Python: В некоторых случаях, особенно когда вы используете интерактивные среды, такие как Jupyter notebooks, новые пакеты могут не быть распознаны до перезапуска интерпретатора. Попробуйте закрыть и перезапустить среду исполнения.

    2. Убедитесь, что используете правильное окружение Python: Если вы используете виртуальное окружение (virtualenv) или систему управления окружениями (например, conda), удостоверьтесь, что вы активировали нужное окружение и что всё установилось именно туда.

    3. Проверьте версию bitsandbytes: Возможно, вам нужна определенная версия пакета bitsandbytes. Попробуйте установить последнюю доступную версию:

      pip install --upgrade bitsandbytes
      
    4. Убедитесь, что у вас последняя версия transformers: Возможно, поддержка параметра load_in_8bit=True была добавлена в новых версиях transformers. Убедитесь, что вы используете последнюю версию:

      pip install --upgrade transformers
      
    5. Проверьте наличие ошибок при установке: При установке bitsandbytes могут возникать ошибки, связанные с операционной системой или зависимостями. Внимательно просмотрите вывод pip во время установки на предмет ошибок.

    6. Прочитайте документацию пакетов: Тщательно изучите документацию библиотеки bitsandbytes и transformers, на предмет каких-либо специальных условий или зависимостей, которые могут повлиять на успешную установку и использование параметра load_in_8bit.

    7. Используйте стандартный PyPI репозиторий для установки: Если проблема остается, попробуйте использовать стандартный пакет bitsandbytes, установленный прямо из PyPI без указания test pypi репозитория:

      pip install bitsandbytes
      

    После выполнения этих шагов попробуйте снова запустить свой код. Если проблема не решается, возможно, стоит обратиться к разработчикам соответствующих библиотек за помощью или подать issue в их репозитории на GitHub с указанием всех деталей и шагов, которые вы уже предприняли.

  9. User

    from tqdm import tqdm что это за библиотека

  10. 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, использование в многопоточных или асинхронных задачах и многое другое.

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

  12. Assistant

    Эта функция has_bad_ss предназначена для проверки списка сообщений messages на наличие в них нежелательных подстрок, определенных в списке BAD_SS. Давайте разберем функцию по шагам:

    1. Функция принимает на вход один параметр messages, который, вероятно, является списком словарей. Каждый словарь в этом списке представляет собой сообщение, где ключ "content" хранит текст сообщения.

    2. В начале функции идет цикл for, который проходит по всем элементам списка messages.

    3. Для каждого сообщения m в списке извлекается значение поля "content", которое затем приводится к нижнему регистру методом .lower(). Это делается для того, чтобы поиск подстроки был нечувствителен к регистру символов.

    4. Внутри цикла есть условная конструкция if any(...), которая проверяет, содержит ли текст сообщения хотя бы одну из нежелательных подстрок, перечисленных в списке BAD_SS.

    5. Если в тексте сообщения обнаруживается нежелательная подстрока (ss in text), функция немедленно возвращает True, что означает наличие "плохой" подстроки в одном из сообщений.

    6. Если после проверки всех сообщений ни одно из них не содержит нежелательных подстрок, то выполняется завершающий return False, возвращающий значение False, что означает отсутствие "плохих" подстрок во всех сообщениях.

    Пример использования такой функции мог бы выглядеть так:

    BAD_SS = ["плохое слово", "запрещенный термин"]
    
    messages = [
        {"content": "Это пример хорошего сообщения."},
        {"content": "Это сообщение содержит плохое слово."},
    ]
    
    if has_bad_ss(messages):
        print("Найдено сообщение с нежелательным содержимым.")
    else:
        print("Все сообщения соответствуют стандартам.")
    

    В этом конкретном примере функция has_bad_ss вернет True, так как во втором сообщении списка messages содержится подстрока "плохое слово", которая присутствует в списке BAD_SS.

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

  14. Assistant

    Эта функция revert_flattening преобразует словарь со списками значений в список словарей. Функция рассчитывает на то, что значения в переданном словаре records организованы так, что каждому ключу соответствует список значений. Количество элементов в каждом из этих списков должно быть одинаковым, чтобы результат был корректным.

    Давайте рассмотрим по шагам, что делает эта функция:

    1. fixed_records инициализируется как пустой список. Это список, который будет содержать итоговые словари.

    2. Цикл for key, values in records.items(): проходит по всем ключам и значениям входного словаря records. key – это ключ в records, values – это список значений, ассоциированных с этим ключом.

    3. При первой итерации цикла, если fixed_records ещё пустой, создаётся список пустых словарей. Количество этих словарей соответствует длине списка values. Это делается для того, чтобы подготовить структуру данных, в которую будут вставлены значения.

    4. Во внутреннем цикле for i, value in enumerate(values):, каждое значение из списка присваивается соответствующему пустому словарю в fixed_records, используя индекс i для нахождения соответствующего словаря и ключ key для назначения значения.

    5. После выполнения всех итераций, 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 – это словарь, который представляет отдельную запись, собранную из оригинального словаря, где списки значений были "развернуты" обратно в отдельные записи.

  15. User

    Что делает вот эта функция def calc_max_length(records): return max([sum([len(m["content"]) for m in r["messages"]]) for r in records])

  16. Assistant

    Функция calc_max_length предназначена для нахождения максимальной суммарной длины текстов сообщений в списке записей records. Каждая запись в этом списке предполагается быть словарём, имеющим ключ "messages", который ассоциируется со списком сообщений. Каждое сообщение в свою очередь тоже является словарём, где по ключу "content" можно получить его текстовое содержимое.

    Давайте разберём функцию по шагам:

    1. Внешний генератор списков ([ ... for r in records]) итерируется по всем записям в списке records.

    2. Для каждой записи r в этом списке берётся значение по ключу "messages", которое представляет собой список сообщений.

    3. Во внутреннем генераторе списков ([len(m["content"]) for m in r["messages"]]) для каждого сообщения m в списке сообщений рассчитывается длина его текстового содержимого (полученного по ключу "content"), то есть количество символов в тексте.

    4. Затем функция sum считает суммарную длину всех текстов сообщений в рамках одной записи – то есть складывает длины всех сообщений, находящихся в r["messages"].

    5. После того как для каждой записи 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.
    

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

  17. 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
    
  18. Assistant

    Функция build_char_system_messages создает системные сообщения для персонажа на основе предоставленной информации.

    В теле функции происходят следующие действия:

    1. Из словаря char, который передается в функцию в качестве аргумента, извлекаются данные персонажа: его имя (name), приветствие (greeting), а также пример диалога (example_dialogue).

    2. Создается пустая строка context, которая будет служить основой для системного сообщения.

    3. С помощью функции random.random() выполняется случайная выборка, чтобы с вероятностью 50% добавить сообщение в context, в котором упоминается имя персонажа (например, "Ты [имя_персонажа].").

    4. Далее, непосредственно к context добавляется информация из char['context'].

    5. Создается пустой список chat, который будет содержать системные сообщения.

    6. Снова используется random.random() для выполнения случайной выборки с вероятностью 20%, и если условие выполняется, в context добавляется указание приветствия (greeting), а в список chat добавляется словарь с приветственным сообщением от бота (в role указывается "bot", в content - приветствие).

    7. Далее, еще раз выполняется случайная выборка с тем же условием вероятности. Если оно выполняется, то создается строка с примером диалога, где для каждого сообщения в example_dialogue указывается роль (пользователь или персонаж) и текст сообщения. Этот пример диалога добавляется в context.

    8. Добавляется системное сообщение (с role "system") в начало списка chat, в котором содержится контекст (информация о персонаже, приветствие, пример диалога).

    9. Функция возвращает список 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 с системными сообщениями, которые могут содержать ту или иную информацию о персонаже в зависимости от случайной выборки.

  19. User

    А что выведется?

  20. Assistant

    Точный вывод будет зависеть от случайных значений, сгенерированных функцией random.random(), так как в приведенном коде есть три условия, влияющие на содержание системных сообщений, каждое из которых основано на рандомизированном выборе:

    1. Имя персонажа добавляется в context с вероятностью 50%.
    2. Приветствие добавляется в context и chat с вероятностью 20%.
    3. Пример диалога добавляется в 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) будет одним из таких вариантов или каким-то другим в соответствии с случайно сгенерированными значениями.

  21. 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")
    
  22. Assistant

    Этот код выполняет несколько шагов для загрузки, обработки и разбиения датасетов на обучающую (train) и валидационную (val) выборки.

    По шагам выполнение этого кода выглядит следующим образом:

    1. Устанавливается фиксированный seed для генератора случайных чисел random для воспроизводимости результатов.

    2. Загружаются и обрабатываются данные из различных источников датасетов (например, "lksy/ru_instruct_gpt4", "IlyaGusev/ru_turbo_saiga", и другие), которые касаются, вероятно, диалоговых систем, где участники взаимодействуют друг с другом, выполняя роли пользователей (user), ботов (bot) и систем (system).

    3. В каждом датасете итерационно обрабатываются записи (row), причём каждая запись подвергается условиям фильтрации, например:

      • Отсекание записей с вероятностью 30% или 50% (в зависимости от случая).
      • Проверка записей на наличие нежелательных подстрок (has_bad_ss функция).
      • Проверка содержания записей на определенные условия (например, имя модели).
    4. Для некоторых датасетов проверяется и обрезается длина контента сообщений так, чтобы она не превышала 10000 символов.

    5. К диалогам из датасета "IlyaGusev/gpt_roleplay_realm" добавляются системные сообщения в начало каждого диалога с помощью функции build_char_system_messages.

    6. Выполняется стандартизация ролей в диалогах, чтобы они соответствовали стандартному набору ("bot", "user", "system").

    7. После обработки всех датасетов их рекорды объединяются в один большой список records.

    8. Выполняется финальная фильтрация records, удаляя пустые сообщения и сообщения, содержащие нежелательные подстроки.

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

    10. Происходит разбиение всего списка на обучающую и валидационную выборки в соотношении 95% к 5% (или любом другом, определённом пользователем).

    11. Результаты записываются в файлы с путями train_path и val_path.

    Этот код предназначен для создания обучающего и валидационного наборов данных для последующего обучения или оценки диалоговой модели. Он демонстрирует, как собирать и объединять разнообразные данные, проводить их предварительную обработку и подготовку для машинного обучения.

  23. User

    что такое формат .jsonl и чем он отличается от json

  24. 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:

    1. Построчное чтение: Данные могут читаться по одной записи за раз, что удобно для больших наборов данных, поскольку не требуется загружать в память весь файл целиком.

    2. Удобство добавления: При добавлении новых данных достаточно записать их в новую строку файла, в то время как для стандартного JSON потребуется перезагрузка и полная перезапись файла.

    3. Потоковая обработка: Формат .jsonl позволяет обрабатывать данные потоково, что эффективно для операций в реальном времени и для больших наборов данных, где файлы слишком велики, чтобы считываться в память полностью.

    4. Упрощение парсинга: Каждая строка .jsonl файла является валидным JSON объектом, поэтому её можно парсить независимо от остальных, что облегчает парсинг и обработку ошибок.

    Формат .jsonl часто используется в задачах машинного обучения для хранения тренировочных данных, в логировании, где каждое событие представляется отдельным JSON объектом, и в других сценариях, где требуется удобная последовательная обработка больших объемов структурированных данных.

  25. User

    from huggingface_hub import snapshot_download что это за библиотека и модуль

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

  27. 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)
    
  28. Assistant

    Код, описанный выше, делает следующее:

    1. Задается папка model_dir, которая является целевым местоположением для скачивания предобученной модели, и идентификатор базовой модели base_model из Hugging Face Hub.

    2. Используя функцию snapshot_download из библиотеки huggingface_hub, код скачивает файлы модели из репозитория с репозиторием base_model в локальную папку model_dir. Во время скачивания игнорируются файлы лицензии, README и git атрибуты.

    3. Устанавливается булева переменная patch_model_config для определения, требуется ли изменить конфигурационные файлы модели (по умолчанию True, что означает необходимость внесения изменений). Если переменная patch_model_config установлена в True, код применяет следующие шаги:

    4. Определяется словарь замен replacements, который содержит новые параметры для файлов tokenizer_config.json и special_tokens_map.json.

    5. Следующий цикл for перебирает файлы конфигурации в указанной локальной папке model_dir и загружает текущее содержание, сравнивая его с новым содержанием, заданным в replacements. Если он обнаруживает, что файл уже содержит требуемые изменения, он не изменяет этот файл. В противном случае, код перезаписывает файл с новыми значениями из replacements.

    6. Замена параметров в файлах конфигурации заключается в том, что задается класс токенизатора, максимальная длина модели, сторона добавления паддинга (заполнения), специальные токены, а также другие настройки токенизатора и маппинга специальных токенов.

    Эта процедура используется для того, чтобы конфигурация модели соответствовала требованиям пользователя или условиям эксперимента, в котором модель будет использоваться. Такие изменения могут быть необходимы в случае, когда вы хотите использовать модель с другим токенизатором или когда предоставленная к модели конфигурация должна быть адаптирована для конкретной задачи.

  29. 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()

  30. Assistant

    Этот код выполняется в среде командной строки Unix/Linux (например, в терминале или Jupyter Notebook с префиксом !), и он состоит из двух частей: команды для обучения модели машинного обучения с использованием Python и проверки после такого обучения.

    1. Команда для обучения модели:

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

    2. Утверждение (assertion):

      assert (output_dir / 'adapter_config.json').exists()
      

      После выполнения обучения код выполняет утверждение, проверяющее, существует ли файл adapter_config.json в директории output_dir. Если утверждение выполняется (файл существует), выполнение кода продолжается. В противном случае возникает исключение AssertionError, указывающее на отсутствие файла, что может свидетельствовать о возникшей ошибке при обучении модели или при сохранении конфигурации адаптера.

      Этот файл, adapter_config.json, видимо, является частью вывода обучения и может содержать параметры, которые указывают на то, как была сконфигурирована или настроена модель в процессе обучения.

    Код использует фигурные скобки {} для подстановки строковых переменных, что типично для Python f-строк или метода .format(). Однако, в данном случае это работает благодаря среде Jupyter Notebook, которая автоматически заменяет значения перед выполнением команды в командной строке.

  31. 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)
    
  32. Assistant

    Этот класс TrainerNoBaseSave является наследником класса Trainer из библиотеки transformers Hugging Face и предназначен для переопределения стандартного поведения сохранения чекпоинтов (состояний) модели во время процесса обучения.

    Давайте разберем, для чего может быть нужно переопределение метода _save_checkpoint в данном наследуемом классе:

    1. Отложенное выполнение: Возможно, сохранение чекпоинтов нативным образом (по умолчанию) занимает много времени или пространства, и разработчик желает изменить способ или момент времени сохранения.

    2. Настройка сохранения: Может быть необходимо сохранять чекпоинты модели в определенной схеме именования или выбирать местоположение сохранения на основании метрик.

    3. Экономия ресурсов: Чтобы экономить дисковое пространство или вычислительные ресурсы, можно изменить логику, чтобы сохранять только определенные чекпоинты (например, содержащие наилучшие результаты).

    4. Контроль лучшей модели: В приведенном коде внутренняя логика сравнивает метрику текущего чекпоинта с лучшей метрикой, чтобы определить, следует ли обновить информацию о "лучшей" модели.

    Конкретно в коде происходят следующие действия:

    • В функции _save_checkpoint текст "Running custom _save_checkpoint" выводится на экран для индикации использования переопределенного метода.
    • Определяется путь к папке чекпоинта output_dir, комбинируя директорию запуска run_dir, префикс PREFIX_CHECKPOINT_DIR и шаг глобального состояния.
    • Если метрики доступны и задан metric_for_best_model, то код проверяет, является ли текущая метрика лучше предыдущей записанной, и если да, обновляет информацию о лучшем чекпоинте.
    • Создается директория чекпоинта с помощью os.makedirs.
    • Если установлен флаг should_save, вызывается метод _rotate_checkpoints, который управляет количеством сохраняемых чекпоинтов, предотвращая переполнение дискового пространства.

    Использование класса позволяет управлять процессом сохранения модели в соответствии с потребностями конкретного эксперимента или требованиями инфраструктуры.

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

  34. Assistant

    Класс SavePeftModelCallback представляет собой пользовательский обратный вызов (callback), который интегрируется с тренировочным циклом, предоставляемым классом Trainer в библиотеке transformers от Hugging Face. Он наследуется от базового класса обратных вызовов TrainerCallback. Цель этого класса — сохранять предварительно обученную модель на определенных этапах процесса обучения.

    Метод on_save вызывается, когда тренер (Trainer) сохраняет чекпоинт. В этом методе реализованны следующие действия:

    1. Определяется путь до папки чекпоинта checkpoint_folder на основе аргументов обучения args.output_dir и шаблона имени директории чекпоинта, который включает шаг глобального состояния state.global_step.

    2. Полученный путь checkpoint_folder используется для сохранения текущей модели с помощью метода save_pretrained модели, которая передается в kwargs (словарь с ключевыми аргументами, переданными в метод обратного вызова).

    3. Возвращается экземпляр TrainerControl, который может быть использован для управления поведением цикла обучения (например, можно было бы передать сигнал об остановке обучения).

    Применение пользовательского обратного вызова позволяет внедрить специфические для конкретной задачи операции сохранения модели в процесс обучения. Например, такой подход полезен в случаях, когда вам нужно сохранять модель в нестандартном формате имени файла или вам необходимо дополнительно сохранять другие артефакты во время чекпоинта.

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

    Чтобы этот обратный вызов заработал, его необходимо передать экземпляру Trainer в параметре callbacks при его инициализации.

  35. 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
    
  36. Assistant

    Эта функция custom_prepare_model_for_int8_training предназначена для подготовки модели нейронных сетей, основанных на PyTorch, к обучению с использованием 8-битной целочисленной числовой точности (int8, также известной как квантизация). Вот детальный разбор её действий:

    1. Отключение обучения всех параметров модели: Первый цикл обходит все параметры модели, устанавливая requires_grad в False для каждого параметра. Это говорит о том, что градиенты для этих параметров не будут вычисляться во время обратного прохода, что явно свидетельствует о намерении фиксировать веса этих слоев во время обучения.

    2. Перевод параметров слоёв нормализации в 32-битное float представление: Второй цикл ещё раз обходит все параметры модели и проверяет, нормализуются ли параметры этого слоя (обычно это гамма и бета в BatchNorm слоях), и если это так, приводит их к 32-битному формату torch.float32. Это необходимо, так как параметры слоев нормализации часто требуют более высокой точности, чем int8, для корректной работы в процессе обучения.

    3. Регистрация хука для включения градиентов на входных данных: Проверяется, есть ли у модели метод enable_input_require_grads. Если такой метод имеется, он вызывается, что позволяет вычислять градиенты для входных данных. В противном случае регистрируется хук make_inputs_require_grad, который вручную устанавливает requires_grad_(True) для выходных данных в форвардном проходе входных эмбеддингов.

    4. Модификация слоя выходных эмбеддингов: Проверяется, имеет ли модель атрибут с именем, заданным в output_embedding_layer_name. Если такой атрибут существует, извлекается соответствующий слой. Далее создается вложенный класс CastOutputToFloat, который наследуется от torch.nn.Sequential и переопределяет метод forward так, чтобы выполнить приведение типа результата к 32-битному формату torch.float32 после выполнения форвард прохода этого слоя.

    5. Активация чекпоинтирования градиентов: Вызывается метод gradient_checkpointing_enable, чтобы активировать чекпоинтирование градиентов, что является техникой для оптимизации использования памяти при обучении модели. Градиенты для некоторых промежуточных результатов могут не сохраняться, что снижает потребление памяти за счет небольшого увеличения времени обучения, поскольку необходимо пересчитывать некоторые операции во время обратного прохода.

    6. Возврат подготовленной модели: Модифицированная модель возвращается из функции для дальнейшего использования.

    Функция полезна в сценариях, где требуется уменьшить использование памяти при обучении сложных моделей или использовать квантизацию для ускорения обучения, ссохранив при этом большую часть точности вычислений.

  37. 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)
    
  38. Assistant

    Эта функция train предназначена для настройки и запуска процесса обучения языковой модели. Давайте разберём её по пунктам:

    1. Начальная установка:

      • Устанавливается фиксированный seed для воспроизводимости результатов.
      • Уровень логгирования PyTorch устанавливается на информационный.
      • Читается файл конфигурации модели и тренировки.
    2. Определение параметров для распределенного обучения (DDP):

      • Настраиваются параметры для DeepSpeed (если используется) и для распределенного обучения, включая количество устройств и настройки градиентного накопления.
    3. Подготовка модели и токенизатора:

      • Загружается токенизатор и модель, причём токенизатор может модифицироваться функцией fix_tokenizer.
      • Если используется квантизация, модель подготавливается с помощью функции custom_prepare_model_for_int8_training или других подобных функций.
    4. Обработка данных:

      • Читаются обучающие и валидационные данные из файлов в формате JSONL.
      • Создаются наборы данных для тренировки и валидации, используя абстракцию ChatDataset.
    5. Настройка DataCollator:

      • Создается объект DataCollatorForTokenClassification, который готовит батчи данных для обучения, выполняя паддинг до определенной длины.
    6. Настройка тренера и обратных вызовов (callbacks):

      • Собираются параметры для объекта TrainingArguments, который определяет поведение и настройки тренера.
      • Инициализируется объект TrainerNoBaseSave, а класс TrainerCallback переопределяется для сохранения модели определенным образом.
    7. Запуск обучения:

      • Опционально инициализируется интеграция с Weights & Biases (WandB) для логгирования.
      • Запускается тренировка модели с предоставленным чекпоинтом checkpoint, если он есть.
      • Сохраняет обученную модель в директорию output_dir.

    Функция обеспечивает богатый и настраиваемый конвейер для обучения моделей с помощью различных опций и улучшений, включая использование чекпоинтов, обработку данных, настройку модели и интеграцию с инструментами вроде DeepSpeed и WandB. Это типичная функция для исследовательских задач машинного обучения и искусственного интеллекта, основанная на возможностях библиотеки transformers и её экосистемы.

  39. User

    Зачем нужны эти модули from peft import PeftModel, PeftConfig from transformers import LlamaForCausalLM

  40. Assistant

    Эти модули представляют собой компоненты библиотеки transformers и потенциально дополнительных библиотек, которые расширяют её функциональность, и служат для работы с моделями трансформеров, а также для их настройки и использования с определёнными конфигурациями.

    1. PeftModel и PeftConfig: PeftModel и PeftConfig могут относиться к пользовательскому расширению библиотеки transformers или отдельной библиотеке, предназначенной для работы с расширенными возможностями моделей, такими как Parameter-Efficient Fine-Tuning (PEFT), что обозначает эффективное дообучение параметров. PeftModel может использоваться для создания экземпляров моделей, которые поддерживают или делают акцент на эффективном дообучении. PeftConfig предсталяет собой конфигурационный объект, который содержит настройки, специфичные для данного расширения.

      Если данная библиотека peft не является частью стандартной установки transformers, возможно, она была разработана сторонними исследователями или инженерами для конкретных экспериментальных целей.

    2. LlamaForCausalLM: LlamaForCausalLM предположительно является классом из библиотеки transformers, предназначенным для работы с моделями языкового моделирования (LM) причинной (Causal) архитектуры. Название Llama может указывать на специфическую предобученную модель или вариант Language Model под названием LLaMA. ForCausalLM означает, что данная модель предназначена для генерации текста в соответствии с принципом причинно-следственной связи: каждое следующее слово генерируется на основе предыдущих слов, без учёта последующего контекста.

    Оба модуля важны для задач дообучения и адаптации моделей на новых наборах данных или для новых задач, а также для использования современных технологий обучения нейросетей с учётом их применимости и производительности.

  41. User

    что делает вот эта функция def unpermute(w, n_heads, dim): return ( w.view(n_heads, 2, dim // n_heads // 2, dim) .transpose(1, 2) .reshape(dim, dim) )

  42. Assistant

    Функция unpermute предназначена для преобразования тензора w, который представляет собой веса (weights) некоторой матрицы или слоя нейронной сети, обычно в контексте весов внимания или линейного слоя в трансформерах. Данная функция применяется для изменения формы тензора так, чтобы он соответствовал ожидаемой структуре для работы слоя.

    w — исходный тензор весов. n_heads — количество голов в механизме внимания мультиголовочного трансформера. dim — общая размерность тензора (обычно это размерность d_model в трансформерах).

    Функция выполняет следующие шаги для преобразования формы тензора:

    1. Использует метод .view() для изменения формы тензора в 4-мерный тензор с размерностями (число голов n_heads, 2, dim // n_heads // 2, dim). Это преобразование предполагает, что исходные веса организованы подходящим образом для разбиения по головам внимания и подразмерностям внутри каждой головы.

    2. Второй шаг использует .transpose() для перестановки второй и третьей осей (оси с индексами 1 и 2). Это преобразование изменяет порядок элементов так, чтобы они соответствовали ожидаемой структуре для дальнейших вычислений механизма внимания.

    3. Финальный шаг, .reshape(), используется для преобразования 4-мерного тензора обратно в 2-мерный тензор с размерностью (dim, dim), где dim — это общая размерность модели.

    Итоговый результат этой функции — 2-мерный тензор весов c размером (dim, dim), который теперь может быть использован в расчетах нейронной сети, таких как слой внимания в трансформере.

    Эта функция полезна при работе с мультиголовочным слоем внимания (multi-head attention), где веса разделены на несколько "голов", чтобы модель могла одновременно учиться на разных представлениях информации. Функция unpermute помогает переходить от мультиголовочной структуры к стандартному 2-мерному представлению весов.

  43. User

    что такое тензор

  44. Assistant

    Тензор – это математический объект, который может быть интерпретирован как обобщение скаляров, векторов и матриц на более высокие размерности. В контексте машинного обучения и научных вычислений тензоры обычно представляются многомерными массивами числовых данных.

    В терминологии машинного обучения:

    • Тензор с нулевым рангом — это скаляр (одно число).
    • Тензор первого ранга — это вектор (массив чисел).
    • Тензор второго ранга — это матрица (двумерный массив чисел).
    • Тензоры третьего и более высоких рангов представляют собой многомерные массивы.

    Тензоры широко используются в таких областях, как глубокое обучение, поскольку они позволяют эффективно представлять и обрабатывать данные с большой размерностью. Например, в глубоком обучении:

    • 1D тензоры (векторы) могут использоваться для хранения данных одномерных последовательностей, таких как временные ряды.
    • 2D тензоры (матрицы) обычно используются для представления входных данных для полносвязных слоев нейронных сетей.
    • 3D тензоры могут представлять данные временных последовательностей для рекуррентных нейронных сетей или данные изображений для сверточных нейронных сетей (каналы изображений х ширина х высота).
    • 4D тензоры часто используются для представления пакетов (батчей) изображений, например, набора обучающих примеров (количество образцов х каналы х ширина х высота).
    • Тензоры более высоких размерностей могут быть использованы для представления ещё более сложных структур данных.

    Библиотеки, такие как TensorFlow и PyTorch, предоставляют специальные инструменты для работы с тензорами, которые включают высокоуровневые операции и автоматическое вычисление градиентов, что делает их основой для построения и обучения нейронных сетей.

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

  46. Assistant

    Функция translate_state_dict_key предназначена для преобразования ключей в словаре состояния (state dictionary) модели для машинного обучения. Это часто требуется при загрузке весов из одной модели в другую, когда имена параметров не совпадают, но соответствуют по смыслу.

    State dictionary в PyTorch – это словарь, где ключи - это строки, соответствующие именам параметров в модели, а значения - тензоры с их весами.

    Вот что делает каждая часть кода:

    1. Удаляет префикс 'base_model.model.' из имен ключей, возможно, для упрощения и адаптации ключей к структуре новой модели, в которую нужно загрузить параметры.

    2. Сопоставляет оригинальные названия ключей с новыми названиями, при этом:

      • 'embed_tokens.weight' переименовывается в 'tok_embeddings.weight', что указывает на веса эмбеддингов токенов.
      • 'norm.weight' остается неизменным, лишь убирается префикс 'model.'.
      • 'lm_head.weight' переименовывается в 'output.weight', подразумевая веса последнего слоя модели.
    3. Обрабатывает имена ключей, связанных со слоями модели ('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'.

    4. При наличии в имени ключа 'rotary_emb.inv_freq' или 'lora', возвращает None, что может означать исключение этих параметров из загрузки.

    5. Если встречается имя ключа, которое не удовлетворяет заданным шаблонам, выбрасывает исключение NotImplementedError.

    Функция предназначена для автоматизации процесса миграции параметров из одной структуры модели в другую при определенных условиях и структуре нейросети. Это полезно в случаях, когда веса из предобученных моделей необходимо загрузить в пользовательскую модель для дообучения или адаптации под текущую задачу.

  47. 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}')
    
  48. Assistant

    Функция convert_to_native проектирована для конвертации предобученной модели (скорее всего в Hugging Face Transformers с клиентским расширением для PEFT-обучения) в формат, оптимизированный для native PyTorch, позволяя тем самым использовать модель в стандартных инструментах и рабочих процессах PyTorch.

    Вот что делает эта функция:

    1. Проверка правильности пути сохранения файла: Убеждается, что output_path заканчивается на ".pt", что является стандартным расширением для файлов моделей PyTorch.

    2. Загрузка конфигурации PEFT-модели: Получает конфигурацию модели, специфическую для использования PEFT (Parameter-Efficient Fine-Tuning), используя предобученное имя модели model_name.

    3. Загрузка базовой модели LLaMA для причинного моделирования языка (Causal Language Modeling): LlamaForCausalLM загружается из переданного пути базовой модели (base_model_path) с заданными параметрами, включая тип данных в памяти и устройство расчета (device).

    4. Загрузка модели PEFT: Модель PEFT (PeftModel) инициализируется из базовой модели и конфигурации, после чего обрабатывается и "разгружается" для последующего использования.

    5. Определение размерностей для конкретных моделей: Размеры голов внимания (n_heads) и размерности (dim) выбираются на основе спецификации базовой модели (например, 7B, 13B или 30B в имени модели).

    6. Модификация словаря состояний модели (state dictionary): Стандартный словарь состояний модели обрабатывается, используя функцию translate_state_dict_key для каждого ключа. Отдельные тензоры могут быть преобразованы с помощью функции unpermute, если это необходимо.

    7. Опциональное выгрузивание (Offloading): Если включена "выгрузка" (enable_offloading), половина тензоров выгружается в оперативную память (RAM) для оптимизации использования GPU-памяти.

    8. Сохранение модифицированного словаря состояний: Модифицированный словарь состояний сохраняется в указанный файл output_path.

    Эта функция полезна для преобразования моделей, использующих параметры PEFT и другие специализированные техники обучения, в формат, который более подходит для native PyTorch, что упрощает интеграцию этих моделей в обширные рабочие процессы, стандартные для PyTorch.

  49. 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")
    
  50. Assistant

    Функция infer разработана для вычисления (инференса) модели языковой модели LLaMA (или модели схожего типа), обеспечивая генерацию текста по входным данным. Вот что делает каждый шаг этой функции:

    1. Инициализация модели: Загружается модель Llama с заданными параметрами, включая путь к модели (model_name) и максимальное количество контекстных токенов (n_ctx). n_parts и use_mmap связаны с технической частью загрузки модели, где use_mmap=False может указывать на то, что используется стандартная загрузка в оперативную память вместо использования памяти с маппингом файла (memory-mapped file).

    2. Чтение входных данных: Входные данные читаются из файла input_path в формате JSON Lines.

    3. Подготовка к записи вывода: Открывается файл output_path для записи результатов и создается объект прогресс-бара (tqdm) для отображения прогресса инференса.

    4. Обработка каждой записи: По каждой записи в данных:

      • Создается начальный список токенов, который включает системные токены и разделитель.
      • Если запись содержит инструкцию без диалоговых сообщений, добавляет инструкцию в список токенов.
      • Для каждого сообщения в диалоге добавляет соответствующие токены в список.
      • Добавляет токены для роли модели (как правило, роль бота).
    5. Генерация текста моделью: Инициируется генерация текста моделью с использованием подготовленных токенов и параметров для выбора токенов (top_k, top_p, temperature, repeat_penalty). Генератор проходит по токенам до тех пор, пока не встретит токен конца строки или не достигнет лимита новых токенов (max_new_tokens), если он задан.

    6. Запись вывода модели в файл: Текст, сгенерированный моделью, декодируется и подготавливается к записи. После этого результат записывается в файл output_path в формате JSON Lines.

    В процессе работы функция регистрирует вывод и прогресс операций в прогресс-баре и в итоге сохраняет сгенерированный текст в качестве ответа ("answer") в файле с результатами. Это позволяет использовать функцию для автоматической обработки больших объемов данных и генерации текста моделью для каждой входной записи.

  51. User

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

  52. Assistant

    Изучение работы с языковыми моделями Saiga и LLaMA (или любыми другими моделями) может быть организовано в несколько этапов. Ниже приведён пример формального описания такого процесса:

    Этап 1: Теория и Основы

    Цель: Получить базовые знания о языковых моделях и механизме их работы.

    Задачи:

    1. Изучить теоретические основы языковых моделей, включая их архитектуру (например, трансформеры) и принципы работы (например, внимание, эмбеддинги).
    2. Понять, что такое Saiga и LLaMA, и какие у них есть особенности по сравнению с другими языковыми моделями.
    3. Ознакомиться с документацией и ресурсами, предоставляемыми сообществом и разработчиками моделей.

    Этап 2: Практический Опыт

    Цель: Приобрести практический опыт работы с моделями Saiga и LLaMA.

    Задачи:

    1. Установить необходимое программное обеспечение, включая библиотеки для работы с машинным обучением, такие как Hugging Face Transformers, если модели интегрированы в неё.
    2. Загрузить предобученные модели Saiga и LLaMA, используя доступные инструменты и API.
    3. Выполнить базовые операции с моделями, такие как токенизация входных данных и генерация текста.
    4. Написать простые скрипты на Python для интерактивной работы с моделями (например, для ответов на вопросы или выполнения задач на понимание текста).

    Этап 3: Расширенный Уровень

    Цель: Исследовать продвинутые темы и техники работы с моделями Saiga и LLaMA.

    Задачи:

    1. Изучить методы дообучения (fine-tuning) языковых моделей на специализированных наборах данных.
    2. Освоить техники оптимизации, позволяющие улучшить производительность и эффективность моделей, например, через квантизацию или pruning (обрезка нейронной сети).
    3. Работа с возможностями моделей, такими как нулевой и одномерный шот (zero-shot and few-shot learning).

    Этап 4: Проектное Применение

    Цель: Применить углубленные знания для решения реальной задачи или проекта.

    Задачи:

    1. Выбрать реальную задачу, где использование Saiga и LLaMA может принести пользу (например, разработка чат-ботов, автоматический перевод или анализ текста).
    2. Подготовить или собрать необходимый датасет для обучения или валидации.
    3. Адаптировать модели под выбранную задачу, провести fine-tuning и оценить результаты.
    4. Анализировать результаты, возможно, повторно настроить параметры моделей или обучения для улучшения результатов.

    Этап 5: Документирование и Представление Результатов

    Цель: Зафиксировать и поделиться знаниями и результатами исследования.

    Задачи:

    1. Составить документацию по проведенной работе, включая описание проблем, методов решения, экспериментов и итогов.
    2. Подготовить презентацию или публикацию, если это требуется в рамках работ или исследования.
    3. Дать советы будущим исследователям или разработчикам, основанные на личном опыте работы с моделями.

    Таким образом, весь процесс изучения работы с языковыми моделями Saiga и LLaMA предполагает последовательный переход от общего знакомства с теорией до практического применения в реальных проектах с последующим документированием опыта и результатов.

  53. User

    тюнинг модели это

  54. Assistant

    Тюнинг модели (fine-tuning) — это процесс адаптации предварительно обученной модели машинного обучения или глубокого обучения к конкретной задаче или набору данных. В контексте моделей глубокого обучения тюнинг обычно включает дополнительное обучение (дообучение) модели на новых данных с тем, чтобы улучшить её производительность в заданной задаче.

    Процесс тюнинга предполагает следующие шаги:

    1. Выбор базовой модели: Исходная модель уже имеет веса, обученные на большом наборе данных (например, изображениях или текстах). Это дает ей способность улавливать общие особенности или паттерны.

    2. Подготовка данных: Необходимо подготовить данные, специфичные для задачи, на которых будет происходить тюнинг. Данные разделяют на обучающую, валидационную и тестовую выборки.

    3. Настройка гиперпараметров: Часто требуется настроить новые гиперпараметры обучения, такие как скорость обучения (learning rate), количество эпох, размер пакета (batch size) и др.

    4. Дообучение модели: Модель обучается на новых данных, в результате чего веса сети адаптируются к специфическим особенностям этих данных. При этом могут дообучаться все слои модели или только часть (часто последние слои).

    5. Оценка производительности: Используя валидационную и тестовую выборки, оценивается, насколько хорошо модель работает на новой задаче.

    Тюнинг может быть как "мягким" (fine-tuning), когда изменяются веса уже существующих слоев модели, так и "жестким" (hard-tuning), когда к модели добавляются новые слои, специализированные под конкретную задачу (например, новый классификационный слой).

    Тюнинг позволяет значительно сократить ресурсы и время, необходимые для обучения модели "с нуля",так как модель уже имеет предварительное представление о признаках из большого набора данных и ей требуется только "отточить" эти знания под новую задачу.