import streamlit as st import streamlit.components.v1 as components import pandas as pd import pickle import numpy as np import plotly.graph_objects as go import plotly.figure_factory as ff from custom_functions import plot_auc, plot_f1_score, plot_loss_curve , plot_precision_curve from custom_functions import plot_CM_ConvnextBase, plot_CM_ConvnextTiny, plot_CM_DenseNet201, plot_CM_DenseNetFT, plot_CM_EfficientNet_B4, plot_CM_ENetB4, plot_CM_ResNet121, plot_CM_ResNetFT, plot_CM_ResNetV2,plot_CM_VGG16,plot_CM_VGG16_FT,plot_CM_VGG19 with open("models/history_DenseNet201.pkl", "rb") as file1: history_densenet = pickle.load(file1) with open("models/history_VGG16.pkl", "rb") as file2: history_vgg = pickle.load(file2) def show_fine_tuning(): # Style des onglets st.markdown(""" """, unsafe_allow_html = True) tab0, tab1, tab2, tab3, tab4, tab5 = st.tabs(["📚 Rappels Deep Learning", "🛠️ Preprocessing", "📈 Modélisation", "🧰 Suivi des métriques", "💻 Modèles testés", "🤖 Modèles finaux"]) #--------------------------------------------------------------------- # Les deux fonctions suivantes pour centrer les images dans les pages # fonction qui coverti une image en foramt bytes def img_to_bytes(img_path): import base64 from pathlib import Path img_bytes = Path(img_path).read_bytes() encoded = base64.b64encode(img_bytes).decode() return encoded # fonction qui coverti l'image encoder en html def img_to_html(img_path): img_html = "".format(img_to_bytes(img_path) ) return img_html #--------------------------------------------------------------------- ### Onglet 0 : Présentation d'un CNN with tab0: st.header("Deep Learning & CNN") st.write("#### 1. Réseaux de neurones artificiels") st.markdown(''' Un réseau de neurones est un ensemble de couches constitués de **Perceptrons**. Ce entité de base cherche à **imiter le fonctionnement d'un neurones biologique** grâce à des concepts mathématiques notamment le produits scalaires.\n Un Perceptron effectue des calculs pour détecter des caractéristiques ou des tendances dans les données d’entrée.\n Un réseau neuronal *'**Feed-Forward**'* est constitué de plusieurs perceptron à couches multiples. ''') #st.image(r".\images\neurone-biologique-et-artificiel.png", caption='Un neurone biologique vs un Perceptron (neurone artificiel)') # chemin du fichier de l'image image_path = r"images/ann_bnn_no_bg.png" # afficher l'image centrée avec markdown st.markdown("

" + img_to_html(image_path) + "

", unsafe_allow_html=True) # La légende de l'image st.markdown("
Un neurone biologique vs un Perceptron (neurone artificiel)
", unsafe_allow_html=True) # Séparateur ligne st.header("", divider = "gray") st.write("#### 2. Convolutional Neural Network (CNN)") st.markdown(''' Les réseaux de neurones convolutifs désignent une sous-catégorie de réseaux de neurones : ils présentent donc toutes les mêmes caractéristiques d'un réseau de neurones. Cependant, les CNN sont spécialement conçus pour traiter des images en entrée.\n Leur architecture est alors plus spécifique : elle est composée de deux blocs principaux: un extracteur de caractéristiques ou partie convolutive *'**features extraction bloc**'*, et un bloc pour la classification.\n La partie convolutive est constitué des couches suivantes: - Convolution : en utilisant des **filtres** et le **produit de convolution**, les caractéristiques de l'image d'entrée sont extraites. - Pooling : méthode de sous échantillonnage, l'objectif est de sous-échantillonner l'entrée en réduisant sa dimension. L'intérêt est la réduction du coût de calcul **en réduisant le nombre de paramètres à apprendre**. les deux méthodes les plus utilisées sont: le **Max-Pooling** (valeur maximum) et l'**Average Pooling** (valeur moyenne). ''') #st.image(r".\images\layers_CNN.png", caption="Architecture d'un réseau de neurones convolutifs CNN") image_path = r"images/layers_cnn_no_bg.png" # afficher l'image centrée avec markdown st.markdown("

" + img_to_html(image_path) + "

", unsafe_allow_html=True) # La légende de l'image st.markdown("
Architecture d'un réseau de neurones convolutifs CNN
", unsafe_allow_html=True) # Démonstration avec l'application de reconnaissance de chiffres st.write("##### Démonstration en direct : fonctionnement d'un CNN") st.link_button("DEMO Chiffre écrit à la main", "https://adamharley.com/nn_vis/cnn/3d.html") # Intégration de la page html de démonstation CNN dans la page streamlit components.iframe("https://adamharley.com/nn_vis/cnn/3d.html", height=700) ### Premier onglet with tab1: st.header("Preprocessing des images") st.write("#### 1. Metadata des images") st.markdown(''' Une étape très importante de notre projet est l'attention portée au traitement des images d'entrée. Nous avons pu voir précédemment que les images possèdent pour certaines, des dimensions et/ou un nombre de canaux différents. Il est important d'homogénéiser l'ensemble des paramètres de nos images pour assurer une bonne performance de nos modèles, et surtout, des résultats comparables. Les éléments en question sont : - Une dimension homogène et carrée, par défaut 299x299 pixels. - Un nombre de trois canaux de couleur. - Une normalisation de la valeur des pixels.\n Une fonction `preproc_img()` est conçue pour simplifier ces étapes, améliorer la reproductibilité et faciliter les ajustements. Elle retourne automatiquement les **ensembles d'entraînement et de test**. ''') # Séparateur ligne st.header("", divider = "gray") st.write("#### 2. Fonctions de pre-processing") # Style CSS pour listes à puces internes st.markdown(''' ''', unsafe_allow_html = True) # Définir le code comme une chaîne de caractères longue code = """ def preproc_img(df_images, df_masks, n_img, normalize, files_path, resolution, with_masks): np.random.seed(42) # Gestion des erreurs if resolution[2] != 1 and resolution[2] != 3: return print("Le nombre de canaux doit être de 1 (en nuances de gris) ou de 3 (en couleur)") if resolution[0] != resolution[1]: return print("La largeur de l'image doit être la même que sa hauteur.") if normalize != 'imagenet' and normalize != 'simple': print(Attention : aucune normalisation n'a été appliquée. Utilisez 'imagenet' pour une normalisation standardisée selon le mode opératoire du set ImageNet ou 'simple' pour simplement normaliser la valeur des canaux entre 0 et 1.") df_images_selected_list = [] for label, group in df_images.groupby('LABEL'): n_samples = min(len(group), n_img) df_images_selected_list.append(group.sample(n=n_samples, replace=False)) df_images_selected = pd.concat(df_images_selected_list) images = [] # Initialiser une liste pour stocker les images prétraitées df_masks_selected = df_masks[df_masks['FILE_NAME'].isin(df_images_selected['FILE_NAME'])] if with_masks else None for i in range(len(df_images_selected)): img_path = df_images_selected[files_path].iloc[i] mask_path = df_masks_selected[files_path].iloc[i] if with_masks else None img = Image.open(img_path) # Charger l'image avec PIL img = img.convert("L") if resolution[2] == 1 else img.convert("RGB") img_resized = img.resize((resolution[0], resolution[1])) # Normalisation des valeurs des pixels if normalize == 'imagenet': img_normalized = np.array(img_resized) / 255.0 img_normalized -= np.array([0.485, 0.456, 0.406]) if resolution[2] == 3 else np.mean([0.485, 0.456, 0.406]) img_normalized /= np.array([0.229, 0.224, 0.225]) if resolution[2] == 3 else np.mean([0.229, 0.224, 0.225]) elif normalize == 'simple': img_normalized = img_resized / 255 else: img_normalized = img_resized images.append(img_normalized) data = np.array(images).reshape(-1, resolution[0], resolution[1], resolution[2]) target = df_images_selected['LABEL'] return data, target """ with st.expander("Voir le code de la fonction preproc_img()"): st.code(code, language = 'python') st.markdown('''Le processus de prétraitement des données consiste à uniformiser les données en les important via `OpenCV` avec `cv2.IMREAD_GRAYSCALE` et en les convertissant en uint8 pour économiser de la mémoire. Les images peuvent être redimensionnées à la résolution de notre choix, stockées sous forme d'arrays numpy. Une normalisation de l'intensité des pixels peut être appliquée selon les besoins et les attentes des modèles, et des méthodes d'équilibrage des classes comme l'undersampling ou l'oversampling peuvent être envisagées en raison de différences significatives dans leur répartition. Les premiers masques sont utilisés pour limiter la surface aux informations utiles, avec la possibilité de créer de nouveaux masques. ''') # Séparateur ligne st.header("", divider = "gray") st.write("#### 3. Encodage des labels") st.markdown(''' Dernière étape après nos images propres et normalisées, il est nécessaire de transformer nos labels multiclasses en entiers afin d'assurer la compatibilité avec une les modèles de classificiation. Cette étape nécessite seulement un traitement par **One Hot Encoding** grâce à `LabelEncoder()`. ''') data = { 'Classes': ['COVID', 'Lung_Opacity', 'Normal', 'Viral Pneumonia'], 'Numéros correspondants': [0, 1, 2, 3] } df = pd.DataFrame(data) # Convertir le dataframe en HTML avec les styles CSS html_table = df.to_html(index=False, justify='center', classes='styled-table') # Afficher le HTML dans Streamlit avec la largeur calculée st.markdown(f"
{html_table}
", unsafe_allow_html=True) ### Deuxième onglet with tab2: st.header("Démarche de modélisation") st.markdown("Nous nous sommes mis d'accord pour commencer par un modèle basique, en l'occurrence **LeNet5**, eafin de prendre en main la modélisation en Deep Learning. Ensuite, travailler avec des modèles plus complexes qui sont disponibles dans **Keras Applications**, nous avons fait du **transfert learning** à partir de ces modèles-là, en réentrainant les dernières couches sur notre base de données. Enfin, avec le module **Keras Tuner** nous avons pu ajuster plus finement nos modèles. ") # LeNet5 st.write("#### 1. LeNet5") st.markdown(''' LeNet est une structure de réseau neuronal convolutif proposée par LeCun et al. en 1998. En général, LeNet fait référence à LeNet-5 et est un réseau neuronal convolutif simple. Les réseaux neuronaux convolutifs sont une sorte de réseau neuronal feed-forward dont les neurones artificiels peuvent répondre à une partie des cellules environnantes dans la zone de couverture et donnent de bons résultats dans le traitement d'images à grande échelle. *Source: https://en.wikipedia.org/wiki/LeNet*. ''') #st.image(r".\images\LeNet5_architecture.png", caption="Architecture du LeNet5") # chemin du fichier de l'image image_path = r"images/LeNet5_architecture_no_bg.png" # afficher l'image centrée avec markdown st.markdown("

" + img_to_html(image_path) + "

", unsafe_allow_html=True) # La légende de l'image st.markdown("
Architecture du LeNet5
", unsafe_allow_html=True) st.write("##### Etudes paramétriques: nombre d'images et nombre d'Epochs") st.markdown(''' L'efficacité et la simplicité, du modèle LeNet5, nous ont permis de réaliser des études paramétriques assez rapidement afin de le nombre d'images et d'époques à partir desquels les performances du modèle n'évoluent plus. Ceci nous a permis d'économiser en temps et coût de calcul par la suite en utilisant des modèles plus complexes. ''') col1, col2 = st.columns([1, 1]) df = pd.read_csv(r"data/Lenet_nb_image.csv") df2 = pd.read_csv(r"data/Lenet_nb_epoque.csv") col1, col2 = st.columns(2) with col1 : fig = go.Figure() fig.add_trace(go.Scatter(x=df['nombre_images'], y=df['Precision max'], mode='lines+markers', name='Precision max', line=dict(color='lightblue'))) fig.add_trace(go.Scatter(x=df['nombre_images'], y=df['Precision max validation'], mode='lines+markers', name='Precision max validation', line=dict(color='salmon'))) fig.add_vline(x=1325, line=dict(color='red', width=1, dash='dash')) fig.update_layout(title="Courbe d’apprentissage du modèle LeNet-5 en fonction du nombre d’images utilisées", xaxis_title='Nombre d\'images', yaxis_title='Précision max', template='plotly_white', paper_bgcolor='rgba(0,0,0,0)', plot_bgcolor='rgba(0,0,0,0)', legend=dict(font=dict(color='white')), xaxis=dict(tickfont=dict(color='white')), yaxis=dict(tickfont=dict(color='white')), title_font=dict(color='white')) st.plotly_chart(fig) with col2: fig2 = go.Figure() fig2.add_trace(go.Scatter(x=df2['Nombre epoque'], y=df2['Precision max'], mode='lines+markers', name='Precision max', line=dict(color='lightblue'))) fig2.add_trace(go.Scatter(x=df2['Nombre epoque'], y=df2['Precision max validation'], mode='lines+markers', name='Precision max validation', line=dict(color='salmon'))) fig2.update_layout(title="Courbe d’apprentissage du modèle LeNet-5 en fonction du nombre d’époques", xaxis_title='Nombre d\'époque', yaxis_title='Précision max', template='plotly_white', paper_bgcolor='rgba(0,0,0,0)', plot_bgcolor='rgba(0,0,0,0)', legend=dict(font=dict(color='white')), xaxis=dict(tickfont=dict(color='white')), yaxis=dict(tickfont=dict(color='white')), title_font=dict(color='white')) st.plotly_chart(fig2) st.markdown(''' Par la suite, nous entrainons les modèles avec les paramètres suivants : - 900 images par classe. - 20 epochs. ''') # Séparateur ligne st.header("", divider = "gray") # 2. Keras Tuner st.write("#### 2. Keras Tuner") st.markdown(''' Keras Tuner est un module qui permet de réaliser une étude d’optimisation des hyperparamètres afin de trouver les meilleures combinaisons de paramètres, permettant d’ajuster un peu plus finement le modèle (O’Malley et al., 2019).\n Il existe plusieurs fonctions intéressantes pour la recherche de paramètres optimaux pour un ajustement plus fin des modèles. RandomSearch() est très pratique pour chercher de manière aléatoire ces hyperparamètres optimaux, elle prend en argument le modèle, la métrique à maximiser, les paramètres à faire varier, etc. ''') # Définir le code comme une chaîne de caractères longue code = """ # 1. Définir une fonction qui construit le modèle avec les HP def build_model(hp): model = keras.Sequential() model.add(layers.Flatten()) # Tune the number of layers. for i in range(hp.Int("num_layers", 1, 3)): model.add( layers.Dense( # Tune number of units separately. units=hp.Int(f"units_{i}", min_value=32, max_value=512, step=32), activation=hp.Choice("activation", ["relu", "tanh"]), ) ) if hp.Boolean("dropout"): model.add(layers.Dropout(rate=0.25)) model.add(layers.Dense(10, activation="softmax")) learning_rate = hp.Float("lr", min_value=1e-4, max_value=1e-2, sampling="log") model.compile( optimizer=keras.optimizers.Adam(learning_rate=learning_rate), loss="categorical_crossentropy", metrics=["accuracy"], ) return model build_model(keras_tuner.HyperParameters()) # 2. RandomSearch pour chercher les meilleurs combinaison d'hyperparamètres tuner = keras_tuner.RandomSearch( hypermodel=build_model, objective="val_accuracy", max_trials=3, executions_per_trial=2, overwrite=True, directory="my_dir", project_name="helloworld", ) """ with st.expander("Voir le code de KerasTuner"): st.code(code, language = 'python') # séparer les sections avec une ligne st.header("", divider = "gray") # 3. Transfer Learning st.write("#### 3. Transfer Learning") st.markdown(''' Le transfer learning est une technique en apprentissage automatique où un modèle pré-entraîné sur une tâche est réutilisé comme point de départ pour résoudre une autre tâche similaire. Plutôt que de construire un nouveau modèle à partir de zéro, on exploite les connaissances et les représentations déjà apprises (les poids), ce qui permet d'améliorer l'apprentissage sur des ensembles de données plus petits ou différents. ''') # Critères de pré-sélectionnement des modèles testés st.write("###### - Critères de présélection") data = {'Critères': ['Taille du modèle (MB)', 'Accuracy (Top1/Top5)', 'Nombre de paramètres (millions)', 'Temps de calcul CPU/GPU (ms)']} df = pd.DataFrame(data) # Convertir le dataframe en HTML avec les styles CSS html_table = df.to_html(index=False, justify='center', classes='styled-table') # Afficher le HTML dans Streamlit avec la largeur calculée st.markdown(f"
{html_table}
", unsafe_allow_html=True) # Tableau qui résume les modèles choisis pour le Transfer Learning st.write("###### - Modèles présélectionnés") data = { 'Modèle': ['InceptionResNet', 'ResNet', 'DenseNet', 'VGG', 'ConvNext', 'EfficientNet'], 'Versions': ['InceptionResNetV2', 'ResNet121V2', 'DenseNet201', 'VGG16, VGG19', 'ConvNextBase, ConvNextTiny', 'EfficientNetB0, EfficientNetB1, EfficientNetB2, EfficientNetB3, EfficientNetB4, EfficientNetB5, EfficientNetB6'] } df = pd.DataFrame(data) # Convertir le dataframe en HTML avec les styles CSS html_table = df.to_html(index=False, justify='center', classes='styled-table') # Afficher le HTML dans Streamlit avec la largeur calculée st.markdown(f"
{html_table}
", unsafe_allow_html=True) ### Troisième onglet with tab3: st.header("Suivi des métriques") st.markdown(''' Dans le domaine du deep learning appliqué à la santé, l'évaluation des modèles joue un rôle crucial pour mesurer leur performance et leur pertinence clinique. Les métriques utilisées fournissent des informations essentielles sur la capacité du modèle à généraliser à de nouvelles données et à fournir des prédictions précises et fiables. ''') col1, col2 = st.columns(2) with col1: st.subheader("Précision (accuracy)") st.markdown(''' La précision est l'une des métriques les plus fondamentales en deep learning. Elle mesure la proportion de prédictions correctes parmi toutes les prédictions effectuées par le modèle. Bien qu'elle soit souvent utilisée comme mesure globale de performance, elle peut être trompeuse dans le contexte médical lorsque les classes sont déséquilibrées. Par exemple, dans le diagnostic médical, où les cas positifs sont rares par rapport aux cas négatifs, une haute précision peut être obtenue simplement en prédisant toujours la classe majoritaire (négative), ce qui masquerait l'incapacité du modèle à détecter les cas positifs. ''') st.subheader("F1 Score") st.markdown(''' Le score F1 est une mesure qui combine à la fois la précision et la sensibilité en un seul nombre. Il est particulièrement utile lorsque le déséquilibre entre les classes est important, car il prend en compte à la fois les faux positifs et les faux négatifs. Dans le domaine médical, où les conséquences des erreurs de prédiction peuvent être graves, le score F1 est souvent préféré pour évaluer la performance des modèles de diagnostic et de détection des maladies. ''') with col2: st.subheader("Sensibilité et Spécificité") st.markdown(''' La sensibilité (recall) mesure la capacité du modèle à identifier correctement les cas positifs parmi tous les cas réellement positifs. Elle est particulièrement importante dans les applications médicales où la détection précoce des anomalies ou des maladies est cruciale. D'un autre côté, la spécificité mesure la capacité du modèle à identifier correctement les cas négatifs parmi tous les cas réellement négatifs. Ensemble, la sensibilité et la spécificité fournissent une image plus complète de la capacité du modèle à discriminer entre les classes et à minimiser les faux positifs et les faux négatifs. ''') st.subheader("Courbe ROC et aire sous la courbe (RAC-AUC)") st.markdown(''' La courbe ROC (Receiver Operating Characteristic) est un graphique qui représente la performance d'un modèle de classification à différents seuils de classification. Elle compare la sensibilité (taux de vrai positif) au taux de faux positif (1 - spécificité) à différents seuils de décision. L'aire sous la courbe (AUC) ROC quantifie la capacité du modèle à discriminer entre les classes et fournit une mesure agrégée de sa performance. Dans le contexte médical, une AUC élevée indique une capacité de diagnostic élevée et une meilleure capacité à séparer les classes. ''') with tab4: col00, col01, col02 = st.columns([0.4, 0.2,0.4]) with col01 : Slider = st.select_slider(" ", options = ["Transfer learning" , "Fine Tuning"]) categorie = {"Transfer learning" :["Modèles testés","InceptionResNetV2","ResNet121V2","DenseNet201","VGG16", "VGG19","ConvNextTiny","ConvNextBase","EfficientNet B4"], "Fine Tuning" : ["EfficientNet", "ResNet", "VGG16_ft" ,"DenseNet"]} Choice_cr = st.selectbox("Navigation", options = categorie[Slider]) csv_path_cr = {"Modèles testés" :r"data/df test model.csv", "InceptionResNetV2" :r"data/df InceptionRes.csv", "ResNet121V2" : r"data/df Res.csv", "DenseNet201": r"data/df densenet.csv", "VGG16" : r"data/df VGG16.csv", "VGG19" : r"data/df VGG19.csv", "ConvNextTiny" : r"data/df Convtiny.csv", "ConvNextBase" : r"data/df Convbase.csv", "EfficientNet B4" :r"data/df efficient.csv", "EfficientNet" :r"data/df efficientnet finetuned.csv", "ResNet" :r"data/df resnet finetuned.csv", "VGG16_ft" :r"data/df VGG16_finetuned.csv", "DenseNet" :r"data/df densenet_finetuned.csv"} comm_dico = {"Modèles testés" :"""
Voici un récapitulatif des modèles que nous avons testés dans le cadre du transfer learning.
Nous avons poursuivi ensuite le fine-tuning avec la répartition suivante.
""", "InceptionResNetV2" :""" """ , "ResNet121V2" :""" """ , "DenseNet201":""" """ , "VGG16" : """ """, "VGG19" : """ """, "ConvNextTiny" : """ """, "ConvNextBase": """ """, "EfficientNet B4": """ """, "EfficientNet": """ """, "ResNet": """ """, "VGG16_ft": """ """, "DenseNet": """ """ } CM_dico = {"Modèles testés" :"", "InceptionResNetV2" :plot_CM_ResNetV2, "ResNet121V2" : plot_CM_ResNet121, "DenseNet201": plot_CM_DenseNet201, "VGG16" : plot_CM_VGG16, "VGG19" : plot_CM_VGG19, "ConvNextTiny" : plot_CM_ConvnextTiny, "ConvNextBase" : plot_CM_ConvnextBase, "EfficientNet B4" :plot_CM_EfficientNet_B4, "EfficientNet" :plot_CM_ENetB4, "ResNet" :plot_CM_ResNetFT, "VGG16_ft" :plot_CM_VGG16_FT, "DenseNet" :plot_CM_DenseNetFT} df = pd.read_csv(csv_path_cr[Choice_cr]) df= df.fillna("") # Convertir le dataframe en HTML avec les styles CSS html_table = df.to_html(index=False, justify='center', classes='styled-table') # Définir le style CSS pour centrer l'affichage du DataFrame et le fond css_style = """ """ # Ajouter le style CSS à la balise div styled_html_table = f"
{html_table}
" col1, col2 = st.columns(2) with col1: st.markdown(css_style, unsafe_allow_html=True) st.markdown(styled_html_table, unsafe_allow_html=True) cola ,colb, colc = st.columns([0.2,0.6,0.2]) with colb: if Choice_cr != "Modèles testés": CM_dico[Choice_cr]() with col2: css_style_text = """ """ st.markdown(css_style_text, unsafe_allow_html=True) st.markdown(f"
{comm_dico[Choice_cr]}
", unsafe_allow_html=True) ### Cinquième onglet with tab5: best_hp = {"VGG16" : """ - Dernière couche dense : 1024 neurones - Dropout : 0 - Learningrate : 10e-4 """, "DenseNet" : """ - Dernière couche dense : 256 neurones (Regularisation L2 : 0.01) - Dropout : 0.4, - Learning rate : 10e-4 """} Col1 , Col2 = st.columns(2) with Col1: st.header("VGG16 métriques") plot_precision_curve(history_vgg) plot_loss_curve(history_vgg) plot_auc(history_vgg) plot_f1_score(history_vgg) st.markdown(best_hp['VGG16']) with Col2: st.header("DenseNet métriques") plot_precision_curve(history_densenet) plot_loss_curve(history_densenet) plot_auc(history_densenet) plot_f1_score(history_densenet) st.markdown(best_hp["DenseNet"])