film-camera service

.dockerignore

@@ -0,0 +1,25 @@
+# build-context = корень репо, образу нужны только training/final_model и deployment
+
+.git
+.env
+.venv
+.ruff_cache
+**/__pycache__/
+*.pyc
+.DS_Store
+
+# данные и другие этапы — в образ не нужны
+data/
+data-pipeline/
+eda/
+problem-validation/
+solution-design/
+
+# из training нужен только final_model (бандл + meta)
+training/*
+!training/final_model
+
+# журнал этапа и тяжёлые форматы
+deployment/log.md
+**/*.parquet
+**/*.ipynb

Dockerfile

@@ -0,0 +1,44 @@
+# syntax=docker/dockerfile:1
+# Прод-образ сервиса film_camera_body_type: FastAPI + 3 энкодера + logreg-бандл
+# torch ставим CPU-колесом, веса энкодеров запекаем на build (HF_TOKEN как BuildKit-секрет),
+# рантайм офлайн. Build context = корень репо (см .dockerignore)
+
+FROM python:3.13-slim
+
+ENV PYTHONUNBUFFERED=1 \
+    PYTHONDONTWRITEBYTECODE=1 \
+    PIP_NO_CACHE_DIR=1 \
+    HF_HOME=/home/user/.cache/huggingface
+
+# непривилегированный юзер (нужен для HF Spaces)
+RUN useradd --create-home --uid 1000 user
+WORKDIR /home/user/app
+
+# зависимости: сперва torch+torchvision CPU-колесом (без CUDA), потом остальное
+COPY deployment/requirements.txt deployment/requirements.txt
+RUN pip install torch torchvision --index-url https://download.pytorch.org/whl/cpu \
+    && pip install -r deployment/requirements.txt
+
+# код сервиса и бандл модели - только нужное в рантайме
+COPY --chown=user:user deployment/app deployment/app
+COPY --chown=user:user deployment/static deployment/static
+COPY --chown=user:user deployment/templates deployment/templates
+COPY --chown=user:user training/final_model training/final_model
+
+USER user
+WORKDIR /home/user/app/deployment
+
+# запекаем веса 3 энкодеров в образ (DINOv3 gated -> токен через секрет), заодно
+# проверяем загрузку бандла. Секрет монтируется только тут и в слои образа не попадает
+RUN --mount=type=secret,id=hf_token,uid=1000 \
+    HF_TOKEN="$(cat /run/secrets/hf_token)" \
+    python -c "from app.model import Predictor; from app.encoders import Encoders; Predictor(encoders=Encoders())"
+
+# веса уже в образе -> рантайм не ходит в сеть
+ENV HF_HUB_OFFLINE=1 \
+    TRANSFORMERS_OFFLINE=1
+
+EXPOSE 7860
+# exec-форма: SIGTERM от docker stop идёт прямо в uvicorn -> чистое завершение
+# порт фиксированный 7860 (в HF Spaces задаётся через app_port)
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,11 +1,21 @@
 ---
-title: Avito Camera Body Type
-emoji: 📊
-colorFrom: pink
-colorTo: purple
+title: Тип корпуса плёночной камеры
+emoji: 📷
+colorFrom: blue
+colorTo: indigo
 sdk: docker
+app_port: 7860
 pinned: false
-license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Определение типа корпуса плёночной камеры
+
+По объявлению (заголовок + описание + фото камеры или ссылка на Авито) сервис определяет тип
+корпуса плёночной камеры: зеркальная (SLR), двухобъективная (TLR), дальномерная, компактная,
+моментальная — или «не определено», если данных мало или на фото не камера
+
+Модель: логистическая регрессия на признаках tfidf + Qwen3 + DINOv3 + PE-Core (вектор 52432)
+
+- форма с загрузкой фото — на главной странице
+- API и интерактивная документация — `/docs`
+- метрики Prometheus — `/metrics`

deployment/app/avito.py

@@ -0,0 +1,57 @@
+"""Загрузка объявления Авито по ссылке: заголовок + главное фото
+
+Авито отдаёт реальную страницу (SSR), но данные не в JSON-LD/og-тегах, а в html:
+заголовок - <h1>, фото - <img> на CDN img.avito.st. Мобильная версия (m.avito.ru)
+чище для парсинга. Описание Авито в статике надёжно не отдаёт (ленивая подгрузка) -
+для url-входа берём title+фото, этого хватает (в заголовке есть модель камеры).
+Любая неудача (блок, нет фото, таймаут) -> None, и сервис отвечает input_unavailable
+"""
+
+import re
+from io import BytesIO
+
+import httpx
+from PIL import Image
+
+_USER_AGENT = (
+    'Mozilla/5.0 (iPhone; CPU iPhone OS 17_0 like Mac OS X) AppleWebKit/605.1.15 '
+    '(KHTML, like Gecko) Version/17.0 Mobile/15E148 Safari/604.1'
+)
+_HEADERS = {'User-Agent': _USER_AGENT, 'Accept-Language': 'ru-RU,ru;q=0.9', 'Referer': 'https://m.avito.ru/'}
+_TIMEOUT = 12.0
+
+
+def fetch_listing(url):
+    """url объявления Авито -> (title, description, PIL.Image) либо None при любой неудаче"""
+    try:
+        mobile_url = re.sub(r'://(www\.)?avito\.ru', '://m.avito.ru', url, count=1)
+        with httpx.Client(headers=_HEADERS, timeout=_TIMEOUT, follow_redirects=True) as client:
+            html = client.get(mobile_url).text
+            title, image_url = _parse(html)
+            content = client.get(image_url).content
+        return title, '', Image.open(BytesIO(content)).convert('RGB')
+    except Exception:
+        return None
+
+
+def _parse(html):
+    """(title, image_url) из html мобильной страницы Авито; без фото - ValueError"""
+    image_url = _main_photo(html)
+    if not image_url:
+        raise ValueError('не нашли фото объявления')
+    return _title(html), image_url
+
+
+def _title(html):
+    """Заголовок из <h1>, фолбэк - alt главного фото"""
+    h1 = re.search(r'<h1[^>]*>(.*?)</h1>', html, re.S)
+    if h1:
+        return re.sub(r'<[^>]+>', '', h1.group(1)).strip()
+    alt = re.search(r'<img[^>]+alt="([^"]+)"', html)
+    return alt.group(1).strip() if alt else ''
+
+
+def _main_photo(html):
+    """URL главного фото: первый <img> с CDN Авито img.avito.st"""
+    match = re.search(r'<img[^>]+src="(https?://\d+\.img\.avito\.st/image/[^"]+)"', html)
+    return match.group(1) if match else None

deployment/app/config.py

@@ -0,0 +1,53 @@
+"""Константы и пути прод-сервиса film_camera_body_type"""
+
+import os
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+DEPLOY_DIR = Path(__file__).resolve().parents[1]
+MODEL_DIR = REPO_ROOT / 'training' / 'final_model'
+_BUNDLE_NAME = 'tfidf_qwen3_dinov3_pe_logreg_reg1_0_unweighted_final_pipeline.joblib'
+BUNDLE_PATH = Path(os.environ.get('BUNDLE_PATH', str(MODEL_DIR / _BUNDLE_NAME)))
+
+ATTRIBUTE = 'film_camera_body_type'
+
+# 5 основных классов идут в автозаполнение, other_unknown это отказ
+MAIN_SET = ('SLR', 'TLR', 'rangefinder_viewfinder', 'compact_point_and_shoot', 'instant')
+ABSTAIN = 'other_unknown'
+ALL_LABELS = MAIN_SET + (ABSTAIN,)
+
+# размерности emb-блоков, порядок hstack: tfidf -> qwen3 -> dinov3 -> pe
+QWEN_DIM = 1024
+DINO_DIM = 384
+PE_DIM = 1024
+TOTAL_DIM = 52432
+
+# решения и причины ответа
+DECISION_AUTO = 'auto_fill'
+DECISION_ABSTAIN = 'abstain'
+REASON_ARGMAX = 'model_argmax'
+REASON_ABSTAIN = 'model_abstained'
+REASON_NO_PHOTO = 'photo_required'
+REASON_URL_FAIL = 'input_unavailable'
+
+# энкодеры (паритет с training/notebooks/extract_*.ipynb)
+QWEN_MODEL = 'Qwen/Qwen3-Embedding-0.6B'
+DINO_MODEL = 'facebook/dinov3-vits16-pretrain-lvd1689m'
+PE_MODEL = 'hf-hub:timm/PE-Core-L-14-336'
+MAX_SEQ_LEN = 512
+
+# человекочитаемые названия классов и причин для веб-страницы
+LABELS_RU = {
+    'SLR': 'Зеркальная (SLR)',
+    'TLR': 'Двухобъективная (TLR)',
+    'rangefinder_viewfinder': 'Дальномерная',
+    'compact_point_and_shoot': 'Компактная «мыльница»',
+    'instant': 'Моментальная (Polaroid/Instax)',
+    'other_unknown': 'Не определено',
+}
+REASONS_RU = {
+    'model_argmax': 'определено по фото и тексту',
+    'model_abstained': 'модель не уверена',
+    'photo_required': 'нужно фото',
+    'input_unavailable': 'не удалось открыть объявление',
+}

deployment/app/encoders.py

@@ -0,0 +1,47 @@
+"""Энкодеры Qwen3/DINOv3/PE-Core - паритет 1-в-1 с training/notebooks/extract_*.ipynb
+
+Текст: (title+' '+desc) -> Qwen3 (L2). Фото: DINOv3 pooler_output (raw) и PE-Core
+encode_image(normalize=False) (raw). L2 на эмбеддинги накладывает model.build_vector.
+Три модели грузятся один раз при создании Encoders
+"""
+
+import open_clip
+import torch
+from sentence_transformers import SentenceTransformer
+from transformers import AutoImageProcessor, AutoModel
+
+from app.config import DINO_MODEL, MAX_SEQ_LEN, PE_MODEL, QWEN_MODEL
+
+
+class Encoders:
+    """Три замороженных энкодера, загруженные один раз"""
+
+    def __init__(self):
+        self.text_model = SentenceTransformer(QWEN_MODEL)
+        self.text_model.max_seq_length = MAX_SEQ_LEN
+        self.dino_processor = AutoImageProcessor.from_pretrained(DINO_MODEL)
+        self.dino_model = AutoModel.from_pretrained(DINO_MODEL).eval()
+        self.pe_model, _, self.pe_preprocess = open_clip.create_model_and_transforms(PE_MODEL)
+        self.pe_model = self.pe_model.eval()
+
+    def encode_text(self, text):
+        """Qwen3 текстовый эмбеддинг, L2-нормированный (1024)"""
+        return self.text_model.encode([text], normalize_embeddings=True)[0]
+
+    @torch.no_grad()
+    def encode_dino(self, image):
+        """DINOv3 pooler_output, сырой (384)"""
+        pixels = self.dino_processor(images=image, return_tensors='pt')
+        out = self.dino_model(**pixels)
+        return out.pooler_output[0].numpy()
+
+    @torch.no_grad()
+    def encode_pe(self, image):
+        """PE-Core image embedding, сырой (1024)"""
+        pixels = self.pe_preprocess(image).unsqueeze(0)
+        feat = self.pe_model.encode_image(pixels, normalize=False)
+        return feat[0].numpy()
+
+    def embed(self, text, image):
+        """Текст + фото -> (qwen, dino, pe) для model.build_vector"""
+        return self.encode_text(text), self.encode_dino(image), self.encode_pe(image)

deployment/app/images.py

@@ -0,0 +1,18 @@
+"""Хелперы для фото: открыть из файла и сериализовать в data-URI для страницы"""
+
+from base64 import b64encode
+from io import BytesIO
+
+from PIL import Image
+
+
+def open_image(file):
+    """Открыть загруженное фото как RGB"""
+    return Image.open(file).convert('RGB')
+
+
+def image_to_img_src(image):
+    """PIL Image -> data:image/png;base64,... для <img> на странице"""
+    buffer = BytesIO()
+    image.save(buffer, format='png')
+    return f'data:image/png;base64,{b64encode(buffer.getvalue()).decode()}'

deployment/app/main.py

@@ -0,0 +1,129 @@
+"""FastAPI прод-сервиса: страница (GET/POST /), JSON POST /predict, GET /health, /metrics
+
+Страница - серверный рендер (Jinja2 + Bootstrap, как aaa-frontend-app). Модель и
+энкодеры грузятся один раз при старте (lifespan). Метрики Prometheus на /metrics
+"""
+
+from contextlib import asynccontextmanager
+
+from dotenv import load_dotenv
+from fastapi import FastAPI, File, Form, Request, UploadFile
+from fastapi.responses import HTMLResponse
+from fastapi.staticfiles import StaticFiles
+from fastapi.templating import Jinja2Templates
+from prometheus_fastapi_instrumentator import Instrumentator
+
+from app.avito import fetch_listing
+from app.config import (
+    DEPLOY_DIR,
+    LABELS_RU,
+    REASON_NO_PHOTO,
+    REASON_URL_FAIL,
+    REASONS_RU,
+    REPO_ROOT,
+)
+from app.encoders import Encoders
+from app.images import image_to_img_src, open_image
+from app.metrics import model_loaded, predict_latency, record
+from app.model import Predictor, abstain
+from app.schemas import PredictResponse
+
+# подхватываем HF_TOKEN (и пр.) из .env, чтобы не держать токен в переменных шелла
+# в Docker .env нет - load_dotenv просто no-op
+load_dotenv(REPO_ROOT / '.env')
+
+_DESCRIPTION = (
+    'Сервис определяет тип корпуса плёночной камеры по объявлению. На вход - заголовок, описание и '
+    'фото камеры либо ссылка на объявление Авито. На выход - один из типов (зеркальная, '
+    'двухобъективная, дальномерная, компактная, моментальная) или «не определено», если данных мало '
+    'или на фото не камера'
+)
+
+
+@asynccontextmanager
+async def lifespan(app):
+    """Грузим бандл и энкодеры один раз на старте"""
+    app.state.predictor = Predictor(encoders=Encoders())
+    model_loaded.set(1)
+    yield
+
+
+app = FastAPI(title='Определение типа корпуса плёночной камеры', version='1.0.0',
+              description=_DESCRIPTION, lifespan=lifespan)
+Instrumentator().instrument(app).expose(app)
+app.mount('/static', StaticFiles(directory=DEPLOY_DIR / 'static'), name='static')
+templates = Jinja2Templates(directory=DEPLOY_DIR / 'templates')
+
+
+def _run(title, description, url, photos):
+    """Логика входа -> (PredictResponse, фото для превью или None)"""
+    image = None
+    if photos and photos[0].filename:
+        image = open_image(photos[0].file)
+    elif url:
+        listing = fetch_listing(url)
+        if listing is None:
+            return abstain(REASON_URL_FAIL), None
+        title, description, image = listing
+    if image is None:
+        return abstain(REASON_NO_PHOTO), None
+    with predict_latency.labels(stage='inference').time():
+        result = app.state.predictor.predict(title, description, image)
+    return result, image
+
+
+def _predict(title, description, url, photos):
+    """То же, что _run, плюс учёт ответа в метриках"""
+    result, image = _run(title, description, url, photos)
+    record(result)
+    return result, image
+
+
+def _render(request, result, image):
+    """Отрисовать страницу с опциональным результатом"""
+    image_src = image_to_img_src(image) if image is not None else None
+    context = {'result': result, 'image_src': image_src, 'labels_ru': LABELS_RU, 'reasons_ru': REASONS_RU}
+    return templates.TemplateResponse(request, 'index.html', context)
+
+
+@app.get('/health', tags=['Сервис'], summary='Проверить, что сервис работает')
+def health():
+    """Возвращает ok, если сервис запущен и отвечает"""
+    return {'status': 'ok'}
+
+
+@app.get('/', response_class=HTMLResponse, include_in_schema=False)
+def index(request: Request):
+    """Страница с формой"""
+    return _render(request, None, None)
+
+
+@app.post('/', response_class=HTMLResponse, include_in_schema=False)
+def index_predict(
+    request: Request,
+    title: str = Form(''),
+    description: str = Form(''),
+    url: str = Form(''),
+    photos: list[UploadFile] = File(default=[]),
+):
+    """Сабмит формы -> та же страница с карточкой результата"""
+    result, image = _predict(title, description, url, photos)
+    return _render(request, result, image)
+
+
+@app.post('/predict', response_model=PredictResponse, tags=['Предсказание'],
+          summary='Определить тип корпуса камеры',
+          response_description='Тип корпуса, уверенность и вероятности по классам')
+def predict(
+    title: str = Form('', description='Заг��ловок объявления'),
+    description: str = Form('', description='Описание объявления'),
+    url: str = Form('', description='Ссылка на объявление Авито - используется, если не загружено фото'),
+    photos: list[UploadFile] = File(default=[], description='Фото камеры (используется первое)'),
+):
+    """Принимает заголовок, описание и фото камеры либо ссылку на объявление Авито
+
+    Если переданы и фото, и ссылка - берётся загруженное фото. Без фото и без рабочей
+    ссылки сервис не угадывает, а возвращает `other_unknown`
+    """
+    result, _ = _predict(title, description, url, photos)
+    return result

deployment/app/metrics.py

@@ -0,0 +1,19 @@
+"""Prometheus-метрики сервиса (отдаются на /metrics)"""
+
+from prometheus_client import Counter, Gauge, Histogram
+
+# prometheus_client сам добавит суффикс _total -> метрика predict_requests_total
+predict_requests = Counter('predict_requests', 'Ответы /predict по решению и классу', ['decision', 'value'])
+predict_latency = Histogram('predict_latency_seconds', 'Время инференса по стадиям', ['stage'])
+# уверенность модели - прокси дрейфа: падает, когда входы уходят от обучающих
+predict_confidence = Histogram(
+    'predict_confidence', 'Уверенность модели, когда она отработала',
+    buckets=(0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0))
+model_loaded = Gauge('model_loaded', 'Модель и энкодеры загружены (1/0)')
+
+
+def record(response):
+    """Учесть ответ /predict в метриках"""
+    predict_requests.labels(decision=response.decision, value=response.value).inc()
+    if response.probabilities:                       # модель реально отработала, а не отказ по входу
+        predict_confidence.observe(response.confidence)

deployment/app/model.py

@@ -0,0 +1,86 @@
+"""Контракт инференса: бандл -> вектор 52432 -> proba -> canonical argmax -> tau -> decision
+
+Энкодеры (Qwen3/DINOv3/PE-Core) считаются отдельно (encoders.py, шаг 2) и приходят сюда
+готовыми векторами. Здесь только сборка фич и решение - зеркало training/src/features.py
+"""
+
+import joblib
+import numpy as np
+from scipy.sparse import csr_matrix, hstack
+from sklearn.preprocessing import normalize
+
+from app.config import (
+    ABSTAIN,
+    ALL_LABELS,
+    BUNDLE_PATH,
+    DECISION_ABSTAIN,
+    DECISION_AUTO,
+    REASON_ABSTAIN,
+    REASON_ARGMAX,
+)
+from app.schemas import PredictResponse
+
+
+def build_vector(bundle, text, qwen_vec, dino_vec, pe_vec):
+    """Разреженный вектор 52432: tfidf | L2(qwen) | L2(dino) | L2(pe)"""
+    blocks = [bundle['vectorizer'].transform([text])]
+    for vec in (qwen_vec, dino_vec, pe_vec):
+        normed = normalize(np.asarray(vec, dtype='float64').reshape(1, -1))
+        blocks.append(csr_matrix(normed))
+    return hstack(blocks).tocsr()
+
+
+def predict_proba_row(bundle, x):
+    """proba головы -> (pred_label, confidence, probabilities) в каноничном порядке ALL_LABELS"""
+    clf = bundle['classifier']
+    proba = clf.predict_proba(x)[0]
+    by_class = {str(cls): float(proba[i]) for i, cls in enumerate(clf.classes_)}
+    probabilities = {label: by_class[label] for label in ALL_LABELS}
+    values = np.array([probabilities[label] for label in ALL_LABELS])
+    best = int(values.argmax())
+    return ALL_LABELS[best], float(values[best]), probabilities
+
+
+def decide(pred_label, confidence, tau):
+    """Решение и причина: ниже tau или other_unknown -> abstain, иначе auto_fill"""
+    if confidence < tau or pred_label == ABSTAIN:
+        return ABSTAIN, DECISION_ABSTAIN, REASON_ABSTAIN
+    return pred_label, DECISION_AUTO, REASON_ARGMAX
+
+
+def abstain(reason):
+    """Готовый ответ-отказ: нет фото, недоступна ссылка и т.п."""
+    return PredictResponse(value=ABSTAIN, decision=DECISION_ABSTAIN, confidence=0.0, reason=reason)
+
+
+def build_text(title, description):
+    """Текст для tfidf и Qwen3: (title + ' ' + description) без краёв"""
+    return (str(title) + ' ' + str(description)).strip()
+
+
+class Predictor:
+    """Грузит бандл один раз и считает ответ; энкодеры инжектятся (torch сюда не тянем)"""
+
+    def __init__(self, bundle_path=BUNDLE_PATH, encoders=None):
+        self.bundle = joblib.load(bundle_path)
+        self.tau = float(self.bundle['tau'])
+        self.encoders = encoders
+
+    def predict(self, title, description, image):
+        """Заголовок/описание/фото -> PredictResponse (энкодеры считают эмбеддинги)"""
+        text = build_text(title, description)
+        qwen_vec, dino_vec, pe_vec = self.encoders.embed(text, image)
+        return self.predict_from_embeddings(text, qwen_vec, dino_vec, pe_vec)
+
+    def predict_from_embeddings(self, text, qwen_vec, dino_vec, pe_vec):
+        """Текст + три готовых эмбеддинга -> PredictResponse"""
+        x = build_vector(self.bundle, text, qwen_vec, dino_vec, pe_vec)
+        pred_label, confidence, probabilities = predict_proba_row(self.bundle, x)
+        value, decision, reason = decide(pred_label, confidence, self.tau)
+        return PredictResponse(
+            value=value,
+            decision=decision,
+            confidence=confidence,
+            reason=reason,
+            probabilities=probabilities,
+        )

deployment/app/schemas.py

@@ -0,0 +1,30 @@
+"""Pydantic-схема ответа сервиса (как в solution-design + вероятности)"""
+
+from pydantic import BaseModel, Field
+
+from app.config import ATTRIBUTE
+
+_EXAMPLE = {
+    'attribute': 'film_camera_body_type',
+    'value': 'instant',
+    'decision': 'auto_fill',
+    'confidence': 0.993,
+    'reason': 'model_argmax',
+    'probabilities': {
+        'SLR': 0.0, 'TLR': 0.0, 'rangefinder_viewfinder': 0.0,
+        'compact_point_and_shoot': 0.0, 'instant': 0.993, 'other_unknown': 0.007,
+    },
+}
+
+
+class PredictResponse(BaseModel):
+    """Ответ: тип корпуса плёночной камеры по объявлению"""
+
+    attribute: str = Field(ATTRIBUTE, description='Заполняемый атрибут товара')
+    value: str = Field(description='Один из 5 типов корпуса либо other_unknown (отказ)')
+    decision: str = Field(description='auto_fill (заполнить) или abstain (отказ)')
+    confidence: float = Field(description='Уверенность 0..1 (максимальная вероятность)')
+    reason: str = Field(description='Причина решения (model_argmax, photo_required, input_unavailable и т.п.)')
+    probabilities: dict[str, float] = Field(default_factory=dict, description='Вероятности по всем 6 классам')
+
+    model_config = {'json_schema_extra': {'example': _EXAMPLE}}

deployment/requirements.txt

@@ -0,0 +1,15 @@
+fastapi[all]
+scikit-learn==1.8.0
+numpy
+scipy
+joblib
+pyyaml
+pillow
+httpx
+python-dotenv
+torch
+transformers
+sentence-transformers
+open_clip_torch
+prometheus-client
+prometheus-fastapi-instrumentator

deployment/templates/index.html

@@ -0,0 +1,143 @@
+<!doctype html>
+<html lang="ru">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>Тип корпуса плёночной камеры — Авито</title>
+    <link
+      href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.3/dist/css/bootstrap.min.css"
+      rel="stylesheet"
+    />
+    <style>
+      :root { --avito: #0099f8; }
+      body { background: #f3f4f6; }
+      .btn-avito { background: var(--avito); border-color: var(--avito); color: #fff; font-weight: 600; }
+      .btn-avito:hover, .btn-avito:focus { background: #0a86d6; border-color: #0a86d6; color: #fff; }
+      .card { border: 0; border-radius: 14px; }
+      .progress-bar { background: var(--avito); }
+      .result-photo { max-height: 220px; border-radius: 12px; object-fit: cover; }
+      .prob-row + .prob-row { margin-top: .35rem; }
+    </style>
+  </head>
+  <body>
+    <nav class="navbar bg-white border-bottom py-3">
+      <div class="container">
+        <a class="navbar-brand" href="/"><img src="/static/avito.svg" alt="Avito" height="26" /></a>
+        <span class="text-muted small">Плёночные фотоаппараты</span>
+      </div>
+    </nav>
+
+    <main class="container py-4" style="max-width: 1080px">
+      <div class="mb-4">
+        <h1 class="h3 fw-bold mb-1">Тип корпуса плёночной камеры</h1>
+        <p class="text-muted mb-0">
+          Загрузите фото камеры и заголовок объявления или вставьте ссылку на Авито — сервис определит
+          тип корпуса: зеркальная, дальномерная, компактная, двухобъективная или моментальная
+        </p>
+      </div>
+
+      <div class="row g-4">
+        <!-- форма -->
+        <div class="col-lg-6">
+          <div class="card shadow-sm">
+            <div class="card-body p-4">
+              <h5 class="card-title mb-4">Объявление</h5>
+              <form method="post" action="/" enctype="multipart/form-data">
+                <div class="mb-3">
+                  <label class="form-label fw-semibold">Заголовок</label>
+                  <input type="text" name="title" class="form-control" placeholder="Например: Зенит TTL" />
+                </div>
+                <div class="mb-3">
+                  <label class="form-label fw-semibold">Описание</label>
+                  <textarea name="description" rows="3" class="form-control" placeholder="Состояние, комплект, модель…"></textarea>
+                </div>
+                <div class="mb-3">
+                  <label class="form-label fw-semibold">Фото камеры</label>
+                  <input type="file" name="photos" accept="image/*" class="form-control" />
+                </div>
+                <div class="text-center text-muted small my-2">— или —</div>
+                <div class="mb-4">
+                  <label class="form-label fw-semibold">Ссылка на объявление Авито</label>
+                  <input type="url" name="url" class="form-control" placeholder="https://www.avito.ru/…" />
+                  <div class="form-text">Если загружено фото камеры, ссылка не используется</div>
+                </div>
+                <button type="submit" class="btn btn-avito w-100 py-2">Определить тип</button>
+              </form>
+            </div>
+          </div>
+        </div>
+
+        <!-- результат -->
+        <div class="col-lg-6">
+          {% if result and result.probabilities %}
+          <div class="card shadow-sm">
+            <div class="card-body p-4">
+              <h6 class="text-uppercase text-muted small mb-3">Результат</h6>
+              {% if image_src %}
+              <div class="text-center mb-3">
+                <img src="{{ image_src }}" class="result-photo" alt="фото камеры" />
+              </div>
+              {% endif %}
+              <div class="d-flex align-items-center flex-wrap gap-2 mb-1">
+                <span class="h3 mb-0">{{ labels_ru.get(result.value, result.value) }}</span>
+                {% if result.decision == 'auto_fill' %}
+                <span class="badge text-bg-success">Можно заполнить</span>
+                {% else %}
+                <span class="badge text-bg-secondary">Лучше оставить пустым</span>
+                {% endif %}
+              </div>
+              <div class="text-muted small mb-3">
+                <code>{{ result.value }}</code>
+                · уверенность {{ ('%.1f'|format(result.confidence * 100))|replace('.', ',') }}%
+                · {{ reasons_ru.get(result.reason, result.reason) }}
+              </div>
+              {% for label, p in result.probabilities|dictsort(by='value', reverse=true) %}
+              <div class="prob-row d-flex align-items-center">
+                <div class="small {% if label == result.value %}fw-semibold{% endif %}" style="width: 210px">
+                  {{ labels_ru.get(label, label) }}
+                </div>
+                <div class="progress flex-grow-1" style="height: 12px">
+                  <div class="progress-bar" role="progressbar" style="width: {{ (p * 100)|round(1) }}%"></div>
+                </div>
+                <div class="small text-end ps-2" style="width: 56px">
+                  {{ ('%.1f'|format(p * 100))|replace('.', ',') }}%
+                </div>
+              </div>
+              {% endfor %}
+            </div>
+          </div>
+          {% elif result %}
+          <div class="card shadow-sm">
+            <div class="card-body p-4 text-center">
+              <h6 class="text-uppercase text-muted small mb-3">Результат</h6>
+              {% if result.reason == 'photo_required' %}
+              <div class="h4 mb-2">Нужно фото</div>
+              <p class="text-muted mb-0">Добавьте фото камеры или вставьте ссылку на объявление — без фото сервис не угадывает</p>
+              {% else %}
+              <div class="h4 mb-2">Не удалось открыть объявление</div>
+              <p class="text-muted mb-0">Проверьте ссылку или загрузите фото вручную</p>
+              {% endif %}
+            </div>
+          </div>
+          {% else %}
+          <div class="card shadow-sm">
+            <div class="card-body p-4">
+              <h6 class="text-uppercase text-muted small mb-3">Типы корпусов</h6>
+              <ul class="list-unstyled mb-0 small">
+                <li class="mb-2"><span class="fw-semibold">Зеркальная (SLR)</span> — видоискатель смотрит через объектив, внутри зеркало и призма</li>
+                <li class="mb-2"><span class="fw-semibold">Двухобъективная (TLR)</span> — два объектива друг над другом</li>
+                <li class="mb-2"><span class="fw-semibold">Дальномерная</span> — наводка на резкость по дальномеру, без зеркала</li>
+                <li class="mb-2"><span class="fw-semibold">Компактная «мыльница»</span> — простая автоматическая, «навёл и снял»</li>
+                <li class="mb-2"><span class="fw-semibold">Моментальная</span> — печатает снимок сразу, Polaroid и Instax</li>
+                <li><span class="fw-semibold">Не определено</span> — на фото не камера, лот из нескольких или данных мало</li>
+              </ul>
+            </div>
+          </div>
+          {% endif %}
+        </div>
+      </div>
+    </main>
+
+    <footer class="container py-4 text-center text-muted small">© 2026 Академия Аналитиков Авито</footer>
+  </body>
+</html>

training/final_model/tfidf_qwen3_dinov3_pe_logreg_reg1_0_unweighted_final_meta.yaml

@@ -0,0 +1,53 @@
+name: tfidf+qwen3+dinov3+pe+logreg__reg1.0_unweighted__final
+champion_config: lrgrid__c1.0__none
+trained_on: train+val
+held_out: test+audit (не трогали)
+n_train_refit: 122234
+n_test: 22079
+tau: 0.0
+labels:
+- SLR
+- TLR
+- rangefinder_viewfinder
+- compact_point_and_shoot
+- instant
+- other_unknown
+head:
+  kind: logreg
+  C: 1.0
+  class_weight: null
+feature_order:
+- block: tfidf
+  dim: 50000
+  scaling: none
+- block: text_emb
+  model: Qwen/Qwen3-Embedding-0.6B
+  dim: 1024
+  scaling: l2
+- block: image_emb
+  source: dinov3
+  model: facebook/dinov3-vits16-pretrain-lvd1689m
+  dim: 384
+  scaling: l2
+- block: image_emb
+  source: pe
+  model: timm/PE-Core-L-14-336
+  dim: 1024
+  scaling: l2
+total_dim: 52432
+split_data_sha256: 11d9d547c3e4c888776e244181fc6cff237ded98094ff2e90eecd74353ef8978
+held_out_metrics:
+  test_proxy:
+    CAR: 0.8350921690293944
+    AER: 0.03733096642823579
+    AER_hi: 0.04010987384058068
+    A: 19153
+    C: 18438
+    W: 715
+  test_audit:
+    CAR: 0.7476190476190476
+    AER: 0.024844720496894408
+    AER_hi: 0.06213330741266006
+    A: 161
+    C: 157
+    W: 4

training/final_model/tfidf_qwen3_dinov3_pe_logreg_reg1_0_unweighted_final_pipeline.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0a3af0a9784f294566da18f63886e410a9c025b81b8c102c08ba9e1b7c174dcf
+size 4380782