Применение машинного обучения в терминальном окружении: обучение моделей классификации трафика на лету с TensorFlow Lite в Termux

Termux давно перестал быть просто «портабельной консолью»: на нём реально строить прикладные ML-сценарии — от обработки логов до анализа данных в реальном времени. В этой статье рассматривается подход к классификации сетевого трафика на лету в терминальном окружении с использованием TensorFlow Lite. Акцент сделан на инженерной стороне: сбор признаков, подготовка данных, обучение (или дообучение) и последующий запуск инференса в Termux.

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

Архитектура решения

Типовая схема выглядит так:

1. Сбор данных в Termux: получение признаков, описывающих сетевые события (например, временные окна, объёмы, частоты, статистики по пакетам/соединениям).
2. Формирование признаков: приведение к фиксированному набору числовых признаков, нормализация.
3. Модель: лёгкая нейросетевая/классификационная архитектура, совместимая с TensorFlow Lite.
4. Обучение/дообучение: как правило, на ПК/сервере (или на самом устройстве при ограниченных задачах). На стороне Termux — запуск модели для инференса.
5. Инференс на лету: классификация текущего окна трафика и выдача результата в консоль/лог.
6. Наблюдаемость: логи решений, метрики, сохранение батчей признаков для последующего обучения.

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

Подготовка Termux и окружения

Начните с обновления пакетов и установки базовых компонентов. Для работы с Python и научным стеком в Termux обычно используются системные пакеты и/или Python-пакетный менеджмент.

pkg update -y
pkg upgrade -y
pkg install -y python clang git wget curl

Далее создайте виртуальное окружение (рекомендуется для чистоты зависимостей):

python -m venv venv
source venv/bin/activate

Установите зависимости для работы с TFLite. Конкретные версии пакетов могут отличаться в зависимости от текущих репозиториев Termux, поэтому ориентируйтесь на совместимость. Как минимум, потребуется интерпретатор TensorFlow Lite.

Базовый вариант (обычно работает с tflite-runtime либо с полной tensorflow — но полная установка TensorFlow в Termux может быть тяжёлой):

pip install --upgrade pip
pip install tflite-runtime numpy

Если tflite-runtime недоступен, можно использовать связку с TensorFlow Lite через подходящие пакеты для вашей среды. В любом случае цель — получить работающий интерпретатор TFLite (Interpreter).

Сбор сетевых признаков в терминале

Ключевой этап — превратить «сырые» сетевые данные в фиксированный набор признаков. На практике чаще всего берут показатели по потокам/соединениям и по временным окнам. В Termux обычно используют:

• логирование активностей сетевого стека (если доступно в вашей конфигурации);
• агрегацию статистик через системные утилиты и доступные API;
• снятие метрик по сокетам/соединениям в рамках разрешённых возможностей.

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

Ниже пример каркаса: создаём окно длительностью 5 секунд и формируем простые признаки (это учебная заготовка — под вашу реальную задачу признаки нужно адаптировать).

import time
import numpy as np

WINDOW_SECONDS = 5

def collect_raw_stats():
    # Заглушка: вместо неё подставьте реальный сбор статистик
    # Например: количество пакетов, суммарные байты, средняя скорость,
    # число новых соединений и т.д.
    return {
        "bytes": np.random.randint(1000, 500000),
        "packets": np.random.randint(10, 2000),
        "flows": np.random.randint(1, 50),
    }

def featurize(stats):
    # Пример: приводим к фиксированному вектору признаков
    # В реальном проекте добавьте больше признаков и нормализацию.
    return np.array([
        stats["bytes"],
        stats["packets"],
        stats["flows"],
        stats["bytes"] / max(stats["packets"], 1),  # средний размер пакета (грубо)
    ], dtype=np.float32)

def streaming_generator():
    last_emit = time.time()
    buffer = []

    while True:
        stats = collect_raw_stats()
        buffer.append(stats)

        if time.time() - last_emit >= WINDOW_SECONDS:
            # Агрегируем по окну
            agg = {
                "bytes": sum(x["bytes"] for x in buffer),
                "packets": sum(x["packets"] for x in buffer),
                "flows": max(x["flows"] for x in buffer),
            }
            x = featurize(agg)
            yield x
            buffer.clear()
            last_emit = time.time()

Для промышленной точности важно, чтобы скрипт формирования признаков был идентичен тому, что применялся при обучении модели (включая нормализацию, масштабирование и порядок признаков).

Подготовка модели для TensorFlow Lite

Предположим, у вас есть обученная модель классификации (например, логистическая регрессия, небольшой MLP, сверточная/рекуррентная модель для последовательностей признаков и т.п.). Далее её нужно подготовить в формат TensorFlow Lite.

Если модель обучалась на ПК, на стороне обучения используйте экспорт в .tflite. Общая идея:

• убедиться, что вход соответствует форме (shape) и типу (например, float32);
• включить/сохранить правильную сигнатуру входа/выхода;
• экспортировать модель в TensorFlow Lite.

Пример экспорта зависит от того, на чём именно обучали модель. Ниже — иллюстративный код для TensorFlow:

import tensorflow as tf

model = ...  # ваша обученная модель Keras
converter = tf.lite.TFLiteConverter.from_keras_model(model)

# Настройки можно уточнять под задачу (например, оптимизация)
converter.optimizations = [tf.lite.Optimize.DEFAULT]

tflite_model = converter.convert()

with open("traffic_classifier.tflite", "wb") as f:
    f.write(tflite_model)

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

Инференс в Termux с TensorFlow Lite

На стороне Termux загружаем .tflite, создаём интерпретатор, подаём входной тензор и получаем вероятности/класс.

Пример скрипта инференса:

import numpy as np
import tflite_runtime.interpreter as tflite
from collections import deque

LABELS = ["class_0", "class_1", "class_2"]
MODEL_PATH = "traffic_classifier.tflite"

interpreter = tflite.Interpreter(model_path=MODEL_PATH)
interpreter.allocate_tensors()

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

input_index = input_details[0]["index"]
output_index = output_details[0]["index"]

# Тип и форма ввода
in_dtype = input_details[0]["dtype"]
in_shape = input_details[0]["shape"]  # например: [1, 4]

def run_inference(x_vec):
    # Приводим форму к нужной (batch, features, ...)
    x = np.array(x_vec, dtype=np.float32)
    # Предположим, что модель ждёт shape [1, 4]
    x = x.reshape(in_shape).astype(in_dtype)

    interpreter.set_tensor(input_index, x)
    interpreter.invoke()

    y = interpreter.get_tensor(output_index)
    # y может быть shape [1, num_classes] — приводим к 1D
    y = np.squeeze(y)

    pred_id = int(np.argmax(y))
    pred_prob = float(y[pred_id])
    return pred_id, pred_prob, y

# Демонстрация работы в режиме "на лету"
from time import sleep

# Предположим, streaming_generator() определён (см. пример выше)
def main():
    window_preds = deque(maxlen=10)
    for x_vec in streaming_generator():
        pred_id, pred_prob, probs = run_inference(x_vec)
        window_preds.append(pred_id)

        print(f"Prediction: {LABELS[pred_id]} (p={pred_prob:.3f}), last_window_probs={probs}")

        # Можно добавить сглаживание по последним окнам
        # Например, голосование:
        # majority = max(set(window_preds), key=window_preds.count)
        sleep(0.1)

if name == "main":
    main()

Практический совет: для «на лету» полезно применять сглаживание по нескольким окнам, иначе результат будет «мигать» из-за естественной вариативности трафика.

Обучение и/или дообучение: как организовать цикл

Под «обучением моделей классификации трафика на лету» чаще всего подразумевают один из двух вариантов:

• Онлайн-обновление модели: модель действительно обновляется в процессе (сложнее и часто требует специализированной архитектуры и тонкой настройки).
• Псевдо-онлайн цикл: Termux собирает данные и признаки, отправляет их на обучение/дообучение (например, на ПК), затем обновлённая модель возвращается в Termux для дальнейшего инференса.

На практике наиболее надёжный и повторяемый путь — второй вариант: вы собираете «сырые» события/признаки в Termux, размечаете (или используете слабую разметку), дообучаете на более мощной машине и затем экспортируете обновлённую TFLite-модель.

Организация конвейера выглядит так:

1. Termux сохраняет батчи признаков в файлы/логи (например, JSON/NPY/CSV).
2. ПК читает накопленные данные, применяет те же преобразования признаков.
3. Выполняется дообучение модели и экспорт в traffic_classifier.tflite.
4. Termux обновляет модель (например, заменой файла) и продолжает инференс.

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

Передача модели и признаков между устройствами

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

На практике используйте сценарий:

# На Termux:
cp traffic_classifier.tflite storage/shared/

# Затем передайте файл на ПК через USB или файловый менеджер

Обязательное требование для корректности: версионируйте схему признаков и модель (например, добавляйте номер версии в имя файла модели и в лог данных).

Оценка качества и эксплуатационные метрики

Для классификации трафика обычно нужны:

• Матрица ошибок (precision/recall по классам).
• Калибровка вероятностей (насколько p близки к реальности).
• Метрики на потоковом сценарии: accuracy по окнам, сглаженная accuracy по голосованию, доля «неуверенных» предсказаний.
• Дрейф признаков: например, контроль распределения входов.

В терминальном приложении полезно логировать:

• время окна;
• вектор признаков (или хэш/сжатое представление);
• класс и вероятность;
• версию модели.

Практические рекомендации по устойчивости

• Согласованность препроцессинга: нормализация и порядок признаков должны совпадать с обучением.
• Фиксированная форма входа: строгое соответствие in_shape из TFLite.
• Стабилизация решения: сглаживание по нескольким окнам.
• Версионирование: модель + схема признаков + пороги/лейблы.
• Режим «не уверены»: вводите порог вероятности, чтобы уменьшить число ложных срабатываний.

Заключение

Применение машинного обучения в Termux с TensorFlow Lite позволяет организовать инференс классификации трафика на лету в терминальном окружении: вы собираете сетевые признаки в оконном режиме, подаёте их в TFLite-модель и получаете предсказания в реальном времени. Наиболее практичная стратегия — «псевдо-онлайн» цикл: Termux собирает данные, а обучение/дообучение модели выполняется на более мощной машине с последующим обновлением TFLite.

Если вам нужна разработка под ваш сценарий (выбор признаков, подготовка датасета, обучение, экспорт в TFLite, интеграция в Termux и продакшн-логирование), обратитесь в РыбинскЛАБ — мы поможем спроектировать и внедрить решение под реальные условия вашего сегмента сети.