A radiologia é uma área que depende significativamente da experiência de profissionais altamente qualificados. Os radiologistas analisam imagens médicas para diagnosticar e monitorar uma série de condições, desde fraturas simples até doenças complexas, como o câncer. No entanto, com o aumento das imagens médicas e a necessidade urgente de diagnósticos rápidos e precisos, os radiologistas estão sob uma enorme pressão. É aqui que entra a inteligência artificial (IA), transformando o campo ao melhorar as capacidades humanas. Ao final deste artigo, você terá criado seu próprio modelo de classificador de imagens para auxiliar na detecção de pneumonia em imagens médicas.
Etapa 1: configurando seu ambiente
Antes de mergulhar na codificação, precisamos garantir que nosso ambiente esteja pronto. Começaremos instalando as bibliotecas necessárias:
%pip install --upgrade tensorflow keras numpy pandas sklearn pillow
Essas bibliotecas são essenciais para construir e treinar nosso modelo:
-
tensorflowekeraspara criação e treinamento de redes neurais. -
numpypara operações numéricas. -
pandaspara manipulação de dados. -
sklearnpara pré-processamento de dados. -
pillowpara processamento de imagens.
Passo 2: Importando Bibliotecas
Com as bibliotecas instaladas, vamos importá-las:
import os from tensorflow import keras from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense, Conv2D, MaxPool2D, Flatten from tensorflow.keras.preprocessing.image import ImageDataGenerator import numpy as np
Começamos importando diversas bibliotecas e módulos essenciais necessários para construir e treinar um modelo de rede neural para tarefas de processamento de imagens. Usaremos o TensorFlow e seus submódulos para criar e gerenciar nossos modelos de aprendizado profundo. Especificamente, importaremos Keras para usar como nossa API de alto nível, Sequential para construir uma pilha linear de camadas e módulos como Dense, Conv2D, MaxPool2D e Flatten para construir e configurar várias camadas de rede neural. Além disso, ImageDataGenerator nos ajudará a aumentar nossos dados de imagem, aumentando a capacidade de generalização do modelo. Por último, importaremos numpy pelo seu suporte a operações numéricas, particularmente útil para lidar com arrays e executar funções matemáticas.
Etapa 3: Preparando os Dados
Nosso radiologista de IA precisa de dados para aprender. Usaremos o ImageDataGenerator para carregar e aumentar nossos dados de treinamento e validação: para baixar os dados, usaremos nosso amigo de dados de código aberto Kaggle, baixe o conjunto de dados rotulado no link aqui.
No contexto da aprendizagem supervisionada aqui, o conjunto de dados rotulado será a verdade básica que o modelo de aprendizagem de máquina deve prever.
trdata = ImageDataGenerator() traindata = trdata.flow_from_directory(directory="data-task1/train", target_size=(224, 224)) tsdata = ImageDataGenerator() testdata = tsdata.flow_from_directory(directory="data-task1/val", target_size=(224, 224))
Este trecho de código configura geradores de dados para nossos conjuntos de dados de treinamento e validação. As imagens são redimensionadas para 224x224 pixels, o tamanho de entrada padrão para o modelo VGG16.
Etapa 4: Construindo o Modelo VGG16
Agora vem a parte divertida: construir o modelo VGG16. VGG16 é uma arquitetura popular de rede neural convolucional (CNN), conhecida por sua simplicidade e eficácia graças à sua arquitetura exclusiva construída principalmente em 13 camadas convolucionais e 3 camadas totalmente conectadas. O que diferencia o VGG16 é o uso de pequenos filtros convolucionais 3x3 em uma rede profunda. Este design captura padrões intrincados em imagens, garantindo eficiência computacional. Veja como o criamos:
model = Sequential() model.add(Conv2D(input_shape=(224,224,3), filters=64, kernel_size=(3,3), padding="same", activation="relu")) model.add(Conv2D(filters=64, kernel_size=(3,3), padding="same", activation="relu")) model.add(MaxPool2D(pool_size=(2,2), strides=(2,2))) model.add(Conv2D(filters=128, kernel_size=(3,3), padding="same", activation="relu")) model.add(Conv2D(filters=128, kernel_size=(3,3), padding="same", activation="relu")) model.add(MaxPool2D(pool_size=(2,2), strides=(2,2))) model.add(Conv2D(filters=256, kernel_size=(3,3), padding="same", activation="relu")) model.add(Conv2D(filters=256, kernel_size=(3,3), padding="same", activation="relu")) model.add(Conv2D(filters=256, kernel_size=(3,3), padding="same", activation="relu")) model.add(MaxPool2D(pool_size=(2,2), strides=(2,2))) model.add(Conv2D(filters=512, kernel_size=(3,3), padding="same", activation="relu")) model.add(Conv2D(filters=512, kernel_size=(3,3), padding="same", activation="relu")) model.add(Conv2D(filters=512, kernel_size=(3,3), padding="same", activation="relu")) model.add(MaxPool2D(pool_size=(2,2), strides=(2,2))) model.add(Conv2D(filters=512, kernel_size=(3,3), padding="same", activation="relu")) model.add(Conv2D(filters=512, kernel_size=(3,3), padding="same", activation="relu")) model.add(Conv2D(filters=512, kernel_size=(3,3), padding="same", activation="relu")) model.add(MaxPool2D(pool_size=(2,2), strides=(2,2))) model.add(Flatten()) model.add(Dense(units=4096, activation="relu")) model.add(Dense(units=4096, activation="relu")) model.add(Dense(units=2, activation="softmax")) model.summary()
Vamos decompô-lo:
- Camadas Conv2D: são camadas convolucionais que aprendem a detectar recursos como bordas e texturas.
- Camadas MaxPool2D: Reduzem as dimensões espaciais, mantendo características importantes.
- Camada nivelada: converte os mapas de recursos 2D em um vetor 1D.
- Camadas densas: são camadas totalmente conectadas para classificação.
Etapa 5: Compilando o Modelo
Com nossa arquitetura de modelo definida, precisamos compilá-la:
opt = keras.optimizers.Adam(learning_rate=0.001) model.compile(optimizer=opt, loss=keras.losses.binary_crossentropy, metrics=['accuracy'])
Aqui, usamos o otimizador Adam com uma taxa de aprendizado de 0,001 e entropia cruzada binária como nossa função de perda, adequada para tarefas de classificação binária. vamos analisar os prós e os contras dessas escolhas:
Componente | Vantagens | Desvantagens |
|---|---|---|
Adam Otimizador | 1. Taxas de aprendizagem adaptativas 2. Funciona bem com configurações padrão. | Potencial para overfitting com modelos complexos. |
Perda de entropia cruzada binária | Ideal para classificação binária | não é muito compatível com minha função de ativação da camada de saída, por quê? (deixe nos comentários!) |
Sinta-se à vontade para experimentar diferentes otimizadores, taxas de aprendizado e funções de perda, pois essa é uma ótima maneira de ganhar experiência.
Etapa 6: treinar o modelo
É hora de treinar nosso radiologista de IA! Configuramos retornos de chamada para salvar o melhor modelo e parar antecipadamente se a precisão da validação parar de melhorar:
from keras.callbacks import ModelCheckpoint, EarlyStopping checkpoint = ModelCheckpoint("vgg16_1.h5", monitor='val_accuracy', verbose=1, save_best_only=True, save_weights_only=False, mode='auto', period=1) early = EarlyStopping(monitor='val_accuracy', min_delta=0, patience=20, verbose=1, mode='auto') hist = model.fit_generator(steps_per_epoch=20, generator=traindata, validation_data=testdata, validation_steps=10, epochs=10, callbacks=[checkpoint, early])
- ModelCheckpoint: salva o melhor modelo com base na precisão da validação.
- EarlyStopping: Interrompe o treinamento se o desempenho do modelo não melhorar por um número especificado de épocas.
Etapa 7: Visualizando o Progresso do Treinamento
Para ver como está o desempenho do nosso modelo, podemos representar graficamente a perda e a precisão do treinamento e validação:
import matplotlib.pyplot as plt # Training loss plt.plot(hist.history['loss']) plt.legend(['Training']) plt.title('Training loss') plt.ylabel('loss') plt.xlabel('epoch') plt.show() # Validation loss plt.plot(hist.history['val_loss']) plt.legend(['Validation']) plt.title('Validation loss') plt.ylabel('validation loss') plt.xlabel('epoch') plt.show() # Training and validation accuracy plt.plot(hist.history['accuracy']) plt.plot(hist.history['val_accuracy']) plt.legend(['Training', 'Validation']) plt.title('Training & Validation accuracy') plt.xlabel('epoch') plt.show()Esses gráficos nos ajudarão a entender quão bem nosso modelo está aprendendo e se ele está sobreajustado ou insuficiente.
Etapa 8: fazer previsões
Após o treinamento, nosso radiologista de IA está pronto para fazer previsões. Veja como você pode carregar uma imagem e obter a previsão do modelo:
from tensorflow.keras.preprocessing import image # Load and preprocess image img_path = 'path_to_your_image.jpg' img = image.load_img(img_path, target_size=(224, 224)) img_array = image.img_to_array(img) img_array = np.expand_dims(img_array, axis=0) # Create batch axis # Make prediction prediction = model.predict(img_array) print('Prediction:', prediction)Etapa 9: ajuste fino e experimentação
Construir um radiologista de IA é apenas o começo. Aqui estão algumas dicas para ajustar e melhorar seu modelo:
- Aumento de dados: Aumente a variedade de seus dados de treinamento com técnicas como rotação, inversão e zoom.
- Aprendizagem por transferência: use modelos pré-treinados como VGG16 como ponto de partida e ajuste-os em seu conjunto de dados específico.
- Ajuste de hiperparâmetros: experimente diferentes taxas de aprendizado, tamanhos de lote e otimizadores para encontrar a melhor combinação.
Conclusão
Uau, trabalho incrível! 🎉 Você criou um modelo que pode analisar imagens médicas e fazer previsões – que grande conquista médica! :) Ao mergulhar profundamente nas complexidades das arquiteturas de redes neurais, você viu o quão impactante um modelo de IA bem ajustado pode ser. Continue ultrapassando limites, experimentando e, o mais importante, aproveite cada momento de trabalho com seus projetos de IA!
