Video Intelligence

Thales Video Intelligence Indexing Platform

Un système full-stack, style production, qui transforme la vidéo brute en données structurées, searchables et prêtes pour l’analyse via CV + NLP + pipelines async.

Système d’intelligence vidéo full‑stack : frames + entités + timelines + transcripts + recherche.

Upload vidéo ou URL → pipeline async → rapport read-only partageable

UX timeline + recherche sémantique pour triage rapide

Artifacts JSON/PDF/CSV déterministes pour auditabilité

Traitement local, offline, CPU-first

Voir la démo Architecture Voir GitHub Lancer en local

Démo locale (teaser)

Ce que vous voyez en 60 secondes : upload → progression → rapport → timeline → recherche → export → lien partageable.

Écran d’ensemble avec recherche globale, actions d’upload et stats — Vue d’ensemble

Écran d’upload avec fichier local ou URL optionnelle — Upload

Bibliothèque vidéo avec statuts de traitement et terminés — Bibliothèque

Rapport vidéo avec aperçu et actions d’export — Rapport + exports

Galerie de frames avec overlays de détection et pagination — Preuves par frame

Timeline consolidée des entités détectées — Timeline

Plages temporelles par entité avec confiance et sources — Plages d’entités

Transcript avec résumé audio et texte complet — Transcript

Recherche unifiée avec filtres et correspondance sémantique — Recherche

Pas de démo cloud : calcul lourd + modèles volumineux + coûts + confidentialité. Évaluez localement.

Problème

Avant : les analystes scrutent des vidéos à la main, pause/play en boucle, prennent des notes manuelles. Pas d’output structuré, pas de timeline corrélée, pas d’archive searchable.

Après : un seul upload produit des entités, timestamps, frames, transcripts, un index searchable, des rapports exportables et des liens read-only partageables.

Critères de succès : rechercher à travers les vidéos, accéder directement aux moments clés, et exporter des artifacts prêts pour l’analyse.

Solution (vue d’ensemble)

Frontend (React) pour l’upload et la revue, FastAPI pour l’orchestration, Celery/Redis pour le calcul lourd, SQLite + filesystem pour la persistance.

Le calcul est asynchrone : jobs en queue, progression traçable, résultats stockés en artifacts pour export et relecture.

Construit end-to-end par un seul ingénieur pour simuler un pipeline de production sans services cloud payants.

Architecture

graph LR
  UI[React UI :5173] --> API[FastAPI :8010]
  API --> REDIS[(Redis :6379)]
  API --> DB[(SQLite)]
  API --> FS[data/entity_indexing]
  WORKER[Celery worker] --> REDIS
  WORKER --> FS
  WORKER --> DB
  API --> SHARE[Read-only share link]

  FS --> FRAMES[frames/]
  FS --> REPORTS[reports/]
  FS --> TRANSCRIPTS[transcripts/]
  FS --> INDEX[index.db]

Frontend (React/Vite) : 5173
Backend (FastAPI) : 8010 (ou 8000 selon env)
Redis : 6379
Worker Celery : pipeline async
Data paths : data/entity_indexing/{frames,reports,transcripts,index.db}
Share links read-only, tokenisées et stockées en SQLite.

Pipeline (étapes + progression)

extracting_frames (0–20)

Input : vidéo fichier ou URL.
Output : frames échantillonnées + metadata.
Échecs : codec non supporté, fichier absent, erreurs ffmpeg.
Persisté : frames/ + métadonnées.

transcribing_audio (20)

Input : piste audio extraite.
Output : transcript + timestamps.
Échecs : pas d’audio ; pipeline continue avec transcript vide.
Persisté : transcripts/ + JSON.

detecting_entities (20–80)

Input : frames + configs modèles.
Output : entités détectées + scores + OCR.
Échecs : erreurs de modèle ; résultats partiels.
Persisté : JSON detection + index frame.

aggregating_report (80–95)

Input : détections + transcript.
Output : plages temporelles, compteurs, frames preuve.
Échecs : data partielle ; rapport généré avec warnings.
Persisté : JSON/PDF/CSV.

indexing_search (95–100)

Input : entités + segments transcript.
Output : index exact + sémantique.
Échecs : embeddings indisponibles → fallback exact.
Persisté : index.db + metadata.

Décisions d’ingénierie

Workloads async avec Celery + Redis pour garder l’UI réactive.
Choix de modèles CPU-first (YOLOv8, MiniLM, faster-whisper base) pour du local/offline.
Recherche hybride : exact match + similarité sémantique.
Agrégation en plages temporelles + scoring de confiance pour expliquer la timeline.
Passage de vérification (CLIP) + filtrage par frames consécutives pour la précision.
OCR + nettoyage audio pour améliorer la qualité transcript/search.
Artifacts déterministes (JSON/PDF/CSV) pour auditabilité et répétabilité.
Export dataset COCO + YOLO avec split par vidéo pour éviter la fuite.

Ce que cela démontre

Capacité	Preuve	Où regarder
Full-stack system design	UI + API + worker	ui/app.py, backend/
Async processing	Queue Celery	backend/worker/
CV/NLP pipeline	frames + detection + STT	backend/src/entity_indexing/
FastAPI endpoints	upload + report APIs	backend/main.py
Dataset export	COCO + YOLO exporter	scripts/export_training_dataset.py

Reproductibilité

Quickstart Docker :
docker-compose up --build
open http://localhost:5173

Quickstart local :
brew install ffmpeg tesseract
python -m venv .venv && source .venv/bin/activate
pip install -r backend/requirements.txt
redis-server
uvicorn backend.main:app --host 0.0.0.0 --port 8010
celery -A backend.worker.celery_app worker --loglevel=info
cd frontend && npm install && npm run dev

Reviewer tasks :
1) Upload une vidéo
2) Ouvrir la timeline et cliquer une plage
3) Lancer une recherche sémantique et exporter le rapport

Demo Kit (sans cloud)

Use a small MP4 sample (or a public MP4 URL) to keep demos fast. Run the pipeline locally, upload the sample, then review the timeline, search results, and exportable report.

If keys are required for any model downloads, set them via env vars locally only. Do not commit secrets.

Démo enregistrée (à ajouter)

Add a Loom/YouTube link here when a recorded demo is available.

Limites & roadmap

Limitations

Performance CPU-bound ; vidéos longues = 1–2 min par minute de vidéo sur laptop.
Déploiement single-node ; pas de workers distribués ni cache partagé.
Pas d’auth/rate limiting si exposé publiquement.
Les uploads via URL peuvent échouer (403) selon la source.

Roadmap

Support GPU pour accélérer l’inférence + Whisper plus large.
Auth + rate limiting pour déploiements partagés.
Workers distribués + Postgres pour scale multi‑users.
Object storage (S3‑compatible) pour artifacts volumineux.
Caching, retry/backoff, meilleur ranking search.
Tests étendus + CI contre régressions pipeline.

Sécurité & confidentialité

Les clés optionnelles doivent venir de env/.env/Docker secrets, jamais commitées.
Share links read-only stockées en SQLite.
Si exposé publiquement, ajouter auth + rate limiting et isoler le stockage.