Двуязычный словарь от ChatGPT за 7 (нет) простых шагов

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

Предыстория

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

1. Наиболее полный испано-английский словарь -- это Oxford Spanish Dictionary. Его лицензия даже дозволяет коммерческое использование API, однако:
   6.1.2 You will not cache, store, or save Content.

   6.1.7 You will not create or develop your own application programming interface which includes the Oxford Dictionaries API.(source)

   Каждый раз ожидать ответа от сервера и вешать на себя дополнительные технические риски (пьяный британский экскаваторщик, кабель, классика) мне показалось не слишком удобным. Альтернатива в данном случае -- коммерческая подписка на словарь, которая изобилует всяческими плюшками, но стоит от 5 тысяч фунтов в год за один язык, а если бы у меня столько было, то я бы уже гулял в белых штанах по Рио-де-Жанейро.

2. Некий опенсорсный словарь авторства юзера mananoreboton (ссылка). Содержит 45 тысяч записей и отдельный словарь с глаголами. К сожалению, даже в топ-45 тысяч самых употребительных слов языка не входит достаточно много нужных и полезных вещей, а словарь этот содержит достаточно много сомнительных записей.

3. Дамп Викисловаря. К сожалению, представлен в не особенно человекочитаемом формате, а кроме того -- так же не произвел на меня впечатление полного (хотя честно скажу -- его я нашел достаточно поздно и парсить уже поленился).

4. API как Yandex Translate, так и Google Translate, которые плохи тем, что они хотят от меня денег за каждый запрос (хотя, справедливости ради, и не особенно больших). Кроме того, есть бесплатный API Yandex Словаря, который а) производит впечатление отложенного на дальнюю полку вместе с самим сервисом Словаря, б) содержит в лицензионном соглашении интересные положения, от банального ограничения на 10000 запросов в день, до былинного:

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

   Нет, спасибо.

5. Ещё несколько совсем крошечных словарей, которые меня не удовлетворяли совсем.

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

Гипотеза

Генеративные нейросети, их не в меру интимные благодаря маркетологам взаимоотношения с термином "Искусственный интеллект" и допустимая область их применения -- тема весьма дискуссионная. Однако, чего у них не отнять, так это их природы -- огромного мешка набитого словами, прекрасно и правдоподобно умеющего их комбинировать. Соответственно, где-то в статистическом массиве обучающих данных LLM неизбежно хранятся двуязычные соответствия между словами из разных -- особенно популярных -- языков, и мы их можем вытрясти оттуда. Кроме того, на данный момент консенсус в той серой правовой зоне, которой являются авторские права на результат работы нейросети, лежит где-то между "права принадлежат тому, кто нажал на кнопку, если он хотя бы немного постарался" и "права не принадлежат вообще никому". Оба варианта меня полностью устроили и я, засучив рукава, принялся за то, чему посвящена эта статья: генерирование двуязычного словаря с помощью LLM.

Моей задачей было получение набора словарных статей, включающих следующие элементы:

1. Слово на испанском языке: trabajo

2. Его перевод на английский язык с указанием частей речи: work (noun); job (noun); to work (noun)

3. Два предложения-примера употребления испанского слова: 'example_1': 'No puedo soportar cuando otros están trabajando. Voy a acostarme.',
   'example_2': 'El trabajo no es un lobo - en el bosque no se escapa.'

4. Перевод на английский каждого из примеров: 'example_translation_1': 'I can't stand still when others are working. I'm going to bed.',
   'example_translation_2': 'Work is not a wolf - it does not run away in the forest.'

Выбор модели

Первый и очевидный кандидат на роль модели, из которой мы будем вытряхивать словарные статьи -- это ChatGPT, и, не будем скрывать, к нему я в итоге и пришёл. Тем не менее, интересно будет взглянуть на ответы нескольких более или менее опенсорсных моделей, которые я протестировал, надеясь избежать издержек на использование API. Запрос к модели в общем случае выглядел так:

from llama_cpp import Llama, LlamaGrammar

# Универсальный промпт
class Prompt():

    def __init__(self, word, from_language = "Spanish", to_language = "English"):
        self.text = """
Instruction:
You get a {from_language} word. List its possible translations to {to_language}. List as much translations as possible, preferrably all of them. Order the list in descending order of likelihood (commonness) of translation. After each word indicate the part of speech as it is done in dictionaries. Then provide two different sentences in {from_language} in which the words are used and their translations to {to_language}. 
if the word has several translations, the example sentences should employ different meanings of the word. Leave no additional comment.

Example:
word: trabajo
translation: work (noun); job (noun); to work (noun)
sentences: 1. No puedo soportar cuando otros están trabajando. Voy a acostarme. 2. El trabajo no es un lobo - en el bosque no se escapa.

Task:
word: {word}
translation:""".format(word = word, to_language = to_language, from_language = from_language)

# Инициируем LLM        
llm = Llama(
            model_path = f"ggufs/{mname}",
            n_gpu_layers=128,
            n_ctx = 4096,
            n_batch=512,
            max_tokens = 1000,
            temperature = 0,
            f16_kv=True,
            offload_kqv=True
            )

# Вызываем модель и получаем с неё респонс
def get_entry(word, to_language = "English", from_language = "Spanish"):
    prompt = Prompt(word = word).text
    output_json = llm(prompt,
                max_tokens=1000,
                      temperature = 0.6,
                stop=["\n\n\n"]
                          )
    output_text = output_json["choices"][0]["text"]
    return output_text

  

Исполнение запроса на Tesla A100 занимало примерно 1-2 секунды. Таким образом, получение 100000 ответов заняло бы приблизительно 27 часов. Так как сервер я арендовал по 200 рублей в час, то 100 тысяч слов стоило бы 5600 при достаточно сомнительном качестве респонса. Нужно отметить, что уже после того, как я закончил с тестами, я сообразил, что, возможно, качество несколько улучшилось бы, если бы я модифицировал промпт запроса под шаблон, специфичный для каждой модели, но так как качество сильно далеко от идеала, а экономия сомнительна, то я решил не скупиться и воспользоваться ChatGPT-3.5-Turbo.

Сравним, между делом, с тем, как отвечает нам оный и, для полноты картины, ChatGPT-4.

Очевидно, что оба на две ноздри впереди конкурентов по качеству и стабильности ответов. При этом ChatGPT-4 ощутимо лучше, чем 3.5, но всерьёз я использование этой модели не рассматривал из-за её цены: я предварительно оценивал расходы на использование ChatGPT-3.5 как приблизительно $30 на 100 тысяч слов. Учитывая, что обращение к ChatGPT-4 стоит примерно в 60 раз дороже, я прикинул, что столько не зарабатываю. Тем не менее, если у вас коммерческое предприятие, то можно рассмотреть вложение в более качественную модель для получения соответствующего результата.

Подготовка базы слов

Итак, вы решили узнать, как переводится каждое слово в испанском языке. Что вам для этого нужно? Для начала -- каждое слово в испанском языке.

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

Предобработка списка слов включала в себя следующие этапы:

0. Чтение датасета.

   Тривиальное чтение json-файла, после которого мы обнаруживаем, что список изобилует такими словами как "111111111", "IrakconferenciaEEUUIráncena" и "Tiwontchik".

1. Простая фильтрация

   Часть мусорных слов представлялось возможным отсеять чисто техническими средствами. Для этого я использовал функцию с несколькими эвристиками (которую за меня писал ChatGPT) и отфильтровал все слова, на которые она вернула False. Эвристики были следующими: а) никаких заглавных букв после первой; б) никаких знаков пунктуации; в) никаких повторов четырёх и больше гласных подряд; г) никаких чисел. Кроме того, я отфильтровал все строки, содержащие числа.

2. Лемматизация

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

   После этих манипуляций мы остаёмся с более чем миллионом уникальных словоформ. Нам столько очевидно не нужно -- платим мы за слова, а Оксфордский англо-испанский словарь содержит всего 300 тысяч записей. Перед нами не стоит задачи обогнать его по полноте. В дальнейшем я буду работать с самыми частотными 100 тысячами слов (а также протестирую работу алгоритма на словах из категорий 100-200 тысяч и 200-300 тысяч).

3. Исключение несуществующих слов и слов с опечатками

   Оказавшийся наиболее трудоёмким этап предобработки. Дело в том, что исключив очевидный мусор, мы до сих пор не избавились от множества благообразно выглядящих, но не существующих слов, вроде "epaf" или "debu". Наличие этих слов в датасете вызывает к жизни две проблемы:

   1. Увеличение количества посылаемых в платный API токенов.

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

   Чистить датасет мы будем так же с помощью ChatGPT-3.5. Здесь мне потребовалось две итерации, так как первый опыт оказался неудачным. Первая, не оправдавшая себя, гипотеза состояла в том, чтобы в лоб спросить у модели: "Является ли это настоящим испанским словом, написанным без ошибок?". Соответственно, запрос к модели выглядел как-то так:

def check_word(word, to_language):
    chat_completion = client.chat.completions.create(model="gpt-3.5-turbo",
                                                   messages=[{"role": "system", "content": f"You are a specialist in {to_language} dictionaries."},
                                                             {"role": "user", "content": f"Is {word} a legit, correctly spelled Spanish word? Answer strictly 'Yes' or 'No'. Do not provide any explanation."}]
                )
    answer = chat_completion.choices[0].message.content
    if "yes" in answer.lower():
        return True
    else:
        chat_completion = client.chat.completions.create(model="gpt-3.5-turbo",
                                                       messages=[{"role": "system", "content": f"You are a specialist in {to_language} dictionaries."},
                                                                 {"role": "user", "content": f"Is {word} a legit, correctly spelled Spanish word? Answer strictly 'Yes' or 'No'. Do not provide any explanation."}]
                    )
        answer = chat_completion.choices[0].message.content
        if "no" in answer.lower():
            return False
        else:
            return True

Выполнение такого запроса использовало в среднем около 50 токенов. Обработка 100 тысяч слов вышла примерно в $12.

Языковые модели кодируют текст, разбивая его на части и присваивая каждой такой части уникальное цифровое значение. Одна такая часть называется токеном. Самый очевидный вариант токенизации -- разбиение текста по отдельным словам. Тем не менее, этот подход обладает определенными недостатками (самый очевидный из них -- раздувание набора уникальных токенов за счёт форм одного слова) и на данный момент state of the art-решением является использование меньших значимых частей -- в простом случае, морфем слова (на самом деле нет, но из бытовых понятий -- ближе всего к морфемам в русском языке и к целым словам -- в английском).

Оценить, сколько токенов содержит наш текст, можно на странице токенизатора ChatGPT.

Пример работы токенизатора

Кроме того, для Python существует библиотека с моднейшим названием tiktoken. она позволяет получить кодировки строк под определенные модели. Путём нехитрой манипуляции получаем из неё то же число:

Я так и не понял, как вставить код под спойлер :(

Наконец, количество токенов содержится в ответе API:

Объект chat_completion

Почему число токенов -- это важно? Потому что OpenAI берёт деньги именно за число токенов в запросе. Для версии 3.5 цена составляет $0.0005 за 1000 токенов в запросе и $0.0015 за 1000 токенов в ответе. Для ChatGPT-4 это $0.03 за 1000 токенов в запросе и $0.06 за 1000 токенов в ответе.

К сожалению, этот эксперимент оказался неудачным. Ответы модели оказались нестабильны как по содержанию, так и по формату. Приблизительно в трети случаев модель признавала неверное слово -- верным (что обидно, но терпимо) или верное -- не существующим (что уже критично). Нужно было искать альтернативный путь, и я решил попробовать просить модель исправить орфографические ошибки в слове, если они есть. Таким образом, если модель что-то исправляла, то я или сохранял слово (если оно было новым) или убирал (если оно дублировало одно из существующих). Запрос теперь выглядел так:

def spelling(word, to_language):
    chat_completion = client.chat.completions.create(model="gpt-3.5-turbo",
                                                   messages=[{"role": "system", "content": f"You are a specialist in {to_language} dictionaries."},
                                                             {"role": "user", "content": f"Correct any spelling errors in the following {to_language} word: {word}. If there are no errors, do not change anything. Return corrected word. If the word is not close to any existing word, return 'Not a word'. Do not provide any explanation."}]
                )

    answer = chat_completion.choices[0].message.content

    #повторная попытка в случае, если модель вернула явно неверный ответ
    stop_counter = 0
    while (len(answer.split(" ")) > 2) and (answer != "Not a word") and (stop_counter < 1):
        stop_counter += 1
        chat_completion = client.chat.completions.create(model="gpt-3.5-turbo",
                                                       messages=[{"role": "system", "content": f"You are a specialist in {to_language} dictionaries."},
                                                                 {"role": "user", "content": f"Correct any spelling errors in the following {to_language} word: {word}. If there are no errors, do not change anything. Return corrected word. If the word is not close to any existing word, return 'Not a word'. Do not provide any explanation. It is important to return only one word or 'Not a word'!"}]
                    )
        answer = chat_completion.choices[0].message.content
    return answer

Получение одного ответа занимало около двух секунд. Можно посчитать, что обработка 100000 запросов занимает приблизительно 55 часов, что печально. Однако, мы не будем отчаиваться раньше времени и распараллелим запрос.

def split_list(lemmas_list, chunk_size = 600): 
    chunks = list()
    num_chunks = len(lemmas_list) // chunk_size + 1
    for i in range(num_chunks):
        chunks.append(lemmas_list[i*chunk_size:(i+1)*chunk_size])
    return chunks

lemma_chunks = split_list(lemmas_list)

spelling_checked_words = []
def check_call(word):
    spelling_checked_words.append({"word" : word, "spelling" : spelling(word, "Spanish")})

        
def parallel_openai_requests(prompts):
    with concurrent.futures.ThreadPoolExecutor() as executor:
        results = list(executor.map(check_call, prompts))

    return results

for chunk in tq.tqdm(lemma_chunks):
    start = time.time()
    parallel_openai_requests(chunk)
    end = time.time()
    if (end - start) < 60:
        time.sleep(60 - (end - start) + 5)

Мы подаём запросы группами по 600 слов. Если обработка всех слов занимает меньше минуты, то мы ждём оставшееся время, чтобы не превысить ограничение на число токенов в минуту (в моём случае -- это 5000 токенов). Это позволило сократить время обработки до нескольких часов. Это стоило мне 12 долларов.

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

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

Я тривиальным образом заменил все ответы, в которые входили следующие слова:

"No errors." , "No errors" , "No changes needed.", "No corrections needed",
"No errors found." , "No changes." , "No spelling errors.", "No changes necessary.",
"No cambios", "No correction"

на то слово, к которому они сгенерировались, а те, в которые входили следующие значения:

"Not a word.", "No word", "No suggestions.", "No es una palabra", "No word.", "No a word", "No existing word.", "No suggestion", "No existe"

на стандартный ответ "Not a word" (без точки).

Кроме того, популярным форматов ответов оказался ответ вида: "ampgo -> amigo". Здесь мы просто делим строку по "->/s" и берем последний элемент.

Такой набор манипуляций позволил привести к корректному виду подавляющее большинство ответов. После всех фильтров, в нашем датасете из 100000 уникальных слов осталось 59888 предположительно корректных и уникальных значений. Можно переходить к оформлению запроса к LLM.

Генерация словарных статей

Перейдём к основной части наших трудов. В первой итерации запрос к API выглядит следующим образом:

# Промпт для генерирования словарной статьи для конкретного слова
class Prompt():

    def __init__(self, word, from_language = "Spanish", to_language = "English"):
        self.text = """
Instruction:
You get a {from_language} word. You need to prepare its dictionary entry. List its possible translations to {to_language}. List as much translations as possible, preferrably all of them. Order the list in descending order of likelihood (commonness) of translation. After each word indicate the part of speech as it is done in dictionaries. Then provide two different sentences in {from_language} in which the words are used and their translations to {to_language}. 
if the word has several translations, the example sentences should employ different meanings of the word. Leave no additional comment. Do not include translations of the sentences to English. If you can not translate a word, return empty strings.

Example:
input word: trabajo
'translation': 'work (noun); job (noun); to work (noun)',
 'example_1': 'No puedo soportar cuando otros están trabajando. Voy a acostarme.',
 'example_2': 'El trabajo no es un lobo - en el bosque no se escapa.',
 'example_translation_1': 'I can't stand still when others are working. I'm going to bed.',
 'example_translation_2': 'Work is not a wolf - it does not run away in the forest.'
""".format(word = word, to_language = to_language, from_language = from_language)

        # Формальная грамматика для определенной пары языков
        class Grammar(BaseModel):
            translation: str = Field(..., description=f"List of all possible translations of the input word from {from_language} to {to_language}.")
            example_1: str = Field(..., description=f"An example of a sentence in which the input word is used in {from_language}.")
            example_2: str = Field(..., description=f"An example of a sentence in which the input word is used in {from_language}. Should be different from example_1.")
            example_translation_1: str = Field(..., description=f"Translation of example_1 from {from_language} to {to_language}.")
            example_translation_2: str = Field(..., description=f"Translation of example_2 from {from_language} to {to_language}.")
                                        

        self.schema = Grammar.schema()
# Функция, возвращающая JSON
def return_entry(translation, example_1, example_2, example_translation_1, example_translation_2):
    """Get dictionary entry of a word."""
    return {"translation" : translation, "example_1" : example_1, "example_2" : example_2, "example_translation_1" : example_translation_1, "example_translation_2" : example_translation_2}

# Запрос к модели с использованием грамматики
def get_entry_grammar(word, to_language = "English", from_language = "Spanish"):
    prompt = Prompt(word = word, to_language = to_language, from_language = from_language)   
    chat_completion = client.chat.completions.create(model="gpt-3.5-turbo",
                                                   messages=[{"role": "system", "content": prompt.text},
                                                             {"role": "user", "content": "The word is: " + word}], 
                                                    tools = [{
            "type": "function",
            "function": {
                "name": "return_entry",
                "description": "Get dictionary entry of a word.",
                "parameters" :     prompt.schema
            }}])
    return chat_completion.choices[0].message.tool_calls[0].function.arguments

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

Я прогнал данный запрос на 1000 слов и наткнулся на неожиданный и неприятный факт: запросы выходили существенно дороже, чем я ожидал (сказывалось использование грамматики, практически удваивавшей число токенов в запросе). При этом 80% токенов, которые я использовал в этом тексте, пришлись на токены промпта, а не токены ответа. Вариант сокращать промпт я рассматривать не мог -- он и так достаточно лаконичен. Поэтому я решил попробовать улучшить соотношение токенов промпта и ответа, получая несколько ответов в одном запросе.

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

from pydantic import conlist 

class PromptMultiple():

    def __init__(self, words, from_language = "Spanish", to_language = "English"):
      #примеры
        ex1 = """{'translation': 'work (noun); job (noun); to work (noun)',
 'example_1': 'No puedo soportar cuando otros están trabajando. Voy a acostarme.',
 'example_2': 'El trabajo no es un lobo - en el bosque no se escapa.',
 'example_translation_1': 'I can't stand still when others are working. I'm going to bed.',
 'example_translation_2': 'Work is not a wolf - it does not run away in the forest.'}"""
        ex2 = """{'translation': 'new (adj)',
 'example_1': 'Mira como un carnero a la nueva puerta.',
 'example_2': 'Una nueva escoba barre en una nueva.',
 'example_translation_1': 'Look like a ram at the new door.',
 'example_translation_2': 'A new broom sweeps as a new one.'}"""
        
        self.text = """
Instruction:
You get a sequence of {from_language} words: {words}. You need to prepare their dictionary entries. List their possible translations to {to_language}. List as much translations as possible, preferrably all of them. Order the list in descending order of likelihood (commonness) of translation. After each word indicate the part of speech as it is done in dictionaries (in {from_language}, please!). Then provide two different sentences in {from_language} in which the words are used and their translations to {to_language}. 
if the word has several translations, the example sentences should employ different meanings of the word. Leave no additional comment. Do not include translations of the sentences to English. If you can not translate a word, return empty strings for this particular word only.
Return a valid JSON to pass into a function for preparing dictionary entries. JSON must include an entry for each word in a sequence.
The format is the following: {{"word_entry_1" : {{"translation" : "", "example_1" : "", "example_2" : "", "example_translation_1" : "", "example_translation_2" : ""}}, ..., "word_entry_n" : {{"translation" : "", "example_1" : "", "example_2" : "", "example_translation_1" : "", "example_translation_2" : ""}}}} for each of N words in a sequence. Ensure that the format is followed.
Example:
[user input]: ["trabajo", "nuevo"]
[your response]:
"word_entry_1" : {ex1},
"word_entry_2" : {ex2}
""".format(to_language = to_language, from_language = from_language, ex1 = ex1, ex2 = ex2, words = str(words))

        #схема словарной статьи
        class WordEntry(BaseModel):
            translation: str = Field(..., description=f"List of all possible translations of the input word from {from_language} to {to_language}.")
            example_1: str = Field(..., description=f"An example of a sentence in which the input word is used in {from_language}.")
            example_2: str = Field(..., description=f"An example of a sentence in which the input word is used in {from_language}. Should be different from example_1.")
            example_translation_1: str = Field(..., description=f"Translation of example_1 from {from_language} to {to_language}.")
            example_translation_2: str = Field(..., description=f"Translation of example_2 from {from_language} to {to_language}.")

        #схема списка словарных статей
        class Grammar(BaseModel):
            word_entry_1: WordEntry = Field(..., description = f"Dictionary entry for {words[0]}")
            word_entry_2: WordEntry = Field(..., description = f"Dictionary entry for {words[1]}")
            # <///> - сократил для статьи
            word_entry_19: WordEntry = Field(..., description = f"Dictionary entry for {words[18]}")
            word_entry_20: WordEntry = Field(..., description = f"Dictionary entry for {words[19]}")

        self.schema = Grammar.schema()
        self.word_schema = WordEntry.schema()

def return_entries(word_entry_1, word_entry_2, word_entry_3, word_entry_4, word_entry_5, word_entry_6, word_entry_7, word_entry_8, word_entry_9, word_entry_10,
                   word_entry_11, word_entry_12, word_entry_13, word_entry_14, word_entry_15, word_entry_16, word_entry_17, word_entry_18, word_entry_19, word_entry_20
                  ):
    """Get dictionary entry of a sequence of words."""
    
    return [{"translation" : entry.translation, "example_1" : entry.example_1, "example_2" : entry.example_2, "example_translation_1" : entry.example_translation_1, "example_translation_2" : entry.example_translation_2} for entry in [word_entry_1, word_entry_2, word_entry_3, word_entry_4, word_entry_5]]

Во-вторых, итеративным процессом разбазаривания личных фондов на исследование самообучения было выяснено, что ответы склонны к впадению в одну из ересей:

1. Возвращение строки, не соответствующей схеме, которую мы запрашиваем.

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

Чтобы сразу выловить такие ошибки, напишем некоторые вспомогательные функции:

from jsonschema import validate

# Функция, которая выкидывает ошибку, если ответ не соответствует формату
def validate_output_error(model_response, bunch_size):
    schema = {
        "type" : "object",
        "properties" : {
           f"word_entry_{n}": {
          "type": "object",
          "properties": {
            "translation": {
              "type": "string"
            },
            "example_1": {
              "type": "string"
            },
            "example_2": {
              "type": "string"
            },
            "example_translation_1": {
              "type": "string"
            },
            "example_translation_2": {
              "type": "string"
            }
          },
          "required": [
            "translation",
            "example_1",
            "example_2",
            "example_translation_1",
            "example_translation_2"
          ]
        } for n in range(1, bunch_size + 1)
        }
    }
    if type(model_response) == str:
        model_response = ast.literal_eval(model_response)
    validate(instance = model_response, schema=schema)
    return model_response

# Функция, которая извлекает значения определенного поля из всех статей в наборе
def extract_fields(entry, field):
    entries_list = []
    for word_entry in entry:
        entries_list.append(entry[word_entry][field].replace(",", ";"))
    return entries_list

# Функция, которая проверяет, что поле translation в ответе не заполнено пустыми строками
def validate_empty_translations(model_response):
    if type(model_response) == str:
        model_response = ast.literal_eval(model_response)
        translations = extract_fields(model_response, "translation")
        translations = "".join(translations)
        if translations == "":
            return False
        else:
            return True

Автор понимает тяжесть своих грехов некоторую неэффективность этих проверок (скажем, literal_eval вызывается на одну и ту же строку неоднократно), однако нужно принять во внимание, что на время работы запроса к модели время, занятое работой CPU составляет примерно несколько миллисекунд, остальное время -- простой в ожидании ответа от API. Таким образом, оптимизация локальных вычислений не даст практически никакого выигрыша, так что оставляю как есть.

Сам запрос пришлось немного усложнить, встроив в него валидации:

def get_entry_grammar(words, to_language = "English", from_language = "Spanish"):
    prompt = PromptMultiple(words = words, to_language = to_language, from_language = from_language) 
    chat_completion = client.chat.completions.create(model="gpt-3.5-turbo",
                                                   messages=[{"role": "system", "content": prompt.text},
                                                             {"role": "user", "content": "The words are: " + str(words)}], 
                                                    tools = [{
            "type": "function",
            "function": {
                "name": "return_entries",
                "description": "Get dictionary entry for each word in a list. Used when a translation is requested for a sequence of .",
                "parameters" :     prompt.schema,
                
            }}],
                                                    )

    response = chat_completion.choices[0].message.tool_calls[0].function.arguments
    validate_output_error(response, 20)

    
    if validate_empty_translations(response) == False:
        chat_completion = client.chat.completions.create(model="gpt-3.5-turbo",
                                               messages=[{"role": "system", "content": prompt.text},
                                                         {"role": "user", "content": "You translated nothing, try again. The words are: " + str(words)}], 
                                                tools = [{
        "type": "function",
        "function": {
            "name": "return_entries",
            "description": "Get dictionary entry for each word in a list. Used when a translation is requested for a sequence of .",
            "parameters" :     prompt.schema,
            
        }}],
                                                )
        response = chat_completion.choices[0].message.tool_calls[0].function.arguments
        validate_output_error(response, 20)

    
    return ast.literal_eval(response)

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

Пример вызова функции:

%%time
get_entry_grammar(['amigo', 'trabajo'
                   , 'pueblo', 'habla', 'unido',  'ministro', 'pasar', 'persona', 'martes', 'primero', 
                   'tras', 'quien', 'después', 'hasta', 'acuerdo', 'prensa', 'si', 'tener', 'domingo', 'partido'
                  ])

CPU times: total: 15.6 ms
Wall time: 30.2 s

{'word_entry_1': {'translation': 'friend (noun)',
  'example_1': 'Mi mejor amigo me ayudó en tiempos difíciles.',
  'example_2': 'Me gusta salir con mis amigos los fines de semana.',
  'example_translation_1': 'My best friend helped me in difficult times.',
  'example_translation_2': 'I enjoy going out with my friends on weekends.'},
 'word_entry_2': {'translation': 'work (noun); job (noun); to work (verb)',
  'example_1': 'No puedo soportar cuando otros están trabajando. Voy a acostarme.',
  'example_2': 'El trabajo no es un lobo - en el bosque no se escapa.',
  'example_translation_1': "I can't stand still when others are working. I'm going to bed.",
  'example_translation_2': 'Work is not a wolf - it does not run away in the forest.'},
 'word_entry_3': {'translation': 'town (noun); people (noun)',
  'example_1': 'Vivo en un pequeño pueblo rodeado de naturaleza.',
  'example_2': 'El pueblo se unió para celebrar el Día de la Independencia.',
  'example_translation_1': 'I live in a small town surrounded by nature.',
  'example_translation_2': 'The people came together to celebrate Independence Day.'},
 'word_entry_4': {'translation': 'speech (noun); language (noun)',
  'example_1': 'Su discurso fue inspirador y poderoso.',
  'example_2': 'Él habla varios idiomas con fluidez.',
  'example_translation_1': 'His speech was inspiring and powerful.',
  'example_translation_2': 'He speaks multiple languages fluently.'},
 'word_entry_5': {'translation': 'united (adjective)',
  'example_1': 'La familia estaba unida en su deseo de prosperidad.',
  'example_2': 'Unidos somos más fuertes.',
  'example_translation_1': 'The family was united in their desire for prosperity.',
  'example_translation_2': 'United we are stronger.'},
 'word_entry_6': {'translation': 'minister (noun)',
  'example_1': 'El ministro de educación anunció nuevas reformas.',
  'example_2': 'El primer ministro está dando un discurso en la conferencia.',
  'example_translation_1': 'The Minister of Education announced new reforms.',
  'example_translation_2': 'The Prime Minister is giving a speech at the conference.'},
 'word_entry_7': {'translation': 'to pass (verb); to spend (verb)',
  'example_1': 'Pasaré el fin de semana en la playa con mis amigos.',
  'example_2': 'No puedo pasar sin café por la mañana.',
  'example_translation_1': 'I will spend the weekend at the beach with my friends.',
  'example_translation_2': "I can't go without coffee in the morning."},
 'word_entry_8': {'translation': 'person (noun)',
  'example_1': 'Cada persona tiene sus propias fortalezas y debilidades.',
  'example_2': 'Me encanta conocer a nuevas personas y aprender de ellas.',
  'example_translation_1': 'Every person has their own strengths and weaknesses.',
  'example_translation_2': 'I love meeting new people and learning from them.'},
 'word_entry_9': {'translation': 'Tuesday (noun)',
  'example_1': 'Vamos a tener una reunión importante el martes.',
  'example_2': 'Los martes son mi día favorito de la semana.',
  'example_translation_1': 'We are going to have an important meeting on Tuesday.',
  'example_translation_2': 'Tuesdays are my favorite day of the week.'},
 'word_entry_10': {'translation': 'first (adjective); first (adverb); firstly (adverb)',
  'example_1': 'El primer lugar en el concurso fue para ella.',
  'example_2': 'Primero, necesitamos analizar los datos antes de tomar una decisión.',
  'example_translation_1': 'She got the first place in the competition.',
  'example_translation_2': 'Firstly, we need to analyze the data before making a decision.'},
 'word_entry_11': {'translation': 'after (preposition); behind (preposition)',
  'example_1': 'El gato se escondió tras la cortina.',
  'example_2': 'El coche venía tras el camión.',
  'example_translation_1': 'The cat hid behind the curtain.',
  'example_translation_2': 'The car was coming after the truck.'},
 'word_entry_12': {'translation': 'who (pronoun)',
  'example_1': '¿Sabes quién es el ganador del concurso?',
  'example_2': 'Quien no arriesga, no gana.',
  'example_translation_1': 'Do you know who is the winner of the competition?',
  'example_translation_2': "Whoever doesn't take risks, doesn't win."},
 'word_entry_13': {'translation': 'after (preposition); later (adverb)',
  'example_1': 'Voy a tomar un descanso y después continuar con el trabajo.',
  'example_2': 'Después de la tormenta, sale el sol.',
  'example_translation_1': "I'm going to take a break and then continue with the work.",
  'example_translation_2': 'After the storm, the sun comes out.'},
 'word_entry_14': {'translation': 'until (preposition); to (preposition)',
  'example_1': 'Estudiaré hasta que termine el examen.',
  'example_2': 'Camina hasta la esquina y luego gira a la derecha.',
  'example_translation_1': 'I will study until the exam is finished.',
  'example_translation_2': 'Walk to the corner and then turn right.'},
 'word_entry_15': {'translation': 'agreement (noun)',
  'example_1': 'Llegamos a un acuerdo sobre el precio del coche.',
  'example_2': 'El acuerdo entre las dos partes fue justo y equitativo.',
  'example_translation_1': 'We reached an agreement on the price of the car.',
  'example_translation_2': 'The agreement between the two parties was fair and equitable.'},
 'word_entry_16': {'translation': 'press (noun)',
  'example_1': 'El presidente dio una conferencia de prensa para anunciar nuevas políticas.',
  'example_2': 'La prensa publicó un artículo sobre el evento.',
  'example_translation_1': 'The president gave a press conference to announce new policies.',
  'example_translation_2': 'The press published an article about the event.'},
 'word_entry_17': {'translation': 'if (conjunction)',
  'example_1': 'Si tienes tiempo, podemos salir a tomar algo.',
  'example_2': 'Si estudias, aprobarás el examen.',
  'example_translation_1': 'If you have time, we can go out for a drink.',
  'example_translation_2': 'If you study, you will pass the exam.'},
 'word_entry_18': {'translation': 'to have (verb); to possess (verb)',
  'example_1': 'Tengo hambre, ¿quieres pedir comida?',
  'example_2': 'Ella tiene mucho talento para la música.',
  'example_translation_1': "I'm hungry, do you want to order food?",
  'example_translation_2': 'She has a lot of talent for music.'},
 'word_entry_19': {'translation': 'Sunday (noun)',
  'example_1': 'Me gusta relajarme los domingos y descansar.',
  'example_2': 'Vamos a la iglesia todos los domingos por la mañana.',
  'example_translation_1': 'I like to relax on Sundays and rest.',
  'example_translation_2': 'We go to church every Sunday morning.'},
 'word_entry_20': {'translation': 'party (noun)',
  'example_1': 'Vamos a organizar una fiesta de cumpleaños sorpresa para Juan.',
  'example_2': 'El partido político presentó su plan para mejorar la economía.',
  'example_translation_1': 'We are going to organize a surprise birthday party for Juan.',
  'example_translation_2': 'The political party presented their plan to improve the economy.'}}

Кстати, внимательно вчитавшись в ответ, можно заметить редкую, но систематическую ошибку модели, которая вскрывает забавную вещь о том, как она генерирует ответ.

'word_entry_20': {'translation': 'party (noun)',
'example_1': 'Vamos a organizar una fiesta de cumpleaños sorpresa para Juan.',
'example_2': 'El partido político presentó su plan para mejorar la economía.',
'example_translation_1': 'We are going to organize a surprise birthday party for Juan.',
'example_translation_2': 'The political party presented their plan to improve the economy.'}}

Последнее слово "partido" действительно означает party, но только не party как вечеринка, а party в значении политической партии. В результате в примере модель, очевидно, взяла английское слово party, сгенерировала к нему пример (про вечеринку) и перевела на испанский -- естественно, в испанском примере слово partido исчезло, потому что переводить модель научилась куда лучше, чем составлять систематические ответы. Тем не менее, такого рода ошибка (к тому же, довольно редкая) не критична для моих задач. Куда хуже, что было потеряно второе значение слова partido -- матч/спортивная игра. Что ж -- мы не всесильны.

Ну и, наконец, распараллелим процесс. По ограничению токенов в минуту пролезает приблизительно 10 банчей по 20 слов в каждом.

%%time
import concurrent.futures

def split_dataframe(df, chunk_size = 20): 
    chunks = list()
    num_chunks = len(df) // chunk_size + 1
    for i in range(num_chunks):
        if len(df[i*chunk_size:(i+1)*chunk_size]) > 0:
            chunks.append(df[i*chunk_size:(i+1)*chunk_size])
    return chunks
  
price_test_entries = []
errors = []
words_processed = []
def openai_call(lemma_bunch):
    try:
        price_test_entries.append({"cohort" : cohort, "word" : lemma_bunch, "entry" : get_entry_grammar(lemma_bunch)})
    except Exception as e:
        try:
            price_test_entries.append({"cohort" : cohort, "word" : lemma_bunch, "entry" : get_entry_grammar(lemma_bunch)})
        except Exception as e2:
            errors.append({"cohort" : cohort, "word" : lemma_bunch, "entry" : str(e2)})
    words_processed.append(lemma_bunch)
        
def parallel_openai_requests(prompts):
    with concurrent.futures.ThreadPoolExecutor() as executor:
        # Map the function over the list of prompts in parallel
        results = list(executor.map(openai_call, prompts))

all_chunks = split_dataframe(split_dataframe(all_lemmas, chunk_size = 20), chunk_size = 10)

Здесь у нас в цикле появляется дополнительный параметр -- cohort. Он возникает из-за моего желания стратифицировать тест качества модели.

Валидация метода

Перед тем, как получить полный словарь с модели, желательно её провалидировать. Для этого мы, во-первых, создадим стратифицированную выборку -- случайным образом возьмём 400 слов из первых 100000 по частотности (после очистки) и по 800 слов из когорт 100-200 тысяч и 200-300 тысяч. Слова из средней и нижней когорт мы подвергнем той же чистке, которую проходила выборка топ-100 тысяч, после чего у нас останется 615 и 592 слова в этих когортах соответственно.

У нас всё готово для получения ответов модели для этих полутора тысяч слов. Подставляя список слов соответствующей когорты вместо all_lemmas в расположенном чуть выше коде, получаем тестовые респонсы модели в каждой из когорт. Тестируем чисто техническую работоспособность модели -- модель правда отрабатывает как надо (правда, около 10% банчей улетает в ошибки -- их приходится пропускать через модель несколько раз). Вся операция стоит нам около $1 -- значит, для 60000 слов мы потратим около $40, что близко к нашей оценке.

Тем не менее, хотелось бы валидировать также качество ответов, а не сам факт их получения. Возьмем простейшую метрику -- долю правильных ответов в каждой когорте. К сожалению, определить правильность ответа -- не такая тривиальная задача в отсутствие эталонного словаря. Проверять каждое слово по интернет-словарям вручную оказалось чудовищно медленно. Здесь я планировал написать длинную и грустную повесть о том, как я провёл несколько интересных (нет) вечеров, пытаясь вытрясти что-то внятное из API (да и просто скрэппинга) всех найденных мной публичных словарей, но потом передумал. Короче говоря, я обратился к API Yandex Translate. Качество переводов я нашёл сомнительным, но это было лучшее, что удалось получить (к тому же, они дают 4000 рублей на тестирование своего API новым аккаунтам).

Получив перевод каждого слова в тестовой выборке от Яндекса, я свёл переводы в таблицу такого вида:

Как этот милаш попал в верхнюю частотную когорту я не знаю

По верхним строкам таблицы мы уже можем наблюдать приятную вещь -- наш перевод кажется в среднем полнее, чем перевод от Яндекса. В частности, Яндекс почему-то не справился с частотным словом tercia и по очевидным причинам со словом puya, которое действительно на каком-то локальном жаргоне означает pointed sting used by toreador. Вопросы к моей выборке слов и анализу частотности в ней усиливаются, но ладно.

Чтобы сверить похожесть переводов, сначала я попытался использовать spacy.

Результат (справа) меня не устроил, поэтому я решил быть проще и использовал библиотеку fuzzywuzzy, основанную на старом-добром расстоянии Левенштейна.

Проведя краткую серию экспериментов, представленную на скриншоте выше, я пришёл к выводу, что коэффициент схожести больше 15 можно считать признаком близких переводов, а больше 30 -- практически гарантией. Это позволило мне вычислить долю хороших переводов в каждой когорте и получить достаточно приятный результат (см. таблицы ниже).

Приведены два варианта подсчета метрики: с исключением непереведенных (т.е. совпадающих в оригинале и в переводе -- возможно, мы теряем ещё часть одинаково пишущихся в двух языках слов) Яндексом слов и по всему списку тестовых слов. В любом случае, нижняя планка корректности в 80% (нижняя потому что визуально значительная часть несовпадений это проблема именно Яндекса) мне кажется весьма неплохой.

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

Хэппи-энд

Спустя несколько итераций исправления ошибок я получил словарь из 59360 непустых переводов. Это заняло 6 часов и почти ровно $25, что близко к моей изначальной оценке. Кроме того, $12 были потрачены на проверку орфографии в словах.

Репозиторий

Проект выложен под MIT-лицензией по адресу: https://github.com/IvanDubls/llm_dictionary. Я не возражаю против использования как готового словаря, так и кода (не очень, правда, читаемого) в различных проектах (буду, наоборот, рад).

Перспективы

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

Заключение

Конечно, прогноз LLM носит вероятностный характер, и словарь, составленный живыми экспертами будет корректнее, чем получающийся с помощью данного алгоритма. Тем не менее, такой словарь хорош своей относительной дешевизной. Мне кажется, он может найти своё применение в студенческих проектах и изготовлении MVP. В общем и целом, я считаю, что он удался как proof-of-concept. Я буду очень доволен собой, если он пригодится кому-то и очень рад, если кому-то было интересен какой-то кусочек этой статьи.