import json import gradio as gr import spaces from backbone_utils import extract_all_features, get_cached_features from classical_ml_utils import train_classical_model from data_utils import dataset_overview, get_class_names, get_images_for_gallery from predict_utils import predict_uploaded_image, test_random_sample from train_utils import ( evaluate_saved_model, list_saved_models, model_meta_path, saved_model_file_path, train_cnn, train_mlp, ) # --------------------------------------------------------------------------- # Tab 1 — Dataset # --------------------------------------------------------------------------- def load_dataset_callback(): try: summary, distribution_df = dataset_overview() class_names = ["Toutes les classes"] + get_class_names() return summary, distribution_df, gr.update(choices=class_names, value="Toutes les classes") except Exception as e: return {"Erreur": str(e)}, None, gr.update() def refresh_gallery_callback(split_name, class_name, max_images): try: return get_images_for_gallery(split_name, class_name, int(max_images)) except Exception as e: return [(None, f"Erreur : {e}")] # --------------------------------------------------------------------------- # Tab 2 — MLP (baseline) # --------------------------------------------------------------------------- def mlp_gpu_duration( num_layers, hidden_dim, dropout, learning_rate, weight_decay, batch_size, epochs, model_tag, request: gr.Request, ): # Calibré sur deux exécutions réelles : # 2 couches, hidden_dim=256, epochs=30 -> 66.6s (2.22 s/époque) # 5 couches, hidden_dim=1024, epochs=50 -> 140.8s (2.82 s/époque) # Le jeu de données est minuscule (peu de pas par époque) : le temps est # dominé par un overhead fixe, hidden_dim ne le fait varier que doucement # (x4 sur hidden_dim -> seulement +27% par époque). On plafonne à 180s : # nettement sous le quota journalier d'un compte gratuit (300s), pour # qu'un seul entraînement au pire réglage ne consomme pas tout le quota # du jour d'un·e étudiant·e. per_epoch = 2.22 + 0.0008 * max(0, int(hidden_dim) - 256) estimated = 15 + per_epoch * int(epochs) return min(180, max(45, int(estimated * 1.4))) @spaces.GPU(duration=mlp_gpu_duration) def train_mlp_callback( num_layers, hidden_dim, dropout, learning_rate, weight_decay, batch_size, epochs, model_tag, request: gr.Request, ): try: session_id = request.session_hash result = train_mlp( session_id=session_id, num_layers=int(num_layers), hidden_dim=int(hidden_dim), dropout=float(dropout), learning_rate=float(learning_rate), weight_decay=float(weight_decay), batch_size=int(batch_size), epochs=int(epochs), model_tag=model_tag, ) models = list_saved_models(session_id) selected = result["model_name"] if result["model_name"] in models else None return ( result["logs"], result["history"], result["summary"], result["classification_report"], result["confusion_matrix"], result["confusion_matrix_path"], result["loss_curve_path"], gr.update(choices=models, value=selected), ) except Exception as e: return f"Échec de l'entraînement :\n{e}", None, None, None, None, None, None, gr.update() # --------------------------------------------------------------------------- # Tab 3 — SimpleCNN # --------------------------------------------------------------------------- def cnn_gpu_duration( num_conv_blocks, base_filters, kernel_size, use_batchnorm, dropout, fc_dim, learning_rate, weight_decay, batch_size, epochs, model_tag, request: gr.Request, ): # Calibré sur deux exécutions réelles : # 3 blocs, filtres=32, noyau=3, epochs=30 -> 65.3s (2.18 s/époque) # 5 blocs, filtres=128, noyau=5, epochs=50 -> 153.9s (3.08 s/époque) # Le nombre de paramètres varie de ~130x entre ces deux essais mais le temps # par époque seulement de 40% : sur ce jeu de données minuscule, le coût est # dominé par un overhead fixe (chargement/augmentation), pas par les FLOPs # du réseau — le nombre de paramètres surestimerait donc très largement. # On interpole plutôt sur un score d'architecture simple. Plafond 180s : # nettement sous le quota journalier d'un compte gratuit (300s). score = int(num_conv_blocks) * int(base_filters) * (int(kernel_size) / 3) baseline_score, worst_score = 96.0, 1066.7 frac = max(0.0, min(1.0, (score - baseline_score) / (worst_score - baseline_score))) per_epoch = 2.18 + 0.9 * frac estimated = 15 + per_epoch * int(epochs) return min(180, max(45, int(estimated * 1.4))) @spaces.GPU(duration=cnn_gpu_duration) def train_cnn_callback( num_conv_blocks, base_filters, kernel_size, use_batchnorm, dropout, fc_dim, learning_rate, weight_decay, batch_size, epochs, model_tag, request: gr.Request, ): try: session_id = request.session_hash result = train_cnn( session_id=session_id, num_conv_blocks=int(num_conv_blocks), base_filters=int(base_filters), kernel_size=int(kernel_size), use_batchnorm=bool(use_batchnorm), dropout=float(dropout), fc_dim=int(fc_dim), learning_rate=float(learning_rate), weight_decay=float(weight_decay), batch_size=int(batch_size), epochs=int(epochs), model_tag=model_tag, ) models = list_saved_models(session_id) selected = result["model_name"] if result["model_name"] in models else None return ( result["logs"], result["history"], result["summary"], result["classification_report"], result["confusion_matrix"], result["confusion_matrix_path"], result["loss_curve_path"], gr.update(choices=models, value=selected), ) except Exception as e: return f"Échec de l'entraînement :\n{e}", None, None, None, None, None, None, gr.update() # --------------------------------------------------------------------------- # Tab 4 — Backbone + ML classique # --------------------------------------------------------------------------- # Mesuré : 352 images -> <10s. 30s laisse une marge x3 sans bloquer # l'admission ZeroGPU quand il ne reste que peu de quota au visiteur. @spaces.GPU(duration=30) def extract_features_callback(): try: _, class_names, counts = extract_all_features() lines = [f"Extraction terminée — {len(class_names)} classes détectées"] for split, n in counts.items(): lines.append(f" • {split} : {n} images → {n} vecteurs de 512 dimensions") return "\n".join(lines) except Exception as e: return f"Erreur lors de l'extraction :\n{e}" def on_clf_type_change(clf_type): show = lambda t: gr.update(visible=(clf_type == t)) return show("SVM"), show("Régression logistique"), show("k-NN"), show("Forêt aléatoire") def train_classical_callback( clf_type, svm_c, logreg_c, knn_k, rf_n_estimators, use_cv, model_tag, request: gr.Request, ): try: session_id = request.session_hash features_cache = get_cached_features() if features_cache is None: return ( {"Erreur": "Veuillez d'abord extraire les caractéristiques (bouton ci-dessus)."}, None, None, None, gr.update(), ) params = {} if clf_type == "SVM": params = {"C": float(svm_c)} elif clf_type == "Régression logistique": params = {"C": float(logreg_c)} elif clf_type == "k-NN": params = {"n_neighbors": int(knn_k)} elif clf_type == "Forêt aléatoire": params = {"n_estimators": int(rf_n_estimators)} class_names = get_class_names() result = train_classical_model( clf_type, features_cache, class_names, session_id, model_tag=model_tag, use_cv=bool(use_cv), **params ) models = list_saved_models(session_id) selected = result["model_name"] if result["model_name"] in models else None return ( result["summary"], result["classification_report"], result["confusion_matrix"], result["confusion_matrix_path"], gr.update(choices=models, value=selected), ) except Exception as e: return {"Erreur": str(e)}, None, None, None, gr.update() # --------------------------------------------------------------------------- # Tab 5 — Tester et analyser # --------------------------------------------------------------------------- def refresh_models_callback(request: gr.Request): models = list_saved_models(request.session_hash) return gr.update(choices=models, value=models[0] if models else None) def get_model_info_callback(model_name, request: gr.Request): if not model_name: return {"message": "Aucun modèle sélectionné."} try: with open(model_meta_path(model_name, request.session_hash), "r", encoding="utf-8") as f: return json.load(f) except FileNotFoundError: return {"message": "Métadonnées introuvables."} def download_model_callback(model_name, request: gr.Request): if not model_name: return None try: return saved_model_file_path(model_name, request.session_hash) except FileNotFoundError: return None # Une seule passe forward sur le jeu de test (53 images) sur un modèle bien # plus léger que le backbone ResNet18 (mesuré <10s sur 352 images) : quelques # secondes réelles. 30s de marge, pas 120s, pour ne pas bloquer l'admission # ZeroGPU quand il reste peu de quota au visiteur. @spaces.GPU(duration=30) def evaluate_callback(model_name, request: gr.Request): try: summary, report_df, cm_df, cm_path = evaluate_saved_model(model_name, request.session_hash) return summary, report_df, cm_df, cm_path except Exception as e: return {"Erreur": str(e)}, None, None, None # Une seule image, inférence pure. 20s de marge (chargement du modèle inclus). @spaces.GPU(duration=20) def predict_callback(model_name, image, request: gr.Request): try: return predict_uploaded_image(model_name, image, request.session_hash) except Exception as e: return f"Échec :\n{e}", None # Une seule image, inférence pure. 20s de marge (chargement du modèle inclus). @spaces.GPU(duration=20) def random_test_callback(model_name, request: gr.Request): try: return test_random_sample(model_name, request.session_hash) except Exception as e: return None, f"Échec :\n{e}", None # --------------------------------------------------------------------------- # UI # --------------------------------------------------------------------------- with gr.Blocks(title="Classification d'images microscopiques") as demo: gr.Markdown("# Classification d'images microscopiques de charbons de bois") gr.Markdown( "Ce parcours pédagogique suit une progression en quatre étapes : " "**exploration des données**, **MLP de référence**, **CNN entraîné de zéro**, " "puis **exploitation d'un backbone préentraîné avec des algorithmes classiques**. " "L'objectif est de comprendre pourquoi la structure convolutive et l'apprentissage par " "transfert sont si puissants, surtout quand les données sont rares." ) with gr.Tabs(): # ------------------------------------------------------------------ # # Tab 1 — Explorer le dataset # ------------------------------------------------------------------ # with gr.Tab("1. Explorer le jeu de données"): gr.Markdown("## Comprendre le problème avant de modéliser") gr.Markdown( "Avant de choisir un modèle, il est essentiel de comprendre la structure du jeu de données. " "Combien de classes ? Combien d'images par classe ? Les classes sont-elles équilibrées ? " "Ces questions conditionnent directement les choix de modélisation." ) load_dataset_btn = gr.Button("Charger les informations du dataset", variant="primary") dataset_summary = gr.JSON(label="Résumé général") class_distribution = gr.Dataframe( label="Distribution des images par split et par classe", interactive=False ) gr.Markdown( "## Visualiser les images\n" "Parcourez des exemples d'images pour vous familiariser avec les données. " "Notez que les images microscopiques de charbons de bois peuvent être " "visuellement très similaires d'une espèce à l'autre — ce qui rend la tâche difficile." ) with gr.Row(): split_selector = gr.Dropdown( choices=["train", "validation", "test"], value="train", label="Split" ) class_selector = gr.Dropdown( choices=["Toutes les classes"], value="Toutes les classes", label="Classe" ) max_images = gr.Slider(minimum=4, maximum=48, value=24, step=4, label="Nombre d'images") refresh_gallery_btn = gr.Button("Afficher des exemples") image_gallery = gr.Gallery(label="Exemples d'images", columns=4, height=600) # ------------------------------------------------------------------ # # Tab 2 — MLP (modèle de référence) # ------------------------------------------------------------------ # with gr.Tab("2. MLP (modèle de référence)"): gr.Markdown("## Un premier réseau de neurones : le perceptron multicouche") gr.Markdown( "Avant d'introduire un CNN, commençons par le modèle le plus simple : un **MLP** " "(perceptron multicouche), entièrement connecté. Chaque image est aplatie en un long " "vecteur de pixels — le réseau ne sait donc rien de la structure spatiale de l'image " "(voisinage des pixels, formes, textures locales).\n\n" "**Contexte du problème :** notre jeu de données contient 39 espèces, " "avec seulement 8 images par espèce en moyenne, réparties en train / validation / test.\n\n" "**Ce que cet exercice doit montrer :** observez les courbes de perte train vs validation. " "À partir de quelle époque la courbe de validation cesse de s'améliorer (ou remonte) " "pendant que la perte d'entraînement continue de baisser ? C'est le signe du surapprentissage. " "Essayez de faire varier le nombre de couches et le nombre de neurones par couche : " "vous constaterez que le surapprentissage apparaît quel que soit le choix — " "un MLP n'exploite pas la structure de l'image et ne peut pas s'en affranchir. " "C'est cette limite qui motive le passage au CNN." ) with gr.Row(): with gr.Column(): gr.Markdown("#### Architecture du MLP") mlp_num_layers = gr.Slider( minimum=1, maximum=4, value=2, step=1, label="Nombre de couches cachées", ) mlp_hidden_dim = gr.Dropdown( choices=[64, 128, 256, 512], value=256, label="Neurones par couche cachée", ) gr.Markdown("#### Hyperparamètres d'entraînement") mlp_dropout = gr.Slider( minimum=0.0, maximum=0.8, value=0.4, step=0.05, label="Dropout", ) mlp_lr = gr.Number(value=1e-3, label="Taux d'apprentissage") mlp_wd = gr.Number(value=1e-4, label="Weight decay (régularisation L2)") mlp_bs = gr.Dropdown(choices=[8, 16, 32, 64], value=16, label="Taille du batch") mlp_epochs = gr.Slider( minimum=1, maximum=50, value=30, step=1, label="Nombre d'époques" ) mlp_tag = gr.Textbox( label="Nom du modèle", placeholder="ex. mlp_2couches_256" ) train_mlp_btn = gr.Button("Lancer l'entraînement", variant="primary") with gr.Column(): mlp_logs = gr.Textbox(label="Journal d'entraînement", lines=20) mlp_history = gr.JSON(label="Historique époque par époque") mlp_summary = gr.JSON(label="Résumé final") gr.Markdown("## Courbes de perte (train vs validation)") mlp_loss_curve = gr.Image(label="Perte par époque", type="filepath") gr.Markdown("## Résultats sur le jeu de test") mlp_report = gr.Dataframe(label="Rapport de classification", interactive=False) mlp_cm = gr.Dataframe(label="Matrice de confusion", interactive=False) mlp_cm_img = gr.Image(label="Matrice de confusion — figure", type="filepath") # ------------------------------------------------------------------ # # Tab 3 — SimpleCNN de zéro # ------------------------------------------------------------------ # with gr.Tab("3. CNN entraîné de zéro"): gr.Markdown("## Entraîner un réseau convolutif sans connaissances préalables") gr.Markdown( "Le MLP de l'onglet précédent surapprend quels que soient les hyperparamètres choisis : " "il ne peut pas exploiter la structure spatiale des images. Construisons maintenant un " "réseau de neurones convolutif (CNN), conçu pour capter des motifs locaux (contours, " "textures) grâce aux filtres de convolution, et entraînons-le directement sur nos données " "de charbons de bois. Ce réseau part de paramètres aléatoires : il ne sait rien des images " "au départ.\n\n" "**Contexte du problème :** notre jeu de données contient 39 espèces, " "avec seulement 8 images par espèce en moyenne. " "C'est extrêmement peu pour apprendre à distinguer 39 classes visuellement similaires.\n\n" "Jouez avec les paramètres d'architecture et d'entraînement pour observer leur effet " "sur les performances. Essayez notamment d'augmenter la complexité du réseau " "et observez ce qui se passe." ) with gr.Row(): with gr.Column(): gr.Markdown("#### Architecture du CNN") num_conv_blocks = gr.Slider( minimum=2, maximum=4, value=3, step=1, label="Blocs convolutionnels", info="Chaque bloc enchaîne Conv2d → BatchNorm → ReLU → MaxPool. Plus de blocs = réseau plus profond.", ) base_filters = gr.Dropdown( choices=[16, 32, 64], value=32, label="Filtres du premier bloc", info="Le nombre de filtres double à chaque bloc. 32 → 64 → 128...", ) kernel_size = gr.Dropdown( choices=[3, 5], value=3, label="Taille du noyau de convolution", info="3×3 capte les détails fins, 5×5 capte des structures plus larges.", ) use_batchnorm = gr.Checkbox( value=True, label="Normalisation par lots (BatchNorm)", info="Stabilise l'entraînement et accélère la convergence.", ) gr.Markdown("#### Hyperparamètres d'entraînement") cnn_dropout = gr.Slider( minimum=0.0, maximum=0.8, value=0.4, step=0.05, label="Dropout", info="Désactive aléatoirement des neurones pour limiter le surapprentissage.", ) cnn_fc_dim = gr.Dropdown( choices=[64, 128, 256, 512], value=256, label="Dimension de la couche cachée", ) cnn_lr = gr.Number(value=1e-3, label="Taux d'apprentissage") cnn_wd = gr.Number(value=1e-4, label="Weight decay (régularisation L2)") cnn_bs = gr.Dropdown(choices=[8, 16, 32, 64], value=16, label="Taille du batch") cnn_epochs = gr.Slider( minimum=1, maximum=50, value=30, step=1, label="Nombre d'époques" ) cnn_tag = gr.Textbox( label="Nom du modèle", placeholder="ex. cnn_3blocs_32filtres" ) train_cnn_btn = gr.Button("Lancer l'entraînement", variant="primary") with gr.Column(): cnn_logs = gr.Textbox(label="Journal d'entraînement", lines=20) cnn_history = gr.JSON(label="Historique époque par époque") cnn_summary = gr.JSON(label="Résumé final") gr.Markdown("## Courbes de perte (train vs validation)") cnn_loss_curve = gr.Image(label="Perte par époque", type="filepath") gr.Markdown("## Résultats sur le jeu de test") cnn_report = gr.Dataframe(label="Rapport de classification", interactive=False) cnn_cm = gr.Dataframe(label="Matrice de confusion", interactive=False) cnn_cm_img = gr.Image(label="Matrice de confusion — figure", type="filepath") # ------------------------------------------------------------------ # # Tab 4 — Backbone préentraîné + ML classique # ------------------------------------------------------------------ # with gr.Tab("4. Backbone préentraîné + ML classique"): gr.Markdown("## Exploiter les connaissances d'un modèle préentraîné") gr.Markdown( "Face aux limites observées avec le MLP et le CNN de zéro (peu de données, beaucoup de " "classes), une stratégie radicalement différente consiste à réutiliser un réseau déjà " "entraîné sur d'autres images, et à s'appuyer sur les représentations qu'il a apprises.\n\n" "### Qu'est-ce qu'un backbone ?\n" "Un **backbone** est un réseau convolutif dont on retire la couche de classification finale. " "Il agit comme un extracteur de caractéristiques : pour chaque image en entrée, " "il produit un vecteur de nombres (ici **512 dimensions**) qui encode le contenu visuel " "de l'image de façon compacte et abstraite.\n\n" "### Quel backbone utilisons-nous ici ?\n" "Nous utilisons un **ResNet18 avec ses poids ImageNet d'origine, sans aucun fine-tuning** " "sur nos images de charbons de bois. Ce modèle a été préentraîné sur ImageNet " "(1,2 million d'images, 1 000 classes) — il n'a jamais vu une image de charbon de bois. " "L'objectif est d'observer si des représentations apprises sur des images naturelles " "génériques transfèrent malgré tout à un domaine très différent (microscopie).\n\n" "### Pourquoi des algorithmes classiques ensuite ?\n" "Une fois les images transformées en vecteurs de 512 dimensions, " "n'importe quel algorithme de classification classique peut être appliqué. " "Ces algorithmes (SVM, régression logistique, k-NN, forêt aléatoire) sont rapides à entraîner, " "interprétables, et ne nécessitent pas de GPU. " "Pour chaque algorithme, un seul hyperparamètre est ajustable — les autres réglages " "sont fixés pour rester comparables. Une option de validation croisée permet en plus " "d'estimer la stabilité du score sur le train set. " "Comparez leurs résultats avec ceux obtenus aux étapes précédentes (MLP, CNN)." ) gr.Markdown("## Étape 1 — Extraction des caractéristiques") gr.Markdown( "Passez toutes les images du jeu de données dans le backbone. " "Chaque image est convertie en un vecteur de 512 valeurs. " "Cette opération est réalisée une seule fois et mise en cache." ) extract_btn = gr.Button( "Extraire les caractéristiques (backbone gelé)", variant="primary" ) extract_status = gr.Textbox(label="Statut", lines=5, interactive=False) gr.Markdown("## Étape 2 — Entraîner un classifieur sur les caractéristiques") gr.Markdown( "Choisissez un algorithme et ajustez ses paramètres. " "L'entraînement est quasi-instantané car il opère sur des vecteurs, " "sans jamais manipuler les images brutes ni utiliser le GPU." ) with gr.Row(): with gr.Column(): clf_type = gr.Radio( choices=["SVM", "Régression logistique", "k-NN", "Forêt aléatoire"], value="SVM", label="Algorithme de classification", ) with gr.Column(visible=True) as svm_col: gr.Markdown("#### Paramètre SVM (noyau RBF, gamma='scale' fixés)") svm_c = gr.Number( value=1.0, label="C — force de régularisation", info="Une valeur faible regularise davantage (marges plus larges).", ) with gr.Column(visible=False) as logreg_col: gr.Markdown("#### Paramètre Régression logistique (max_iter=1000 fixé)") logreg_c = gr.Number(value=1.0, label="C — force de régularisation") with gr.Column(visible=False) as knn_col: gr.Markdown("#### Paramètre k-NN (distance euclidienne fixée)") knn_k = gr.Slider( minimum=1, maximum=20, value=5, step=1, label="k — nombre de voisins", info="k=1 mémorise les données, k élevé généralise davantage.", ) with gr.Column(visible=False) as rf_col: gr.Markdown("#### Paramètre Forêt aléatoire (profondeur illimitée fixée)") rf_n_estimators = gr.Slider( minimum=10, maximum=500, value=100, step=10, label="Nombre d'arbres" ) cv_checkbox = gr.Checkbox( value=False, label="Activer la validation croisée sur le train set", info="Ajoute un score F1 macro moyenné sur plusieurs folds, en plus du score sur le jeu de test.", ) ml_tag = gr.Textbox( label="Nom du modèle", placeholder="ex. svm_C1" ) train_classical_btn = gr.Button("Entraîner le classifieur", variant="primary") with gr.Column(): ml_summary = gr.JSON(label="Résumé des métriques") ml_report = gr.Dataframe(label="Rapport de classification", interactive=False) ml_cm = gr.Dataframe(label="Matrice de confusion", interactive=False) ml_cm_img = gr.Image(label="Matrice de confusion — figure", type="filepath") # ------------------------------------------------------------------ # # Tab 5 — Tester et analyser # ------------------------------------------------------------------ # with gr.Tab("5. Tester et analyser"): gr.Markdown("## Comparer et évaluer les modèles") gr.Markdown( "Tous les modèles entraînés dans les onglets précédents apparaissent ici — " "MLP, CNN de zéro comme classifieurs ML. " "Évaluez-les sur le jeu de test, prédisez la classe d'une image importée, " "et tirez vos conclusions sur l'apport du backbone préentraîné." ) with gr.Row(): with gr.Column(): model_selector = gr.Dropdown( choices=[], value=None, label="Modèle sauvegardé", info="Liste propre à votre session — les modèles des autres étudiant·e·s ne sont pas visibles ici.", ) refresh_btn = gr.Button("Actualiser la liste") load_info_btn = gr.Button("Afficher les informations du modèle") model_info = gr.JSON(label="Métadonnées du modèle") download_btn = gr.Button("Préparer le fichier à télécharger") model_download = gr.File( label="Fichier du modèle (poids .pt ou pipeline .joblib) — cliquez sur " "« Préparer le fichier à télécharger » puis sur la flèche de téléchargement ci-dessous", ) with gr.Column(): evaluate_btn = gr.Button("Évaluer sur le jeu de test", variant="primary") eval_summary = gr.JSON(label="Résumé des métriques") eval_report = gr.Dataframe(label="Rapport de classification", interactive=False) eval_cm = gr.Dataframe(label="Matrice de confusion", interactive=False) eval_cm_img = gr.Image(label="Matrice de confusion — figure", type="filepath") gr.Markdown("## Prédiction sur une image importée") gr.Markdown( "Importez une image microscopique de charbon de bois et observez " "comment les différents modèles la classifient." ) with gr.Row(): with gr.Column(): upload_image = gr.Image(type="pil", label="Image à classer") predict_btn = gr.Button("Prédire la classe", variant="primary") with gr.Column(): predict_text = gr.Textbox(label="Résultat de la prédiction", lines=7) predict_probs = gr.Label(label="Probabilités par classe") gr.Markdown("## Test sur un échantillon aléatoire du jeu de test") gr.Markdown( "Tirez une image au hasard dans le jeu de test et vérifiez si le modèle " "sélectionné la classe correctement." ) random_test_btn = gr.Button("Tirer un échantillon aléatoire") with gr.Row(): random_img = gr.Image(type="pil", label="Image tirée") random_text = gr.Textbox(label="Résultat", lines=7) random_probs = gr.Label(label="Probabilités par classe") # ---------------------------------------------------------------------- # # Event wiring # ---------------------------------------------------------------------- # load_dataset_btn.click( fn=load_dataset_callback, inputs=None, outputs=[dataset_summary, class_distribution, class_selector], ) refresh_gallery_btn.click( fn=refresh_gallery_callback, inputs=[split_selector, class_selector, max_images], outputs=image_gallery, ) train_mlp_btn.click( fn=train_mlp_callback, inputs=[ mlp_num_layers, mlp_hidden_dim, mlp_dropout, mlp_lr, mlp_wd, mlp_bs, mlp_epochs, mlp_tag, ], outputs=[ mlp_logs, mlp_history, mlp_summary, mlp_report, mlp_cm, mlp_cm_img, mlp_loss_curve, model_selector, ], ) train_cnn_btn.click( fn=train_cnn_callback, inputs=[ num_conv_blocks, base_filters, kernel_size, use_batchnorm, cnn_dropout, cnn_fc_dim, cnn_lr, cnn_wd, cnn_bs, cnn_epochs, cnn_tag, ], outputs=[ cnn_logs, cnn_history, cnn_summary, cnn_report, cnn_cm, cnn_cm_img, cnn_loss_curve, model_selector, ], ) extract_btn.click(fn=extract_features_callback, inputs=None, outputs=extract_status) clf_type.change( fn=on_clf_type_change, inputs=clf_type, outputs=[svm_col, logreg_col, knn_col, rf_col], ) train_classical_btn.click( fn=train_classical_callback, inputs=[ clf_type, svm_c, logreg_c, knn_k, rf_n_estimators, cv_checkbox, ml_tag, ], outputs=[ml_summary, ml_report, ml_cm, ml_cm_img, model_selector], ) refresh_btn.click(fn=refresh_models_callback, inputs=None, outputs=model_selector) load_info_btn.click( fn=get_model_info_callback, inputs=model_selector, outputs=model_info ) model_selector.change( fn=download_model_callback, inputs=model_selector, outputs=model_download ) download_btn.click( fn=download_model_callback, inputs=model_selector, outputs=model_download ) evaluate_btn.click( fn=evaluate_callback, inputs=model_selector, outputs=[eval_summary, eval_report, eval_cm, eval_cm_img], ) predict_btn.click( fn=predict_callback, inputs=[model_selector, upload_image], outputs=[predict_text, predict_probs], ) random_test_btn.click( fn=random_test_callback, inputs=model_selector, outputs=[random_img, random_text, random_probs], ) # Peuple la liste des modèles au chargement de la page, à partir de la # session du navigateur qui vient de se connecter (cf. refresh_models_callback). demo.load(fn=refresh_models_callback, inputs=None, outputs=model_selector) if __name__ == "__main__": demo.launch(ssr_mode=False)