$$\rightleftharpoonup{xx}$$
$$\longleftharp{xx}$$,
$$\longrightharp{xx}$$,
Cette étude a utilisé exclusivement des ensembles de données d’imagerie CT et IRM anonymisées et accessibles au public. Aucun sujet humain ou animal vivant n’a été impliqué. Par conséquent, il n’était pas nécessaire d’obtenir l’approbation d’un comité d’examen institutionnel (CISR) ou d’un comité d’éthique.
Vue d’ensemble de la méthode
Ce protocole présente un pipeline reproductible pour le débruitage d’images médicales économes en énergie. Il combine des techniques de prétraitement, y compris des filtres d’affûtage et le clustering de K-means, avec un auto-encodeur basé sur un réseau neuronal convolutif (CNN) pour débruiter les images. Cette méthode intégrée améliore la qualité de l’image tout en réduisant le temps de formation et la consommation d’énergie du matériel, ce qui permet un diagnostic médical durable 19,20,21,22,23. La figure 5 résume le cadre de bout en bout.

Figure 5 : Architecture du cadre de débruitage proposée. Cette figure présente l’ensemble du pipeline : acquisition de données, prétraitement (affûtage + segmentation des moyennes K), suivi du débruitage de l’auto-encodeur basé sur CNN. Il met l’accent sur l’approche hybride visant à réduire la consommation d’énergie tout en préservant la fidélité structurelle. Veuillez cliquer ici pour voir une version agrandie de cette figure.
L’ensemble du flux de travail est résumé dans la figure 5, qui montre la séquence allant de la configuration de l’ensemble de données au prétraitement (netteté et K-moyennes) jusqu’à l’auto-encodeur CNN, le débruitage et les tests.
Configuration du logiciel et de l’environnement
Option A - Google Colab (recommandée pour la reproductibilité) : Allez dans colab.research.google.com, cliquez sur Nouveau bloc-notes. Sélectionnez Exécuter > Modifier le type d’exécution > Accélérateur matériel : GPU > Enregistrer. Cliquez sur Fichier > Charger pour importer le bloc-notes fourni et le .zip de l’ensemble de données (ou connectez-vous à Google Drive en cliquant sur Fichiers > Monter le lecteur). Dans la première cellule de code, installez les dépendances (déjà dans le notebook) : pip install opencv-python scikit-image scikit-learn tensorflow matplotlib numpy pandas. Cliquez sur Exécution > Exécuter tout. Vérifiez que vous voyez : (i) un résumé de l’environnement avec les versions du package, (ii) le nom du GPU (dans la sortie de la cellule) et (iii) la création d’un dossier d’expérience runs/YYYY-MM-DD/.
Option B - Local (conda) : Ouvrez Anaconda Prompt/Terminal et exécutez :

Placez votre ensemble de données sous data/raw/ et les scripts sous code/. Exécuter : python code/train_autoencoder.py --data_root data --img_size 256 --k_values 3 5 --epochs 100 --batch 32 --lr 0.001. Confirmez pour voir : l’impression de l’environnement, le GPU détecté et l’exécution d’un répertoire de journaux/AAAA-MM-JJ/.
Préparation de l’ensemble de données
Les ensembles de données publiques de tomodensitométrie et d’IRM proviennent de dépôts d’imagerie médicale. Ces ensembles de données contenaient du bruit typique des scanners cliniques du monde réel et ont été anonymisés conformément aux normes institutionnelles et éthiques 8,9. Chaque image a été redimensionnée à 256 x 256 pixels et stockée au format PNG ou DICOM pour plus de compatibilité. Les ensembles de données ont été répartis de manière aléatoire comme suit : 70 % pour l’entraînement, 15 % pour la validation et 15 % pour les tests, assurant une distribution stratifiée des modalités d’imagerie et des niveaux de bruit. Les statistiques de bruit ont été mesurées à l’aide de la variance moyenne des pixels avant le débruitage.
Organiser les dossiers : créez un dossier comme décrit ci-dessous :

Pour ajouter des images, copiez les images CT/MRI anonymisées dans data/raw/CT et data/raw/MRI (PNG, JPG ou DICOM). Standardiser la taille de l’image à l’aide de Python (recommandé) : exécutez la cellule de bloc-notes Resize & Convert. Il charge chaque image, convertit les niveaux de gris si nécessaire et redimensionne à 256 x 256.

Une alternative consiste à utiliser GUI (alternative ImageJ/Fiji) comme décrit. Cliquez sur Fichier > Importer > séquence d’images (ou des images uniques), puis sur Type de > d’image > 8 bits, Image > Ajuster > taille... > 256 x 256, puis Fichier > Enregistrer sous > PNG dans data/preproc/.
Créer des fractionnements : exécutez le fractionnement de la cellule de bloc-notes Train/Val/Test (70/15/15) ; Il mélange les noms de fichiers et les copie dans data/splits/train|val|test/. La console imprime les comptes (par exemple, Train : 700, Val : 150, Test : 150). Point de contrôle (observer) : Ouvrez les données/fractionne/train/ et vérifiez que les images sont de 256 x 256 et en niveaux de gris (1 canal). Conservez un petit manifeste CSV (splits.csv) qui répertorie le chemin d’accès au fichier, la modalité et l’étiquette de fractionnement.
Prétraitement de l’image
Utilisez le noyau d’affûtage 3 x 3. Effectuez l’amélioration de l’image à l’aide d’un noyau d’accentuation. Un noyau de convolution d’affûtage a été utilisé pour améliorer les limites anatomiques avant la segmentation :

Ce filtre accentue les structures importantes en boostant les composantes haute fréquence 4,5. Chaque image a été convoluée à l’aide de la bibliothèque OpenCV de Python (cv2.filter2D()) pour générer l’image améliorée. La figure 6 illustre les comparaisons avant-après.

Figure 6 : Graphique de précision de validation pour différentes valeurs de k. Diagramme à barres illustrant la précision de validation obtenue pour diverses valeurs de K utilisées dans l’étape de regroupement des K-moyennes (K = 2, 3, 4, 5). La précision culmine à K=3, indiquant une séparation optimale entre les structures anatomiques et les régions de bruit. Échelle : Valeurs de précision normalisées (0-1). Veuillez cliquer ici pour voir une version agrandie de cette figure.
Postulez (Python/OpenCV) en utilisant le code ci-dessous.

Vous pouvez également utiliser l’interface graphique alternative (ImageJ/Fiji) en cliquant sur Traiter > filtres > Convolve. Collez la matrice 3 x 3 ci-dessus et cliquez sur OK > Fichier > Enregistrer sous > PNG dans data/preproc/enhanced/. Observez le point de contrôle lorsque les bords et les limites des organes semblent plus nets ; Si des halos trop aiguisés sont observés, réduisez le poids central du noyau de 5 à 4,5 et relancez. La figure 7 montre les résultats avant et après le débruitage. Les images avant présentent clairement du bruit et du flou, tandis que les images après affichent une clarté accrue, des limites anatomiques plus nettes et un contraste amélioré, démontrant l’efficacité du pipeline de débruitage proposé.

Figure 7 : Architecture réseau NAutoencoder à convolution. Illustre l’architecture de l’auto-encodeur : couche d’entrée, encodeur (couches Conv + Pool), goulot d’étranglement, décodeur (couches Conv suréchantillonnage + transposée). Chaque couche est étiquetée avec sa taille et sa fonction. Veuillez cliquer ici pour voir une version agrandie de cette figure.
Clustering K-Means pour la segmentation
Les images améliorées ont été remodelées à l’aide de NumPy (image.reshape(-1, 1)) et regroupées à l’aide de sklearn.cluster.KMeans(n_clusters=3 ou 5). La sortie segmentée a été remodelée en 2D (np.reshape(clustered_array, image.shape)) pour visualiser les régions anatomiques par rapport aux zones de bruit14. Le tableau 1 répertorie les paramètres de segmentation.
| Sr Non | Valeur de k | Exactitude |
| 1 | 3 | 0.761 |
| 2 | 5 | 0.869 |
| 3 | 7 | 0.75 |
Tableau 1 : Valeurs de k avec les précisions de validation respectives. Ce tableau présente les précisions de validation obtenues pour différentes valeurs du paramètre de clustering k utilisé dans l’étape de segmentation des moyennes K du pipeline de débruitage. Les résultats démontrent que k = 5 donne la plus grande précision, guidant la sélection optimale des paramètres de clustering.
Segmentation K-Means : Remodelez et regroupez (Python/scikit-learn) à l’aide du code ci-dessous.

Effectuez un aperçu des couleurs (facultatif) et mappez les étiquettes aux couleurs pour un contrôle qualité visuel et des bords de superposition à partir de l’image nette. Choisissez K en exécutant avec K=3 et K=5 ; calculer la précision de la validation en aval (le Tableau 1 répertorie les paramètres ; La figure 6 montre la précision par rapport à K). Il s’agit d’un point de contrôle ; observer les pixels à dominante de bruit formant des grappes distinctes ; Les régions anatomiques doivent rester contiguës. Si de petites taches apparaissent, appliquez des limites anatomiques.
Débruitage basé sur un réseau neuronal
Description de l’architecture : voir la figure 8 pour le schéma codeur-goulot d’étranglement-décodeur. Un auto-encodeur basé sur CNN a été développé à l’aide de TensorFlow/Keras. L’architecture comprenait : couche d’entrée : image en niveaux de gris de 256 x 256, encodeur avec trois couches convolutives (noyau : 3 x 3, foulée : 1, activation de ReLU), chacune suivie d’un max-pooling ; goulot d’étranglement comme représentation latente dense, décodeur avec trois couches de suréchantillonnage avec circonvolutions transposées, sortie sous forme de couche activée par Sigmoïde produisant une image débruitée. Le tableau 2 fournit des paramètres architecturaux complets par couche.

Figure 8 : Résultats visuels du processus de débruitage. Présente l’image sonore d’origine, l’image prétraitée et la sortie débruitée finale côte à côte pour une évaluation qualitative. Démontre la préservation des bords et la réduction des artefacts. Veuillez cliquer ici pour voir une version agrandie de cette figure.
| Sr Non | Attributs de compilation | Valeurs des attributs de compilation |
| 1 | Optimiseur | Adam |
| 2 | Perte | Entropie croisée catégorielle |
| 3 | Métrique | Exactitude |
Tableau 2 : Attributs de compilation du réseau de neurones. Ce tableau détaille les principaux paramètres de compilation utilisés pour entraîner le modèle d’auto-encodeur convolutif. Ces paramètres ont été implémentés dans TensorFlow et incluent l’optimiseur, la fonction de perte, la métrique d’évaluation, le nombre d’époques et la taille du lot.
Configuration de l’entraînement : les paramètres d’entraînement comprenaient : la fonction de perte en tant qu’erreur quadratique moyenne (MSE), l’optimiseur en tant qu’Adam (taux d’apprentissage = 0,001), la taille du lot de 32 et les époques en tant que 100 avec arrêt précoce (patience = 10).
Voici un bref aperçu de la formation. Lancez la formation en allant sur Colab et en cliquant sur Runtime > Run all ; confirmez que le GPU est répertorié (par exemple, Tesla T4). Utiliser python code/train_autoencoder.py --data_root data --epochs 100 --batch 32 --lr 0.001 --early_stop 10. À l’aide de la console, la console imprime l’époque, la train_loss, la val_loss et l’heure/l’époque. Déclencheurs d’arrêt précoce après patience = 10 époques sans amélioration. Le meilleur modèle est enregistré dans runs/.../checkpoints/best.h5. Il s’agit d’un point de contrôle, observez en utilisant model.summary() qui montre la pile de couches ; Le nombre de paramètres doit correspondre à celui de la Table 2. Si vous obtenez des erreurs OOM, réduisez le lot à 16 ou définissez la taille d’entrée sur 224 x 224.
Points de contrôle intermédiaires et dépannage
Après l’accentuation et la segmentation, prévisualisez trois images par division et vérifiez que (i) les bords sont améliorés, (ii) les masques de cluster s’alignent avec l’anatomie. Pendant la formation, assurez-vous que la perte de validation diminue et ne diverge pas. Si la sortie débruitée semble trop lissée, réduisez le centre du noyau (4.5) ou augmentez les époques d’entraînement de 10 avec un taux d’apprentissage plus faible (par exemple, 5e-4).
Évaluation des performances : Les mesures quantitatives suivantes ont été utilisées : rapport signal/bruit de crête (PSNR), mesure de l’indice de similarité structurelle (SSIM) et précision de validation de la classification des images débruitées.
La méthode proposée a permis d’améliorer le PSNR de 21,52 à 28,14 dB et le SSIM de 0,76 à 0,86 par rapport aux modèles de référence présentés en 7,16. L’efficacité énergétique a été enregistrée par la surveillance de l’utilisation du GPU (journaux NVIDIA-SMI) et du temps d’entraînement. Le tableau 3 résume les résultats de la débruitage.
| Sr Non | Métrique | Modèle de référence |
| 1 | Temps d’époque moyen (s) | 25.8 |
| 2 | Énergie totale d’entraînement (kWh) | 0.52 |
| 3 | Utilisation du GPU ( %) | 85% |
| 4 | Temps d’inférence par image (ms) | 18.7 |
| 5 | Précision de la validation ( %) | 76.19% |
| 6 | PSNR (dB) | 21.52 |
| 7 | Système d’identification | 0.7619 |
Tableau 3 : Indicateurs d’évaluation du rendement de la base de référence par rapport à la méthode proposée. Ce tableau compare le pipeline de débruitage proposé à un modèle de référence sur plusieurs mesures de performances, notamment le temps d’entraînement, l’utilisation du GPU et les mesures de qualité (PSNR, SSIM et précision de validation). Les résultats indiquent une amélioration de l’efficacité énergétique et de la qualité de l’image avec la méthode proposée.
Calculez PSNR/SSIM et la consommation d’énergie. Pour PSNR/SSIM (scikit-image), utilisez le code ci-dessous.

Pour calculer l’utilisation de l’énergie/GPU, exécutez la cellule qui enregistre nvidia-smi --query-gpu=power.draw,utilization.gpu --format=csv -l 1 pour exécuter/.../gpu_log.csv pendant l’entraînement (fourni dans le notebook). Dans un second terminal, exécutez le code suivant :

Analysez CSV pour calculer la puissance moyenne (W) et intégrez-la au fil du temps d’entraînement pour l’énergie estimée (Wh = kWh). Le bloc-notes agrège le PSNR, le SSIM, la précision de validation, l’heure d’époque et l’énergie en results_table3.csv pour une inclusion directe.
Évaluation de la durabilité et simulation de télémédecine
Pour évaluer la durabilité du matériel des appareils, nous avons appliqué des bruits gaussiens et de Poisson pour simuler la dégradation de l’image des appareils vieillissants. Le modèle a restauré ces entrées dégradées à une qualité proche du diagnostic, validant leur robustesse 27,28,29. Dans les simulations de télémédecine, les images débruitées ont été transmises par une bande passante simulée de 256 Kbps à l’aide de sockets Python. La clarté visuelle a été conservée, ce qui permet le diagnostic à distance 30,31,32.
Pour la simulation du vieillissement du dispositif, appliquez le bruit gaussien (σ=10-30) et le bruit de Poisson aux images nettes (simulation du vieillissement des cellules) et enregistrez-les dans data/simulated/aged/. Exécuter le modèle entraîné sur des entrées âgées/ ; Enregistrer les sorties dans results/aged_denoised/. Observez que la qualité visuelle doit atteindre une fidélité proche du diagnostic ; comparer PSNR/SSIM avec la référence.
Pour le test de bande passante de télémédecine, compressez les images débruitées en PNG/JPEG à 85 %-95 % et envoyez-les via une liaison simulée de 256 kbit/s à l’aide du test de socket Python fourni (telemed_sim.py). Mesurer le temps d’aller-retour et le hachage de l’intégrité des fichiers ; Vérifiez qu’aucun artefact de diagnostic n’est introduit. Observez que la clarté visuelle est préservée et que les tailles de fichier sont adaptées aux flux de travail à faible bande passante.
Point de terminaison du protocole
À la fin, vous devriez avoir : (i) des images affinées dans preproc/enhanced/, (ii) des images segmentées dans preproc/segmented/, (iii) un auto-encodeur entraîné avec best.h5 dans runs/.../checkpoints/, (iv) des sorties débruitées pour les tests et des images âgées dans results/, (v) un fichier de métriques compilé (results_table3.csv) résumant PSNR, SSIM, précision de validation, temps d’époque et énergie estimée.