This article is a simple introduction to simple binary classification for images with Keras deep learning library.
There are many ways to do image classification with Keras. Here are the detail of this particular implementation:
- Type of classification: binary classification. Other type of classification will be the focus of other article
- Dataset used is Dogs vs Cats Redux: Kernels Edition
- Model: NASNet from Keras (https://keras.io/applications/#nasnet)
- Pre trained model / transfer learning from imagenet
- Feeding the images with image.ImageDataGenerator.flow_from_directory() instead of image.ImageDataGenerator.flow()
 |
| Dogs vs Cats classification problem |
Prepare Working Directories
First step is to prepare working directory.
 |
||
| Binary classification directory structure |
This is the directory structure used in this article.
It’s better to use a structured working directory, don’t just mix all files in the same directory. You may modify the directory structure to suit your needs.
flow_from_director() expects each class to have its own directory. The directory names must match class names.
Download Dataset
- Download dataset from Dataset: Dogs vs Cats Redux: Kernels Edition
- Put cat images in <root>/data/train/cat
- Put dog images in <root>/data/train/dog
- Put test images in <root>/data/test
Now we can jump straight into the code. First step is to import libraries.
import tensorflow as tf
import keras as keras
import os
from keras.layers import Flatten, Dense, AveragePooling2D, GlobalAveragePooling2D
from keras.models import Model
from keras.optimizers import RMSprop, SGD
from keras.callbacks import ModelCheckpoint
from keras.callbacks import EarlyStopping
from keras.preprocessing.image import ImageDataGenerator
from keras.callbacks import CSVLogger
from keras.layers.normalization import BatchNormalization
import numpy as np
from keras.models import load_model
import numpy as np
from pathlib import Path
import os
import shutil
The next step is to define parameters for our deep learning model.
# preparing parameters
image_dir_cat='../data/train/cat' # assuming cat & dog images has been separated in different directories
image_dir_dog='../data/train/dog'
session = "simple1000" # to differentiate between runs
ClassNames = ['cat', 'dog']
data_dir="../simple1000" # to differentiate between runs
learning_rate = 0.0001
img_width = 331 # 331 for pre-trained nasnet
img_height = 331
nbr_epochs = 10
batch_size = 4 # batch size depends on available memory on GPU. GTX 1080 Ti use (4)
np.random.seed(2018)
train_dir = data_dir + "/train"
valid_dir = data_dir + "/valid"
number_of_class=len(ClassNames)
print("train directory : ", train_dir)
print("valid directory : ", valid_dir)
print("number of classes: "+ str(number_of_class))
logfile = session + '-train' + '.log'
print("logfile :", logfile)
Explanation:
- image_dir_cat & image_dir_dog must match the directory where we put our training dataset.
- session string is useful if we want to make several different run. There will be many weights files, prediction files. If we don’t stick to a naming structure, the whole thing can become a jumbled mess
The next step is to prepare files for training step. We have 12500 images of cats and 12500 images of dogs in the dataset, but in this experiment, we only use 1000 images of cats and 1000 of dogs , to speed up the experiment. We can easily add more files later.
The following code prepares files for the training. For training we use 800 cat images and 800 dog images, while for validation we use 200 cat images and 200 dog images.
# make training directory
# make validation directory
# copy images to respective directories
print("copy start")
def MakeDir(newdir):
if not os.path.exists(newdir):
os.makedirs(newdir)
# make validation & training directories, if not exist yet
MakeDir(valid_dir)
MakeDir(valid_dir+'/cat')
MakeDir(valid_dir+'/dog')
MakeDir(train_dir)
MakeDir(train_dir+'/cat')
MakeDir(train_dir+'/dog')
# copy files to working directories
print("copy cats")
counter=0
for root, dirs, files in os.walk(image_dir_cat):
for file in files:
fullfilename = os.path.join(root, file)
# print(str(counter) + ": " + fullfilename)
if(counter<800):
shutil.copyfile(fullfilename,train_dir+"/cat/"+file)
if(counter>=800 and counter<1000):
shutil.copyfile(fullfilename,valid_dir+"/cat/"+file)
if(counter>=1000):
break
counter=counter+1
print("copy dogs")
counter=0
for root, dirs, files in os.walk(image_dir_dog):
for file in files:
fullfilename = os.path.join(root, file)
# print(str(counter) + ": " + fullfilename)
if(counter<800):
shutil.copyfile(fullfilename,train_dir+"/dog/"+file)
if(counter>=800 and counter<1000):
shutil.copyfile(fullfilename,valid_dir+"/dog/"+file)
if(counter>=1000):
break
counter=counter+1
print("copy finished")
Building Model
# make model with transfer learning
if(True):
model_notop = keras.applications.nasnet.NASNetLarge(input_shape=(img_width, img_height, 3),
include_top=False,
weights='imagenet', input_tensor=None,
pooling=None)
# add a global spatial average pooling layer
x = model_notop.output
x = GlobalAveragePooling2D()(x)
x = Dense(1024, activation='relu')(x) # let's add a fully-connected layer
x = BatchNormalization()(x)
predictions = Dense(1, activation='sigmoid')(x)
deep_model = Model(model_notop.input, predictions)
Explanation
- For the first layers, we use model & weight from NASNet, without its fully connected layer.
- We replace the NASNet final layer with our own, with 1024 hidden neurons (Dense) and 1 in output layer.
- Since this is a binary classification, the final layer activation is sigmoid, and only consist of 1 cell.
- Batch Normalization is added to reduce overfitting
- The number of hidden layer (1024) is arbitrary, it can be increased or decreased later to find better result.
Train The Model
# training
if(True):
sgd_optimizer = SGD(lr=learning_rate, momentum=0.9, decay=0.0, nesterov=True)
deep_model.compile(loss='binary_crossentropy', optimizer=sgd_optimizer, metrics=['accuracy'])
# set up callbacks
csv_logger = CSVLogger(logfile, append=True)
early_stopping = EarlyStopping(monitor='val_loss', min_delta=0, patience=2, verbose=1, mode='auto')
best_model_file=session+'-weights.{epoch:02d}-{val_loss:.2f}.h5'
# best_model_file = session + '-weights' + '.h5'
best_model = ModelCheckpoint(best_model_file, monitor='val_acc', verbose=1, save_best_only=True)
# this is the augmentation configuration we will use for training
train_datagen = ImageDataGenerator(
rescale=1. / 255,
shear_range=0.2,
zoom_range=0.2,
rotation_range=90,
width_shift_range=0.2,
height_shift_range=0.2,
horizontal_flip=True,
vertical_flip=True)
val_datagen = ImageDataGenerator(rescale=1. / 255)
print('prepare train generator')
train_generator = train_datagen.flow_from_directory(
train_dir,
target_size=(img_width, img_height),
batch_size=batch_size,
shuffle=True,
class_mode='binary')
print('prepare validation generator')
validation_generator = val_datagen.flow_from_directory(
valid_dir,
target_size=(img_width, img_height),
batch_size=batch_size,
shuffle=True,
class_mode='binary')
print('fit generator')
deep_model.fit_generator(
generator=train_generator,
# steps_per_epoch=nbr_train_samples/batch_size, # in Keras 2.2.0, automatically acquired from train generator
epochs=nbr_epochs,
verbose=1,
validation_data=validation_generator,
# validation_steps=nbr_validation_samples/batch_size, # automatically acquired from validation generator
callbacks=[best_model, csv_logger, early_stopping])
training progress
prepare train generator
Found 1600 images belonging to 2 classes.
prepare validation generator
Found 400 images belonging to 2 classes.
fit generator
Epoch 1/10
400/400 [==============================] - 279s 697ms/step - loss: 0.3509 - acc: 0.8500 - val_loss: 0.1920 - val_acc: 0.9525
Epoch 00001: val_acc improved from -inf to 0.95250, saving model to simple1000-weights.01-0.19.h5
Epoch 2/10
400/400 [==============================] - 230s 574ms/step - loss: 0.3015 - acc: 0.8769 - val_loss: 0.1307 - val_acc: 0.9725
Epoch 00002: val_acc improved from 0.95250 to 0.97250, saving model to simple1000-weights.02-0.13.h5
Epoch 3/10
400/400 [==============================] - 231s 578ms/step - loss: 0.2886 - acc: 0.8869 - val_loss: 0.1337 - val_acc: 0.9675
Epoch 00003: val_acc did not improve from 0.97250
Epoch 4/10
400/400 [==============================] - 233s 581ms/step - loss: 0.3108 - acc: 0.8744 - val_loss: 0.1299 - val_acc: 0.9750
Epoch 00004: val_acc improved from 0.97250 to 0.97500, saving model to simple1000-weights.04-0.13.h5
Epoch 5/10
400/400 [==============================] - 232s 580ms/step - loss: 0.2880 - acc: 0.8863 - val_loss: 0.1093 - val_acc: 0.9775
Epoch 00005: val_acc improved from 0.97500 to 0.97750, saving model to simple1000-weights.05-0.11.h5
Epoch 6/10
400/400 [==============================] - 231s 576ms/step - loss: 0.2284 - acc: 0.9113 - val_loss: 0.0928 - val_acc: 0.9775
Epoch 00006: val_acc did not improve from 0.97750
Epoch 7/10
400/400 [==============================] - 230s 575ms/step - loss: 0.2560 - acc: 0.8969 - val_loss: 0.0935 - val_acc: 0.9825
Epoch 00007: val_acc improved from 0.97750 to 0.98250, saving model to simple1000-weights.07-0.09.h5
Epoch 8/10
400/400 [==============================] - 231s 577ms/step - loss: 0.2461 - acc: 0.9019 - val_loss: 0.0821 - val_acc: 0.9775
Epoch 00008: val_acc did not improve from 0.98250
Epoch 9/10
400/400 [==============================] - 231s 578ms/step - loss: 0.2606 - acc: 0.8981 - val_loss: 0.0722 - val_acc: 0.9825
Epoch 00009: val_acc did not improve from 0.98250
Epoch 10/10
400/400 [==============================] - 231s 578ms/step - loss: 0.2267 - acc: 0.9113 - val_loss: 0.1130 - val_acc: 0.9775
Epoch 00010: val_acc did not improve from 0.98250
Prediction & Submit
Prediction step
#prediction
nbr_test_samples=12500
#choose weights file manually
weights_path = 'simple1000-weights.07-0.09.h5'
test_data_dir = '../data/test/'
test_datagen = ImageDataGenerator(rescale=1./255)
test_generator = test_datagen.flow_from_directory(
test_data_dir,
target_size=(img_width, img_height),
batch_size=batch_size,
shuffle = False, # no shuffling, since filenames must match predictions. Shuffling may change file sequence
classes = None, #
class_mode = None)
test_image_list = test_generator.filenames
print('Loading model and weights')
predict_model = load_model(weights_path)
print('Begin to predict for testing data ...')
predictions = predict_model.predict_generator(test_generator, nbr_test_samples)
np.savetxt(session+'-predictions.txt', predictions) # store prediction matrix, for later analysis if necessary
Make submission file
Make submission file, format must match given sample_submission.csv
# submission
submission_file=session+'-submit.csv'
print('Begin to write submission file:'+submission_file)
f_submit = open(submission_file, 'w')
f_submit.write('id,labeln')
for i, image_name in enumerate(test_image_list):
basename=os.path.basename(image_name)
filename, fileext = os.path.splitext(basename)
prediction_class =predictions[i][0] # get predictions from array
f_submit.write('%s,%sn' % (filename, prediction_class))
f_submit.close()
print('Finished write submission file ..')
Submit the result to https://www.kaggle.com/c/dogs-vs-cats-redux-kernels-edition/leaderboard , click on “Late Submission”
We got score of 0.10979, still long way from the top (0.03) but not too bad for only 1000 samples.
Full source code for simple solution is available here: https://github.com/waskita/kaggle-dogs-cats/blob/master/simple-binary-classification.ipynb
Reference
- Tutorial on using Keras flow_from_directory and generators
- https://www.pyimagesearch.com/2017/12/11/image-classification-with-keras-and-deep-learning/
- http://blog.kaggle.com/2017/04/03/dogs-vs-cats-redux-playground-competition-winners-interview-bojan-tunguz/
- Code formatter: http://codeformatter.blogspot.com/