maj

.gitattributes

@@ -0,0 +1,36 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.plk filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,22 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+# On ajoute 'curl' qui est parfois nécessaire pour les téléchargements de modèles
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    git \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# On upgrade pip AVANT d'installer le reste
+RUN pip install --no-cache-dir --upgrade pip setuptools wheel
+
+COPY . /app
+
+# On installe le requirements
+RUN pip install --no-cache-dir -r requirements.txt
+
+EXPOSE 7860
+
+CMD ["streamlit", "run", "app.py", "--server.port=7860", "--server.address=0.0.0.0"]

README.md

@@ -0,0 +1,10 @@
+---
+title: GDM Aide RUN V2
+emoji: 📊
+colorFrom: red
+colorTo: gray
+sdk: docker
+pinned: false
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

api.py

@@ -0,0 +1,33 @@
+from fastapi import FastAPI
+from pydantic import BaseModel
+from app import predire_ticket  # On importe ta fonction depuis app.py
+
+# Initialisation de l'API
+app = FastAPI(title="GDM Ticket Classifier API")
+
+# Définition du format de donnée attendu (JSON)
+class TicketInput(BaseModel):
+    objet: str
+    description: str
+
+@app.get("/")
+def home():
+    return {"message": "API GDM opérationnelle. Utilisez l'endpoint /predict en POST."}
+
+@app.post("/predict")
+def api_predict(ticket: TicketInput):
+    # Sécurité : Si le modèle n'est pas chargé, on renvoie une erreur propre
+    from app import MODELE, MTTR_MOYENS
+    if MODELE is None:
+        return {"error": "Le modèle n'est pas chargé. Vérifiez les fichiers .pkl"}
+
+    obj = str(ticket.objet)
+    desc = str(ticket.description)
+    
+    categorie, mttr, confiance = predire_ticket(obj, desc)
+    
+    return {
+        "pole_expertise": str(categorie),
+        "temps_resolution_estime_h": float(mttr) if mttr is not None else 0.0,
+        "score_confiance": round(float(confiance), 4)
+    }

app.py

@@ -0,0 +1,192 @@
+import streamlit as st
+import pickle
+import pandas as pd
+import numpy as np
+import torch
+import os
+import io
+from transformers import AutoTokenizer, AutoModel 
+from sklearn.base import BaseEstimator, TransformerMixin
+
+# --- 0. DÉFINITION DE LA CLASSE CUSTOM (Indispensable pour charger le PKL) ---
+class LLMFeatureExtractor(BaseEstimator, TransformerMixin):
+    def __init__(self, model_name='distilbert-base-multilingual-cased', max_length=128):
+        self.model_name = model_name
+        self.max_length = max_length
+        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+        self.model = AutoModel.from_pretrained(model_name).to("cpu")
+
+    def fit(self, X, y=None):
+        return self
+
+    def transform(self, X):
+        m_len = getattr(self, 'max_length', 128)
+        texts = X.tolist() if hasattr(X, 'tolist') else list(X)
+        texts = [str(t)[:1000] for t in texts] 
+        inputs = self.tokenizer(
+            texts, 
+            padding=True, 
+            truncation=True, 
+            max_length=m_len, 
+            return_tensors="pt"
+        ).to("cpu")
+        with torch.no_grad():
+            outputs = self.model(**inputs)
+        return outputs.last_hidden_state[:, 0, :].detach().numpy()
+
+# Sécurité pour le désarchivage du modèle sur CPU
+class CPU_Unpickler(pickle.Unpickler):
+    def find_class(self, module, name):
+        # Force Python à chercher LLMFeatureExtractor dans le module app
+        if name == 'LLMFeatureExtractor':
+            import app
+            return app.LLMFeatureExtractor
+        if module == 'torch.storage' and name == '_load_from_bytes':
+            return lambda b: torch.load(io.BytesIO(b), map_location='cpu')
+        return super().find_class(module, name)
+    
+# --- 1. CHARGEMENT DYNAMIQUE ---
+@st.cache_resource
+def charger_modele_et_data():
+    # Chemins robustes pour environnement local et cloud
+    base_path = os.path.dirname(__file__)
+    MODELE_PATH = os.path.join(base_path, 'modele_classification_taln_llm.pkl')
+    MTTR_PATH = os.path.join(base_path, 'mttr_moyennes.pkl') 
+    
+    try:
+        with open(MODELE_PATH, 'rb') as file:
+            modele = CPU_Unpickler(file).load()
+        
+        mttr_moyens = {}
+        if os.path.exists(MTTR_PATH):
+            with open(MTTR_PATH, 'rb') as f:
+                mttr_moyens = pickle.load(f)
+            
+        return modele, mttr_moyens
+    except Exception as e:
+        print(f"Erreur de chargement : {e}")
+        return None, None
+
+# Chargement global pour être accessible par api.py
+MODELE, MTTR_MOYENS = charger_modele_et_data()
+
+# --- 2. FONCTION DE PRÉDICTION ---
+def predire_ticket(objet: str, description: str):
+    texte_complet_saisi = str(objet).strip() + " " + str(description).strip()
+    if not texte_complet_saisi.strip():
+        return "Saisie vide", 0.0, 0.0
+    
+    X_inference = pd.Series([texte_complet_saisi])
+    
+    try:
+        probabilites = MODELE.predict_proba(X_inference)[0]
+        confiance = np.max(probabilites)
+        prediction_brute = MODELE.classes_[np.argmax(probabilites)]
+    except Exception as e:
+        prediction_brute = "Erreur"
+        confiance = 0.0
+
+    # SEUIL DE CONFIANCE GDM
+    SEUIL_CRITIQUE = 0.65
+    if confiance < SEUIL_CRITIQUE or str(prediction_brute).upper() == "AUTRES":
+        categorie_finale = "À qualifier (Hors catalogue)"
+    else:
+        categorie_finale = prediction_brute
+        
+    mttr_predit = MTTR_MOYENS.get(prediction_brute, 0.0)
+    return categorie_finale, mttr_predit, confiance
+
+# --- 3. INTERFACE STREAMLIT ---
+# Cette partie ne s'exécute QUE si on lance 'streamlit run app.py'
+if __name__ == "__main__":
+    st.set_page_config(page_title="GDM Aide au RUN V4", layout="wide", page_icon="👗")
+
+    st.markdown("""
+        <style>
+        .stApp { background-color: #FFFFFF !important; }
+        html, body, [data-testid="stWidgetLabel"], .stText, p { color: #1A1A1A !important; }
+        .stButton>button { background-color: #E29792 !important; color: white !important; border-radius: 20px; font-weight: bold; }
+        .stMetric { background-color: #FDF2F1 !important; padding: 15px; border-radius: 10px; border-left: 5px solid #E29792 !important; }
+        [data-testid="stMetricValue"], [data-testid="stMetricLabel"] { color: #1A1A1A !important; }
+        </style>
+        """, unsafe_allow_html=True)
+
+    st.title("👗 Grain de Malice - Aide au RUN")
+    st.subheader("Optimisation par Pôles d'Expertise Consolidés")
+
+    with st.sidebar:
+        # 1. Logo et En-tête
+        if os.path.exists("logo_gdm.png"):
+            st.image("logo_gdm.png", width=150)
+        st.header("🚀 Spécifications V4")
+        st.success("✅ **Modèle :** DistilBERT Multilingual")
+        st.info("📊 **Mapping :** 3 Pôles Stratégiques")
+        
+        # 2. Section Expertise (Ton tableau MTTR d'origine)
+        st.markdown("---")
+        st.subheader("📊 MTTR par Pôle")
+        if MTTR_MOYENS:
+            df_mttr = pd.DataFrame([
+                {"Pôle": k, "Délai Moyen": f"{v:.1f} h"} 
+                for k, v in MTTR_MOYENS.items() if v is not None
+            ])
+            st.table(df_mttr)
+
+        # 3. NOUVEAU : Architecture & Industrialisation (Pour la certif)
+        st.markdown("---")
+        st.subheader("🛠️ Industrialisation")
+        
+        with st.expander("🌐 API & Intégration"):
+            st.write("""
+            Exposition via **FastAPI** :
+            - Endpoint : `/predict`
+            - Format : JSON REST
+            - Compatible : ServiceNow, Jira, Apps Magasins.
+            """)
+        
+        with st.expander("📦 Déploiement Docker"):
+            st.write("""
+            - Conteneur : `python:3.10-slim`
+            - Stockage : Git LFS (Large File Storage)
+            - Scalabilité : Prêt pour Kubernetes.
+            """)
+
+        st.caption("Innovation IT - Grain de Malice © 2026")
+
+    st.markdown("---")
+
+    col_input1, col_input2 = st.columns(2)
+    with col_input1:
+        objet_saisi = st.text_input("📍 Objet du ticket :")
+    with col_input2:
+        description_saisie = st.text_area("📝 Description détaillée :")
+
+    if st.button("🚀 Lancer le Diagnostic IA"):
+        if not objet_saisi and not description_saisie:
+            st.warning("Veuillez saisir des informations.")
+        else:
+            with st.spinner('Analyse sémantique en cours...'):
+                categorie, mttr, confiance = predire_ticket(objet_saisi, description_saisie)
+                
+            st.markdown("### ✅ Résultat du Diagnostic")
+            res1, res2, res3 = st.columns([2, 1, 1])
+
+            with res1:
+                st.metric("Pôle d'Expertise Prédit", categorie)
+            with res2:
+                st.metric("MTTR Estimé", f"{mttr:.1f} h" if mttr else "N/A")
+            with res3:
+                st.metric("Confiance IA", f"{confiance*100:.1f} %")
+
+            # ALERTES CONTEXTUELLES V4
+            if "À qualifier" in categorie:
+                st.warning("⚠️ **VÉRIFICATION :** Routage manuel nécessaire (Confiance trop faible).")
+            elif "Business & Ventes" in categorie:
+                st.success("💰 **COMMERCE :** Ticket orienté vers le pôle Business (Impact CA).")
+            elif "Data & Finance" in categorie:
+                st.info("📊 **DATA :** Analyse de flux financiers ou reporting BI requis.")
+            elif "Opérations & Support" in categorie:
+                st.error("🚨 **OPS & RUN :** Incident sur les flux techniques ou le support RUN.")
+
+    st.info("💡 **Note :** Cette version 3-pôles réduit le bruit et augmente la précision du routage automatique.")
+    st.sidebar.caption("🟢 Container Status: Healthy (Port 7860)")

requirements.txt

@@ -0,0 +1,18 @@
+# --- Base ---
+streamlit
+pandas
+numpy
+scikit-learn
+
+# --- TALN (Ordre spécifique pour éviter les conflits) ---
+huggingface-hub
+tokenizers
+transformers
+torch
+spacy
+gradio_client
+fastapi
+uvicorn
+
+# --- Modèle SpaCy ---
+https://github.com/explosion/spacy-models/releases/download/fr_core_news_sm-3.7.0/fr_core_news_sm-3.7.0.tar.gz

setup.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+
+# Mise à jour de pip
+pip install --upgrade pip
+
+# Installation des dépendances du requirements.txt
+pip install -r requirements.txt
+
+# Téléchargement explicite du modèle SpaCy français
+python -m spacy download fr_core_news_sm

train_V3.py

@@ -0,0 +1,159 @@
+import pandas as pd
+import pickle
+import numpy as np
+import torch
+import os
+import csv
+from transformers import AutoTokenizer, AutoModel 
+from sklearn.base import BaseEstimator, TransformerMixin
+from sklearn.pipeline import Pipeline
+from sklearn.linear_model import LogisticRegression
+
+# 1. Sécurité pour les gros volumes de texte (évite les erreurs de lecture)
+csv.field_size_limit(10000000)
+
+# --- CLASSE D'EXTRACTION LLM (DISTILBERT) ---
+class LLMFeatureExtractor(BaseEstimator, TransformerMixin):
+    def __init__(self, model_name='distilbert-base-multilingual-cased', max_length=128, batch_size=32):
+        self.model_name = model_name
+        self.max_length = max_length
+        self.batch_size = batch_size # On traite par petits paquets
+        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+        self.model = AutoModel.from_pretrained(model_name).to("cpu")
+
+    def fit(self, X, y=None):
+        return self
+
+    def transform(self, X):
+        texts = [str(t)[:1000] for t in X]
+        all_embeddings = []
+        
+        # Traitement par lots pour économiser la RAM
+        for i in range(0, len(texts), self.batch_size):
+            batch_texts = texts[i : i + self.batch_size]
+            inputs = self.tokenizer(
+                batch_texts, 
+                padding=True, 
+                truncation=True, 
+                max_length=self.max_length, 
+                return_tensors="pt"
+            ).to("cpu")
+            
+            with torch.no_grad():
+                outputs = self.model(**inputs)
+                # On récupère les embeddings et on les remet sur CPU/Numpy
+                embeddings = outputs.last_hidden_state[:, 0, :].detach().numpy()
+                all_embeddings.append(embeddings)
+            
+            if i % 512 == 0:
+                print(f"⏳ Progression : {i}/{len(texts)} tickets vectorisés...")
+
+        return np.vstack(all_embeddings)
+    
+    
+# --- CONFIGURATION V3 ---
+# Liste tes deux fichiers d'export ici
+FICHIERS_ENTREE = ["Tickets_1.csv", "Tickets_2.csv"] 
+NOM_MODELE_GENERE = "modele_classification_taln_llm.pkl"
+NOM_MTTR_GENERE = "mttr_moyennes.pkl"
+
+def normaliser(texte):
+    """ Nettoyage pour matcher les colonnes peu importe l'encodage """
+    return str(texte).strip().lower().replace('é', 'e').replace('è', 'e').replace('ê', 'e')
+
+def map_pole_expertise(groupe):
+    """ Regroupement sémantique en 3 pôles majeurs pour optimiser l'apprentissage """
+    g = str(groupe).upper()
+    
+    # Pôle 1 : COMMERCE & BUSINESS (Le plus gros volume)
+    if "COMMERCE" in g:
+        return "Business & Ventes"
+    
+    # Pôle 2 : DATA & FINANCE (Gestion de la donnée et des chiffres)
+    elif any(keyword in g for keyword in ["DATA", "BI", "FINANCE"]):
+        return "Data & Finance"
+    
+    # Pôle 3 : OPS & SUPPORT (Maintenance et flux techniques)
+    elif any(keyword in g for keyword in ["RUN", "OPCON", "FLUX", "AUTOMATE"]):
+        return "Opérations & Support"
+    
+    else:
+        return "AUTRES"
+
+def lancer_entrainement_v3():
+    print(f"🚀 Initialisation du Pipeline V3...")
+    
+    # 1. CHARGEMENT ET FUSION DES DEUX SOURCES
+    liste_df = []
+    for f in FICHIERS_ENTREE:
+        if os.path.exists(f):
+            try:
+                temp_df = pd.read_csv(f, sep=None, engine='python', encoding='utf-8-sig')
+                liste_df.append(temp_df)
+                print(f"📖 Chargé : {f} ({len(temp_df)} lignes)")
+            except Exception as e:
+                print(f"⚠️ Erreur sur {f} : {e}")
+    
+    if not liste_df:
+        print("❌ Aucun fichier trouvé. Vérifiez les noms des CSV.")
+        return
+
+    df = pd.concat(liste_df, ignore_index=True)
+    print(f"🔗 Fusion réussie : {len(df)} tickets consolidés.")
+
+    # 2. DÉTECTION DES COLONNES
+    mapping = {normaliser(c): c for c in df.columns}
+    col_desc = mapping.get('description')
+    col_grp = mapping.get('groupe')
+    col_mttr = next((c for norm, c in mapping.items() if 'delai' in norm or 'resolution' in norm), None)
+
+    if not all([col_desc, col_grp]):
+        print(f"❌ Colonnes 'Description' ou 'Groupe' introuvables. Colonnes vues : {list(mapping.keys())}")
+        return
+
+    # 3. NETTOYAGE ET MAPPING DES CLASSES
+    df = df.dropna(subset=[col_desc, col_grp])
+    df = df.drop_duplicates(subset=[col_desc]) # Supprime les doublons pour un meilleur apprentissage
+    df['categorie'] = df[col_grp].apply(map_pole_expertise)
+    
+    print(f"🧹 Nettoyage terminé : {len(df)} tickets uniques.")
+
+    # 4. CALCUL DU MTTR DYNAMIQUE
+    if col_mttr:
+        def convertir_en_heures(val):
+            try:
+                if ":" in str(val): # Gestion format HH:MM:SS
+                    p = str(val).split(':')
+                    return float(p[0]) + float(p[1])/60 + float(p[2])/3600
+                return float(val) # Gestion format décimal
+            except: return np.nan
+
+        df['mttr_h'] = df[col_mttr].apply(convertir_en_heures)
+        # On ignore les valeurs aberrantes (ex: tickets restés ouverts 2 ans)
+        df_mttr = df[df['mttr_h'] < 1500].dropna(subset=['mttr_h'])
+        
+        mttr_moyennes = df_mttr.groupby('categorie')['mttr_h'].mean().to_dict()
+        with open(NOM_MTTR_GENERE, 'wb') as f:
+            pickle.dump(mttr_moyennes, f)
+        print(f"📊 Référentiel MTTR généré pour {len(mttr_moyennes)} pôles.")
+
+    # 5. ENTRAÎNEMENT HYBRIDE (LLM + LOGISTIC REGRESSION)
+    print("🧠 Entraînement DistilBERT en cours (cela peut prendre quelques minutes)...")
+    X = df[col_desc].astype(str)
+    y = df['categorie']
+
+    pipeline = Pipeline([
+        ('feature_extractor', LLMFeatureExtractor()),
+        ('classifier', LogisticRegression(max_iter=1000, solver='lbfgs', multi_class='multinomial'))
+    ])
+
+    pipeline.fit(X, y)
+
+    # 6. SAUVEGARDE FINALE
+    with open(NOM_MODELE_GENERE, 'wb') as f:
+        pickle.dump(pipeline, f)
+    
+    print(f"✨ MISSION V3 RÉUSSIE ! Modèle et MTTR sauvegardés.")
+
+if __name__ == "__main__":
+    lancer_entrainement_v3()