Немного вызывающее название статьи отсылает к известной работе Внимание - всё, что вам нужно. На этот раз речь пойдет о качестве данных, на которых обучают LLM. Оказывается, качественный учебник (как концентрат знаний в любой сфере) в разы сокращает потребность и в памяти, и в мощности GPU, и в деньгах инвесторов...
Эта статья - о качестве данных при обучении/файнтюнинге LLM. Классическая работа о количественных данных позволит лучше понять, на что влияет качество датасета: Законы масштабирования нейронных языковых моделей
2 октября 2023
Мы представляем phi-1, новую большую языковую модель для генерации кода, которая значительно меньше по размеру по сравнению с конкурирующими моделями: phi-1 — это модель на основе архитектуры трансформера с 1,3 миллиардами параметров, обученная в течение 4 дней на 8 A100, с использованием выборки данных "качество-как-в-учебнике" из интернета (6 миллиардов токенов) а также синтетически сгенерированных с помощью GPT-3.5 учебников и упражнений (1 миллиард токенов). Несмотря на такой небольшой масштаб, phi-1 достигает точности pass@1 50,6% на HumanEval и 55,5% на MBPP. Модель также демонстрирует удивительные эмерджентные свойства по сравнению с phi-1-base, нашей моделью до этапа тонкой настройки (файнтюнинга) на наборе данных с упражнениями по программированию, и по сравнению с phi-1-small, меньшей моделью с 350 миллионами параметров, обученной по тому же конвейеру, что и phi-1, которая, однако, всё ещё достигает 45% на HumanEval.
Искусство обучения больших нейронных сетей показало невероятный прогресс за последнее десятилетие, особенно после открытия архитектуры трансформера [*], однако научные знания, стоящие за этим успехом, пока остаются ограниченными. Среди множества запутанных результатов появилось некое подобие порядка примерно в то же время, когда были представлены модели, основанные на трансформере. Было доказано, что производительность предсказуемо улучшается по мере увеличения либо объёма вычислений, либо размера сети [*], явление, которое теперь называют законами масштабирования [*]. Последующие исследования масштабирования в глубоком обучении взяли за основу эти законы масштабирования, и полученные результаты привели к резкому скачку в производительности. В этой работе, следуя по стопам Eldan и Li [*], мы исследуем улучшения, которые можно получить вдоль другой оси: качество данных.
Давно известно, что данные более высокого качества приводят к лучшим результатам, например, очистка данных является важной частью создания современных наборов данных, это также может дать другие дополнительные преимущества, такие как несколько меньшие наборы данных или возможность делать больше проходов по данным. Недавняя работа Eldan и Li над TinyStories (высококачественным набором данных, синтетически сгенерированным для обучения нейронных сетей английскому языку) показала, что эффект высококачественных данных выходит далеко за пределы этого: улучшение качества данных может кардинально изменить форму законов масштабирования, потенциально позволяя достичь производительности больших моделей с гораздо более скромными затратами на обучение модели.
В этой работе мы выходим за рамки первоначального исследования Eldan и Li, чтобы показать, что высококачественные данные могут даже улучшить SOTA больших языковых моделей (LLM), при этом значительно сокращая размер набора данных и объём вычислений для обучения. Важно, что меньшие модели, требующие меньше обучения, могут значительно снизить экологические издержки от LLM.
Мы сосредоточим внимание на LLM, обученных для генерации кода, и, в частности, на написании простых функций на Python, используя их строки документации (docstrings), см. [*]. Бенчмарк, предложенный в последней работе, HumanEval, широко используется для сравнения производительности LLM в генерации кода. Мы демонстрируем мощь высококачественных данных, которые нарушают существующие законы масштабирования, обучая модель с 1,3 миллиардами параметров, которую мы называем phi-1, примерно на 8 проходах по 7 миллиардам токенов (всего чуть более 50 миллиардов токенов) с последующей тонкой настройкой (файнтюнингом) на менее чем 200 миллионах токенов.
Грубо говоря, мы предварительно обучаем на данных с качеством "как в учебнике", как синтетически сгенерированных (с помощью GPT-3.5), так и отфильтрованных из веб-источников, и проводим файнтюнинг на данных, похожих на упражнения из учебника.
Несмотря на то, что модель на несколько порядков меньше конкурирующих моделей как по размеру набора данных, так и по размеру модели (см. Таблицу 1), мы достигаем точности 50,6% pass@1 на HumanEval и 55,5% pass@1 на MBPP (Mostly Basic Python Programs), что является одним из лучших самостоятельно заявленных результатов с использованием только одной генерации LLM.
Таблица 1: Мы используем данные отчетов, если они доступны. Несмотря на то, что phi-1 обучалась на значительно меньшем объеме данных, она превосходит конкурирующие модели по метрикам HumanEval и MBPP, за исключением модели GPT-4 (также WizardCoder показывает лучший результат на HumanEval, но хуже на MBPP).
Дата | Модель | Размер (параметры) модели | Размер датасета (токенов) | HumanEval | MBPP |
Jul 21 | Codex-300M [CTJ + 21] | 300M | 100B | 13.2% | N.A. |
Jun 23 | phi-1 | 1.3B | 7B | 50.6% | 55.5% |
CodeGen-Mono: [NPH + 23], StarCoder-Prompted: [LAZ + 23], InstructCodeT5+: [WLG + 23]
В Разделе 2 мы приводим некоторые детали нашего процесса обучения и обсуждаем доказательства важности нашего процесса отбора данных для достижения этого результата. Более того, несмотря на обучение на значительно меньшем количестве токенов по сравнению с существующими моделями, phi-1 всё же демонстрирует эмерджентные свойства.
Эмерджентность — это явление, когда в системе возникают новые свойства или поведение, которые не характерны для отдельных её компонентов. Т.е. это проявления феномена, когда целое больше, чем сумма его частей - прим. переводчика.
В Разделе 3 мы обсудим эти эмерджентные свойства и, в частности, подтвердим гипотезу о том, что количество параметров играет ключевую роль в эмерджентности (см., например, [WTB22]), сравнивая вывод модели phi-1 с выводом phi-1-small, модели, обученной по тому же конвейеру, но только с 350 миллионами параметров. Методология, используемая в этом разделе, напоминает работу Sparks of AGI, в которой утверждается, что необходимо отойти от статических бенчмарков для тестирования производительности LLM.
Наконец, в Разделе 4 мы обсудим альтернативные бенчмарки для оценки модели, а в Разделе 5 изучим возможное загрязнение наших обучающих данных в отношении HumanEval. Мы выкладываем модель для использования и оценки широким сообществом, но опускаем некоторые детали синтетической генерации данных по причинам наличия прав собственности.
Другие работы по темеНаша работа является частью недавней программы использования LLM для синтеза программного кода, дополнительные ссылки на которую см. в [CTJ+21, NPH+22]. Наш подход также является частью тенденции использования существующих LLM для синтеза данных для обучения новых поколений LLM, [WKM+22, TGZ+23, MMJ+23, LGK+23, JWJ+23]. В настоящее время ведутся споры о том, что возможно такое “рекурсивное обучение” приведет к деградации моделей [SZ+23, GUESS+23], противоположную точку зрения смотрите в [MMJ+23].
Обратите внимание, что в этой статье мы фокусируемся на узкой задаче, аналогично [JWJ +23], при которой достижение лучшей производительности, чем у исходной LLM, кажется реалистичным (что и доказывается статье).
Для моделей с 1.3 млрд параметров phi-1 и phi-1-base являются контрольными точками после обучения на 51 млрд токенов (770 GPU-часов), а модель The Stack+ была обучена на 76 млрд токенов и 1090 GPU-часов. Мы подчеркиваем, что даже без какого-либо дообучения наша модель phi-1-base, обученная на наборе данных CodeTextbook, достигает 29% производительности на HumanEval при всего 1.3 млрд параметров. Предыдущая самая маленькая модель, достигшая около 30% производительности на HumanEval, это Replit-Finetuned с 2.7 млрд параметров, которая была обучена на объеме токенов в 100 раз больше, чем наша [Rep23]. Кроме того, дообучение на нашем наборе данных CodeExercises для получения phi-1 не только дало нам максимальную производительность 51% на HumanEval, но и раскрыло дополнительные неожиданные возможности кодирования (см. Раздел 3).
Как намекает название статьи, ключевым ингредиентом нашей модели являются данные обучения "качества как в учебнике". В отличие от предыдущих работ, которые использовали стандартные источники текстовых данных для генерации кода, такие как The Stack (содержащий исходный код из репозиториев с разрешающими лицензиями) и другие веб-наборы данных (например, StackOverflow и CodeContest [*]), мы утверждаем, что эти источники не оптимальны для обучения модели алгоритмическому мышлению и планированию. С другой стороны, архитектура нашей модели и методы обучения довольно традиционны (Раздел 2.3), поэтому этот раздел мы посвящаем в основном объяснению того, как мы отбирали наши данные.
Стандартные наборы данных для кода [*, *] представляют собой большой и разнообразный корпус, охватывающий широкий спектр тем и случаев использования. Однако, основываясь на ручном анализе случайных выборок, мы можем сказать, что многие из этих фрагментов кода далеко не очень полезны для изучения основ программирования и страдают от нескольких недостатков:
Многие примеры не самодостаточны, то есть они зависят от других модулей или файлов, внешних по отношению к фрагменту, что делает их трудными для понимания без дополнительного контекста.
Типичные примеры не содержат значимых вычислений, а скорее состоят из тривиального или шаблонного кода, такого как определение констант, установка параметров или настройка элементов графического интерфейса.
Примеры, содержащие алгоритмическую логику, часто скрыты внутри сложных или плохо документированных функций, что затрудняет их понимание или изучение.
Примеры смещены в сторону определённых тем или случаев использования, что приводит к несбалансированному распределению концепций и навыков программирования в наборе данных.
Можно представить, насколько неэффективной и полной разочарований стала бы попытка человека освоить навыки программирования по таким наборам данных, так как ему пришлось бы иметь дело с большим количеством шума, неоднозначности и неполноты данных.
Мы предполагаем, что эти проблемы также влияют на производительность языковых моделей, поскольку они снижают качество и количество сигналов, которые связывают естественный язык с кодом. Мы предполагаем, что языковые модели выиграют от обучающего набора данных, который обладает теми же качествами, что и хороший "учебник": он должен быть ясным, самодостаточным, поучительным и сбалансированным.
В этой работе мы напрямую решаем эту проблему и показываем, что целенаправленно отбирая и генерируя высококачественные данные можно достичь современных результатов в задачах генерации кода с гораздо меньшим размером модели и меньшими вычислительными затратами, чем существующие подходы. Наше обучение основывается на трёх основных наборах данных:
Отфильтрованный набор данных "код-язык", который представляет собой подмножество The Stack и StackOverflow, полученное с использованием классификатора на основе языковой модели (состоящий из около 6 миллиардов токенов).
Синтетический датасет "учебников", состоящий из менее чем 1 миллиарда токенов учебников по Python, сгенерированных GPT-3.5.
Небольшой датасет "упражнения", состоящий из ~180 миллионов токенов упражнений и решений на Python.
Мы подробно описываем эти наборы данных в следующих подразделах. В совокупности вышеуказанные наборы данных содержат менее 7 миллиардов токенов. Мы называем "CodeTextbook" комбинацию отфильтрованного набора данных "код-язык" и синтетического набора данных "учебников" и используем его на этапе предварительного обучения для получения нашей базовой модели phi-1-base — эта модель уже достигает конкурентоспособной производительности на HumanEval в 29%.
Затем мы используем набор данных "упражнения" из 180 миллионов токенов, называемый "CodeExercises", для файнтюнинга нашей модели phi-1-base для создания phi-1. Несмотря на небольшой размер набора данных "CodeExercises", файнтюнинг с этим набором данных имеет решающее значение не только для значительного улучшения генерации простых функций на Python, как показано на Рисунке 2.1, но и для разблокировки многих интересных эмерджентных возможностей в нашей модели phi-1, которые не наблюдаются в phi-1-base (см. Раздел 3).
Мы начинаем с общедоступных наборов данных на Python: используем подмножество Python из дедуплицированной версии The Stack и StackOverflow, которые вместе содержат более 35 миллионов файлов/примеров, всего более 35 миллиардов токенов.
Мы аннотируем качество небольшого подмножества этих файлов (около 100 тысяч примеров) с помощью GPT-4: для каждого фрагмента кода у GPT-4 запрашивается: "определить образовательную ценность для студента, цель которого — изучить основные концепции программирования".
Затем мы используем этот аннотированный набор данных для обучения классификатора на основе случайного леса, который предсказывает качество файла/примера, используя выдачу из предварительно обученной codegen-модели в виде соответствующих признаков. Мы отмечаем, что, в отличие от GPT-3.5, который мы активно используем для генерации синтетического контента (обсуждается ниже), мы используем GPT-4 минимально только для аннотирования качества небольшого подмножества примеров из The Stack и StackOverflow. Таким образом, мы рассматриваем использование GPT-4 как способ избежать утомительных усилий по ручному аннотированию [*].
# Высокая ценность
import torch
import torch.nn.functional as F
def normalize(x, axis=-1):
"""Performs L2-Norm."""
num = x
denom = torch.norm(x, 2, axis, keepdim=True)
.expand_as(x) + 1e-12
return num / denom
def euclidean_dist(x, y):
"""Computes Euclidean distance."""
m, n = x.size(0), y.size(0)
xx = torch.pow(x, 2).sum(1, keepdim=True).
expand(m, n)
yy = torch.pow(x, 2).sum(1, keepdim=True).
expand(m, m).t()
dist = xx + yy - 2 * torch.matmul(x, y.t())
dist = dist.clamp(min=1e-12).sqrt()
return dist
def cosine_dist(x, y):
"""Computes Cosine Distance."""
x = F.normalize(x, dim=1)
y = F.normalize(y, dim=1)
dist = 2 - 2 * torch.mm(x, y.t())
return dist
# Низкая ценность
import re
import typing
...
class Default(object):
def __init__(self, vim: Nvim) -> None:
self._vim = vim
self._denite: typing.Optional[SyncParent] = None
self._selected_candidates: typing.List[int] = []
self._candidates: Candidates = []
self._cursor = 0
self._entire_len = 0
self._result: typing.List[typing.Any] = []
self._context: UserContext = {}
self._bufnr = -1
self._winid = -1
self._winrestcmd = ''
self._initialized = False
self._winheight = 0
self._winwidth = 0
self._winminheight = -1
self._is_multi = False
self._is_async = False
self._matched_pattern = ''
...
Наш метод фильтрации значительно повышает производительность модели даже без использования синтетических наборов данных, описанных ниже: для моделей с 350 миллионами параметров, обученных на неотфильтрованном Stack (дедуплицированный Python) и StackOverflow, производительность на HumanEval достигает предела на уровне 12,19%, даже после 96 тысяч шагов обучения (~200 млрд токенов). При этом обучение на отфильтрованном подмножестве данных даёт результат 17,68% на HumanEval уже после 36 тысяч шагов. Мы дополнительно улучшили этот показатель до 20,12% (см. рисунок 2.1), обучая модель на комбинации отфильтрованного набора данных и синтетического набора данных из учебников, описанного ниже.
Одной из основных проблем при создании высококачественного набора данных для генерации кода является обеспечение того, чтобы примеры были разнообразными и не повторялись.
Под разнообразием мы понимаем, что примеры должны охватывать широкий спектр концепций, навыков и сценариев программирования, а также варьироваться по уровню сложности, стилю и структуре. Разнообразие важно по нескольким причинам: оно знакомит языковую модель с различными способами выражения и решения задач в коде, снижает риск переобучения или запоминания конкретных шаблонов или решений, а также повышает возможности обобщения и устойчивость модели к новым или незнакомым задачам. Однако достижение разнообразия — нетривиальная задача, особенно при использовании синтетических данных, сгенерированных другой языковой моделью. Простое указание модели создать учебник по программированию или набор упражнений, даже с некоторыми вариациями в инструкциях или параметрах, скорее всего, приведёт к созданию однородного и избыточного набора данных, где одни и те же концепции и решения повторяются с незначительными изменениями. Это происходит потому, что языковые модели склонны следовать наиболее вероятным или распространённым путям, исходя из их обучающих данных и априорных знаний, и у них нет стимула или творческого подхода для исследования альтернативных или новых способов генерации кода. Поэтому необходимо найти правильный "трюк", который заставит языковую модель быть более креативной и разнообразной в своих выводах, сохраняя при этом качество и связность примеров.
Вдохновлённые работой [*], в которой путём включения случайного подмножества слов из фиксированного словаря в запрос и требования их комбинирования в сгенерированном тексте был создан разнообразный набор коротких историй, мы ищем способы внедрения случайности в запрос таким образом, чтобы это способствовало созданию набора данных с высоким разнообразием.
Этот набор данных состоит из менее чем 1 миллиарда токенов учебников по Python, сгенерированных GPT-3.5, и предназначен для предоставления высококачественного источника текста с естественным языком, перемежающегося соответствующими фрагментами кода. Мы также ориентировали содержание этих учебников на темы, которые способствуют развитию логического мышления и базовых алгоритмических навыков. Разнообразие достигается за счёт наложения ограничений на темы и целевую аудиторию генерируемого учебника. Вот пример текста из синтетического учебника:
Для начала давайте определим, что такое сингулярные и несингулярные матрицы. Матрица называется сингулярной, если её определитель равен нулю. С другой стороны, матрица называется несингулярной, если её определитель не равен нулю. Теперь давайте рассмотрим эти концепции на примерах.
Пример 1: Рассмотрим матрицу
A = np.array([[1, 2], [2, 4]])
. Мы можем проверить, является ли эта матрица сингулярной или несингулярной, используя функцию определителя. Мы можем определить функцию на Python,is_singular(A)
, которая возвращаетTrue
, если определитель A равен нулю, иFalse
в противном случае.
import numpy as np
def is_singular(A):
det = np.linalg.det(A)
if det == 0:
return True
else:
return False
A = np.array([[1, 2], [2, 4]])
print(is_singular(A)) # True
Это небольшой синтетический набор данных "упражнения", состоящий из менее чем 180 миллионов токенов упражнений и решений на Python. Каждое упражнение представляет собой строку документации функции, которую необходимо завершить. Цель этого набора данных — настроить модель на выполнение задач по завершению функций на основе инструкций на естественном языке. Этот набор данных также был сгенерирован GPT-3.5, где основным способом достижения разнообразия является ограничение на имена функций. Для этого набора данных мы проводим явную деконтаминацию и альтернативные оценки в следующих разделах, чтобы убедиться, что задачи, похожие на те, что представлены в бенчмарке HumanEval, не встречаются во время файнтюнинга. Следующий фрагмент иллюстрирует синтетически сгенерированное упражнение:
def valid_guessing_letters(word: str, guesses: List[str]) -> List[str]:
"""
Returns a list of valid guessing letters, which are letters that have not been guessed yet and
are present in the word.
Parameters:
word (str): The word to guess.
guesses (List[str]): A list of letters that have already been guessed.
Returns:
List[str]: A list of valid guessing letters.
"""
valid_letters = []
for letter in word:
if letter not in guesses and letter not in valid_letters:
valid_letters.append(letter)
return valid_letters
Мы использовали трансформер с декодером [*], использующий реализацию FlashAttention для многоголового внимания (MHA) [*]. Также мы применили MHA и слои MLP в параллельной конфигурации, следуя недавним моделям, таким как CodeGen [*], PaLM [*] и GPT-NeoX [*].
Архитектура нашей модели phi-1 с 1.3 миллиардами параметров состоит из 24 слоев, скрытой размерности 2048, внутренней размерности MLP 8192 и 32 голов внимания размерностью 64 каждая.
Меньшая модель phi-1-small с 350 миллионами параметров имеет 20 слоев, скрытую размерность 1024, внутреннюю размерность MLP 4096 и 16 голов внимания размерностью 64 каждая.
Мы также использовали вращающийся позиционный эмбеддинг (rotary position embedding) [*] с размерностью вращения 32. Эти архитектурные решения были заимствованы из [*]. Мы использовали тот же токенизатор, что и в codegen-350M-mono
[*]. Помимо FlashAttention, наши модели не используют другие техники, такие как Fill-In-the-Middle (FIM) [*] или Multi-Query-Attention (MQA) [*], которые могли бы дополнительно повысить производительность и эффективность [*].
Для предобучения и дообучения (файнтюнинга) мы объединили соответствующие наборы данных в одномерный массив, используя токен «⟨∣endoftext∣⟩
» для разделения файлов. Мы обучали наши модели на последовательностях длиной 2048, взятых из нашего массива данных с функцией потерь прогнозирования следующего токена. Обучение проводилось с использованием fp16, оптимизатора AdamW, линейного графика обучения с разогревом и затуханием, а также внимания и остаточного dropout на уровне 0,1. Обучение выполнялось на 8 GPU Nvidia A100 с использованием deepspeed. Наша базовая предобученная модель phi-1-base была получена менее чем за 4 дня обучения. Дообучение (файнтюнинг) для получения phi-1 заняло дополнительные 7 часов на том же оборудовании.
phi-1-base был обучен на датасете CodeTextbook (отфильтрованный корпус кода и синтетические учебники). Мы использовали эффективный размер батча 1024 (включая параллелизм данных и накопление градиентов), максимальную скорость обучения 1e-3 с разогревом в течение 750 шагов и коэффициентом регуляризации весов 0,1 всего за 36,000 шагов. Мы использовали контрольную точку на 24,000 шаге в качестве нашей phi-1-base — это эквивалентно примерно 8 эпохам на нашем наборе данных CodeTextbook, что составляет чуть более 50 миллиардов тренировочных токенов. Несмотря на малый размер и вычислительные ресурсы, эта модель уже достигает точности 29% на HumanEval.
phi-1 получена путем файнтюнинга phi-1-base на наборе данных CodeExercises. Для файнтюнинга мы использовали ту же настройку, что и для предобучения, но с другими гиперпараметрами: эффективный размер батча 256, максимальная скорость обучения 1e-4 с разогревом в течение 50 шагов и коэффициентом регуляризации весов 0.01. Мы обучали модель в течение общего количества шагов 6000 и выбирали лучшую контрольную точку (сохраняемую каждые 1000 шагов).
На Рисунке 2.1 показано, что наибольшее улучшение в результатах на HumanEval было достигнуто благодаря файнтюнингу на небольшом наборе данных CodeExercises (<200 млн токенов). CodeExercises состоит исключительно из коротких задач на Python с использованием только базовых библиотек. В этом разделе мы продемонстрируем интересный факт: модель после дообучения показывает значительное улучшение также в выполнении задач, которые не представлены в наборе данных для дообучения. В том числе управление сложными алгоритмическими задачами и использование внешних библиотек.
Это позволяет предположить, что процесс файнтюнинга мог помочь модели реорганизовать и закрепить знания, полученные во время предварительного обучения, даже если такие знания явно не присутствуют в нашем наборе данных CodeExercises. В этом разделе мы сосредоточимся на качественном сравнении возможностей нашей дообученной модели phi-1 и её базовой модели phi-1-base с 1,3 млрд параметров.
Используя простую функцию Python, которую мы создали самостоятельно, мы наблюдаем, что модель демонстрирует значительно более высокий уровень понимания и соответствия инструкциям после файнтюнинга. В частности, мы видим, что phi-1-base испытывает трудности с логическими связями в запросах, в то время как phi-1 может интерпретировать вопрос и сгенерировать правильный ответ. В этом примере даже наша 350-миллионная модель phi-1-small показывает некоторый уровень понимания проблемы, хотя итоговое решение оказывается неверным. Мы наблюдаем такие тенденции последовательно в процессе наших взаимодействий с моделью, см. другой пример в Приложении A.
# phi-1
points = [0, 0]
for i in range(30):
alice_num = random.randint(333, 678)
bob_num = random.randint(alice_num, 888)
charles_num = random.randint(123, bob_num)
if (alice_num - charles_num) % int(bob_num ** 0.5) == 0:
points[0] += 1
else:
points[1] += 1
return f"Alice: {points[0]}, Bob: {points[1]}"
# phi-1-base
self.points = 0
self.alice = 333
self.bob = 678
self.charles = 888
self.bob_points = 0
self.alice_points = 0
self.iterations = 30
self.alice_turn = True
self.bob_turn = True
self.alice_turn_points = 0
self.bob_turn_points = 0
self.alice_turn_points_history = []
self.bob_turn_points_history = []
self.alice_turn_points_history.append(self.alice_points)
self.bob_turn_points_history.append(self.bob_points)
# phi-1-small
indices = []
import random
alice_points = 0
bob_points = 0
for i in range(30):
alice_num = random.randint(333, 678)
bob_num = random.randint(123, bob_num)
if (alice_num - bob_num) % math.floor(math.sqrt(bob_num)) == 0:
alice_points += 1
if (i % 2) == 0:
bob_points += 1
print(f"Alice gets {alice_points} points, while Bob gets {bob_points} points.")
Мы продемонстрируем, что дообучение на наборе CodeExercises неожиданно улучшает способность модели использовать внешние библиотеки, такие как Pygame и Tkinter, несмотря на то, что наши упражнения не содержат этих библиотек. Это позволяет предположить, что наше дообучение не только улучшает выполнение целевых задач, но также облегчает извлечение знаний для несвязанных задач, полученных в ходе предварительного обучения. Для справки, на Рисунке 3.1 показано распределение импортов пакетов в нашем наборе данных CodeExercises.
Пример с PyGame
Мы начинаем с запроса к модели, в котором просим сгенерировать код для перемещения мяча в PyGame:
# phi-1
...
screen = pygame.display.set_mode((400, 600))
x, y = 0, 0
while True:
for event in pygame.event.get():
...
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE:
x = 200
y = 400
x += random.randint(-10, 10)
y += random.randint(-20, 20)
if x < 0:
x = 0
elif x > 400:
x = 400
if y < 0:
y = 0
elif y > 600:
y = 600
screen.fill((255, 255, 255))
pygame.draw.circle(screen, (255, 0, 0), (x, y), 10)
pygame.display.update()
# phi-1-base
...
ball_x = random.randint(-10, 10)
ball_y = random.randint(-20, 20)
ball_vx = random.randint(-5, 5)
ball_vy = random.randint(-5, 5)
...
screen = pygame.display.set_mode((800, 600))
...
while not done:
for event in pygame.event.get():
...
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE:
ball_x = 200
ball_y = 400
ball_x += ball_vx
ball_y += ball_vy
ball_vx += ball
pygame.display.flip()
# phi-1-small
...
x, y = 0, 0
dx, dy = random.randint(-10, 10), random.randint(-20, 20)
while True:
screen.fill((0, 0, 0))
pygame.draw.rect(screen, (255, 255, 255), (x, y, 400, 600))
pygame.display.update()
x += dx
y += dy
if x + dx > 400:
dx = -dx
elif x + dx < 0:
dx = dx
if y + dy > 600:
dy = -dy
elif y + dy < 0:
dy = dy
pygame.time.wait(50)
Приведенный выше фрагмент кода показывает основной цикл простой программы на PyGame, в которой мяч отскакивает на экране. Модель phi-1 корректно применяет функции PyGame для обновления и отрисовки мяча, следуя инструкциям из запроса. Модели phi-1-base и phi-1-small генерируют вызовы функций, которые синтаксически правильны, но семантически не соответствуют задаче. Мы видим, что phi-1-base демонстрирует некоторую способность использовать соответствующие вызовы API, но не может следовать логике задачи, в то время как phi-1-small после дообучения понимает логику, но не обладает достаточной емкостью для изучения правильных вызовов функций.
Пример с TKinter
Наш второй пример — это приложение на TKinter
, в котором мы просим модель обновлять текстовое поле в зависимости от нажатия кнопок.
# phi-1
...
global s
s = ""
def submit():
global s
text = textfield.get()
if "pew" in text:
textfield.delete(0, tk.END)
textfield.insert(0, "pewpewpew...")
else:
textfield.delete(0, tk.END)
textfield.insert(0, text + "no pew...")
s = text
def recover():
global s
textfield.delete(0, tk.END)
textfield.insert(0, s)
textfield = tk.Entry(root)
textfield.pack()
submit_button = tk.Button(root, text="Submit", command=submit)
submit_button.pack()
recover_button = tk.Button(root, text="Recover", command=recover)
recover_button.pack()
root.mainloop()
# phi-1-base
global s
s = s.replace("pew", "pewpewpew")
if "pew" in s:
s = s.replace("pew", "pewpewpew")
else:
s = s + "no pew..."
text.delete(0.0, END)
text.insert(0.0, s)
def main():
global s
s = "pewpewpew"
text.delete(0.0, END)
text.insert(0.0, s)
text.tag_add("button", "<Button-1>", "<Button-3>")
text.tag_add("button", "<Button-2>", "<Button-4>")
# The model keeps adding buttons from here
# phi-1-small
import tkinter as tk
root = tk.Tk()
global s
text = ""
while True:
event, values = tk.popup()
if event == "submit":
text += values.split()[0] + " "
elif event == "textfield":
s += values.split()[0] + " "
elif event == "submit-button-text":
text = values.split()[0] + " "
elif event == "text-button-text":
s = text
if "pew" in text:
text = text.replace("pew", "pewpewpew")
if "no pew" in text:
break
tk.destroy()
Результаты выполнения трех моделей демонстрируют значительный разрыв в их понимании запросов. И phi-1-base, и phi-1-small не смогли использовать правильные API Tkinter и создали бессмысленные вызовы функций. С другой стороны, phi-1 корректно реализовала графический интерфейс и все функции (за исключением небольшой ошибки в копировании строки "pewpewpew?"). В Приложении A мы приводим два дополнительных примера для pytorch и pyplot.
Пример в режиме чата.
Наконец, мы покажем, что phi-1 обладает лучшими способностями к ведению диалога по сравнению с phi-1-base, несмотря на то, что данные для чата присутствовали только на этапе предварительного обучения, а не файнтюнинга.
Ответ phi-1:
Установите параметр dpi
на желаемое разрешение (например, 300 для 300 DPI).
Используйте функцию rotate
из модуля matplotlib.pyplot
, чтобы повернуть график на 90 градусов по часовой стрелке.
Пример:
import matplotlib.pyplot as plt
fig, ax = plt.subplots()
ax.plot([1, 2, 3], [4, 5, 6])
# Установите разрешение на 300 DPI
ax.set_dpi(300)
# Поверните график на 90 градусов по часовой стрелке
ax.rotate(90)
Ответ phi-1-base:
Вы можете использовать функцию setp()
для установки разрешения и функцию set_rotation()
для поворота графика. <|endoftext|>
Ответ phi-1-small:
Я — график на Python pyplot, и я хочу увеличить его разрешение и повернуть. Что мне делать?
ВТОРОЙ:
Я — график на Python pyplot, и я хочу увеличить его разрешение и повернуть. Что мне делать?
ТРЕТИЙ:...
Одной из потенциальных проблем, связанных с удивительно высокой производительностью модели phi-1 на HumanEval (см. Таблицу 1 и Рисунок 2.1), может быть запоминание данных из-за возможного загрязнения синтетического набора данных CodeExercises. Мы изучим это потенциальное загрязнение напрямую в Разделе 5, а в этом разделе рассматрим эту проблему с помощью новой оценки, которая была разработана достаточно нестандартно, чтобы её появление в нашем обучающем наборе данных было маловероятно.
Чтобы минимизировать предвзятость и утечку данных, новые задачи для оценки были созданы специальной командой, которая не имела доступа к набору данных CodeExercises или финальной модели. Они создали 50 новых задач в том же формате, что и HumanEval, с инструкциями разработать задачи, которые вряд ли появятся в реальных базах кода или в качестве учебных упражнений. Вот пример такой задачи:
Одной из сложностей оценки языковых моделей на задачах по программированию является то, что вывод модели часто бинарный: либо код проходит все unit-тесты, либо не проходит. Однако это не отражает нюансов производительности модели, так как она может сгенерировать код, который почти правильный, но содержит небольшую ошибку, или код, который полностью неверен, но случайно проходит некоторые тесты. Более информативным способом оценки навыков модели может быть сравнение её вывода с правильным решением и выставление оценки на основе того, насколько хорошо оно соответствует ожидаемой логике. Это похоже на то, как люди оцениваются на собеседованиях по программированию, где интервьюер не только запускает код, но и анализирует рассуждения и качество решения.
Для оценки решений мы используем подход, при котором GPT-4 выступает в роли оценщика (как, например, в [*]). Этот подход имеет два преимущества:
(1) используя GPT-4 в качестве оценщика, мы можем использовать его знания и генеративные способности для получения более детального и осмысленного сигнала о способностях модели к программированию, и
(2) это устраняет необходимость в тестах.
Наш запрос инструктирует LLM оценить решение студента сначала в краткой вербальной оценке, а затем выставить оценку от 0 до 10.
Таблица 2: Оценки понимания (Understanding scores) на 50 новых нестандартных задачах по программированию, выставленные с использованием LLM.
Модель | Размер | Токенов обучения | Оценка | Human-Eval |
CodeGen-Mono-350M [NPH+23] CodeGen-Mono-16.1B [NPH+23] Replit [Rep23] StarCoder [LAZ+23]350M | 350M 16.1B 2.7B 15.5B | 577B 577B 525B 1T | 19% 38% 37% 51% | 13% 29% 22% 34% |
phi-1-base phi-1-small phi-1 | 1.3B 350M 1.3B | 7B 7B 7B | 37% 45% 52% | 29% 45% 51% |
См. Таблицу 2 для наших результатов с phi-1 и конкурирующими моделями. Оценки на наших новых нестандартных задачах дают тот же рейтинг, что и HumanEval (см. Таблицу 1). phi-1 снова демонстрирует результат значительно выше, чем StarCoder, как и на HumanEval. Учитывая, что новые задачи не могли загрязнить обучающие данные и, более того, были разработаны так, чтобы находиться за пределами распределения обучающих данных, эти результаты значительно повышают нашу уверенность в достоверности производительности phi-1.
На Рисунке 2.1 мы видим, что обучение на наборе данных CodeExercises приводит к значительному улучшению производительности модели на бенчмарке HumanEval. Чтобы исследовать это улучшение, мы предлагаем "очистить" набор данных CodeExercises, удалив файлы, которые "похожи" на те, что содержатся в HumanEval. Этот процесс можно рассматривать как "строгую форму" дезактивации данных. Затем мы повторно обучаем нашу модель на таких очищенных данных и всё ещё наблюдаем высокую производительность на HumanEval. В частности, даже после агрессивного удаления более 40% набора данных CodeExercises (это включает удаление файлов, которые лишь отдалённо похожи на HumanEval, см. Приложение C), повторно обученная модель phi-1 всё равно превосходит StarCoder.
Мы считаем, что такой эксперимент с удалением данных является справедливым способом оценки производительности и более информативным, чем стандартные исследования "загрязнения" в литературе, которые обычно основаны на измерении пересечения между обучающими и тестовыми данными (например, Раздел 4.8 в [*]). Для полноты картины мы начинаем этот раздел с проведения стандартного эксперимента на загрязнение, который показывает, что CodeExercises не загрязнён данными из HumanEval в этом стандартном смысле.
N-граммы измеряют схожесть текстовых сегментов на основе общих последовательностей из n слов. Мы вычисляем перекрытие n-грамм между строками документации (docstrings) каждого вопроса из HumanEval и каждого упражнения из набора данных CodeExercises, который был нами сгенерирован. Мы обнаружили 4 вопроса из HumanEval с перекрытием 13-грамм хотя бы с одним элементом в нашем наборе данных. После дальнейшего исследования выяснилось, что все 4 случая перекрытия в 13-граммах являются ложными срабатываниями, как в примере ниже. Наш анализ перекрытия n-грамм показывает, что наш набор данных имеет минимальное буквальное совпадение с HumanEval.
HumanEval:
Вам дан непустой список положительных целых чисел. Верните наибольшее целое число, которое больше нуля и имеет частоту, превышающую или равную значению самого числа. Частота числа — это количество раз, которое оно встречается в списке.
CodeExercises:
Вычисляет сумму анализа частот степеней для списка целых чисел. Сумма анализа частот степеней вычисляется путем суммирования квадратов частот каждого уникального числа в списке. Частота числа — это количество раз, которое оно встречается в списке.
Как мы только что увидели, анализ n-грамм недостаточно точен для поиска схожих фрагментов кода между HumanEval и CodeExercises. Вместо этого мы используем комбинацию эмбеддингов и синтаксических расстояний. Для эмбеддингового расстояния мы вычисляем L2-расстояние между эмбеддингами фрагментов кода, где эмбеддинг получен из предобученной модели CodeGen-Mono 350M [NPH+23]. Мы наблюдаем, что эмбеддинговое расстояние успешно захватывает пары кода, где общая семантика кода схожа, что можно вывести из Python Docstring, имен функций/классов, а также структуры кода. Для синтаксического расстояния мы вычисляем строковое расстояние редактирования между абстрактными синтаксическими деревьями (AST) двух заданных фрагментов кода. Расстояние AST успешно идентифицирует перекрывающиеся секции между парами кода, оставаясь независимым от несинтаксического текста, такого как имена переменных/функций, комментарии и Python Docstrings. Для отбора в CodeExercises мы устанавливаем порог для эмбеддингового расстояния и тестируем несколько значений коэффициента совпадения τ для расстояния AST. См. Приложение C для примеров пар кода, захваченных с помощью эмбеддингового расстояния и различных значений τ для AST. Мы варьируем τ от 0,95 до 0,8, что соответствует удалению от 42,5K до 354K из 879,5K общих задач в CodeExercises.
Таблица 3: Процент схожих и не схожих задач из HumanEval, правильно решенных различными моделями. Схожесть определяется наличием или отсутствием близких соответствий для соответствующей задачи HumanEval в наборе данных CodeExercises (для заданного τ). Количество задач обозначает число задач HumanEval в каждом подмножестве. Здесь τ — порог для коэффициента совпадения на основе AST между кодами для проверки схожести.
τ | Кол-во задач | phi-1 | phi-1 retrained on pruned data | StarCoder Prompted [*] | |
0.95 | похожие | 71 | 81.7% | 74.6% | 57.7% |
0.9 | похожие | 93 | 63.4% | 51.6% | 48.4% |
0.85 | похожие | 106 | 62.3% | 52.8% | 47.2% |
0.8 | похожие | 116 | 59.5% | 52.6% | 45.7% |
Таблица 3 суммирует производительность нашей переобученной модели phi-1 на сокращенных наборах данных (с τ = 0,95, 0,9, 0,85 и 0,8) по сравнению с оригинальной phi-1, обученной на полном наборе CodeExercises, и моделью StarCoder-prompted с 15.5 миллиардами параметров. Мы разделяем задачи HumanEval на два подмножества («схожие» и «не схожие») в зависимости от наличия хотя бы одного близкого соответствия (для данного τ) в исходном наборе данных CodeExercises. Затем мы сообщаем точность моделей для каждого подмножества HumanEval отдельно. Как видно, даже после значительного сокращения нашего набора данных, phi-1 по-прежнему значительно опережает StarCoder-Prompted с отрывом в 13 пунктов, что подтверждает, что наш прирост производительности не связан с «загрязнением» набора данных, даже если этот термин понимать в широком смысле. Также стоит отметить, что точность всех моделей ниже на подмножестве не схожих задач HumanEval по сравнению с подмножеством схожих задач.
Качественный и хорошо составленный учебник может предоставить студенту необходимые знания для освоения нового предмета, и наша работа показывает значительное влияние высококачественных данных на повышение мастерства языковой модели в задачах генерации кода. Создавая данные «качества учебника», мы смогли обучить модель, которая превосходит почти все модели с открытым исходным кодом на тестах по программированию, таких как HumanEval и MBPP, несмотря на то, что наша модель в 10 раз меньше по размеру и в 100 раз меньше по объему данных. Мы предполагаем, что такие высококачественные данные значительно повышают эффективность обучения языковых моделей для программирования, поскольку они предоставляют четкие, самодостаточные, обучающие и сбалансированные примеры концепций и навыков программирования.
Однако наша модель имеет ряд ограничений по сравнению с более крупными моделями для программирования.
Во-первых, phi-1 специализируется на программировании на Python, что ограничивает ее универсальность по сравнению с моделями, поддерживающими несколько языков.
Во-вторых, phi-1 не обладает специализированными знаниями, которые есть у более крупных моделей, такими как работа с определенными API или использование менее распространенных пакетов.
Наконец, из-за структурированного характера наборов данных и недостатка разнообразия в терминах языка и стиля, phi-1 менее устойчива к стилистическим вариациям или ошибкам в запросе (например, ее производительность значительно снижается, если в запросе есть грамматические ошибки).
Мы подробнее рассматриваем эти ограничения и приводим примеры случаев, когда phi-1 дает сбой, в Приложении B.
Ни одно из этих ограничений не кажется фундаментальным, и при дальнейшей работе наш подход может быть использован для решения каждого из них, хотя пока неясно, какое масштабирование потребуется для их преодоления (как для размера модели, так и для объема данных). Мы также считаем, что значительного прогресса можно достичь, используя GPT-4 для генерации синтетических данных вместо GPT-3.5, поскольку мы заметили, что данные GPT-3.5 содержат много ошибок. Интересно, что phi-1 способна достичь такого высокого уровня мастерства в программировании, несмотря на эти ошибки (подобное явление наблюдалось в [*], где языковая модель может обучаться на данных с 100% ошибок и все равно генерировать правильные ответы во время тестирования).
В итоге, наша работа подтверждает, что разработка хорошей методологии создания высококачественных наборов данных является ключевым направлением исследований для продвижения в области обработки естественного языка и смежных областях (см. также [*]). Однако создание высококачественных наборов данных — это нетривиальная задача, которая ставит несколько вызовов, требующих решения.
Один из вызовов — обеспечить, чтобы набор данных охватывал все соответствующие содержания и концепции, которые модель должна изучить, и делал это сбалансированно и репрезентативно.
Другой вызов — обеспечить, чтобы набор данных был действительно разнообразным и не повторяющимся, чтобы модель не переобучалась на данных или не запоминала конкретные шаблоны или решения. Это требует поиска способов внедрения случайности и творчества в процесс генерации данных, сохраняя при этом качество и связность примеров.
Более того, даже после создания таких наборов данных у нас нет хорошей методологии для измерения и оценки уровня разнообразия и избыточности в данных. Например, если у нас есть набор данных с упражнениями по программированию, сложно определить, сколько различных вариаций каждого упражнения существует и как они распределены по набору данных. Наконец, поскольку сами языковые модели будут использоваться для генерации данных для будущих языковых моделей, это повышает актуальность этических и социальных последствий обучения таких моделей, таких как подотчетность, прозрачность и предвзятость данных и моделей, участвующих в этом процессе.
Ссылки[ADF+ 23] Rohan Anil, Andrew M Dai, Orhan Firat, Melvin Johnson, Dmitry Lepikhin, Alexandre Passos, Siamak Shakeri, Emanuel Taropa, Paige Bailey, Zhifeng Chen, et al. Palm 2 technical report. arXiv preprint arXiv:2305.10403, 2023.
[ALK+ 23] Loubna Ben Allal, Raymond Li, Denis Kocetkov, Chenghao Mou, Christopher Akiki, Carlos Munoz Ferrandis, Niklas Muennighoff, Mayank Mishra, Alex Gu, Manan Dey, et al. Santacoder: don’t reach for the stars! arXiv preprint arXiv:2301.03988, 2023.
[AON+ 21] Jacob Austin, Augustus Odena, Maxwell Nye, Maarten Bosma, Henryk Michalewski, David Dohan, Ellen Jiang, Carrie Cai, Michael Terry, Quoc Le, et al. Program synthesis with large language models. arXiv preprint arXiv:2108.07732, 2021.
[AZL23] Zeyuan Allen-Zhu and Yuanzhi Li. Physics of language models: Part 1, context-free grammar. arXiv preprint arXiv:2305.13673, 2023.
[BBH+ 22] Sid Black, Stella Biderman, Eric Hallahan, Quentin Anthony, Leo Gao, Laurence Golding, Horace He, Connor Leahy, Kyle McDonell, Jason Phang, Michael Pieler, USVSN Sai Prashanth, Shivanshu Purohit, Laria Reynolds, Jonathan Tow, Ben Wang, and Samuel Weinbach. GPT-NeoX-20B: An open-source autoregressive language model. In Proceedings of the ACL Workshop on Challenges & Perspectives in Creating Large Language Models, 2022.
[BCE+ 23] S´ebastien Bubeck, Varun Chandrasekaran, Ronen Eldan, Johannes Gehrke, Eric Horvitz, Ece Kamar, Peter Lee, Yin Tat Lee, Yuanzhi Li, Scott Lundberg, et al. Sparks of artificial general intelligence: Early experiments with gpt-4. arXiv preprint arXiv:2303.12712, 2023.
[BGMMS21] Emily M Bender, Timnit Gebru, Angelina McMillan-Major, and Shmargaret Shmitchell. On the dangers of stochastic parrots: Can language models be too big? In Proceedings of the 2021 ACM Conference on Fairness, Accountability, and Transparency, pages 610–623, 2021.
[BJT+ 22] Mohammad Bavarian, Heewoo Jun, Nikolas Tezak, John Schulman, Christine McLeavey, Jerry Tworek, and Mark Chen. Efficient training of language models to fill in the middle. arXiv preprint arXiv:2207.14255, 2022.
[BMR+ 20] Tom Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared D Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, Sandhini Agarwal, Ariel Herbert-Voss, Gretchen Krueger, Tom Henighan, Rewon Child, Aditya Ramesh, Daniel Ziegler, Jeffrey Wu, Clemens Winter, Chris Hesse, Mark Chen, Eric Sigler, Mateusz Litwin, Scott Gray, Benjamin Chess, Jack Clark, Christopher Berner, Sam McCandlish, Alec Radford, Ilya Sutskever, and Dario Amodei. Language models are few-shot learners. In Advances in Neural Information Processing Systems, volume 33, pages 1877– 1901, 2020.
[CND+ 22] Aakanksha Chowdhery, Sharan Narang, Jacob Devlin, Maarten Bosma, Gaurav Mishra, Adam Roberts, Paul Barham, Hyung Won Chung, Charles Sutton, Sebastian Gehrmann, et al. Palm: Scaling language modeling with pathways. arXiv preprint arXiv:2204.02311, 2022.
[CTJ+ 21] Mark Chen, Jerry Tworek, Heewoo Jun, Qiming Yuan, Henrique Ponde de Oliveira Pinto, Jared Kaplan, Harri Edwards, Yuri Burda, Nicholas Joseph, Greg Brockman, et al. Evaluating large language models trained on code. arXiv preprint arXiv:2107.03374, 2021.
[DFE+ 22] Tri Dao, Dan Fu, Stefano Ermon, Atri Rudra, and Christopher R´e. Flashattention: Fast and memory-efficient exact attention with io-awareness. Advances in Neural Information Processing Systems, 35:16344–16359, 2022.
[DLT+ 23] Yann Dubois, Xuechen Li, Rohan Taori, Tianyi Zhang, Ishaan Gulrajani, Jimmy Ba, Carlos Guestrin, Percy Liang, and Tatsunori B Hashimoto. Alpacafarm: A simulation framework for methods that learn from human feedback. arXiv preprint arXiv:2305.14387, 2023.
[EL23] Ronen Eldan and Yuanzhi Li. Tinystories: How small can language models be and still speak coherent english? arXiv preprint arXiv:2305.07759, 2023. [GWS+ 23] Arnav Gudibande, Eric Wallace, Charlie Snell, Xinyang Geng, Hao Liu, Pieter Abbeel, Sergey Levine, and Dawn Song. The false promise of imitating proprietary llms. arXiv preprint arXiv:2305.15717, 2023.
[HBM+ 22] Jordan Hoffmann, Sebastian Borgeaud, Arthur Mensch, Elena Buchatskaya, Trevor Cai, Eliza Rutherford, Diego de las Casas, Lisa Anne Hendricks, Johannes Welbl, Aidan Clark, Tom Hennigan, Eric Noland, Katherine Millican, George van den Driessche, Bogdan Damoc, Aurelia Guy, Simon Osindero, Karen Simonyan, Erich Elsen, Oriol Vinyals, Jack William Rae, and Laurent Sifre. An empirical analysis of compute-optimal large language model training. In Alice H. Oh, Alekh Agarwal, Danielle Belgrave, and Kyunghyun Cho, editors, Advances in Neural Information Processing Systems, 2022.
[HNA+ 17] Joel Hestness, Sharan Narang, Newsha Ardalani, Gregory Diamos, Heewoo Jun, Hassan Kianinejad, Md Mostofa Ali Patwary, Yang Yang, and Yanqi Zhou. Deep learning scaling is predictable, empirically. arXiv preprint arXiv:1712.00409, 2017.
[JWJ+ 23] Jaehun Jung, Peter West, Liwei Jiang, Faeze Brahman, Ximing Lu, Jillian Fisher, Taylor Sorensen, and Yejin Choi. Impossible distillation: from low-quality model to high-quality dataset & model for summarization and paraphrasing. arXiv preprint arXiv:2305.16635, 2023.
[KLA+ 22] Denis Kocetkov, Raymond Li, Loubna Ben Allal, Jia Li, Chenghao Mou, Carlos Mu˜noz Ferrandis, Yacine Jernite, Margaret Mitchell, Sean Hughes, Thomas Wolf, et al. The stack: 3 tb of permissively licensed source code. arXiv preprint arXiv:2211.15533, 2022.
[KMH+ 20] Jared Kaplan, Sam McCandlish, Tom Henighan, Tom B Brown, Benjamin Chess, Rewon Child, Scott Gray, Alec Radford, Jeffrey Wu, and Dario Amodei. Scaling laws for neural language models. arXiv preprint arXiv:2001.08361, 2020.
[LAZ+ 23] Raymond Li, Loubna Ben Allal, Yangtian Zi, Niklas Muennighoff, Denis Kocetkov, Chenghao Mou, Marc Marone, Christopher Akiki, Jia Li, Jenny Chim, et al. Starcoder: may the source be with you! arXiv preprint arXiv:2305.06161, 2023.
[LCC+ 22] Yujia Li, David Choi, Junyoung Chung, Nate Kushman, Julian Schrittwieser, R´emi Leblond, Tom Eccles, James Keeling, Felix Gimeno, Agustin Dal Lago, et al. Competition-level code generation with alphacode. Science, 378(6624):1092–1097, 2022.
[LGK+ 23] Zinan Lin, Sivakanth Gopi, Janardhan Kulkarni, Harsha Nori, and Sergey Yekhanin. Differentially private synthetic data via foundation model apis 1: Images. arXiv preprint arXiv:2305.15560, 2023.
[LXWZ23] Jiawei Liu, Chunqiu Steven Xia, Yuyao Wang, and Lingming Zhang. Is your code generated by chatgpt really correct? rigorous evaluation of large language models for code generation. arXiv preprint arXiv:2305.01210, 2023.
[LXZ+ 23] Ziyang Luo, Can Xu, Pu Zhao, Qingfeng Sun, Xiubo Geng, Wenxiang Hu, Chongyang Tao, Jing Ma, Qingwei Lin, and Daxin Jiang. Wizardcoder: Empowering code large language models with evol-instruct, 2023.
[LYR+ 23] Shayne Longpre, Gregory Yauney, Emily Reif, Katherine Lee, Adam Roberts, Barret Zoph, Denny Zhou, Jason Wei, Kevin Robinson, David Mimno, et al. A pretrainer’s guide to training data: Measuring the effects of data age, domain coverage, quality, & toxicity. arXiv preprint arXiv:2305.13169, 2023.
[MMJ+ 23] Subhabrata Mukherjee, Arindam Mitra, Ganesh Jawahar, Sahaj Agarwal, Hamid Palangi, and Ahmed Awadallah. Orca: Progressive learning from complex explanation traces of gpt-4. arXiv preprint arXiv:2306.02707, 2023.
[MRB+ 23] Niklas Muennighoff, Alexander M Rush, Boaz Barak, Teven Le Scao, Aleksandra Piktus, Nouamane Tazi, Sampo Pyysalo, Thomas Wolf, and Colin Raffel. Scaling data-constrained language models. arXiv preprint arXiv:2305.16264, 2023.
[NHX+ 23] Erik Nijkamp, Hiroaki Hayashi, Caiming Xiong, Silvio Savarese, and Yingbo Zhou. Codegen2: Lessons for training llms on programming and natural languages. arXiv preprint arXiv:2305.02309, 2023.
[NPH+ 22] Erik Nijkamp, Bo Pang, Hiroaki Hayashi, Lifu Tu, Huan Wang, Yingbo Zhou, Silvio Savarese, and Caiming Xiong. Codegen: An open large language model for code with multi-turn program synthesis. arXiv preprint, 2022.
[NPH+ 23] Erik Nijkamp, Bo Pang, Hiroaki Hayashi, Lifu Tu, Huan Wang, Yingbo Zhou, Silvio Savarese, and Caiming Xiong. Codegen: An open large language model for code with multi-turn program synthesis. ICLR, 2023.
[Ope23] OpenAI. Gpt-4 technical report, 2023. arXiv preprint arXiv:2303.08774 [cs.CL]. [Rep23] Replit. Replit dev day. https://twitter.com/Replit/status/ 1651344184593506304, 2023.
[RSR+ 20] Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, and Peter J Liu. Exploring the limits of transfer learning with a unified text-to-text transformer. The Journal of Machine Learning Research, 21(1):5485–5551, 2020.
[SLP+ 21] Jianlin Su, Yu Lu, Shengfeng Pan, Bo Wen, and Yunfeng Liu. Roformer: Enhanced transformer with rotary position embedding. arXiv preprint arXiv:2104.09864, 2021.
[SSZ+ 23] Ilia Shumailov, Zakhar Shumaylov, Yiren Zhao, Yarin Gal, Nicolas Papernot, and Ross Anderson. Model dementia: Generated data makes models forget. arXiv preprint arXiv:2305.17493, 2023
[TGZ+ 23] Rohan Taori, Ishaan Gulrajani, Tianyi Zhang, Yann Dubois, Xuechen Li, Carlos Guestrin, Percy Liang, and Tatsunori B. Hashimoto. Stanford alpaca: An instruction-following llama model. https://github.com/tatsu-lab/stanford_alpaca, 2023.
[VSP+ 17] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, L ukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in Neural Information Processing Systems, volume 30, 2017.
[WKM+ 22] Yizhong Wang, Yeganeh Kordi, Swaroop Mishra, Alisa Liu, Noah A Smith, Daniel Khashabi, and Hannaneh Hajishirzi. Self-instruct: Aligning language model with self generated instructions. arXiv preprint arXiv:2212.10560, 2022.
[WLG+ 23] Yue Wang, Hung Le, Akhilesh Deepak Gotmare, Nghi DQ Bui, Junnan Li, and Steven CH Hoi. Codet5+: Open code large language models for code understanding and generation. arXiv preprint arXiv:2305.07922, 2023.
[WTB+ 22] Jason Wei, Yi Tay, Rishi Bommasani, Colin Raffel, Barret Zoph, Sebastian Borgeaud, Dani Yogatama, Maarten Bosma, Denny Zhou, Donald Metzler, Ed H. Chi, Tatsunori Hashimoto, Oriol Vinyals, Percy Liang, Jeff Dean, and William Fedus. Emergent abilities of large language models. Transactions on Machine Learning Research, 2022. Survey Certification.
[YGK+ 23] Da Yu, Sivakanth Gopi, Janardhan Kulkarni, Zinan Lin, Saurabh Naik, Tomasz Lukasz Religa, Jian Yin, and Huishuai Zhang. Selective pre-training for private fine-tuning. arXiv preprint arXiv:2305.13865, 2023.
[ZXZ+ 23] Qinkai Zheng, Xiao Xia, Xu Zou, Yuxiao Dong, Shan Wang, Yufei Xue, Zihan Wang, Lei Shen, Andi Wang, Yang Li, Teng Su, Zhilin Yang, and Jie Tang. Codegeex: A pre-trained model for code generation with multilingual evaluations on humaneval-x, 2023.
В Разделе 3 мы обсудили на нескольких примерах, как дообученные модели демонстрируют значительное улучшение по сравнению с базовой моделью при выполнении задач, которые не представлены в наборе данных для дообучения. Здесь мы предоставляем дополнительные примеры и детали, чтобы проиллюстрировать эти улучшения.
Следующий пример является сложным из-за обилия различных логических операторов, таких как «и» и «не», которые связывают множество утверждений. До файнтюнинга модель путается в логике, заложенной в утверждении. Она с трудом различает «элементы» и «индексы» и не уверена, какой массив использовать. Напротив, дообученная модель успешно идентифицирует все соответствующие массивы и индексы, корректно реализуя логические операторы.
Prompt: Input is an array A, an array B, an array C, an array E, a numpy matrix D. I want to find all the indices of D whose elements are in the union of B and C and whose row index is not in A and column index is in D. Loop through the elements in D. Return the list of indices.
Промпт: Входные данные: массив A, массив B, массив C, массив E, матрица numpy D. Найди все индексы матрицы D, элементы которых находятся в объединении B и C, и чей индекс строки не входит в A, а индекс столбца входит в D. Пройдись по элементам матрицы D. Верни список индексов.
# phi-1
indices = []
for i in range(D.shape[0]):
for j in range(D.shape[1]):
if D[i][j] in B or D[i][j] in C:
if i not in A and j in D:
indices.append((i,j))
return indices
# phi-1-base
indices = []
for i in range(len(D)):
for j in range(len(D[i])):
if D[i][j] in B and D[i][j] not in A:
indices.append(j)
return indices
# phi-1-small
indices = []
for i in range(D.shape[1]):
if D[0][i] in B and D[0][i] not in A and D[i][0] in C and D[i][0] not in E:
indices.append(i)
return indices
Пример с PyTorch.
В этом примере с использованием PyTorch мы просим модель написать модифицированный шаг обновления градиента:
Prompt: Write a pytorch function. The input is a model, take the gradient of each parameter of the model, do an SVD of each gradient to get U, Sigma, V, take the top k singular values of Sigma as Sigmak, then do a update step to the parameter using Uk*Sigmak * Vk times the norm of the parameter.
Промпт: Напиши функцию на PyTorch. Входные данные — это модель. Возьми градиент каждого параметра модели, выполни сингулярное разложение (SVD) каждого градиента, чтобы получить U, Sigma, V, возьми топ-k сингулярных значений Sigma как Sigma k, затем выполни шаг обновления параметра, используя Uk * Sigma k * Vk, умноженное на норму параметра.
# phi-1
...
for p in model.parameters():
if p.grad is not None:
U, Sigma, V = p.grad.svd()
Sigmak = Sigma[:k].diag()
p.data.add_(torch.mm(U[:,:k], torch.mm(Sigmak, V[:k,:])).mul_(norm))
# phi-1-base
...
self.model = model
self.k = k
self.eps = eps
self.max_iter = max_iter
self.verbose = verbose
self.svd_u = None
self.svd_sigma = None
self.svd_v = None
self.svd_k = None
self.svd_u_k = None
...
# phi-1-small
def svd(x):
u, s, v = np.linalg.svd(x)
return u, s, v
def update_parameter(parameter, grad):
u, s, v = svd(grad)
parameter = u[:, :k]
np.diag(s[:k]) v[:k, :]
parameter += np.diag(sigmoid(parameter))
return parameter
Код, созданный моделью phi-1-small, демонстрирует недостаточное понимание API и ограничения в понимании задачи, что приводит к нескольким значительным ошибкам. Во-первых, он использует np.linalg.svd(x)
, что несовместимо с тензорами PyTorch
. Во-вторых, он ошибочно присваивает результат SVD непосредственно параметру, отклоняясь от инструкции в запросе, где требуется добавить его. С другой стороны, phi-1-base полностью теряется и выдает лишь последовательность бессмысленных определений. Это указывает на то, что улучшение способности модели к логическому рассуждению (даже для простых функций) может значительно повысить общую способность модели к написанию кода.
Пример с Pyplot
Последний пример связан с использованием API Pyplot. Модель обычно хорошо справляется с Pyplot, поэтому мы разработали сложную задачу, попросив модель реализовать анимацию.
Prompt: Create an x array that are integers from 1 to 20, y array that is equal to the
elementwise cos of x divided by element-wise sqrt(x + 1). Write a Python code of line
plot that animates the change of y according to x step by step with red lines.
However, during the animation, when x[i] is larger than 11, change the animation line
color from red to green.Промпт: Создай массив x, состоящий из целых чисел от 1 до 20, и массив y, равный cos x каждого элемента, деленному на квадратный корень из (x + 1) каждого элемента. Напиши код на Python для построения линейного графика, который анимирует изменение y в зависимости от x шаг за шагом с использованием красных линий. Однако во время анимации, когда x[i] становится больше 11, изменит цвет линии анимации с красного на зеленый.
# phi-1
...
x = np.arange(1, 21)
y = np.cos(x) / np.sqrt(x + 1)
fig, ax = plt.subplots()
line, = ax.plot([], [], color='red')
...
ax.set_title('Animation of Cosine and Cosine-Square-Root')
def animate(i):
if x[i] > 11:
line.set_color('green')
else:
line.set_color('red')
line.set_data(x[:i+1], y[:i+1])
return line,
anim = animation.FuncAnimation(fig, animate, frames=len(x), interval=500, blit=True)
plt.show()
# phi-1-base
...
fig, ax = plt.subplots()
x = np.arange(1, 21)
y = np.cos(x) / np.sqrt(x + 1)
line, = ax.plot([], [], lw=2)
def init():
line.set_data([], [])
return line,
def animate(i):
if x[i] > 11:
line.set_color('green')
else:
line.set_color('red')
return line,
anim = FuncAnimation(fig, animate, init_func=init, frames=len(x), interval=50, blit=True)
# phi-1-small
...
fig, ax = plt.subplots()
x_array = list(range(1, 21))
y_array = [math.cos(xi/10) for xi in x_array]
def animate(i):
...
ax.plot(x_array, y_array)
if x_array[i] > 11:
color = "red"
else:
color = "green"
ax.scatter(x_array[i],
y_array[i], color=color)
return ax
ani = animation.FuncAnimation(fig, animate, frames=len(x_array), interval=50, blit=True)
plt.show()
phi-1-small выдает некорректный результат. С точки зрения API, модель не понимает требование «линейный график» и использует только точечный график (и даже он реализован неправильно). phi-1-base правильно понимает шаблон, но упускает основную функцию для обновления линейного графика на каждой итерации.
Хотя дообучение на простых упражнениях значительно улучшает общую производительность модели, существуют определенные ограничения, присущие нашей модели, которые невозможно преодолеть только за счет файнтюнинга. Во-первых, наша модель имеет всего 1,3 миллиарда параметров и обучалась на 7 миллиардах токенов, что ограничивает ее способность справляться с более сложными задачами, такими как разработка сложного приложения на Flask, по сравнению с другими моделями, такими как Starcoder. Помимо ограничений нашей модели в плане универсальности по сравнению с StarCoder или ChatGPT, мы также выделили несколько других слабых сторон:
Чувствительность к вариациям в запросах.
Наша модель чувствительна к различным изменениям в запросах. Во-первых, ее производительность значительно снижается с увеличением длины запроса, так как она склонна игнорировать, забывать или неправильно интерпретировать части запроса, если он слишком длинный. Например, наша модель не справляется, когда мы увеличиваем количество слоев с 3 до 4 в следующем случае. Мы предполагаем, что эта проблема возникает из-за того, что наши упражнения в основном состоят из коротких запросов. Кроме того, результат генерации может качественно отличаться при незначительном изменении запроса. В этом случае, с добавлением команды import torch
, модель часто успешно справляется с задачей, которая ранее вызывала у нее затруднения.
Пример запроса 1:
Create a neural network class in Pytorch with 3 layers. Implement a new "rr" method to this new function: It takes input x. Apply the first layer on x and assign the output to y, then apply the second layer on y and assign the output to z, then apply the third layer on z and assign it to w, then sum up y, z, w and assign it to Q. Return Q
Создай класс нейронной сети на PyTorch с 3 слоями. Реализуй новый метод "rr" для этой функции: Он принимает входные данные x. Примени первый слой к x и присвой результат y, затем примени второй слой к y и присвой результат z, затем примени третий слой к z и присвой результат w, затем сложи y, z, w и присвой результат Q. Верни Q.
class NeuralNetwork(nn.Module):
def __init__(self):
super(NeuralNetwork, self).__init__()
self.layer1 = nn.Linear(2, 5)
self.layer2 = nn.Linear(5, 3)
self.layer3 = nn.Linear(3, 1)
def rr(self, x):
y = self.layer1(x)
z = self.layer2(y)
w = self.layer3(z)
Q = y + z + w
return Q
Пример запроса 2:
Create a neural network class in Pytorch with 4 layers. Implement a new "rr" method to this new function: It takes input x. Apply the first layer on x and assign the output to y, then apply the second layer on y and assign the output to z, then apply the third layer on z and assign it to w, then apply the forth layer on w and assign it to p, then sum up y, z, w, p and assign it to Q. Return Q.
Создай класс нейронной сети на PyTorch с 4 слоями. Реализуй новый метод "rr" для этой функции: Он принимает входные данные x. Примени первый слой к x и присвой результат y, затем примени второй слой к y и присвой результат z, затем примени третий слой к z и присвой результат w, затем примени четвертый слой к w и присвой результат p, затем сложи y, z, w, p и присвой результат Q. Верни Q.
class NeuralNetwork:
def __init__(self):
self.layers = []
def add_layer(self, layer):
self.layers.append(layer)
...
def rr(self, x):
y = self.forward(x)
z = self.forward(y)
w = self.forward(z)
p = self.forward(w)
Q = y + z + w + p
return Q
Пример запроса 3:
import torch
Create a neural network class in Pytorch with 4 layers. Implement a new "rr" method to this new function: It takes input x. Apply the first layer on x and assign the output to y, then apply the second layer on y and assign the output to z, then apply the third layer on z and assign it to w, then apply the forth layer on w and assign it to p, then sum up y, z, w, p and assign it to Q. Return Q.
import torch
Создай класс нейронной сети на PyTorch с 4 слоями. Реализуй новый метод "rr" для этой функции: Он принимает входные данные x. Примени первый слой к x и присвой результат y, затем примени второй слой к y и присвой результат z, затем примени третий слой к z и присвой результат w, затем примени четвертый слой к w и присвой результат p, затем сложи y, z, w, p и присвой результат Q. Верни Q.
class NeuralNetwork(torch.nn.Module):
def __init__(self):
super(NeuralNetwork, self).__init__()
self.layer1 = torch.nn.Linear(10, 20)
...
def forward(self, x):
x = torch.nn.functional.relu(self.layer1(x))
y = torch.nn.functional.relu(self.layer2(x))
z = torch.nn.functional.relu(self.layer3(y))
w = torch.nn.functional.relu(self.layer4(z))
p = torch.nn.functional.relu(self.output(w))
Q = p + y + z + w
return Q
Чувствительность к естественным языковым запросам
Модель phi-1 демонстрирует меньшую устойчивость к обработке естественного языка по сравнению с ChatGPT или StarCoder, особенно в случае неоднозначных запросов. Это может быть связано с тем, что мы исключили определенные типы данных из процесса обучения, чтобы гарантировать качество на уровне учебника.
Например, наша модель испытывает трудности с термином «неизменный» (unchanged) и с интерпретацией нумерованных списков в запросе.
Пример запроса 1:
Alice is moving a point along x,y axes at every iteration. Every time Alice moves the point randomly with one of the options: (1). x increases by 2, y decreases by 5; (2). x increases by 1, y decreases by 2, (3). x stays unchanged, y increase by 4. Simulate the movement of the points.
Алиса перемещает точку вдоль осей x и y на каждой итерации. Каждый раз Алиса перемещает точку случайным образом одним из вариантов: (1) x увеличивается на 2, y уменьшается на 5; (2) x увеличивается на 1, y уменьшается на 2; (3) x остается неизменным, y увеличивается на 4. Смоделируй движение точки.
x, y = 0, 0
for i in range(10):
move = random.choice([1, 2,3])
if move == 1:
x += 2
y -= 5
elif move == 2:
x += 1
y -= 2
elif move == 3:
x = 0
y += 4
return f"Alice's final position is ({x}, {y})."
Пример запроса 2:
Alice is moving a point along x,y axes at every iteration. Every time Alice moves the point randomly with one of the options: (1). x increases by 2, y decreases by 5; (2). x increases by 1, y decreases by 2, (3). x stays at x, y increase by 4. Simulate the movement of the points.
Алиса перемещает точку вдоль осей x и y на каждой итерации. Каждый раз Алиса перемещает точку случайным образом одним из вариантов: (1) x увеличивается на 2, y уменьшается на 5; (2) x увеличивается на 1, y уменьшается на 2; (3) x остается равным x, y увеличивается на 4. Смоделируй движение точки.
x, y = 0, 0
for i in range(10):
move = random.choice([1, 2, 3])
if move == 1:
x += 2
y -= 5
elif move == 2:
x += 1
y -= 2
elif move == 3:
x = x
y += 4
print(f"Alice moved {move}
point to ({x}, {y})")
Пример запроса 3:
Alice is moving a point along x,y axes at every iteration. Every time Alice moves the point randomly with one of the options: (1). move by (2, -5); (2). move by (1, 2); (3). move by (0, 4); Simulate the movement of the points.
Алиса перемещает точку вдоль осей x и y на каждой итерации. Каждый раз Алиса перемещает точку случайным образом одним из вариантов: (1) перемещение на (2, -5); (2) перемещение на (1, 2); (3) перемещение на (0, 4); Смоделируй движение точки.
x, y = 0, 0
for i in range(n):
move = random.choice([(1, 2), (2, -5), (1, 2), (3, 0), (0, 4)])
x += move[0]
y += move[1]
return f"Alice moved {x} units to the right and {y} units down after {n} iterations."
# Note: the model hallucinates the moves (1, 2), (3, 0).
Эти примеры показывают, что модель phi-1 может испытывать трудности с интерпретацией естественного языка, особенно если присутствуют неоднозначные или сложные конструкции. Это подчеркивает необходимость дальнейшего улучшения модели в плане обработки естественного языка и повышения ее устойчивости к вариативным запросам.
Плохая способность к счету и пространственному мышлению
Одним из основных ограничений нашей модели, особенно в сравнении с альтернативами, такими как StarCoder, является ее производительность на задачах, связанных с подсчетом и пространственным мышлением. Модель с трудом поддерживает точные данные о количестве и расположении элементов в сцене. Чтобы проиллюстрировать это, рассмотрим следующий пример:
Пример запроса:
Generate a
tkinter
application, I want two textfields side by side at the top, three buttons at the bottom, one named A on the left, one named B on the right, one named C at the middle.Создай приложение на
tkinter
. Мне нужно два текстовых поля, расположенных рядом в верхней части, три кнопки в нижней части: одна с именем A слева, одна с именем B справа и одна с именем C по центру.
# phi-1
...
text_a = tk.Text(root, width=30, height=5)
text_b = tk.Text(root, width=30, height=5)
text_c = tk.Text(root, width=30, height=5)
# Create the buttons
button_a = tk.Button(root, text="A", width=10, height=2)
button_b = tk.Button(root, text="B", width=10, height=2)
button_c = tk.Button(root, text="C", width=10, height=2)
# Place the text fields and buttons in the top row
text_a.grid(row=0, column=0, padx=5, pady=5)
text_b.grid(row=0, column=1, padx=5, pady=5)
text_c.grid(row=0, column=2, padx=5, pady=5)
# Place the buttons in the bottom row
button_a.grid(row=1, column=0, columnspan=3, padx=5, pady=5)
button_b.grid(row=1, column=1, columnspan=3, padx=5, pady=5)
button_c.grid(row=1, column=2, columnspan=3, padx=5, pady=5)
...
# phi-1-small
window = tk.Tk()
window.title("TextFields")
# Create the left and right textfields
text1 = tk.Text(window, text="A")
text1.pack()
text2 = tk.Text(window, text="B")
text2.pack()
# Create the middle button
button = tk.Button(window, text="C")
button.pack()
# Start the tkinter application
window.mainloop()
# phi-1-base
root = tk.Tk()
root.title("Text Fields")
root.geometry("300x200")
root.resizable(False, False)
root.configure(background="white")
root.configure(font=("Arial", 12))
root.configure(foreground="black")
root.configure(relief="groove")
root.configure(padx=10, pady=10)
root.configure(state="disabled")
# The model keeps outputting nonsensical code.
Несмотря на улучшения, достигнутые за счет дообучения, наша модель по-прежнему испытывает трудности с подсчетом и пространственным мышлением. Она создает лишнее текстовое поле и неправильно размещает кнопку в сцене.
В этом разделе мы предоставляем примеры пар кода, с разными коэффициентами совпадения AST. Кроме того, мы приводим пример пары кода, полученной с использованием эмбеддингового расстояния в качестве меры схожести.
Коэффициент совпадения AST = 1.0
Здесь задачи на программирование требуют одинакового логического рассуждения, хотя формулировки запросов могут значительно отличаться. В частности, в запросе используется реальное событие (например, расстояние между отверстиями на линии), чтобы неявно обучить модели базовой задаче нахождения ближайшей пары элементов в массиве.
HumanEval
from typing import List, Tuple
def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
""" From a supplied list of numbers (of
length at least two) select and return two
that are the closest to each
other and return them in order (smaller
number, larger number).
>>> find_closest_elements([1.0, 2.0, 3.0,
4.0, 5.0, 2.2])
(2.0, 2.2)
>>> find_closest_elements([1.0, 2.0, 3.0,
4.0, 5.0, 2.0])
(2.0, 2.0)
"""
numbers.sort()
min_diff = float('inf')
closest_pair = None
for i in range(len(numbers) - 1):
diff = numbers[i+1] - numbers[i]
if diff < min_diff:
min_diff = diff
closest_pair = (numbers[i], numbers[i
+1])
return closest_pair
CodeExercises
from typing import List, Tuple
def find_closest_two_holes(holes: List[int]) -> (int, int):
"""
Finds the two closest holes on a line.
Args:
holes: A list of integers representing
the positions of holes on a line.
Returns:
A tuple of two integers representing the
positions of the two closest holes on the
line.
"""
holes.sort()
min_distance = float('inf')
closest_holes = None
for i in range(len(holes) - 1):
distance = holes[i+1] - holes[i]
if distance < min_distance:
min_distance = distance
closest_holes = (holes[i], holes[i+1])
return closest_holes
Коэффициент совпадения AST = 0.96
Здесь две задачи используют схожие логические рассуждения и концепции программирования, но их запросы требуют выполнения разных задач, например, возвращение пары чисел в отличие от вычисления их среднего значения.
HumanEval
from typing import List
def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
""" From a supplied list of numbers (of
length at least two) select and return two
that are the closest to each
other and return them in order (smaller
number, larger number).
>>> find_closest_elements([1.0, 2.0, 3.0,
4.0, 5.0, 2.2])
(2.0, 2.2)
>>> find_closest_elements([1.0, 2.0, 3.0,
4.0, 5.0, 2.0])
(2.0, 2.0)
"""
numbers.sort()
min_diff = float('inf')
closest_pair = None
for i in range(len(numbers) - 1):
diff = numbers[i+1] - numbers[i]
if diff < min_diff:
min_diff = diff
closest_pair = (numbers[i], numbers[i+1])
return closest_pair
CodeExercises
from typing import List
def find_closest_pair_average(li: List[int]) -> float:
"""
Returns the average of the two integers in
the list that are closest to each other.
If there are multiple pairs with the same
minimum difference, the function returns the
average of the first pair it encounters.
Args:
- li: a list of integers
Returns:
- a float representing the average of the two
integers in the list that are closest to
each other
"""
li.sort()
min_diff = float('inf')
closest_pair = None
for i in range(len(li)-1):
diff = li[i+1] - li[i]
if diff < min_diff:
min_diff = diff
closest_pair = (li[i], li[i+1])
return sum(closest_pair) / 2
Коэффициент совпадения AST ≤ 0.9
Когда коэффициент совпадения AST ≤ 0.9, пары кода становятся менее схожими, так как их структура и логика начинают значительно отличаться. Здесь уровень совпадения AST (абстрактного синтаксического дерева) составляет 0.9 и 0.83 соответственно.
HumanEval
from typing import List
def all_prefixes(string: str) -> List[str]:
""" Return list of all prefixes from
shortest to longest of the input string
>>> all_prefixes('abc')
['a', 'ab', 'abc']
"""
prefixes = []
for i in range(len(string)):
prefixes.append(string[:i+1])
return prefixes
CodeExercises
from typing import List
def increase_after_each(li: List[int]) -> List[int]:
"""
Given a list of integers, returns a new list
where each element is increased by the
number of elements in the original list that
come after it.
Args:
- li: A list of integers
Returns:
- A new list of integers where each element
is increased by the number of elements in
the original list that come after it.
"""
result = []
for i in range(len(li)):
result.append(li[i] + len(li[i+1:]))
return result
HumanEval
from typing import List
def rescale_to_unit(numbers: List[float]) -> List[float]:
""" Given list of numbers (of at least two
elements), apply a linear transform to that
list, such that the smallest number will
become 0 and the largest will become 1
>>> rescale_to_unit([1.0, 2.0, 3.0, 4.0,
5.0])
[0.0, 0.25, 0.5, 0.75, 1.0]
"""
min_num = min(numbers)
max_num = max(numbers)
return [(num - min_num) / (max_num - min_num) for num in numbers]
CodeExercises
from typing import List
def frequency_ranges_plot(values: List[float]) -> List[List[int]]:
"""
Returns a list of lists where each inner list
represents a frequency range and contains
the count of values
that fall within that range. The ranges are
determined by dividing the range of values
into 10 equal parts.
Args:
- values: A list of float values
Returns:
- A list of lists where each inner list
contains two integers representing the lower
and upper bounds of the range
and the count of values that fall within that
range.
"""
min_val = min(values)
max_val = max(values)
range_size = (max_val - min_val) / 10
ranges = [[min_val + i*range_size, min_val + (i+1)*range_size, 0] for i in ange(10)]
for val in values:
for i, r in enumerate(ranges):
if r[0] <= val < r[1]:
ranges[i][2] += 1
break
return [[int(r[0]), int(r[1]), r[2]] for r in ranges]
Эмбеддинговое расстояние = 0.16
Здесь две задачи имеют схожие Python Docstrings, имена функций, а также структуру кода, что можно выявить с помощью L2-расстояния между нормализованными эмбеддингами CodeGen-Mono 350M для каждой из них.
HumanEval
def sum_product(numbers: List[int]) -> Tuple[int, int]:
""" For a given list of integers, return a
tuple consisting of a sum and a product of
all the integers in a list.
Empty sum should be equal to 0 and empty
product should be equal to 1.
>>> sum_product([])
(0, 1)
>>> sum_product([1, 2, 3, 4])
(10, 24)
"""
sum_value = 0
prod_value = 1
for n in numbers:
sum_value += n
prod_value *= n
return sum_value, prod_value
CodeExercises
from typing import List, Tuple
def all_numbers_sum_product(numbers: List[int]) -> Tuple[int,int]:
"""
Returns a tuple containing the sum and
product of all the numbers in the input list.
Args:
- numbers (List[int]): a list of integers
Returns:
- a tuple containing two integers:
- the sum of all the numbers in the input
list
- the product of all the numbers in the
input list
"""
sum_of_numbers = 0
product_of_numbers = 1
for num in numbers:
sum_of_numbers += num
product_of_numbers *= num
return (sum_of_numbers, product_of_numbers)