Usando datasets do Kaggle

Mesmo que você seja um novato no aprendizado de máquina, você provavelmente já ouviu falar sobre o Kaggle. Kaggle é uma comunidade on-line de cientistas de dados e aprendizes de máquinas. O Kaggle permite que os usuários encontrem e publiquem conjuntos de dados, explorem e construam modelos, trabalhem com outros cientistas de dados e engenheiros de aprendizado de máquina e participem de competições para resolver os desafios da ciência de dados. Resumindo, o Kaggle é o lugar certo para aprender e praticar aprendizado de máquina.

Neste post você aprenderá como usar um dos muitos conjuntos de dados disponibilizados pelo kaggle. Você pode clonar este projeto aqui: https://github.com/waslleysouza/keras.

Vamos criar algumas pastas dentro da pasta do projeto.
Crie uma pasta com o nome ‘datasets’.
Dentro da pasta ‘datasets’, crie uma pasta com o nome ‘dogs-vs-cats’.
Finalmente, dentro da pasta ‘dogs-vs-cats’, crie uma pasta com o nome ‘original’.

Vá para o Kaggle (https://www.kaggle.com/c/dogs-vs-cats/data) e faça download do dataset dogs-vs-cats.

Copie o arquivo zip para a pasta original e descompacte-o.

Vamos codificar!
Importe todas as bibliotecas necessárias.

from keras.models import Sequential
from keras.layers import Dense, Flatten, Conv2D, MaxPooling2D
from keras.preprocessing.image import ImageDataGenerator
import os, shutil

Todas as imagens de cães e gatos estão misturadas dentro da pasta original/train e precisamos organizá-las.
O código a seguir define o caminho das pastas criadas.

base_dir = 'datasets/dogs-vs-cats'

original_dir = os.path.join(base_dir, 'original')
original_train_dir = os.path.join(original_dir, 'train')

train_dir = os.path.join(base_dir, 'train')
validation_dir = os.path.join(base_dir, 'validation')

cats_train_dir = os.path.join(train_dir, 'cats')
cats_validation_dir = os.path.join(validation_dir, 'cats')

dogs_train_dir = os.path.join(train_dir, 'dogs')
dogs_validation_dir = os.path.join(validation_dir, 'dogs')

Este código cria as 6 novas pastas.

os.mkdir(train_dir)
os.mkdir(validation_dir)
os.mkdir(cats_train_dir)
os.mkdir(cats_validation_dir)
os.mkdir(dogs_train_dir)
os.mkdir(dogs_validation_dir)

Agora que criamos todas as pastas necessárias, podemos organizar as imagens.
A partir da pasta original/train, 10.000 imagens de gatos são copiadas para a pasta train/cat e 2.500 imagens de gatos são copiadas para a pasta validation/cat.
A mesma quantidade de imagens de cães são copiadas para as pastas train/dog e validation/dog.

def copy_images_to_folder(filename_pattern, start_range, stop_range, src_dir, dst_dir):
    filenames = [filename_pattern.format(i) for i in range(start_range, stop_range)]
    for filename in filenames:
        src = os.path.join(src_dir, filename)
        dst = os.path.join(dst_dir, filename)
        shutil.copyfile(src, dst)

copy_images_to_folder('cat.{}.jpg', 0, 10000, original_train_dir, cats_train_dir)
copy_images_to_folder('cat.{}.jpg', 10000, 12500, original_train_dir, cats_validation_dir)

copy_images_to_folder('dog.{}.jpg', 0, 10000, original_train_dir, dogs_train_dir)
copy_images_to_folder('dog.{}.jpg', 10000, 12500, original_train_dir, dogs_validation_dir)

Use Geradores para ler as pastas de treinamento e validação para criar lotes de imagens e rótulos.
Esses lotes serão necessários para treinar e validar o modelo.

batch_size = 20

train_datagen = ImageDataGenerator(rescale=1./255)
validation_datagen = ImageDataGenerator(rescale=1./255)

train_generator = train_datagen.flow_from_directory(train_dir, 
                                                    target_size=(50,50), 
                                                    batch_size=batch_size, 
                                                    class_mode='binary')

validation_generator = validation_datagen.flow_from_directory(validation_dir, 
                                                              target_size=(50,50), 
                                                              batch_size=batch_size, 
                                                              class_mode='binary')

Crie uma nova Rede Neural Convolucional.

model = Sequential()
model.add(Conv2D(32, kernel_size=(3,3), activation='relu', input_shape=(50,50,3)))
model.add(MaxPooling2D(pool_size=(2,2)))
model.add(Conv2D(64, kernel_size=(3,3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2,2)))
model.add(Conv2D(128, kernel_size=(3,3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2,2)))
model.add(Conv2D(128, kernel_size=(3,3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2,2)))
model.add(Flatten())
model.add(Dense(512, activation='relu'))
model.add(Dense(1, activation='sigmoid'))
model.summary()

Compile e treine a rede usando o método fit_generator.

model.compile(loss='binary_crossentropy', optimizer='rmsprop', metrics=['accuracy'])

history = model.fit_generator(train_generator, 
                              steps_per_epoch=20000/batch_size, 
                              epochs=10, 
                              validation_data=validation_generator, 
                              validation_steps=5000/batch_size)

A partir desse momento você pode usar outros datasets, não apenas os datasets que fazem parte do Keras.
Divirta-se!

Autor: Waslley Souza

Consultor Oracle com foco em tecnologias Oracle Fusion Middleware e SOA. Certificado Oracle WebCenter Portal, Oracle ADF e Java.

Deixe uma resposta

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *