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("""
🏭 Prédicteur État Financier Automobile

Application de machine learning pour l'évaluation automatique de la santé financière des entreprises automobiles

Hugging Face Spaces Gradio Python
""") # Configuration du modèle with gr.Row(): with gr.Column(scale=3): gr.Markdown("### ⚙️ Configuration du Modèle") gr.Markdown("Chargez votre modèle K-means (.joblib) ou utilisez le mode démonstration") with gr.Column(scale=2): model_file = gr.File( label="📂 Modèle K-means (.joblib)", file_types=[".joblib"], type="binary" ) model_status = gr.Textbox( label="📊 Statut du Modèle", value="🎮 Mode démonstration - Chargez un modèle pour des prédictions réelles", interactive=False ) # Chargement du modèle model_file.change( fn=charger_modele, inputs=[model_file], outputs=[gr.State(), model_status] ) # Tabs principales with gr.Tabs(): # Tab 1: Analyse Individuelle with gr.TabItem("📊 Analyse Individuelle"): gr.Markdown("### 🏢 Analyse d'une Entreprise") with gr.Row(): nom_entreprise = gr.Textbox( label="🏢 Nom de l'entreprise", value="AutoCorp Demo", placeholder="Saisissez le nom de l'entreprise" ) gr.Markdown("### 💰 Ratios Financiers") gr.Markdown("*Ajustez les ratios selon les données de votre entreprise. Les valeurs par défaut correspondent aux seuils de référence du secteur automobile.*") # Sous-tabs pour organiser les ratios with gr.Tabs(): with gr.TabItem("📈 Rentabilité"): with gr.Row(): rentabilite_economique = gr.Slider( label="🎯 Rentabilité Économique", minimum=-0.5, maximum=0.5, value=0.04, step=0.001, info="Seuil recommandé: 0.04 (4%)" ) rentabilite_financiere = gr.Slider( label="💰 Rentabilité Financière", minimum=-0.5, maximum=0.5, value=0.07, step=0.001, info="Seuil recommandé: 0.07 (7%)" ) with gr.Row(): taux_marge_nette = gr.Slider( label="📉 Taux de Marge Nette", minimum=-0.5, maximum=0.5, value=0.04, step=0.001, info="Seuil recommandé: 0.04 (4%)" ) roa = gr.Slider( label="🎢 ROA (Return on Assets)", minimum=-0.5, maximum=0.5, value=0.03, step=0.001, info="Seuil recommandé: 0.03 (3%)" ) with gr.Row(): roe = gr.Slider( label="🏆 ROE (Return on Equity)", minimum=-0.5, maximum=0.5, value=0.10, step=0.001, info="Seuil recommandé: 0.10 (10%)" ) marge_beneficiaire = gr.Slider( label="💎 Marge Bénéficiaire Nette", minimum=-0.5, maximum=0.5, value=0.05, step=0.001, info="Seuil recommandé: 0.05 (5%)" ) with gr.TabItem("💵 Liquidité"): with gr.Row(): liquidite_generale = gr.Slider( label="💧 Liquidité Générale", minimum=0.0, maximum=5.0, value=1.2, step=0.01, info="Seuil recommandé: 1.2" ) tresorerie_immediate = gr.Slider( label="💸 Trésorerie Immédiate", minimum=0.0, maximum=2.0, value=0.3, step=0.01, info="Seuil recommandé: 0.3" ) with gr.Row(): delai_clients = gr.Slider( label="⏰ Délai Règlement Clients (jours)", minimum=0, maximum=180, value=55, step=1, info="Seuil recommandé: 55 jours maximum" ) delai_fournisseurs = gr.Slider( label="🕐 Délai Règlement Fournisseurs (jours)", minimum=0, maximum=180, value=70, step=1, info="Seuil recommandé: 70 jours minimum" ) with gr.TabItem("🏦 Structure Financière"): with gr.Row(): autonomie_financiere = gr.Slider( label="🛡️ Autonomie Financière", minimum=0.0, maximum=1.0, value=0.35, step=0.01, info="Seuil recommandé: 0.35 (35%)" ) taux_endettement = gr.Slider( label="⚖️ Taux d'Endettement", minimum=0.0, maximum=5.0, value=1.4, step=0.01, info="Seuil recommandé: < 1.4 (140%)" ) with gr.Row(): gearing = gr.Slider( label="⚙️ Gearing", minimum=0.0, maximum=3.0, value=0.8, step=0.01, info="Seuil recommandé: < 0.8" ) solvabilite = gr.Slider( label="🏛️ Solvabilité Générale", minimum=0.0, maximum=5.0, value=1.5, step=0.01, info="Seuil recommandé: 1.5" ) with gr.Row(): couverture_interets = gr.Slider( label="🔒 Ratio Couverture des Intérêts", minimum=0.0, maximum=20.0, value=5.0, step=0.1, info="Seuil recommandé: 5.0" ) with gr.TabItem("⚡ Croissance"): with gr.Row(): croissance_ca = gr.Slider( label="📈 Croissance du CA", minimum=-0.5, maximum=0.5, value=0.03, step=0.001, info="Seuil recommandé: 0.03 (3%)" ) croissance_benefices = gr.Slider( label="💹 Croissance Bénéfice Net", minimum=-0.5, maximum=0.5, value=0.05, step=0.001, info="Seuil recommandé: 0.05 (5%)" ) with gr.Row(): per = gr.Slider( label="📊 PER (Price to Earnings)", minimum=0.0, maximum=50.0, value=15.0, step=0.1, info="Seuil recommandé: 15" ) pb = gr.Slider( label="📋 P/B (Price to Book)", minimum=0.0, maximum=10.0, value=1.5, step=0.01, info="Seuil recommandé: 1.5" ) # Bouton d'analyse analyze_btn = gr.Button("🔮 Analyser l'État Financier", variant="primary", size="lg") # Résultats with gr.Row(): with gr.Column(scale=1): resume_output = gr.Markdown(label="📋 Résumé de l'Analyse") recommandations_output = gr.Markdown(label="💡 Recommandations") with gr.Column(scale=1): radar_plot = gr.Plot(label="📊 Graphique Radar Comparatif") prob_plot = gr.Plot(label="📈 Probabilités par Cluster") # Rapport complet with gr.Accordion("📄 Rapport Complet", open=False): rapport_complet = gr.Markdown() # Connecter l'analyse analyze_btn.click( fn=analyser_entreprise_individuelle, inputs=[ nom_entreprise, rentabilite_economique, rentabilite_financiere, taux_marge_nette, roa, roe, marge_beneficiaire, liquidite_generale, tresorerie_immediate, delai_clients, delai_fournisseurs, autonomie_financiere, taux_endettement, gearing, solvabilite, couverture_interets, croissance_ca, croissance_benefices, per, pb ], outputs=[resume_output, radar_plot, prob_plot, recommandations_output, rapport_complet] ) # Tab 2: Analyse Batch with gr.TabItem("📈 Analyse Batch"): gr.Markdown("### 📤 Analyse de Fichier - Plusieurs Entreprises") gr.Markdown("Téléchargez un fichier CSV ou Excel contenant les ratios financiers de plusieurs entreprises pour une analyse comparative automatisée.") with gr.Row(): with gr.Column(scale=1): gr.Markdown("#### 📋 Template de Données") gr.Markdown("Téléchargez ce template CSV et remplissez-le avec vos données:") template_btn = gr.DownloadButton( label="📥 Télécharger Template CSV", value=creer_template_csv(), filename="template_analyse_batch.csv" ) gr.Markdown(""" **Format requis:** - 📄 Fichier CSV ou Excel - 🏢 Colonne obligatoire: `nom_entreprise` - 📊 Colonnes de ratios (voir template) - 📏 Maximum 100 entreprises """) with gr.Column(scale=1): fichier_batch = gr.File( label="📂 Sélectionner votre fichier", file_types=[".csv", ".xlsx"], type="filepath" ) analyze_batch_btn = gr.Button("🚀 Lancer l'Analyse Batch", variant="primary") # Résultats de l'analyse batch with gr.Row(): rapport_batch = gr.Markdown(label="📊 Rapport d'Analyse") distribution_plot = gr.Plot(label="📈 Distribution des États Financiers") with gr.Accordion("📥 Export des Résultats", open=False): csv_export = gr.File(label="📄 Télécharger Résultats CSV", visible=False) export_info = gr.Markdown("Les résultats apparaîtront ici après l'analyse.") # Connecter l'analyse batch def process_batch_with_export(fichier): rapport, fig, csv_data = analyser_fichier_batch(fichier) if csv_data: # Sauvegarder le CSV csv_file = tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.csv') csv_file.write(csv_data) csv_file.close() export_msg = "✅ **Résultats disponibles au téléchargement ci-dessous**" return rapport, fig, csv_file.name, export_msg else: return rapport, fig, None, "❌ Aucun résultat à exporter" analyze_batch_btn.click( fn=process_batch_with_export, inputs=[fichier_batch], outputs=[rapport_batch, distribution_plot, csv_export, export_info] ) # Tab 3: À Propos with gr.TabItem("ℹ️ À Propos"): gr.Markdown(""" ## 🎯 Prédicteur d'État Financier Automobile ### 🚀 Fonctionnalités Principales Cette application utilise des techniques avancées de **machine learning** pour évaluer automatiquement la santé financière des entreprises du secteur automobile. - **📊 Analyse Individuelle**: Évaluation détaillée d'une entreprise avec visualisations interactives - **📈 Analyse Batch**: Traitement de plusieurs entreprises simultanément via fichier CSV/Excel - **🧠 Modèle K-means**: Classification en 3 niveaux de santé financière - **🎨 Visualisations**: Graphiques radar et probabilités interactifs - **📋 Rapports Détaillés**: Recommandations personnalisées par cluster ### 🏷️ Classifications Financières - **🟢 Cluster 0 - Bonne Santé Financière**: Ratios supérieurs aux seuils, structure solide - **🟡 Cluster 1 - Santé Financière Moyenne**: Performance mitigée, points d'amélioration - **🔴 Cluster 2 - Santé Financière Fragile**: Ratios préoccupants, action immédiate requise ### 📊 Modèle de Machine Learning **Algorithme**: K-means Clustering non supervisé **Features**: 25+ ratios financiers pondérés **Preprocessing**: Normalisation StandardScaler + inversion des ratios négatifs **Performance**: > 85% de cohérence avec l'analyse manuelle ### 🔧 Stack Technique - **Interface**: Gradio + Plotly pour les visualisations - **ML**: Scikit-learn K-means, Pandas, NumPy - **Déploiement**: Hugging Face Spaces - **Format Modèle**: Joblib pour la sérialisation ### 📈 Ratios Analysés (Exemples) **Rentabilité**: ROA, ROE, Marge nette, Rentabilité économique **Liquidité**: Liquidité générale, Trésorerie, Délais clients/fournisseurs **Structure**: Autonomie financière, Endettement, Gearing, Solvabilité **Croissance**: Croissance CA/bénéfices, PER, P/B ### 🚨 Avertissements - 📊 **Usage Professionnel**: Outil d'aide à la décision, ne remplace pas une analyse d'expert - 🎯 **Secteur Automobile**: Seuils optimisés pour ce secteur spécifiquement - 🔄 **Validation**: Toujours valider avec des experts avant décisions importantes - ⚖️ **Responsabilité**: L'utilisateur reste responsable de ses décisions financières ### 📞 Support - 🐛 **Issues**: Signalez les bugs via GitHub - 💡 **Suggestions**: Proposez des améliorations - 📚 **Documentation**: Consultez le README du projet --- **Made with ❤️ for the Financial Analysis Community** *Powered by Hugging Face Spaces, Gradio & Scikit-learn* """) # Lancement de l'application if __name__ == "__main__": app.launch( share=True, server_name="0.0.0.0", server_port=7860, show_error=True )