Точная настройка кода Llama на Amazon SageMaker JumpStart | Веб-сервисы Amazon

Сегодня мы рады объявить о возможности точной настройки моделей Code Llama с помощью Meta с помощью Amazon SageMaker JumpStart. Семейство больших языковых моделей (LLM) Code Llama представляет собой набор предварительно обученных и точно настроенных моделей генерации кода с масштабом от 7 до 70 миллиардов параметров. Тщательно настроенные модели Code Llama обеспечивают большую точность и объяснимость по сравнению с базовыми моделями Code Llama, о чем свидетельствует их тестирование на соответствие HumanEval и наборы данных MBPP. Вы можете точно настроить и развернуть модели Code Llama с помощью SageMaker JumpStart, используя Студия Amazon SageMaker Пользовательский интерфейс в несколько кликов или с помощью SageMaker Python SDK. Тонкая настройка моделей Лам производится на основе скриптов, представленных в репозиторий рецептов ламы на GitHub из Meta с использованием методов квантования PyTorch FSDP, PEFT/LoRA и Int8.

В этом посте мы рассмотрим, как точно настроить предварительно обученные модели Code Llama с помощью SageMaker JumpStart с помощью пользовательского интерфейса в один клик и использования SDK, доступного в следующих разделах. Репозиторий GitHub.

Что такое SageMaker JumpStart

С помощью SageMaker JumpStart специалисты по машинному обучению (ML) могут выбирать из широкого спектра общедоступных базовых моделей. Специалисты по машинному обучению могут развертывать базовые модели для выделенных Создатель мудреца Амазонки экземпляры из сетевой изолированной среды и настраивать модели с помощью SageMaker для обучения и развертывания моделей.

Что такое Код Лама

Code Llama — это специализированная версия Llama 2 который был создан путем дальнейшего обучения Llama 2 на наборах данных, специфичных для кода, и выборки большего количества данных из того же набора данных в течение длительного времени. Code Llama обладает расширенными возможностями кодирования. Он может генерировать код и естественный язык о коде как из кода, так и из подсказок на естественном языке (например, «Напишите мне функцию, которая выводит последовательность Фибоначчи»). Вы также можете использовать его для завершения кода и отладки. Он поддерживает многие из наиболее популярных языков программирования, используемых сегодня, включая Python, C++, Java, PHP, Typescript (JavaScript), C#, Bash и другие.

Зачем проводить тонкую настройку моделей Code Llama

Meta опубликовала тесты производительности Code Llama на HumanEval и MBPP для распространенных языков кодирования, таких как Python, Java и JavaScript. Производительность моделей Code Llama Python на HumanEval продемонстрировала различную производительность для разных языков кодирования и задач: от 38 % в модели 7B Python до 57 % в моделях Python 70 B. Кроме того, точно настроенные модели Code Llama на языке программирования SQL показали лучшие результаты, о чем свидетельствуют тесты оценки SQL. Эти опубликованные тесты подчеркивают потенциальные преимущества тонкой настройки моделей Code Llama, позволяющей повысить производительность, настройку и адаптацию к конкретным областям и задачам кодирования.

Точная настройка без кода с помощью пользовательского интерфейса SageMaker Studio.

Чтобы начать тонкую настройку моделей лам с помощью SageMaker Studio, выполните следующие шаги:

1. В консоли SageMaker Studio выберите Толчок в навигационной панели.

Вы найдете списки более 350 моделей, начиная от моделей с открытым исходным кодом и заканчивая проприетарными моделями.

2. Найдите модели Code Llama.
   

Если вы не видите модели Code Llama, вы можете обновить версию SageMaker Studio, завершив работу и перезапустив ее. Дополнительную информацию об обновлениях версий см. Завершение работы и обновление приложений Studio. Вы также можете найти другие варианты модели, выбрав Изучите все модели генерации кода или введите код Ламы в поле поиска.

SageMaker JumpStart в настоящее время поддерживает точную настройку инструкций для моделей Code Llama. На следующем снимке экрана показана страница тонкой настройки модели Code Llama 2 70B.

3. Что касается Расположение набора данных для обучения, вы можете указать на Простой сервис хранения Amazon (Amazon S3) Корзина, содержащая наборы данных обучения и проверки для точной настройки.
4. Задайте конфигурацию развертывания, гиперпараметры и параметры безопасности для точной настройки.
5. Выберите Train чтобы начать работу по тонкой настройке экземпляра SageMaker ML.
   

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

6. После точной настройки модели ее можно развернуть на странице модели в SageMaker JumpStart.

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

Точная настройка с помощью SageMaker Python SDK

В этом разделе мы продемонстрируем, как точно настроить модели Code LIama с помощью SageMaker Python SDK для набора данных в формате инструкций. В частности, модель точно настроена для набора задач обработки естественного языка (NLP), описываемых с помощью инструкций. Это помогает повысить производительность модели при выполнении невидимых задач с помощью подсказок с нулевым результатом.

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

Во-первых, давайте посмотрим на формат набора данных, необходимый для точной настройки инструкций. Данные обучения должны быть отформатированы в формате строк JSON (.jsonl), где каждая строка представляет собой словарь, представляющий образец данных. Все данные обучения должны находиться в одной папке. Однако его можно сохранить в нескольких файлах .jsonl. Ниже приведен пример в формате строк JSON:

{
	'system_prompt': 'a chat',
	'question': 'Please focus on the efficiency of this problem and provide code in python:nYou are given two strings `s` and `t` consisting of only lowercase English letters.nnReturn _the minimum number of characters that need to be appended to the end of_ `s` _so that_ `t` _becomes a **subsequence** of_ `s`.nnA **subsequence** is a string that can be derived from another string by deleting some or no characters without changing the order of the remaining characters.nn**Example 1:**nn**Input:** s = "coaching ", t = "coding "n**Output:** 4n**Explanation:** Append the characters "ding " to the end of s so that s = "coachingding ".nNow, t is a subsequence of s ( "**co**aching**ding** ").nIt can be shown that appending any 3 characters to the end of s will never make t a subsequence.nn**Example 2:**nn**Input:** s = "abcde ", t = "a "n**Output:** 0n**Explanation:** t is already a subsequence of s ( "**a**bcde ").nn**Example 3:**nn**Input:** s = "z ", t = "abcde "n**Output:** 5n**Explanation:** Append the characters "abcde " to the end of s so that s = "zabcde ".nNow, t is a subsequence of s ( "z**abcde** ").nIt can be shown that appending any 4 characters to the end of s will never make t a subsequence.nn**Constraints:**nn* `1 <= s.length, t.length <= 105`n* `s` and `t` consist only of lowercase English letters.',
	'response': '### Explanationn The algorithm maintains two pointers, `i` and `j`, to iterate through the given strings `s` and `t`. The pointer `i` iterates through the string `s` and the pointer `j` iterates through the string `t`. While iterating through `s`, if we find a character that matches the current character in `t`, we increment the `j` pointer. This is because the matched character can be a part of the subsequence we are looking for. The iteration stops when either `i` reaches the end of `s` or `j` reaches the end of `t`.nnAt the end, we subtract the index `j` from the length of `t`. This gives us the minimum number of characters that need to be appended to the end of `s` so that `t` becomes a subsequence of `s`.nn### Pseudocode:n```nMIN-ADDITION(s, t)n s_len = LENGTH(s)n t_len = LENGTH(t)n i = 1n j = 1n WHILE i <= s_len AND j <= t_lenn IF s[i] == t[j]n j = j + 1n ENDIFn i = i + 1n ENDWHILEn RETURN t_len - j + 1nENDMIN-ADDITIONn```nn### Coden```pythonndef min_addition(s: str, t: str) -> int:n s_len = len(s)n t_len = len(t)n i, j = 0, 0n while i < s_len and j < t_len:n if s[i] == t[j]:n j += 1n i += 1n return t_len - jn```n'
}

Папка обучения может содержать template.json файл, описывающий форматы ввода и вывода. Ниже приведен пример шаблона:

{
    "prompt": "{system_prompt} ### Input: {question}",
    "completion": "{response}"
}

Чтобы соответствовать шаблону, каждый образец в файлах строк JSON должен включать system_prompt, questionи response поля. В этой демонстрации мы используем Набор данных Dolphin Coder из «Обнимающего лица».

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

from sagemaker.jumpstart.estimator import JumpStartEstimator

model_id = "meta-textgeneration-llama-codellama-7b" 
model_version = "*"
train_data_location = f"s3://{your_own_bucket_hosting_training_data}/" # training data in s3 bucket

estimator = JumpStartEstimator(
    model_id=model_id,
    model_version=model_version,
    hyperparameters= hyperparameters,
    environment={
        "accept_eula": "false"
    },  # please change `accept_eula` to be `true` to accept EULA.
)

estimator.fit({"training": train_data_location})

Вы можете развернуть точно настроенную модель непосредственно из средства оценки, как показано в следующем коде. Подробности смотрите в блокноте Репозиторий GitHub.

finetuned_predictor = estimator.deploy()

Техники тонкой настройки

Языковые модели, такие как Llama, имеют размер более 10 ГБ или даже 100 ГБ. Для точной настройки таких больших моделей требуются экземпляры со значительно большим объемом памяти CUDA. Кроме того, обучение этих моделей может быть очень медленным из-за размера модели. Поэтому для эффективной тонкой настройки мы используем следующие оптимизации:

• Адаптация низкого ранга (LoRA) – Это тип эффективной точной настройки параметров (PEFT) для эффективной точной настройки больших моделей. Используя этот метод, вы замораживаете всю модель и добавляете в нее только небольшой набор настраиваемых параметров или слоев. Например, вместо обучения всех 7 миллиардов параметров для Llama 2 7B вы можете точно настроить менее 1% параметров. Это помогает значительно снизить требования к памяти, поскольку вам нужно хранить градиенты, состояния оптимизатора и другую информацию, связанную с обучением, только для 1% параметров. Кроме того, это помогает сократить время обучения, а также стоимость. Более подробную информацию об этом методе см. LoRA: низкоранговая адаптация больших языковых моделей.
• Квантование Int8 – Даже с такими оптимизациями, как LoRA, такие модели, как Llama 70B, все еще слишком велики для обучения. Чтобы уменьшить объем памяти во время обучения, вы можете использовать квантование Int8 во время обучения. Квантование обычно снижает точность типов данных с плавающей запятой. Хотя это уменьшает объем памяти, необходимой для хранения весов модели, но снижает производительность из-за потери информации. Квантование Int8 использует только четверть точности, но не приводит к снижению производительности, поскольку не просто отбрасывает биты. Он округляет данные из одного типа в другой. Чтобы узнать о квантовании Int8, обратитесь к LLM.int8(): 8-битное умножение матриц для трансформаторов в масштабе.
• Полностью сегментированный параллелизм данных (FSDP) – Это тип алгоритма параллельного обучения, который распределяет параметры модели между исполнителями параллельных данных и может при необходимости переложить часть обучающих вычислений на центральные процессоры. Хотя параметры распределяются по разным графическим процессорам, вычисление каждого микропакета выполняется локально для работника графического процессора. Он распределяет параметры более равномерно и обеспечивает оптимальную производительность за счет перекрытия связи и вычислений во время обучения.

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

Точная настройка моделей Llama основана на скриптах, предоставленных следующими Репо GitHub.

Поддерживаемые гиперпараметры для обучения

Точная настройка Code Llama 2 поддерживает ряд гиперпараметров, каждый из которых может влиять на требования к памяти, скорость обучения и производительность точно настроенной модели:

• эпоха – Количество проходов, которые алгоритм тонкой настройки выполняет через набор обучающих данных. Должно быть целое число больше 1. Значение по умолчанию — 5.
• Learning_rate – Скорость обновления весов модели после обработки каждой серии обучающих примеров. Должно быть положительное число с плавающей запятой больше 0. Значение по умолчанию — 1e-4.
• инструкция_tuned – Следует ли обучать модель инструкции или нет. Должно быть True or False. По умолчанию False.
• per_device_train_batch_size – Размер пакета на ядро ​​графического процессора/ЦП для обучения. Должно быть положительным целым числом. По умолчанию — 4.
• per_device_eval_batch_size – Размер пакета на ядро ​​графического процессора/ЦП для оценки. Должно быть положительным целым числом. По умолчанию — 1.
• max_train_samples – В целях отладки или более быстрого обучения сократите количество обучающих примеров до этого значения. Значение -1 означает использование всех обучающих выборок. Должно быть положительным целым числом или -1. По умолчанию – -1.
• max_val_samples – В целях отладки или более быстрого обучения сократите количество примеров проверки до этого значения. Значение -1 означает использование всех проверочных образцов. Должно быть положительным целым числом или -1. По умолчанию – -1.
• max_input_length – Максимальная общая длина входной последовательности после токенизации. Последовательности длиннее этого значения будут обрезаны. Если -1, max_input_length установлено минимальное значение 1024 и максимальная длина модели, определенная токенизатором. Если установлено положительное значение, max_input_length установлено минимальное из предоставленного значения, а model_max_length определяется токенизатором. Должно быть положительным целым числом или -1. По умолчанию – -1.
• validation_split_ratio – Если канал проверки none, соотношение разделения проверки поезда из данных поезда должно находиться в диапазоне 0–1. По умолчанию — 0.2.
• train_data_split_seed – Если данные проверки отсутствуют, это фиксирует случайное разделение входных данных обучения на данные обучения и проверки, используемые алгоритмом. Должно быть целое число. По умолчанию — 0.
• preprocessing_num_workers – Количество процессов, используемых для предварительной обработки. Если None, основной процесс используется для предварительной обработки. По умолчанию None.
• лора_р – Лора Р. Должно быть положительным целым числом. По умолчанию — 8.
• лора_альфа – Лора Альфа. Должно быть положительным целым числом. По умолчанию – 32.
• lora_dropout – Лора Дропаут. должно быть положительным плавающим числом от 0 до 1. Значение по умолчанию — 0.05.
• int8_quantization - Если True, модель загружается с 8-битной точностью для обучения. По умолчанию для 7B и 13B: False. По умолчанию для 70B True.
• Enable_fsdp – Если True, при обучении используется FSDP. По умолчанию для 7B и 13B установлено значение True. По умолчанию для 70B установлено значение False. Обратите внимание, что int8_quantization не поддерживается FSDP.

При выборе гиперпараметров учитывайте следующее:

• настройка int8_quantization=True уменьшает потребность в памяти и приводит к более быстрому обучению.
• Убывающий per_device_train_batch_size и max_input_length уменьшает требования к памяти и, следовательно, может запускаться на небольших экземплярах. Однако установка очень низких значений может увеличить время обучения.
• Если вы не используете квантование Int8 (int8_quantization=False), используйте ФСДП (enable_fsdp=True) для более быстрого и эффективного обучения.

Поддерживаемые типы экземпляров для обучения

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

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

• Инстансы G5 обеспечивают наиболее эффективное обучение среди поддерживаемых типов инстансов. Поэтому, если у вас есть доступные экземпляры G5, вам следует использовать их.
• Время обучения во многом зависит от количества доступных графических процессоров и памяти CUDA. Поэтому обучение на инстансах с одинаковым количеством графических процессоров (например, ml.g5.2xlarge и ml.g5.4xlarge) примерно одинаковое. Поэтому для обучения можно использовать более дешевый экземпляр (ml.g5.2xlarge).
• При использовании экземпляров p3 обучение будет выполняться с 32-битной точностью, поскольку bfloat16 в этих экземплярах не поддерживается. Таким образом, задание обучения будет потреблять вдвое больше памяти CUDA при обучении на экземплярах p3 по сравнению с экземплярами g5.

Информацию о стоимости обучения за один экземпляр см. Amazon EC2 G5 Экземпляры.

Оценка

Оценка является важным шагом для оценки эффективности точно настроенных моделей. Мы представляем как качественные, так и количественные оценки, чтобы показать улучшение моделей с точной настройкой по сравнению с моделями без точной настройки. При качественной оценке мы показываем пример ответа как от точно настроенных, так и от неточно настроенных моделей. При количественной оценке мы используем HumanEval, набор тестов, разработанный OpenAI для генерации кода Python для проверки способности выдавать правильные и точные результаты. Репозиторий HumanEval находится под лицензией MIT. Мы доработали варианты Python всех моделей Code LIama для разных размеров (Code LIama Python 7B, 13B, 34B и 70B на Набор данных Dolphin Coder) и представить результаты оценки в следующих разделах.

Качественная оценка

Развернув точно настроенную модель, вы можете начать использовать конечную точку для генерации кода. В следующем примере мы представляем ответы как от базового, так и от доработанных вариантов Python Code LIama 34B на тестовом образце в Набор данных Dolphin Coder:

alpaca_format = """{system_prompt}

### Input:
{question}

### Response:n"""

system="You are a coding AI"
prompt = """Please explain the reasoning behind the following solution and 
provide code in python: Given a string `s`, return the longest palindromic 
substring in `s`. **Example 1:** **Input:** s = "babad " **Output:** "bab " 
**Explanation:** "aba " is also a valid answer. **Example 2:** 
**Input:** s = "cbbd " **Output:** "bb " 
**Constraints:** * `1 <= s.length <= 1000` * `s` consist of only digits 
and English letters."""

payload = json.dumps({
    "inputText": alpaca_format.format(system_prompt=system, question=prompt),
    "textGenerationConfig": {
    "maxTokenCount": 2048,
    "temperature":0.2
}})

finetuned_response = finetuned_predictor.predict(payload)
finetuned_response["generated_text"]

Точная настройка модели Code Llama, помимо предоставления кода для предыдущего запроса, генерирует подробное объяснение подхода и псевдокод.

Код Llama 34b Ответ Python без точной настройки:

### Code
def longestPalindrome(s):
    # Fill this in.
    longest = ""
    for i in range(len(s)):
        for j in range(len(s), i, -1):
            if len(longest) >= j-i:
                break
            elif s[i:j] == s[i:j][::-1]:
                longest = s[i:j]
                break
    return longest

print(longestPalindrome("abaxyzzyxf"))
# axyzzyx
###Reference:
- [https://www.geeksforgeeks.org/longest-palindrome-substring-set-1/]
(https://www.geeksforgeeks.org/longest-palindrome-substring-set-1/)

Код Llama 34B Точный ответ Python

### Explanation
The algorithm uses dynamic programming to find the longest palindromic substring. 
It initializes a 2D boolean table `dp` with the same dimensions as the input string `s`. 
The `dp[i][j]` value is set to `true` if the substring from index `i` to index `j` is a palindrome.

The algorithm then iterates through the string in a nested loop, starting from the first character to the last. 
It checks if the substring from index `i` to index `j` is a palindrome. 
If it is, it sets the `dp[i][j]` value to `true`. 
If the substring is of length 2 or 3, it sets the `dp[i][j]` value to `true` as well.

After the nested loop, the algorithm iterates through the `dp` table to find the longest palindromic substring. 
It keeps track of the maximum length and the starting and ending indices of the substring.

Finally, the algorithm returns the substring from the starting index to the ending index.

### Code
```python
def longestPalindrome(s: str) -> str:
    n = len(s)
    dp = [[False] * n for _ in range(n)]

    for i in range(n):
        dp[i][i] = True
        if i + 1 < n:
            dp[i][i + 1] = s[i] == s[i + 1]

    max_len = 1
    start = 0
    end = 0

    for i in range(n - 1):
        for j in range(i + 1, n):
            if j - i == 1 or dp[i + 1][j - 1]:
                dp[i][j] = s[i] == s[j]
                if j - i + 1 > max_len:
                    max_len = j - i + 1
                    start = i
                    end = j

    return s[start:end + 1]
```

Земная Истина

### Explanation 
1. Initialize `start` and `maxLength` for result substring. 
2. Iterate through the given string `s` using the index `i`. 
3. For each index `i`, create two pointers `l` and `r` starting at `i`. 
4. Check if there's a consecutive sequence of identical characters, increment the right pointer `r` until the end of the sequence is reached. 
5. Update the index `i` to the current value of `r`. 
6. Expand the pointers `l` and `r` outwards to find the longest palindromic substring, checking that characters on both sides are equal. 
7. If the current length of the substring is greater than `maxLength`, update `start` and `maxLength`. 
8. Return the longest palindromic substring using the `start` and `maxLength`. 

### Code 
```python 
def longest_palindromic_substring(s: str) → str:
    n = len(s)
    if n == 0:
        return ""
    
    start, max_length = 0, 1
    for i in range(n):
        l, r = i, i
        while r < n - 1 and s[r] == s[r + 1]:
            r += 1
            i = r
        while l > 0 and r < n - 1 and s[l - 1] == s[r + 1]:
            l -= 1
            r += 1
        length = r - l + 1
        if length > max_length:
            start, max_length = l, length
    return s[start:start + max_length]
```

Интересно, что наша доработанная версия Code Llama 34B Python обеспечивает решение на основе динамического программирования для самой длинной палиндромной подстроки, которое отличается от решения, представленного в основной истине из выбранного тестового примера. Наша точно настроенная модель подробно объясняет и объясняет решение на основе динамического программирования. С другой стороны, модель без точной настройки галлюцинирует потенциальные результаты сразу после print оператор (показан в левой ячейке), поскольку выходные данные axyzzyx не является самым длинным палиндромом в данной строке. С точки зрения временной сложности решение динамического программирования обычно лучше, чем первоначальный подход. Решение динамического программирования имеет временную сложность O(n^2), где n — длина входной строки. Это более эффективно, чем первоначальное решение из модели без точной настройки, которая также имела квадратичную временную сложность O(n^2), но с менее оптимизированным подходом.

Это выглядит многообещающе! Помните, что мы доработали вариант Code LIama Python только с 10% Набор данных Dolphin Coder. Есть еще много интересного для изучения!

Несмотря на подробные инструкции в ответе, нам все равно необходимо проверить правильность кода Python, представленного в решении. Далее мы используем систему оценки под названием Человеческая оценка запускать интеграционные тесты сгенерированного ответа Code LIama для систематической проверки его качества.

Количественная оценка с помощью HumanEval

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

Каждый вопрос по программированию на основе Python мы отправляем в модель Code LIama, развернутую на конечной точке SageMaker, чтобы получить k ответов. Далее мы запускаем каждый из k ответов на интеграционные тесты в репозитории HumanEval. Если какой-либо ответ из k ответов проходит интеграционные тесты, мы считаем, что тестовый пример успешен; в противном случае провалился. Затем мы повторяем процесс, чтобы вычислить долю успешных случаев в качестве итоговой оценки, называемой pass@k. Следуя стандартной практике, мы установили k равным 1 в нашей оценке, чтобы генерировать только один ответ на вопрос и проверять, проходит ли он интеграционный тест.

Ниже приведен пример кода для использования репозитория HumanEval. Вы можете получить доступ к набору данных и сгенерировать один ответ, используя конечную точку SageMaker. Подробности смотрите в блокноте Репозиторий GitHub.

%pip3 install human_eval
import json
from human_eval.evaluation import evaluate_functional_correctness
from human_eval.data import write_jsonl, read_problems
from tqdm import tqdm
problems = read_problems()

num_samples_per_task = 1 # value k: number of responses for each question
samples = [
    dict(task_id=task_id, completion=generate_one_completion(problems[task_id]["prompt"]))
    for task_id in tqdm(problems)
    for _ in range(num_samples_per_task)
]
write_jsonl("samples.jsonl", samples)

evaluate_functional_correctness('./samples.jsonl')

В следующей таблице показаны улучшения моделей Code LIama Python с точной настройкой по сравнению с моделями без точной настройки для моделей разных размеров. Чтобы гарантировать корректность, мы также развертываем модели Code LIama без точной настройки в конечных точках SageMaker и проводим оценки Human Eval. пароль@1 числа (первая строка в следующей таблице) соответствуют числам, указанным в Исследовательская статья «Код Ламы». Параметры вывода последовательно задаются как "parameters": {"max_new_tokens": 384, "temperature": 0.2}.

Как мы видим из результатов, все варианты Code LIama Python с точной настройкой демонстрируют значительное улучшение по сравнению с моделями без точной настройки. В частности, Code LIama Python 70B превосходит модель без точной настройки примерно на 12%.

Теперь вы можете попробовать настроить модели Code LIama на своем собственном наборе данных.

Убирать

Если вы решите, что больше не хотите, чтобы конечная точка SageMaker работала, вы можете удалить ее, используя AWS SDK для Python (Boto3), Интерфейс командной строки AWS (AWS CLI) или консоль SageMaker. Для получения дополнительной информации см. Удалить конечные точки и ресурсы. Кроме того, вы можете закройте ресурсы SageMaker Studio которые больше не нужны.

Заключение

В этом посте мы обсудили тонкую настройку моделей Meta Code Llama 2 с помощью SageMaker JumpStart. Мы показали, что вы можете использовать консоль SageMaker JumpStart в SageMaker Studio или SageMaker Python SDK для точной настройки и развертывания этих моделей. Мы также обсудили технику тонкой настройки, типы экземпляров и поддерживаемые гиперпараметры. Кроме того, мы изложили рекомендации по оптимизации тренировок на основе различных проведенных нами тестов. Как мы видим из этих результатов точной настройки трех моделей по двум наборам данных, точная настройка улучшает суммирование по сравнению с моделями без точной настройки. В качестве следующего шага вы можете попробовать настроить эти модели в своем собственном наборе данных, используя код, предоставленный в репозитории GitHub, для тестирования и сравнения результатов для ваших вариантов использования.

Об авторах

Доктор Синь Хуан — старший научный сотрудник Amazon SageMaker JumpStart и встроенных алгоритмов Amazon SageMaker. Он занимается разработкой масштабируемых алгоритмов машинного обучения. Его исследовательские интересы лежат в области обработки естественного языка, объяснимого глубокого обучения на табличных данных и надежного анализа непараметрической пространственно-временной кластеризации. Он опубликовал множество статей на конференциях ACL, ICDM, KDD и в Королевском статистическом обществе: серия A.

Вишаал Яламанчали — архитектор стартап-решений, работающий с компаниями, занимающимися генеративным искусственным интеллектом, робототехникой и автономными транспортными средствами на ранней стадии. Вишаал работает со своими клиентами над предоставлением передовых решений машинного обучения и лично заинтересован в обучении с подкреплением, оценке LLM и генерации кода. До работы в AWS Вишаал учился в UCI, специализируясь на биоинформатике и интеллектуальных системах.

Минакшисундарам Тандавараян работает в AWS специалистом по AI/ML. У него есть страсть к проектированию, созданию и продвижению ориентированных на человека данных и аналитики. Мина специализируется на разработке устойчивых систем, которые обеспечивают измеримые конкурентные преимущества стратегическим клиентам AWS. Мина является специалистом по связям с общественностью и дизайнерским мыслителем и стремится направить бизнес к новым способам работы посредством инноваций, инкубации и демократизации.

Доктор Ашиш Хетан — старший научный сотрудник, работающий со встроенными алгоритмами Amazon SageMaker и помогающий разрабатывать алгоритмы машинного обучения. Он получил докторскую степень в Университете Иллинойса в Урбана-Шампейн. Он является активным исследователем в области машинного обучения и статистических выводов и опубликовал множество статей на конференциях NeurIPS, ICML, ICLR, JMLR, ACL и EMNLP.

• SEO-контент и PR-распределение. Получите усиление сегодня.
• PlatoData.Network Вертикальный генеративный ИИ. Расширьте возможности себя. Доступ здесь.
• ПлатонАйСтрим. Интеллект Web3. Расширение знаний. Доступ здесь.
• ПлатонЭСГ. Углерод, чистые технологии, Энергия, Окружающая среда, Солнечная, Управление отходами. Доступ здесь.
• ПлатонЗдоровье. Биотехнологии и клинические исследования. Доступ здесь.
• Источник: https://aws.amazon.com/blogs/machine-learning/fine-tune-code-llama-on-amazon-sagemaker-jumpstart/