Add own test py file

own_test.py

@@ -0,0 +1,437 @@
+import streamlit as st
+from PIL import Image, ImageOps
+import tensorflow as tf
+import keras
+import os
+import numpy as np
+import pandas as pd
+import time
+import cv2
+os.environ["KERAS_BACKEND"] = "tensorflow"
+
+from custom_functions import make_gradcam_heatmap, save_and_display_gradcam
+from keras.layers import Conv2D
+from tensorflow.keras.preprocessing.image import img_to_array, array_to_img
+from keras.models import load_model
+
+#modele prédiction COVID
+model_densenet = tf.keras.models.load_model("models/DenseNet201_finetuned.h5")
+model_vgg = tf.keras.models.load_model("models/VGG16_finetuned.h5")
+model_tri = tf.keras.models.load_model("models/filtermodel.h5")
+model = None
+
+def show_test():
+
+    # Style des onglets
+    st.markdown("""
+        <style>
+            .stTabs [data-baseweb="tab-list"] {
+                display: flex;
+                gap: 10px;
+            }
+
+            .stTabs [data-baseweb="tab"] {
+                padding: 10px 15px;
+                border: 1px solid transparent;
+                border-radius: 5px 5px 0 0;
+                background-color: transparent;
+                cursor: pointer;
+                transition: all 0.3s ease;
+            }
+
+            .stTabs [data-baseweb="tab"]:hover {
+                background-color: #8f8d9b;
+            }
+
+            .stTabs [aria-selected="true"] {
+                background-color:  #57546a;
+                border-color: #ccc;
+                border-bottom-color: transparent;
+            }
+        </style>""", unsafe_allow_html = True)
+
+    tab1, tab2, tab3 = st.tabs(["👀 Analyse de la GRAD-CAM", "🚀 Réaliser des prédictions", "⚖️ Qualités et limites"])
+
+    with tab1:
+        st.header("Analyse de la GRAD-CAM")
+
+        col1, col2 = st.columns([0.6, 0.4])
+
+        with col1:
+            st.markdown('''
+            Le GRAD-CAM est une technique de visualisation : elle est utile pour comprendre quelles parties d'une image donnée ont conduit un réseau de neurones convolutifs à sa décision finale de classification.
+
+            Elle est utile pour déboguer le processus de décision d'un algorithme, en particulier dans le cas d'une erreur de classification.
+
+            Cette technique provient d'une catégorie plus générale de procédés appelée visualisation de __Class Activation Map__ (CAM).
+
+            Elle consiste à produire des heatmaps représentant les classes d'activation sur les images d'entrée. Une __class activation heatmap__ est associée à une classe de sortie spécifique.
+
+            Ces classes sont calculées pour chaque pixel d'une image d'entrée, indiquant l'importance de chaque pixel par rapport à la classe considérée.
+
+            Par exemple, si une image est utilisée dans un convnet chiens/chats, la visualisation CAM permet de générer une carte thermique pour la classe « chat », indiquant à quel point les différentes parties de l'image ressemblent à un chat, et également une carte thermique pour la classe « chien », indiquant à quel point les parties de l'image ressemblent à un chien.
+                        ''')
+
+        with col2:
+            gradcam = Image.open('images\illustration_gradcam.jpeg')
+            st.image(gradcam, use_column_width = True, caption = "Illustration de la feature-map sur une image de chien")
+
+    with tab2:
+        st.header("Réaliser des prédictions")
+        # Configuration initiale de l'état de session
+        if 'model_selected' not in st.session_state:
+            st.session_state.model_selected = None
+        if 'model_loaded' not in st.session_state:
+            st.session_state.model_loaded = None
+
+        col1, col2, col3 = st.columns([0.3, 0.4, 0.3])
+
+        with col1:
+            st.session_state.model_selected = st.selectbox(
+                "Quel modèle utiliser ?",
+                ("DenseNet201", "VGG16"),
+                index=None,
+                placeholder="Choisissez un modèle..."
+            )
+            if st.session_state.model_selected == "DenseNet201":
+                st.write("Modèle le plus performant, mais aussi le plus lourd.")
+                st.session_state.model_loaded = 'DenseNet201'
+            elif st.session_state.model_selected == "VGG16":
+                st.write("Modèle le plus équilibré.")
+                st.session_state.model_loaded = 'VGG16'
+
+        with col2:
+            if st.session_state.model_selected == "DenseNet201" and st.session_state.model_loaded == 'DenseNet201':
+                model = model_densenet
+                st.success('👏 Modèle DenseNet201 chargé et prêt à prédire !')
+            elif st.session_state.model_selected == "VGG16" and st.session_state.model_loaded == 'VGG16':
+                model = model_vgg
+                st.success('👏 Modèle VGG16 chargé et prêt à prédire !')
+
+        with col3:
+            if st.button('Réinitialiser le modèle', type = 'primary', key = 321):
+                keys_to_delete = ['model_selected', 'model_loaded', 'file_uploaded']
+                for key in keys_to_delete:
+                    if key in st.session_state:
+                        del st.session_state[key]
+                        st.experimental_rerun()
+
+        st.header("", divider = 'gray')
+
+        col1, col2 = st.columns([0.6, 0.4])
+
+        with col1:
+            file_container = st.empty()
+            uploaded_file = file_container.file_uploader("", type=['png', 'jpg', 'jpeg'])
+
+        if uploaded_file and st.session_state.model_selected is not None:
+            with col2:
+                st.write('')
+                st.write('')
+                #original = Image.open(uploaded_file)
+                bar_progress = 0
+                my_bar = st.progress(bar_progress, text = "Ouverture de l'image...")
+                time.sleep(0.5)
+                bar_progress = 10
+                my_bar.progress(bar_progress, text = "Réalisation du preprocessing...")
+        
+        if (uploaded_file is not None) and (st.session_state.model_selected is not None):
+
+            file_bytes = np.asarray(bytearray(uploaded_file.read()), dtype=np.uint8)
+            image = cv2.imdecode(file_bytes, cv2.IMREAD_COLOR)
+            resized_image = cv2.resize(image, (224, 224))
+            resized_image = resized_image/255
+            to_predict = np.expand_dims(resized_image, axis=0)
+            tri_image = model_tri.predict(to_predict)
+
+            if tri_image <= 0.5:
+
+                # Ouvrir l'image téléchargée
+                original = Image.open(uploaded_file)        
+
+                # Image traitée
+                gray_image = original.convert('L')
+                channelized = gray_image.convert("RGB")
+                resized = channelized.resize((224, 224))
+                img_normalized = np.array(resized) / 255.0  # Convertir l'image en array et normaliser entre 0 et 1
+                img_normalized -= np.array([0.485, 0.456, 0.406])  # Soustraction de la moyenne par canal
+                img_normalized /= np.array([0.229, 0.224, 0.225])  # Division par l'écart-type par canal
+                img_normalized = img_normalized.reshape(-1, 224, 224, 3)  # Remodeler pour correspondre aux attentes du modèle (batch_size, height, width, channels
+                
+                bar_progress = 30
+                my_bar.progress(bar_progress, text = "Estimation des prédictions...")
+                time.sleep(0.5)
+                predictions = model.predict(img_normalized)
+                bar_progress = 70
+                my_bar.progress(bar_progress, text = "Génération de la GRAD-CAM...")
+                time.sleep(0.5)
+                    
+                col1, col2, col3 = st.columns([0.3, 0.4, 0.3])
+
+                def normalize_display_image(img_normalized):
+                    img_display = (img_normalized * np.array([0.229, 0.224, 0.225])) + np.array([0.485, 0.456, 0.406])
+                    img_display = np.clip(img_display, 0, 1)
+                    img_display = (img_display * 255).astype(np.uint8)
+                    return img_display
+
+                if original.width > 500:
+                    width = 500
+                else:
+                    width = original.width
+
+                with col1:
+                    st.subheader("Image originale")
+                    st.image(original, use_column_width = False, width = width, clamp = True)
+                    st.warning("Image redimensionnée pour des raisons d'affichage.", icon = "⚠️") if original.width > 500 else None
+
+                with col2:
+                    st.subheader("Image traitée")
+                    st.image(img_normalized, use_column_width = False, clamp = True)
+
+                with col3:
+                    st.subheader("GRAD-CAM")
+                    # Préparation de l'image pour GRAD-CAM sans dimension de batch
+                    heatm_img = np.squeeze(img_normalized)
+
+                    last_conv_layer_name = None
+                    for layer in reversed(model.layers):
+                        if isinstance(layer, keras.layers.Conv2D):  # Assure-toi que c'est bien keras.layers.Conv2D
+                            last_conv_layer_name = layer.name
+                            break
+
+                    # Générer la heatmap à partir du modèle et de l'image traitée
+                    heatmap = make_gradcam_heatmap(np.expand_dims(heatm_img, axis = 0), model, last_conv_layer_name)
+
+                    # Préparation de l'image pour l'affichage de la superposition GRAD-CAM
+                    img_display = normalize_display_image(heatm_img)  # Convertir l'image normalisée en image affichable
+                    grad_img = save_and_display_gradcam(img_display, heatmap)  # Utilise l'image affichable ici
+                    bar_progress = 100
+                    my_bar.progress(bar_progress, text = "Exécution terminée")
+                    time.sleep(0.5)
+                    st.image(grad_img, use_column_width=False, clamp=True)
+                
+                class_names = {0 : 'COVID',
+                            1 : 'Lung_Opacity',
+                            2 : 'Normal',
+                            3 : 'Viral Pneumonia'}
+                df_predictions = pd.DataFrame(predictions)
+                df_predictions = df_predictions.rename(columns = class_names)
+                df_predictions_sorted = df_predictions.sort_values(by = 0, axis = 1, ascending = False)
+                df_transposed = df_predictions_sorted.T
+                table_html = df_transposed.to_html(header = False, index = True)
+
+                classe_predite_indice = np.argmax(predictions)
+                nom_classe_predite = class_names[classe_predite_indice]
+                probabilite_predite = np.max(predictions)
+                probabilite_predite = "{:.4f}".format(probabilite_predite)
+
+                col1, col2, col3 = st.columns([0.3, 0.3, 0.4])
+
+                with col1:
+                    # Afficher la classe prédite et sa probabilité
+                    st.markdown("Tableau des probabilités estimées :")
+                    st.write(table_html, unsafe_allow_html = True)
+                
+                with col2:
+                    st.markdown(
+                        f"""
+                        <div style='border-radius: 5px; border: 2px solid #d6d6d6; padding: 10px; max-width: 400px; background-color: rgba(255, 255, 255, 0.2);'>
+                            <div style='display: flex; justify-content: space-around;'>
+                                <div>
+                                    <p style='font-size: 20px; text-align: center; margin: 0;'>Classe prédite</p>
+                                    <p style='font-size: 30px; text-align: center; margin: 0;'>{nom_classe_predite}</p>
+                                </div>
+                            </div>
+                        </div>
+                        """,
+                        unsafe_allow_html=True
+                    )
+                    st.write("")
+                    percent_predit = float(probabilite_predite) * 100
+                    st.markdown(
+                        f"""
+                        <div style='border-radius: 5px; border: 2px solid #d6d6d6; padding: 10px; max-width: 400px; background-color: rgba(255, 255, 255, 0.2);'>
+                            <div style='display: flex; justify-content: space-around;'>
+                                <div>
+                                    <p style='font-size: 20px; text-align: center; margin: 0;'>Confiance de la prédiction</p>
+                                    <p style='font-size: 30px; text-align: center; margin: 0;'>{percent_predit} %</p>
+                                </div>
+                            </div>
+                        </div>
+                        """,
+                        unsafe_allow_html=True
+                    )
+
+                with col3:
+                    if float(probabilite_predite) > 0.90:
+                        st.markdown(f"Avec une probabilité de {probabilite_predite}, il est **certain** que cette radiographie illustre un cas {nom_classe_predite}. Attention cependant, cette prédiction est à prendre en compte seulement si l'image s'agit bien d'une radiographie conforme.")
+                    elif float(probabilite_predite) > 0.75:
+                        st.markdown(f"Avec une probabilité de {probabilite_predite}, il est **probable** que cette radiographie illustre un cas {nom_classe_predite}. Attention cependant, cette prédiction est à prendre en compte seulement si l'image s'agit bien d'une radiographie conforme.")
+                    elif float(probabilite_predite) > 0.5:
+                        st.markdown(f"Avec une probabilité de {probabilite_predite}, il est **possible** que cette radiographie illustre un cas {nom_classe_predite}. Attention cependant, cette prédiction est à prendre en compte seulement si l'image s'agit bien d'une radiographie conforme.")
+                    elif float(probabilite_predite) <= 0.5:
+                        st.markdown(f"Avec une probabilité de {probabilite_predite}, il **n'est pas prudent de dire** que cette radiographie illustre un cas {nom_classe_predite}. Il est possible que l'image ne soit pas adaptée au modèle.")
+
+            else:  
+                bar_progress = 0
+                my_bar.progress(bar_progress, text = "Exécution en attente...")
+                st.warning("L'image fournie ne semble pas être une radiographie. Souhaitez-vous quand même continuer ?", icon = "⚠️")
+                if st.button("Oui", key = 123):
+                    # Ouvrir l'image téléchargée
+                    original = Image.open(uploaded_file)        
+
+                    # Image traitée
+                    gray_image = original.convert('L')
+                    channelized = gray_image.convert("RGB")
+                    resized = channelized.resize((224, 224))
+                    img_normalized = np.array(resized) / 255.0  # Convertir l'image en array et normaliser entre 0 et 1
+                    img_normalized -= np.array([0.485, 0.456, 0.406])  # Soustraction de la moyenne par canal
+                    img_normalized /= np.array([0.229, 0.224, 0.225])  # Division par l'écart-type par canal
+                    img_normalized = img_normalized.reshape(-1, 224, 224, 3)  # Remodeler pour correspondre aux attentes du modèle (batch_size, height, width, channels
+                    
+                    bar_progress = 30
+                    my_bar.progress(bar_progress, text = "Estimation des prédictions...")
+                    time.sleep(0.5)
+                    predictions = model.predict(img_normalized)
+                    bar_progress = 70
+                    my_bar.progress(bar_progress, text = "Génération de la GRAD-CAM...")
+                    time.sleep(0.5)
+                        
+                    col1, col2, col3 = st.columns([0.3, 0.4, 0.3])
+
+                    def normalize_display_image(img_normalized):
+                        img_display = (img_normalized * np.array([0.229, 0.224, 0.225])) + np.array([0.485, 0.456, 0.406])
+                        img_display = np.clip(img_display, 0, 1)
+                        img_display = (img_display * 255).astype(np.uint8)
+                        return img_display
+
+                    if original.width > 500:
+                        width = 500
+                    else:
+                        width = original.width
+
+                    with col1:
+                        st.subheader("Image originale")
+                        st.image(original, use_column_width = False, width = width, clamp = True)
+                        st.warning("Image redimensionnée pour des raisons d'affichage.", icon = "⚠️") if original.width > 500 else None
+
+                    with col2:
+                        st.subheader("Image traitée")
+                        st.image(img_normalized, use_column_width = False, clamp = True)
+
+                    with col3:
+                        st.subheader("GRAD-CAM")
+                        # Préparation de l'image pour GRAD-CAM sans dimension de batch
+                        heatm_img = np.squeeze(img_normalized)
+
+                        last_conv_layer_name = None
+                        for layer in reversed(model.layers):
+                            if isinstance(layer, keras.layers.Conv2D):  # Assure-toi que c'est bien keras.layers.Conv2D
+                                last_conv_layer_name = layer.name
+                                break
+
+                        # Générer la heatmap à partir du modèle et de l'image traitée
+                        heatmap = make_gradcam_heatmap(np.expand_dims(heatm_img, axis = 0), model, last_conv_layer_name)
+
+                        # Préparation de l'image pour l'affichage de la superposition GRAD-CAM
+                        img_display = normalize_display_image(heatm_img)  # Convertir l'image normalisée en image affichable
+                        grad_img = save_and_display_gradcam(img_display, heatmap)  # Utilise l'image affichable ici
+                        bar_progress = 100
+                        my_bar.progress(bar_progress, text = "Exécution terminée")
+                        time.sleep(0.5)
+                        st.image(grad_img, use_column_width=False, clamp=True)
+                    
+                    class_names = {0 : 'COVID',
+                                1 : 'Lung_Opacity',
+                                2 : 'Normal',
+                                3 : 'Viral Pneumonia'}
+                    df_predictions = pd.DataFrame(predictions)
+                    df_predictions = df_predictions.rename(columns = class_names)
+                    df_predictions_sorted = df_predictions.sort_values(by = 0, axis = 1, ascending = False)
+                    df_transposed = df_predictions_sorted.T
+                    table_html = df_transposed.to_html(header = False, index = True)
+
+                    classe_predite_indice = np.argmax(predictions)
+                    nom_classe_predite = class_names[classe_predite_indice]
+                    probabilite_predite = np.max(predictions)
+                    probabilite_predite = "{:.4f}".format(probabilite_predite)
+
+                    col1, col2, col3 = st.columns([0.3, 0.3, 0.4])
+
+                    with col1:
+                        # Afficher la classe prédite et sa probabilité
+                        st.markdown("Tableau des probabilités estimées :")
+                        st.write(table_html, unsafe_allow_html = True)
+                    
+                    with col2:
+                        st.markdown(
+                            f"""
+                            <div style='border-radius: 5px; border: 2px solid #d6d6d6; padding: 10px; max-width: 400px; background-color: rgba(255, 255, 255, 0.2);'>
+                                <div style='display: flex; justify-content: space-around;'>
+                                    <div>
+                                        <p style='font-size: 20px; text-align: center; margin: 0;'>Classe prédite</p>
+                                        <p style='font-size: 30px; text-align: center; margin: 0;'>{nom_classe_predite}</p>
+                                    </div>
+                                </div>
+                            </div>
+                            """,
+                            unsafe_allow_html=True
+                        )
+                        st.write("")
+                        percent_predit = float(probabilite_predite) * 100
+                        st.markdown(
+                            f"""
+                            <div style='border-radius: 5px; border: 2px solid #d6d6d6; padding: 10px; max-width: 400px; background-color: rgba(255, 255, 255, 0.2);'>
+                                <div style='display: flex; justify-content: space-around;'>
+                                    <div>
+                                        <p style='font-size: 20px; text-align: center; margin: 0;'>Confiance de la prédiction</p>
+                                        <p style='font-size: 30px; text-align: center; margin: 0;'>{percent_predit} %</p>
+                                    </div>
+                                </div>
+                            </div>
+                            """,
+                            unsafe_allow_html=True
+                        )
+
+                    with col3:
+                        if float(probabilite_predite) > 0.90:
+                            st.markdown(f"Avec une probabilité de {probabilite_predite}, il est **certain** que cette radiographie illustre un cas {nom_classe_predite}. Attention cependant, cette prédiction est à prendre en compte seulement si l'image s'agit bien d'une radiographie conforme.")
+                        elif float(probabilite_predite) > 0.75:
+                            st.markdown(f"Avec une probabilité de {probabilite_predite}, il est **probable** que cette radiographie illustre un cas {nom_classe_predite}. Attention cependant, cette prédiction est à prendre en compte seulement si l'image s'agit bien d'une radiographie conforme.")
+                        elif float(probabilite_predite) > 0.5:
+                            st.markdown(f"Avec une probabilité de {probabilite_predite}, il est **possible** que cette radiographie illustre un cas {nom_classe_predite}. Attention cependant, cette prédiction est à prendre en compte seulement si l'image s'agit bien d'une radiographie conforme.")
+                        elif float(probabilite_predite) <= 0.5:
+                            st.markdown(f"Avec une probabilité de {probabilite_predite}, il **n'est pas prudent de dire** que cette radiographie illustre un cas {nom_classe_predite}. Il est possible que l'image ne soit pas adaptée au modèle.")
+
+        else:
+            # Message affiché tant qu'aucune image n'est téléchargée
+            st.warning("Veuillez télécharger une image pour commencer l'analyse.", icon = "⚠️")
+
+    with tab3:
+        st.header("Résumé des modèles")
+
+        col1, col2 = st.columns([0.5, 0.5])
+
+        with col1:
+            st.subheader("Avantages")
+            st.markdown('''
+                ✔️ Performances de prédictions équilibrées et satisfaisantes pour les différentes classes.
+
+                ✔️ Modèle réactif et léger à mettre en place, applicable à toutes les radiographies pulmonaires standards.
+
+                ✔️ Sensibilité et spécificité élevées, en particulier pour les classes COVID (0.96) et Normal (0.91).
+
+                ✔️ Equilibre contrôlé dans l'entrainement du modèle, réduisant le risque de data drift.
+                        ''')
+
+        with col2:
+            st.subheader("Inconvénients")
+            st.markdown('''
+                ❌ Bien qu'efficace, les modèles peuvent encore être optimisés en visant la qualité des images et la sélection des jeux d'entrainement.
+
+                ❌ Les GRADCAM montrent encore des features "non pertinentes" pour certaines images avec de nombreux artefacts.
+
+                ❌ Bien que les métriques utilisés pour sélectionner les modèles soient complémentaires et pertinentes, personnaliser des métriques de perte permettraient d'améliorer d'autant plus les performances du modèle.
+
+                ❌ Le modèle ne fait pasl a différence entre une radiographie et un autre type d'image.
+                        ''')