$$\rightleftharpoonup{xx}$$
$$\longleftharp{xx}$$,
$$\longrightharp{xx}$$,
Este estudo utilizou exclusivamente conjuntos de dados de imagens de TC e RM não identificados e disponíveis publicamente. Nenhum sujeito humano ou animal vivo estava envolvido. Portanto, não foi necessária a aprovação do comitê de ética ou do comitê de ética em pesquisa.
Visão geral do método
Este protocolo apresenta um pipeline reproduzível para redução de ruído de imagens médicas com eficiência energética. Ele combina técnicas de pré-processamento, incluindo filtros de nitidez e clustering K-means, com um autoencoder baseado em rede neural convolucional (CNN) para reduzir o ruído das imagens. Este método integrado melhora a qualidade da imagem enquanto reduz o tempo de treinamento e o consumo de energia do hardware, apoiando diagnósticos médicos sustentáveis 19,20,21,22,23. A Figura 5 resume a estrutura de ponta a ponta.

Figura 5: Proposta de arquitetura de estrutura de redução de ruído. Esta figura descreve o pipeline completo: aquisição de dados, pré-processamento (nitidez + segmentação K-means), seguido por redução de ruído do autoencoder baseado em CNN. Ele enfatiza a abordagem híbrida que visa reduzir o uso de energia, preservando a fidelidade estrutural. Clique aqui para ver uma versão maior desta figura.
O fluxo de trabalho completo está resumido na Figura 5, que mostra a sequência desde a configuração do conjunto de dados até o pré-processamento (nitidez e K-means) para a redução de ruído do codificador automático da CNN para o teste.
Configuração de software e ambiente
Opção A - Google Colab (recomendado para reprodutibilidade): Vá para colab.research.google.com, clique em Novo Bloco de Anotações. Selecione Tempo de execução > Alterar o tipo de tempo de execução > Acelerador de hardware: GPU > Salvar. Clique em Arquivo > Upload para fazer upload do notebook fornecido e do conjunto de dados .zip (ou conecte o Google Drive clicando em Arquivos > unidade de montagem). Na primeira célula de código, instale as dependências (já no notebook): pip install opencv-python scikit-image scikit-learn tensorflow matplotlib numpy pandas. Clique em Tempo de execução > Executar tudo. Confirme se você vê: (i) resumo do ambiente com versões de pacote, (ii) nome da GPU (na saída da célula) e (iii) criação de uma pasta de experimento runs/AAAA-MM-DD/.
Opção B - Local (conda): Abra o Anaconda Prompt/Terminal e execute:

Coloque seu conjunto de dados em data/raw/ e scripts em code/. Execute: python code/train_autoencoder.py --data_root data --img_size 256 --k_values 3 5 --epochs 100 --batch 32 --lr 0.001. Confirme para ver: impressão do ambiente, GPU detectada e um diretório de log runs/AAAA-MM-DD/.
Preparação do conjunto de dados
Conjuntos de dados disponíveis publicamente de tomografias computadorizadas e ressonâncias magnéticas foram obtidos de repositórios de imagens médicas. Esses conjuntos de dados continham ruídos típicos de exames clínicos do mundo real e foram desidentificados de acordo com os padrões institucionais e éticos 8,9. Cada imagem foi redimensionada para 256 x 256 pixels e armazenada no formato PNG ou DICOM para compatibilidade. Os conjuntos de dados foram divididos aleatoriamente da seguinte forma: 70% para treinamento, 15% para validação e 15% para teste, garantindo uma distribuição estratificada das modalidades de imagem e níveis de ruído⁶. As estatísticas de ruído foram medidas usando a variância média de pixels antes da redução de ruído.
Organize pastas: Crie uma pasta conforme descrito abaixo:

Para adicionar imagens, copie imagens de TC/RM não identificadas em dados/bruto/TC e dados/bruto/RESSONÂNCIA MAGNÉTICA (PNG, JPG ou DICOM). Padronizar o tamanho da imagem usando Python (recomendado): Execute a célula do notebook Resize & convert. Ele carrega cada imagem, converte a escala de cinza, se necessário, e redimensiona para 256 x 256 .

Uma alternativa é usar a GUI (alternativa ImageJ/Fiji) conforme descrito. Clique em Arquivo > Importar > sequência de imagens (ou imagens únicas) e, em seguida , em Tipo de > de imagem > 8 bits, Ajustar > de imagem > tamanho... > 256 x 256 e, em seguida, Arquivo > Salvar como PNG > em data/preproc/.
Criar divisões: Execute a célula do notebook Train/Val/Test split (70/15/15); ele embaralha os nomes dos arquivos e os copia em data/splits/train|val|test/. O console imprime as contagens (por exemplo, Trem: 700, Val: 150, Teste: 150). Ponto de verificação (observar): Abra os dados / divide / treine / e verifique se as imagens são 256 x 256 e em tons de cinza (1 canal). Mantenha um pequeno manifesto CSV (splits.csv) que liste o caminho do arquivo, a modalidade e o rótulo dividido.
Pré-processamento de imagem
Use o kernel de afiação 3 x 3. Execute o aprimoramento da imagem usando um kernel de nitidez. Um kernel de convolução de nitidez foi usado para melhorar os limites anatômicos antes da segmentação:

Este filtro acentua estruturas importantes, aumentando os componentes de alta frequência 4,5. Cada imagem foi convolvida usando a biblioteca OpenCV do Python (cv2.filter2D()) para gerar a imagem aprimorada. A Figura 6 ilustra as comparações antes e depois.

Figura 6: Gráfico de precisão de validação para diferentes valores de k. Gráfico de barras ilustrando a precisão de validação alcançada para vários valores de K usados na etapa de agrupamento de K-means (K = 2, 3, 4, 5). A precisão atinge o pico em K=3, indicando separação ideal entre estruturas anatômicas e regiões de ruído. Escala: Valores de precisão normalizados (0-1). Clique aqui para ver uma versão maior desta figura.
Aplique (Python/OpenCV) usando o código abaixo.

Ou use a alternativa GUI (ImageJ/Fiji) clicando em Processar > Filtros > Convolve. Cole a matriz 3 x 3 acima e clique em OK > Arquivo > Salvar como PNG > em data/preproc/enhanced/. Observe o ponto de verificação à medida que as bordas e os limites dos órgãos parecem mais nítidos; Se forem observados halos superafiados, reduza o peso central do kernel de 5 para 4,5 e execute novamente. A Figura 7 mostra os resultados de redução de ruído antes e depois. As imagens anteriores exibem claramente ruído e desfoque, enquanto as imagens posteriores exibem maior clareza, limites anatômicos mais nítidos e contraste aprimorado, demonstrando a eficácia do pipeline de redução de ruído proposto.

Figura 7: Arquitetura de rede NAutoencoder de convolução. Ilustra a arquitetura do autoencoder: camada de entrada, codificador (camadas Conv + Pool), gargalo, decodificador (camadas Upsampling + Conv transpostas). Cada camada é rotulada com tamanho e função. Clique aqui para ver uma versão maior desta figura.
Agrupamento K-Means para segmentação
As imagens aprimoradas foram remodeladas usando NumPy (image.reshape(-1, 1)) e agrupadas usando sklearn.cluster.KMeans(n_clusters=3 ou 5). A saída segmentada foi remodelada de volta para 2D (np.reshape(clustered_array, image.shape)) para visualizar regiões anatômicas versus zonas de ruído14. A Tabela 1 lista as configurações de segmentação.
| Sr Não | Valor de k | Exatidão |
| 1 | 3 | 0.761 |
| 2 | 5 | 0.869 |
| 3 | 7 | 0.75 |
Tabela 1: Valores de k com as respectivas precisões de validação. Esta tabela apresenta as precisões de validação obtidas para diferentes valores do parâmetro de agrupamento k usado na etapa de segmentação K-means do pipeline de redução de ruído. Os resultados demonstram que k = 5 produz a maior precisão, orientando a seleção ideal do parâmetro de agrupamento.
Segmentação K-Means: remodele e agrupe (Python / scikit-learn) usando o código abaixo.

Execute a visualização de cores (opcional) e mapeie rótulos para cores para controle de qualidade visual e bordas de sobreposição da imagem nítida. Escolha K executando com K = 3 e K = 5; calcular a precisão da validação downstream (Tabela 1 lista as configurações; A Figura 6 mostra a precisão versus K). Este é um posto de controle; observar pixels com predominância de ruído formando clusters distintos; as regiões anatômicas devem permanecer contíguas. Se aparecerem pequenas manchas, aplique limites anatômicos.
Redução de ruído baseada em rede neural
Descrição da arquitetura: consulte a Figura 8 para obter o esquema do codificador-gargalo-decodificador. Um autoencoder baseado em CNN foi desenvolvido usando TensorFlow/Keras. A arquitetura incluiu: camada de entrada: imagem em tons de cinza de 256 x 256, codificador com três camadas convolucionais (kernel: 3 x 3, stride: 1, ativação ReLU), cada uma seguida de max-pooling; gargalo como representação latente densa, decodificador com três camadas de amostragem ascendente com convoluções transpostas, saída como camada ativada por Sigmoid produzindo uma imagem sem ruído. A Tabela 2 fornece parâmetros arquitetônicos completos em camadas.

Figura 8: Resultados visuais do processo de redução de ruído. Apresenta imagem ruidosa original, imagem pré-processada e saída final sem ruído lado a lado para avaliação qualitativa. Demonstra a preservação da borda e a redução de artefatos. Clique aqui para ver uma versão maior desta figura.
| Sr Não | Atributos de compilação | Valores de atributos de compilação |
| 1 | Otimizador | Adam |
| 2 | Perda | Entropia cruzada categórica |
| 3 | Métricas | Exatidão |
Tabela 2: Atributos de compilação da rede neural. Esta tabela detalha os principais parâmetros de compilação usados para treinar o modelo de codificador automático convolucional. Essas configurações foram implementadas no TensorFlow e incluem o otimizador, a função de perda, a métrica de avaliação, o número de épocas e o tamanho do lote.
Configuração de treinamento: Os parâmetros de treinamento incluíram: função de perda como Erro Quadrático Médio (MSE), otimizador como Adam (taxa de aprendizado = 0,001), tamanho do lote de 32 e épocas como 100 com parada precoce (paciência = 10).
Uma breve visão geral do treinamento é a seguinte. Inicie o treinamento acessando o Colab e clicando em Tempo de execução > Executar tudo; confirme se a GPU está listada (por exemplo, Tesla T4). Use código/train_autoencoder.py python --data_root data --epochs 100 --batch 32 --lr 0.001 --early_stop 10. Monitore usando o console imprime época, train_loss, val_loss e hora/época. A interrupção precoce é desencadeada após paciência = 10 épocas sem melhora. O melhor modelo é salvo em runs/.../checkpoints/best.h5. Este é um ponto de verificação, observe usando o model.summary() que mostra a pilha de camadas; a contagem de parâmetros deve corresponder à Tabela 2. Se você receber erros de OOM, reduza o lote para 16 ou defina o tamanho da entrada para 224 x 224.
Pontos de verificação intermediários e solução de problemas
Após a nitidez e a segmentação, visualize três imagens por divisão e confirme (i) se as bordas são aprimoradas, (ii) as máscaras de cluster se alinham com a anatomia. Durante o treinamento, certifique-se de que a perda de validação diminua e não diverja. Se a saída sem ruído parecer muito suavizada, reduza o centro do kernel (4.5) ou aumente as épocas de treinamento em 10 com uma taxa de aprendizado mais baixa (por exemplo, 5e-4).
Avaliação de desempenho: As seguintes métricas quantitativas foram usadas: Relação sinal-ruído de pico (PSNR), Medida do Índice de Similaridade Estrutural (SSIM) e Precisão de validação da classificação de imagens sem ruído.
O método proposto melhorou o PSNR de 21,52 para 28,14 dB e o SSIM de 0,76 para 0,86 em comparação com os modelos de linha de base apresentados em 7,16. A eficiência energética foi registrada monitorando o uso da GPU (logs NVIDIA-SMI) e o tempo de treinamento. A Tabela 3 resume os resultados de redução de ruído.
| Sr Não | Métrica | Modelo de linha de base |
| 1 | Tempo médio de época (seg) | 25.8 |
| 2 | Energia total de treinamento (kWh) | 0.52 |
| 3 | Utilização da GPU (%) | 85% |
| 4 | Tempo de inferência por imagem (ms) | 18.7 |
| 5 | Precisão de validação (%) | 76.19% |
| 6 | PSNR (dB) | 21.52 |
| 7 | SSIM | 0.7619 |
Tabela 3: Métricas de avaliação de desempenho da linha de base versus o método proposto. Esta tabela compara o pipeline de redução de ruído proposto com um modelo de linha de base em várias métricas de desempenho, incluindo tempo de treinamento, utilização de GPU e medidas de qualidade (PSNR, SSIM e precisão de validação). Os resultados indicam melhoria da eficiência energética e da qualidade da imagem com o método proposto.
Calcule PSNR/SSIM e uso de energia. Para PSNR/SSIM (scikit-image), use o código abaixo.

Para uso de energia de computação/GPU, execute a célula que registra nvidia-smi --query-gpu=power.draw,utilization.gpu --format=csv -l 1 to runs/.../gpu_log.csv durante o treinamento (fornecido no notebook). Em um segundo terminal, execute o seguinte código:

Analise CSV para calcular a potência média (W) e integre ao longo do tempo de treinamento a energia estimada (Wh = kWh). O notebook agrega PSNR, SSIM, precisão de validação, tempo de época e energia em results_table3.csv para inclusão direta.
Avaliação de sustentabilidade e simulação de telemedicina
Para avaliar a sustentabilidade do hardware do dispositivo, aplicamos o ruído gaussiano e de Poisson para simular a degradação da imagem de dispositivos antigos. O modelo restaurou essas entradas degradadas para uma qualidade quase diagnóstica, validando sua robustez 27,28,29. Em simulações de telemedicina, imagens sem ruído foram transmitidas por largura de banda simulada de 256 Kbps usando soquetes Python. A clareza visual foi mantida, suportando diagnósticos remotos 30,31,32.
Para simulação de envelhecimento do dispositivo, aplique ruído gaussiano (σ=10-30) e ruído de Poisson para limpar imagens (simulação de envelhecimento celular) e salve em dados/simulado/envelhecido/. Execute o modelo treinado em entradas antigas/; salve as saídas em results/aged_denoised/. Observe que a qualidade visual deve atingir fidelidade quase diagnóstica; comparar PSNR/SSIM com a linha de base.
Para teste de largura de banda de telemedicina, compacte imagens com ruído para PNG/JPEG em 85% a 95% e envie um link simulado de 256 kbps usando o teste de soquete Python (telemed_sim.py) fornecido. Meça o tempo de ida e volta e o hash de integridade do arquivo; Verifique se nenhum artefato de diagnóstico foi introduzido. Observe que a clareza visual é preservada e os tamanhos de arquivo adequados para fluxos de trabalho de baixa largura de banda.
Ponto de extremidade do protocolo
Na conclusão, você deve ter: (i) imagens nítidas em preproc/enhanced/, (ii) imagens segmentadas em preproc/segmented/, (iii) um autoencoder treinado com best.h5 em runs/.../checkpoints/, (iv) saídas sem ruído para imagens de teste e envelhecidas em results/, (v) um arquivo de métricas compilado (results_table3.csv) resumindo PSNR, SSIM, precisão de validação, tempo de época e energia estimada.