-
Notifications
You must be signed in to change notification settings - Fork 0
/
visualizer.py
170 lines (154 loc) · 6.38 KB
/
visualizer.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
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
import cv2
from .inference import draw_text
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()