https://docs.google.com/presentation/d/e/2PACX-1vSfVpdcH3YzCmd9Jw5qHyrd6SLjqV4xLwMNobEnIA_9jL6hAaSyaCMYQ4dMpwhisg/pubembed?start=false&loop=false&delayms=3000
A interpretabilidade em redes neurais profundas representa um dos maiores desafios em Explainable AI, especialmente quando lidamos com arquiteturas complexas que processam milhões de parâmetros 1. Diferentemente de modelos tradicionais como árvores de decisão, as redes neurais são frequentemente consideradas "caixas pretas" devido à complexidade de suas representações internas 2. Esta aula explora técnicas avançadas para visualizar e interpretar o funcionamento interno dessas redes, permitindo compreender como diferentes camadas processam informações 3.
Visualização de rede neural com fluxo de gradientes e mapas de ativação
As redes neurais convolucionais (CNNs) processam imagens através de múltiplas camadas hierárquicas, onde cada camada aprende características progressivamente mais complexas 4. As camadas iniciais detectam características simples como bordas e texturas, enquanto camadas mais profundas identificam objetos e conceitos de alto nível 5. A visualização dessas representações internas é fundamental para compreender o processo de tomada de decisão da rede 1.
A organização hierárquica das CNNs permite que características simples sejam combinadas para formar representações mais complexas 6. Por exemplo, detectores de bordas nas primeiras camadas se combinam para formar detectores de texturas, que posteriormente formam detectores de partes de objetos 5. Esta progressão hierárquica é essencial para o poder representacional das redes neurais profundas 3.
*# Instalação das bibliotecas necessárias*
!pip install tensorflow keras matplotlib numpy opencv-python
!pip install grad-cam
*# Importações essenciais*
import tensorflow as tf
from tensorflow import keras
import numpy as np
import matplotlib.pyplot as plt
import cv2
from tensorflow.keras.applications import VGG16, ResNet50
from tensorflow.keras.preprocessing import image
from tensorflow.keras.applications.vgg16 import preprocess_input, decode_predictions
*# Carregar modelo pré-treinado*
model = VGG16(weights='imagenet', include_top=True)
*# Função para extrair feature maps de uma camada específica*
def get_feature_maps(model, layer_name, img_array):
intermediate_layer_model = keras.Model(
inputs=model.input,
outputs=model.get_layer(layer_name).output
)
feature_maps = intermediate_layer_model.predict(img_array)
return feature_maps
*# Carregar e preprocessar imagem*
img_path = 'example_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)
img_array = preprocess_input(img_array)
*# Extrair feature maps da primeira camada convolucional*
feature_maps = get_feature_maps(model, 'block1_conv1', img_array)
*# Visualizar primeiros 16 filtros*
fig, axes = plt.subplots(4, 4, figsize=(12, 12))
for i in range(16):
ax = axes[i // 4, i % 4]
ax.imshow(feature_maps[0, :, :, i], cmap='viridis')
ax.set_title(f'Filter {i+1}')
ax.axis('off')
plt.tight_layout()
plt.show()
*# Função para analisar ativações em diferentes profundidades*
def analyze_layer_activations(model, img_array, layer_names):
results = {}
for layer_name in layer_names:
*# Extrair ativações*
feature_maps = get_feature_maps(model, layer_name, img_array)
*# Estatísticas das ativações*
mean_activation = np.mean(feature_maps)
std_activation = np.std(feature_maps)
max_activation = np.max(feature_maps)
sparsity = np.mean(feature_maps == 0) *# Porcentagem de zeros (ReLU)*
results[layer_name] = {
'shape': feature_maps.shape,
'mean': mean_activation,
'std': std_activation,
'max': max_activation,
'sparsity': sparsity
}
return results
*# Analisar múltiplas camadas*
layer_names = ['block1_conv1', 'block2_conv1', 'block3_conv1', 'block4_conv1', 'block5_conv1']
activation_stats = analyze_layer_activations(model, img_array, layer_names)
*# Visualizar estatísticas*
for layer, stats in activation_stats.items():
print(f"\\n{layer}:")
print(f" Shape: {stats['shape']}")
print(f" Mean activation: {stats['mean']:.4f}")
print(f" Std activation: {stats['std']:.4f}")
print(f" Max activation: {stats['max']:.4f}")
print(f" Sparsity: {stats['sparsity']:.2%}")
A visualização de camadas é fundamental para identificar quando modelos aprendem correlações espúrias em vez de características relevantes 9. Por exemplo, um modelo pode focar no fundo da imagem em vez do objeto principal, revelando possíveis problemas no dataset ou arquitetura 10. Grad-CAM ajuda a detectar esses vieses ao mostrar exatamente onde o modelo direciona sua atenção 11.
As técnicas de visualização permitem identificar neurônios "mortos" (que sempre produzem zero) ou camadas que não contribuem significativamente para a predição 12. A análise de sparsidade das ativações revela a eficiência da rede e pode guiar decisões sobre poda de neurônios 1. Guided Backpropagation é particularmente útil para identificar características que o modelo considera importantes 13.