Spaces:
Runtime error
Runtime error
Download app.py from JaagYS/clustering: direct link, hf CLI and curl.
- Browser
- Download file 39.1 kB
-
https://huggingface.co/spaces/JaagYS/clustering/resolve/main/app.py
- Command line
-
hf download hf://spaces/JaagYS/clustering/app.py
-
curl -L -o app.py https://huggingface.co/spaces/JaagYS/clustering/resolve/main/app.py
39.1 kB
| 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(""" | |
| <div class="main-header"> | |
| 🏭 Prédicteur État Financier Automobile | |
| </div> | |
| <div style="text-align: center; margin-bottom: 2rem;"> | |
| <p style="font-size: 1.2rem; color: #666;"> | |
| Application de machine learning pour l'évaluation automatique de la santé financière des entreprises automobiles | |
| </p> | |
| <div style="margin: 1rem 0;"> | |
| <img src="https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Spaces-blue" alt="Hugging Face Spaces"> | |
| <img src="https://img.shields.io/badge/Gradio-Interface-orange" alt="Gradio"> | |
| <img src="https://img.shields.io/badge/Python-3.9+-green" alt="Python"> | |
| </div> | |
| </div> | |
| """) | |
| # 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 | |
| ) | |