Termux и машинное обучение на мобильных GPU: установка PyTorch, TensorFlow Lite и обучение небольших моделей непосредственно на устройстве

Машинное обучение на мобильном устройстве перестало быть экспериментом: современные смартфоны с GPU ускоряют вычисления, а Termux позволяет собрать удобную среду для экспериментов. В этом материале мы разберём, как организовать рабочее окружение в Termux для:

• установки и тестирования TensorFlow Lite (как наиболее практичный вариант для инференса и мобильных сценариев),
• подготовки окружения для PyTorch (с учётом ограничений мобильных платформ),
• обучения небольших моделей непосредственно на устройстве (там, где это реально по ресурсам),
• управления зависимостями, памятью и ускорением (в том числе с GPU).

Важно: «максимальная скорость» на телефоне зависит от GPU, драйверов и типа акселератора. Поэтому ниже мы ориентируемся на инженерный подход: проверяем доступность ускорений на практике и выбираем то, что реально работает в вашей модели смартфона.

Подготовка устройства и Termux

Перед стартом убедитесь, что устройство соответствует базовым условиям:

• Android версии: чем новее, тем проще добиться совместимости пакетов (обычно от Android 10 и выше).
• Достаточно свободного места (для зависимостей может понадобиться несколько сотен мегабайт).
• Желательно включить режим, при котором Termux не «убивает» процессы в фоне.

Начните с обновления пакетов внутри Termux:

pkg update && pkg upgrade -y

Далее установим базовые инструменты и Python:

pkg install -y python git wget clang cmake make pkg-config

Проверьте версию Python:

python -V

Если у вас есть привычные менеджеры зависимостей, можно использовать venv. Для предсказуемости лучше отделять проекты:

python -m venv ~/ml-env

source ~/ml-env/bin/activate

Проверьте, что окружение активировано:

which python

Установка и базовая проверка TensorFlow Lite

Для мобильных сценариев чаще всего оптимален стек TensorFlow Lite: модель можно конвертировать в формат TFLite и запускать локально. Ускорение зависит от интерпретатора и delegate’ов, но даже без GPU обычно можно получить приемлемую производительность для небольших моделей.

Установим TensorFlow (в режиме совместимости с TFLite на Android через Python-пакет). На практике возможны различия по версии, поэтому ориентируйтесь на «последний стабильный релиз», который доступен в вашей среде:

pip install --upgrade pip

pip install tensorflow

После установки проверим импорт:

python -c "import tensorflow as tf; print(tf.version)"

Проверка TFLite-интерпретатора:

python - <<'PY'
import tensorflow as tf
print("TFLite available:", hasattr(tf, "lite"))
print("Interpreter:", tf.lite.Interpreter)
PY

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

• конвертируете/создаёте небольшую модель,
• получаете TFLite-модель (.tflite),
• запускаете инференс в интерпретаторе.

Инференс TFLite на устройстве: минимальный пример

Допустим, у вас уже есть файл модели model.tflite. Запустим инференс через интерпретатор. Файл ввода в примере условный — вам нужно подставить свой препроцессинг под конкретную архитектуру.

python - <<'PY'
import numpy as np
import tensorflow as tf

model_path = "model.tflite"
interpreter = tf.lite.Interpreter(model_path=model_path)
interpreter.allocate_tensors()

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

# Пример: создаём случайный вход нужной формы
inp_shape = input_details[0]['shape']
inp_dtype = input_details[0]['dtype']
x = np.random.random(inp_shape).astype(inp_dtype)

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

y = interpreter.get_tensor(output_details[0]['index'])
print("Output shape:", y.shape)
print("Output sample:", y.flatten()[:10])
PY

Практический совет: если модель не встаёт в память или запускается медленно, уменьшайте размер входа, используйте квантование (например, int8), и ограничивайте batch до 1.

GPU-ускорение в TFLite: что ожидать

В TFLite «подключение GPU» обычно реализуется через delegate’ы. На реальном устройстве доступность delegate’ов зависит от:

• версии Android и графического стека,
• того, собран ли delegate в составе пакета и доступен ли для вашей платформы,
• совместимости формата модели.

Универсальный способ — сначала попытаться использовать TFLite delegate (если он доступен в вашей сборке). Например, на некоторых платформах встречаются варианты GPU delegate через отдельные пакеты или через API, но в Termux конкретная доступность может отличаться.

Поэтому корректная стратегия такая:

• сначала подтверждаете корректность инференса на CPU,
• затем изучаете, какие delegate’ы присутствуют в вашей сборке TensorFlow,
• и только после этого включаете ускорение.

Если вы хотите, я могу подсказать конкретный путь под вашу модель смартфона и версию TensorFlow, но для этого нужны: модель устройства, Android-версия и вывод python -c "import tensorflow as tf; print(tf.version)".

Подготовка к PyTorch на мобильном устройстве

PyTorch на мобильных GPU — задача более сложная, чем TFLite, потому что:

• мобильный Python-стек (Termux) не всегда совпадает с тем, что предполагают сборки PyTorch для Android,
• ускорение через CUDA в телефоне недоступно (а вместо CUDA используются другие механизмы),
• возможны ограничения по бинарным зависимостям.

Тем не менее, можно настроить окружение для небольших экспериментов: обучать на CPU и/или использовать PyTorch для подготовки/экспортирования моделей, затем конвертировать в TFLite для запуска на устройстве.

Попробуем установить PyTorch:

pip install torch torchvision torchaudio

Проверка:

python - <<'PY'
import torch
print("torch:", torch.version)
print("cuda available:", torch.cuda.is_available())
print("mps available:", hasattr(torch.backends, "mps") and torch.backends.mps.is_available())
PY

Если cuda недоступно (скорее всего так и будет), это нормально. Фокус для мобильного обучения в реальности чаще переносится на:

• обучение маленьких моделей на CPU (быстро и стабильно),
• инференс через TFLite (с потенциальным ускорением).

Если установка PyTorch проходит, но упирается в совместимость — можно рассмотреть схему «обучаю в облаке/на ПК → конвертирую → запускаю в Termux». Для обучения «прямо на телефоне» PyTorch часто требует более тонкой настройки под конкретную архитектуру.

Обучение небольших моделей в Termux: инженерный подход

Обучение на телефоне возможно, но важно сделать его «маленьким»:

• выбирайте простые модели (линейные/MLP, небольшие CNN, lightweight-архитектуры),
• используйте небольшие батчи (например, 8/16),
• следите за памятью (если устройство начинает «тормозить», снижайте размер входа/батча),
• сохраняйте чекпоинты и уменьшайте количество эпох для тестов.

Ниже — общий шаблон цикла обучения (без привязки к конкретной библиотеке). Для TensorFlow можно использовать Keras, а для PyTorch — свой тренировочный цикл. В рамках Termux наиболее практично сначала обучить на CPU через небольшой Keras/TF-подход, а затем экспортировать в TFLite.

Пример «скелета» обучения (Keras):

python - <<'PY'
import tensorflow as tf
import numpy as np

# Пример синтетических данных: замените на свои
x_train = np.random.random((256, 32, 32, 3)).astype(np.float32)
y_train = np.random.randint(0, 10, size=(256,))
y_train = tf.keras.utils.to_categorical(y_train, num_classes=10)

model = tf.keras.Sequential([
    tf.keras.layers.Input(shape=(32, 32, 3)),
    tf.keras.layers.Conv2D(8, 3, activation="relu"),
    tf.keras.layers.MaxPool2D(),
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dense(32, activation="relu"),
    tf.keras.layers.Dense(10, activation="softmax"),
])

model.compile(optimizer="adam",
              loss="categorical_crossentropy",
              metrics=["accuracy"])

model.fit(x_train, y_train, epochs=3, batch_size=16)

# Сохранение
model.save("small_model_tf")
print("Saved.")
PY

Дальше вы конвертируете модель в TFLite и запускаете инференс.

Экспорт в TFLite из TensorFlow

После того как модель обучена в TensorFlow, конвертируйте в TFLite:

python - <<'PY'
import tensorflow as tf

model = tf.keras.models.load_model("small_model_tf")
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)

print("TFLite saved to model.tflite")
PY

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

Оптимизация для скорости и стабильности на телефоне

Чтобы обучение и инференс были «живыми» на мобильном устройстве, используйте следующие практики:

• Квантование: попробуйте уменьшить точность (например, int8) — это часто сильно ускоряет инференс.
• Снижение разрешения: для изображений уменьшайте вход (например, 224 → 96/64).
• Batch size: делайте небольшим (обычно 1–16).
• Сериализация: периодически сохраняйте чекпоинты, чтобы не терять время.
• Контроль времени: замеряйте инференс (например, несколько прогонов) и смотрите, где узкое место.

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

Процесс от идеи до работающей модели на устройстве

Рекомендованный пайплайн для Termux и мобильного ML:

1. Соберите окружение в Termux и протестируйте базовый инференс через TFLite.
2. Сделайте простую модель, обучите её на телефоне (если хватает ресурсов) или загрузите готовую.
3. Сконвертируйте в .tflite и проверьте корректность выхода.
4. Только затем пробуйте ускорение через delegate’ы (GPU/NNAPI), если они доступны.
5. Сделайте профилирование: проверьте форму входа, тип данных, размеры тензоров.

Типичные проблемы и способы их решения

1) Установка пакетов падает
Причины: несовпадение версий, отсутствие бинарей для вашей платформы, конфликты зависимостей. Решение: обновите pip, используйте виртуальное окружение, уменьшите требования (например, сначала только TFLite), и фиксируйте версии пакетов.

2) Модель не конвертируется в TFLite
Причины: неподдерживаемые операции. Решение: упростите архитектуру, используйте поддерживаемые слои, попробуйте отключить оптимизации квантования на первом этапе.

3) Инференс слишком медленный
Решение: квантование, уменьшение входа, упрощение сети, batch=1, сокращение постобработки.

4) PyTorch не видит ускорение
На телефоне почти всегда отсутствует «классическая» GPU-ветка уровня CUDA. Поэтому реалистичная цель — обучение на CPU и последующий экспорт/конвертация для мобильного запуска (через TFLite).

Заключение

Termux позволяет организовать на Android практичную среду для машинного обучения: вы можете начать с TensorFlow Lite для быстрого и локального инференса, при необходимости — подготовить модели через PyTorch (или обучить маленькие модели на CPU), затем конвертировать и запускать их на устройстве. Главный принцип — тестировать реальные ограничения вашего смартфона и строить пайплайн так, чтобы ускорение и стабильность обеспечивались не «в теории», а по факту.

Если хотите, мы в РыбинскЛАБ поможем: подберём оптимальный стек под ваш Android/GPU, настроим окружение в Termux, подготовим pipeline обучения/конвертации в TFLite и поможем довести модель до стабильной работы на устройстве.