Módulo 4: Implementação e Avaliação

1. Preparação e Treinamento

import numpy as np
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers

*# 1. Carregar e normalizar MNIST*
(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()
x_train = x_train.astype("float32") / 255.0
x_test  = x_test.astype("float32")  / 255.0

*# Expandir dimensão de canal*
x_train = np.expand_dims(x_train, -1)  *# (60000, 28, 28, 1)*
x_test  = np.expand_dims(x_test, -1)   *# (10000, 28, 28, 1)# One-hot das labels*
y_train = keras.utils.to_categorical(y_train, 10)
y_test  = keras.utils.to_categorical(y_test, 10)

*# 2. Definir e compilar CNN simples*
model = keras.models.Sequential([
    layers.Input((28,28,1)),
    layers.Conv2D(32, 3, activation="relu"),
    layers.MaxPooling2D(),
    layers.Conv2D(64, 3, activation="relu"),
    layers.MaxPooling2D(),
    layers.Flatten(),
    layers.Dropout(0.5),
    layers.Dense(128, activation="relu"),
    layers.Dense(10, activation="softmax")
])
model.compile(
    optimizer="adam",
    loss="categorical_crossentropy",
    metrics=["accuracy"]
)

*# 3. Treinar e avaliar*
model.fit(x_train, y_train, batch_size=128, epochs=5, validation_split=0.1)
loss, acc = model.evaluate(x_test, y_test, verbose=0)
print(f"Teste — Loss: {loss:.4f}, Acurácia: {acc:.4f}")

2. Avaliação da Explicabilidade

2.1 Integrated Gradients (TensorFlow)

import matplotlib.pyplot as plt
import tensorflow_hub as hub

*# Funções auxiliares*
def interpolate_images(baseline, image, alphas):
    alphas = alphas[:, None, None, None]
    delta = image[None] - baseline[None]
    return baseline[None] + alphas * delta

@tf.function
def compute_gradients(images, target_idx):
    with tf.GradientTape() as tape:
        tape.watch(images)
        preds = model(images)
        probs = preds[:, target_idx]
    return tape.gradient(probs, images)

def integrated_gradients(baseline, image, target_idx, m_steps=50, batch_size=32):
    alphas = tf.linspace(0.0, 1.0, m_steps+1)
    grads = []
    for i in range(0, len(alphas), batch_size):
        batch = alphas[i:i+batch_size]
        imgs = interpolate_images(baseline, image, batch)
        grads.append(compute_gradients(imgs, target_idx))
    total_grads = tf.concat(grads, axis=0)
    avg_grads = (total_grads[:-1] + total_grads[1:]) / 2.0
    avg_grads = tf.reduce_mean(avg_grads, axis=0)
    return (image - baseline) * avg_grads

*# Selecionar instância e baseline*
idx = 0
instance = x_test[idx]
pred_class = tf.argmax(model.predict(instance[None]), axis=1).numpy()[0]
baseline = tf.zeros_like(instance)

*# Calcular e plotar IG*
ig = integrated_gradients(baseline, instance, pred_class, m_steps=100)
mask = tf.reduce_sum(tf.math.abs(ig), axis=-1)

plt.figure(figsize=(8,4))
plt.subplot(1,2,1)
plt.title("Input")
plt.imshow(instance[:,:,0], cmap="gray")
plt.axis("off")
plt.subplot(1,2,2)
plt.title("IG Mask")
plt.imshow(mask, cmap="inferno")
plt.axis("off")
plt.tight_layout()
plt.show()

2.2 SHAP (DeepExplainer)

import shap

*# Selecionar background para SHAP*
background = x_train[np.random.choice(x_train.shape[0], 100, replace=False)]
explainer = shap.DeepExplainer(model, background)

*# Explicar instância*
shap_values = explainer.shap_values(instance[None])

*# Plot force e summary*
shap.initjs()
shap.force_plot(
    explainer.expected_value[pred_class],
    shap_values[pred_class][0],
    instance.squeeze(),
    matplotlib=True
)
shap.summary_plot(
    shap_values,
    x_test,
    feature_names=[f"pixel_{i}" for i in range(28*28)],
    plot_type="bar"
)

Conclusão: este fluxo demonstra como treinar um classificador MNIST e avaliar sua explicabilidade com duas técnicas complementares, oferecendo insights locais e globais sobre o modelo.

Captura de tela 2025-07-04 180008.png