Keras: Hyper-parameters optimization

link

http://machinelearningmastery.com/grid-search-hyperparameters-deep-learning-models-python-keras/

http://www.pyimagesearch.com/2016/08/15/how-to-tune-hyperparameters-with-python-and-scikit-learn/

and simple image-base neural network
http://www.pyimagesearch.com/2016/09/26/a-simple-neural-network-with-python-and-keras/

Keras: IRIS dataset example

Important Point

we need to convert classes that look like

setosa
versicolor
setosa
virginica
...

to a table that looks like

setosa versicolor virginica
     1          0         0
     0          1         0
     1          0         0
     0          0         1

import numpy as np
from keras.models import Sequential
from keras.layers import Dense,Dropout,Activation,Flatten
from keras.layers import Convolution2D,MaxPooling2D
from keras.utils import np_utils
from keras.datasets import mnist
from matplotlib import pyplot as plt
import keras.backend as K
import pandas as pd
from sklearn.cross_validation import train_test_split
#import keras.backend as K

def f1_score(y_true, y_pred):

    tp = K.sum(K.round(K.clip(y_true * y_pred, 0,1)))
    predicted_p = K.sum(K.round(K.clip(y_pred,0,1)))
    possible_p = K.sum(K.round(K.clip(y_true,0,1)))

    p = tp/(predicted_p + K.epsilon())
    r = tp/(possible_p + K.epsilon())
    beta  = 1
    bb = beta**2
    fbeta_score = (1 + bb) * (p * r)/(bb * p + r + K.epsilon())

    return fbeta_score
def prec(y_true, y_pred):

    tp = K.sum(K.round(K.clip(y_true * y_pred, 0,1)))
    predicted_p = K.sum(K.round(K.clip(y_pred,0,1)))
    possible_p = K.sum(K.round(K.clip(y_true,0,1)))

    p = tp/(predicted_p + K.epsilon())
  

    return p
def recall(y_true, y_pred):

    tp = K.sum(K.round(K.clip(y_true * y_pred, 0,1)))
    predicted_p = K.sum(K.round(K.clip(y_pred,0,1)))
    possible_p = K.sum(K.round(K.clip(y_true,0,1)))

    p = tp/(predicted_p + K.epsilon())
    r = tp/(possible_p + K.epsilon())
 

    return r

def one_hot_encode_object_array(arr):
    '''One hot encode a numpy array of objects (e.g. strings)'''
    uniques, ids = np.unique(arr, return_inverse=True)
    return np_utils.to_categorical(ids, len(uniques))


seed = 7
np.random.seed(seed)

dataframe = pd.read_csv("iris.csv",header=None)
dataset = dataframe.values

X = dataset[:,0:4].astype(float)
Y = dataset[:,4]

train_X, test_X, train_y, test_y = train_test_split(X, Y, train_size=0.5, random_state=1)
#print X
Y_train = one_hot_encode_object_array(train_y)
Y_test = one_hot_encode_object_array(test_y)
#print Y_test


model = Sequential()
model.add(Dense(16, input_shape=(4,)))
model.add(Activation('sigmoid'))
model.add(Dense(3))
model.add(Activation('softmax'))
model.compile(loss='categorical_crossentropy',optimizer='adam',metrics=['accuracy',f1_score,prec, recall])
model.fit(train_X,Y_train, verbose=1, batch_size=1, nb_epoch=100)
score = model.evaluate(test_X, Y_test,  verbose =0)

print "score is "
print score

-----------------------------------------
we got accuracy of 100%


References
Tutorial link
Code improvement link

Keras: Epoch vs Batch_size

Information got from the link

In the neural network terminology:

• one epoch = one forward pass and one backward pass of all the training examples
• batch size = the number of training examples in one forward/backward pass. The higher the batch size, the more memory space you'll need.
• number of iterations = number of passes, each pass using [batch size] number of examples. To be clear, one pass = one forward pass + one backward pass (we do not count the forward pass and backward pass as two different passes).

Example: if you have 1000 training examples, and your batch size is 500, then it will take 2 iterations to complete 1 epoch.

Keras 2.0: Precision, recall

import keras.backend as K

def f1_score(y_true, y_pred):

    # Count positive samples.
    #c1 = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))
    #c2 = K.sum(K.round(K.clip(y_pred, 0, 1)))
    #c3 = K.sum(K.round(K.clip(y_true, 0, 1)))

    true_positives = K.sum(K.round(K.clip(y_true * y_pred , 0, 1)))

   predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))
   possible_positives = K.sum(K.round(K.clip(y_true, 0, 1)))
    p = true_positives / (predicted_positives + K.epsilon())

r = true_positives / (possible_positives + K.epsilon()) beta = 1 # fmeasure bb = beta**2 fbeta_score = (1 + bb) * (p * r) / (bb * p + r + K.epsilon())

      return fbeta_score 

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

opencv: matching faces over time

link

Python and opencv : tracker example

Taken from

Link import cv2

import sys

if __name__ == '__main__' :

    # Set up tracker.

    # Instead of MIL, you can also use

    # BOOSTING, KCF, TLD, MEDIANFLOW or GOTURN

     

    tracker = cv2.Tracker_create("MIL")

    # Read video

    video = cv2.VideoCapture("videos/chaplin.mp4")

    # Exit if video not opened.

    if not video.isOpened():

        print "Could not open video"

        sys.exit()

    # Read first frame.

    ok, frame = video.read()

    if not ok:

        print 'Cannot read video file'

        sys.exit()

     

    # Define an initial bounding box

    bbox = (287, 23, 86, 320)

    # Uncomment the line below to select a different bounding box

    # bbox = cv2.selectROI(frame, False)

    # Initialize tracker with first frame and bounding box

    ok = tracker.init(frame, bbox)

    while True:

        # Read a new frame

        ok, frame = video.read()

        if not ok:

            break

         

        # Update tracker

        ok, bbox = tracker.update(frame)

        # Draw bounding box

        if ok:

            p1 = (int(bbox[0]), int(bbox[1]))

            p2 = (int(bbox[0] + bbox[2]), int(bbox[1] + bbox[3]))

            cv2.rectangle(frame, p1, p2, (0,0,255))

        # Display result

        cv2.imshow("Tracking", frame)

        # Exit if ESC pressed

        k = cv2.waitKey(1) & 0xff

        if k == 27 : break