Добавляем пользовательскую LLM в торгового робота (Часть 3): Обучение собственной LLM с помощью CPU

Введение

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

В предыдущей статье серии мы рассмотрели базовую настройку среды для запуска больших языковых моделей и запустили простой экземпляр LLM с использованием llama.cpp в WSL. Самое интересное то, что мы можем запустить пример даже без мощного графического процессора (GPU), используя только центральный процессор (CPU)! Я постараюсь максимально снизить системные требования, чтобы читатели могли попробовать и проверить примеры, не сталкиваясь с нехваткой вычислительной мощности. Конечно, в части обучения модели я представлю версии для различных платформ, включая версию для чистого CPU и версию, поддерживающую ускоренные вычисления на базе видеокарт AMD.

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

В этой статье мы рассмотрим, как обучить большую языковую модель (large language model, LLM) с помощью CPU и создать набор финансовых данных, необходимый для ее обучения. Это потребует информации из моих предыдущих статей. Если вы хотите углубиться в тему, пожалуйста, прочтите мои статьи, где предоставлены необходимые ссылки.

Содержание:

• Введение 
• О наборах данных больших языковых моделей
• Создание набора данных
  
• Обработка данных
  
• Обучение нашей большой языковой модели
  
• Заключение
  
• Ссылки
  

О наборах данных больших языковых моделей

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

1. Токенизатор

Алгоритм сегментации токенизатора является самым базовым компонентом языковых моделей обработки естественного языка (natural language processing, NLP). На основе токенизатора текст можно преобразовать в список независимых токенов, которые затем можно преобразовать во входные векторы, понятные компьютерам. В токенизаторе мы используем предварительно обученные модели для нормализации текста, предварительной сегментации, сегментации на основе модели, постобработки и многого другого. Как упоминалось ранее, токенизатор также интегрирует различные предварительно обученные модели (такие как GPT, GPT-2, GPT-J, GPT-Neo, RoBERTa, BART, LLaMA, AlBERT, T5, mBART, XLNet и т. д.), и мы можем удобно выбирать различные предварительно обученные модели для обработки данных (конечно, вы также можете обучить свою собственную модель сегментации).

2. Различные токенизаторы имеют разное применение и цели:

• Модели кодировщиков: основные модели включают ALBERT, BERT, DistilBERT, ELECTRA, RoBERTa, подходящие для задач, требующих понимания полноценных предложений, таких как классификация предложений, распознавание именованных сущностей (и, в более общем плане, классификация слов) и извлекаемые ответы на вопросы.
• Модели дешифровщиков: основные модели включают CTRL, GPT, GPT-2 и Transformer XL. Предварительное обучение моделей декодера обычно связано с предсказанием следующего слова в предложении. Эти модели лучше всего подходят для задач, связанных с генерацией текста.
• Модели кодировщиков-дешифровщиков: основные модели включают BART, T5, Marian и mBART. Эти модели лучше всего подходят для задач, связанных с созданием новых предложений на основе заданных входных данных, таких как реферирование, перевод или генеративный ответ на вопрос.

3. Специальные токены
Чтобы модель могла распознавать начало и конец последовательностей, мы обычно добавляем специальные символы при использовании токенизатора для сегментации, такие как [CLS], [SEP] и т. д. В этой статье мы будем использовать ['<|endoftext|>'] для прерывания последовательности.

Создание набора данных

При обучении собственных моделей создание набора данных часто становится самой большой проблемой, поскольку существует множество руководств по обучению модели с использованием существующего набора данных, но лишь немногие из них рассказывают, как создать свой собственный набор данных. Вы можете легко обучить модель, но не иметь ни малейшего представления о том, как создать набор данных на основе собственных идей. Здесь я могу сослаться на свою серию статей "Разметка данных в анализе временных рядов" (она включает шесть статей, включая "Разметка данных в анализе временных рядов (Часть 1)：Создаем набор данных с маркерами тренда с помощью графика советника"), которая, как я надеюсь, станет подспорьем в вашей работе. Конечно, вы также можете применить эти знания для обучения больших языковых моделей.

А теперь вернемся к нашей теме. Мы все еще получаем данные из клиента MetaTrader 5, а затем обрабатываем их. Учитывая, что мы работаем на CPU, а также принимая во внимание производительность большинства современных компьютеров, мы исходим из того, что длина нашей последовательности не должна быть слишком большой. В противном случае работа будет идти слишком медленно. Обратите внимание, что примеры в этой статье приведены исключительно для демонстрации того, как тренировать модель с помощью CPU. Создание набора данных и обучение модели — это всего лишь примеры, и результаты могут быть не идеальными. Для получения лучших результатов вам может потребоваться подготовить больший набор данных или такой, который больше соответствует ожиданиям от задачи, а также выполнить дополнительную обработку данных. Возможно, вам также придется соответствующим образом настроить параметры модели, но эти темы не будут рассматриваться в базовом примере.
Пришло время приступить к пошаговому созданию набора данных:

1. Определение глобальных переменных

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

DATA_DIR = os.path.dirname(__file__)
data_file = os.path.join(DATA_DIR, "llm_data.csv")

2. Получение данных от клиента

Из-за ограничений обучения на CPU в качестве исходных данных мы получим данные для одной валютной пары длиной 2500 точек данных.

    mt_data_len=2500
    sr_len=60

    if not mt.initialize():
        print("mt initialize failed!")
    else:
        sbs=mt.symbols_get(group='*micro*')
        if sbs is  not  None:
            # for i in [mt.TIMEFRAME_M5,mt.TIMEFRAME_M15,mt.TIMEFRAME_H1,mt.TIMEFRAME_D1]:

Примечание:

Я использовал функцию 'mt.symbols_get(group='*micro*')' для получения валютных пар в клиенте. Поскольку мой счет является микросчетом, я использовал group='*micro*' для поиска валютных пар с "micro". Если вы используете стандартный счет, вам необходимо удалить это условие. В противном случае вы не найдете никаких валютных пар. Конечно, вы можете изменить "micro" для соответствия интересующим вас валютным парам, например, использовать GBP, чтобы сопоставить все валютные пары с британским фунтом.

3. Разделение данных
Учитывая вычислительные возможности CPU, мы возьмем из котировок только столбец close и начнем с индекса 0, принимая каждые 60 котировок за последовательность и отбрасывая последовательности, длина которых меньше 60. Таким образом, мы просто создали набор последовательностей, каждая длиной в 60 котировок. Конечно, длину можно изменить в соответствии с вычислительной мощностью вашего процессора. В целом, чем длиннее последовательность, тем лучше потенциальный эффект. В коде мы использовали два цикла for для управления выбором периодов и разновидностей, что позволяет легко добавлять больше периодов и больше валютных пар, а набор данных можно корректировать в любое время по мере необходимости.

            for i in [mt.TIMEFRAME_M5,]: 
                xy=None
                # xy_list=[]
                ct=0
                for j in sbs: 
                    if ct>0:
                        break 
                    print(j.name)
                    d_=mt.copy_rates_from_pos(j.name,i,0,mt_data_len)
                    df_d=pd.DataFrame(d_)
                    cl_d=df_d['close']
                    k=0
                    while k+1:
                        if mt_data_len-k>=sr_len:
                            cl_ds=cl_d[k:k+sr_len].tolist()
                            if xy is None:
                                xy=pd.DataFrame([cl_ds])
                                # xy_list=[cl_ds]
                            else:
                                xy.loc[len(xy)]=cl_ds
                                # xy_list.append(cl_ds)
                            k+=1                       
                        else:
                            break
                    ct+=1
            mt.shutdown()

Примечания:

• Мы использовали переменную ct для управления количеством получаемых данных по валютным парам.
• k используется для управления смещением индекса данных для получения данных последовательности. Если длина последовательности данных меньше длины, определенной в переменной sr_len, то добавление последовательности в набор данных xy прекратится.

4. Запись обработанных данных в файл

Конечно, это необязательный шаг. Вы можете продолжить обработку данных, не сохраняя их в файле. Однако, поскольку мы продолжим использовать эти данные в будущем и нет необходимости получать их повторно, рекомендуется все же сохранить их.

xy.to_csv(data_file)

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

def get_data():
    mt_data_len=2500
    sr_len=60

    if not mt.initialize():
        print("mt initialize failed!")
    else:
        sbs=mt.symbols_get(group='*micro*')
        if sbs is  not  None:
            # for i in [mt.TIMEFRAME_M5,mt.TIMEFRAME_M15,mt.TIMEFRAME_H1,mt.TIMEFRAME_D1]:
            for i in [mt.TIMEFRAME_M5,]: 
                xy=None
                # xy_list=[]
                ct=0
                for j in sbs: 
                    if ct>0:
                        break 
                    print(j.name)
                    d_=mt.copy_rates_from_pos(j.name,i,0,mt_data_len)
                    df_d=pd.DataFrame(d_)
                    cl_d=df_d['close']
                    k=0
                    while k+1:
                        if mt_data_len-k>=sr_len:
                            cl_ds=cl_d[k:k+sr_len].tolist()
                            if xy is None:
                                xy=pd.DataFrame([cl_ds])
                                # xy_list=[cl_ds]
                            else:
                                xy.loc[len(xy)]=cl_ds
                                # xy_list.append(cl_ds)
                            k+=1                       
                        else:
                            break
                    ct+=1
            mt.shutdown()
            
    # print(len(xy),"   ",len(xy_list))
    xy.to_csv(data_file)
    # xy.to_json(f'llm_data.json')
    return xy

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

Обработка данных

Мы уже упомянули токенизаторы и теперь располагаем набором данных. Следующим шагом будет обработка данных с использованием токенизатора. В этом примере мы воспользуемся библиотекой tiktoken и выберем предварительно обученную модель gpt2 для кодирования нашего набора данных.

1. Чтение данных

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

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

data=get_data()
# data=pd.read_csv(data_file)
# data=data.iloc[1:,1:]

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

2. Определение переменных

Здесь нам необходимо создать экземпляр токенизатора и определить специальные токены. Как упоминалось ранее, в этой статье в качестве начала и конца последовательности используется "<|endoftext|>".

    enc = tiktoken.get_encoding("gpt2")
    encode = lambda s: enc.encode_ordinary(s)
    eot = enc._special_tokens['<|endoftext|>']

    train_tokens=[]
    val_tokens=[]
    val_cut=len(data)//10

Примечания:

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

3. Определение функции для записи в файл bin

Перед окончательной обработкой данных нам необходимо определить функцию для записи обработанных данных в bin-файл.

def data_to_file(path, tks):

    header = np.zeros(256, dtype=np.int32)
    header[0] = 20240520
    header[1] = 1
    header[2] = len(tks)
    toks_np = np.array(tks, dtype=np.uint16)
    with open(path, "wb") as f:
        f.write(header.tobytes())
        f.write(toks_np.tobytes())

Сама по себе эта функция несложна, но важно отметить значение header[0]=20240520, которое может быть использовано при последующем обучении большой модели. Во время загрузки данных для обучения большой модели это значение будет проверено, и если оно не совпадает, возникнет ошибка. Это требует особого внимания!

4. Токенизация данных

Сначала мы используем цикл for для обхода каждой строки набора данных, чтобы получить каждую последовательность, при этом переменная i получает номер строки последовательности, а r — саму последовательность.

for i,r in data.iterrows():

На этом этапе r сохраняет данные в формате Series. Сначала нам нужно преобразовать их в формат списка, а затем формат списка - в последовательность строк в виде "x,x,x,x,…". Конечно, мы могли бы напрямую использовать f'{ser}', чтобы преобразовать последовательность в список, обернутый строкой "[x,x,x,x,x,…]", но это будет выглядеть немного странно, поэтому давайте придерживаться стиля "x,x,x,x,x,…".

ser=r.tolist()
ser= ''.join(str(elem) for elem in ser)

Далее мы кодируем последовательность, сохраняя первые 10% набора данных в val_tokens, а оставшуюся часть — в train_tokens, и вызываем функцию data_to_file(), чтобы записать их в соответствующие bin-файлы:

tokens = encode(ser)
if i< val_cut:
    val_tokens.append(eot)
    val_tokens.extend(tokens)
    enc_f = os.path.join(DATA_DIR, "val_data.bin")
    data_to_file(enc_f, val_tokens)
else:
    train_tokens.append(eot)
    train_tokens.extend(tokens)
    enc_f = os.path.join(DATA_DIR, "train_data.bin")
    data_to_file(enc_f, train_tokens)

Мы завершили токенизацию данных. Весь процесс от сбора данных до токенизации завершен, и мы запишем этот контент в файл data_enc.py. Полный код всего файла:

import MetaTrader5 as mt
import pandas as pd
import numpy as np
import os
import tiktoken


DATA_DIR = os.path.dirname(__file__)
data_file = os.path.join(DATA_DIR, "llm_data.csv")

def get_data():
    mt_data_len=2500
    sr_len=60

    if not mt.initialize():
        print("mt initialize failed!")
    else:
        sbs=mt.symbols_get(group='*micro*')
        if sbs is  not  None:
            # for i in [mt.TIMEFRAME_M5,mt.TIMEFRAME_M15,mt.TIMEFRAME_H1,mt.TIMEFRAME_D1]:
            for i in [mt.TIMEFRAME_M5,]: 
                xy=None
                # xy_list=[]
                ct=0
                for j in sbs: 
                    if ct>0:
                        break 
                    print(j.name)
                    d_=mt.copy_rates_from_pos(j.name,i,0,mt_data_len)
                    df_d=pd.DataFrame(d_)
                    cl_d=df_d['close']
                    k=0
                    while k+1:
                        if mt_data_len-k>=sr_len:
                            cl_ds=cl_d[k:k+sr_len].tolist()
                            if xy is None:
                                xy=pd.DataFrame([cl_ds])
                                # xy_list=[cl_ds]
                            else:
                                xy.loc[len(xy)]=cl_ds
                                # xy_list.append(cl_ds)
                            k+=1                       
                        else:
                            break
                    ct+=1
            mt.shutdown()
            
    # print(len(xy),"   ",len(xy_list))
    xy.to_csv(data_file)
    # xy.to_json(f'llm_data.json')
    return xy

def data_to_file(path, tks):

    header = np.zeros(256, dtype=np.int32)
    header[0] = 20240520 
    header[1] = 1 
    header[2] = len(tks) 
    toks_np = np.array(tks, dtype=np.uint16)
    with open(path, "wb") as f:
        f.write(header.tobytes())
        f.write(toks_np.tobytes())

if __name__=="__main__":

    data=get_data()
    # data=pd.read_csv(data_file)
    # data=data.iloc[1:,1:]

    enc = tiktoken.get_encoding("gpt2")
    encode = lambda s: enc.encode_ordinary(s)
    eot = enc._special_tokens['<|endoftext|>']

    train_tokens=[]
    val_tokens=[]
    val_cut=len(data)//10
    for i,r in data.iterrows():
        ser=r.tolist()
        ser=''.join(str(elem) for elem in ser)
        # ser = ser.strip() 
        tokens = encode(ser)
        if i< val_cut:
            val_tokens.append(eot)
            val_tokens.extend(tokens)
            enc_f = os.path.join(DATA_DIR, "val_data.bin")
            data_to_file(enc_f, val_tokens)
        else:
            train_tokens.append(eot)
            train_tokens.extend(tokens)
            enc_f = os.path.join(DATA_DIR, "train_data.bin")
            data_to_file(enc_f, train_tokens)
    print(f"tain:{len(train_tokens)}",f"val:{len(val_tokens)}")

Далее мы обучим нашу большую модель.
Примечания:

• При первом использовании библиотеки tiktoken для токенизации она подключится к Интернету, чтобы загрузить соответствующую предварительно обученную модель из huggingface, поэтому убедитесь, что ваша сеть имеет доступ к huggingface. Конечно, вы также можете использовать заранее подготовленную локальную модель для токенизации, но в статье это обсуждаться не будет.
• Как правило, обработка данных больших моделей требует дополнений и маскирования данных. Поскольку наш набор данных невелик и каждая последовательность имеет фиксированную длину, мы этого не сделали. Но если вы хотите создать большой и сложный набор данных, внимательно отнеситесь к выбору и очистке данных. Этот шаг очень важен и существенно влияет на качество модели. Наша обработка набора данных может быть достаточно грубой, но для демонстрационного примера ее достаточно.
• Функция самого токенизатора заключается в преобразовании текста в список чисел, а наши данные сами по себе числовые, так зачем же их токенизировать? Лично я считаю, что подход к обработке зависит от конечной цели модели. Функции и задачи, заложенные в модели, определяют метод обработки данных.

Обучение нашей большой языковой модели

Поначалу это может показаться самой сложной частью работы, но с помощью проекта с открытым исходным кодом llm.c на GitHub нам нужно будет использовать только его обучающие файлы. Комментарии во всех файлах очень подробные и содержат пояснения практически к каждому шагу, поэтому нет необходимости в отдельном анализе или интерпретации кода в этой статье.
1. Подготовка к обучению
URL проекта llm.c: https://github.com/karpathy/llm.c.
В качестве примера платформы кода в этой статье используется среда WSL, развернутая в Windows, как было сказано ранее, с использованием miniconda для среды интерпретатора Python с версией Python 3.11.5.
Перед началом обучения используйте git clone для загрузки проекта llm.c и убедитесь, что библиотеки, требуемые файлом requirements.txt проекта, установлены, а make установлен в WSL.

git clone  https://github.com/karpathy/llm.c.git

cd llm.c

pip install -r requirements.txt

2. Обучение модели
Прежде всего откройте клиент MetaTrader 5 в Windows, чтобы получить данные, найдите местоположение файла data_enc.py (обратите внимание, что этот файл также должен быть помещен в среду Windows, я не проверял, можно ли получить данные в WSL) и выполните команду python data_enc.py.

python data_enc.py

После запуска скрипта мы сгенерируем два файла в одном каталоге: train_data.bin и val_data.bin, которые нам нужно скопировать в файловую систему WSL. Конечно, поскольку WSL может полностью прочитать содержимое файловой системы Windows, копирование файлов не является обязательным.
После получения данных нам также необходимо запустить файл train_gpt2.py в корневом каталоге проекта llm.c. Здесь возможны два варианта:

• Непосредственно изменить значение по умолчанию --input_bin в строке 397 train_gpt2.py, заменив его на путь к нашему файлу данных, например dev/data/mt5/val_data.bin, а затем запустить python train_gpt2.py.
• Добавить параметры непосредственно в командную строку, чтобы найти наш файл данных, например, python train_gpt2.py --input_bin dev/data/mt5/val_data.bin.

Я решил запустить этот файл с аргументами в командной строке.

python train_gpt2.py --input_bin dev/data/mt5/val_data.bin

Результаты запуска:


Мы видим "<|endoftext|>40% of the remaining 80% of the remaining 20% of the remaining 40" (|endoftext|>40% от оставшихся 80% от оставшихся 20% от оставшихся 40). Результаты этого теста оказались неожиданно странными! Но это не должно останавливать нас от движения вперед, поэтому мы продолжаем!

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

• Файлы параметров модели сохраняются в форматах float32 и bfloat16 (файлы - gpt2_124M.bin и gpt2_124M_bf16.bin соответственно);
• Файл токенизатора gpt2_tokenizer.bin;
• Файл для отладки C, gpt2_124M_debug_state.bin.

Во время выполнения скрипта будет выполнено несколько шагов вывода и выведены результаты, что послужит предварительным тестом модели. Остальной код в файле не будет далее интерпретироваться в этой статье, поскольку исходный код содержит очень подробные комментарии, позволяющие читателям понять весь процесс.
После запуска скрипта train_gpt2.py нам необходимо скомпилировать обучающий код. Но перед компиляцией нам также необходимо изменить путь чтения данных в исходном коде train_gpt2.c для обучения на CPU. Около строки 1041 этого файла C определены две константы: const char* train_tokens и const char* val_tokens, и нам нужно изменить их значения на наши собственные пути train_data.bin и val_data.bin. Например, после моей модификации:

    const char* train_tokens = "dev/data/mt5/train_data.bin";
    const char* val_tokens = "dev/data/mt5/val_data.bin";

Пожалуйста, не забудьте поставить ; в конце оператора. Это отличается от синтаксиса Python! Аналогично, я не хочу слишком подробно интерпретировать исходный код этого файла, поскольку исходный код автора содержит подробные комментарии, что облегчает понимание всего процесса обучения.
После изменения исходного кода запустите make train_gpt2 непосредственно в командной строке. Если вы не установили библиотеку ускоренных вычислений CUDA, то эта команда напрямую скомпилирует исходный код обучения в программу, которая может работать на CPU.

Теперь мы можем начать обучение нашей большой языковой модели. Выполните команду OMP_NUM_THREADS=10 ./train_gpt2 в командной строке, где параметр OMP_NUM_THREADS указывает количество используемых потоков. Установите значение в соответствии с общим количеством потоков, поддерживаемых вашим аппаратным устройством.

Результаты запуска:

Результат теста в ходе обучения:

```

generating: --- 30.605360.605540.605590.605510.605650.605510.605650.60550.605550.605540.605590.605540.605590.606107<|endoftext|>0.605640.60 --- ```
Теперь, возвращаясь к исходным данным, можно увидеть, что значения в моем файле llm_data.csv следующие:

Давайте сравним. Исходные значения в основном составляют около 0,6, поэтому, по-видимому, в выходных данных отсутствуют разделители. Как упоминалось ранее, наш формат данных - "x,x,x,x,…", но выходные данные выглядят как "xxxxxxx…". Однако я не думаю, что это проблема, поскольку наша идея была подтверждена, обученная большая модель просто может выдавать нужные нам результаты! Незначительные проблемы можно решить путем оптимизации процесса кодирования и дешифровки.
Поскольку это всего лишь демонстрационный пример, мы не упоминали сохранение модели или тестирование торговых стратегий в клиенте. Более того, обученную на CPU модель не нужно сохранять и тестировать из-за проблем с точностью. Я думаю, если вы хотите, чтобы модель была по-настоящему пригодна для использования, вам, возможно, придется применить научный подход и приложить больше усилий. Например, проектирование наборов данных для конкретных задач, формулирование соответствующих торговых стратегий, проектирование и обучение модели кодировщика и дешифровщика, отвечающей требованиям задачи, настройка гиперпараметров модели и т. д. Для выполнения всего этого требуется много практики, и вряд ли эти темы можно четко объяснить в рамках нескольких статей, поэтому процесс требует от читателей самостоятельного изучения. Эта статья лишь предоставляет вам больше возможностей.

Конечно, это также поднимает вопрос о том, как использовать нашу обученную языковую модель в торговых стратегиях или тестировании. Самый простой пример: мы можем запустить службу вывода большой модели в среде Python, а затем отправлять запросы на обслуживание с помощью советника через сокет, при этом служба вывода вычисляет результаты и возвращает их советнику. Подробности можно найти в моей статье "Разметка данных в анализе временных рядов (Часть 5)：Применение и тестирование советника с помощью Socket ".

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

Примечания:

В каталоге mnt в корне WSL вы можете найти все буквы дисков Windows. Также вы можете найти файлы в Windows под соответствующей буквой диска из WSL, например, /mnt/g/Program Files. Следует отметить, что если имя папки Windows содержит пробелы, как в примере, мы не можем войти в эту папку напрямую с помощью "cd /mnt/g/Program Files", нам необходимо использовать кавычки, чтобы заключить имя папки в пробелы. Правильным методом будет "cd /mnt/g/'Program Files'".

Заключение

Невероятно! Мы успешно обучили нашу собственную большую языковую модель, используя только CPU!

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

В следующей статье мы рассмотрим, как использовать видеокарты для ускорения обучения нашей модели. Если вы используете видеокарту AMD, имейте в виду, что ускорение AMD не поддерживается во многих популярных библиотеках (по крайней мере, на момент написания статьи). В долгосрочной перспективе я по-прежнему верю, что экосистема искусственного интеллекта AMD станет лучше в ближайшем будущем! Или экосистема искусственного интеллекта, такого как llama.cpp, поддерживающего все платформы, станет более популярной! Поэтому в соответствии с первоначальным намерением охватить все платформы в как можно большей степени, в следующей статье мы обсудим, как использовать видеокарты AMD для ускорения обучения нашей большой языковой модели! Скорее всего, я не буду обсуждать использование видеокарты NVIDIA для ускоренных вычислений, поскольку в настоящее время я использую платформу AMD, но если вы можете использовать AMD для ускоренного обучения, то работа с NVIDIA, располагающей более совершенной экосистемой ИИ, не составит труда верно?

Увидимся в следующей статье!

Ссылки

llm.c: https://github.com/karpathy/llm.c.git