import streamlit as st
from PIL import Image
import numpy as np
import torch
from torchvision.transforms import Compose, Resize, ToTensor, Normalize
import tensorflow as tf
from tensorflow.keras.models import load_model
import random
from fpdf import FPDF
import io
import os
# Taille d'entrée pour les modèles
INPUT_SIZE = 224
# Chemins des modèles sauvegardés
MODEL_PT_PATH = "best_model.pth"
MODEL_TF_PATH = "model/kidney_model.keras"
# Chargement des classes
class_names = ['Cyst', 'Normal', 'Stone', 'Tumor']
# Architecture CNN pour PyTorch
class AdvancedCNN(torch.nn.Module):
def __init__(self, num_classes):
super(AdvancedCNN, self).__init__()
self.features = torch.nn.Sequential(
torch.nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1),
torch.nn.BatchNorm2d(64),
torch.nn.ReLU(),
torch.nn.MaxPool2d(kernel_size=2, stride=2),
torch.nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1),
torch.nn.BatchNorm2d(128),
torch.nn.ReLU(),
torch.nn.MaxPool2d(kernel_size=2, stride=2),
torch.nn.Conv2d(128, 256, kernel_size=3, stride=1, padding=1),
torch.nn.BatchNorm2d(256),
torch.nn.ReLU(),
torch.nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1),
torch.nn.BatchNorm2d(256),
torch.nn.ReLU(),
torch.nn.MaxPool2d(kernel_size=2, stride=2)
)
self.classifier = torch.nn.Sequential(
torch.nn.Flatten(),
torch.nn.Linear(256 * (INPUT_SIZE // 8) ** 2, 512),
torch.nn.ReLU(),
torch.nn.Dropout(0.5),
torch.nn.Linear(512, num_classes)
)
def forward(self, x):
x = self.features(x)
x = self.classifier(x)
return x
# Fonction pour prédire avec PyTorch
def predict_with_pytorch(model_path, image):
model = AdvancedCNN(num_classes=len(class_names))
model.load_state_dict(torch.load(model_path, map_location=torch.device('cpu')))
model.eval()
transform = Compose([
Resize((INPUT_SIZE, INPUT_SIZE)),
ToTensor(),
Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])
])
image_tensor = transform(image).unsqueeze(0)
with torch.no_grad():
outputs = model(image_tensor)
probabilities = torch.nn.functional.softmax(outputs[0], dim=0)
label_idx = torch.argmax(probabilities).item()
return class_names[label_idx], probabilities.numpy()
# Fonction pour prédire avec TensorFlow
def predict_with_tensorflow(model_path, image):
model = load_model(model_path)
image_resized = image.resize((INPUT_SIZE, INPUT_SIZE))
image_array = np.array(image_resized) / 255.0
image_array = np.expand_dims(image_array, axis=0)
predictions = model.predict(image_array)[0]
label_idx = np.argmax(predictions)
return class_names[label_idx], predictions
# Fonction pour générer un PDF avec les prédictions et recommandations
def generate_pdf(prediction, probabilities, image, model_name):
pdf = FPDF()
pdf.set_auto_page_break(auto=True, margin=15)
pdf.add_page()
pdf.set_font("Arial", style="B", size=16)
pdf.cell(200, 10, "Rapport de Prédiction", ln=True, align='C')
pdf.ln(10)
pdf.set_font("Arial", size=12)
pdf.cell(200, 10, f"Modèle utilisé: {model_name}", ln=True)
pdf.cell(200, 10, f"Prédiction: {prediction}", ln=True)
pdf.cell(200, 10, "Probabilités:", ln=True)
for i, prob in enumerate(probabilities):
pdf.cell(200, 10, f"{class_names[i]}: {prob:.2%}", ln=True)
pdf.ln(10)
pdf.cell(200, 10, "Recommandations:", ln=True)
recommendations = {
"Cyst": "Consultez un urologue pour une évaluation approfondie.",
"Normal": "Aucune intervention n'est requise.",
"Stone": "Hydratation et suivi avec un spécialiste recommandés.",
"Tumor": "Consultez un oncologue pour un diagnostic précis."
}
pdf.multi_cell(0, 10, recommendations.get(prediction, "Aucune recommandation disponible."))
# Sauvegarde et insertion de l'image
img_path = "temp_image.jpg"
image.save(img_path)
pdf.image(img_path, x=60, w=90)
# Générer le PDF en mémoire
pdf_output = io.BytesIO()
pdf_bytes = pdf.output(dest='S').encode('latin1') # Générer en mémoire
pdf_output.write(pdf_bytes)
pdf_output.seek(0)
return pdf_output
# Fonction JS pour animer les ballons
def show_balloons():
st.markdown("""
""", unsafe_allow_html=True)
# CSS pour une interface moderne avec dégradés et icônes
st.markdown("""
""", unsafe_allow_html=True)
# Application Streamlit
st.markdown('
Session Normale (Kidney Classification)
', unsafe_allow_html=True)
menu = st.sidebar.selectbox("Menu", ["🧠 Accueil", "Classification avec PyTorch", "Classification avec TensorFlow", "👨💻À propos", "Légendes"])
if menu == "🧠 Accueil":
st.write("Bienvenue dans notre application de classification d'images. Cette application a été développée pour la classification d'images dans le contexte du **CT-KIDNEY-DATASET-Normal-Cyst-Tumor-Stone**, un dataset médical contenant des images de tomodensitométrie (CT) de reins, avec des catégories représentant des reins normaux, des kystes, des tumeurs et des calculs rénaux.")
st.write("""
Cette application a pour objectif de classer ces images en différentes catégories (Normal, Cyst, Tumor, Stone) à l'aide de modèles de machine learning.
Nous avons créé deux modèles de classification d'images en utilisant deux des frameworks les plus populaires : **TensorFlow** et **PyTorch**.
Ces modèles ont été entraînés sur le dataset CT-KIDNEY-DATASET et peuvent être utilisés pour prédire la catégorie d'une image donnée, en détectant des anomalies ou en validant l'état du rein à partir des images CT.
""")
# Création des onglets pour chaque framework
tab_tensorflow, tab_pytorch = st.tabs(["TensorFlow", "PyTorch"])
with tab_tensorflow:
st.image("tensorflow.svg", caption="TensorFlow", width=300)
st.write("""
**TensorFlow** est un framework de machine learning open source développé par Google.
Il est particulièrement adapté aux tâches d'apprentissage supervisé et non supervisé,
ainsi qu'aux modèles de deep learning complexes tels que les réseaux de neurones convolutifs (CNN) et récurrents (RNN).
### Avantages :
- Hautement optimisé pour des performances sur GPU.
- Supporte l'exécution sur des dispositifs mobiles et embarqués.
- Large écosystème avec des outils comme TensorFlow Lite, TensorFlow.js et TensorFlow Hub.
### Utilisation :
TensorFlow est largement utilisé dans la reconnaissance d'images, le traitement du langage naturel (NLP), et la prédiction des séries temporelles.
""")
# Espacement entre les tabs avec un grand espace (sauts de ligne)
st.markdown("
", unsafe_allow_html=True)
with tab_pytorch:
st.image("pytorch.svg", caption="PyTorch", width=300)
st.write("""
**PyTorch** est un framework open source développé par Facebook, très populaire pour l'apprentissage profond.
Il offre une flexibilité exceptionnelle grâce à son approche dynamique pour la construction des modèles, ce qui le rend très apprécié des chercheurs et des développeurs.
### Avantages :
- Facilité d’utilisation avec un code dynamique pour un débogage simplifié.
- Excellente intégration avec les bibliothèques Python natives et une large communauté de support.
- Optimisation automatique des gradients pour les modèles de deep learning.
### Utilisation :
PyTorch est largement utilisé dans la recherche académique ainsi que dans des applications industrielles, telles que la reconnaissance d'image, la segmentation sémantique, et la traduction automatique.
""")
st.write("Ces deux frameworks sont puissants et largement utilisés dans le domaine du machine learning et du deep learning, chacun ayant ses spécificités et ses avantages en fonction du type de projet.")
elif menu == "Classification avec PyTorch":
st.subheader("Classification avec un modèle PyTorch")
uploaded_file = st.file_uploader("Téléchargez une image", type=["jpg", "jpeg", "png"])
if uploaded_file is not None:
image = Image.open(uploaded_file)
st.image(image, caption="Image Téléchargée", use_container_width=True)
if st.button("Classifier"):
label, probabilities = predict_with_pytorch(MODEL_PT_PATH, image)
st.markdown(f'
Classe prédite : {label}
', unsafe_allow_html=True)
st.bar_chart(probabilities)
pdf_file = generate_pdf(label, probabilities, image, MODEL_PT_PATH)
st.download_button("Télécharger le rapport PDF", pdf_file, "rapport_prediction.pdf", "application/pdf")
if label == "Normal":
st.balloons() # Affiche les ballons si la classe est "Normal"
else:
st.markdown("
Désolé, le résultat n'est pas normal...
", unsafe_allow_html=True)
elif menu == "Classification avec TensorFlow":
st.subheader("Classification avec un modèle TensorFlow")
uploaded_file = st.file_uploader("Téléchargez une image", type=["jpg", "jpeg", "png"])
if uploaded_file is not None:
image = Image.open(uploaded_file)
st.image(image, caption="Image Téléchargée", use_container_width=True)
if st.button("Classifier"):
label, probabilities = predict_with_tensorflow(MODEL_TF_PATH, image)
st.markdown(f'
Classe prédite : {label}
', unsafe_allow_html=True)
st.bar_chart(probabilities)
pdf_file = generate_pdf(label, probabilities, image, MODEL_TF_PATH)
st.download_button("Télécharger le rapport PDF", pdf_file, "rapport_prediction.pdf", "application/pdf")
if label == "Normal":
st.balloons() # Affiche les ballons si la classe est "Normal"
else:
st.markdown("
Désolé, le résultat n'est pas normal...
", unsafe_allow_html=True)
elif menu == "Légendes":
st.subheader("Légendes des modèles")
st.write("Voici des informations détaillées sur les deux modèles utilisés dans cette application :")
st.write("### 1. Modèle PyTorch")
st.write("PyTorch est un framework open-source développé par Facebook.")
st.write("### 2. Modèle TensorFlow")
st.write("TensorFlow est un autre framework populaire développé par Google.")
elif menu == "👨💻À propos":
st.header("À propos de moi")
st.markdown(
"""
Mon Parcours
Je suis un passionné de l'intelligence artificielle et de la donnée. Actuellement en Master 2 en IA et Big Data, je travaille sur des solutions innovantes dans le domaine de l'Intelligence Artificielle appliquée à la santé.
