Projeto EfficientNetV2_ViT_Hybrid - Classificação de Displasia

📋 Descrição do Projeto

Este projeto implementa uma rede neural híbrida para classificação de imagens histopatológicas de displasia utilizando o dataset OralEphiteliumDB. O modelo combina três arquiteturas diferentes:

1. EfficientNetV2B0 (pré-treinada) - Extração de características robustas
2. Vision Transformer customizado - Processamento baseado em patches
3. Seção de "pescoço" (neck) - Camadas convolucionais tradicionais

🔬 Dataset

O projeto trabalha com imagens histopatológicas classificadas em 4 graus de severidade:

• Healthy (Saudável) - Tecido saudavel
• Mild (Leve) - Carcinoma grau baixo
• Moderate (Moderado) - Carcinoma grau intermediário
• Severe (Severo) - Carcinoma grau alto

Estrutura de Diretórios Necessária

OralEpithelium_Dysplasia_Classification/
├── Dataset/
│   └── Originais/
│       ├── healthy/     # Imagens .tif de tecido saudável
│       ├── mild/        # Imagens .tif de carcinoma leve
│       ├── moderate/    # Imagens .tif de carcinoma moderado
│       └── severe/      # Imagens .tif de carcinoma severo
├── NewAumentado/        # Criado automaticamente pelo código
├── OralEpithelium_Dysplasia_Classification.ipynb
└── README.md

🛠️ Configuração do Ambiente

Dependências Principais

pip install tensorflow>=2.10.0
pip install keras
pip install pandas
pip install numpy
pip install matplotlib
pip install seaborn
pip install scikit-learn
pip install opencv-python
pip install tqdm
pip install openpyxl
pip install pydot
pip install graphviz

Configuração de GPU (Opcional)

O código detecta automaticamente GPUs disponíveis usando tf.distribute.MirroredStrategy() para treinamento distribuído.

📊 Como Usar

1. Preparação dos Dados

Execute as células de preparação que irão:

• Criar diretórios de trabalho (NewAumentado/)
• Copiar imagens do dataset original
• Aplicar balanceamento de classes via upsampling
• Dividir dados em treino (49%), validação (21%) e teste (30%)

2. Configuração do Modelo

Parâmetros Principais:

size = 128              # Tamanho das imagens (128x128)
epochs = 100            # Número de épocas
batch_size = 32         # Tamanho do lote (testado: 1, 8, 16, 32, 64)
num_classes = 2         # Classes (2 ou 4 classes)
patch_size = (32, 32)   # Tamanho dos patches para Vision Transformer

Configurações de Classificação:

Para 2 Classes (Binária):

# Exemplo: Saudável vs Severo
data = pd.DataFrame(index=np.arange(0, len(healthy_images) + len(severe_images)), 
                    columns=["image", "target"])
num_classes = 2

Para 4 Classes (Multiclasse):

# Todas as classes
data = pd.DataFrame(index=np.arange(0, len(healthy_images) + len(mild_images) + 
                                       len(moderate_images) + len(severe_images)), 
                    columns=["image", "target"])
num_classes = 4

3. Treinamento

O modelo é treinado com:

• Data Augmentation: Rotação, zoom, cisalhamento, deslocamento
• Callbacks: Early stopping, redução de learning rate, log CSV
• Métricas: Accuracy, Precision, Recall, F1-Score, AUC, IoU, Tversky

4. Avaliação

Após o treinamento, são gerados:

• Matriz de confusão (Matriz de Confusão.png)
• Gráficos de métricas (Model-Results.png)
• Modelo salvo (modelBH_Dataset.h5)
• Histórico de treinamento (output.xlsx)
• Predições (predy.npy, truey.npy)

📈 Arquitetura do Modelo

Componentes:

1. EfficientNet Bottleneck:

   • EfficientNetV2B0 pré-treinada (ImageNet)
   • GlobalAveragePooling2D
   • Dense(256) + BatchNormalization

2. Vision Transformer:

   • Processamento por patches (32x32)
   • Camadas Conv2D + MaxPooling2D
   • Flatten para concatenação

3. Neck Section:

   • Conv2D(256, kernel=7x7)
   • BatchNormalization + PReLU
   • MaxPooling2D + Flatten

4. Fusão e Classificação:

   • Concatenação das três arquiteturas
   • Dense final com softmax

Métricas Customizadas:

- IoU (Intersection over Union)
- Sensitivity (Recall)
- Specificity 
- F1-Score
- Dice Coefficient
- Tversky Loss/Index

🔧 Ajustes de Configuração

Mudança de Diretório do Dataset:

Edite as linhas que referenciam o caminho do dataset:

# Linha ~240 - Ajustar para seu caminho
files_healthy = getListOfFiles('SEU_CAMINHO/Dataset/Originais/healthy')
files_moderate = getListOfFiles('SEU_CAMINHO/Dataset/Originais/moderate')
files_mild = getListOfFiles('SEU_CAMINHO/Dataset/Originais/mild')  
files_severe = getListOfFiles('SEU_CAMINHO/Dataset/Originais/severe')

Diferentes Combinações de Classes:

O código está preparado para testar várias combinações binárias:

# Descomente a linha desejada:
# data = pd.DataFrame(..., len(healthy_images) + len(severe_images))    # Saudável vs Severo
# data = pd.DataFrame(..., len(healthy_images) + len(mild_images))      # Saudável vs Leve  
# data = pd.DataFrame(..., len(healthy_images) + len(moderate_images))  # Saudável vs Moderado
# data = pd.DataFrame(..., len(mild_images) + len(moderate_images))     # Leve vs Moderado
# data = pd.DataFrame(..., len(moderate_images) + len(severe_images))   # Moderado vs Severo
# data = pd.DataFrame(..., len(mild_images) + len(severe_images))       # Leve vs Severo

Alteração do Batch Size:

Para experimentar com diferentes tamanhos de lote, modifique a variável batch_size:

#batch_size = 1     
#batch_size = 8     
#batch_size = 16    
batch_size = 32     # (padrão atual)
#batch_size = 64    

Impacto do Batch Size:

• Menor (1-8): Treinamento mais lento, mas usa menos memória
• Médio (16-32): Bom equilíbrio entre velocidade e uso de memória
• Maior (64+): Treinamento mais rápido, requer mais memória GPU

Ajuste da Matriz de Confusão:

Edite os labels na função confusion_matrix_img():

# Para diferentes classificações, ajuste:
labels = ['healthy','severe']     # Saudável vs Severo
title = 'Matriz de Confusão Saudável X Severo'

📁 Estrutura de Resultados

Cada execução gera uma pasta com:

batch_size_X(Y classes)/
├── Model-Results.png        # Gráficos de métricas
├── Model.log               # Log de treinamento  
├── modelBH_Dataset.h5      # Modelo treinado
├── output.xlsx             # Histórico detalhado
├── predy.npy              # Predições
├── truey.npy              # Labels verdadeiros
├── Matriz de Confusão.png  # Matriz de confusão
└── Resultado batch_size=X.png  # Resultado final

🚀 Execução Rápida

1. Configure o ambiente com as dependências
2. Organize o dataset na estrutura especificada
3. Ajuste os parâmetros (classes, batch_size, epochs)
4. Execute o notebook célula por célula
5. Analise os resultados gerados

⚠️ Observações Importantes

• Memória: Modelos grandes requerem GPU com ≥8GB VRAM
• Tempo: Treinamento pode levar várias horas dependendo do hardware
• Balanceamento: Upsampling automático equilibra classes desbalanceadas
• Reprodutibilidade: Seeds fixas para resultados consistentes (random_state=42)

---

Desenvolvido para pesquisa em análise de imagens histopatológicas de carcinoma de mama.