Spaces:

rinogeek
/

FireWatch

Sleeping

App Files Files Community

FireWatch / INSTALLATION.md

rinogeek

first commit

e9d86db 4 months ago

preview code

raw

history blame contribute delete

10.2 kB

📖 Guide d'Installation - FireWatch AI

Créé par Marino ATOHOUN

Ce guide vous accompagne pas à pas dans l'installation et la configuration de FireWatch AI.

🎯 Prérequis Système

Minimum requis

OS : Ubuntu 20.04+, Windows 10+, macOS 10.15+
Python : 3.11 ou supérieur
RAM : 8 GB minimum (16 GB recommandé)
Stockage : 10 GB d'espace libre
GPU : Optionnel mais recommandé (NVIDIA avec CUDA)

Logiciels requis

Git
Python 3.11+
pip (gestionnaire de packages Python)
Node.js 16+ (pour les outils de développement frontend)

🔧 Installation Étape par Étape

Étape 1 : Préparation de l'environnement

Sur Ubuntu/Debian

# Mise à jour du système
sudo apt update && sudo apt upgrade -y

# Installation des dépendances système
sudo apt install -y python3.11 python3.11-venv python3-pip git curl
sudo apt install -y libgl1-mesa-glx libglib2.0-0 libsm6 libxext6 libxrender-dev
sudo apt install -y libgomp1 libgthread-2.0-0 libgtk-3-0 python3-opencv ffmpeg

# Installation de PostgreSQL (optionnel, pour la production)
sudo apt install -y postgresql postgresql-contrib

# Installation de Redis (optionnel, pour le cache)
sudo apt install -y redis-server

Sur Windows

# Installer Python depuis python.org ou via Microsoft Store
# Installer Git depuis git-scm.com
# Installer Visual Studio Build Tools pour les packages natifs

# Via Chocolatey (optionnel)
choco install python git nodejs postgresql redis-64

Sur macOS

# Via Homebrew
brew install python@3.11 git node postgresql redis opencv ffmpeg

# Ou via MacPorts
sudo port install python311 git nodejs postgresql redis opencv4

Étape 2 : Clonage et Configuration du Projet

# Cloner le projet
git clone https://github.com/votre-username/firewatch-ai.git
cd firewatch-ai

# Créer un environnement virtuel
python3.11 -m venv venv

# Activer l'environnement virtuel
# Sur Linux/macOS :
source venv/bin/activate
# Sur Windows :
venv\Scripts\activate

# Vérifier la version de Python
python --version  # Doit afficher Python 3.11.x

Étape 3 : Installation des Dépendances Python

# Mettre à jour pip
pip install --upgrade pip

# Installer les dépendances de base
pip install -r requirements.txt

# Pour le développement (optionnel)
pip install -r requirements-dev.txt

Note : L'installation peut prendre 10-15 minutes selon votre connexion internet.

Étape 4 : Configuration des Variables d'Environnement

# Copier le fichier d'exemple
cp .env.example .env

# Éditer le fichier .env
nano .env  # ou votre éditeur préféré

Configuration minimale pour commencer :

DEBUG=True
SECRET_KEY=votre-cle-secrete-django-changez-moi
ALLOWED_HOSTS=localhost,127.0.0.1,0.0.0.0
DATABASE_URL=sqlite:///db.sqlite3

Étape 5 : Préparation des Modèles YOLOv8

# Créer le répertoire des modèles
mkdir -p models

# Copier vos modèles YOLOv8 (vous devez les avoir entraînés)
cp /chemin/vers/vos/modeles/incendies.pt models/
cp /chemin/vers/vos/modeles/intrusion.pt models/

# Vérifier que les modèles sont présents
ls -la models/
# Doit afficher : incendies.pt et intrusion.pt

Si vous n'avez pas encore de modèles :

# L'application fonctionnera en mode simulation
# Vous pourrez tester l'interface et intégrer vos modèles plus tard
echo "Les modèles seront chargés quand vous les placerez dans models/"

Étape 6 : Configuration de la Base de Données

Option A : SQLite (Développement)

# Créer et appliquer les migrations
python manage.py makemigrations
python manage.py migrate

# Créer un superutilisateur
python manage.py createsuperuser
# Suivre les instructions à l'écran

Option B : PostgreSQL (Production)

# Se connecter à PostgreSQL
sudo -u postgres psql

# Créer la base de données et l'utilisateur
CREATE DATABASE firewatch_db;
CREATE USER firewatch WITH PASSWORD 'votre_mot_de_passe';
GRANT ALL PRIVILEGES ON DATABASE firewatch_db TO firewatch;
\q

# Modifier .env
DATABASE_URL=postgresql://firewatch:votre_mot_de_passe@localhost:5432/firewatch_db

# Appliquer les migrations
python manage.py migrate
python manage.py createsuperuser

Étape 7 : Collecte des Fichiers Statiques

# Collecter les fichiers statiques
python manage.py collectstatic --noinput

# Créer les répertoires media
mkdir -p media/uploads/images media/uploads/videos media/results

Étape 8 : Test de l'Installation

# Lancer le serveur de développement
python manage.py runserver 0.0.0.0:8000

# Dans un autre terminal, tester l'API
curl http://localhost:8000/

Ouvrir votre navigateur : http://localhost:8000

Vous devriez voir la page d'accueil de FireWatch AI.

🐳 Installation avec Docker (Recommandée)

Prérequis Docker

# Installer Docker
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh

# Installer Docker Compose
sudo curl -L "https://github.com/docker/compose/releases/latest/download/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose

# Ajouter votre utilisateur au groupe docker
sudo usermod -aG docker $USER
# Redémarrer votre session

Installation Docker

# Cloner le projet
git clone https://github.com/votre-username/firewatch-ai.git
cd firewatch-ai

# Placer vos modèles
mkdir models
cp /chemin/vers/incendies.pt models/
cp /chemin/vers/intrusion.pt models/

# Lancer avec Docker Compose
docker-compose up -d

# Vérifier que tout fonctionne
docker-compose ps
docker-compose logs web

Accéder à l'application : http://localhost:8000

⚙️ Configuration Avancée

Configuration GPU (NVIDIA)

# Installer NVIDIA Docker
distribution=$(. /etc/os-release;echo $ID$VERSION_ID)
curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | sudo apt-key add -
curl -s -L https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.list | sudo tee /etc/apt/sources.list.d/nvidia-docker.list

sudo apt-get update && sudo apt-get install -y nvidia-docker2
sudo systemctl restart docker

# Modifier docker-compose.yml pour utiliser le GPU
# Ajouter sous le service web :
#   deploy:
#     resources:
#       reservations:
#         devices:
#           - driver: nvidia
#             count: 1
#             capabilities: [gpu]

Configuration Redis (Cache)

# Installer Redis
sudo apt install redis-server

# Configurer Redis
sudo nano /etc/redis/redis.conf
# Modifier : bind 127.0.0.1
# Modifier : maxmemory 256mb
# Modifier : maxmemory-policy allkeys-lru

# Redémarrer Redis
sudo systemctl restart redis-server

# Tester Redis
redis-cli ping  # Doit retourner PONG

Configuration Nginx (Production)

# Installer Nginx
sudo apt install nginx

# Créer la configuration
sudo nano /etc/nginx/sites-available/firewatch

# Contenu de la configuration :
server {
    listen 80;
    server_name votre-domaine.com;
    
    client_max_body_size 50M;
    
    location /static/ {
        alias /path/to/firewatch/staticfiles/;
    }
    
    location /media/ {
        alias /path/to/firewatch/media/;
    }
    
    location / {
        proxy_pass http://127.0.0.1:8000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

# Activer le site
sudo ln -s /etc/nginx/sites-available/firewatch /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl restart nginx

🔍 Vérification de l'Installation

Tests de Base

# Activer l'environnement virtuel
source venv/bin/activate

# Lancer les tests
python manage.py test

# Vérifier les modèles
python manage.py shell
>>> from detection.models import AIModelStatus
>>> AIModelStatus.objects.all()

Tests Fonctionnels

Interface Web : http://localhost:8000
Administration : http://localhost:8000/admin/
API Status : http://localhost:8000/api/models/status/
Upload d'image : Tester via l'interface web

Logs et Débogage

# Voir les logs Django
tail -f logs/firewatch.log

# Logs Docker
docker-compose logs -f web

# Déboguer les erreurs
python manage.py check
python manage.py check --deploy

🚨 Résolution des Problèmes Courants

Erreur : "No module named 'cv2'"

pip install opencv-python
# Ou sur Ubuntu :
sudo apt install python3-opencv

Erreur : "CUDA out of memory"

# Réduire la taille des batches dans settings.py
# Ou utiliser CPU uniquement :
export CUDA_VISIBLE_DEVICES=""

Erreur : "Permission denied" sur media/

sudo chown -R $USER:$USER media/
chmod -R 755 media/

Erreur de base de données

# Réinitialiser la base de données
rm db.sqlite3
python manage.py migrate
python manage.py createsuperuser

Port 8000 déjà utilisé

# Utiliser un autre port
python manage.py runserver 0.0.0.0:8080

# Ou tuer le processus
sudo lsof -t -i tcp:8000 | xargs kill -9

📋 Checklist Post-Installation

✅ Python 3.11+ installé
✅ Environnement virtuel créé et activé
✅ Dépendances installées sans erreur
✅ Variables d'environnement configurées
✅ Base de données migrée
✅ Superutilisateur créé
✅ Modèles YOLOv8 placés (ou mode simulation)
✅ Serveur démarre sans erreur
✅ Interface web accessible
✅ Upload d'image fonctionne
✅ Administration accessible

🎉 Félicitations !

Votre installation de FireWatch AI est maintenant terminée !

Prochaines étapes :

Tester l'application avec vos propres images/vidéos
Intégrer vos modèles YOLOv8 personnalisés
Configurer la production si nécessaire
Personnaliser l'interface selon vos besoins

Ressources utiles :

Besoin d'aide ? Contactez Marino ATOHOUN, créateur de FireWatch AI.