281 lines
8.8 KiB
Python
Executable File
281 lines
8.8 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
"""
|
|
Diagnostic de l'index FAISS - Vérifie l'état et le contenu de l'index.
|
|
"""
|
|
|
|
import os
|
|
import sys
|
|
import pickle
|
|
from pathlib import Path
|
|
|
|
# Ajouter le chemin du projet
|
|
sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'geniusia2'))
|
|
|
|
def check_faiss_installation():
|
|
"""Vérifie si FAISS est installé."""
|
|
print("\n1. Vérification de l'installation FAISS")
|
|
print("=" * 60)
|
|
|
|
try:
|
|
import faiss
|
|
print(f"✓ FAISS installé: version {faiss.__version__ if hasattr(faiss, '__version__') else 'inconnue'}")
|
|
return True
|
|
except ImportError:
|
|
print("✗ FAISS n'est pas installé")
|
|
return False
|
|
|
|
|
|
def check_index_files():
|
|
"""Vérifie la présence des fichiers d'index."""
|
|
print("\n2. Vérification des fichiers d'index")
|
|
print("=" * 60)
|
|
|
|
index_path = Path("geniusia2/data/faiss_index")
|
|
index_file = index_path / "embeddings.index"
|
|
metadata_file = index_path / "metadata.pkl"
|
|
|
|
results = {}
|
|
|
|
# Vérifier le répertoire
|
|
if index_path.exists():
|
|
print(f"✓ Répertoire d'index existe: {index_path}")
|
|
results['dir'] = True
|
|
else:
|
|
print(f"✗ Répertoire d'index manquant: {index_path}")
|
|
results['dir'] = False
|
|
return results
|
|
|
|
# Vérifier le fichier d'index
|
|
if index_file.exists():
|
|
size = index_file.stat().st_size
|
|
print(f"✓ Fichier d'index existe: {index_file}")
|
|
print(f" Taille: {size:,} octets ({size / 1024:.2f} KB)")
|
|
results['index'] = True
|
|
else:
|
|
print(f"✗ Fichier d'index manquant: {index_file}")
|
|
results['index'] = False
|
|
|
|
# Vérifier le fichier de métadonnées
|
|
if metadata_file.exists():
|
|
size = metadata_file.stat().st_size
|
|
print(f"✓ Fichier de métadonnées existe: {metadata_file}")
|
|
print(f" Taille: {size:,} octets ({size / 1024:.2f} KB)")
|
|
results['metadata'] = True
|
|
else:
|
|
print(f"✗ Fichier de métadonnées manquant: {metadata_file}")
|
|
results['metadata'] = False
|
|
|
|
return results
|
|
|
|
|
|
def check_index_content():
|
|
"""Vérifie le contenu de l'index FAISS."""
|
|
print("\n3. Vérification du contenu de l'index")
|
|
print("=" * 60)
|
|
|
|
try:
|
|
import faiss
|
|
|
|
index_file = Path("geniusia2/data/faiss_index/embeddings.index")
|
|
|
|
if not index_file.exists():
|
|
print("✗ Impossible de charger l'index (fichier manquant)")
|
|
return False
|
|
|
|
# Charger l'index
|
|
index = faiss.read_index(str(index_file))
|
|
|
|
print(f"✓ Index FAISS chargé avec succès")
|
|
print(f" Type d'index: {type(index).__name__}")
|
|
print(f" Dimension des vecteurs: {index.d}")
|
|
print(f" Nombre de vecteurs: {index.ntotal}")
|
|
print(f" Index entraîné: {'Oui' if index.is_trained else 'Non'}")
|
|
|
|
if index.ntotal == 0:
|
|
print("\n⚠ L'index est vide (aucun embedding stocké)")
|
|
else:
|
|
print(f"\n✓ L'index contient {index.ntotal} embeddings")
|
|
|
|
return True
|
|
|
|
except Exception as e:
|
|
print(f"✗ Erreur lors du chargement de l'index: {e}")
|
|
return False
|
|
|
|
|
|
def check_metadata_content():
|
|
"""Vérifie le contenu des métadonnées."""
|
|
print("\n4. Vérification des métadonnées")
|
|
print("=" * 60)
|
|
|
|
metadata_file = Path("geniusia2/data/faiss_index/metadata.pkl")
|
|
|
|
if not metadata_file.exists():
|
|
print("✗ Fichier de métadonnées manquant")
|
|
return False
|
|
|
|
try:
|
|
with open(metadata_file, 'rb') as f:
|
|
metadata = pickle.load(f)
|
|
|
|
print(f"✓ Métadonnées chargées avec succès")
|
|
print(f" Type: {type(metadata).__name__}")
|
|
print(f" Nombre d'entrées: {len(metadata)}")
|
|
|
|
if len(metadata) == 0:
|
|
print("\n⚠ Aucune métadonnée stockée")
|
|
else:
|
|
print(f"\n✓ {len(metadata)} métadonnées stockées")
|
|
|
|
# Afficher un exemple
|
|
if metadata:
|
|
first_key = list(metadata.keys())[0]
|
|
first_entry = metadata[first_key]
|
|
print(f"\n Exemple de métadonnée (ID {first_key}):")
|
|
for key, value in first_entry.items():
|
|
if isinstance(value, str) and len(value) > 50:
|
|
value = value[:50] + "..."
|
|
print(f" {key}: {value}")
|
|
|
|
return True
|
|
|
|
except Exception as e:
|
|
print(f"✗ Erreur lors du chargement des métadonnées: {e}")
|
|
return False
|
|
|
|
|
|
def check_embeddings_manager():
|
|
"""Vérifie que l'EmbeddingsManager peut être initialisé."""
|
|
print("\n5. Vérification de l'EmbeddingsManager")
|
|
print("=" * 60)
|
|
|
|
try:
|
|
# Importer sans initialiser complètement (éviter de charger les modèles lourds)
|
|
from geniusia2.core.embeddings_manager import EmbeddingsManager
|
|
print("✓ Module EmbeddingsManager importé avec succès")
|
|
|
|
# Vérifier les dépendances
|
|
try:
|
|
import open_clip
|
|
print("✓ OpenCLIP disponible")
|
|
except ImportError:
|
|
print("✗ OpenCLIP non disponible")
|
|
|
|
try:
|
|
import faiss
|
|
print("✓ FAISS disponible")
|
|
except ImportError:
|
|
print("✗ FAISS non disponible")
|
|
|
|
try:
|
|
import torch
|
|
print(f"✓ PyTorch disponible (version {torch.__version__})")
|
|
except ImportError:
|
|
print("✗ PyTorch non disponible")
|
|
|
|
return True
|
|
|
|
except Exception as e:
|
|
print(f"✗ Erreur lors de l'import de l'EmbeddingsManager: {e}")
|
|
return False
|
|
|
|
|
|
def check_usage_in_code():
|
|
"""Vérifie où FAISS est utilisé dans le code."""
|
|
print("\n6. Utilisation de FAISS dans le code")
|
|
print("=" * 60)
|
|
|
|
files_to_check = [
|
|
"geniusia2/core/suggestion_manager.py",
|
|
"geniusia2/core/embeddings_manager.py",
|
|
"geniusia2/core/learning_manager.py"
|
|
]
|
|
|
|
for file_path in files_to_check:
|
|
if os.path.exists(file_path):
|
|
with open(file_path, 'r') as f:
|
|
content = f.read()
|
|
|
|
# Chercher les références à FAISS
|
|
if 'faiss' in content.lower() or 'embeddings_manager' in content.lower():
|
|
print(f"✓ {file_path}")
|
|
|
|
# Compter les occurrences
|
|
faiss_count = content.lower().count('faiss')
|
|
embeddings_count = content.count('embeddings_manager')
|
|
search_similar_count = content.count('search_similar')
|
|
|
|
if faiss_count > 0:
|
|
print(f" - Mentions de 'faiss': {faiss_count}")
|
|
if embeddings_count > 0:
|
|
print(f" - Mentions de 'embeddings_manager': {embeddings_count}")
|
|
if search_similar_count > 0:
|
|
print(f" - Appels à 'search_similar': {search_similar_count}")
|
|
|
|
return True
|
|
|
|
|
|
def main():
|
|
"""Fonction principale."""
|
|
print("\n" + "=" * 60)
|
|
print("DIAGNOSTIC DE L'INDEX FAISS")
|
|
print("=" * 60)
|
|
|
|
results = []
|
|
|
|
# 1. Installation FAISS
|
|
results.append(check_faiss_installation())
|
|
|
|
# 2. Fichiers d'index
|
|
file_results = check_index_files()
|
|
results.append(all(file_results.values()))
|
|
|
|
# 3. Contenu de l'index
|
|
if file_results.get('index', False):
|
|
results.append(check_index_content())
|
|
else:
|
|
print("\n3. Vérification du contenu de l'index")
|
|
print("=" * 60)
|
|
print("⊘ Ignoré (fichier d'index manquant)")
|
|
results.append(False)
|
|
|
|
# 4. Métadonnées
|
|
if file_results.get('metadata', False):
|
|
results.append(check_metadata_content())
|
|
else:
|
|
print("\n4. Vérification des métadonnées")
|
|
print("=" * 60)
|
|
print("⊘ Ignoré (fichier de métadonnées manquant)")
|
|
results.append(False)
|
|
|
|
# 5. EmbeddingsManager
|
|
results.append(check_embeddings_manager())
|
|
|
|
# 6. Usage dans le code
|
|
results.append(check_usage_in_code())
|
|
|
|
# Résumé
|
|
print("\n" + "=" * 60)
|
|
print("RÉSUMÉ")
|
|
print("=" * 60)
|
|
|
|
passed = sum(results)
|
|
total = len(results)
|
|
|
|
print(f"Vérifications réussies: {passed}/{total}")
|
|
|
|
if passed == total:
|
|
print("\n✓ FAISS est correctement installé et configuré!")
|
|
elif passed >= total - 2:
|
|
print("\n⚠ FAISS est installé mais l'index est peut-être vide")
|
|
print(" Ceci est normal si aucune tâche n'a encore été apprise.")
|
|
else:
|
|
print("\n✗ Des problèmes ont été détectés avec FAISS")
|
|
print(" Exécute './geniusia2/install_faiss.sh' pour réinstaller")
|
|
|
|
return 0 if passed >= total - 2 else 1
|
|
|
|
|
|
if __name__ == "__main__":
|
|
sys.exit(main())
|