the convert script ( some character is bad in the post )

#!/usr/bin/env python

-- coding: utf-8 --

"""
Convertisseur de dataset juridique Parquet vers format Alpaca

Ce script convertit un fichier Parquet contenant des articles juridiques
vers le format Alpaca utilisé par LLaMA Factory pour le fine-tuning.
"""

import os
import sys
import json
import argparse
import logging
import traceback
from datetime import datetime
from typing import Dict, Any, Optional, Tuple

import pandas as pd
import numpy as np
from tqdm import tqdm

Configuration du logging

logging.basicConfig(
level=logging.INFO,
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
handlers=[
logging.FileHandler("parquet_to_alpaca_conversion.log"),
logging.StreamHandler()
]
)
logger = logging.getLogger('parquet_to_alpaca')

Constantes

DEFAULT_INSTRUCTION = "Restitue le texte intégral de l'article référencé: {ref}"
TIMESTAMP_COLS = ['dateDebut', 'dateFin', 'dateFinExtension', 'dateDebutExtension']

Colonnes techniques à exclure de l'export (pas d'intérêt juridique)

EXCLUDED_COLS = [
'idTechInjection', 'refInjection', 'origine', 'idTexte',
'multipleVersions', 'comporteLiensSP'
]

Dépendances requises

REQUIRED_PACKAGES = {
'pandas': '1.0.0',
'numpy': '1.0.0',
'tqdm': '4.0.0'
}

def check_dependencies() -> Tuple[bool, Dict[str, str]]:
"""
Vérifie que toutes les dépendances requises sont installées et retourne leurs versions.
"""
import importlib

all_deps_ok = True
versions = {}

for package in REQUIRED_PACKAGES:
    try:
        # Vérifier si le package est installé
        module = importlib.import_module(package)
        # Obtenir la version installée
        try:
            version = getattr(module, '__version__', 'version inconnue')
        except:
            version = 'version inconnue'
        
        versions[package] = version
        logger.info(f"Package {package} trouvé, version: {version}")
        
    except ImportError:
        all_deps_ok = False
        logger.error(f"Package requis {package} non installé")

# Vérification spécifique pour NumPy 2.0+
if 'numpy' in versions:
    numpy_version = versions['numpy']
    try:
        major_version = int(numpy_version.split('.')[0])
        if major_version >= 2:
            logger.warning(f"NumPy version {numpy_version} détectée. Cette version a changé certains types, "
                          f"le script a été adapté pour être compatible.")
    except (ValueError, IndexError):
        logger.warning(f"Impossible de déterminer la version majeure de NumPy ({numpy_version}).")

return all_deps_ok, versions

def timestamp_to_date(timestamp: Any) -> Optional[str]:
"""
Convertit un timestamp Unix en milliseconds en date lisible au format YYYY-MM-DD.
"""
if timestamp is None:
return None

# Pour les tableaux NumPy, essayons d'extraire une valeur
if isinstance(timestamp, np.ndarray):
    if timestamp.size == 0:
        return None
    timestamp = timestamp.item(0)  # Prendre le premier élément

# Vérifier si c'est NaN
if isinstance(timestamp, float) and np.isnan(timestamp):
    return None

try:
    return datetime.fromtimestamp(int(timestamp)/1000).strftime('%Y-%m-%d')
except (ValueError, TypeError, OverflowError) as e:
    logger.warning(f"Erreur de conversion timestamp: {e}")
    return None

def is_null_or_na(value):
"""
Teste si une valeur est nulle ou NA, compatible avec les tableaux NumPy.
"""
if value is None:
return True

if isinstance(value, np.ndarray):
    if value.size == 0:
        return True
    # Pour les tableaux non-vides, vérifier si tous les éléments sont NaN
    if np.issubdtype(value.dtype, np.number):
        return np.isnan(value).all()
    return False

# Pour les types pandas
if pd.__version__ >= '1.0.0':
    return pd.isna(value)
else:
    return pd.isnull(value)

def safe_convert(value):
"""
Convertit de manière sûre une valeur pour JSON, y compris les tableaux NumPy.
"""
# None ou valeurs nulles
if is_null_or_na(value):
return None

# Tableaux NumPy
if isinstance(value, np.ndarray):
    if value.size == 0:
        return []
    
    # Pour les tableaux à une dimension
    if value.ndim == 1:
        result = []
        for item in value:
            if isinstance(item, (np.integer, np.floating, np.bool_)):
                result.append(item.item())
            else:
                result.append(safe_convert(item))
        return result
    
    # Pour les tableaux multidimensionnels, conversion récursive
    return value.tolist()

# Types NumPy scalaires
if np.issubdtype(type(value), np.integer):
    return int(value)
elif np.issubdtype(type(value), np.floating):
    if np.isnan(value):
        return None
    return float(value)
elif np.issubdtype(type(value), np.bool_):
    return bool(value)

# Types de conteneurs
if isinstance(value, dict):
    return {k: safe_convert(v) for k, v in value.items()}
elif isinstance(value, (list, tuple)):
    return [safe_convert(item) for item in value]

# Types de base
if isinstance(value, (str, int, float, bool)):
    return value

# Pour tout autre type, convertir en chaîne
return str(value)

def convert_parquet_to_alpaca(
input_file: str,
output_file: str,
instruction_template: str = DEFAULT_INSTRUCTION,
limit: Optional[int] = None
) -> None:
"""
Convertit un fichier Parquet d'articles juridiques au format Alpaca.
"""
logger.info(f"Début de la conversion du fichier: {input_file}")

# Vérification de l'existence du fichier
if not os.path.exists(input_file):
    logger.error(f"Le fichier {input_file} n'existe pas!")
    return

# Charger le DataFrame
try:
    df = pd.read_parquet(input_file)
    
    if limit:
        df = df.head(limit)
        
    logger.info(f"Nombre total d'articles à traiter: {len(df)}")
except Exception as e:
    logger.error(f"Erreur lors de la lecture du fichier: {e}")
    logger.debug(f"Détails de l'erreur: {traceback.format_exc()}")
    return

# Afficher quelques informations sur les colonnes
logger.info(f"Colonnes disponibles dans le dataset: {df.columns.tolist()}")

# Charger tous les articles en dictionnaires (plus simple à manipuler que le DataFrame)
articles = []
for _, row in df.iterrows():
    articles.append(row.to_dict())

# Liste pour stocker les entrées Alpaca
alpaca_data = []
success_count = 0
error_count = 0

# Traiter les articles un par un
for article in tqdm(articles, desc="Traitement des articles"):
    try:
        # Récupérer la référence et le texte
        ref = str(article.get('ref', 'Article inconnu'))
        article_text = article.get('texte', '')
        if is_null_or_na(article_text):
            article_text = ""
        else:
            article_text = str(article_text)
        
        # Préparer l'instruction
        instruction = instruction_template.format(ref=ref)
        
        # Créer un dictionnaire de métadonnées
        metadata = {}
        
        # Traiter chaque colonne
        for col, value in article.items():
            # Ignorer les colonnes exclues et le texte principal
            if col in EXCLUDED_COLS or col == 'texte':
                continue
            
            # Ignorer les valeurs nulles
            if is_null_or_na(value):
                continue
            
            # Traitement spécial pour les dates
            if col in TIMESTAMP_COLS:
                date_str = timestamp_to_date(value)
                if date_str:
                    metadata[col] = date_str
                continue
            
            # Convertir de manière sûre pour JSON
            try:
                metadata[col] = safe_convert(value)
            except Exception as e:
                logger.warning(f"Erreur lors de la conversion de la colonne {col} pour l'article {ref}: {e}")
                # En dernier recours, convertir en chaîne
                try:
                    metadata[col] = str(value)
                except:
                    logger.warning(f"Impossible de convertir la colonne {col} en chaîne, ignorée.")
        
        # Vérifier que les métadonnées peuvent être sérialisées en JSON
        try:
            json_metadata = json.dumps(metadata, ensure_ascii=False)
        except TypeError as e:
            logger.warning(f"Erreur de sérialisation JSON pour l'article {ref}: {e}")
            # Tenter une dernière approche en convertissant explicitement chaque valeur en chaîne
            clean_metadata = {}
            for k, v in metadata.items():
                try:
                    json.dumps(v)
                    clean_metadata[k] = v
                except:
                    clean_metadata[k] = str(v)
            json_metadata = json.dumps(clean_metadata, ensure_ascii=False)
        
        # Créer l'entrée Alpaca
        alpaca_entry = {
            "instruction": instruction,
            "input": json_metadata,
            "output": article_text
        }
        
        # Ajouter à la liste des données Alpaca
        alpaca_data.append(alpaca_entry)
        success_count += 1
        
    except Exception as e:
        error_count += 1
        logger.error(f"Erreur lors du traitement de l'article {article.get('ref', 'inconnu')}: {e}")
        if logger.level <= logging.DEBUG:
            logger.debug(traceback.format_exc())

# Sauvegarder les données
try:
    with open(output_file, 'w', encoding='utf-8') as f:
        json.dump(alpaca_data, f, ensure_ascii=False, indent=2)
    
    logger.info(f"Conversion terminée. {success_count} articles convertis et sauvegardés dans {output_file}")
    if error_count > 0:
        logger.warning(f"{error_count} articles n'ont pas pu être convertis.")
except Exception as e:
    logger.error(f"Erreur lors de la sauvegarde du fichier: {e}")
    if logger.level <= logging.DEBUG:
        logger.debug(traceback.format_exc())

def main():
"""Point d'entrée principal du script"""
parser = argparse.ArgumentParser(
description="Convertit un fichier Parquet d'articles juridiques au format Alpaca pour LLaMA Factory"
)
parser.add_argument(
"--input", "-i",
required=True,
help="Chemin vers le fichier Parquet d'entrée"
)
parser.add_argument(
"--output", "-o",
required=True,
help="Chemin pour sauvegarder le fichier JSON Alpaca"
)
parser.add_argument(
"--instruction",
default=DEFAULT_INSTRUCTION,
help=f"Template pour l'instruction (utiliser {{ref}} comme placeholder). Par défaut: '{DEFAULT_INSTRUCTION}'"
)
parser.add_argument(
"--limit",
type=int,
default=None,
help="Limite optionnelle du nombre d'articles à convertir (pour tests)"
)
parser.add_argument(
"--log-level",
choices=["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"],
default="INFO",
help="Niveau de détail des logs"
)

args = parser.parse_args()

# Configuration du niveau de log
logger.setLevel(getattr(logging, args.log_level))

# Vérification des dépendances
logger.info("Vérification des dépendances...")
deps_ok, versions = check_dependencies()
if not deps_ok:
    logger.error("Des dépendances requises sont manquantes. Veuillez les installer et réessayer.")
    sys.exit(1)

# Afficher un résumé des versions
logger.info("Versions des dépendances:")
for package, version in versions.items():
    logger.info(f"  - {package}: {version}")

# Exécution de la conversion
convert_parquet_to_alpaca(
    input_file=args.input,
    output_file=args.output,
    instruction_template=args.instruction,
    limit=args.limit
)

if name == "main":

script to diagnostic :

#!/usr/bin/env python

-- coding: utf-8 --

"""
Script de diagnostic approfondi pour datasets juridiques

Ce script analyse et compare les datasets Parquet et Alpaca, identifie
les anomalies et permet d'explorer les entrées problématiques.
Version corrigée pour gérer les tableaux NumPy.
"""

import json
import os
import sys
import argparse
import statistics
import re
from typing import Dict, List, Any, Tuple, Optional
from collections import Counter
import pandas as pd
import numpy as np
from tqdm import tqdm
import textwrap
import datetime
import random

Essai d'importation de tiktoken (installation si nécessaire)

try:
import tiktoken
except ImportError:
print("Installation de tiktoken...")
import subprocess
subprocess.check_call([sys.executable, "-m", "pip", "install", "tiktoken"])
import tiktoken

Configuration du script

DEFAULT_MAX_TOKENS = 8192
DEFAULT_WARNING_TOKENS = 4096
MAX_DISPLAY_ENTRIES = 10
MAX_EXTRACT_LENGTH = 150

Couleurs pour terminal

class Colors:
HEADER = '\033[95m'
BLUE = '\033[94m'
CYAN = '\033[96m'
GREEN = '\033[92m'
WARNING = '\033[93m'
FAIL = '\033[91m'
ENDC = '\033[0m'
BOLD = '\033[1m'
UNDERLINE = '\033[4m'

def color_text(text, color):
return f"{color}{text}{Colors.ENDC}"

def is_numpy_array_empty(arr):
"""Vérifie de manière sûre si un tableau NumPy est vide."""
if isinstance(arr, np.ndarray):
return arr.size == 0
return True

def safe_convert_numpy(obj):
"""Convertit un objet NumPy en type Python standard de manière sûre."""
if isinstance(obj, np.ndarray):
if obj.size == 0:
return []
if obj.ndim == 0:
return obj.item()
return obj.tolist()
elif isinstance(obj, np.integer):
return int(obj)
elif isinstance(obj, np.floating):
return float(obj)
elif isinstance(obj, np.bool_):
return bool(obj)
elif obj is np.nan:
return None
return obj

def estimate_tokens(text: str, model: str = "cl100k_base") -> int:
"""Estime le nombre de tokens dans un texte en utilisant tiktoken."""
if text is None:
return 0

# Convertir des types spéciaux (comme NumPy) en types Python standard
if isinstance(text, (np.ndarray, np.integer, np.floating, np.bool_)):
    text = safe_convert_numpy(text)

if not isinstance(text, str):
    try:
        text = str(text)
    except:
        return 0
        
try:
    encoding = tiktoken.get_encoding(model)
    return len(encoding.encode(text))
except Exception as e:
    # Estimation grossière si tiktoken échoue
    return len(str(text).split()) * 1.3

def format_size(size_bytes):
"""Formate une taille en bytes en format lisible."""
for unit in ['B', 'KB', 'MB', 'GB']:
if size_bytes < 1024.0 or unit == 'GB':
return f"{size_bytes:.2f} {unit}"
size_bytes /= 1024.0

def get_parquet_schema(file_path: str) -> Dict[str, Any]:
"""Obtient le schéma d'un fichier Parquet."""
try:
df = pd.read_parquet(file_path, columns=None)
return {col: str(dtype) for col, dtype in df.dtypes.items()}
except Exception as e:
print(f"Erreur lors de la lecture du schéma Parquet: {e}")
return {}

def is_null_or_empty(value):
"""Vérifie si une valeur est nulle ou vide, en gérant correctement les tableaux NumPy."""
if value is None:
return True
if isinstance(value, (pd.Series, pd.DataFrame)):
return value.empty
if isinstance(value, np.ndarray):
return value.size == 0
if pd.isna(value):
return True
if isinstance(value, (str, list, dict, tuple)):
return len(value) == 0
return False

def safe_estimate_tokens_for_series(series):
"""Estime de manière sûre les tokens pour une série pandas."""
results = []
for value in series:
if is_null_or_empty(value):
results.append(0)
else:
# Conversion sûre de tableaux NumPy et autres types
try:
# Les tableaux numpy doivent être convertis en JSON
if isinstance(value, np.ndarray):
value_str = json.dumps(value.tolist())
else:
value_str = str(value)
results.append(estimate_tokens(value_str))
except:
results.append(0)
return results
def examine_parquet_file(file_path: str, max_samples: int = 10) -> Dict[str, Any]:
"""Examine un fichier Parquet pour comprendre sa structure et son contenu."""
results = {
"schema": {},
"row_count": 0,
"column_stats": {},
"largest_entries": [],
"token_stats": {},
"reference_anomalies": []
}

try:
    # Charger le schéma
    df = pd.read_parquet(file_path, columns=None)
    results["schema"] = {col: str(dtype) for col, dtype in df.dtypes.items()}
    results["row_count"] = len(df)
    
    # Statistiques sur les colonnes
    for col in df.columns:
        try:
            # Gérer différemment pour chaque type
            if df[col].dtype == object or pd.api.types.is_string_dtype(df[col]):
                # Pour les colonnes textuelles
                non_null_mask = ~df[col].isna()
                non_null_count = non_null_mask.sum()
                
                if non_null_count > 0:
                    # Pour les chaînes de caractères, calculer la longueur moyenne
                    length_stats = {}
                    try:
                        # Obtenir un échantillon pour les calculs
                        sample = df.loc[non_null_mask, col].head(100)
                        
                        # Utiliser apply pour gérer différents types
                        lengths = sample.apply(lambda x: len(str(x)) if not is_null_or_empty(x) else 0)
                        
                        if len(lengths) > 0:
                            length_stats = {
                                "avg_length": lengths.mean(),
                                "max_length": lengths.max(),
                            }
                        
                        # Obtenir un exemple
                        first_value = df.loc[non_null_mask, col].iloc[0] if non_null_count > 0 else None
                        sample_text = ""
                        if first_value is not None:
                            if isinstance(first_value, np.ndarray):
                                sample_text = str(first_value.tolist())
                            else:
                                sample_text = str(first_value)
                            
                            sample_text = sample_text[:100] + "..." if len(sample_text) > 100 else sample_text
                        
                        results["column_stats"][col] = {
                            "non_null_count": non_null_count,
                            **length_stats,
                            "sample": sample_text
                        }
                        
                        # Estimation des tokens pour les colonnes textuelles
                        token_estimates = safe_estimate_tokens_for_series(sample)
                        
                        if token_estimates:
                            results["token_stats"][col] = {
                                "avg_tokens": sum(token_estimates) / len(token_estimates) if token_estimates else 0,
                                "max_tokens": max(token_estimates) if token_estimates else 0,
                                "median_tokens": statistics.median(token_estimates) if token_estimates else 0
                            }
                    except Exception as e:
                        print(f"Erreur lors de l'analyse de la colonne {col} (données): {e}")
                        import traceback
                        traceback.print_exc()
        except Exception as e:
            print(f"Erreur lors de l'analyse de la colonne {col}: {e}")
    
    # Identifier les entrées qui pourraient causer des problèmes (les plus volumineuses)
    if 'texte' in df.columns and 'num' in df.columns:
        try:
            # Créer une liste pour stocker les résultats
            entries = []
            
            # Échantillonner les données pour l'analyse si le dataset est grand
            sample_size = min(1000, len(df))
            df_sample = df.sample(sample_size) if len(df) > sample_size else df
            
            # Analyser chaque ligne échantillonnée
            for idx, row in df_sample.iterrows():
                entry = {"index": idx}
                
                # Obtenir le numéro d'article
                num = row.get('num')
                if isinstance(num, np.ndarray):
                    if num.size > 0:
                        num = str(num[0])
                    else:
                        num = ""
                entry["num"] = str(num)
                
                # Créer une référence standard
                entry["ref"] = f"Code de la sécurité sociale, art. {entry['num']}"
                
                # Estimer les tokens pour le texte
                texte = row.get('texte')
                entry["tokens_texte"] = estimate_tokens(texte) if not is_null_or_empty(texte) else 0
                
                # Estimer les tokens pour le texteHtml s'il existe
                texteHtml = row.get('texteHtml') if 'texteHtml' in row else None
                entry["tokens_texteHtml"] = estimate_tokens(texteHtml) if not is_null_or_empty(texteHtml) else 0
                
                # Estimer les tokens pour les citations
                citations = row.get('lienCitations') if 'lienCitations' in row else None
                if not is_null_or_empty(citations):
                    citations_str = json.dumps(safe_convert_numpy(citations))
                    entry["tokens_citations"] = estimate_tokens(citations_str)
                else:
                    entry["tokens_citations"] = 0
                
                # Calculer le total
                entry["total_tokens"] = entry["tokens_texte"] + entry["tokens_texteHtml"] + entry["tokens_citations"]
                
                entries.append(entry)
            
            # Trier par total_tokens décroissant et prendre les N plus grands
            entries.sort(key=lambda x: x["total_tokens"], reverse=True)
            results["largest_entries"] = entries[:max_samples]
            
            # Vérifier les incohérences dans les numéros d'articles
            if 'num' in df.columns:
                # Motif pour détecter les anomalies (espaces en fin, caractères spéciaux, etc.)
                pattern = re.compile(r'^[A-Z0-9\-]+$')
                anomalies = []
                
                for idx, row in df.iterrows():
                    num = row.get('num')
                    # Gérer les tableaux NumPy
                    if isinstance(num, np.ndarray):
                        if num.size > 0:
                            num = str(num[0])
                        else:
                            continue
                    
                    if isinstance(num, str) and not pattern.match(num.strip()):
                        anomalies.append({
                            "index": idx,
                            "num": num,
                            "expected": num.strip()
                        })
                        
                        # Limiter le nombre d'anomalies rapportées
                        if len(anomalies) >= max_samples:
                            break
                            
                results["reference_anomalies"] = anomalies
        except Exception as e:
            print(f"Erreur lors de l'analyse des entrées volumineuses: {e}")
            import traceback
            traceback.print_exc()
    
    return results
except Exception as e:
    print(f"Erreur lors de l'examen du fichier Parquet: {e}")
    import traceback
    traceback.print_exc()
    return results

def analyze_json_structure(data: List[Dict[str, Any]]) -> Tuple[bool, List[str]]:
"""Analyse la structure du JSON pour vérifier sa conformité au format Alpaca."""
is_valid = True
issues = []
required_keys = ["instruction", "output"]

for idx, item in enumerate(data):
    # Vérifier les clés requises
    for key in required_keys:
        if key not in item:
            is_valid = False
            issues.append(f"Entrée {idx}: Clé requise '{key}' manquante")
    
    # Vérifier les types de données
    for key in ["instruction", "input", "output"]:
        if key in item and not isinstance(item[key], str):
            is_valid = False
            issues.append(f"Entrée {idx}: La valeur de '{key}' n'est pas une chaîne de caractères")
    
    # Vérifier si l'entrée "input" est un JSON valide (spécifique à votre cas)
    if "input" in item and item["input"]:
        try:
            if item["input"].startswith("{") and item["input"].endswith("}"):
                json.loads(item["input"])
        except json.JSONDecodeError:
            issues.append(f"Entrée {idx}: Le champ 'input' contient du JSON invalide")

return is_valid, issues

def analyze_token_length(data: List[Dict[str, Any]], max_tokens: int, warning_tokens: int) -> Dict[str, Any]:
"""Analyse la longueur des tokens pour chaque entrée du dataset."""
results = {
"instruction_lengths": [],
"input_lengths": [],
"output_lengths": [],
"total_lengths": [],
"entries_by_length": [],
"max_length_idx": -1,
"max_length": 0,
"entries_exceeding_limit": 0,
"entries_with_warnings": 0
}

for idx, item in enumerate(data):
    instruction_tokens = estimate_tokens(item.get("instruction", ""))
    input_tokens = estimate_tokens(item.get("input", ""))
    output_tokens = estimate_tokens(item.get("output", ""))
    total_tokens = instruction_tokens + input_tokens + output_tokens
    
    results["instruction_lengths"].append(instruction_tokens)
    results["input_lengths"].append(input_tokens)
    results["output_lengths"].append(output_tokens)
    results["total_lengths"].append(total_tokens)
    
    # Stocker les détails pour chaque entrée
    results["entries_by_length"].append({
        "index": idx,
        "instruction_tokens": instruction_tokens,
        "input_tokens": input_tokens,
        "output_tokens": output_tokens,
        "total_tokens": total_tokens
    })
    
    if total_tokens > results["max_length"]:
        results["max_length"] = total_tokens
        results["max_length_idx"] = idx
    
    if total_tokens > max_tokens:
        results["entries_exceeding_limit"] += 1
    
    if total_tokens > warning_tokens:
        results["entries_with_warnings"] += 1

# Trier par longueur totale décroissante
results["entries_by_length"] = sorted(
    results["entries_by_length"], 
    key=lambda x: x["total_tokens"], 
    reverse=True
)

return results

def analyze_references(data: List[Dict[str, Any]]) -> Tuple[Dict[str, int], List[Dict[str, Any]]]:
"""Analyse les références d'articles pour détecter des problèmes potentiels."""
ref_counter = Counter()
anomalies = []
ref_pattern = re.compile(r'Code de la sécurité sociale, art. ([A-Z0-9-]+)')

for idx, item in enumerate(data):
    instruction = item.get("instruction", "")
    match = ref_pattern.search(instruction)
    
    if match:
        article_ref = match.group(1)
        ref_counter[article_ref] += 1
        
        # Vérifier la cohérence entre la référence et l'input JSON
        if "input" in item and isinstance(item["input"], str):
            try:
                input_data = json.loads(item["input"]) if item["input"].startswith("{") else {}
                if input_data.get("num") and input_data["num"].strip() != article_ref.strip():
                    anomalies.append({
                        "index": idx,
                        "ref_in_instruction": article_ref,
                        "ref_in_metadata": input_data.get("num", ""),
                        "expected": article_ref.strip()
                    })
            except:
                pass
    else:
        anomalies.append({
            "index": idx,
            "problem": "format_incorrect",
            "instruction": instruction[:100] + "..." if len(instruction) > 100 else instruction
        })

# Détecter les doublons
for ref, count in ref_counter.items():
    if count > 1:
        # Trouver les indices des entrées avec cette référence
        indices = []
        for idx, item in enumerate(data):
            instruction = item.get("instruction", "")
            if f"Code de la sécurité sociale, art. {ref}" in instruction:
                indices.append(idx)
                
        anomalies.append({
            "problem": "duplicate_reference",
            "ref": ref,
            "count": count,
            "indices": indices[:5]  # Limiter aux 5 premiers indices
        })

return dict(ref_counter), anomalies

def extract_problematic_entries(
data: List[Dict[str, Any]],
token_analysis: Dict[str, Any],
reference_anomalies: List[Dict[str, Any]],
max_to_show: int = 5
) -> Dict[str, List[Dict[str, Any]]]:
"""Extrait les entrées problématiques pour inspection."""
problems = {
"longest_entries": [],
"reference_anomalies": []
}

# Extraire les entrées les plus longues
longest_indices = [entry["index"] for entry in token_analysis["entries_by_length"][:max_to_show]]
for idx in longest_indices:
    entry = data[idx]
    instruction_tokens = token_analysis["entries_by_length"][0]["instruction_tokens"] if idx == token_analysis["entries_by_length"][0]["index"] else None
    input_tokens = token_analysis["entries_by_length"][0]["input_tokens"] if idx == token_analysis["entries_by_length"][0]["index"] else None
    output_tokens = token_analysis["entries_by_length"][0]["output_tokens"] if idx == token_analysis["entries_by_length"][0]["index"] else None
    total_tokens = token_analysis["entries_by_length"][0]["total_tokens"] if idx == token_analysis["entries_by_length"][0]["index"] else None
    
    problems["longest_entries"].append({
        "index": idx,
        "instruction": entry.get("instruction", ""),
        "input_preview": entry.get("input", "")[:MAX_EXTRACT_LENGTH] + "..." if len(entry.get("input", "")) > MAX_EXTRACT_LENGTH else entry.get("input", ""),
        "output_preview": entry.get("output", "")[:MAX_EXTRACT_LENGTH] + "..." if len(entry.get("output", "")) > MAX_EXTRACT_LENGTH else entry.get("output", ""),
        "instruction_tokens": instruction_tokens,
        "input_tokens": input_tokens,
        "output_tokens": output_tokens,
        "total_tokens": total_tokens
    })

# Extraire les entrées avec des anomalies de référence
for anomaly in reference_anomalies[:max_to_show]:
    if "index" in anomaly:
        idx = anomaly["index"]
        if idx < len(data):
            entry = data[idx]
            problems["reference_anomalies"].append({
                "index": idx,
                "anomaly_type": "inconsistent_reference" if "ref_in_instruction" in anomaly else "format_incorrect",
                "instruction": entry.get("instruction", ""),
                "ref_in_instruction": anomaly.get("ref_in_instruction", ""),
                "ref_in_metadata": anomaly.get("ref_in_metadata", ""),
                "expected": anomaly.get("expected", "")
            })

return problems

def print_entry_details(
data: List[Dict[str, Any]],
idx: int
) -> None:
"""Affiche les détails d'une entrée spécifique pour examen manuel."""
if idx < 0 or idx >= len(data):
print(f"Indice {idx} hors limites. Le dataset contient {len(data)} entrées.")
return

entry = data[idx]

print("\n" + color_text("="*80, Colors.HEADER))
print(color_text(f"DÉTAILS DE L'ENTRÉE {idx}", Colors.HEADER))
print(color_text("="*80, Colors.HEADER))

# Afficher l'instruction
print(color_text("INSTRUCTION:", Colors.BOLD))
print(entry.get("instruction", ""))
print()

# Essayer de parser l'input JSON pour un affichage plus lisible
print(color_text("INPUT:", Colors.BOLD))
if "input" in entry and entry["input"]:
    try:
        if entry["input"].startswith("{") and entry["input"].endswith("}"):
            input_data = json.loads(entry["input"])
            print(color_text("Métadonnées JSON:", Colors.CYAN))
            for key, value in input_data.items():
                if isinstance(value, str) and len(value) > 100:
                    value = value[:100] + "..."
                print(f"  {key}: {value}")
        else:
            print(entry["input"][:1000] + "..." if len(entry["input"]) > 1000 else entry["input"])
    except:
        print(entry["input"][:1000] + "..." if len(entry["input"]) > 1000 else entry["input"])
else:
    print("(vide)")
print()

# Afficher l'output
print(color_text("OUTPUT:", Colors.BOLD))
if "output" in entry and entry["output"]:
    print(entry["output"][:1000] + "..." if len(entry["output"]) > 1000 else entry["output"])
else:
    print("(vide)")
print()

# Calculer et afficher les statistiques de tokens
instruction_tokens = estimate_tokens(entry.get("instruction", ""))
input_tokens = estimate_tokens(entry.get("input", ""))
output_tokens = estimate_tokens(entry.get("output", ""))
total_tokens = instruction_tokens + input_tokens + output_tokens

print(color_text("STATISTIQUES DE TOKENS:", Colors.BOLD))
print(f"Instruction: {instruction_tokens} tokens")
print(f"Input:       {input_tokens} tokens")
print(f"Output:      {output_tokens} tokens")
print(f"Total:       {total_tokens} tokens")

print(color_text("="*80, Colors.HEADER))

def analyze_alpaca_file(
file_path: str,
max_tokens: int,
warning_tokens: int
) -> Dict[str, Any]:
"""Analyse complète d'un fichier JSON au format Alpaca."""
results = {
"file_info": {
"path": file_path,
"size": os.path.getsize(file_path),
"size_formatted": format_size(os.path.getsize(file_path))
},
"entries_count": 0,
"structure_valid": False,
"structure_issues": [],
"token_analysis": {},
"reference_stats": {},
"reference_anomalies": [],
"problematic_entries": {},
"raw_data": [] # Pour permettre l'inspection ultérieure
}

try:
    with open(file_path, 'r', encoding='utf-8') as f:
        data = json.load(f)
    
    # Vérifier si c'est une liste
    if not isinstance(data, list):
        results["structure_valid"] = False
        results["structure_issues"].append("Le fichier n'est pas au format attendu (liste d'objets)")
        return results
    
    results["entries_count"] = len(data)
    results["raw_data"] = data
    
    # Analyser la structure
    is_valid, structure_issues = analyze_json_structure(data)
    results["structure_valid"] = is_valid
    results["structure_issues"] = structure_issues
    
    # Analyser la longueur des tokens
    results["token_analysis"] = analyze_token_length(data, max_tokens, warning_tokens)
    
    # Analyser les références
    results["reference_stats"], results["reference_anomalies"] = analyze_references(data)
    
    # Extraire les entrées problématiques
    results["problematic_entries"] = extract_problematic_entries(
        data, 
        results["token_analysis"],
        results["reference_anomalies"]
    )
    
    return results
except json.JSONDecodeError as e:
    results["structure_valid"] = False
    results["structure_issues"].append(f"Le fichier n'est pas un JSON valide: {e}")
    return results
except Exception as e:
    results["structure_valid"] = False
    results["structure_issues"].append(f"Une erreur s'est produite lors de l'analyse: {e}")
    import traceback
    traceback.print_exc()
    return results

def print_alpaca_analysis(analysis: Dict[str, Any], max_tokens: int, warning_tokens: int) -> None:
"""Affiche les résultats de l'analyse du fichier Alpaca."""
print(color_text("\n" + "="*80, Colors.HEADER))
print(color_text(" ANALYSE DU FICHIER ALPACA", Colors.HEADER))
print(color_text("="*80, Colors.HEADER))

# Informations de base
print(f"Fichier:       {analysis['file_info']['path']}")
print(f"Taille:        {analysis['file_info']['size_formatted']}")
print(f"Entrées:       {analysis['entries_count']}")

# Structure
if analysis["structure_valid"]:
    print(color_text("\n✅ Structure JSON valide", Colors.GREEN))
else:
    print(color_text(f"\n❌ Problèmes de structure détectés: {len(analysis['structure_issues'])}", Colors.FAIL))
    for issue in analysis["structure_issues"][:MAX_DISPLAY_ENTRIES]:
        print(f"  - {issue}")
    if len(analysis["structure_issues"]) > MAX_DISPLAY_ENTRIES:
        print(f"  - ... et {len(analysis['structure_issues']) - MAX_DISPLAY_ENTRIES} autres problèmes")

# Analyse des tokens
token_analysis = analysis["token_analysis"]
if token_analysis:
    print(color_text("\n--- Statistiques de longueur des tokens ---", Colors.BOLD))
    for field in ["instruction", "input", "output", "total"]:
        lengths = token_analysis.get(f"{field}_lengths", [])
        if lengths:
            print(f"{field.capitalize()}:")
            print(f"  - Moyenne: {statistics.mean(lengths):.1f} tokens")
            print(f"  - Médiane: {statistics.median(lengths):.1f} tokens")
            print(f"  - Max: {max(lengths)} tokens")
            print(f"  - Min: {min(lengths)} tokens")
    
    print(f"\nEntrée la plus longue (Indice {token_analysis['max_length_idx']}): {token_analysis['max_length']} tokens")
    print(f"Entrées dépassant la limite spécifiée ({max_tokens} tokens): {token_analysis['entries_exceeding_limit']}")
    print(f"Entrées avec avertissements ({warning_tokens} tokens): {token_analysis['entries_with_warnings']}")
    
    if token_analysis['max_length'] > max_tokens:
        print(color_text("\n⚠️ ATTENTION: Certaines entrées sont trop longues!", Colors.WARNING))
        print(color_text("   Cela peut causer des problèmes lors du fine-tuning.", Colors.WARNING))
        print(color_text("   Utilisez le script de correction pour tronquer ces entrées.", Colors.WARNING))
        
        # Afficher les détails des entrées les plus longues
        print(color_text("\nTop 5 des entrées les plus longues:", Colors.BOLD))
        for i, entry in enumerate(token_analysis["entries_by_length"][:5]):
            print(f"#{i+1}: Indice {entry['index']} - {entry['total_tokens']} tokens (Input: {entry['input_tokens']}, Output: {entry['output_tokens']})")

# Analyse des références
ref_anomalies = analysis["reference_anomalies"]
if ref_anomalies:
    print(color_text(f"\n--- Analyse des références ---", Colors.BOLD))
    print(f"Nombre de références uniques: {len(analysis['reference_stats'])}")
    
    duplicates = [anomaly for anomaly in ref_anomalies if "problem" in anomaly and anomaly["problem"] == "duplicate_reference"]
    inconsistencies = [anomaly for anomaly in ref_anomalies if "ref_in_instruction" in anomaly and "ref_in_metadata" in anomaly]
    
    if duplicates:
        print(color_text(f"\nRéférences dupliquées: {len(duplicates)}", Colors.WARNING))
        for anomaly in duplicates[:3]:
            print(f"  - Référence '{anomaly['ref']}' apparaît {anomaly['count']} fois (aux indices {anomaly['indices']})")
    
    if inconsistencies:
        print(color_text(f"\nIncohérences de références: {len(inconsistencies)}", Colors.WARNING))
        for anomaly in inconsistencies[:5]:
            print(f"  - Indice {anomaly['index']}: '{anomaly['ref_in_instruction']}' vs '{anomaly['ref_in_metadata']}'")
    
    if len(ref_anomalies) > 0:
        total_shown = min(len(duplicates), 3) + min(len(inconsistencies), 5)
        if len(ref_anomalies) > total_shown:
            print(f"  - ... et {len(ref_anomalies) - total_shown} autres anomalies")

def print_parquet_analysis(analysis: Dict[str, Any]) -> None:
"""Affiche les résultats de l'analyse du fichier Parquet."""
print(color_text("\n" + "="*80, Colors.HEADER))
print(color_text(" ANALYSE DU FICHIER PARQUET", Colors.HEADER))
print(color_text("="*80, Colors.HEADER))

# Informations de base
print(f"Lignes:       {analysis['row_count']}")
print(f"Colonnes:     {len(analysis['schema'])}")

# Schéma
print(color_text("\n--- Schéma du fichier ---", Colors.BOLD))
important_cols = ['ref', 'num', 'texte', 'texteHtml', 'lienCitations', 'dateDebut', 'dateFin']
for col in important_cols:
    if col in analysis['schema']:
        print(f"{col:15s}: {analysis['schema'][col]}")

# Statistiques des colonnes textuelles
print(color_text("\n--- Statistiques des colonnes textuelles ---", Colors.BOLD))
important_text_cols = ['texte', 'texteHtml', 'lienCitations']
for col in important_text_cols:
    if col in analysis['column_stats']:
        stats = analysis['column_stats'][col]
        print(f"{col}:")
        print(f"  - Valeurs non nulles: {stats['non_null_count']}")
        print(f"  - Longueur moyenne: {stats['avg_length']:.1f} caractères")
        print(f"  - Longueur maximale: {stats['max_length']} caractères")
        if col in analysis['token_stats']:
            token_stats = analysis['token_stats'][col]
            print(f"  - Tokens moyens: {token_stats['avg_tokens']:.1f}")
            print(f"  - Tokens maximum: {token_stats['max_tokens']}")

# Entrées les plus volumineuses
if analysis['largest_entries']:
    print(color_text("\n--- Top 5 des entrées les plus volumineuses ---", Colors.BOLD))
    for i, entry in enumerate(analysis['largest_entries'][:5]):
        print(f"#{i+1}: Article {entry['num']} - Total: {entry['total_tokens']} tokens")
        print(f"   - Texte: {entry['tokens_texte']} tokens")
        print(f"   - HTML: {entry['tokens_texteHtml']} tokens")
        print(f"   - Citations: {entry['tokens_citations']} tokens")

# Anomalies dans les numéros d'articles
if analysis['reference_anomalies']:
    print(color_text(f"\n--- Anomalies dans les numéros d'articles ---", Colors.WARNING))
    for i, anomaly in enumerate(analysis['reference_anomalies'][:5]):
        print(f"  - Indice {anomaly['index']}: '{anomaly['num']}' (devrait être '{anomaly['expected']}')")
    if len(analysis['reference_anomalies']) > 5:
        print(f"  - ... et {len(analysis['reference_anomalies']) - 5} autres anomalies")

def compare_datasets(
parquet_analysis: Dict[str, Any],
alpaca_analysis: Dict[str, Any]
) -> Dict[str, Any]:
"""Compare les analyses des datasets Parquet et Alpaca pour identifier les problèmes."""
comparison = {
"size_ratio": 0,
"entries_ratio": 0,
"common_issues": [],
"conversion_issues": [],
"token_increase": 0,
"problematic_entries": []
}

# Comparer le nombre d'entrées
parquet_rows = parquet_analysis.get('row_count', 0)
alpaca_entries = alpaca_analysis.get('entries_count', 0)

if parquet_rows > 0 and alpaca_entries > 0:
    comparison['entries_ratio'] = alpaca_entries / parquet_rows
    
    if comparison['entries_ratio'] != 1.0:
        comparison['conversion_issues'].append(
            f"Le nombre d'entrées diffère: {parquet_rows} dans Parquet vs {alpaca_entries} dans Alpaca."
        )

# Comparer les problèmes de références/numéros d'articles
parquet_ref_anomalies = parquet_analysis.get('reference_anomalies', [])
alpaca_ref_anomalies = alpaca_analysis.get('reference_anomalies', [])

if parquet_ref_anomalies and alpaca_ref_anomalies:
    comparison['common_issues'].append(
        f"Problèmes de références dans les deux datasets: {len(parquet_ref_anomalies)} dans Parquet vs {len(alpaca_ref_anomalies)} dans Alpaca."
    )

# Comparer la taille des données
parquet_largest = parquet_analysis.get('largest_entries', [])
alpaca_longest = alpaca_analysis.get('token_analysis', {}).get('entries_by_length', [])

# Identifier les entrées avec un ratio taille/tokens anormal
problematic = []
if parquet_largest and alpaca_longest:
    # Créer un dictionnaire pour les entrées Parquet
    parquet_entries_by_num = {entry['num']: entry for entry in parquet_largest}
    
    # Pour chaque entrée Alpaca longue, essayer de trouver la correspondance Parquet
    for alpaca_entry in alpaca_longest[:10]:  # Limiter à 10 entrées
        idx = alpaca_entry['index']
        
        # Chercher le numéro d'article dans les données Alpaca brutes
        if idx < len(alpaca_analysis.get('raw_data', [])):
            alpaca_item = alpaca_analysis['raw_data'][idx]
            try:
                if "input" in alpaca_item and alpaca_item["input"]:
                    input_data = json.loads(alpaca_item["input"]) if alpaca_item["input"].startswith("{") else {}
                    article_num = input_data.get("num", "")
                    
                    # Si on trouve cet article dans les entrées Parquet volumineuses
                    if article_num in parquet_entries_by_num:
                        parquet_entry = parquet_entries_by_num[article_num]
                        
                        # Calculer le ratio entre les tokens Alpaca et les tokens estimés Parquet
                        parquet_tokens = parquet_entry['total_tokens']
                        alpaca_tokens = alpaca_entry['total_tokens']
                        ratio = alpaca_tokens / parquet_tokens if parquet_tokens > 0 else float('inf')
                        
                        problematic.append({
                            "article_num": article_num,
                            "alpaca_index": idx,
                            "parquet_tokens": parquet_tokens,
                            "alpaca_tokens": alpaca_tokens,
                            "ratio": ratio
                        })
            except:
                pass

comparison['problematic_entries'] = problematic

# Identifier l'augmentation de tokens dans la conversion
if parquet_analysis.get('token_stats', {}).get('texte', {}).get('avg_tokens', 0) > 0:
    avg_parquet = parquet_analysis['token_stats']['texte']['avg_tokens']
    avg_alpaca_output = statistics.mean(alpaca_analysis['token_analysis'].get('output_lengths', [0]))
    
    # Si les tokens moyens de sortie dépassent largement les tokens moyens de texte
    if avg_alpaca_output > avg_parquet * 1.5:
        comparison['token_increase'] = avg_alpaca_output / avg_parquet
        comparison['conversion_issues'].append(
            f"Les tokens moyens de sortie ont augmenté de {comparison['token_increase']:.1f}x par rapport au texte source."
        )

# Analyser la croissance des données dans les métadonnées
if alpaca_analysis['token_analysis'].get('input_lengths', []):
    avg_input_tokens = statistics.mean(alpaca_analysis['token_analysis']['input_lengths'])
    if avg_input_tokens > 500:  # Seuil arbitraire pour les métadonnées
        comparison['conversion_issues'].append(
            f"Les métadonnées JSON sont très volumineuses (moyenne: {avg_input_tokens:.1f} tokens)."
        )

return comparison

def main():
parser = argparse.ArgumentParser(
description="Analyse et compare des datasets juridiques Parquet et Alpaca",
formatter_class=argparse.RawDescriptionHelpFormatter,
epilog=textwrap.dedent("""
Exemples:
# Analyser seulement un fichier Alpaca
python diagnostic.py --alpaca data/code_securite_sociale_alpaca.json

      # Analyser les deux fichiers et générer un rapport
      python diagnostic.py --parquet source.parquet --alpaca converted.json --report rapport.json
      
      # Mode interactif pour explorer un fichier Alpaca
      python diagnostic.py --alpaca data/code_securite_sociale_alpaca.json --interactive
      
      # Modifier les seuils de tokens
      python diagnostic.py --alpaca data/code_securite_sociale_alpaca.json --max-tokens 8192 --warning-tokens 4096
    """)
)
parser.add_argument("--parquet", help="Chemin vers le fichier Parquet original")
parser.add_argument("--alpaca", help="Chemin vers le fichier JSON au format Alpaca")
parser.add_argument("--report", help="Chemin où sauvegarder le rapport de diagnostic")
parser.add_argument("--max-tokens", type=int, default=DEFAULT_MAX_TOKENS, 
                  help=f"Limite maximale de tokens (défaut: {DEFAULT_MAX_TOKENS})")
parser.add_argument("--warning-tokens", type=int, default=DEFAULT_WARNING_TOKENS,
                  help=f"Seuil d'avertissement pour les tokens (défaut: {DEFAULT_WARNING_TOKENS})")
parser.add_argument("--interactive", action="store_true", 
                  help="Active le mode interactif pour explorer les données")
parser.add_argument("--limit-entries", type=int, default=None,
                  help="Limite le nombre d'entrées à analyser (pour les fichiers volumineux)")
args = parser.parse_args()

# Vérification des arguments
if not args.parquet and not args.alpaca:
    parser.print_help()
    print("\nErreur: Vous devez spécifier au moins un fichier à analyser (--parquet ou --alpaca).")
    sys.exit(1)

# Initialiser les résultats d'analyse
parquet_analysis = {}
alpaca_analysis = {}
comparison = {}

# Analyser le fichier Parquet si spécifié
if args.parquet:
    if not os.path.exists(args.parquet):
        print(f"Le fichier Parquet {args.parquet} n'existe pas.")
        sys.exit(1)
    
    print(f"Analyse du fichier Parquet: {args.parquet}")
    parquet_analysis = examine_parquet_file(args.parquet)
    print_parquet_analysis(parquet_analysis)

# Analyser le fichier Alpaca si spécifié
if args.alpaca:
    if not os.path.exists(args.alpaca):
        print(f"Le fichier Alpaca {args.alpaca} n'existe pas.")
        sys.exit(1)
    
    print(f"Analyse du fichier Alpaca: {args.alpaca}")
    alpaca_analysis = analyze_alpaca_file(args.alpaca, args.max_tokens, args.warning_tokens)
    print_alpaca_analysis(alpaca_analysis, args.max_tokens, args.warning_tokens)

# Comparer les deux analyses si les deux fichiers sont spécifiés
if args.parquet and args.alpaca:
    print(color_text("\n" + "="*80, Colors.HEADER))
    print(color_text(" COMPARAISON DES DATASETS", Colors.HEADER))
    print(color_text("="*80, Colors.HEADER))
    
    comparison = compare_datasets(parquet_analysis, alpaca_analysis)
    
    if comparison.get('conversion_issues'):
        print(color_text("\nProblèmes de conversion détectés:", Colors.WARNING))
        for issue in comparison['conversion_issues']:
            print(f"  - {issue}")
    
    if comparison.get('problematic_entries'):
        print(color_text("\nEntrées avec croissance de tokens excessive:", Colors.WARNING))
        for i, entry in enumerate(comparison['problematic_entries'][:5]):
            print(f"  #{i+1}: Article {entry['article_num']} - Ratio: {entry['ratio']:.1f}x")
            print(f"     Parquet: {entry['parquet_tokens']} tokens → Alpaca: {entry['alpaca_tokens']} tokens")
    
    print(color_text("\nRecommandations:", Colors.BOLD))
    if alpaca_analysis['token_analysis'].get('entries_exceeding_limit', 0) > 0:
        print(f"1. Modifiez le script de conversion pour tronquer les entrées trop longues")
        print(f"   ou simplifiez les métadonnées JSON.")
    
    median_total = statistics.median(alpaca_analysis['token_analysis'].get('total_lengths', [0]))
    print(f"2. Pour le fine-tuning, définissez:")
    print(f"   - cutoff_len: {max(2048, int(median_total * 1.2))}")
    print(f"   - max_source_length: {max(1024, int(median_total * 0.7))}")
    print(f"   - max_target_length: {max(1024, int(median_total * 0.3))}")
    print(f"   - Activez rope_scaling pour les longues séquences")

# Sauvegarder le rapport de diagnostic si demandé
if args.report and (args.parquet or args.alpaca):
    import datetime
    save_diagnostic_report(parquet_analysis, alpaca_analysis, comparison, args.report)

# Mode interactif si demandé
if args.interactive and args.alpaca:
    interactive_inspection(alpaca_analysis)

def save_diagnostic_report(
parquet_analysis: Dict[str, Any],
alpaca_analysis: Dict[str, Any],
comparison: Dict[str, Any],
output_file: str
) -> None:
"""Sauvegarde un rapport de diagnostic complet au format JSON."""
report = {
"timestamp": datetime.datetime.now().isoformat(),
"parquet_analysis": {k: v for k, v in parquet_analysis.items() if k != 'raw_data'},
"alpaca_analysis": {k: v for k, v in alpaca_analysis.items() if k != 'raw_data'},
"comparison": comparison,
"recommendations": []
}

# Générer des recommandations basées sur l'analyse
if alpaca_analysis['token_analysis'].get('entries_exceeding_limit', 0) > 0:
    report['recommendations'].append({
        "priority": "high",
        "issue": "Entrées trop longues",
        "description": f"{alpaca_analysis['token_analysis']['entries_exceeding_limit']} entrées dépassent la limite de tokens.",
        "solution": "Utilisez le script de correction pour tronquer les entrées ou réduire les métadonnées."
    })

if comparison.get('problematic_entries', []):
    report['recommendations'].append({
        "priority": "high",
        "issue": "Croissance excessive des tokens",
        "description": f"Certaines entrées ont un ratio de tokens anormalement élevé entre Parquet et Alpaca.",
        "solution": "Vérifiez la conversion des entrées spécifiques et limitez les métadonnées."
    })

if alpaca_analysis.get('reference_anomalies', []):
    report['recommendations'].append({
        "priority": "medium",
        "issue": "Incohérences de références",
        "description": f"{len(alpaca_analysis['reference_anomalies'])} anomalies détectées dans les références.",
        "solution": "Corrigez les incohérences entre les références dans l'instruction et les métadonnées."
    })

# Ajouter des recommandations pour la configuration de fine-tuning
median_total = statistics.median(alpaca_analysis['token_analysis'].get('total_lengths', [0]))
report['recommendations'].append({
    "priority": "medium",
    "issue": "Configuration de fine-tuning",
    "description": f"La longueur médiane des entrées est de {median_total:.1f} tokens.",
    "solution": f"Utilisez cutoff_len: {max(2048, int(median_total * 1.2))}, max_source_length: {max(1024, int(median_total * 0.7))}, max_target_length: {max(1024, int(median_total * 0.3))}"
})

with open(output_file, 'w', encoding='utf-8') as f:
    json.dump(report, f, ensure_ascii=False, indent=2)

print(f"\nRapport de diagnostic sauvegardé dans {output_file}")

def interactive_inspection(alpaca_analysis: Dict[str, Any]) -> None:
"""Mode interactif pour inspecter les entrées problématiques du dataset."""
if not alpaca_analysis.get('raw_data'):
print("Données brutes non disponibles pour l'inspection.")
return

data = alpaca_analysis['raw_data']
token_analysis = alpaca_analysis['token_analysis']

print(color_text("\n" + "="*80, Colors.HEADER))
print(color_text(" MODE D'INSPECTION INTERACTIVE", Colors.HEADER))
print(color_text("="*80, Colors.HEADER))
print("Commandes disponibles:")
print("  - 'longest N': Affiche les N entrées les plus longues")
print("  - 'show INDEX': Affiche les détails de l'entrée à l'indice spécifié")
print("  - 'search PATTERN': Recherche des entrées contenant le motif")
print("  - 'random': Affiche une entrée aléatoire")
print("  - 'anomalies': Liste les anomalies de référence")
print("  - 'exit' ou 'quit': Quitte le mode interactif")

while True:
    cmd = input("\nCommande (ou 'exit' pour quitter): ").strip()
    
    if cmd.lower() in ('exit', 'quit', 'q'):
        break
    
    try:
        if cmd.lower().startswith('longest'):
            parts = cmd.split()
            n = int(parts[1]) if len(parts) > 1 else 5
            print(color_text(f"\nTop {n} des entrées les plus longues:", Colors.BOLD))
            for i, entry in enumerate(token_analysis["entries_by_length"][:n]):
                idx = entry["index"]
                print(f"#{i+1}: Indice {idx} - {entry['total_tokens']} tokens")
                if "input" in data[idx] and data[idx]["input"]:
                    try:
                        input_data = json.loads(data[idx]["input"])
                        if "num" in input_data:
                            print(f"   Article: {input_data['num']}")
                    except:
                        pass
                print(f"   Instruction: {data[idx].get('instruction', '')[:100]}...")
        
        elif cmd.lower().startswith('show'):
            parts = cmd.split()
            if len(parts) > 1:
                idx = int(parts[1])
                print_entry_details(data, idx)
            else:
                print("Veuillez spécifier un indice, par exemple: 'show 123'")
        
        elif cmd.lower().startswith('search'):
            pattern = cmd[len('search'):].strip()
            if not pattern:
                print("Veuillez spécifier un motif de recherche, par exemple: 'search L161-8'")
                continue
            
            found = []
            for idx, entry in enumerate(data):
                if pattern in json.dumps(entry, ensure_ascii=False):
                    found.append(idx)
            
            if found:
                print(f"Trouvé {len(found)} entrées contenant '{pattern}':")
                for idx in found[:5]:
                    print(f"Indice {idx}: {data[idx].get('instruction', '')[:100]}...")
                if len(found) > 5:
                    print(f"... et {len(found) - 5} autres entrées")
                
                show_idx = input("Afficher une entrée spécifique (indice ou 'n' pour annuler): ").strip()
                if show_idx.lower() not in ('n', 'no', 'non'):
                    try:
                        idx = int(show_idx)
                        print_entry_details(data, idx)
                    except:
                        print("Indice invalide.")
            else:
                print(f"Aucune entrée contenant '{pattern}' trouvée.")
        
        elif cmd.lower() == 'random':
            idx = random.randint(0, len(data) - 1)
            print_entry_details(data, idx)
        
        elif cmd.lower() == 'anomalies':
            anomalies = alpaca_analysis.get('reference_anomalies', [])
            if anomalies:
                print(color_text(f"\n{len(anomalies)} anomalies de référence détectées:", Colors.BOLD))
                inconsistencies = [a for a in anomalies if "ref_in_instruction" in a and "ref_in_metadata" in a]
                duplicates = [a for a in anomalies if "problem" in a and a["problem"] == "duplicate_reference"]
                
                if inconsistencies:
                    print(color_text(f"\nIncohérences de références: {len(inconsistencies)}", Colors.WARNING))
                    for i, anomaly in enumerate(inconsistencies[:10]):
                        print(f"#{i+1}: Indice {anomaly['index']} - Instruction: '{anomaly['ref_in_instruction']}', Métadonnées: '{anomaly['ref_in_metadata']}'")
                
                if duplicates:
                    print(color_text(f"\nRéférences dupliquées: {len(duplicates)}", Colors.WARNING))
                    for i, anomaly in enumerate(duplicates[:5]):
                        print(f"#{i+1}: '{anomaly['ref']}' apparaît {anomaly['count']} fois (indices: {anomaly['indices']})")
            else:
                print("Aucune anomalie de référence détectée.")
        
        else:
            print("Commande non reconnue. Tapez 'exit' pour quitter.")
    except Exception as e:
        print(f"Erreur lors de l'exécution de la commande: {e}")

if name == "main":

add to dataset_info.json in data directory for LLama Factory

},
"code_securite_sociale": {
"file_name": "code_securite_sociale_alpaca.json",
"columns": {
"prompt": "instruction",
"query": "input",
"response": "output"
}
},