Completamento de Rostos com Estimadores de Saída Múltipla

Introdução

Este laboratório demonstra como usar estimadores de múltiplas saídas para completar imagens. O objetivo é prever a metade inferior de um rosto, dada a sua metade superior. Diferentes algoritmos, como árvores aleatórias extremas, vizinhos mais próximos, regressão linear e regressão de ridge, serão usados para completar a metade inferior dos rostos. Os rostos completados serão comparados com os rostos originais para avaliar o desempenho dos algoritmos.

Dicas da Máquina Virtual

Após o arranque da máquina virtual, clique no canto superior esquerdo para mudar para a aba Notebook para aceder ao Jupyter Notebook para a prática.

Por vezes, pode ser necessário esperar alguns segundos para o Jupyter Notebook terminar de carregar. A validação das operações não pode ser automatizada devido a limitações no Jupyter Notebook.

Se tiver problemas durante a aprendizagem, não hesite em contactar o Labby. Forneça feedback após a sessão e resolveremos prontamente o problema para si.

Carregar os Dados

O primeiro passo é carregar o conjunto de dados de rostos Olivetti, que contém 400 imagens em tons de cinza de 64x64 pixels cada. Os dados são divididos em conjuntos de treino e teste. O conjunto de treino contém os rostos de 30 pessoas, e o conjunto de teste contém os rostos das pessoas restantes. Neste laboratório, vamos testar os algoritmos num subconjunto de cinco pessoas.

## Carregar os conjuntos de dados de rostos
data, targets = fetch_olivetti_faces(return_X_y=True)

train = data[targets < 30]
test = data[targets >= 30]  ## Teste em pessoas independentes

## Teste num subconjunto de pessoas
n_faces = 5
rng = check_random_state(4)
face_ids = rng.randint(test.shape[0], size=(n_faces,))
test = test[face_ids, :]

n_pixels = data.shape[1]
## Metade superior dos rostos
X_train = train[:, : (n_pixels + 1) // 2]
## Metade inferior dos rostos
y_train = train[:, n_pixels // 2 :]
X_test = test[:, : (n_pixels + 1) // 2]
y_test = test[:, n_pixels // 2 :]

Ajustar Estimadores

O segundo passo é ajustar os estimadores de saída múltipla aos dados de treino. Usaremos quatro algoritmos diferentes: árvores aleatórias extremas, vizinhos mais próximos, regressão linear e regressão de ridge. Os estimadores preverão a metade inferior dos rostos com base na metade superior.

## Ajustar estimadores
ESTIMATORS = {
    "Árvores aleatórias extremas": ExtraTreesRegressor(
        n_estimators=10, max_features=32, random_state=0
    ),
    "K-vizinhos mais próximos": KNeighborsRegressor(),
    "Regressão linear": LinearRegression(),
    "Ridge": RidgeCV(),
}

y_test_predict = dict()
for name, estimator in ESTIMATORS.items():
    estimator.fit(X_train, y_train)
    y_test_predict[name] = estimator.predict(X_test)

Plotar os Rostos Completos

O passo final é plotar os rostos completos para cada algoritmo e compará-los com os rostos originais. Os rostos originais são mostrados na primeira coluna, e os rostos completos são mostrados nas colunas subsequentes para cada algoritmo. O desempenho dos algoritmos pode ser avaliado comparando os rostos completos com os rostos originais.

## Plotar os rostos completos
image_shape = (64, 64)

n_cols = 1 + len(ESTIMATORS)
plt.figure(figsize=(2.0 * n_cols, 2.26 * n_faces))
plt.suptitle("Completamento de rostos com estimadores de saída múltipla", size=16)

for i in range(n_faces):
    true_face = np.hstack((X_test[i], y_test[i]))

    if i:
        sub = plt.subplot(n_faces, n_cols, i * n_cols + 1)
    else:
        sub = plt.subplot(n_faces, n_cols, i * n_cols + 1, title="rostos verdadeiros")

    sub.axis("off")
    sub.imshow(
        true_face.reshape(image_shape), cmap=plt.cm.gray, interpolation="nearest"
    )

    for j, est in enumerate(sorted(ESTIMATORS)):
        completed_face = np.hstack((X_test[i], y_test_predict[est][i]))

        if i:
            sub = plt.subplot(n_faces, n_cols, i * n_cols + 2 + j)

        else:
            sub = plt.subplot(n_faces, n_cols, i * n_cols + 2 + j, title=est)

        sub.axis("off")
        sub.imshow(
            completed_face.reshape(image_shape),
            cmap=plt.cm.gray,
            interpolation="nearest",
        )

plt.show()

Resumo

Este laboratório demonstrou como usar estimadores de saída múltipla para completar imagens. Usamos quatro algoritmos diferentes para prever a metade inferior de um rosto com base na metade superior. O desempenho dos algoritmos foi avaliado comparando os rostos completos com os rostos originais.