conda install keras

echo ‘{

    "epsilon": 1e-07,

    "floatx": "float32",

    "image_data_format": "channels_last",

    "backend": "theano"

}’> ~/.keras/keras.json

from __future__ import division, print_function

import os, json

from glob import glob

import numpy as np

from scipy import misc, ndimage

from scipy.ndimage.interpolation import zoom

from keras import backend as K

from keras.layers.normalization import BatchNormalization

from keras.utils.data_utils import get_file

from keras.models import Sequential

from keras.layers.core import Flatten, Dense, Dropout, Lambda

#from keras.layers.convolutional import Convolution2D, MaxPooling2D, ZeroPadding2D

from keras.layers.convolutional import Conv2D, MaxPooling2D, ZeroPadding2D  # Conv2D: Keras2

from keras.layers.pooling import GlobalAveragePooling2D

from keras.optimizers import SGD, RMSprop, Adam

from keras.preprocessing import image

# In case we are going to use the TensorFlow backend we need to explicitly set the Theano image ordering

from keras import backend as K

K.set_image_dim_ordering('th')

vgg_mean = np.array([123.68, 116.779, 103.939], dtype=np.float32).reshape((3,1,1))

def vgg_preprocess(x):

    """

        Subtracts the mean RGB value, and transposes RGB to BGR.

        The mean RGB was computed on the image set used to train the VGG model.

        Args:

            x: Image array (height x width x channels)

        Returns:

            Image array (height x width x transposed_channels)

    """

    x = x - vgg_mean

    return x[:, ::-1] # reverse axis rgb->bgr

class Vgg16():

    """

        The VGG 16 Imagenet model

    """

    def __init__(self):

        self.FILE_PATH = 'http://files.fast.ai/models/'

        self.create()

        self.get_classes()

    def get_classes(self):

        """

            Downloads the Imagenet classes index file and loads it to self.classes.

            The file is downloaded only if it not already in the cache.

        """

        fname = 'imagenet_class_index.json'

        fpath = get_file(fname, self.FILE_PATH+fname, cache_subdir='models')

        with open(fpath) as f:

            class_dict = json.load(f)

        self.classes = [class_dict[str(i)][1] for i in range(len(class_dict))]

    def predict(self, imgs, details=False):

        """

            Predict the labels of a set of images using the VGG16 model.

            Args:

                imgs (ndarray)    : An array of N images (size: N x width x height x channels).

                details : ??

            Returns:

                preds (np.array) : Highest confidence value of the predictions for each image.

                idxs (np.ndarray): Class index of the predictions with the max confidence.

                classes (list)   : Class labels of the predictions with the max confidence.

        """

        # predict probability of each class for each image

        all_preds = self.model.predict(imgs)

        # for each image get the index of the class with max probability

        idxs = np.argmax(all_preds, axis=1)

        # get the values of the highest probability for each image

        preds = [all_preds[i, idxs[i]] for i in range(len(idxs))]

        # get the label of the class with the highest probability for each image

        classes = [self.classes[idx] for idx in idxs]

        return np.array(preds), idxs, classes

    def ConvBlock(self, layers, filters):

        """

            Adds a specified number of ZeroPadding and Covolution layers

            to the model, and a MaxPooling layer at the very end.

            Args:

                layers (int):   The number of zero padded convolution layers

                                to be added to the model.

                filters (int):  The number of convolution filters to be

                                created for each layer.

        """

        model = self.model

        for i in range(layers):

            model.add(ZeroPadding2D((1, 1)))

            # model.add(Convolution2D(filters, 3, 3, activation='relu'))

        model.add(Conv2D(filters, kernel_size=(3, 3), activation='relu'))

        model.add(MaxPooling2D((2, 2), strides=(2, 2)))

    def FCBlock(self):

        """

            Adds a fully connected layer of 4096 neurons to the model with a

            Dropout of 0.5

            Args:   None

            Returns:   None

        """

        model = self.model

        model.add(Dense(4096, activation='relu'))

        model.add(Dropout(0.5))

    def create(self):

        """

            Creates the VGG16 network achitecture and loads the pretrained weights.

            Args:   None

            Returns:   None

        """

        model = self.model = Sequential()

        model.add(Lambda(vgg_preprocess, input_shape=(3,224,224), output_shape=(3,224,224)))

        self.ConvBlock(2, 64)

        self.ConvBlock(2, 128)

        self.ConvBlock(3, 256)

        self.ConvBlock(3, 512)

        self.ConvBlock(3, 512)

        model.add(Flatten())

        self.FCBlock()

        self.FCBlock()

        model.add(Dense(1000, activation='softmax'))

        fname = 'vgg16.h5'

        model.load_weights(get_file(fname, self.FILE_PATH+fname, cache_subdir='models'))

    def get_batches(self, path, gen=image.ImageDataGenerator(), shuffle=True, batch_size=8, class_mode='categorical'):

        """

            Takes the path to a directory, and generates batches of augmented/normalized data. Yields batches indefinitely, in an infinite loop.

            See Keras documentation: https://keras.io/preprocessing/image/

        """

        return gen.flow_from_directory(path, target_size=(224,224),

                class_mode=class_mode, shuffle=shuffle, batch_size=batch_size)

    def ft(self, num):

        """

            Replace the last layer of the model with a Dense (fully connected) layer of num neurons.

            Will also lock the weights of all layers except the new layer so that we only learn

            weights for the last layer in subsequent training.

            Args:

                num (int) : Number of neurons in the Dense layer

            Returns:

                None

        """

        model = self.model

        model.pop()

        for layer in model.layers: layer.trainable=False

        model.add(Dense(num, activation='softmax'))

        self.compile()

    def finetune(self, batches):

    self.ft(batches.num_classes)

        classes = list(iter(batches.class_indices)) # get a list of all the class labels

        # batches.class_indices is a dict with the class name as key and an index as value

        # eg. {'cats': 0, 'dogs': 1}

        # sort the class labels by index according to batches.class_indices and update model.classes

        for c in batches.class_indices:

            classes[batches.class_indices[c]] = c

        self.classes = classes

    def compile(self, lr=0.001):

        """

            Configures the model for training.

            See Keras documentation: https://keras.io/models/model/

        """

        self.model.compile(optimizer=Adam(lr=lr),

                loss='categorical_crossentropy', metrics=['accuracy'])

    def fit_data(self, trn, labels,  val, val_labels,  nb_epoch=1, batch_size=64):

        """

            Trains the model for a fixed number of epochs (iterations on a dataset).

            See Keras documentation: https://keras.io/models/model/

        """

        #self.model.fit(trn, labels, nb_epoch=nb_epoch,

        #        validation_data=(val, val_labels), batch_size=batch_size)

    self.model.fit(trn, labels, epochs=nb_epoch,

                validation_data=(val, val_labels), batch_size=batch_size)

    #def fit(self, batches, val_batches, nb_epoch=1):

    def fit(self, batches, val_batches, batch_size, nb_epoch=1):

        """

            Fits the model on data yielded batch-by-batch by a Python generator.

            See Keras documentation: https://keras.io/models/model/

        """

        #self.model.fit_generator(batches, samples_per_epoch=batches.nb_sample, nb_epoch=nb_epoch,

        #        validation_data=val_batches, nb_val_samples=val_batches.nb_sample)

    self.model.fit_generator(batches, steps_per_epoch=int(np.ceil(batches.samples/batch_size)), epochs=nb_epoch,

                validation_data=val_batches, validation_steps=int(np.ceil(val_batches.samples/batch_size)))

    def test(self, path, batch_size=8):

        """

            Predicts the classes using the trained model on data yielded batch-by-batch.

            Args:

                path (string):  Path to the target directory. It should contain one subdirectory

                                per class.

                batch_size (int): The number of images to be considered in each batch.

            Returns:

                test_batches, numpy array(s) of predictions for the test_batches.

        """

        test_batches = self.get_batches(path, shuffle=False, batch_size=batch_size, class_mode=None)

        #return test_batches, self.model.predict_generator(test_batches, test_batches.nb_sample)

    return test_batches, self.model.predict_generator(test_batches, int(np.ceil(test_batches.samples/batch_size)))