title: Keras Classification - Object Detection
body: <p>I am working on a classification then object detection with Keras and Python. I have classified cats/dogs with 80%+ accuracy, Im ok with the current result for now. My question is how do I detect cat or dog from an input image? I'm completely confused. I want to use my own heights and not pretrained ones from internet.</p>
  
  <p>Here is my code currently:</p>
  
  <pre><code>from keras.preprocessing.image import ImageDataGenerator
  from keras.models import Sequential
  from keras.layers import Convolution2D, MaxPooling2D
  from keras.layers import Activation, Dropout, Flatten, Dense
  import numpy as np
  import matplotlib.pyplot as plt
  import matplotlib
  
  from keras.preprocessing.image import ImageDataGenerator, array_to_img, img_to_array, load_img
  
  #########################################################################################################
  #VALUES
  # dimensions of our images.
  img_width, img_height = 150, 150
  
  train_data_dir = 'data/train'
  validation_data_dir = 'data/validation'
  nb_train_samples = 2000 #1000 cats/dogs
  nb_validation_samples = 800 #400cats/dogs
  nb_epoch = 50
  #########################################################################################################
  
  #MODEL
  model = Sequential()
  model.add(Convolution2D(32, 3, 3, input_shape=(3, img_width, img_height)))
  model.add(Activation('relu'))
  model.add(MaxPooling2D(pool_size=(2, 2)))
  
  model.add(Convolution2D(32, 3, 3))
  model.add(Activation('relu'))
  model.add(MaxPooling2D(pool_size=(2, 2)))
  
  model.add(Convolution2D(64, 3, 3))
  model.add(Activation('relu'))
  model.add(MaxPooling2D(pool_size=(2, 2)))
  
  model.add(Flatten())
  model.add(Dense(64))
  model.add(Activation('relu'))
  model.add(Dropout(0.5))
  model.add(Dense(1))
  model.add(Activation('sigmoid'))
  
  model.compile(loss='binary_crossentropy',
                optimizer='rmsprop',
                metrics=['accuracy'])
  
  
  # this is the augmentation configuration we will use for training
  train_datagen = ImageDataGenerator(
          rescale=1./255,
          shear_range=0.2,
          zoom_range=0.2,
          horizontal_flip=True)
  ##########################################################################################################
  #TEST AUGMENTATION
  img = load_img('data/train/cats/cat.0.jpg')  # this is a PIL image
  x = img_to_array(img)  # this is a Numpy array with shape (3, 150, 150)
  x = x.reshape((1,) + x.shape)  # this is a Numpy array with shape (1, 3, 150, 150)
  
  # the .flow() command below generates batches of randomly transformed images
  # and saves the results to the `preview/` directory
  i = 0
  for batch in train_datagen.flow(x, batch_size=1,
                            save_to_dir='data/TEST AUGMENTATION', save_prefix='cat', save_format='jpeg'):
      i += 1
      if i &gt; 20:
          break  # otherwise the generator would loop indefinitely
  ##########################################################################################################
  # this is the augmentation configuration we will use for testing:
  # only rescaling
  test_datagen = ImageDataGenerator(rescale=1./255)
  
  #PREPARE TRAINING DATA
  train_generator = train_datagen.flow_from_directory(
          train_data_dir, #data/train
          target_size=(img_width, img_height),  #RESIZE to 150/150
          batch_size=32,
          class_mode='binary')  #since we are using binarycrosentropy need binary labels
  
  #PREPARE VALIDATION DATA
  validation_generator = test_datagen.flow_from_directory(
          validation_data_dir,  #data/validation
          target_size=(img_width, img_height), #RESIZE 150/150
          batch_size=32,
          class_mode='binary')
  
  
  #START model.fit
  history =model.fit_generator(
          train_generator, #train data
          samples_per_epoch=nb_train_samples,
          nb_epoch=nb_epoch,
          validation_data=validation_generator,  #validation data
          nb_val_samples=nb_validation_samples)
  
  
  model.save_weights('savedweights.h5')
  # list all data in history
  print(history.history.keys())
  
  #ACC VS VAL_ACC
  plt.plot(history.history['acc'])
  plt.plot(history.history['val_acc'])
  plt.title('model accuracy ACC VS VAL_ACC')
  plt.ylabel('accuracy')
  plt.xlabel('epoch')
  plt.legend(['train', 'test'], loc='upper left')
  plt.show()
  # summarize history for loss
  #LOSS VS VAL_LOSS
  plt.plot(history.history['loss'])
  plt.plot(history.history['val_loss'])
  plt.title('model loss LOSS vs VAL_LOSS')
  plt.ylabel('loss')
  plt.xlabel('epoch')
  plt.legend(['train', 'test'], loc='upper left')
  plt.show()
  
  
  model.load_weights('first_try.h5')
  </code></pre>
  
  <p>So now since i classified cat and dog, how and what do I need to do to input an image and go through it to find cat or a dog in it with a bounding box? I'm completely new to this nd not even sure if I'm tackling this in a correct way?
  Thank you.</p>
  
  <p><strong>UPDATE</strong>
  Hi, Sorry to post results so late, was unable to work on this for few days.
  I am importing an image and reshaping it to 1,3,150,150 shape as 150,150 shape brings error:</p>
  
  <pre><code>Exception: Error when checking : expected convolution2d_input_1 to have 4 dimensions, but got array with shape (150L, 150L)
  </code></pre>
  
  <p>Importing image:</p>
  
  <pre><code>#load test image
  img=load_img('data/prediction/cat.155.jpg')
  #reshape to 1,3,150,150
  img = np.arange(1* 150 * 150).reshape((1,3,150, 150))
  #check shape
  print(img.shape)
  </code></pre>
  
  <p>Then I have changed def predict_function(x) to:</p>
  
  <pre><code>def predict_function(x):
      # example of prediction function for simplicity, you
      # should probably use `return model.predict(x)`
     # random.seed(x[0][0])
    #  return random.random()
     return model.predict(img)
  </code></pre>
  
  <p>Now when I run:</p>
  
  <pre><code>best_box = get_best_bounding_box(img, predict_function)
  print('best bounding box %r' % (best_box, ))
  </code></pre>
  
  <p>I get output as best bounding box: None</p>
  
  <p>So I ran just:</p>
  
  <pre><code>model.predict(img)
  </code></pre>
  
  <p>And get the following out:</p>
  
  <pre><code>model.predict(img)
  Out[54]: array([[ 0.]], dtype=float32)
  </code></pre>
  
  <p>So it is not checking at all if its a cat or a dog... Any ideas? </p>
  
  <p>NOTE: when def predict)function(x) is using:</p>
  
  <pre><code>random.seed(x[0][0])
     return random.random()
  </code></pre>
  
  <p>I do get the output as , it check boxes and gives the best one.</p>