Привет!
Я закончил реализацию и проверку всей функциональности которую планировал для публикации следующего релиза Adept! 🎉

Помимо основных задач, провел важное кросс-платформенное тестирование:
✅ Успешно протестировал распределённое обучение (DDP) на связке из двух RTX 2080Ti.
✅ Проверил сборку и работу на Android с GPU Adreno 650 и Snapdragon 870.
💡 Также в планах на новый релиз: помимо стандартных Python wheel, мы подготовим RPM-пакет для Alt Linux.

📝 Что нового с 6 сентября:

🎮 GPU / Vulkan Backend
• Перешли на сегментированный аллокатор памяти для GPU устройств (`vksegalloc`) вместо выделения буферов на каждый тензор. Добавили отдельные абстракции staging-буферов.
• Интегрировали это в Vulkan device/manager, GPU API и Python-биндинги.
• Реализовали graceful fallback для устройств без поддержки опциональных расширений (на уровнях device, shader и submit).

🎯 YOLO v11 и распределённое обучение
• Добавили опцию выбора Device-ID в Python CLI и C++ примере для инференса YOLO.
• Реализовали поддержку распределённого обучения (DDP) для YOLO v11, включая корректировки функций потерь под распределённые вычисления.

📦 Сборка и пакетирование
• OpenMPI runtime теперь бандлится в wheel, добавлен лаунчер adeptrun.
• Настроили пайплайн сборки manylinux wheel.
• ⚠️ Важно: Минимальная требуемая версия Python повышена с 3.11 до 3.12.
• Починили зависимости MPI и добавили возможность сборки под Android с помощью clang.

🧹 Очистка и адаптация API
• Удалили легаси и неструктурированные примеры.
• Адаптировали актуальные примеры (LeNet, MLP, ResNet, импорт ONNX) под свежее API.

В ближайшее время всё залью в основную ветку, сделаю тег 0.2.0 и опубликую Python пакет для x86_64 в GitVerse 🛠

#Adept #MachineLearning #Vulkan #YOLOv11 #DistributedTraining #AltLinux #Android #OpenSource #C++ #Python #GPU

Привет!

С радостью сообщаю что наконец-то вышел Релиз 0.2.0

Основные изменения:
- Тензорный движок переработан с использованием смещений и представлений(strides and views).
- Добавлена индексация в стиле PyTorch.
- Типизированные скалярные аргументы.
- Упрощен API редукции.
- Переработан формат записи checkpoints.
- Переработана система сборки.
- Использование Python 3.12.
- Переработано управление памятью в Vulkan.
- MVP для импорта моделей ONNX.
- Распределенное обучение.
- Централизованное логирование.
- И много новых операций.
Больше деталей в описании релиза.

Установить новую версию для Linux x86_64 можно так:

pip install https://storage.yandexcloud.net/adept-releases/adept-0.2.0-cp312-cp312-manylinux_2_34_x86_64.whl

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

Новый адрес проекта:
https://gitverse.ru/adept-platform/adept

В связи с этим тем кто работает с кодом надо изменить remote origin для рабочей копии в git:

git remote set-url origin git@gitverse.ru:adept-platform/adept.git

#Release #Updates #NewFeatures

Проект стал доступен в индексе пакетов pypi.org.
Установка стала проще:

pip install adept-platform

Это скриншот с моего телефона.
Начал делать скрипты для крос-компиляции проекта с использованием Android SDK/NDK и заниматься интеграцией библиотеки в мобильное приложение.

Доделал скрипты для сборки библиотеки под Android, исправил ошибки и немного в очередной раз оптимизировал свёртку. Всё уже на мастер ветке.

Выложил проект с демкой для Android, там в релизах можно скачать apk и попробовать. В приложении веса самой маленькой модели YOLOv11 получившиеся тренировкой на урезанном для балансировке датасете MS COCO. Тренировка длилась 200 эпох на 4х GPU(3 AMD + 1 Nivida), конечно же с реализацией на Adept.

В результате получилось ~7 FPS на CPU и ~5 FPS на GPU. Что вполне сравнимо с NCNN и мобильным libtorch для YOLOv5, особенно учитывая существенно более тяжелую архитектуру в 11 версии с блоком внимания и работу в FP32.

Весте с лабораторией YADRO на факультете информационных технологий НГУ поучаствовали в «Двадцать второй конференции разработчиков свободных программ».
Матвей Сорокин студент кафедры Систем Информатики подготовил тезисы для сборника на тему «Развитие библиотеки Adept: сборка RPM-пакета для ALT Linux».

После публикации релиза продолжаем работу:

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

- Продолжаем работу над реализацией поддержки формата GGUF. Сначала будет загрузка квантованных весов с распаковкой в FP32 и API для квантования с использованием ggml. Далее планируем делать поддержку квантованных данных в вычислительных ядрах.

- Будем пробовать увеличить производительность реализации GEMM для Vulkan.

- И я затеял глубокий рефакторинг системы построения вычислительного графа и авто-дифференцирования. Будем уходить от простого подхода с неявным построением графа к явному описанию с узлами, рёбрами и соответствующей дополнительной информацией. Это должно позволить осуществлять преобразования графа в другие промежуточные представления(IR) и производить его анализ и оптимизацию. На первом этапе хочется получить функциональный слой для всех операций и возможность генерации StableHLO IR для использования тензорного компилятора OpenXLA. Прикладной API это не затронет и даже упростит, так как уберем класс Variable и будем оперировать только тензорами.

#plans #IR #GGUF #tensor #compiler #StableHLO

Сделал детальное представление вычислительного графа и теперь его можно преобразовать в другое IR.
Вот например для такого небольшого перцептрона:

class MLP : public Module {
 public:
  MLP()
      : linear1(28 * 28, 1024),
        linear2(1024, 512),
        linear3(512, 256),
        linear4(256, 10) {
    ...
  }
  Tensor forward(Tensor input) {
    auto out = l1(input);
    out = relu(out);
    out = l2(out);
    out = relu(out);
    out = l3(out);
    out = relu(out);
    out = l4(out);
    return out;
  }
  ...
};

Получается такое представление в StableHLO формате:

module {
  func.func @main(%arg0: tensor<784x784xf32>, %arg1: tensor<1024x784xf32>, %arg2: tensor<1024xf32>, %arg3: tensor<512x1024xf32>, %arg4: tensor<512xf32>, %arg5: tensor<256x512xf32>, %arg6: tensor<256xf32>, %arg7: tensor<10x256xf32>, %arg8: tensor<10xf32>) -> tensor<784x10xf32> {
    %0 = stablehlo.transpose %arg1, permutation = [1, 0] : (tensor<1024x784xf32>) -> tensor<784x1024xf32>
    %1 = stablehlo.dot_general %arg0, %0, contracting_dims = [1] x [0] : (tensor<784x784xf32>, tensor<784x1024xf32>) -> tensor<784x1024xf32>
    %2 = stablehlo.broadcast_in_dim %arg2, dims = [1] : (tensor<1024xf32>) -> tensor<784x1024xf32>
    %3 = stablehlo.add %1, %2 : tensor<784x1024xf32>
    %4 = stablehlo.constant dense<0> : tensor<784x1024xf32>
    %5 = stablehlo.maximum %3, %4 : tensor<784x1024xf32>
    %6 = stablehlo.transpose %arg3, permutation = [1, 0] : (tensor<512x1024xf32>) -> tensor<1024x512xf32>
    %7 = stablehlo.dot_general %5, %6, contracting_dims = [1] x [0] : (tensor<784x1024xf32>, tensor<1024x512xf32>) -> tensor<784x512xf32>
    %8 = stablehlo.broadcast_in_dim %arg4, dims = [1] : (tensor<512xf32>) -> tensor<784x512xf32>
    %9 = stablehlo.add %7, %8 : tensor<784x512xf32>
    %10 = stablehlo.constant dense<0> : tensor<784x512xf32>
    %11 = stablehlo.maximum %9, %10 : tensor<784x512xf32>
    %12 = stablehlo.transpose %arg5, permutation = [1, 0] : (tensor<256x512xf32>) -> tensor<512x256xf32>
    %13 = stablehlo.dot_general %11, %12, contracting_dims = [1] x [0] : (tensor<784x512xf32>, tensor<512x256xf32>) -> tensor<784x256xf32>
    %14 = stablehlo.broadcast_in_dim %arg6, dims = [1] : (tensor<256xf32>) -> tensor<784x256xf32>
    %15 = stablehlo.add %13, %14 : tensor<784x256xf32>
    %16 = stablehlo.constant dense<0> : tensor<784x256xf32>
    %17 = stablehlo.maximum %15, %16 : tensor<784x256xf32>
    %18 = stablehlo.transpose %arg7, permutation = [1, 0] : (tensor<10x256xf32>) -> tensor<256x10xf32>
    %19 = stablehlo.dot_general %17, %18, contracting_dims = [1] x [0] : (tensor<784x256xf32>, tensor<256x10xf32>) -> tensor<784x10xf32>
    %20 = stablehlo.broadcast_in_dim %arg8, dims = [1] : (tensor<10xf32>) -> tensor<784x10xf32>
    %21 = stablehlo.add %19, %20 : tensor<784x10xf32>
    return %21 : tensor<784x10xf32>
  }
}

Далее его надо преобразовать тензорным компиляторм. Эксперименты продолжаются.