Ajuda a proteger a Grande Barreira de Corais com TensorFlow em Kaggle Junte Desafio

Boundless Colab

Ver no TensorFlow.org Executar no Google Colab Ver no GitHub Baixar caderno Veja os modelos TF Hub

Bem-vindo ao modelo Boundless Colab! Este notebook irá guiá-lo pelas etapas de execução do modelo em imagens e visualizar os resultados.

Visão geral

Boundless é um modelo para extrapolação de imagens. Este modelo tem uma imagem, internamente máscaras uma parte dele ( 1/2 , 1/4 , 3/4 ) e completa a parte mascarada. Para mais detalhes consulte Boundless: Generative Adversarial Networks para a imagem de extensão ou a documentação do modelo na TensorFlow Hub.

Importações e configuração

Vamos começar com as importações básicas.

import tensorflow as tf
import tensorflow_hub as hub
from io import BytesIO
from PIL import Image as PilImage
import numpy as np
from matplotlib import pyplot as plt
from six.moves.urllib.request import urlopen

Lendo imagem para entrada

Vamos criar um método utilitário para ajudar a carregar a imagem e formatá-la para o modelo (257x257x3). Este método também corta a imagem em um quadrado para evitar distorção e você pode usar com imagens locais ou da Internet.

def read_image(filename):
    fd = None
    if(filename.startswith('http')):
      fd = urlopen(filename)
    else:
      fd = tf.io.gfile.GFile(filename, 'rb')

    pil_image = PilImage.open(fd)
    width, height = pil_image.size
    # crop to make the image square
    pil_image = pil_image.crop((0, 0, height, height))
    pil_image = pil_image.resize((257,257),PilImage.ANTIALIAS)
    image_unscaled = np.array(pil_image)
    image_np = np.expand_dims(
        image_unscaled.astype(np.float32) / 255., axis=0)
    return image_np

Método de visualização

Também criaremos um método de visuzalização para mostrar a imagem original lado a lado com a versão mascarada e a versão "preenchida", ambas geradas pelo modelo.

def visualize_output_comparison(img_original, img_masked, img_filled):
  plt.figure(figsize=(24,12))
  plt.subplot(131)
  plt.imshow((np.squeeze(img_original)))
  plt.title("Original", fontsize=24)
  plt.axis('off')
  plt.subplot(132)
  plt.imshow((np.squeeze(img_masked)))
  plt.title("Masked", fontsize=24)
  plt.axis('off')
  plt.subplot(133)
  plt.imshow((np.squeeze(img_filled)))
  plt.title("Generated", fontsize=24)
  plt.axis('off')
  plt.show()

Carregando uma imagem

Carregaremos uma imagem de amostra, mas ficaremos à vontade para enviar sua própria imagem para o colab e tentar com ela. Lembre-se que o modelo possui algumas limitações em relação às imagens humanas.

wikimedia = "https://upload.wikimedia.org/wikipedia/commons/thumb/3/31/Nusfjord_road%2C_2010_09.jpg/800px-Nusfjord_road%2C_2010_09.jpg"
# wikimedia = "https://upload.wikimedia.org/wikipedia/commons/thumb/4/47/Beech_forest_M%C3%A1tra_in_winter.jpg/640px-Beech_forest_M%C3%A1tra_in_winter.jpg"
# wikimedia = "https://upload.wikimedia.org/wikipedia/commons/thumb/b/b2/Marmolada_Sunset.jpg/640px-Marmolada_Sunset.jpg"
# wikimedia = "https://upload.wikimedia.org/wikipedia/commons/thumb/9/9d/Aegina_sunset.jpg/640px-Aegina_sunset.jpg"

input_img = read_image(wikimedia)

Seleção de um modelo do TensorFlow Hub

No TensorFlow Hub, temos três versões do modelo Boundless: Half, Quarter e Three Quarters. Na célula seguinte você pode escolher qualquer um deles e experimentar a sua imagem. Se quiser experimentar com outro, basta selecioná-lo e executar as seguintes células.

Seleção de modelo

Agora que escolhemos o modelo que queremos, vamos carregá-lo do TensorFlow Hub.

print("Loading model {} ({})".format(model_name, model_handle))
model = hub.load(model_handle)
Loading model Boundless Quarter (https://tfhub.dev/google/boundless/quarter/1)

Fazendo inferência

O modelo sem limites tem duas saídas:

  • A imagem de entrada com uma máscara aplicada
  • A imagem mascarada com a extrapolação para completá-la

podemos usar essas duas imagens para mostrar uma visualização de comparação.

result = model.signatures['default'](tf.constant(input_img))
generated_image =  result['default']
masked_image = result['masked_image']

visualize_output_comparison(input_img, masked_image, generated_image)

png