In [33]:
%run -i 5.2-cat-vs-dog.py
In [24]:
import os, shutil
# The path to the directory where the original
# dataset was uncompressed
original_dataset_dir = r"C:\Users\huxiaomi\Downloads\deep-learning\data\kaggle-dogs-vs-cats\train"
# The directory where we will
# store our smaller dataset
base_dir = r"C:\Users\huxiaomi\Downloads\deep-learning\data\kaggle-dogs-vs-cats\book"
os.mkdir(base_dir)
# Directories for our training,
# validation and test splits
train_dir = os.path.join(base_dir, 'train')
os.mkdir(train_dir)
validation_dir = os.path.join(base_dir, 'validation')
os.mkdir(validation_dir)
test_dir = os.path.join(base_dir, 'test')
os.mkdir(test_dir)
# Directory with our training cat pictures
train_cats_dir = os.path.join(train_dir, 'cats')
os.mkdir(train_cats_dir)
# Directory with our training dog pictures
train_dogs_dir = os.path.join(train_dir, 'dogs')
os.mkdir(train_dogs_dir)
# Directory with our validation cat pictures
validation_cats_dir = os.path.join(validation_dir, 'cats')
os.mkdir(validation_cats_dir)
# Directory with our validation dog pictures
validation_dogs_dir = os.path.join(validation_dir, 'dogs')
os.mkdir(validation_dogs_dir)
# Directory with our validation cat pictures
test_cats_dir = os.path.join(test_dir, 'cats')
os.mkdir(test_cats_dir)
# Directory with our validation dog pictures
test_dogs_dir = os.path.join(test_dir, 'dogs')
os.mkdir(test_dogs_dir)
# Copy first 1000 cat images to train_cats_dir
fnames = ['cat.{}.jpg'.format(i) for i in range(1000)]
for fname in fnames:
src = os.path.join(original_dataset_dir, fname)
dst = os.path.join(train_cats_dir, fname)
shutil.copyfile(src, dst)
# Copy next 500 cat images to validation_cats_dir
fnames = ['cat.{}.jpg'.format(i) for i in range(1000, 1500)]
for fname in fnames:
src = os.path.join(original_dataset_dir, fname)
dst = os.path.join(validation_cats_dir, fname)
shutil.copyfile(src, dst)
# Copy next 500 cat images to test_cats_dir
fnames = ['cat.{}.jpg'.format(i) for i in range(1500, 2000)]
for fname in fnames:
src = os.path.join(original_dataset_dir, fname)
dst = os.path.join(test_cats_dir, fname)
shutil.copyfile(src, dst)
# Copy first 1000 dog images to train_dogs_dir
fnames = ['dog.{}.jpg'.format(i) for i in range(1000)]
for fname in fnames:
src = os.path.join(original_dataset_dir, fname)
dst = os.path.join(train_dogs_dir, fname)
shutil.copyfile(src, dst)
# Copy next 500 dog images to validation_dogs_dir
fnames = ['dog.{}.jpg'.format(i) for i in range(1000, 1500)]
for fname in fnames:
src = os.path.join(original_dataset_dir, fname)
dst = os.path.join(validation_dogs_dir, fname)
shutil.copyfile(src, dst)
# Copy next 500 dog images to test_dogs_dir
fnames = ['dog.{}.jpg'.format(i) for i in range(1500, 2000)]
for fname in fnames:
src = os.path.join(original_dataset_dir, fname)
dst = os.path.join(test_dogs_dir, fname)
shutil.copyfile(src, dst)
In [28]:
from keras import layers
from keras import models
from keras import optimizers
from keras.preprocessing.image import ImageDataGenerator
import matplotlib.pyplot as plt
model = models.Sequential()
model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(150, 150, 3)))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(128, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(128, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Flatten())
model.add(layers.Dropout(0.5))
model.add(layers.Dense(512, activation='relu'))
model.add(layers.Dense(1, activation='sigmoid'))
model.compile(loss='binary_crossentropy', optimizer=optimizers.RMSprop(lr=1e-4),metrics=['acc'])
In [35]:
train_datagen = ImageDataGenerator(
rescale=1./255,
rotation_range=40,
width_shift_range=0.2,
height_shift_range=0.2,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=True,)
# Note that the validation data should not be augmented!
test_datagen = ImageDataGenerator(rescale=1./255)
train_generator = train_datagen.flow_from_directory(
# This is the target directory
train_dir,
# All images will be resized to 150x150
target_size=(150, 150),
batch_size=32,
# Since we use binary_crossentropy loss, we need binary labels
class_mode='binary')
validation_generator = test_datagen.flow_from_directory(
validation_dir,
target_size=(150, 150),
batch_size=32,
class_mode='binary')
history = model.fit_generator(
train_generator,
steps_per_epoch=100,
epochs=100,
validation_data=validation_generator,
validation_steps=50)
In [34]:
model.summary()
In [36]:
%reset
In [37]:
from keras.applications import VGG16
conv_base = VGG16(weights='imagenet', include_top=False,
input_shape=(150, 150, 3))
In [38]:
conv_base.summary()
In [64]:
import os
import numpy as np
from keras.preprocessing.image import ImageDataGenerator
from keras.applications import VGG16
import time
conv_base = VGG16(weights='imagenet', include_top=False,
input_shape=(150, 150, 3))
base_dir = r"C:\Users\huxiaomi\Downloads\deep-learning\data\kaggle-dogs-vs-cats"
small_base_dir = os.path.join(base_dir, "small")
train_dir = os.path.join(small_base_dir, r"train")
cv_dir = os.path.join(small_base_dir, r"validation")
test_dir = os.path.join(small_base_dir, r"test")
batch_size = 20
imageGen = ImageDataGenerator(rescale=(1.0/255))
def extract_features(dir, sample_count):
features = np.zeros(shape=(sample_count, 4, 4, 512))
labels = np.zeros(shape=(sample_count,))
generator = imageGen.flow_from_directory(dir, target_size=(
150, 150), batch_size=batch_size, class_mode='binary')
i = 0
for inputs_batch, labels_batch in generator:
start_time = time.time()
feature = conv_base.predict(inputs_batch)
elapsed_time = time.time() - start_time
print(elapsed_time)
features[i*batch_size:(i+1)*batch_size] = feature
labels[i*batch_size:(i+1)*batch_size] = labels_batch
i += 1
if(i*batch_size >= sample_count):
break
return features, labels
train_feature, train_label = extract_features(train_dir, 2000)
validation_feature, validation_label = extract_features(cv_dir, 1000)
test_feature, test_label = extract_features(train_dir, 2000)
In [44]:
train_feature = train_feature.reshape(2000, -1)
validation_feature = validation_feature.reshape(1000, -1)
test_feature = test_feature.reshape(1000, -1)
In [48]:
from keras import models
from keras import layers
from keras import optimizers
from keras import losses
from keras import metrics
model = models.Sequential()
model.add(layers.Dense(512, activation='relu', input_dim=4*4*512))
model.add(layers.Dropout(0.5))
model.add(layers.Dense(1, activation='sigmoid'))
model.compile(optimizer=optimizers.RMSprop(lr=1e-4),
loss=losses.binary_crossentropy, metrics=[metrics.binary_accuracy])
history = model.fit(train_feature, train_label, batch_size=20, epochs=30,
validation_data=(validation_feature, validation_label))
In [52]:
import matplotlib.pyplot as plt
loss = history.history['loss']
acc = history.history['binary_accuracy']
val_acc = history.history['val_binary_accuracy']
val_loss = history.history['val_loss']
epochs = range(1, len(acc) + 1)
plt.plot(epochs, acc, 'bo', label='Training acc')
plt.plot(epochs, val_acc, 'b', label='Val acc')
plt.title('Accuracy')
plt.legend()
plt.figure()
plt.plot(epochs, loss, 'bo', label='Training loss')
plt.plot(epochs, val_loss, 'b', label='Val loss')
plt.title('Losses')
plt.legend()
plt.show()
In [53]:
%reset
In [58]:
import os
import numpy as np
from keras.preprocessing.image import ImageDataGenerator
from keras.applications import VGG16
from keras import models
from keras import layers
from keras import optimizers
from keras import losses
from keras import metrics
conv_base = VGG16(weights='imagenet', include_top=False,
input_shape=(150, 150, 3))
base_dir = r"C:\Users\huxiaomi\Downloads\deep-learning\data\kaggle-dogs-vs-cats"
small_base_dir = os.path.join(base_dir, "small")
train_dir = os.path.join(small_base_dir, r"train")
cv_dir = os.path.join(small_base_dir, r"validation")
test_dir = os.path.join(small_base_dir, r"test")
batch_size = 20
train_datagen = ImageDataGenerator(rescale=1.0 / 255, rotation_range=40, width_shift_range=0.2,
height_shift_range=0.2, shear_range=0.2,
zoom_range=0.2, horizontal_flip=True)
test_datagen = ImageDataGenerator(rescale=1.0 / 255)
conv_base = VGG16(weights='imagenet', include_top=False,
input_shape=(150, 150, 3))
model = models.Sequential()
model.add(conv_base)
model.add(layers.Flatten())
model.add(layers.Dense(256, activation='relu', input_dim=4*4*512))
model.add(layers.Dense(1, activation='sigmoid'))
conv_base.trainable = False
model.compile(optimizer=optimizers.RMSprop(lr=1e-5),
loss=losses.binary_crossentropy, metrics=[metrics.binary_accuracy])
In [63]:
model.summary()
conv_base.trainable = True
len(model.trainable_weights)
Out[63]:
In [60]:
train_generator = train_datagen.flow_from_directory(
train_dir, target_size=(150, 150), batch_size=batch_size, class_mode='binary')
validation_generator = train_datagen.flow_from_directory(
cv_dir, target_size=(150, 150), batch_size=batch_size, class_mode='binary')
history = model.fit_generator(train_generator, epochs=100, steps_per_epoch=100,
validation_data=validation_generator, validation_steps=50)
In [57]:
%reset
In [ ]: