From 6644e03b4c7c909a1a36a5c32e7aad620d8b005e Mon Sep 17 00:00:00 2001 From: Heiko J Schick Date: Fri, 23 Oct 2020 09:52:37 +0200 Subject: [PATCH] Renamed files using VGG16 network --- Makefile | 10 +-- vgg16-prepare_train_model.py | 122 +++++++++++++++++++++++++++++++++++ vgg16-test_model.py | 72 +++++++++++++++++++++ 3 files changed, 199 insertions(+), 5 deletions(-) create mode 100644 vgg16-prepare_train_model.py create mode 100644 vgg16-test_model.py diff --git a/Makefile b/Makefile index 74fbbbe..9577b2d 100644 --- a/Makefile +++ b/Makefile @@ -11,7 +11,7 @@ OBJECT_DETECTION=prepare_train_model.py test_model.py help: @echo "make linear_regression" @echo " runs the simple linear regression example" - @echo "make objct_detection" + @echo "make vgg16" @ecgo " runs the object detection example" @echo "make env" @echo " creates and prepares the environment" @@ -44,11 +44,11 @@ $(VENV_NAME)/bin/activate: linear_regression: env ${PYTHON} $(LINEAR_REGRESSION) -object_detection_training: fine_tune.h5 +vgg16_training: fine_tune.h5 fine_tune.h5: - ${PYTHON} prepare_train_model.py -object_detection: env object_detection_training - ${PYTHON} test_model.py + ${PYTHON} vgg16-prepare_train_model.py +vgg16: env vgg16_training + ${PYTHON} vgg16-test_model.py lint: env ${PYTHON} -m pylint --rcfile=pylintrc $(LINT_FILES) diff --git a/vgg16-prepare_train_model.py b/vgg16-prepare_train_model.py new file mode 100644 index 0000000..ab2c1e6 --- /dev/null +++ b/vgg16-prepare_train_model.py @@ -0,0 +1,122 @@ +""" +Simple example on how to fine tune models in Keras and how to use them. +Part 1 + +Source: https://www.guru99.com/keras-tutorial.html +""" + +#### Data preparation +from keras.preprocessing.image import ImageDataGenerator +import numpy as np +import matplotlib.pyplot as plt +import keras +from keras.layers import Flatten, Dense +from keras.applications.vgg16 import VGG16 +from keras.optimizers import SGD + +TRAIN_PATH = 'images/train/' +TEST_PATH = 'images/test/' +BATCH_SIZE = 16 +IMAGE_SIZE = 224 +NUM_CLASSES = 8 + +# The ImageDataGenerator will make an X_training data from a directory. +# The sub-directory in that directory will be used as a class for each object. +# The image will be loaded with the RGB color mode, with the categorical class +# mode for the Y_training data, with a batch size of 16. Finally, shuffle the +# data. + +train_datagen = ImageDataGenerator(validation_split=0.3, + shear_range=0.2, + zoom_range=0.2, + horizontal_flip=True) + +train_generator = train_datagen.flow_from_directory( + directory=TRAIN_PATH, + target_size=(IMAGE_SIZE,IMAGE_SIZE), + batch_size=BATCH_SIZE, + class_mode='categorical', + color_mode='rgb', + shuffle=True) + + +# Let's see our images randomly by plotting them with matplotlib +# x_batch, y_batch = train_generator.next() +x_batch, y_batch = next(train_generator) +fig=plt.figure() + +COLUMNS = 4 +ROWS = 4 + +for i in range(1, COLUMNS*ROWS): + num = np.random.randint(BATCH_SIZE) + image = x_batch[num].astype(np.int) + fig.add_subplot(ROWS, COLUMNS, i) + plt.imshow(image) +plt.show() + +### Creating model +# Let's create our network model from VGG16 with imageNet pre-trained weight. +# We will freeze these layers so that the layers are not trainable to help us +# reduce the computation time. + +# Load the VGG model +base_model = VGG16(weights='imagenet', include_top=False, input_shape=(IMAGE_SIZE, IMAGE_SIZE, 3)) + +print(base_model.summary()) + +# Freeze the layers +for layer in base_model.layers: + layer.trainable = False + +# Create the model +model = keras.models.Sequential() + +# Add the vgg convolutional base model +model.add(base_model) + +# Add new layers +model.add(Flatten()) +model.add(Dense(1024, activation='relu')) +model.add(Dense(1024, activation='relu')) +model.add(Dense(NUM_CLASSES, activation='softmax')) + +# Show a summary of the model. Check the number of trainable parameters +print(model.summary()) + +input("Press Enter to continue...") + +# As you can see, the summary of our network model. From an input from +# VGG16 Layers, then we add 2 Fully Connected Layer which will extract 1024 +# features and an output layer that will compute the 8 classes with the softmax +# activation. + +#### Training +# Compile the model +model.compile(loss='categorical_crossentropy', + optimizer=SGD(lr=1e-3), + metrics=['accuracy']) + +# Start the training process +# model.fit(x_train, y_train, validation_split=0.30, batch_size=32, epochs=50, verbose=2) + +# Save the model +# model.save('catdog.h5') + +history = model.fit_generator(train_generator, + steps_per_epoch=train_generator.n/BATCH_SIZE, + epochs=10) + +model.save('fine_tune.h5') + +# Summarize history for accuracy +plt.plot(history.history['loss']) +plt.title('loss') +plt.ylabel('loss') +plt.xlabel('epoch') +plt.legend(['loss'], loc='upper left') +plt.show() + +# Our losses are dropped significantly and the accuracy is almost 100%. For +# testing our model, we randomly picked images over the internet and put it on +# the test folder with a different class to test diff --git a/vgg16-test_model.py b/vgg16-test_model.py new file mode 100644 index 0000000..2ede54b --- /dev/null +++ b/vgg16-test_model.py @@ -0,0 +1,72 @@ +""" +Simple example on how to fine tune models in Keras and how to use them. +Part 2 + +Source: https://www.guru99.com/keras-tutorial.html +""" + +from keras.models import load_model +from keras.preprocessing.image import ImageDataGenerator +import matplotlib.pyplot as plt +import numpy as np + +train_datagen = ImageDataGenerator(validation_split=0.3, + shear_range=0.2, + zoom_range=0.2, + horizontal_flip=True) + +TRAIN_PATH = 'images/train/' +TEST_PATH = 'images/test/' +BATCH_SIZE = 16 +IMAGE_SIZE = 224 +NUM_CLASSES = 8 + +### Testing our model +model = load_model('fine_tune.h5') + +test_datagen = ImageDataGenerator() +train_generator = train_datagen.flow_from_directory( + directory=TRAIN_PATH, + target_size=(IMAGE_SIZE, IMAGE_SIZE), + batch_size=BATCH_SIZE, + class_mode='categorical', + color_mode='rgb', + shuffle=True) + +test_generator = test_datagen.flow_from_directory( + directory=TEST_PATH, + target_size=(IMAGE_SIZE, IMAGE_SIZE), + color_mode='rgb', + shuffle=False, + class_mode='categorical', + batch_size=1) + +filenames = test_generator.filenames +nb_samples = len(filenames) + +fig = plt.figure() + +COLUMNS = 4 +ROWS = 4 + +# And our test is as given below! Only 1 image is predicted wrong from a test of +# 14 images! + +for i in range(1, COLUMNS*ROWS -1): + x_batch, y_batch = next(test_generator) + + name = model.predict(x_batch) + name = np.argmax(name, axis=-1) + true_name = y_batch + true_name = np.argmax(true_name, axis=-1) + + label_map = (test_generator.class_indices) + label_map = dict((v,k) for k,v in label_map.items()) #flip k,v + predictions = [label_map[k] for k in name] + true_value = [label_map[k] for k in true_name] + + image = x_batch[0].astype(np.int) + fig.add_subplot(ROWS, COLUMNS, i) + plt.title(str(predictions[0]) + ':' + str(true_value[0])) + plt.imshow(image) +plt.show()