import numpy as np
import matplotlib.cm as cm
from mpl_toolkits.axes_grid1 import make_axes_locatable
import matplotlib.pyplot as plt
import numpy.ma as ma
def make_mosaic(images, num_rows, num_cols, border=1, class_names=None):
num_images = len(images)
image_shape = images.shape[1:]
mosaic = ma.masked_all(
(num_rows * image_shape[0] + (num_rows - 1) * border,
num_cols * image_shape[1] + (num_cols - 1) * border),
dtype=np.float32)
paddedh = image_shape[0] + border
paddedw = image_shape[1] + border
for image_arg in range(num_images):
row = int(np.floor(image_arg / num_cols))
col = image_arg % num_cols
image = np.squeeze(images[image_arg])
image_shape = image.shape
mosaic[row * paddedh:row * paddedh + image_shape[0],
col * paddedw:col * paddedw + image_shape[1]] = image
return mosaic
def make_mosaic_v2(images, num_mosaic_rows=None,
num_mosaic_cols=None, border=1):
images = np.squeeze(images)
num_images, image_pixels_rows, image_pixels_cols = images.shape
if num_mosaic_rows is None and num_mosaic_cols is None:
box_size = int(np.ceil(np.sqrt(num_images)))
num_mosaic_rows = num_mosaic_cols = box_size
num_mosaic_pixel_rows = num_mosaic_rows * (image_pixels_rows + border)
num_mosaic_pixel_cols = num_mosaic_cols * (image_pixels_cols + border)
mosaic = np.empty(shape=(num_mosaic_pixel_rows, num_mosaic_pixel_cols))
mosaic_col_arg = 0
mosaic_row_arg = 0
for image_arg in range(num_images):
if image_arg % num_mosaic_cols == 0 and image_arg != 0:
mosaic_col_arg = mosaic_col_arg + 1
mosaic_row_arg = 0
x0 = image_pixels_cols * (mosaic_row_arg)
x1 = image_pixels_cols * (mosaic_row_arg + 1)
y0 = image_pixels_rows * (mosaic_col_arg)
y1 = image_pixels_rows * (mosaic_col_arg + 1)
image = images[image_arg]
mosaic[y0:y1, x0:x1] = image
mosaic_row_arg = mosaic_row_arg + 1
return mosaic
def pretty_imshow(axis, data, vmin=None, vmax=None, cmap=None):
if cmap is None:
cmap = cm.jet
if vmin is None:
vmin = data.min()
if vmax is None:
vmax = data.max()
cax = None
divider = make_axes_locatable(axis)
cax = divider.append_axes('right', size='5%', pad=0.05)
image = axis.imshow(data, vmin=vmin, vmax=vmax,
interpolation='nearest', cmap=cmap)
plt.colorbar(image, cax=cax)
def normal_imshow(axis, data, vmin=None, vmax=None,
cmap=None, axis_off=True):
if cmap is None:
cmap = cm.jet
if vmin is None:
vmin = data.min()
if vmax is None:
vmax = data.max()
image = axis.imshow(data, vmin=vmin, vmax=vmax,
interpolation='nearest', cmap=cmap)
if axis_off:
plt.axis('off')
return image
def display_image(face, class_vector=None,
class_decoder=None, pretty=False):
if class_vector is not None and class_decoder is None:
raise Exception('Provide class decoder')
face = np.squeeze(face)
color_map = None
if len(face.shape) < 3:
color_map = 'gray'
plt.figure()
if class_vector is not None:
class_arg = np.argmax(class_vector)
class_name = class_decoder[class_arg]
plt.title(class_name)
if pretty:
pretty_imshow(plt.gca(), face, cmap=color_map)
else:
plt.imshow(face, color_map)
def draw_mosaic(data, num_rows, num_cols, class_vectors=None,
class_decoder=None, cmap='gray'):
if class_vectors is not None and class_decoder is None:
raise Exception('Provide class decoder')
figure, axis_array = plt.subplots(num_rows, num_cols)
figure.set_size_inches(8, 8, forward=True)
titles = []
if class_vectors is not None:
for vector_arg in range(len(class_vectors)):
class_arg = np.argmax(class_vectors[vector_arg])
class_name = class_decoder[class_arg]
titles.append(class_name)
image_arg = 0
for row_arg in range(num_rows):
for col_arg in range(num_cols):
image = data[image_arg]
image = np.squeeze(image)
axis_array[row_arg, col_arg].axis('off')
axis_array[row_arg, col_arg].imshow(image, cmap=cmap)
axis_array[row_arg, col_arg].set_title(titles[image_arg])
image_arg = image_arg + 1
plt.tight_layout()
if __name__ == '__main__':
# from utils.data_manager import DataManager
from utils.utils import get_labels
from keras.models import load_model
import pickle
# dataset_name = 'fer2013'
# model_path = '../trained_models/emotion_models/simple_CNN.985-0.66.hdf5'
dataset_name = 'fer2013'
class_decoder = get_labels(dataset_name)
# data_manager = DataManager(dataset_name)
# faces, emotions = data_manager.get_data()
faces = pickle.load(open('faces.pkl', 'rb'))
emotions = pickle.load(open('emotions.pkl', 'rb'))
pretty_imshow(plt.gca(), make_mosaic(faces[:4], 2, 2), cmap='gray')
plt.show()
"""
image_arg = 0
face = faces[image_arg:image_arg + 1]
emotion = emotions[image_arg:image_arg + 1]
display_image(face, emotion, class_decoder)
plt.show()
normal_imshow(plt.gca(), make_mosaic(faces[:4], 3, 3), cmap='gray')
plt.show()
draw_mosaic(faces, 2, 2, emotions, class_decoder)
plt.show()
"""
model = load_model('../trained_models/emotion_models/simple_CNN.985-0.66.hdf5')
conv1_weights = model.layers[2].get_weights()
kernel_conv1_weights = conv1_weights[0]
kernel_conv1_weights = np.squeeze(kernel_conv1_weights)
kernel_conv1_weights = np.rollaxis(kernel_conv1_weights, 2, 0)
kernel_conv1_weights = np.expand_dims(kernel_conv1_weights, -1)
num_kernels = kernel_conv1_weights.shape[0]
box_size = int(np.ceil(np.sqrt(num_kernels)))
print('Box size:', box_size)
print('Kernel shape', kernel_conv1_weights.shape)
plt.figure(figsize=(15, 15))
plt.title('conv1 weights')
pretty_imshow(
plt.gca(),
make_mosaic(kernel_conv1_weights, box_size, box_size),
cmap=cm.binary)
plt.show()
