Признаки в проде: feature store и train/serve skew

Признак считают дважды: батчем для обучения и онлайн при инференсе. На стенде онлайн-код по той же спецификации расходится с батчем в каждом значении, перевёрнутые решения и пропущенное мошенничество есть, ошибок — ноль. Feast убирает расхождение путей, но его граница point-in-time включительна, онлайн-хранилище не применяет ttl, а материализация раз в сутки делает устаревшей половину значений. PIT по времени события ещё не PIT по времени знания, а накопительный счёт с самим событием при включительной границе отдаёт модели собственную метку — с ней качество в проде падает ниже случайного. И когда feature store не нужен вовсе

Модель приносят обученной: файл с весами, список признаков, порог. Её нужно встроить в сервис, который отвечает на продовый трафик, и здесь впервые выясняется, что признак — не колонка в таблице, а формула, и считают её дважды. При обучении — батчем по истории, при инференсе — на лету по свежему событию. Если две реализации расходятся, модель получает в проде не те числа, на которых училась. Ошибок при этом нет: сервис отвечает, задержка в норме, дашборды зелёные — просто предсказания хуже.

Первая статья серии «Классический ML в проде». Рамка у всей серии одна: инфраструктура вокруг модели глазами backend-инженера, которому модель принесли и попросили обслуживать. Алгоритмы, гиперпараметры и метрики качества как таковые — не предмет; качество появляется только там, где по нему видна поломка инфраструктуры. Здесь — признаки: расхождение двух путей в числах, сборка обучающей выборки без подглядывания в будущее, онлайн- и офлайн-хранилище feature store и цена его свежести.

Стенд: digital-cookbook/ai/ml-features, датасет серии — digital-cookbook/ai/ml-dataset. Нужны Docker и Python; PostgreSQL и Python с Feast работают в контейнерах одной сети. Версии: Feast 0.66.0 с офлайн- и онлайн-хранилищем на PostgreSQL 18.6, scikit-learn 1.9.1, pandas 2.3.3.

Инженерная схема в стиле «Полдень. XXI век»: под общим чертежом формулы большой архивный барабан с лентой истории и маленький арифмометр у окошка выводят стрелки на один циферблат; стрелки расходятся на одно деление, а лампа над окошком горит спокойным бирюзовым

В статье

Признак существует дважды

Сквозной пример серии — платёжный скоринг. Сервис авторизации платежа спрашивает модель: похоже ли это на мошенничество. Датасет синтетический и детерминированный: 2000 пользователей, 120 дней, обычные платежи с недельной сезонностью и захваты аккаунта — серии крупных платежей за пару часов, чаще с нового устройства и из чужой страны. Разметка приходит с задержкой: chargeback — через 10–60 дней, легитимность подтверждается закрытием окна в 60 дней. Модель — градиентный бустинг из scikit-learn, намеренно простой.

Модель отдаёт не решение, а оценку от 0 до 1 — насколько платёж похож на мошенничество. Решение — флаг на ручную проверку — ставит порог: оценка выше порога означает флаг. В серии порог выбран так, чтобы флагов было 1 % трафика: столько платежей успевает проверить команда. Метрики качества понадобятся три. Полнота (recall) — доля мошенничества, получившая флаг. Точность (precision) — доля мошенничества среди флагов. AUC — насколько хорошо оценка упорядочивает платежи, без привязки к порогу: 0,5 — как случайная, 1 — каждое мошенничество выше каждого легитимного платежа.

Признаки — состояние пользователя до платежа:

признак смысл
tx_count_24h число платежей за 24 часа до этого
amount_avg_30d средняя сумма за 30 дней до этого
minutes_since_prev минут с прошлого платежа
amount_ratio сумма платежа к средней за 30 дней
amount, device_new, foreign поля самого запроса

Обучение читает историю. Естественный путь — SQL по таблице платежей, оконные функции по пользователю:

-- stand/db.py
SELECT tx_id,
       count(*) OVER w24 AS tx_count_24h,
       avg(amount::float8) OVER w30 AS amount_avg_30d,
       extract(epoch FROM ts - lag(ts) OVER (PARTITION BY user_id ORDER BY ts)) / 60 AS minutes_since_prev
FROM tx
WINDOW w24 AS (PARTITION BY user_id ORDER BY ts RANGE BETWEEN interval '24 hours' PRECEDING AND CURRENT ROW EXCLUDE CURRENT ROW),
       w30 AS (PARTITION BY user_id ORDER BY ts RANGE BETWEEN interval '30 days' PRECEDING AND CURRENT ROW EXCLUDE CURRENT ROW)

Инференс так не может: платёж пришёл сейчас, ответ нужен за десятки миллисекунд, а оконный запрос по истории — это не то, что делают на каждый запрос. Сервис скоринга держит состояние пользователя в памяти или в key-value и досчитывает признаки по потоку. Этот код пишут отдельно, часто другая команда и на другом языке, по той же спецификации — «число платежей за 24 часа», «средняя сумма за 30 дней».

В стенде онлайн-путь написан честно по спецификации, но в трёх местах прочтение разошлось с батчем. Каждое правдоподобно само по себе:

# stand/online_team.py
    def request(self, user, ts, amount):
        prev = self.last.get(user)               # минуты с прошлого платежа команда считала верно
        if "current" not in self.fixes:
            self.observe(user, ts, amount)       # сначала записали событие, потом посчитали
        q = self.events[user]
        if "current" in self.fixes:
            in24 = [a for t, a in q if ts - DAY <= t < ts]
        else:
            in24 = [a for t, a in q if ts - DAY < t <= ts]
        lo30 = (ts - 30 * DAY) if "calendar" in self.fixes else (midnight(ts) - 30 * DAY)
  • свой платёж в окне — событие сначала записали в состояние, потом посчитали агрегаты; окно включает сам платёж;
  • календарные 30 дней — «за 30 дней» понято как 30 дней по дате, от полуночи, а не скользящие 30 × 24 часа;
  • пропуск как ноль — нет истории за 30 дней: среднее — ноль, отношение — единица; в обучении там пропуск, и бустинг ведёт его своей веткой.

Train/serve skew в числах

Модель обучена на батч-признаках дней 0–74, порог — 1 % флагов на валидации (дни 75–89). Дни 90–99 — прод: каждый платёж проходит через онлайн-путь, и стенд сравнивает признаки и решения с тем, что дал бы батч для того же платежа. Расхождения выключаются по одному, чтобы видеть вклад каждого. Контроль первым: батч совпал с эталоном генератора во всех платежах, а сравнение ловит подложенный сдвиг на единицу — то есть сверка не «зелёная всегда».

$ python3 scripts/run-checks.py controls
{"variant": "controls", "outcome": "match", "detail": "батч SQL против эталона: расхождений 0; сравнение ловит сдвиг на единицу: да; PostgreSQL 18"}
$ python3 scripts/run-checks.py skew
{"variant": "skew", "outcome": "match", "detail": "запросов 26052, ошибок 0; как написан — расходится tx_count_24h 100.00 %, amount_avg_30d 100.00 %; перевёрнуто решений 58, поймано мошенничества 121 из 159 (батч 126); без своего платежа в окне — расходится tx_count_24h 0.00 %, amount_avg_30d 50.05 %; перевёрнуто решений 14, поймано мошенничества 127 из 159 (батч 126); плюс скользящие 30 дней — расходится tx_count_24h 0.00 %, amount_avg_30d 0.02 %; перевёрнуто решений 1, поймано мошенничества 126 из 159 (батч 126); плюс пропуск как пропуск — расходится tx_count_24h 0.00 %, amount_avg_30d 0.00 %; перевёрнуто решений 0, поймано мошенничества 126 из 159 (батч 126)"}
онлайн-путь расходится tx_count_24h расходится amount_avg_30d перевёрнуто решений поймано мошенничества ошибок
как написан 100,00 % 100,00 % 58 121 из 159 0
без своего платежа в окне 0,00 % 50,05 % 14 127 из 159 0
+ скользящие 30 дней 0,00 % 0,02 % 1 126 из 159 0
+ пропуск как пропуск 0,00 % 0,00 % 0 126 из 159 0
батч (обучение) — — — 126 из 159 —

Онлайн-путь как написан: из 26 052 запросов перевёрнуто 58 решений, флагов 203 против 209 у батча, поймано мошенничества 121 из 159 против 126.

Первое, что видно: ошибок нет ни в одном варианте. Сервис отвечает на каждый запрос, и по метрикам сервиса — коды ответов, задержка, число вызовов — расхождение не найти. Второе: расходится каждое значение tx_count_24h, но решений переворачивается немного. Цена расхождения зависит от модели и от того, где лежит порог: сдвиг счётчика на единицу почти не трогает уверенные решения и бьёт по пограничным, а пограничные — это как раз часть мошенничества. Третье: самое безобидное по доле расхождение — пропуск как ноль — касается долей процента запросов и всё равно переворачивает решение. Поломка, которая затрагивает редкие случаи, по средним не видна совсем.

Увидеть skew можно только сравнением значений. Метод — логировать признаки, с которыми модель реально приняла решение, и пересчитывать их батчем для тех же событий: расхождение «отданное против пересчитанного» и есть метрика. Это отдельный конвейер, но без него о расхождении узнают по качеству, а качество — с задержкой разметки, о чём четвёртая статья серииготовится, с 3 декабря.

Point-in-time: как подмешать будущее в прошлое

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

Стенд проверяет это на признаке, где утечка особенно правдоподобна, — счёт подтверждённого мошенничества пользователя. Утечек здесь может быть две, и их важно разделить: собственная метка — признак платежа знает, что сам этот платёж мошеннический, — и задержанное знание — признак знает о прошлых мошеннических платежах раньше, чем о них узнала бы система. Четыре способа собрать выборку:

  • снимок — значение из профиля на день 90, одно на все строки; к дню 90 известна и часть меток самих обучающих платежей, так что здесь возможны обе утечки;
  • PIT по времени платежа, с самим платежом — накопительный счёт мошеннических платежей пользователя, строка помечена временем платежа и включает его самого; join в Feast включительный, поэтому мошеннический платёж видит собственную метку — обе утечки сразу;
  • PIT по времени платежа, строго по предыдущим — состояние до каждого платежа: сколько мошеннических платежей пользователя было раньше него, по времени событий; собственной метки нет, задержанное знание осталось;
  • PIT по времени знания — строка признака помечена временем, когда пришёл chargeback: утечек нет.

Обучение — дни 0–74, валидация — 75–89 той же сборкой, прод — 90–99, где признак честный: в проде известно только то, о чём chargeback уже пришёл.

сборка выборки AUC, валидация AUC, прод
снимок профиля на день 90 0,941 0,929
PIT по времени платежа, с самим платежом 0,980 0,329
PIT по времени платежа, строго по предыдущим 0,880 0,893
PIT по времени chargeback 0,927 0,907
$ python3 scripts/run-checks.py point_in_time
{"variant": "point_in_time", "outcome": "match", "detail": "AUC валидация → прод: снимок на день 90 0.941 → 0.929, PIT по времени платежа с самим платежом 0.980 → 0.329, строго по предыдущим 0.880 → 0.893, PIT по времени chargeback 0.927 → 0.907; счёт с самим платежом у мошеннических строк обучения на единицу больше: да; «строго по предыдущим» против независимого счёта на всех строках — расхождений 0; PIT Feast против эталона: расхождений 0"}

Обе строки PIT по времени платежа выглядят корректно: Feast выполнил point-in-time join как положено, ни одна строка не взята из будущего по отметке времени. Стенд проверяет оба признака отдельно: у каждой мошеннической строки обучения счёт «с самим платежом» на единицу больше, чем «строго по предыдущим», а «строго по предыдущим» на всех строках — мошеннических и обычных — совпадает с независимым счётом мошеннических платежей пользователя раньше текущего.

Последняя сверка появилась не сразу. Первая версия этого признака считала накопительный счёт оконной функцией по уже отобранным мошенническим строкам, и обычный платёж после мошенничества получал счёт «до последнего мошенничества», а не включая его. Контроль на одних мошеннических строках этого не видел — там расчёт верен. Признак, посчитанный только на позитивных строках, проверяют и на негативных.

Катастрофу даёт собственная метка. Счёт, включающий сам платёж, больше нуля у каждого мошеннического платежа — даже у первого в серии захвата аккаунта, — и модель учится на почти готовом ответе. В проде признак честный, у текущего платежа его собственного chargeback нет, и модель, привыкшая опираться на этот признак, ранжирует хуже случайного. Это та же включительная граница, о которой речь в следующем разделе, только здесь она стоит метки, а не одного признака: строка признака, помеченная временем самого события и включающая его, при включительном join всегда видит само событие.

Задержанное знание без собственной метки в этом опыте валидацию не завысило. Внутри серии захвата второй и следующие платежи видят «уже было мошенничество», хотя chargeback по серии придёт через недели, — но модель на таком признаке оказалась хуже честной и на валидации, и в проде. Гипотеза стенда — задержанное знание завышает валидацию — здесь не подтвердилась. Опасность у этой сборки другая: обучение и инференс видят признак с разной семантикой — по времени события и по времени знания, — и качество в проде ниже, чем у модели, обученной честно. Это снова расхождение без единой ошибки, только тихое, а не катастрофическое.

Снимок на день 90 просел между валидацией и продом слабее, чем ожидалось в гипотезе. Это не оправдание снимка, а свойство этого признака и этих данных: что утекает в снимок, зависит от того, что успело стать известным к дате сборки. PIT по времени знания даёт близкие числа на валидации и в проде — так и должна выглядеть честная оценка.

Правило из опыта: point-in-time корректность — про время, когда значение стало известно системе, а не время события, которое оно описывает, и признак строки обучения не должен включать метку самой этой строки. Для разметки, поздних событий, исправленных записей это разные времена. Feast точно выполняет join по тем отметкам, которые ему дали; выбрать отметку — работа того, кто описывает источник. Собственная сверка стенда: PIT Feast по времени знания совпал с эталоном генератора на всех строках.

Онлайн и офлайн: два хранилища одной сущности

Feature store решает проблему двух путей организационно: признак описывается один раз, а читается двумя способами. Офлайн-хранилище — вся история с отметками времени, из неё собирают обучающие выборки с point-in-time join. Онлайн-хранилище — key-value с последним значением на сущность, из него читает инференс. Feast — открытая реализация этой схемы под Apache 2.0; управляемые коммерческие feature store (Tecton и облачные платформы) устроены так же, но в этой статье не проверялись.

В стенде Feast описывает состояние пользователя после каждого платежа — строка на платёж с отметкой его времени — и признаки, которые считаются в момент запроса из этого состояния и самого платежа:

# feast/repo.py
user_state = FeatureView(
    name="user_state",
    entities=[user],
    ttl=timedelta(days=7),
    schema=[Field(name="tx_count_24h", dtype=Int64), Field(name="amount_avg_30d", dtype=Float64),
            Field(name="last_tx_ts", dtype=Int64)],
    source=PostgreSQLSource(name="user_state_src", query="SELECT * FROM user_state", timestamp_field="event_timestamp"),
    online=True,
)
# feast/repo.py
@on_demand_feature_view(sources=[user_state, payment],
                        schema=[Field(name="amount_ratio", dtype=Float64), Field(name="minutes_since_prev", dtype=Float64)])
def payment_features(df: pd.DataFrame) -> pd.DataFrame:
    # одна функция на оба пути: Feast вызывает её и при сборке выборки, и при инференсе
    out = pd.DataFrame()
    out["amount_ratio"] = df["amount"] / df["amount_avg_30d"]
    out["minutes_since_prev"] = (df["request_ts"] - df["last_tx_ts"]) / 60.0
    return out

Онлайн-путь в опыте — поток платежей дней 90–91 по времени: запрос читает признаки из онлайн-хранилища, после ответа состояние платежа записывается туда же (write_to_online_store, как это делал бы потоковый конвейер). Офлайн-путь — get_historical_features по тем же платежам. Модель — обученная на офлайн-выборке Feast.

$ python3 scripts/run-checks.py feature_store
{"variant": "feature_store", "outcome": "match", "detail": "граница PIT включительна: да; отметка = время платежа — расходится с онлайном tx_count_24h 72.98 %, остальные 100.00 %, перевёрнуто 63 из 4918; отметка на секунду раньше — расхождений вне ttl 0, с паузой больше ttl 31 случаев, расходятся все: да; значение Feast отличается от эталона «до платежа» в 53.71 % запросов; онлайн: известный пользователь найден — да, неизвестный пуст — да"}

Три наблюдения, и все три — про то, что feature store не отменяет внимания к семантике.

Граница point-in-time включительна. Офлайн-хранилище PostgreSQL в Feast берёт строку признака, если её отметка <= отметке сущности, — это видно и в шаблоне его SQL, и в опыте: строка с той же отметкой попадает в выборку. Для представления «состояние после платежа» это значит, что при обучении платёж видит сам себя — тот же дефект, что у онлайн-кода «другой команды», только теперь его вносит feature store. Онлайн в момент запроса этой строки ещё нет. Отметка сущности на секунду раньше времени платежа убирает расхождение целиком — но только потому, что в датасете отметки целые секунды, а у одного пользователя два платежа в одну секунду не встречаются: генератор строго упорядочивает их. На реальных событиях внутри одной секунды, с часами разных источников и поздними записями такой сдвиг не универсален. Надёжнее строить строки состояния «до события» или вести строгий порядок явно — номером события в потоке пользователя, — а отметку времени использовать только для окна.

Онлайн-хранилище не применяет ttl. У представления ttl 7 дней: офлайн для пользователя, который не платил дольше недели, вернёт пусто. Онлайн-хранилище PostgreSQL отдаёт последнее значение, сколько бы ему ни было. Вне таких пауз расхождений ноль; в паузах расходятся все значения. Либо ttl должен быть больше любой разумной паузы, либо возраст значения проверяют на чтении сами.

Согласованно — не значит правильно. Значение Feast отличается от эталона «до платежа» у заметной доли запросов: окно tx_count_24h посчитано в момент прошлого платежа и с течением времени не сдвигается. «Платежей за 24 часа» стало «платежей за 24 часа до прошлого платежа». Модель обучена на той же семантике, поэтому расхождения путей нет, — но смысл признака изменился, и это надо знать, когда признак читают люди или другие модели.

Материализация и её отставание

В онлайн-хранилище значения попадают двумя путями: потоковой записью каждого события (push) или материализацией — периодическим заданием, которое копирует последние значения из офлайна. Между запусками онлайн стоит на месте. Стенд проигрывает те же два дня с материализацией раз в 15 минут, раз в час и раз в сутки и сравнивает с записью каждого состояния.

материализация устаревших значений перевёрнуто решений
раз в 15 минут 1,75 % 2
раз в час 5,77 % 8
раз в сутки 50,08 % 27

Запросов — 4 918, сравнение с записью каждого состояния.

$ python3 scripts/run-checks.py materialization
{"variant": "materialization", "outcome": "match", "detail": "запросов 4918; устаревших значений против записи каждого состояния: раз в 15 мин — 1.75 %, перевёрнуто 2, раз в 1 ч — 5.77 %, перевёрнуто 8, раз в 24 ч — 50.08 %, перевёрнуто 27"}

Для признаков скорости — «сколько платежей за последние часы» — суточная материализация бессмысленна: половина значений устарела, и именно у тех пользователей, которые сейчас активны, то есть интересны модели больше всего. Захват аккаунта длится пару часов; признак, обновляемый раз в сутки, его не увидит. Отсюда эксплуатационное правило: свежесть признака — метрика наравне с задержкой ответа. Её мерят как возраст последней материализованной строки или как отставание потоковой записи, ставят на неё алерт и выбирают способ доставки по признаку: медленные профили — материализацией, скоростные — потоком.

Когда feature store не нужен

Последняя ось — проверка обратного: что, если пути не два, а один. В стенде это функция PostgreSQL над сырыми платежами. Её вызывает и обучение — LATERAL по историческим платежам, — и инференс — на каждый запрос по таблице, куда платежи пишутся по мере прихода:

-- stand/db.py
CREATE FUNCTION features_before(p_user text, p_ts timestamptz, OUT tx_count_24h bigint, OUT amount_avg_30d float8,
                                OUT minutes_since_prev float8)
LANGUAGE sql STABLE AS $$
  SELECT (SELECT count(*) FROM tx_live WHERE user_id = p_user AND ts >= p_ts - interval '24 hours' AND ts < p_ts),
         (SELECT avg(amount::float8) FROM tx_live WHERE user_id = p_user AND ts >= p_ts - interval '30 days' AND ts < p_ts),
         (SELECT extract(epoch FROM p_ts - max(ts)) / 60 FROM tx_live WHERE user_id = p_user AND ts < p_ts)
$$;
$ python3 scripts/run-checks.py one_path
{"variant": "one_path", "outcome": "match", "detail": "одна SQL-функция на оба пути, запросов 4918: расхождений с батчем 0, обучения с инференсом 0"}

Расхождений нет ни с батчем, ни между обучением и инференсом: код один, источник один, окно «до платежа» записано один раз. В стенде вызов функции был даже быстрее чтения через Python SDK Feast — это накладные расходы SDK и признаков по запросу на pandas, а не свойство хранилищ, и бенчмарком это не является.

Такой путь работает, пока выполняются три условия: модель одна или несколько у одной команды, признаки считаются из одной базы, и расчёт по сырым событиям укладывается в бюджет задержки. Feature store окупается, когда одно из них ломается: признаки переиспользуют разные команды и модели; агрегаты тяжёлые и их нельзя считать на каждый запрос; источников несколько, и обучающие выборки на миллионы строк собирают по ним с point-in-time join. До этого порога дисциплина «одна функция — два вызова» даёт главное, что обещает feature store, — один источник правды для признака, — без ещё одной системы в эксплуатации.

Что из этого следует

  1. Два пути расчёта признака расходятся молча: в стенде онлайн-код по той же спецификации разошёлся с батчем в каждом значении счётчика, и ни одной ошибки. Ловится только сравнением отданных признаков с пересчитанными.
  2. Расхождения неравноценны: сдвиг на единицу во всех значениях может стоить меньше, чем редкий пропуск, заменённый нулём. Мерить надо решения и пойманное, а не только долю расхождений.
  3. Point-in-time — по времени знания, и без метки самой строки. Счёт с самим событием при включительной границе отдаёт модели собственную метку — в проде качество ниже случайного; join по времени события строго по прошлому даёт другую семантику признака в обучении и в проде и уступает честной сборке.
  4. Feature store убирает расхождение путей, но вносит свою семантику: включительную границу PIT, ttl только в офлайне, окно, заякоренное на прошлом событии. Отметку сущности и ttl выбирают осознанно.
  5. Свежесть признака — эксплуатационная метрика. Материализация раз в сутки для признаков скорости бесполезна; для них — потоковая запись.
  6. Пока модель одна и признаки из одной базы, одна функция на оба пути даёт ноль расхождений без feature store.

Следующая статья серии — реестр моделей: версионирование того, что нельзя прочитать глазами: признаки — одна из частей версии модели, и их рассинхрон с весами ломает воспроизводимость так же тихо. Откуда берутся сами данные для обучения — в серии «Data engineering»: dimensional modeling и качество данных и контракты.

Документация и первоисточники

Обсуждение в Telegram

Присоединиться →