Système d'IA Contextuelle Résidentielle

Assistant vocal intelligent 100% offline pour la domotique résidentielle avec reconnaissance faciale et traitement du langage naturel local.

Smart Home IA
Système actif

1. Objectifs & Périmètre

Assistance Résidentielle

Assistant vocal + visuel qui reconnaît les occupants, comprend le contexte, commande la domotique et répond en temps réel.

100% Edge / Offline

Aucune donnée biométrique, texte ou audio ne quitte le logement : LLM, Vision et TTS sont auto-hébergés.

Open-source & Modulaire

Tous les scripts sont Python 3.11 ; chaque fonction est un micro-service ou un thread indépendant, remplaçable facilement.

2. Vue Système (C4 : Container Diagram)

┌───────────┐  MJPEG/USB  ┌────────────────────┐
│  Webcam   │───────────►│ Reconnaissance      │
└───────────┘            │ faciale (OpenCV)    │
                         │ reco.py             │
                         └─────────┬───────────┘
                                   │   JSON (maj à chaud)
                                   ▼
                         personnes_detectees.json
                                   │
                                   ▼
┌──────────────┐  REST  ┌────────────────────┐
│ Interface    │◄──────│ Orchestrateur      │
│ utilisateur  │       │ chat_loop.py       │
│ (CLI / STT)  │──────►│ (prompts LLM)      │
└──────────────┘       └─────────┬──────────┘
                                 │  streaming tokens
                                 ▼
                         LM Studio (Gemma-2-2b-IT)
                                 │
                                 ▼
                        file_vocale (Queue)
                                 │  /tts JSON
                                 ▼
                       Micro-service Flask TTS

Architecture Logicielle

  • Design modulaire avec communication inter-processus
  • Gestion asynchrone des flux audio/vidéo/textuels
  • Paradigme producteur-consommateur pour les queues

Interfaces

  • Input MJPEG via USB (UVC standard)
  • API REST interne pour orchestration
  • Interface STT/CLI extensible

3. Modules Logiciels

Reconnaissance Faciale

Fichier: reconnaissance.py

Rôle: Détection et identification des visages via webcam

Points clés: 30 FPS sur CPU ; stocke les visages inconnus

Base d'Encodages

Fichier: lfw_encodings.pickle

Rôle: Stockage des empreintes faciales

Points clés: 13k visages LFW ; 150 Mo RAM

Orchestrateur

Fichier: chat_loop.py

Rôle: Gestion du flux conversationnel

Points clés: Prompt engineering dynamique avec Gemma-2-2b-IT

Profils Utilisateur

Fichier: profils/*.json

Rôle: Personnalisation des interactions

Points clés: Métadonnées linguistiques et stylistiques

Synthèse Vocale

Fichier: test_tts.py

Rôle: Conversion texte-parole

Points clés: Latence 200-300 ms ; Flask + edge-tts

Apprentissage Auto

Fichier: apprentissage_auto.py

Rôle: Ajout de nouveaux visages

Points clés: Déclenché après saisie manuelle

4. Flux d'exécution détaillé

Capture

reconnaissance.py capture une frame, détecte les bounding boxes puis calcule l'encodage (HOG ou CNN).

Latence: 25-35 ms

1

Identification

face_recognition.compare_faces → nom ou "Inconnu". Mise à jour du JSON de présence.

Latence: 1-2 ms

2

Prompting

chat_loop.py lit la présence, charge les profils et construit le prompt contextuel.

Latence: 2 ms

3

Génération LLM

Streaming REST ; chaque token est filtré et imprimé ; détection de ponctuation pour découpage.

Latence: 25 ms/token

4

Synthèse Vocale

File file_vocale → POST /tts ; edge-tts génère l'audio, converti et joué.

Latence: 200-400 ms

5

6. Installation & Mise en Route

Matériel Minimum

  • RPi 5 ou NUC i5 ≥ 8 Go RAM
  • Webcam 720p (UVC)
  • Enceintes / sortie audio

Pré-requis Logiciels

  • OS: Ubuntu 22.04 64 bit
  • Python 3.11

Dépendances

pip install opencv-python face_recognition dlib requests 
edge-tts pydub simpleaudio inputimeout emoji keyboard flask

Initialisation

# Pré-encodage (~30 min sur RPi 5)
python encode_lfw.py

# Lancement des services
Terminal A: python reconnaissance.py
Terminal B: python test_tts.py
Terminal C: python chat_loop.py

TL;DR pour l'ingénieur·e

Le projet combine Vision temps réel (OpenCV+dlib), LLM local (Gemma-2-2b-IT), TTS neuronal et un orchestrateur Python qui relie le tout via des queues thread-safe. Le code reste lisible, chaque composant peut être remplacé, et aucune donnée sensible ne sort de la maison : vous pouvez donc lire, tester, modifier, déployer en quelques heures.