Повысьте производительность вывода для моделей Mixtral и Llama 2 с помощью новых контейнеров Amazon SageMaker | Веб-сервисы Amazon

В январе 2024, Создатель мудреца Амазонки запустил новую версию (0.26.0) Контейнеров глубокого обучения (DLC) для вывода больших моделей (LMI). Эта версия предлагает поддержку новых моделей (включая Mixture of Experts), улучшения производительности и удобства использования в бэкэндах вывода, а также детали нового поколения для повышения контроля и объяснимости прогнозов (например, причину завершения генерации и вероятности журнала на уровне токена).

Дополнения LMI предлагают интерфейс с низким уровнем кода, который упрощает использование самых современных методов оптимизации вывода и аппаратного обеспечения. LMI позволяет применять тензорный параллелизм; новейшие методы эффективного внимания, пакетной обработки, квантования и управления памятью; потоковая передача токенов; и многое другое, просто запрашивая идентификатор модели и дополнительные параметры модели. С помощью дополнений LMI для SageMaker вы можете ускорить окупаемость своих проектов. генеративный искусственный интеллект (ИИ) приложения, разгрузите тяжелую работу, связанную с инфраструктурой, и оптимизируйте модели больших языков (LLM) для выбранного вами оборудования, чтобы достичь лучшего в своем классе соотношения цены и качества.

В этом посте мы рассмотрим новейшие функции, представленные в этом выпуске, рассмотрим тесты производительности и предоставим подробное руководство по развертыванию новых LLM с DLC LMI с высокой производительностью.

Новые возможности дополнений LMI

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

• Распределенная библиотека LMI – Это платформа AWS для выполнения логических выводов с помощью LLM, основанная на OSS, для достижения максимально возможной задержки и точности результата.
• LMI vLLM – Это серверная реализация AWS с эффективным использованием памяти. vLLM библиотека вывода
• Набор инструментов LMI TensorRT-LLM – Это серверная реализация AWS NVIDIA ТензорРТ-LLM, который создает движки для конкретных графических процессоров для оптимизации производительности на разных графических процессорах.
• LMI ДипСпид – Это адаптация AWS Глубокая скорость, который добавляет настоящую непрерывную пакетную обработку, квантование SmoothQuant и возможность динамической настройки памяти во время вывода.
• LMI NeuronX – Вы можете использовать это для развертывания на AWS Инферентия2 и AWS Трениум-основанные экземпляры, обеспечивающие настоящую непрерывную пакетную обработку и ускорение на основе Нейрон SDK для AWS

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

Поддерживаются новые модели

Во всех серверных модулях поддерживаются новые популярные модели, такие как Mistral-7B (все серверные части), Mixtral на базе MoE (все серверные части, кроме Transformers-NeuronX) и Llama2-70B (Transformers-NeuronX).

Методы расширения контекстного окна

Контекстное масштабирование на основе ротационного позиционного внедрения (RoPE) теперь доступно на серверных модулях LMI-Dist, vLLM и TensorRT-LLM. Масштабирование RoPE позволяет увеличить длину последовательности модели во время вывода практически до любого размера без необходимости тонкой настройки.

При использовании RoPE следует учитывать два важных фактора:

• Модельное недоумение – По мере увеличения длины последовательности так может модель растерянность. Этот эффект можно частично компенсировать, проведя минимальную точную настройку входных последовательностей, больших, чем те, которые использовались при исходном обучении. Для более глубокого понимания того, как RoPE влияет на качество модели, см. Расширение RoPE.
• Производительность логического вывода – Более длинные последовательности будут потреблять более высокую пропускную способность памяти ускорителя (HBM). Увеличение использования памяти может отрицательно повлиять на количество одновременных запросов, которые может обработать ваш ускоритель.

Добавлены сведения о поколении.

Теперь вы можете получить две подробные сведения о результатах генерации:

• Finish_reason – Это указывает на причину завершения генерации, которой может быть достижение максимальной длины генерации, генерация токена конца предложения (EOS) или генерация определяемого пользователем токена остановки. Он возвращается вместе с последним фрагментом потоковой последовательности.
• log_probs – Возвращает вероятность журнала, назначенную моделью для каждого токена в фрагменте потоковой последовательности. Вы можете использовать их для грубой оценки достоверности модели, вычисляя совместную вероятность последовательности как сумму log_probs отдельных токенов, что может быть полезно для оценки и ранжирования выходных данных модели. Имейте в виду, что вероятности токенов LLM, как правило, слишком самоуверенны без калибровки.

Вы можете включить вывод результатов генерации, добавив Details=True во входные полезные данные в LMI, оставив все остальные параметры неизменными:

payload = {“inputs”:“your prompt”,
“parameters”:{max_new_tokens”:256,...,“details”:True}
}

Параметры консолидированной конфигурации

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

LMI-Распределенный бэкэнд

На выставке AWS re:Invent 2023 компания LMI-Dist добавила новые оптимизированные коллективные операции для ускорения связи между графическими процессорами, что привело к снижению задержки и повышению пропускной способности для моделей, которые слишком велики для одного графического процессора. Эти коллективы доступны исключительно для SageMaker, для экземпляров p4d.

В то время как предыдущая итерация поддерживала сегментирование только для всех 8 графических процессоров, в LMI 0.26.0 реализована поддержка тензорной параллельности степени 4 в частичном шаблоне «все ко всем». Это можно совместить с Компоненты вывода SageMaker, с помощью которого вы можете детально настроить, сколько ускорителей должно быть выделено для каждой модели, развернутой за конечной точкой. Вместе эти функции обеспечивают лучший контроль над использованием ресурсов базового экземпляра, позволяя вам повысить мультитенантность модели за счет размещения разных моделей за одной конечной точкой или точно настроить совокупную пропускную способность вашего развертывания в соответствии с вашей моделью и характеристиками трафика.

На следующем рисунке сравниваются прямые схемы «все ко всем» и частичные схемы «все ко всем».

Серверная часть TensorRT-LLM

NVIDIA TensorRT-LLM был представлен как часть предыдущего выпуска LMI DLC (0.25.0), обеспечивая современную производительность графического процессора и такие оптимизации, как SmoothQuant, FP8 и непрерывную пакетную обработку для LLM при использовании графических процессоров NVIDIA.

TensorRT-LLM требует, чтобы модели перед развертыванием были скомпилированы в эффективные механизмы. DLC LMI TensorRT-LLM может автоматически обрабатывать список поддерживаемых моделей в режиме реального времени (JIT) перед запуском сервера и загрузкой модели для вывода в реальном времени. Версия 0.26.0 DLC расширяет список поддерживаемых моделей для JIT-компиляции, добавляя модели Baichuan, ChatGLM, GPT2, GPT-J, InternLM, Mistral, Mixtral, Qwen, SantaCoder и StarCoder.

JIT-компиляция увеличивает время подготовки и масштабирования конечных точек на несколько минут, поэтому всегда рекомендуется компилировать модель заранее. Руководство о том, как это сделать, и список поддерживаемых моделей см. Учебное пособие по предварительной компиляции моделей TensorRT-LLM. Если выбранная вами модель еще не поддерживается, см. Руководство по компиляции моделей TensorRT-LLM для компиляции любой другой модели, поддерживаемой TensorRT-LLM.

Кроме того, LMI теперь предоставляет встроенное квантование TensorRT-LLM SmootQuant с параметрами для управления альфа-каналом и коэффициентом масштабирования по токену или каналу. Дополнительную информацию о соответствующих конфигурациях см. ТензорРТ-ЛЛМ.

серверная часть vLLM

Обновленная версия vLLM, включенная в LMI DLC, обеспечивает повышение производительности до 50 % за счет графического режима CUDA вместо активного режима. Графики CUDA ускоряют рабочие нагрузки графического процессора, запуская несколько операций графического процессора за один раз, а не запуская их по отдельности, что снижает накладные расходы. Это особенно эффективно для небольших моделей при использовании тензорного параллелизма.

Дополнительная производительность достигается за счет увеличения потребления памяти графического процессора. Режим графика CUDA теперь используется по умолчанию для серверной части vLLM, поэтому, если вы ограничены в объеме доступной памяти графического процессора, вы можете установить option.enforce_eager=True чтобы принудительно включить режим PyTorch.

Серверная часть Transformers-NeuronX

Обновленный выпуск НейронХ включенный в DLC LMI NeuronX, теперь поддерживает модели с механизмом группового запроса, такие как Mistral-7B и LLama2-70B. Внимание к групповым запросам — это важная оптимизация механизма внимания преобразователя по умолчанию, при котором модель обучается с меньшим количеством заголовков ключей и значений, чем заголовков запросов. Это уменьшает размер кэша KV в памяти графического процессора, обеспечивая большую параллельную работу и улучшая соотношение цены и производительности.

На следующем рисунке показаны методы внимания с несколькими головками, групповыми запросами и несколькими запросами (источник).

Доступны различные стратегии сегментирования кэша KV для разных типов рабочих нагрузок. Дополнительную информацию о стратегиях сегментирования см. Поддержка групповых запросов (GQA). Вы можете включить желаемую стратегию (shard-over-heads, например) с помощью следующего кода:

option.group_query_attention=shard-over-heads

Кроме того, новая реализация NeuronX DLC представляет API-интерфейс кэша для TransformerNeuronX, который обеспечивает доступ к кэшу KV. Он позволяет вам вставлять и удалять строки кэша KV из новых запросов во время выполнения пакетного вывода. Перед внедрением этого API кэш KV пересчитывался для всех новых добавленных запросов. По сравнению с LMI V7 (0.25.0) мы улучшили задержку более чем на 33 % при одновременных запросах и поддерживаем гораздо более высокую пропускную способность.

Выбор правильного бэкэнда

Чтобы решить, какой бэкэнд использовать в зависимости от выбранной модели и задачи, используйте следующую блок-схему. Для отдельных руководств пользователя серверной части и поддерживаемых моделей см. Руководства пользователя серверной части LMI.

Разверните Mixtral с помощью LMI DLC с дополнительными атрибутами.

Давайте рассмотрим, как можно развернуть модель Mixtral-8x7B с контейнером LMI 0.26.0 и сгенерировать дополнительные сведения, например log_prob и finish_reason как часть вывода. Мы также обсудим, как вы можете извлечь выгоду из этих дополнительных атрибутов в сценарии использования для создания контента.

Полный блокнот с подробной инструкцией доступен по ссылке. Репо GitHub.

Начнем с импорта библиотек и настройки среды сеанса:

import boto3
import sagemaker 
import json 
import io 
import numpy as np 
from sagemaker import Model, image_uris, serializers, deserializers 

role = sagemaker.get_execution_role() # execution role for the endpoint 
session = sagemaker.session.Session() # sagemaker session for interacting with different AWS APIs 
region = session._region_name # region name of the current SageMaker Studio environment

Вы можете использовать контейнеры SageMaker LMI для размещения моделей без какого-либо дополнительного кода вывода. Вы можете настроить сервер модели либо с помощью переменных среды, либо с помощью serving.properties файл. По желанию вы можете иметь model.py файл для любой предварительной или постобработки и requirements.txt файл для любых дополнительных пакетов, которые необходимо установить.

В этом случае мы используем serving.properties файл для настройки параметров и настройки поведения контейнера LMI. Для получения более подробной информации см. Репо GitHub. В репозитории подробно описаны различные параметры конфигурации, которые вы можете установить. Нам нужны следующие ключевые параметры:

• двигатель – Указывает механизм выполнения, который будет использовать DJL. Это управляет сегментированием и стратегией загрузки модели в ускорителях модели.
• option.model_id – указывает Простой сервис хранения Amazon (Amazon S3) URI предварительно обученной модели или идентификатор модели предварительно обученной модели, размещенной в репозитории модели на Обнимая лицо. В этом случае мы указываем идентификатор модели Mixtral-8x7B.
• option.tensor_parallel_степень – Устанавливает количество устройств графического процессора, по которым Accelerate необходимо разделить модель. Этот параметр также контролирует количество рабочих процессов на модель, которые будут запущены при запуске обслуживания DJL. Мы установили это значение max (максимальный графический процессор на текущей машине).
• option.rolling_batch – Обеспечивает непрерывное дозирование для оптимизации использования ускорителя и общей производительности. Для контейнера TensorRT-LLM мы используем auto.
• option.model_loading_timeout – Устанавливает значение тайм-аута для загрузки и загрузки модели для вывода.
• option.max_rolling_batch – Устанавливает максимальный размер непрерывного пакета, определяя, сколько последовательностей можно обрабатывать параллельно в любой момент времени.

%%writefile serving.properties 
engine=MPI 
option.model_id=mistralai/Mixtral-8x7B-v0.1 
option.tensor_parallel_degree=max 
option.max_rolling_batch_size=32 
option.rolling_batch=auto 
option.model_loading_timeout = 7200

Мы упаковываем serving.properties файл конфигурации в формате tar.gz, чтобы он соответствовал требованиям хостинга SageMaker. Настраиваем контейнер DJL LMI с помощью tensorrtllm в качестве внутреннего движка. Дополнительно указываем последнюю версию контейнера (0.26.0).

image_uri = image_uris.retrieve(
   framework="djl-tensorrtllm",
   region=sess.boto_session.region_name,
   version="0.26.0"
)

Затем мы загружаем локальный архив (содержащий serving.properties файл конфигурации) на префикс S3. Мы используем URI изображения для контейнера DJL и местоположение Amazon S3, в которое был загружен архив модели, обслуживающей артефакты, для создания объекта модели SageMaker.

model = Model(image_uri=image_uri, model_data=code_artifact, role=role) 

instance_type = "ml.p4d.24xlarge" 
endpoint_name = sagemaker.utils.name_from_base("mixtral-lmi-model") 

model.deploy(
   initial_instance_count=1,
   instance_type=instance_type,
   endpoint_name=endpoint_name,
   container_startup_health_check_timeout=1800
)

В рамках LMI 0.26.0 теперь вы можете использовать две дополнительные подробные сведения о сгенерированных выходных данных:

• log_probs – Это вероятность журнала, назначенная моделью для каждого токена в фрагменте потоковой последовательности. Их можно использовать в качестве грубой оценки достоверности модели, вычисляя совместную вероятность последовательности как сумму логарифмических вероятностей отдельных токенов, что может быть полезно для оценки и ранжирования выходных данных модели. Имейте в виду, что вероятности токенов LLM, как правило, слишком самоуверенны без калибровки.
• Finish_reason – Это причина завершения генерации, которая может заключаться в достижении максимальной длины генерации, генерации токена EOS или генерации определяемого пользователем стоп-токена. Он возвращается вместе с последним фрагментом потоковой последовательности.

Вы можете включить их, передав "details"=True как часть вашего вклада в модель.

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

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

class LineIterator:
    def __init__(self, stream):
        # Iterator to get bytes from stream 
        self.byte_iterator = iter(stream)  
        # Buffer stream bytes until we get a full line
        self.buffer = io.BytesIO()  
        # Track current reading position within buffer
        self.read_pos = 0

   def __iter__(self):
        # Make class iterable 
        return self

    def __next__(self):
        while True:
           # Seek read position within buffer
           self.buffer.seek(self.read_pos)  
           # Try reading a line from current position
           line = self.buffer.readline()
           # If we have a full line
           if line and line[-1] == ord('n'):
               # Increment reading position past this line
               self.read_pos += len(line)  
               # Return the line read without newline char
               return line[:-1] 
           # Fetch next chunk from stream  
           try:
               chunk = next(self.byte_iterator)
           # Handle end of stream 
           except StopIteration:
               # Check if we have any bytes still unread
               if self.read_pos < self.buffer.getbuffer().nbytes:
                   continue
               # If not, raise StopIteration
               raise
           # Add fetched bytes to end of buffer
           self.buffer.seek(0, io.SEEK_END)  
           self.buffer.write(chunk['PayloadPart']['Bytes'])

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

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

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

sm_client = boto3.client("sagemaker-runtime")

# Set details: True as a runtime parameter within the input.
body = {"inputs": prompt, "parameters": {"max_new_tokens":512, "details": True}}
resp = sm_client.invoke_endpoint_with_response_stream(EndpointName=endpoint_name, Body=json.dumps(body), ContentType="application/json")
event_stream = resp['Body']

overall_log_prob = []

for line in LineIterator(event_stream):
    resp = json.loads(line)
    if resp['token'].get('text') != None:
        token_log_prob = resp['token']['log_prob']
        overall_log_prob.append(token_log_prob)
    elif resp['generated_text'] != None:
        generated_text= resp['generated_text']

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

print(generated_text) 
overall_score=np.exp(np.mean(overall_log_prob)) 
print(f"nnOverall confidence score in the generated text: {overall_score}")

Это был один из примеров того, как можно создавать и использовать log_prob, в контексте варианта использования создания контента. Аналогичным образом вы можете использовать log_prob как мера оценки достоверности для вариантов использования классификации.

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

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

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

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

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

def inference(payload):
    # Call SageMaker endpoint and get response stream
    resp = sm_client.invoke_endpoint_with_response_stream(EndpointName=endpoint_name, Body=json.dumps(payload), ContentType="application/json")
    event_stream = resp['Body']
    text_output = []
    for line in LineIterator(event_stream):
        resp = json.loads(line) 
        # Extract text tokens if present
        if resp['token'].get('text') != None:
            token = resp['token']['text']
            text_output.append(token)  
            print(token, end='')
        # Get finish reason if details present
        if resp.get('details') != None:
            finish_reason = resp['details']['finish_reason']
            # Return extracted output, finish reason and token length
            return payload['inputs'] + ''.join(text_output), finish_reason, len(text_output)

# set details: True as a runtime parameter within the input.
payload = {"inputs": prompt,  "parameters": {"max_new_tokens":256, "details": True}} 

finish_reason = "length"
# Print initial output 
print(f"Output: {payload['inputs']}", end='')  
total_tokens = 0
total_requests = 0
while finish_reason == 'length':
    # Call inference and get extracts
    output_text, finish_reason, out_token_len = inference(payload)
    # Update payload for next request
    payload['inputs'] = output_text 
    total_tokens += out_token_len
    total_requests += 1
# Print metrics
print(f"nntotal tokens generated: {total_tokens} ntotal requests sent: {total_requests}")

Как мы видим, хотя max_new_token для параметра установлено значение 256, мы используем атрибут Finish_reason Detail как часть вывода для связывания нескольких запросов к конечной точке, пока не будет сгенерирован весь вывод.

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

Заключение

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

Чтобы узнать больше о возможностях LMI DLC, см. Параллелизм моделей и вывод больших моделей. Мы рады видеть, как вы используете эти новые возможности SageMaker.

Об авторах

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

Рахул Шарма — старший архитектор решений в AWS, помогающий клиентам AWS проектировать и создавать решения AI/ML. До прихода в AWS Рахул несколько лет проработал в секторе финансов и страхования, помогая клиентам создавать платформы данных и аналитики.

Цин Лан является инженером-разработчиком программного обеспечения в AWS. Он работал над несколькими сложными продуктами в Amazon, включая высокопроизводительные решения для логического вывода машинного обучения и высокопроизводительную систему ведения журналов. Команда Цин успешно запустила первую модель с миллиардом параметров в Amazon Advertising с очень низкой задержкой. Цин обладает глубокими знаниями по оптимизации инфраструктуры и ускорению глубокого обучения.

Цзянь Шэн — инженер-разработчик программного обеспечения в Amazon Web Services, который работал над несколькими ключевыми аспектами систем машинного обучения. Он внес ключевой вклад в сервис SageMaker Neo, уделяя особое внимание компиляции глубокого обучения и оптимизации среды выполнения. Недавно он направил свои усилия и внес свой вклад в оптимизацию системы машинного обучения для вывода больших моделей.

Тайлер Остерберг — инженер-разработчик программного обеспечения в AWS. Он специализируется на разработке высокопроизводительных методов машинного обучения в SageMaker. В последнее время его внимание было сосредоточено на оптимизации производительности контейнеров глубокого обучения Inferentia на платформе SageMaker. Тайлер преуспевает во внедрении высокопроизводительных решений хостинга для больших языковых моделей и улучшении пользовательского опыта с помощью передовых технологий.

Рупиндер Гревал — старший специалист по архитектуре решений AI/ML в AWS. В настоящее время он занимается обслуживанием моделей и MLOps в Amazon SageMaker. До этой должности он работал инженером по машинному обучению, создавая и размещая модели. Вне работы он любит играть в теннис и кататься на велосипеде по горным тропам.

Дхавал Патель является главным архитектором машинного обучения в AWS. Он работал с организациями, начиная от крупных предприятий и заканчивая стартапами среднего размера, над проблемами, связанными с распределенными вычислениями и искусственным интеллектом. Он специализируется на глубоком обучении, включая домены NLP и Computer Vision. Он помогает клиентам добиться высокопроизводительного логического вывода модели в SageMaker.

Рагху Рамеша — старший архитектор решений машинного обучения в сервисной команде Amazon SageMaker. Он специализируется на оказании помощи клиентам в создании, развертывании и переносе рабочих нагрузок машинного обучения на SageMaker в любом масштабе. Он специализируется на машинном обучении, искусственном интеллекте и компьютерном зрении и имеет степень магистра компьютерных наук в Университете Техаса в Далласе. В свободное время увлекается путешествиями и фотографией.

• SEO-контент и PR-распределение. Получите усиление сегодня.
• PlatoData.Network Вертикальный генеративный ИИ. Расширьте возможности себя. Доступ здесь.
• ПлатонАйСтрим. Интеллект Web3. Расширение знаний. Доступ здесь.
• ПлатонЭСГ. Углерод, чистые технологии, Энергия, Окружающая среда, Солнечная, Управление отходами. Доступ здесь.
• ПлатонЗдоровье. Биотехнологии и клинические исследования. Доступ здесь.
• Источник: https://aws.amazon.com/blogs/machine-learning/boost-inference-performance-for-mixtral-and-llama-2-models-with-new-amazon-sagemaker-containers/