Машинное обучение на Android: запуск TensorFlow Lite и PyTorch Mobile в Termux, подготовка моделей и ускорение через OpenCL

Android давно перестал быть «только для приложений»: его мощности хватает для обучения на небольших задачах и, особенно, для инференса (выполнения готовых моделей). В этой статье покажем, как организовать рабочее окружение машинного обучения в Termux, чтобы запускать модели TensorFlow Lite и PyTorch Mobile, подготовить модели под мобильный запуск и обсудить практические способы ускорения с учетом OpenCL.

Материал ориентирован на реальную разработку: вы сможете подготовить артефакты (модели/конфиги), собрать минимальный пайплайн запуска и продумать оптимизацию под конкретное устройство.

Требования и важные оговорки

Android (желательно 8+ для стабильности современных пакетов в Termux).
Termux из F-Droid/официального источника.
Свободное место (зависит от ваших моделей и образа сборки).
Понимание различий: инференс обычно выполняется без обучения, а подготовка/конвертация моделей может делаться на ПК или прямо на телефоне.
OpenCL: доступность и качество ускорения зависят от драйверов и GPU-стека конкретного устройства. Мы рассмотрим подходы, но результат может отличаться.

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

Подготовка Termux: базовая среда для ML

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

pkg update && pkg upgrade -y
pkg install -y build-essential python git wget curl unzip tar

Далее установите Python-пакеты для подготовки моделей (если планируете конвертацию/предобработку в Termux).

pip install --upgrade pip
pip install numpy pillow onnx onnxruntime

Примечание: Python-окружение в Termux удобно для подготовки данных, извлечения признаков и конвертации. Для самого инференса TensorFlow Lite и PyTorch Mobile часто эффективнее использовать нативные рантаймы (C++/готовые бинари), но Python может помочь в тестах.

TensorFlow Lite в Termux: подготовка модели

TensorFlow Lite (TFLite) — один из наиболее практичных вариантов для Android-инференса. В Termux вы обычно делаете следующее:

Подготовка модели (конвертация из TensorFlow/keras или из другого формата).
Проверка входов/выходов (shape, типы, нормализация).
Запуск инференса через TFLite рантайм (в зависимости от того, как вы решите организовать рантайм в Termux).

Конвертация в TensorFlow Lite

Если у вас есть модель в TensorFlow, типовой путь — сохранение в формате SavedModel и конвертация в .tflite. На практике, часто удобнее делать конвертацию на ПК, а в Termux переносить готовый артефакт.

Пример шаблона конвертации (на стороне, где доступен TensorFlow):

import tensorflow as tf

model = tf.keras.models.load_model('model.h5')
converter = tf.lite.TFLiteConverter.from_keras_model(model)

# Для оптимизации иногда включают оптимизации и квантование.
# converter.optimizations = [tf.lite.Optimize.DEFAULT]

tflite_model = converter.convert()
with open('model.tflite', 'wb') as f:
    f.write(tflite_model)

На стороне Termux вы используете уже готовый model.tflite.

Тестирование входов/выходов в Termux

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

python - <<'PY'
import numpy as np

# Пример: демонстрационный код. Подставьте правильные input/output details.
# Для реальной модели нужно знать размерность входа и имя/индексы тензоров.

try:
    import tflite_runtime.interpreter as tflite
except ImportError:
    # Если tflite_runtime нет — можно использовать tensorflow (если установлен).
    import tensorflow as tf
    interpreter = tf.lite.Interpreter(model_path='model.tflite')
else:
    interpreter = tflite.Interpreter(model_path='model.tflite')

interpreter.allocate_tensors()
input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()

print('Input details:', input_details)
print('Output details:', output_details)

# Допустим, модель ожидает float32 [1, 224, 224, 3]
# Замените на ваши shape и preprocess.
input_shape = input_details[0]['shape']
x = np.random.rand(*input_shape).astype(np.float32)

interpreter.set_tensor(input_details[0]['index'], x)
interpreter.invoke()

y = interpreter.get_tensor(output_details[0]['index'])
print('Output:', y)
PY

Если у вас пока нет tflite_runtime, можно установить его (зависит от доступных пакетов в вашем окружении). Альтернатива — использовать tensorflow, но это обычно тяжелее для Termux.

PyTorch Mobile в Termux: формат и сценарии запуска

Для PyTorch Mobile обычно используют TorchScript (scripted или traced модель) и запускают через мобильный интерпретатор (в классическом мире — через Java/Kotlin, но в нашем контексте ключевой вопрос: как вы хотите реализовать рантайм в Termux).

В Termux чаще всего делают так:

Подготавливают модель на ПК: переводят в TorchScript.
Загружают и тестируют артефакт в среде, где есть совместимый рантайм.
При необходимости — пишут минимальный C++/Python тест, но чаще практичнее ограничиться демонстрацией корректности выходов.

Экспорт модели в TorchScript

Если у вас есть модель в PyTorch:

import torch

model = ...
model.eval()

# Вариант 1: tracing (если входы стабильны по форме)
example = torch.randn(1, 3, 224, 224)
traced = torch.jit.trace(model, example)
traced.save('model.pt')

# Вариант 2: scripting (когда модель содержит python-логики,
# совместимой с torchscript)
# scripted = torch.jit.script(model)
# scripted.save('model.pt')

Важный момент: обязательно проверьте, что preprocess для PyTorch и TFLite совпадает логически (масштабирование, нормализация, расположение каналов и порядок измерений).

Запуск PyTorch Mobile из Termux: практический подход

Варианты зависят от того, есть ли в вашем окружении готовый рантайм. На практике часто проще организовать запуск в связке «Termux + локальная сборка/бинарник рантайма», но это требует аккуратной настройки toolchain и совместимости библиотек.

Рекомендуемый инженерный подход для команды разработки:

Сначала обеспечить корректность артефакта: TorchScript модель должна воспроизводить outputs на ПК.
Затем проверить инференс на Android-рантайме (через ваш целевой стек).
И только после этого переносить в Termux как часть рабочего инструментария (например, для быстрой регрессии).

Если вы хотите, мы можем помочь составить «минимальный контейнерный» сценарий сборки рантайма под вашу архитектуру (arm64-v8a/armeabi-v7a) — но он выходит за рамки универсального шаблона, так как зависит от конкретного устройства и доступных пакетов.

Подготовка данных и сопоставление с реальным pre/post-processing

Самая частая причина «модель не работает» в мобильной среде — различия в предобработке и интерпретации выходов. Рекомендуется:

Фиксировать pipeline: resize/crop, нормализацию (mean/std или scale), порядок каналов (HWC vs CHW), тип (float32/int8).
Сравнивать выходы на ПК и на телефоне: например, первые 10 классов и вероятности.
Для квантованных моделей (int8) обязательно учитывать scale/zero-point и соответствующие параметры в preproc.

Оптимизация моделей: квантование и ускорение инференса

Для ускорения на Android ключевые рычаги:

Квантование: от float32 к float16 или int8 (при корректной калибровке).
Оптимизация графа: fold constants, удаление неиспользуемых узлов.
Снижение разрешения входа там, где это приемлемо по качеству.
Выбор модели (lightweight backbones) и разумная батч-стратегия (обычно batch=1).

Пример стратегии для TFLite:

# На стадии конвертации (зависит от модели и калибровочного датасета):
converter.optimizations = [tf.lite.Optimize.DEFAULT]

# Для int8 нужна representative dataset:
# def representative_dataset_gen():
#     for sample in ...:
#         yield [sample]
#
# converter.representative_dataset = representative_dataset_gen
# converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]
# converter.inference_input_type = tf.int8
# converter.inference_output_type = tf.int8

Если вы добиваетесь стабильного качества после квантования — ускорение часто становится заметным.

OpenCL на Android: как мыслить об ускорении

OpenCL может дать выигрыш, но это не «волшебная кнопка». В реальности ускорение зависит от:

наличия OpenCL ICD/драйверов и корректности поставляемых библиотек;
поддержки OpenCL со стороны конкретного рантайма (TFLite delegate, custom backend и т.д.);
типа модели и операций: часть ops может не иметь OpenCL-реализации, и тогда будет смешанный режим (часть на CPU).

В рамках практичного подхода в Termux важно не «включить OpenCL», а проверить, доступна ли платформа и есть ли поддержка делегатов в вашем стеке.

Проверка доступности OpenCL (диагностика)

Набор инструментов зависит от того, установлены ли OpenCL заголовки/утилиты и есть ли доступ к runtime. Начните с поиска пакетов и базовой диагностики устройства.

pkg install -y clang lldb
# Далее обычно проверяют наличие opencl headers/loader в окружении.
# На многих устройствах драйверы предоставляются системой, но доступ в Termux может требовать дополнительных библиотек.

Если у вас есть доступ к соответствующим утилитам (например, из комплектов opencl-dev), можно собрать маленький диагностический пример. Однако конкретные команды зависят от наличия пакетов в репозитории Termux и архитектуры.

OpenCL делегирование в TFLite: ключевая идея

Для TFLite чаще рассматривают делегаты (delegates), которые могут использовать GPU/OpenCL-подобные пути. В инженерной практике план такой:

Определить: какой рантайм/библиотека у вас реально используется в Termux (чистый interpreter, кастомный сборочный рантайм, delegate).
Уточнить: есть ли delegate, который поддерживает OpenCL на вашем устройстве.
Сравнить производительность: CPU-only vs с delegate.

Так как конкретные делегаты зависят от версии рантайма и сборки, универсальный «один набор команд» для всех устройств дать сложно. Но алгоритм оценки одинаковый: проверка доступности → включение delegate (если поддерживается) → замер latency на нескольких прогонов → проверка качества.

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

Чтобы ускорение было реальным, измеряйте:

latency (время одного инференса), желательно усреднение по 50–200 прогонам;
warm-up (первые 5–10 прогонов часто нерепрезентативны);
стабильность: разброс значений и влияние фоновых процессов;
температуру и троттлинг (при необходимости — через системные индикаторы).

Если вы ведете разработку в команде, полезно фиксировать набор тестов и сравнивать результаты на одном и том же устройстве.

Типовой рабочий пайплайн: от обучения до запуска

Выбор модели (под вашу задачу и ограничения по размеру).
Подготовка данных: единый preproc для обучения и инференса.
Экспорт в TFLite (.tflite) или TorchScript (.pt).
Оптимизация: квантование/граф-оптимизации/заморозка batch.
Тест на ПК: сравнение outputs.
Перенос в Termux и тест корректности.
Ускорение: проверка delegate/библиотек, анализ OpenCL доступности и замеры.

Практические замечания по совместимости

Архитектура: arm64 обычно проще; armeabi-v7a может потребовать отдельной сборки.
Версии библиотек: разная версия protobuf/flatbuffers может влиять на запуск конвертированных моделей.
Типы данных: float16/int8 требуют точного соответствия pipeline.
Операции: некоторые кастомные ops могут не поддерживаться в TFLite без расширений.

Заключение

Машинное обучение на Android через Termux — это реалистичный способ быстро подготовить и проверить инференс моделей. TensorFlow Lite и PyTorch Mobile дают разные компромиссы: TFLite часто проще в плане портирования и оптимизаций, а PyTorch Mobile хорошо подходит, когда вам ближе экосистема TorchScript. Ускорение через OpenCL возможно, но его нужно рассматривать как инженерную задачу: сначала диагностика доступности, затем корректное включение delegate/рантайма (если поддерживается в вашем стеке) и обязательные замеры latency.

Если хотите получить результат быстрее и без «потери времени на несовместимости», обращайтесь в РыбинскЛАБ: мы помогаем с подготовкой моделей под мобильный запуск, настройкой Termux-среды, подбором оптимизаций (включая квантование) и настройкой/проверкой ускорения под конкретные устройства.