news.shamcode.ru | Как я запускаю 15+ самых разных ИИ на своей машине — open-source, self-hosted, с HTTP-доступом

TLDR: я написал BrainBox — local-first сервис поддержки open-source ИИ-систем для генерации изображений, распознавания объектов на снимках, озвучки, распознавания текстов, транскрибирования аудиозаписей и других целей. Эти системы запускаются за фасадом веб-сервера, который устанавливает их и затем принимает и выполняет задачи в едином для всех систем формате. Задачи можно ставить из любого языка программирования с помощью отправки веб-запросов на сервер, а для Python дополнительно разработан удобный API. Проект доступен на pypi https://pypi.org/project/kaia-brainbox/ с подробной документацией и инструкцией на английском языке. Я надеюсь, что BrainBox поможет тем, кто хочет сделать небольшой проект с использованием ИИ, но не хочет разбираться в питоне и торче, или просто не знает, с чего начать.

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

Мотивация

В 2023 после появления Stable Diffusion и Llama, искусственный интеллект перестал быть эксклюзивной собственностью корпораций и стал доступен всем. Стало понятно, что с этим нужно разбираться, чтобы не остаться со своими pandas и torch где-то на обочине истории. На работе этой темой было заниматься не особенно перспективно: полностью погрузиться в Прекрасное, то есть в технологии, не получается, бизнес все-таки должен генерировать прибыль, а значит, творческие порывы ограничиваются такими скучными вещами, как экономическая целесообразность и KPI.

Поэтому я решил сделать пет-проект в этой области, и через некоторое набрел на удачную тематику: Kitchen AI Assistant (Kaia) — кухонный помощник с лицом, голосом и характером моих любимых персонажей. Это как гуглоколонка, только с дисплеем и с большей персонализацией: с помощью AI я генерирую картинки с моими любимыми персонажами в разных ситуациях, клонирую их голос, а также перефразирую детерминированные ответы голосового помощника в соответствие с характером персонажей. Код помощника также открыт. Выглядит все это примерно так (чтобы не нарушать авторские права и морально-нравственные законы, в демо-версии используются open-source голоса и красивые AI-пейзажи):

Проект почти готов — осталось только переписать кое-какие управляющие алгоритмы на фронтенде, чтобы избавиться от требования наличия Python на девайсе и, соответственно, сделать Каю совместимой с Android-планшетами и IPad.

Но собственно об этом проекте я расскажу как-нибудь потом, а пока сосредоточусь на гораздо более проработанной и полезной его части — BrainBox, сервере поддержки ИИ-систем.

ИИ-систем в Kaia много. Очень много. Только для инференса нужно как минимум две. Во-первых, нужен text-to-speech, и я использую Piper — легковесный TTS, запускающийся на машинах без GPU и даже на Raspberry PI. Он поддерживает множество различных языков, в том числе достаточно малые. Голоса могут быть дотренированы в ходе отдельной процедуры обучения.

Во-вторых, нужно распознавание голоса. Стандартом де-факто здесь является Whisper, который преобразует сказанный текст в строку со всей необходимой пунктуацией. Однако, конкретно для помощника гораздо лучше подходит Kaldi, который я использую через его имплементацию в Rhasspy: он позволяет определить грамматику с фразами, которые будут распознаны помощником, и с такой закрытой грамматикой работает быстрее Whisper, при этом совмещая text-to-speech и natural-language understanding. Кроме того, есть еще Vosk — как и Whisper, он работает по открытой грамматике, он быстрее и существенно менее требователен к ресурсам, его выход лучше привязан к звуковому потоку, но отсутствует украшение в виде пунктуации.

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

Для генерации картинок я использую ComfyUI, стандартное и эффективное решение в этой области. Для рисования картинок с моими персонажами мне необходимо сначала натренировать LoRA для них, и с этим мне помогает KohyaSS. Для тренировки LoRA, в свою очередь, требуется подготовить датасет, и здесь требуется огромный арсенал инструментов: разделение видео на отдельные кадры, поиск лиц на этих кадрах с помощью YOLO и тэгирование изображений с помощью WD14Tagger.

Похожая ситуация с обучением голоса. Для него требуется около получаса чистых сэмплов, без музыки и шумов. Найти такое количество голосов в первоисточников очень непросто, поэтому я применяю апсемплинг: на основе ~1 минуты звуков из первоисточников я генерирую требуемые 30 минут с помощью Zonos или CoquiTTS.

Меньше всего проблем в перефразом: для этого нужна только LLM, Llama либо Mistral (для европейских языков), и они доступны через решение Ollama.

Собственно, из всех упомянутых систем только Ollama способна беспроблемно установиться, выкачать все, что ей нужно для работы и далее работать через API. Остальные системы на таком уровне, мягко говоря, не находятся, и часто представляют собой просто репозиторий с кодом и ноутбук с демонстрацией — и нужно еще как следует потрудиться, чтобы ее запустить, потому что с зависимостями в половине случаев царит полная неопределенность. Соответственно, для использования в проекте весь этот зоопарк нужно было как-то организовать. Так и появился BrainBox

Когда я уже написал BrainBox в проекте Kaia, я внезапно осознал, какого масштаба работу я проделал, и сколько шишек собрал на этом пути. Дополнительно в этом мне помогли студенты ФИИТ УрФУ, где я все еще волонтерю на проектной деятельности: задача "быстренько разобраться с новой ИИ-системой" могла легко растянуться на недели; задача "подготовить систему к использованию в продакшне" — на месяцы. Я понял, с какими серьезными вызовами на самом деле сталкивается человек, который хочет сделать небольшой ИИ-проект, даже самый простой: озвучивание аудиокниги, суммаризацию заметок, рисование обложек на Ютуб и так далее. И как многократно возрастают эти вызовы в случае, если python — не основной язык программирования. Порог вхождения в эту область слишком высок, и он вынуждает идти на поклон к корпоратам.

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

Я очень надеюсь, что BrainBox поможет новым людям приобщиться к удивительному миру современного ИИ, и создать больше хороших, полезных продуктов. Нынешние времена очень напоминают мне зарю Web2.0: Тогда тоже внезапно появились различные инструменты, с помощью которых люди создавали новые продукты, от фейсбука до личного приложения для заметок. Не все из них стали юникорнами, но многие были и остаются полезными для своих пользователей. Сейчас точно такое же время.

Архитектура

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

Докер-контейнеры

Первым вопросом, который встал передо мной при проектировании, был такой: как организовать множество ИИ систем для работы за единым веб-интерфейсом?

Первым решением было запихнуть все эти системы в одно приложение с веб-сервером. Эта идея была крайне неудачной, что стало понятно в самом начале: когда я попытался интегрировать вместе всего три системы (Oobabooga вместо Ollama, Automatic1111 вместо ComfyUI и TortoiseTTS), все они требовали своих конкретных версий библиотек и победить эту проблему оказалось непросто. Это был тупиковый путь.

Вторым подходом было написание нескольких маленьких серверов, каждый из которых обслуживал свою систему: в питоне есть механизм окружений, который позволяет так сделать. Это решило проблему Oobabooga, Automatic1111 и TortoiseTTS, однако уже на CoquiTTS выяснилось, что это решение тоже нежизнеспособно: CoquiTTS потребовало установки espeak, который под Windows установить не так-то просто, а другим системам уже были нужны и wget, и ffmpeg... Стало ясно, что инструкция по установке такого решения будет очень длинной и никто его себе устанавливать на Windows не будет. При этом Windows — это основная система для машин с хорошими GPU из-за игр, а значит, большой процент потенциальной ЦА останется при таком решении за бортом.

Финальной версией стала сборка каждой системы внутри собственного докер-контейнера. ffmpeg, espeak и все прочее устанавливаются автоматически через apt, соответственно, пользователю ни с чем, кроме установки Docker и Python, разбираться не придется. Контейнеры я решил собирать прямо на пользовательской машине — в противном случае, мне бы пришлось менеджить все увеличивающийся пул репозиториев, что делать лениво. Кроме того, централизация контейнеров завязала бы систему на конкретные локации в интернете, и сделало бы ее, по моему ощущению, менее свободной.

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

Очередь задач

Как правило, контейнеры содержат внутри себя HTTP-серверы — они, в основном, пишутся путем копипасты поставляемых с ИИ-системой ноутбуков в код сервера. По идее, этого уже достаточно для работы: минималистичный контроллерный веб-сервер запускает нужный вам ИИ, и затем вы общаетесь с ним через его собственный HTTP-сервер.

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

Поэтому я написал второй слой BrainBox поверх контроллерного — слой десайдеров: сущностей, методы которых вызывают эндпоинты HTTP-серверов моделей и преобразуют, если необходимо, их результат. Запрос на вызов того или иного метода десайдера я называю задачей. BrainBox организует очередь задач, приоритизирует ее и далее выполняет работы в соответствии с этой приоритизацией, поднимая и опуская нужные докер-контейнеры.

Приоритизацией занимается еще одна сущность — планер, который зависит от сценария использования BrainBox. В случае, когда BrainBox используется как поддерживающий сервер для Kaia, все нужные контейнеры поднимаются один раз, при старте Kaia, и затем BrainBox занимается исключительно диспетчеризацией запросов; в исследовательском режиме планер выбирает один из десайдеров, поднимает контейнер, выполняет все приписанные к нему задачи, затем опускает контейнер и переходит к следующему десайдеру. Добавление задач в очередь, блокировка процесса до достижения результата, мониторинг статуса и получение результатов осуществляется через эндпоинты BrainBox-сервера. Таким образом, слой десайдеров обеспечивает единый интерфейс для всех поддерживаемых систем.

Этот интерфейс дополнительно усилен PythonAPI, который упрощает создание задач за счет использования фич python. Это будет дополнительно разобрано далее, в примерах использования BrainBox.

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

В принципе, BrainBox может быть запущен на отдельной машине, например, в облаке, и выполнять также функцию удаленного сервера поддержки ИИ — что-то вроде open-source версии AWS Bedrock. Я использую такой сценарий в локальной сети, но для разворачивания в облаке нужно, вероятно, как-то решить вопрос с безопасностью — чего я не делаю, потому что ничего в этом не понимаю. Поэтому я из осторожности не рекомендую такой способ, но если вы знаете, что делаете, и готовы рискнуть, то я не ожидаю проблем на уровне самого BrainBox.

Самотестирование

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

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

Добавление нового десайдера

Для добавления в BrainBox новой ИИ-системы требуется выполнить следующую последовательность действий:

Заставить эту систему работать на своей машине вне докер-контейнера, и понять, какие зависимости для этого нужны
Создать контроллер для сборки контейнера с этими зависимостями и исходным кодом системы
Реализовать внутри контейнера веб-сервер
Реализовать десайдер, взаимодействующий с этим веб-сервером
Написать самотестирование

Сейчас эти процедуры можно сделать за несколько часов. Подробное видео, в котором я это делаю с нуля для системы Zonos, можно посмотреть здесь.

Использование BrainBox

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

Установка BrainBox

Для установки BrainBox требуются следующие шаги:

Установка Docker
Установка Python (я предпочитаю дистрибутив Anaconda)
Установка и самотестирование BrainBox.

Ссылки содержат руководства по установке, и обычно они работают хорошо. На случай, если вы новичок в Anaconda и Docker и/или у вас что-то не получается, я приведу в приложении более детальную инструкцию по их установке.

После установки Docker и Anaconda, создайте окружение для BrainBox:

conda create --name brainbox python=3.11

BrainBox протестирован для Python 3.9-3.13, но разработан на Python 3.11, поэтому это самая надежная для использования версия Python. После создания окружения, активируйте его:

conda activate brainbox

Все последующие операции с BrainBox необходимо выполнять с активированным окружением. Теперь вы можете установить BrainBox:

pip install kaia-brainbox

И, наконец, запустить его:

python -m brainbox.run --data-folder PATH_TO_SOME_LOCAL_FOLDER

Успешно запущенный сервер напечатает в консоли:

WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead. * Running on all addresses (0.0.0.0) * Running on http://127.0.0.1:8090 * Running on http://10.10.5.48:8090
Press CTRL+C to quit

Поскольку BrainBox все еще в стадии разработки, я рекомендую протестировать запущенный сервер. Для этого в другом консольном окне наберите:

conda activate brainbox
python -m brainbox.run_test

В случае успеха, тест напечатает ALL GOOD в конце.

Основной причиной неудач является незапущенный (в Windows или MacOS) Docker-сервер. В этом случае консоль теста напечатает длинную ошибку, заканчивающуюся в Windows:

error during connect: this error may indicate that the docker daemon is not running: Get "http://%2F%2F.%2Fpipe%2Fdocker_engine/v1.24/containers/json?all=1&filters=%7B%22ancestor%22%3A%7B%22hello_brain_box%22%3Atrue%7D%7D": open //./pipe/docker_engine: The system cannot find the file specified.

в MacOS:

Cannot connect to the Docker daemon at unix:///Users/yura/.docker/run/docker.sock. Is the docker daemon running?

Для исправления проблемы, запустите Docker Desktop в этих операционных системах, и запустите тесты снова. Сервер BrainBox можно не перезагружать. В Linux докер-демон по умолчанию запускается при загрузке ОС и не требует приложений, поэтому такой проблемы возникать не должно.

Для всех последующих примеров вам нужно запустить BrainBox и держать его запущенным все время работы. В Windows и MacOs также необходимо держать запущенным Docker Desktop.

Установка десайдера

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

Самый простой способ сделать это - через WebUI BrainBox, по адресу http://127.0.0.1:8090/controllers/status. Для действий, описанных ниже, вам понадобятся десайдеры Piper и WD14Tagger. Эти десайдеры не требуют ни GPU, ни в целом интенсивных вычислений, и заведутся на плюс-минус любом ноутбуке.

После установки, имеет смысл запустить процедуру самотестирования и ознакомиться с ее результатами: это позволит на ранней стадии отловить ошибки, а также позволит понять, как пользоваться установленными десайдерами.

Установить десайдеры можно не только через UI, но также с помощью API либо HTTP-запросов, этот пример я приведу ниже.

Озвучка (API)

Для Python разработан удобный API, который позволяет использовать Brainbox, по сути, в формате Remote Procedure Call, почти бесшовно:

from brainbox import BrainBox
from brainbox.deciders import Piper

if __name__ == '__main__':    
  
  #Создаем api для уже запущенного сервера    
  api = BrainBox.Api("127.0.0.1:8090")   
  
  #Запускаем озвучивание текста    
  result = api.execute(BrainBox.Task.call(Piper).voiceover("Привет, мир!", "ru")) 
  
  #Результат является строкой - именем файла. Этот файл можно скачать:    
  api.download(result, "./piper_result.wav")    
  
  #Либо открыть без скачивания, например, для ipywidgets.Audio    
  print(api.open_file(result).content[:10])

Piper - это десайдер, и его метод Piper::voiceover, будучи запущен из-под BrainBox, выполняет запрос к контейнеру piper. В приведенном коде, однако, вызова voiceover не происходит, поскольку реализован такой фокус: BrainBox.Task.call(Piper) через аннотацию возвращаемого значения "притворяется", что возвращает объект Piper, но на самом деле возвращает мок, вызовы которого строят задачу для BrainBox. Однако обманутый IDE показывает методы внутри класса Piper, для каждого из методов показывает аргументы с их типами, а при появлении документации, покажет и ее. Дополнительно мок выполняет проверку аргументов, и несогласованности на этом этапе будут отловлены до попадания задачи в BrainBox, то есть на стороне клиента.

Озвучка (HTTP-запросы)

Все API BrainBox доступно без использования питона. Этот способ не являлся основным для доступа к BrainBox, и в целом мне пока непонятно, насколько велик спрос на него. Поэтому это реализовано по принципу "лишь бы работало", и оно действительно работает, но расти есть куда, особенно в плане документации и формата передаваемых данных.

Следующая инструкция добавляет в очередь массив из одной задачи на озвучку, для Linux/MacOS:

curl -X POST "http://127.0.0.1:8090/jobs/add" \
     -H "Content-Type: application/json" \
     -d '{
         "arguments": {
             "jobs": [
                 {
                     "decider": "Piper",
                     "method": "voiceover",
                     "arguments": {
                         "text": "Привет, мир!",
                         "model": "ru"
                     }
                 }
             ]
         }
     }'

Windows:

curl -X POST "http://127.0.0.1:8090/jobs/add" ^
     -H "Content-Type: application/json" ^
     -d "{""arguments"":{""jobs"":[{""decider"":""Piper"",""method"":""voiceover"",""arguments"":{""text"":""Привет, мир!"",""model"":""ru""}}]}}"

Эти команды возвращают JSON следующего формата:

{
  "error": null, 
  "result": ["4e1ddb3d-c50b-4201-a90c-f954c8024ca8"]
}

где result - это массив id поставленных в очередь задач, по длине равный длине массива переданных задач. После этого, необходимо дождаться выполнения этой задачи с помощью эндпоинта join, в Linux/MacOS:

curl -X GET "http://127.0.0.1:8090/jobs/join" \
     -H "Content-Type: application/json" \
     -d '{
            "arguments": {
                "ids": ["4e1ddb3d-c50b-4201-a90c-f954c8024ca8"]
            }
         }'

В Windows:

curl -X GET "http://127.0.0.1:8090/jobs/join" ^
     -H "Content-Type: application/json" ^
     -d "{""arguments"":{""ids"":[""4e1ddb3d-c50b-4201-a90c-f954c8024ca8""]}}"

Результатом этого вызова является уже непосредственно результат озвучки:

{
  "error": null,
  "result": ["4e1ddb3d-c50b-4201-a90c-f954c8024ca8.output.wav"]
}

Поскольку результатом озвучки является бинарный контент, этот контент сохраняется в файл и возвращается только имя файла. Соответственно, файл необходимо скачать из кэша BrainBox:

curl -o voiceover.wav http://127.0.0.1:8090/cache/download/4e1ddb3d-c50b-4201-a90c-f954c8024ca8.output.wav

Распознавание изображений

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

from brainbox import BrainBox
from brainbox.deciders import WD14Tagger
from pathlib import Path


if __name__ == '__main__':
    api = BrainBox.Api("127.0.0.1:8090")

    api.upload('image.png', Path(__file__).parent/'image.png')

    result = api.execute(BrainBox.Task.call(WD14Tagger).interrogate('image.png'))
    print(result)

На самом деле, загрузку файлов можно "обойти" несколькими способами. В первом из них передается путь до файла:

result = api.execute(BrainBox.Task.call(WD14Tagger).interrogate(Path(__file__).parent/'image.png'))

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

Кроме того, можно передать весь файл целиком:

with open(Path(__file__).parent/'image.png', 'rb') as file:
    image = file.read()

result = api.execute(BrainBox.Task.call(WD14Tagger).interrogate(image))

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

Лучше всего - если вход одного десайдера является выходом другого. В этом случае ни скачивать, ни заливать ничего не нужно: все файлы лежат в кэше BrainBox, и, соответственно, между десайдерами нужно передавать лишь их имена.

На уровне HTTP-запросов, загрузка файлов происходит стандартным образом:

curl -X POST -F "image.png=@image.png" http://127.0.0.1:8090/cache/upload

После этого, необходимо выполнить ту же пару add/join со следующим JSON:

{
  "arguments": {
    "jobs": [
      {
        "decider": "WD14Tagger",
        "method": "interrogate",
        "arguments": {
          "image": "image.png"
        }
      }
    ]
  }
}

Заключение

Я надеюсь, что приведенные примеры убедят вас попробовать BrainBox для своих проектов, и что это решение окажется вам полезным. Я достаточно уверен в его стабильности: уже около года я использую BrainBox как сервер поддержки для Kaia, а также как исследовательский сервер для таких задач, как подготовка сэмплов для клонирования голоса, изготовления LoRA моделей, рисования картинок или перефраза ответов голосового помощника в зависимости от персонажа. Кроме того, я выполнил пару небольших проектов на BrainBox, типа озвучивания аудиокниги или описания одежды на фотографии.

Дополнительная документация по BrainBox находится на его Pypi-странице, и содержит следующие темы:

Управление ресурсами десайдеров, разделяемыми между файловой системой хоста и контейнером
Скачивание дополнительных моделей для десайдеров
Построение воркфлоу для десайдеров
Пакетный запуск задач со сбором их результатов воедино

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

Приложение

Установка Docker

Перед тем как устанавливать Docker, проверьте, что он еще не установлен. Для этого в Windows и MacOS поищите приложение DockerDesktop и запустите его; в Linux этот шаг не требуется. Далее откройте командную строку и наберите

docker run hello-world

В случае успеха, будет возвращен текст, начинающийся с Hello from Docker!

Если Docker Desktop отсутствует и команда docker не обнаружена, установите Docker, выполнив инструкции:

Для Windows
Для MacOS
Для Linux, кроме этого, необходимы несколько обязательных шагов

После установки перезагрузите систему, откройте Docker Desktop и выполните docker run hello-world еще раз.

Если на вашей машине установлено GPU и вы хотите убедиться, что оно корректно пробрасывается в Docker, выполните

docker run --gpus all hello-world

Если будет возвращен текст, начинающийся с Hello from Docker!, то все хорошо. В противном случае, вам нужно убедиться, что у вас установлены нужные драйверы CUDA для взаимодействия с докером.

Установка Anaconda

Зайдите на https://www.anaconda.com/download/success
Выберите вашу операционную систему
Скачайте и установите дистрибутив

В Linux и MacOS команды Anaconda будут доступны из обычного терминала. В Windows следует использовать программу "Anaconda Prompt", которая появится после установки.

Установка десайдера через API

Следующий код проверяет, установлен ли десайдер (Piper), и устанавливает его в случае отсутствия:

from brainbox import BrainBox
from brainbox.deciders import Piper


if __name__ == '__main__':
    api = BrainBox.Api("127.0.0.1:8090")
    status = api.controller_api.controller_status(Piper)
    if not status.installation_status.installed:
        api.controller_api.install(Piper, True)
        api.controller_api.self_test(Piper)

Для уровня HTTP-запросов эта проверка выполняется несколько сложнее, и я приведу ее тоже на Python, но с использованием библиотеки requests.

import requests

if __name__ == '__main__':
    status = requests.post(
        'http://127.0.0.1:8090/controllers/status',
        json=dict(arguments={})
    )

    containers = status.json()['result']['@content']['containers']
    piper_container = next((c for c in containers if c['name']=='Piper'))
    if not piper_container['installation_status']['installed']:
        requests.post(
            'http://127.0.0.1:8090/controllers/install',
            json=dict(arguments=dict(decider='Piper', join=True))
        )
        requests.post(
            'http://127.0.0.1:8090/controllers/self_test',
            json=dict(arguments=dict(decider='Piper'))
        )