FP32, FP16, BF16 и FP8 — разбираемся в основных типах чисел с плавающей запятой30.09.2024 14:45

Привет, Хабр! Сегодня давайте поговорим о том, как современные вычисления на GPU стали более гибкими и эффективными благодаря различным форматам чисел с плавающей запятой (FP64, FP32, FP16, BFLOAT16 и FP8). Эти форматы не просто числа — за каждым из них стоит конкретная область применения. В разных ситуациях мы сталкиваемся с задачами, где важны либо скорость, либо точность, и правильно выбранный тип floating point помогает оптимизировать ресурсы. Давайте разберём всё это на примерах и поймём, в каких задачах каждый из этих форматов будет наиболее полезен.

Введение

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

FP64: максимальная точность для научных расчётов

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

Задача: Рассмотрим задачу численного интегрирования для расчёта траектории космического объекта, движущегося под воздействием гравитации Земли. Для таких задач крайне важно использовать максимальную точность, чтобы не допустить отклонений в расчётах, которые могут привести к неправильному предсказанию орбиты.

Пример кода для численного интегрирования с использованием FP64:

import torch

# Положение и скорость спутника
initial_position = torch.tensor([7.0e6, 0.0, 0.0], dtype=torch.float64)
initial_velocity = torch.tensor([0.0, 7.12e3, 0.0], dtype=torch.float64)
mass_earth = 5.972e24
g = 6.67430e-11

# Функция для вычисления ускорения
def compute_acceleration(position, mass, g=6.67430e-11):
   distance = torch.norm(position)
   return -g * mass / distance**3 * position

# Метод Рунге-Кутты для численного интегрирования
def runge_kutta_step(position, velocity, mass, time_step):
   k1_v = compute_acceleration(position, mass) * time_step
   k1_x = velocity * time_step
   k2_v = compute_acceleration(position + k1_x / 2, mass) * time_step
   k2_x = (velocity + k1_v / 2) * time_step
   return position + (k1_x + 2 * k2_x) / 3, velocity + (k1_v + 2 * k2_v) / 3

# Применение метода
time_step = 1.0  # шаг времени в секундах
position, velocity = runge_kutta_step(initial_position, initial_velocity, mass_earth, time_step)

print(f"Положение: {position}, Скорость: {velocity}")

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

FP32: баланс между точностью и скоростью

FP32 — это стандартный 32-битный формат, который используется в большинстве повседневных задач, таких как рендеринг графики, обработка изображений и обучение нейросетей. Он обеспечивает достаточную точность при высокой производительности, что делает его оптимальным выбором для задач, где скорость важнее точности.

Задача: Умножение матриц для обработки изображений в реальном времени. В таких задачах требуется быстрое выполнение вычислений, а точность FP32 достаточна для получения качественных результатов.

Пример кода для умножения матриц с использованием FP32:

import torch


# Инициализация матриц в формате float32
matrix_a = torch.tensor([[1.0, 2.0], [3.0, 4.0]], dtype=torch.float32)
matrix_b = torch.tensor([[5.0, 6.0], [7.0, 8.0]], dtype=torch.float32)


# Выполнение умножения матриц
result = torch.matmul(matrix_a, matrix_b)


print(f"Результат умножения матриц с FP32: \n{result}")

Зачем здесь нужен FP32? В ряде задач, связанных с рендерингом или обработкой графики, критически важно выполнять расчёты в реальном времени, например, при создании графических эффектов или обработке видео. FP32 обеспечивает хорошее соотношение между точностью и производительностью. Конечно, крайне маловероятно что кто-то будет использовать Python для задач требующих исполнения в реальном времени, но для однородности он тут выбран как и для остальных примеров, хотя C/C++/Rust/Zig подошли бы лучше.

FP16: ускорение обработки данных

FP16 — это 16-битный формат, который позволяет значительно ускорить вычисления за счёт уменьшения точности, но без существенного ущерба для качества результата. Этот формат активно используется в задачах машинного обучения и нейросетей, где важна высокая скорость обработки больших объёмов данных.

Задача: Обучение нейросети для классификации изображений. FP16 позволяет ускорить тренировку модели без значительной потери качества.

Пример кода для работы с FP16:

import torch
import torch.nn as nn
import torch.optim as optim

# Простая нейросеть для классификации
class SimpleNet(nn.Module):
   def __init__(self):
       super(SimpleNet, self).__init__()
       self.fc1 = nn.Linear(784, 128)
       self.fc2 = nn.Linear(128, 10)

   def forward(self, x):
       x = torch.relu(self.fc1(x))
       return self.fc2(x)

# Инициализация данных и модели
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = SimpleNet().to(device, dtype=torch.float16)
optimizer = optim.Adam(model.parameters(), lr=0.001)

# Фиктивные данные для обучения
data = torch.randn(64, 784, dtype=torch.float16).to(device)
target = torch.randint(0, 10, (64,), dtype=torch.long).to(device)

# Прогон обучения
optimizer.zero_grad()
output = model(data)
loss = nn.CrossEntropyLoss()(output, target)
loss.backward()
optimizer.step()

print(f"Потери: {loss.item()}")

Зачем здесь нужен FP16? При обучении больших нейросетей на огромных датасетах время обработки играет решающую роль. FP16 позволяет в несколько раз ускорить процесс обучения на GPU, уменьшив объём занимаемой памяти и снизив потребление ресурсов. Это особенно полезно при обучении глубоких моделей с большими объёмами данных.

BFLOAT16: оптимизация для инференса

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

Задача: Инференс модели для обработки изображений с использованием BFLOAT16 для ускорения вычислений.

Пример кода для инференса с использованием BFLOAT16:

import torch

# Инициализация данных с использованием BFLOAT16
input_data = torch.randn(64, 784, dtype=torch.bfloat16).cuda()

# Фиктивная модель для инференса
class SimpleInferenceNet(nn.Module):
   def __init__(self):
       super(SimpleInferenceNet, self).__init__()
       self.fc = nn.Linear(784, 10)

   def forward(self, x):
       return self.fc(x)

# Выполнение инференса
model = SimpleInferenceNet().cuda().bfloat16()
output = model(input_data)

print(f"Результат инференса: {output}")

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

FP8: максимальная производительность для инференса

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

Задача: Выполнение инференса с использованием FP8 для распознавания объектов на изображении.

Пример кода:

import torch
import torch.nn as nn # Import the torch.nn module

# Пример симуляции работы с FP8
def to_fp8(tensor):
   return torch.clamp(tensor, min=-128, max=127).to(torch.float32)

# Инициализация данных
input_data = torch.randn(64, 784).cuda()
input_data_fp8 = to_fp8(input_data)

# Простейшая модель для инференса
class SimpleFP8Net(nn.Module):
   def __init__(self):
       super(SimpleFP8Net, self).__init__()
       self.fc = nn.Linear(784, 10)

   def forward(self, x):
       return self.fc(x)

# Выполнение инференса
model = SimpleFP8Net().cuda()
output = model(input_data_fp8)


print(f"Результат с использованием FP8: {output}")

Зачем здесь нужен FP8? FP8 идеально подходит для задач, где точность может быть снижена в пользу максимальной скорости обработки данных. Это актуально в инференсе для систем искусственного интеллекта, где нужно мгновенно обрабатывать огромные объёмы данных с минимальными затратами ресурсов.

Заключение

Каждый тип float — будь то FP64, FP32, FP16, BFLOAT16 или FP8 — имеет своё применение и должен выбираться в зависимости от задачи. FP64 — для научных расчётов, FP32 — для баланса между производительностью и точностью, FP16 — для обучения нейросетей, а BFLOAT16 и FP8 — для инференса. Современные ускорители Nvidia Tesla, Radeon Instinct или Intel GPU Max поддерживают все эти форматы, что позволяет вам максимально эффективно использовать мощь GPU для каждой конкретной задачи.

А какой тип float используете вы в своих проектах и почему? Делитесь в комментариях, будет интересно обсудить!

© Habrahabr.ru