import streamlit as st import pandas as pd import numpy as np import torch import torch.nn as nn from sklearn.preprocessing import LabelEncoder import plotly.express as px import plotly.graph_objects as go import umap import shap import seaborn as sns import matplotlib.pyplot as plt from sklearn.decomposition import PCA from sklearn.cluster import KMeans from sklearn.ensemble import RandomForestClassifier from transformers import AutoTokenizer, AutoModelForSequenceClassification from reportlab.lib.pagesizes import A4 from reportlab.pdfgen import canvas from reportlab.lib import colors import io import logging from datetime import datetime import warnings import os warnings.filterwarnings('ignore') logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s') # Chemin du modèle dans l’image Docker model_path = 'src/omics_vae_best_hyperparams.pth' # Biomarqueurs IRC irc_biomarkers = [ 'UMOD_rs12917707', 'APOL1_rs73885319', 'MYH9_rs4821480', 'HAVCR1', 'TGFB1', 'IL6', 'HNF4A', 'NPHS1', 'AQP2', 'B2MG', 'Albumin', 'NGAL', 'Cystatin_C', 'Uromodulin', 'KLOTHO', 'Kynurenine', 'Indoxyl_Sulfate', 'Creatinine', '5-MTP' ] # Définition du modèle OmicsVAE class OmicsVAE(nn.Module): def __init__(self, input_dims, hidden_dim=256, latent_dim=64, num_heads=8, num_layers=3, dropout=0.4, num_classes=2): super(OmicsVAE, self).__init__() self.input_dims = input_dims self.hidden_dim = hidden_dim self.latent_dim = latent_dim self.num_omics = len(input_dims) self.num_classes = num_classes self.input_projections = nn.ModuleList([nn.Linear(dim, hidden_dim) for dim in input_dims]) self.positional_encoding = self.create_positional_encoding(hidden_dim, max_len=self.num_omics) transformer_layer = nn.TransformerEncoderLayer( d_model=hidden_dim, nhead=num_heads, dim_feedforward=hidden_dim * 4, dropout=dropout, batch_first=True ) self.transformer_encoder = nn.TransformerEncoder(transformer_layer, num_layers=num_layers) self.fc_mu = nn.Linear(hidden_dim * self.num_omics, latent_dim) self.fc_log_var = nn.Linear(hidden_dim * self.num_omics, latent_dim) self.fc_decode = nn.Linear(latent_dim, hidden_dim * self.num_omics) self.decoder_projections = nn.ModuleList([nn.Linear(hidden_dim, dim) for dim in input_dims]) self.fc_classify = nn.Linear(latent_dim, num_classes) def create_positional_encoding(self, d_model, max_len): pe = torch.zeros(max_len, d_model) position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1) div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-np.log(10000.0) / d_model)) pe[:, 0::2] = torch.sin(position * div_term) pe[:, 1::2] = torch.cos(position * div_term) return pe.unsqueeze(0) def reparameterize(self, mu, log_var): std = torch.exp(0.5 * log_var) eps = torch.randn_like(std) return mu + eps * std def forward(self, x_list): encoded = [] for i, x in enumerate(x_list): proj = self.input_projections[i](x) pe = self.positional_encoding[:, i, :].to(x.device) proj = proj + pe.expand(x.size(0), -1) encoded.append(proj.unsqueeze(1)) encoded = torch.cat(encoded, dim=1) transformer_out = self.transformer_encoder(encoded) transformer_out = transformer_out.contiguous().view(transformer_out.size(0), -1) mu = self.fc_mu(transformer_out) log_var = self.fc_log_var(transformer_out) z = self.reparameterize(mu, log_var) decoded = self.fc_decode(z).view(z.size(0), self.num_omics, self.hidden_dim) outputs = [self.decoder_projections[i](decoded[:, i, :]) for i in range(self.num_omics)] class_logits = self.fc_classify(z) return outputs, z, mu, log_var, class_logits # Fonction pour générer des recommandations avec BioBERT def generate_recommendation_with_biobert(patient_data, patient_id, biomarkers, tokenizer, model, data_dict): # Extraire les valeurs réelles des biomarqueurs biomarker_values = [] for omic in data_dict: for biomarker in biomarkers[:3]: if biomarker in data_dict[omic].columns: value = data_dict[omic].loc[patient_id, biomarker] biomarker_values.append(f"{biomarker}: {value:.2f}") # Structurer le texte d’entrée text = f""" Patient: {patient_id}, {patient_data['sex']}, {patient_data['age']} ans. Score de risque IRC: {patient_data['risk_score']:.1f}%. Antécédents familiaux: IRC ({'Oui' if patient_data['family_history_irc'] else 'Non'}), Diabète ({'Oui' if patient_data['family_history_diabetes'] else 'Non'}), Hypertension ({'Oui' if patient_data['family_history_hypertension'] else 'Non'}). Comorbidités: Diabète ({'Oui' if patient_data['diabetes'] else 'Non'}), Hypertension ({'Oui' if patient_data['hypertension'] else 'Non'}). Biomarqueurs: {', '.join(biomarker_values)}. """ # Tokenisation et classification inputs = tokenizer(text, return_tensors="pt", truncation=True, padding=True, max_length=512) with torch.no_grad(): outputs = model(**inputs) logits = outputs.logits prediction = torch.argmax(logits, dim=1).item() # Génération dynamique des recommandations base_advice = { 0: { 'title': f"Patient {patient_id} : Risque Faible ({patient_data['risk_score']:.1f}%)", 'state': "Faible probabilité de progression vers l'IRC.", 'lifestyle': "Adopter une alimentation faible en sel (<2g/jour), riche en fruits et légumes. Activité physique modérée (30 min/jour, 5 jours/semaine).", 'monitoring': f"Bilan rénal annuel, surveiller {', '.join(biomarker_values[:2])}. Hydratation adéquate (1,5-2L/jour).", 'therapy': "Aucune thérapie spécifique requise." }, 1: { 'title': f"Patient {patient_id} : Risque Modéré ({patient_data['risk_score']:.1f}%)", 'state': "Risque intermédiaire de progression vers l'IRC.", 'lifestyle': "Régime strict : réduire protéines animales, sodium (<1,5g/jour). Contrôler pression artérielle (<130/80 mmHg).", 'monitoring': f"Consultation néphrologue trimestrielle, évaluer {', '.join(biomarker_values[:2])}. Éviter AINS sauf prescription.", 'therapy': "Considérer un contrôle glycémique strict si diabétique." }, 2: { 'title': f"Patient {patient_id} : Risque Élevé ({patient_data['risk_score']:.1f}%)", 'state': "Forte probabilité de progression vers l'IRC.", 'lifestyle': "Régime rénal strict : faible en potassium, phosphore, sodium.", 'monitoring': f"Consultation néphrologue urgente, surveillance hebdomadaire (créatinine, DFG). Analyser {', '.join(biomarker_values[:3])}. ", 'therapy': "Envisager inhibiteurs de l’ECA ou diurétiques, après évaluation." } } advice = base_advice[prediction] if patient_data['diabetes']: advice['therapy'] += " Contrôle strict de la glycémie (HbA1c <7%)." if patient_data['hypertension']: advice['therapy'] += " Médicaments antihypertenseurs (ex. : losartan) sous supervision." if patient_data['family_history_irc']: advice['monitoring'] += " Surveillance accrue des antécédents familiaux." for biomarker in biomarker_values: if "Creatinine" in biomarker and float(biomarker.split(":")[1]) > 1.5: advice['monitoring'] += f" Attention : Créatinine élevée ({biomarker.split(':')[1]} mg/dL), suivi rapproché recommandé." formatted_advice = f""" **{advice['title']}** - **État** : {advice['state']} - **Mode de vie** : {advice['lifestyle']} - **Suivi** : {advice['monitoring']} - **Thérapie** : {advice['therapy']} **Avertissement** : Ces recommandations doivent être validées par un médecin. """ return formatted_advice # Fonction pour générer un rapport PDF en mémoire def generate_pdf_report(patient_id, patient_data, advice, umap_df, shap_importance=None): buffer = io.BytesIO() c = canvas.Canvas(buffer, pagesize=A4) c.setFont("Helvetica-Bold", 16) c.drawString(50, 800, f"Rapport IRC - Patient {patient_id}") c.setFont("Helvetica", 12) c.drawString(50, 770, f"Date: {datetime.now().strftime('%Y-%m-%d')}") # Informations patient c.setFont("Helvetica-Bold", 14) c.drawString(50, 740, "Informations du Patient") c.setFont("Helvetica", 12) y = 720 c.drawString(50, y, f"Âge: {patient_data['age']} ans") c.drawString(50, y-20, f"Sexe: {patient_data['sex']}") c.drawString(50, y-40, f"Score de risque: {patient_data['risk_score']:.1f}%") c.drawString(50, y-60, f"Antécédents familiaux: IRC ({'Oui' if patient_data['family_history_irc'] else 'Non'}), " f"Diabète ({'Oui' if patient_data['family_history_diabetes'] else 'Non'}), " f"Hypertension ({'Oui' if patient_data['family_history_hypertension'] else 'Non'})") c.drawString(50, y-80, f"Comorbidités: Diabète ({'Oui' if patient_data['diabetes'] else 'Non'}), " f"Hypertension ({'Oui' if patient_data['hypertension'] else 'Non'})") # Recommandations c.setFont("Helvetica-Bold", 14) c.drawString(50, y-110, "Recommandations") c.setFont("Helvetica", 12) text_object = c.beginText(50, y-130) text_object.setLeading(14) for line in advice.split('\n'): text_object.textLine(line) c.drawText(text_object) # Graphique UMAP if 'umap_df' in st.session_state: fig = px.scatter( umap_df, x='UMAP1', y='UMAP2', color='Score de Risque (%)', symbol='Status', title='Projection UMAP', color_continuous_scale='RdYlGn_r', template='plotly_dark' ) fig.update_traces(marker=dict(size=12)) img_buffer = io.BytesIO() fig.write_image(img_buffer, format='png', width=500, height=300) img_buffer.seek(0) c.drawImage(img_buffer, 50, y-400, width=500, height=300) # Graphique SHAP if shap_importance is not None: c.showPage() c.setFont("Helvetica-Bold", 14) c.drawString(50, 800, "Analyse SHAP") fig, ax = plt.subplots(figsize=(6, 4)) sns.barplot(data=shap_importance.head(10), x='Importance SHAP', y='Biomarqueur', palette='Set2') plt.title('Top 10 Biomarqueurs') img_buffer = io.BytesIO() fig.savefig(img_buffer, format='png', bbox_inches='tight') plt.close() img_buffer.seek(0) c.drawImage(img_buffer, 50, 700, width=500, height=300) c.save() buffer.seek(0) return buffer # Configuration de Streamlit st.set_page_config(page_title="Analyse Multi-Omique IRC", layout="wide") st.markdown(""" """, unsafe_allow_html=True) st.title("Plateforme d’Analyse Multi-Omique pour l’IRC") st.markdown("**Ngoue David, M2 Intelligence Artificielle et Big Data** | Hôpital Général de Yaoundé") # Menu latéral st.sidebar.header("Navigation") page = st.sidebar.radio("Étapes", [ "Présentation", "Chargement des Données", "Analyse Exploratoire", "Clustering", "Scores de Risque", "Analyse SHAP", "Conseiller Médical", "Résumé" ]) # Chargement de BioBERT @st.cache_resource def load_biobert(): tokenizer = AutoTokenizer.from_pretrained("dmis-lab/biobert-v1.1") model = AutoModelForSequenceClassification.from_pretrained("dmis-lab/biobert-v1.1", num_labels=3) return tokenizer, model biobert_tokenizer, biobert_model = load_biobert() # Chargement du modèle VAE @st.cache_resource def load_model(input_dims, num_classes): model = OmicsVAE(input_dims=input_dims, num_classes=num_classes) try: model.load_state_dict(torch.load(model_path)) except FileNotFoundError: raise FileNotFoundError(f"Modèle {model_path} non trouvé dans l’image Docker.") model.eval() return model # Présentation if page == "Présentation": st.header("Contexte et Innovation") st.markdown(""" **Projet : Thérapie Personnalisée de l’IRC** Réalisé par Ngoue David, ce projet révolutionne la prise en charge de l’IRC à l’Hôpital Général de Yaoundé via une approche multi-omique. Une architecture de transformers hybrides (OmicsVAE) permet : - **Prédiction** des risques de progression de l’IRC. - **Thérapies sur mesure** basées sur les profils moléculaires. - **Suivi intelligent** avec un conseiller BioBERT. **Impact** : Médecine de précision pour le Cameroun, meilleurs résultats, coûts réduits. **Explorez** via le menu latéral. """) # Chargement des Données elif page == "Chargement des Données": st.header("Chargement des Données") st.markdown("Uploadez les fichiers omiques (CSV) pour l’analyse.") uploaded_files = {} omics_types = ['génomique', 'transcriptomique', 'protéomique', 'métabolomique'] for omic in omics_types: uploaded_file = st.file_uploader(f"Données {omic} (CSV)", type="csv", key=omic) if uploaded_file: uploaded_files[omic] = uploaded_file if st.button("Initialiser l’Analyse") and len(uploaded_files) == len(omics_types): try: data_dict = {} for omic, file in uploaded_files.items(): df = pd.read_csv(file, index_col='Patient_ID') if 'Status' not in df.columns: raise ValueError(f"Le fichier {omic} doit contenir une colonne 'Status'.") data_dict[omic] = df.drop(columns=['Status']) labels = pd.read_csv(uploaded_files['génomique'], index_col='Patient_ID')['Status'] le = LabelEncoder() encoded_labels = pd.Series(le.fit_transform(labels), index=labels.index, name='Status') common_samples = data_dict['génomique'].index for omic in data_dict: data_dict[omic] = data_dict[omic].loc[common_samples] labels = encoded_labels.loc[common_samples] input_dims = [data_dict[omic].shape[1] for omic in data_dict] model = load_model(input_dims, len(np.unique(encoded_labels))) st.session_state['data_dict'] = data_dict st.session_state['labels'] = labels st.session_state['label_encoder'] = le st.session_state['common_samples'] = common_samples st.session_state['model'] = model st.session_state['input_dims'] = input_dims st.success("Données et modèle chargés avec succès !") except Exception as e: st.error(f"Erreur : {str(e)}") # Analyse Exploratoire elif page == "Analyse Exploratoire": st.header("Analyse Exploratoire") if 'data_dict' not in st.session_state: st.warning("Chargez les données d'abord.") else: data_dict = st.session_state['data_dict'] labels = st.session_state['labels'] omic = st.selectbox("Type omique", list(data_dict.keys())) biomarkers = [col for col in data_dict[omic].columns if col in irc_biomarkers] if biomarkers: st.subheader(f"Matrice de Corrélation ({omic})") corr_matrix = data_dict[omic][biomarkers].corr() fig = go.Figure(data=go.Heatmap( z=corr_matrix.values, x=corr_matrix.columns, y=corr_matrix.columns, colorscale='Magma', zmin=-1, zmax=1, text=np.round(corr_matrix.values, 2), texttemplate="%{text}", hovertemplate='Biomarqueur 1: %{x}
Biomarqueur 2: %{y}
Corrélation: %{z:.2f}' )) fig.update_layout(title=f'Matrice de Corrélation ({omic})', template='plotly_dark') st.plotly_chart(fig, use_container_width=True) st.subheader(f"Projection PCA 3D ({omic})") pca = PCA(n_components=3) pca_result = pca.fit_transform(data_dict[omic]) pca_df = pd.DataFrame(pca_result, columns=['PC1', 'PC2', 'PC3'], index=data_dict[omic].index) pca_df['Status'] = labels explained_variance = pca.explained_variance_ratio_ fig = px.scatter_3d( pca_df, x='PC1', y='PC2', z='PC3', color='Status', title=f'Projection PCA 3D ({omic}) - Variance : {explained_variance.sum():.2%}', labels={'PC1': f'PC1 ({explained_variance[0]:.2%})', 'PC2': f'PC2 ({explained_variance[1]:.2%})', 'PC3': f'PC3 ({explained_variance[2]:.2%})'}, color_continuous_scale='Viridis', opacity=0.7, template='plotly_dark' ) fig.update_traces(marker=dict(size=5)) st.plotly_chart(fig, use_container_width=True) # Clustering elif page == "Clustering": st.header("Clustering") if 'data_dict' not in st.session_state: st.warning("Chargez les données d'abord.") else: n_clusters = st.slider("Nombre de clusters", 2, 10, 5) if st.button("Lancer le Clustering"): data_dict = st.session_state['data_dict'] labels = st.session_state['labels'] common_samples = st.session_state['common_samples'] combined_data = pd.concat([data_dict[omic] for omic in data_dict], axis=1) kmeans = KMeans(n_clusters=n_clusters, random_state=42, n_init=10) umap_reducer = umap.UMAP(n_components=2, n_neighbors=15, min_dist=0.1, random_state=42) umap_embedding = umap_reducer.fit_transform(combined_data) umap_df = pd.DataFrame(umap_embedding, columns=['UMAP1', 'UMAP2'], index=common_samples) umap_df['Cluster'] = kmeans.fit_predict(umap_embedding) umap_df['Status'] = st.session_state['label_encoder'].inverse_transform(labels) st.session_state['umap_df'] = umap_df st.session_state['kmeans'] = kmeans st.session_state['umap_embedding'] = umap_embedding fig = px.scatter( umap_df, x='UMAP1', y='UMAP2', color='Cluster', symbol='Status', title='Projection UMAP avec Clusters KMeans', color_continuous_scale='Viridis', labels={'Cluster': 'Cluster', 'Status': 'Status'}, template='plotly_dark' ) fig.update_traces(marker=dict(size=10)) st.plotly_chart(fig, use_container_width=True) # Scores de Risque elif page == "Scores de Risque": st.header("Scores de Risque") if 'umap_df' not in st.session_state: st.warning("Effectuez le clustering d'abord.") else: umap_df = st.session_state['umap_df'] kmeans = st.session_state['kmeans'] umap_embedding = st.session_state['umap_embedding'] data_dict = st.session_state['data_dict'] labels = st.session_state['labels'] label_encoder = st.session_state['label_encoder'] if st.button("Calculer les Scores"): cluster_centers = kmeans.cluster_centers_ distances = np.zeros(len(umap_embedding)) for i, emb in enumerate(umap_embedding): distances[i] = np.linalg.norm(emb - cluster_centers[umap_df['Cluster'].iloc[i]]) base_risk = (distances - distances.min()) / (distances.max() - distances.min()) biomarker_weights = {omic: {col: 2.0 if col in irc_biomarkers else 1.0 for col in data_dict[omic].columns} for omic in data_dict} weighted_risk = base_risk.copy() for omic in data_dict: for col, weight in biomarker_weights[omic].items(): deviation = np.abs(data_dict[omic][col].values - data_dict[omic][col].mean()) weighted_risk += weight * deviation weighted_risk = (weighted_risk - weighted_risk.min()) / (weighted_risk.max() - weighted_risk.min()) classifier = RandomForestClassifier(n_estimators=100, random_state=42, class_weight='balanced') combined_data = pd.concat([data_dict[omic] for omic in data_dict], axis=1) classifier.fit(combined_data, labels) irc_class = label_encoder.transform(['IRC'])[0] if 'IRC' in label_encoder.classes_ else np.argmax(np.bincount(labels)) class_probs = classifier.predict_proba(combined_data)[:, irc_class] final_risk = weighted_risk * 0.5 + class_probs * 0.5 final_risk = final_risk * 100 umap_df['Score de Risque (%)'] = final_risk st.session_state['umap_df'] = umap_df fig = px.scatter( umap_df, x='UMAP1', y='UMAP2', color='Score de Risque (%)', symbol='Status', title='Projection UMAP avec Scores de Risque', color_continuous_scale='RdYlGn_r', labels={'Score de Risque (%)': 'Score de Risque (%)', 'Status': 'Status'}, template='plotly_dark' ) fig.update_traces(marker=dict(size=12)) st.plotly_chart(fig, use_container_width=True) # Analyse SHAP elif page == "Analyse SHAP": st.header("Analyse SHAP") if 'model' not in st.session_state: st.warning("Chargez les données d'abord.") else: model = st.session_state['model'] data_dict = st.session_state['data_dict'] input_dims = st.session_state['input_dims'] combined_data = pd.concat([data_dict[omic] for omic in data_dict], axis=1) feature_names = sum([data_dict[omic].columns.tolist() for omic in data_dict], []) if st.button("Lancer SHAP"): device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') X_concat = combined_data.values n_samples = min(100, X_concat.shape[0]) X_subset = X_concat[:n_samples] class VAEWrapper: def __init__(self, model, device): self.model = model self.device = device def predict(self, X): X_tensors = [] start = 0 for dim in input_dims: X_tensors.append(torch.tensor(X[:, start:start + dim], dtype=torch.float32).to(self.device)) start += dim with torch.no_grad(): _, z, _, _, _ = self.model(X_tensors) return torch.norm(z, dim=1).cpu().numpy() explainer = shap.KernelExplainer(VAEWrapper(model, device).predict, X_subset) shap_values = explainer.shap_values(X_subset, nsamples=100) shap_importance = pd.DataFrame({ 'Biomarqueur': feature_names[:len(np.mean(np.abs(shap_values[0]), axis=0))], 'Importance SHAP': np.mean(np.abs(shap_values[0]), axis=0) }).sort_values('Importance SHAP', ascending=False) st.session_state['shap_importance'] = shap_importance fig, ax = plt.subplots(figsize=(6, 4)) sns.barplot(data=shap_importance.head(10), x='Importance SHAP', y='Biomarqueur', palette='Set2') plt.title('Top 10 Biomarqueurs') st.pyplot(fig) plt.close() st.subheader("Biomarqueurs Clés") st.dataframe(shap_importance.head(10)) # Conseiller Médical elif page == "Conseiller Médical": st.header("Conseiller Médical BioBERT") st.markdown("Entrez les informations du patient pour des recommandations personnalisées et un rapport.") if 'umap_df' not in st.session_state or 'data_dict' not in st.session_state: st.warning("Calculez les scores de risque et chargez les données d'abord.") else: umap_df = st.session_state['umap_df'] data_dict = st.session_state['data_dict'] with st.form("patient_form"): patient_id = st.text_input("ID du Patient", help="Ex. Patient_001") age = st.number_input("Âge", min_value=18, max_value=120, value=30) sex = st.selectbox("Sexe", ["Homme", "Femme"]) family_history_irc = st.checkbox("Antécédents familiaux d’IRC") family_history_diabetes = st.checkbox("Antécédents familiaux de diabète") family_history_hypertension = st.checkbox("Antécédents familiaux d’hypertension") diabetes = st.checkbox("Diabète actuel") hypertension = st.checkbox("Hypertension actuelle") submitted = st.form_submit_button("Obtenir Recommandations et Rapport") if submitted and patient_id in umap_df.index: patient_data = { 'risk_score': umap_df.loc[patient_id, 'Score de Risque (%)'], 'age': age, 'sex': sex, 'family_history_irc': family_history_irc, 'family_history_diabetes': family_history_diabetes, 'family_history_hypertension': family_history_hypertension, 'diabetes': diabetes, 'hypertension': hypertension } advice = generate_recommendation_with_biobert( patient_data, patient_id, irc_biomarkers, biobert_tokenizer, biobert_model, data_dict ) st.markdown(f"
{advice}
", unsafe_allow_html=True) # Générer et proposer le rapport PDF shap_importance = st.session_state.get('shap_importance', None) pdf_buffer = generate_pdf_report(patient_id, patient_data, advice, umap_df, shap_importance) st.download_button( label="Télécharger Rapport PDF", data=pdf_buffer, file_name=f"rapport_irc_{patient_id}_{datetime.now().strftime('%Y%m%d')}.pdf", mime="application/pdf" ) elif submitted: st.error("ID du patient invalide.") # Résumé elif page == "Résumé": st.header("Résumé") if 'umap_df' not in st.session_state: st.warning("Complétez les étapes précédentes.") else: st.subheader("Scores de Risque") st.dataframe(st.session_state['umap_df'][['Cluster', 'Status', 'Score de Risque (%)']]) csv_buffer = io.StringIO() st.session_state['umap_df'].to_csv(csv_buffer, index=True) csv_buffer.seek(0) st.download_button( label="Télécharger Résultats (CSV)", data=csv_buffer.getvalue(), file_name=f"resultats_irc_{datetime.now().strftime('%Y%m%d')}.csv", mime="text/csv" )