Mac ML demo

gistfile1.txt

import os
import zipfile
import image
import numpy as np

os.environ["KERAS_BACKEND"] = "plaidml.keras.backend"

import keras
import keras.applications as kapp
from keras.preprocessing import image

local_zip = '/tmp/cats_and_dogs_filtered.zip'
zip_ref = zipfile.ZipFile(local_zip, 'r')
zip_ref.extractall('/tmp')
zip_ref.close()

base_dir = '/tmp/cats_and_dogs_filtered'
train_dir = os.path.join(base_dir, 'train')
validation_dir = os.path.join(base_dir, 'validation')

# Directory with our training cat/dog pictures
train_cats_dir = os.path.join(train_dir, 'cats')
train_dogs_dir = os.path.join(train_dir, 'dogs')

# Directory with our validation cat/dog pictures
validation_cats_dir = os.path.join(validation_dir, 'cats')
validation_dogs_dir = os.path.join(validation_dir, 'dogs')

train_cat_fnames = os.listdir( train_cats_dir )
train_dog_fnames = os.listdir( train_dogs_dir )

print(train_cat_fnames[:10])
print(train_dog_fnames[:10])

print('total training cat images :', len(os.listdir(      train_cats_dir ) ))
print('total training dog images :', len(os.listdir(      train_dogs_dir ) ))

print('total validation cat images :', len(os.listdir( validation_cats_dir ) ))
print('total validation dog images :', len(os.listdir( validation_dogs_dir ) ))

import matplotlib.image as mpimg
import matplotlib.pyplot as plt

# Parameters for our graph; we'll output images in a 4x4 configuration
nrows = 4
ncols = 4

pic_index = 0 # Index for iterating over images

fig = plt.gcf()
fig.set_size_inches(ncols*4, nrows*4)

pic_index+=8

next_cat_pix = [os.path.join(train_cats_dir, fname) 
                for fname in train_cat_fnames[ pic_index-8:pic_index] 
               ]

next_dog_pix = [os.path.join(train_dogs_dir, fname) 
                for fname in train_dog_fnames[ pic_index-8:pic_index]
               ]

for i, img_path in enumerate(next_cat_pix+next_dog_pix):
  # Set up subplot; subplot indices start at 1
  sp = plt.subplot(nrows, ncols, i + 1)
  sp.axis('Off') # Don't show axes (or gridlines)
  sp.set_title(os.path.basename(img_path))
  img = mpimg.imread(img_path)
  plt.imshow(img)

# plt.show()
model = None

try:
  model = keras.models.load_model('model.h5')
except:
  print('file not found, creating model')

if not model:
  model = keras.models.Sequential([
      # Note the input shape is the desired size of the image 150x150 with 3 bytes color
      keras.layers.Conv2D(16, (3,3), activation='relu', input_shape=(150, 150, 3)),
      keras.layers.MaxPooling2D(2,2),
      keras.layers.Conv2D(32, (3,3), activation='relu'),
      keras.layers.MaxPooling2D(2,2), 
      keras.layers.Conv2D(64, (3,3), activation='relu'), 
      keras.layers.MaxPooling2D(2,2),
      # Flatten the results to feed into a DNN
      keras.layers.Flatten(), 
      # 512 neuron hidden layer
      keras.layers.Dense(512, activation='relu'), 
      # Only 1 output neuron. It will contain a value from 0-1 where 0 for 1 class ('cats') and 1 for the other ('dogs')
      keras.layers.Dense(1, activation='sigmoid')  
  ])

  model.summary()

  from keras.optimizers import RMSprop

  model.compile(optimizer=RMSprop(lr=0.001),
                loss='binary_crossentropy',
                metrics = ['acc'])

  from keras.preprocessing.image import ImageDataGenerator

  # All images will be rescaled by 1./255.
  train_datagen = ImageDataGenerator( rescale = 1.0/255. )
  test_datagen  = ImageDataGenerator( rescale = 1.0/255. )

  # --------------------
  # Flow training images in batches of 20 using train_datagen generator
  # --------------------
  train_generator = train_datagen.flow_from_directory(train_dir,
                                                      batch_size=20,
                                                      class_mode='binary',
                                                      target_size=(150, 150))     
  # --------------------
  # Flow validation images in batches of 20 using test_datagen generator
  # --------------------
  validation_generator =  test_datagen.flow_from_directory(validation_dir,
                                                          batch_size=20,
                                                          class_mode  = 'binary',
                                                          target_size = (150, 150))

  history = model.fit_generator(train_generator,
                                validation_data=validation_generator,
                                steps_per_epoch=100,
                                epochs=15,
                                validation_steps=50,
                                verbose=2)

img_path = "cat.jpg"
img = image.load_img(img_path, target_size=(150, 150))

x=image.img_to_array(img)
x=np.expand_dims(x, axis=0)
images = np.vstack([x])classes = model.predict(images, batch_size=1)
print(classes[0])
  
if classes[0]>0:
  print("is a dog")
  
else:
  print("is a cat")

print(keras.__version__)