import gradio as gr import pandas as pd import numpy as np import joblib import plotly.express as px import plotly.graph_objects as go from plotly.subplots import make_subplots import warnings import io import tempfile warnings.filterwarnings('ignore') # Configuration des seuils et ratios - Identiques à l'app Streamlit SEUILS_AUTOMOBILE = { 'autonomie_financière': 0.35, 'financement_des_immobilisations': 1.1, 'productivité': 450000, 'rentabilité_économique': 0.04, 'rentabilité_financière': 0.07, 'liquidité_générale': 1.2, 'taux_de_marge_nette': 0.04, "capacité_d'autofinancement": 0.06, "taux_d'endettement": 1.4, 'poids_des_frais_financiers': 0.035, 'délai_de_règlement_clients': 55, 'délai_de_règlement_fournisseurs': 70, 'besoin_en_fonds_de_roulement': 0.16, 'durée_de_rotation_des_stocks': 55, 'solvabilité_générale': 1.5, 'per': 15, 'pb': 1.5, 'peg': 1.0, 'rendement_des_capitaux_propres': 0.10, 'marge_bénéficiaire_nette': 0.05, 'roa': 0.03, 'capacité_de_remboursement': 4.0, 'gearing': 0.8, 'indépendance_financière': 0.40, 'ratio_de_couverture_des_intérêts': 5.0, 'croissance_du_ca': 0.03, 'croissance_du_bénéfice_net': 0.05, 'croissance_de_bpa': 0.05, 'rendement_du_dividende': 0.03, 'payout_ratio': 0.30, 'trésorerie_immédiate': 0.3 } RATIOS_POSITIFS = [ 'autonomie_financière', 'financement_des_immobilisations', 'productivité', 'rentabilité_économique', 'rentabilité_financière', 'liquidité_générale', 'taux_de_marge_nette', "capacité_d'autofinancement", 'solvabilité_générale', 'rendement_des_capitaux_propres', 'marge_bénéficiaire_nette', 'roa', 'indépendance_financière', 'ratio_de_couverture_des_intérêts', 'croissance_du_ca', 'croissance_du_bénéfice_net', 'croissance_de_bpa', 'rendement_du_dividende', 'trésorerie_immédiate' ] RATIOS_NEGATIFS = [ "taux_d'endettement", 'poids_des_frais_financiers', 'délai_de_règlement_clients', 'délai_de_règlement_fournisseurs', 'besoin_en_fonds_de_roulement', 'durée_de_rotation_des_stocks', 'per', 'pb', 'peg', 'capacité_de_remboursement', 'gearing', 'payout_ratio' ] POIDS_RATIOS = { 'autonomie_financière': 1.5, 'financement_des_immobilisations': 1.0, 'productivité': 0.8, 'rentabilité_économique': 1.8, 'rentabilité_financière': 1.7, 'liquidité_générale': 1.2, 'taux_de_marge_nette': 1.5, "capacité_d'autofinancement": 1.3, "taux_d'endettement": 1.6, 'poids_des_frais_financiers': 1.4, 'délai_de_règlement_clients': 0.9, 'délai_de_règlement_fournisseurs': 0.9, 'besoin_en_fonds_de_roulement': 1.2, 'durée_de_rotation_des_stocks': 1.0, 'solvabilité_générale': 1.4, 'per': 0.7, 'pb': 0.7, 'peg': 0.6, 'rendement_des_capitaux_propres': 1.6, 'marge_bénéficiaire_nette': 1.5, 'roa': 1.3, 'capacité_de_remboursement': 1.5, 'gearing': 1.5, 'indépendance_financière': 1.3, 'ratio_de_couverture_des_intérêts': 1.4, 'croissance_du_ca': 0.9, 'croissance_du_bénéfice_net': 1.1, 'croissance_de_bpa': 0.8, 'rendement_du_dividende': 0.7, 'payout_ratio': 0.7, 'trésorerie_immédiate': 1.2 } ETAT_FINANCIER = { 0: "Bonne santé financière", 1: "Santé financière moyenne", 2: "Santé financière fragile" } # Variables globales pour stocker le modèle global_model_data = None def charger_modele(model_file): """Charge le modèle K-means entraîné""" try: if model_file is None: return None, "Aucun modèle sélectionné" # Sauvegarder temporairement le fichier with tempfile.NamedTemporaryFile(delete=False, suffix='.joblib') as tmp_file: tmp_file.write(model_file) tmp_file.flush() model_data = joblib.load(tmp_file.name) global global_model_data global_model_data = model_data return model_data, "✅ Modèle chargé avec succès!" except Exception as e: return None, f"❌ Erreur lors du chargement: {e}" def preparer_donnees_prediction(donnees_entreprise, features, ratios_negatifs): """Prépare les données pour la prédiction""" # Créer DataFrame X = pd.DataFrame([donnees_entreprise]) # Ajouter les features manquantes avec valeurs par défaut for feature in features: if feature not in X.columns: if feature in SEUILS_AUTOMOBILE: X[feature] = SEUILS_AUTOMOBILE[feature] else: X[feature] = 0 # Sélectionner les features du modèle X = X[features] X = X.fillna(X.median()) # Inverser les ratios négatifs for ratio in ratios_negatifs: if ratio in X.columns: max_val = X[ratio].max() * 1.5 if X[ratio].max() > 0 else 1 X[ratio] = max_val - X[ratio] return X def predire_etat_financier(donnees_entreprise, model_data=None): """Fait une prédiction sur l'état financier""" try: if model_data is None: model_data = global_model_data if model_data is None: # Mode démonstration score_global = 0 ratios_evalues = 0 for ratio, valeur in donnees_entreprise.items(): if ratio in SEUILS_AUTOMOBILE: seuil = SEUILS_AUTOMOBILE[ratio] if ratio in RATIOS_NEGATIFS: score_global += 1 if valeur <= seuil else 0 else: score_global += 1 if valeur >= seuil else 0 ratios_evalues += 1 score_pct = (score_global / ratios_evalues * 100) if ratios_evalues > 0 else 50 if score_pct >= 70: cluster_demo = 0 confiance_demo = 75 + (score_pct - 70) / 30 * 20 elif score_pct >= 40: cluster_demo = 1 confiance_demo = 60 + (score_pct - 40) / 30 * 25 else: cluster_demo = 2 confiance_demo = 50 + score_pct / 40 * 25 return { 'cluster_predit': cluster_demo, 'etat_financier': ETAT_FINANCIER[cluster_demo], 'confiance': round(confiance_demo, 1), 'probabilites': { 'Bonne santé': 85.0 if cluster_demo == 0 else 15.0, 'Santé moyenne': 10.0 if cluster_demo == 0 else 75.0 if cluster_demo == 1 else 25.0, 'Santé fragile': 5.0 if cluster_demo == 0 else 10.0 if cluster_demo == 1 else 75.0 }, 'distance_au_centre': round(np.random.uniform(0.1, 0.8), 3), 'mode_demo': True } kmeans = model_data['kmeans'] scaler = model_data['scaler'] features = model_data['features'] # Préparer données X = preparer_donnees_prediction(donnees_entreprise, features, RATIOS_NEGATIFS) # Normaliser X_scaled = scaler.transform(X) # Appliquer pondération for i, feature in enumerate(features): if feature in POIDS_RATIOS: X_scaled[0, i] *= POIDS_RATIOS[feature] # Prédiction cluster = kmeans.predict(X_scaled)[0] etat = ETAT_FINANCIER[cluster] # Calcul confiance et probabilités distances = kmeans.transform(X_scaled)[0] distance_au_centre = distances[cluster] confiance = max(0, 1 - (distance_au_centre / np.max(distances))) * 100 probabilites = 1 / (distances + 0.1) probabilites = probabilites / np.sum(probabilites) * 100 return { 'cluster_predit': int(cluster), 'etat_financier': etat, 'confiance': round(confiance, 1), 'probabilites': { 'Bonne santé': round(probabilites[0], 1), 'Santé moyenne': round(probabilites[1], 1), 'Santé fragile': round(probabilites[2], 1) }, 'distance_au_centre': round(distance_au_centre, 3), 'mode_demo': False } except Exception as e: return {'erreur': f"Erreur lors de la prédiction: {e}"} def creer_graphique_radar(donnees_entreprise, nom_entreprise): """Crée un graphique radar comparatif""" ratios_importants = [ 'autonomie_financière', 'rentabilité_économique', 'rentabilité_financière', 'liquidité_générale', 'taux_de_marge_nette', "taux_d'endettement", 'poids_des_frais_financiers', 'roa', 'solvabilité_générale', 'gearing' ] entreprise_vals = [] seuils_vals = [] ratios_labels = [] for ratio in ratios_importants: if ratio in donnees_entreprise: val_entreprise = donnees_entreprise[ratio] val_seuil = SEUILS_AUTOMOBILE.get(ratio, 1) if ratio in RATIOS_NEGATIFS: val_norm_entreprise = val_seuil / val_entreprise if val_entreprise > 0 else 0 val_norm_seuil = 1 else: val_norm_entreprise = val_entreprise / val_seuil if val_seuil > 0 else 0 val_norm_seuil = 1 entreprise_vals.append(val_norm_entreprise) seuils_vals.append(val_norm_seuil) ratios_labels.append(ratio.replace('_', ' ').title()) fig = go.Figure() fig.add_trace(go.Scatterpolar( r=seuils_vals, theta=ratios_labels, fill='toself', name='Seuils de référence', line=dict(color='rgba(0,100,200,0.6)'), fillcolor='rgba(0,100,200,0.1)' )) fig.add_trace(go.Scatterpolar( r=entreprise_vals, theta=ratios_labels, fill='toself', name=nom_entreprise, line=dict(color='rgba(200,50,50,0.8)'), fillcolor='rgba(200,50,50,0.2)' )) fig.update_layout( polar=dict(radialaxis=dict(visible=True, range=[0, 2])), showlegend=True, title=f"Comparaison des ratios - {nom_entreprise}", height=450, font=dict(size=12) ) return fig def creer_graphique_probabilites(probabilites): """Crée un graphique en barres des probabilités""" fig = go.Figure(data=[ go.Bar( x=list(probabilites.keys()), y=list(probabilites.values()), marker_color=['#2ecc71', '#f39c12', '#e74c3c'], text=[f"{v}%" for v in probabilites.values()], textposition='auto', textfont=dict(size=14, color='white') ) ]) fig.update_layout( title="Probabilités d'appartenance aux clusters", xaxis_title="État financier", yaxis_title="Probabilité (%)", height=400, font=dict(size=12), showlegend=False ) return fig def analyser_entreprise_individuelle( nom_entreprise, # Ratios de rentabilité rentabilite_economique, rentabilite_financiere, taux_marge_nette, roa, roe, marge_beneficiaire, # Ratios de liquidité liquidite_generale, tresorerie_immediate, delai_clients, delai_fournisseurs, # Ratios de structure financière autonomie_financiere, taux_endettement, gearing, solvabilite, couverture_interets, # Ratios de croissance croissance_ca, croissance_benefices, per, pb ): """Fonction principale d'analyse individuelle""" # Construire le dictionnaire des données donnees_entreprise = { 'rentabilité_économique': rentabilite_economique, 'rentabilité_financière': rentabilite_financiere, 'taux_de_marge_nette': taux_marge_nette, 'roa': roa, 'rendement_des_capitaux_propres': roe, 'marge_bénéficiaire_nette': marge_beneficiaire, 'liquidité_générale': liquidite_generale, 'trésorerie_immédiate': tresorerie_immediate, 'délai_de_règlement_clients': delai_clients, 'délai_de_règlement_fournisseurs': delai_fournisseurs, 'autonomie_financière': autonomie_financiere, "taux_d'endettement": taux_endettement, 'gearing': gearing, 'solvabilité_générale': solvabilite, 'ratio_de_couverture_des_intérêts': couverture_interets, 'croissance_du_ca': croissance_ca, 'croissance_du_bénéfice_net': croissance_benefices, 'per': per, 'pb': pb } # Faire la prédiction resultats = predire_etat_financier(donnees_entreprise) if 'erreur' in resultats: return resultats['erreur'], None, None, "", "" # Générer les graphiques fig_radar = creer_graphique_radar(donnees_entreprise, nom_entreprise) fig_prob = creer_graphique_probabilites(resultats['probabilites']) # Générer le rapport textuel cluster = resultats['cluster_predit'] etat = resultats['etat_financier'] confiance = resultats['confiance'] # Emoji et couleur selon le cluster if cluster == 0: emoji = "🟢" couleur_html = "#28a745" recommandations = """ **🟢 Excellente Performance Financière !** 🎯 **Actions Recommandées :** - ✅ Maintenir les bonnes pratiques actuelles - 📈 Surveiller l'évolution du marché automobile - 💰 Considérer des investissements stratégiques - 🔍 Analyser les opportunités de croissance - 🏆 Partager les bonnes pratiques en interne """ elif cluster == 1: emoji = "🟡" couleur_html = "#ffc107" recommandations = """ **🟡 Performance Correcte - Optimisation Possible** ⚠️ **Actions Prioritaires :** - 📊 Identifier et améliorer les ratios sous-performants - 💵 Optimiser la gestion des liquidités - 🏦 Revoir la structure financière - 📈 Mettre en place un plan d'amélioration - 🔄 Surveillance mensuelle des indicateurs """ else: emoji = "🔴" couleur_html = "#dc3545" recommandations = """ **🔴 Situation Financière Critique - Action Immédiate Requise** 🚨 **Actions Urgentes :** - 🆘 Révision immédiate de la stratégie financière - 💸 Réduction prioritaire de l'endettement - 📉 Amélioration de la rentabilité opérationnelle - 🤝 Recherche de financement ou restructuration - 👥 Consultation d'experts financiers """ # Résumé principal resume = f""" # 📋 Analyse Financière - {nom_entreprise} ## {emoji} Résultat Principal **État Financier:** {etat} **Niveau de Confiance:** {confiance}% **Cluster:** {cluster} (0=Excellent, 1=Moyen, 2=Fragile) **Distance au centre:** {resultats['distance_au_centre']} {"**Mode Démonstration Activé** - Chargez un modèle .joblib pour des prédictions réelles" if resultats.get('mode_demo', False) else "**Prédiction basée sur le modèle K-means chargé**"} """ # Analyse détaillée des ratios analyse_ratios = "## 📊 Analyse Détaillée des Ratios\n\n" for ratio, valeur in donnees_entreprise.items(): if ratio in SEUILS_AUTOMOBILE: seuil = SEUILS_AUTOMOBILE[ratio] if ratio in RATIOS_NEGATIFS: statut = "✅ Conforme" if valeur <= seuil else "❌ À améliorer" ecart = ((valeur - seuil) / seuil * 100) if seuil != 0 else 0 else: statut = "✅ Conforme" if valeur >= seuil else "❌ À améliorer" ecart = ((valeur - seuil) / seuil * 100) if seuil != 0 else 0 analyse_ratios += f"**{ratio.replace('_', ' ').title()}:** {valeur:.3f} (seuil: {seuil:.3f}) - {statut} ({ecart:+.1f}%)\n\n" rapport_complet = resume + "\n" + recommandations + "\n\n" + analyse_ratios return resume, fig_radar, fig_prob, recommandations, rapport_complet def analyser_fichier_batch(fichier): """Analyse un fichier CSV/Excel avec plusieurs entreprises""" if fichier is None: return "Aucun fichier sélectionné", None, None try: # Lire le fichier if fichier.name.endswith('.csv'): df = pd.read_csv(fichier.name, encoding='utf-8') else: df = pd.read_excel(fichier.name) if 'nom_entreprise' not in df.columns: return "❌ Erreur: La colonne 'nom_entreprise' est obligatoire", None, None if len(df) > 100: df = df.head(100) warning_msg = "⚠️ Limitation à 100 entreprises pour optimiser les performances.\n\n" else: warning_msg = "" # Traitement des entreprises resultats_batch = [] for i, row in df.iterrows(): nom_entreprise = row.get('nom_entreprise', f'Entreprise_{i+1}') try: # Préparer les données de l'entreprise donnees_entreprise = row.drop('nom_entreprise').to_dict() donnees_entreprise = {k: v for k, v in donnees_entreprise.items() if pd.notna(v) and str(v).strip() != ''} # Prédiction resultats = predire_etat_financier(donnees_entreprise) if 'erreur' not in resultats: resultats['nom_entreprise'] = nom_entreprise resultats['nb_ratios_utilises'] = len(donnees_entreprise) resultats_batch.append(resultats) except Exception as e: continue if not resultats_batch: return "❌ Aucune entreprise n'a pu être analysée", None, None # Créer le DataFrame des résultats df_resultats = pd.DataFrame(resultats_batch) # Statistiques nb_total = len(df_resultats) nb_bonne = len(df_resultats[df_resultats['cluster_predit'] == 0]) nb_moyenne = len(df_resultats[df_resultats['cluster_predit'] == 1]) nb_fragile = len(df_resultats[df_resultats['cluster_predit'] == 2]) confiance_moyenne = df_resultats['confiance'].mean() # Rapport textuel rapport_batch = f""" {warning_msg}# 📈 Rapport d'Analyse Batch ## 📊 Statistiques Globales - **Total Entreprises Analysées:** {nb_total} - **🟢 Bonne Santé Financière:** {nb_bonne} ({nb_bonne/nb_total*100:.1f}%) - **🟡 Santé Financière Moyenne:** {nb_moyenne} ({nb_moyenne/nb_total*100:.1f}%) - **🔴 Santé Financière Fragile:** {nb_fragile} ({nb_fragile/nb_total*100:.1f}%) - **🎯 Confiance Moyenne:** {confiance_moyenne:.1f}% ## 🚨 Alertes """ # Entreprises en difficulté entreprises_fragiles = df_resultats[df_resultats['cluster_predit'] == 2] if len(entreprises_fragiles) > 0: rapport_batch += f"\n**🔴 {len(entreprises_fragiles)} entreprises nécessitent une attention immédiate:**\n" for _, row in entreprises_fragiles.head(5).iterrows(): rapport_batch += f"- {row['nom_entreprise']} (confiance: {row['confiance']:.1f}%)\n" # Entreprises excellentes entreprises_excellentes = df_resultats[df_resultats['cluster_predit'] == 0] if len(entreprises_excellentes) > 0: meilleure = entreprises_excellentes.loc[entreprises_excellentes['confiance'].idxmax()] rapport_batch += f"\n**🏆 Benchmark interne:** {meilleure['nom_entreprise']} (confiance: {meilleure['confiance']:.1f}%)" # Graphique de distribution fig_distribution = px.histogram( df_resultats, x='etat_financier', color='etat_financier', title="📈 Distribution des États Financiers", color_discrete_map={ 'Bonne santé financière': '#2ecc71', 'Santé financière moyenne': '#f39c12', 'Santé financière fragile': '#e74c3c' } ) fig_distribution.update_layout(showlegend=False, height=400) # Créer le CSV de résultats csv_output = df_resultats[['nom_entreprise', 'etat_financier', 'cluster_predit', 'confiance', 'nb_ratios_utilises']].to_csv(index=False) return rapport_batch, fig_distribution, csv_output except Exception as e: return f"❌ Erreur lors du traitement: {e}", None, None def creer_template_csv(): """Crée un template CSV pour l'analyse batch""" template_data = { 'nom_entreprise': ['AutoCorp_A', 'AutoCorp_B', 'AutoCorp_C'], 'autonomie_financière': [0.45, 0.25, 0.60], 'rentabilité_économique': [0.06, 0.02, 0.08], 'rentabilité_financière': [0.09, 0.03, 0.12], 'liquidité_générale': [1.8, 0.9, 2.1], 'taux_de_marge_nette': [0.07, 0.02, 0.09], "taux_d'endettement": [0.8, 2.5, 0.6], 'poids_des_frais_financiers': [0.02, 0.08, 0.015], 'roa': [0.05, 0.01, 0.07], 'solvabilité_générale': [2.0, 1.1, 2.5], 'gearing': [0.6, 1.2, 0.4] } template_df = pd.DataFrame(template_data) return template_df.to_csv(index=False) # CSS personnalisé pour Gradio css = """ .gradio-container { max-width: 1200px !important; margin: auto !important; } .main-header { text-align: center; color: #1f77b4; font-size: 2.5rem; margin-bottom: 1rem; background: linear-gradient(90deg, #667eea 0%, #764ba2 100%); -webkit-background-clip: text; -webkit-text-fill-color: transparent; background-clip: text; } .metric-box { background-color: #f8f9fa; padding: 1rem; border-radius: 0.5rem; border-left: 4px solid #1f77b4; margin: 0.5rem 0; } .success-box { background-color: #d4edda; border-color: #28a745; color: #155724; } .warning-box { background-color: #fff3cd; border-color: #ffc107; color: #856404; } .danger-box { background-color: #f8d7da; border-color: #dc3545; color: #721c24; } """ # Interface Gradio principale with gr.Blocks(css=css, title="🏭 Prédicteur État Financier Automobile", theme=gr.themes.Soft()) as app: # En-tête gr.HTML("""
Application de machine learning pour l'évaluation automatique de la santé financière des entreprises automobiles