Classificação de imagem do Tensorflow 2.0: instalar, carregar dados, construir e treinar o modelo

A classificação de imagens é uma categoria de reconhecimento de padrões. Classifica as imagens de acordo com a relação entre os pixels vizinhos. Em outras palavras, ele usa informações contextuais para organizar as imagens e é bastante popular entre as diferentes tecnologias. É um tópico de destaque no Deep Learning e, se você estiver aprendendo sobre isso, certamente apreciará este artigo.

Aqui, realizaremos a classificação da imagem do TensorFlow. Vamos construir um modelo, treiná-lo e melhorar sua precisão para classificar imagens de cactos. O TensorFlow é uma plataforma de aprendizado de máquina de código aberto e um produto do Google.

Vamos começar.

Instale o TensorFlow 2.0

Primeiro, você precisará instalar o TensorFlow no Google Colab. Você pode instalá-lo através do pip:

!pip instala tensorflow-gpu==2.0.0-alpha0

Em seguida, verificaremos a instalação:

importe tensorflow como tf

print(tf.__version)

# Saída: 2.0.0-alpha0

Fonte

Aprenda: os 5 projetos mais populares do TensorFlow para iniciantes

Carregar dados

Após a verificação, podemos carregar os dados usando o tf.data.dataset. Construiremos um classificador que determina se uma imagem contém um cacto ou não. O cacto tem que ser colunar. Podemos usar o conjunto de dados Cactus Aerial Photos para esta finalidade. Agora, carregaremos os caminhos dos arquivos junto com seus rótulos:

train_csv = pd.read_csv('data/train.csv')

# Prefixa nomes de arquivos de imagem em train/ com caminho relativo

nomes de arquivos = ['train/' + fname para fname em train_csv['id'].tolist()]

rótulos = train_csv['has_cactus'].tolist()

train_filenames, val_filenames, train_labels, val_labels =

train_test_split(nomes de arquivos,

rótulos,

train_size=0,9,

random_state=42)

Assim que tivermos os rótulos e os nomes dos arquivos, estamos prontos para criar os objetos tf.data.Dataset:

train_data = tf.data.Dataset.from_tensor_slices(

(tf.constant(train_filenames), tf.constant(train_labels))

)

val_data = tf.data.Dataset.from_tensor_slices(

(tf.constant(val_filenames), tf.constant(val_labels))

)

Fonte

No momento, nosso conjunto de dados não possui as imagens reais. Ele só tem seus nomes de arquivos. Precisaremos de uma função para carregar as imagens necessárias e processá-las para que possamos realizar o reconhecimento de imagem do TensorFlow nelas.

IMAGE_SIZE = 96 # Tamanho mínimo da imagem para uso com MobileNetV2

BATCH_SIZE = 32

# Função para carregar e pré-processar cada imagem

def _parse_fn(nome do arquivo, etiqueta):

img = tf.io.read_file(img)

img = tf.image.decode_jpeg(img)

img = (tf.cast(img, tf.float32)/127.5) – 1

img = tf.image.resize(img, (IMAGE_SIZE, IMAGE_SIZE))

retornar img, etiqueta

# Execute _parse_fn em cada exemplo nos conjuntos de dados train e val

# Também embaralhar e criar lotes

train_data = (train_data.map(_parse_fn)

.shuffle(buffer_size=10000)

.batch(BATCH_SIZE)

)

val_data = (val_data.map(_parse_fn)

.shuffle(buffer_size=10000)

.batch(BATCH_SIZE)

)

Fonte

Construindo um modelo

Neste exemplo de classificação de imagem do TensorFlow, criaremos um modelo de aprendizado de transferência. Esses modelos são rápidos, pois podem usar modelos de classificação de imagens existentes que passaram por treinamento anteriormente. Eles só precisam treinar novamente a camada superior de sua rede, pois essa camada especifica a classe da imagem necessária.

Usaremos a API Keras do TensorFlow 2.0 para criar nosso modelo de classificação de imagens. E para fins de aprendizado de transferência, usaremos o MobileNetV2 para ser o detector de atributos. É a segunda versão do MobileNet e é um produto do Google. É mais leve do que outros modelos, como Inception e ResNet, e pode ser executado em dispositivos móveis. Vamos carregar este modelo no ImageNet, congelar os pesos, adicionar um cabeçalho de classificação e executá-lo sem sua camada superior.

IMG_SHAPE = (IMAGE_SIZE, IMAGE_SIZE, 3)

# Modelo pré-treinado com MobileNetV2

base_model = tf.keras.applications.MobileNetV2(

input_shape=IMG_SHAPE,

include_top=Falso,

pesos='imagenet'

)

# Congele os pesos do modelo pré-treinado

base_model.trainable = False

# Cabeça de classificação treinável

maxpool_layer = tf.keras.layers.GlobalMaxPooling2D()

previsão_layer = tf.keras.layers.Dense(1, ativação='sigmoid')

# Cabeça de classificação de camadas com detector de recursos

model = tf.keras.Sequential([

base_model,

maxpool_layer,

camada_previsão

])

taxa_aprendizagem = 0,0001

# Compilar o modelo

model.compile(optimizer=tf.keras.optimizers.Adam(lr=learning_rate),

perda='binary_crossentropy',

métricas=['precisão']

)

Fonte

Você deve usar otimizadores do TensorFlow se for treinar modelos tf.keras. Os otimizadores nas APIs tf.keras.optimizers e tf.train estão juntos nos tf.keras.optimizers do TensorFlow 2.0. No TensorFlow 2.0, muitos dos otimizadores originais do tf.keras receberam atualizações e substituições para melhor desempenho. Eles nos permitem aplicar otimizadores sem comprometer o desempenho e economizar tempo também.

Leia: Tutorial de detecção de objetos do TensorFlow para iniciantes

Aprenda cursos de ciência de dados das melhores universidades do mundo. Ganhe Programas PG Executivos, Programas de Certificado Avançado ou Programas de Mestrado para acelerar sua carreira.

Treinando o Modelo

Depois de construirmos o modelo, podemos ensiná-lo. A API tf.keras do TensorFlow 2.0 é compatível com a API tf.data, portanto, você precisa usar os objetos tf.data.Dataset para essa finalidade. Ele pode realizar o treinamento com eficiência e não teríamos que comprometer o desempenho.

num_épocas = 30

step_per_epoch = round(num_train)//BATCH_SIZE

val_steps = 20

model.fit(train_data.repeat(),

épocas=num_épocas,

step_per_epoch = step_per_epoch,

validação_data=val_data.repeat(),

validação_steps=val_steps)

Fonte

Após 30 épocas, a precisão do modelo aumenta substancialmente, mas podemos melhorá-la ainda mais. Lembre-se, mencionamos o congelamento dos pesos durante o aprendizado de transferência? Bem, agora que treinamos o chefe de classificação, podemos descongelar essas camadas e ajustar ainda mais nosso conjunto de dados:

# Descongele todas as camadas do MobileNetV2

base_model.trainable = Verdadeiro

# Recongele as camadas até as camadas que queremos ajustar

para camada em base_model.layers[:100]:

layer.trainable = False

# Use uma taxa de aprendizado menor

lr_finetune = learning_rate / 10

# Recompilar o modelo

model.compile(loss='binary_crossentropy',

otimizador = tf.keras.optimizers.Adam(lr=lr_finetune),

métricas=['precisão'])

# Aumente as épocas de treinamento para ajuste fino

fine_tune_epochs = 30

total_epochs = num_epochs + fine_tune_epochs

# Modelo de ajuste fino

# Nota: Defina initial_epoch para iniciar o treinamento após a época 30, pois

# previamente treinado por 30 épocas.

model.fit(train_data.repeat(),

step_per_epoch = step_per_epoch,

épocas=total_épocas,

inicial_epoch = num_epochs,

validação_data=val_data.repeat(),

validação_steps=val_steps)

Fonte

30 épocas depois, a precisão do modelo melhora ainda mais. Com mais épocas, vimos mais melhorias na precisão do modelo. Agora, temos um modelo adequado de reconhecimento de imagem do TensorFlow que pode reconhecer cactos colunares em imagens com alta precisão.

Leia também: Ideias de projetos do Tensorflow para iniciantes

Saiba mais sobre a classificação de imagens do TensorFlow

As APIs altamente funcionais do TensorFlow e seus recursos o tornam uma tecnologia poderosa para qualquer programador. Suas APIs de alto nível também removem sua complexidade geral, facilitando o uso.

Você está interessado em saber mais sobre o TensorFlow, classificação de imagens e tópicos relacionados? Então, recomendamos que você confira o Diploma PG do IIIT-B e do upGrad em Machine Learning & AI, projetado para profissionais que trabalham e oferece mais de 450 horas de treinamento rigoroso, mais de 30 estudos de caso e atribuições, status de ex-alunos do IIIT-B, mais de 5 práticas projetos práticos e assistência de trabalho com as principais empresas.