def main_train(self):
with tf.Graph().as_default():
with tf.Session() as sess:
img_data = facenet.get_dataset(self.datadir)
path, label = facenet.get_image_paths_and_labels(img_data)
print('Classes: %d' % len(img_data))
print('Images: %d' % len(path))
facenet.load_model(self.modeldir)
images_placeholder = tf.get_default_graph().get_tensor_by_name(
"input:0")
embeddings = tf.get_default_graph().get_tensor_by_name(
"embeddings:0")
phase_train_placeholder = tf.get_default_graph(
).get_tensor_by_name("phase_train:0")
embedding_size = embeddings.get_shape()[1]
print('Extracting features of images for model')
batch_size = 1000
image_size = 160
nrof_images = len(path)
nrof_batches_per_epoch = int(
math.ceil(1.0 * nrof_images / batch_size))
emb_array = np.zeros((nrof_images, embedding_size))
for i in range(nrof_batches_per_epoch):
start_index = i * batch_size
end_index = min((i + 1) * batch_size, nrof_images)
paths_batch = path[start_index:end_index]
images = facenet.load_data(paths_batch, False, False,
image_size)
feed_dict = {
images_placeholder: images,
phase_train_placeholder: False
}
emb_array[start_index:end_index, :] = sess.run(
embeddings, feed_dict=feed_dict)
classifier_file_name = os.path.expanduser(
self.classifier_filename)
# Training Started
print('Training Started')
model = SVC(kernel='linear', probability=True)
model.fit(emb_array, label)
class_names = [cls.name.replace('_', ' ') for cls in img_data]
# Saving model
with open(classifier_file_name, 'wb') as outfile:
pickle.dump((model, class_names), outfile)
return classifier_file_name
def collect_data(self):
output_dir = os.path.expanduser(self.output_datadir)
if not os.path.exists(output_dir):
os.makedirs(output_dir)
dataset = facenet.get_dataset(self.input_datadir)
with tf.Graph().as_default():
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.5)
sess = tf.Session(config=tf.ConfigProto(
gpu_options=gpu_options, log_device_placement=False))
with sess.as_default():
pnet, rnet, onet = detect_face.create_mtcnn(sess, '')
minsize = 20 # minimum size of face
threshold = [0.6, 0.7, 0.7] # three steps's threshold
factor = 0.709 # scale factor
margin = 44
image_size = 182
# Add a random key to the filename to allow alignment using multiple processes
random_key = np.random.randint(0, high=99999)
bounding_boxes_filename = os.path.join(
output_dir, 'bounding_boxes_%05d.txt' % random_key)
with open(bounding_boxes_filename, "w") as text_file:
nrof_images_total = 0
nrof_successfully_aligned = 0
for cls in dataset:
output_class_dir = os.path.join(output_dir, cls.name)
if not os.path.exists(output_class_dir):
os.makedirs(output_class_dir)
for image_path in cls.image_paths:
nrof_images_total += 1
filename = os.path.splitext(
os.path.split(image_path)[1])[0]
output_filename = os.path.join(output_class_dir,
filename + '.png')
print("Image: %s" % image_path)
if not os.path.exists(output_filename):
try:
img = misc.imread(image_path)
except (IOError, ValueError, IndexError) as e:
errorMessage = '{}: {}'.format(image_path, e)
print(errorMessage)
else:
if img.ndim < 2:
print('Unable to align "%s"' % image_path)
text_file.write('%s\n' % (output_filename))
continue
if img.ndim == 2:
img = facenet.to_rgb(img)
print('to_rgb data dimension: ', img.ndim)
img = img[:, :, 0:3]
bounding_boxes, _ = detect_face.detect_face(
img, minsize, pnet, rnet, onet, threshold,
factor)
nrof_faces = bounding_boxes.shape[0]
print('No of Detected Face: %d' % nrof_faces)
if nrof_faces > 0:
det = bounding_boxes[:, 0:4]
img_size = np.asarray(img.shape)[0:2]
if nrof_faces > 1:
bounding_box_size = (
det[:, 2] - det[:, 0]) * (det[:, 3] -
det[:, 1])
img_center = img_size / 2
offsets = np.vstack([
(det[:, 0] + det[:, 2]) / 2 -
img_center[1],
(det[:, 1] + det[:, 3]) / 2 -
img_center[0]
])
offset_dist_squared = np.sum(
np.power(offsets, 2.0), 0)
index = np.argmax(
bounding_box_size -
offset_dist_squared * 2.0
) # some extra weight on the centering
det = det[index, :]
det = np.squeeze(det)
bb_temp = np.zeros(4, dtype=np.int32)
bb_temp[0] = det[0]
bb_temp[1] = det[1]
bb_temp[2] = det[2]
bb_temp[3] = det[3]
cropped_temp = img[bb_temp[1]:bb_temp[3],
bb_temp[0]:bb_temp[2], :]
scaled_temp = misc.imresize(
cropped_temp, (image_size, image_size),
interp='bilinear')
nrof_successfully_aligned += 1
misc.imsave(output_filename, scaled_temp)
text_file.write(
'%s %d %d %d %d\n' %
(output_filename, bb_temp[0], bb_temp[1],
bb_temp[2], bb_temp[3]))
else:
print('Unable to align "%s"' % image_path)
text_file.write('%s\n' % (output_filename))
return (nrof_images_total, nrof_successfully_aligned)
def main(args):
sleep(random.random())
output_dir = os.path.expanduser(args.output_dir)
if not os.path.exists(output_dir):
os.makedirs(output_dir)
# Store some git revision info in a text file in the log directory
src_path, _ = os.path.split(os.path.realpath(__file__))
facenet.store_revision_info(src_path, output_dir, ' '.join(sys.argv))
dataset = facenet.get_dataset(args.input_dir)
print('Creating networks and loading parameters')
with tf.Graph().as_default():
gpu_options = tf.GPUOptions(
per_process_gpu_memory_fraction=args.gpu_memory_fraction)
sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options,
log_device_placement=False))
with sess.as_default():
pnet, rnet, onet = align.detect_face.create_mtcnn(sess, None)
minsize = 20 # minimum size of face
threshold = [0.6, 0.7, 0.7] # three steps's threshold
factor = 0.709 # scale factor
# Add a random key to the filename to allow alignment using multiple processes
random_key = np.random.randint(0, high=99999)
bounding_boxes_filename = os.path.join(
output_dir, 'bounding_boxes_%05d.txt' % random_key)
with open(bounding_boxes_filename, "w") as text_file:
nrof_images_total = 0
nrof_successfully_aligned = 0
if args.random_order:
random.shuffle(dataset)
for cls in dataset:
output_class_dir = os.path.join(output_dir, cls.name)
if not os.path.exists(output_class_dir):
os.makedirs(output_class_dir)
if args.random_order:
random.shuffle(cls.image_paths)
for image_path in cls.image_paths:
nrof_images_total += 1
filename = os.path.splitext(os.path.split(image_path)[1])[0]
output_filename = os.path.join(output_class_dir,
filename + '.png')
print(image_path)
if not os.path.exists(output_filename):
try:
img = misc.imread(image_path)
except (IOError, ValueError, IndexError) as e:
errorMessage = '{}: {}'.format(image_path, e)
print(errorMessage)
else:
if img.ndim < 2:
print('Unable to align "%s"' % image_path)
text_file.write('%s\n' % (output_filename))
continue
if img.ndim == 2:
img = facenet.to_rgb(img)
img = img[:, :, 0:3]
bounding_boxes, _ = align.detect_face.detect_face(
img, minsize, pnet, rnet, onet, threshold, factor)
nrof_faces = bounding_boxes.shape[0]
if nrof_faces > 0:
det = bounding_boxes[:, 0:4]
det_arr = []
img_size = np.asarray(img.shape)[0:2]
if nrof_faces > 1:
if args.detect_multiple_faces:
for i in range(nrof_faces):
det_arr.append(np.squeeze(det[i]))
else:
bounding_box_size = (
det[:, 2] - det[:, 0]) * (det[:, 3] -
det[:, 1])
img_center = img_size / 2
offsets = np.vstack([
(det[:, 0] + det[:, 2]) / 2 -
img_center[1],
(det[:, 1] + det[:, 3]) / 2 -
img_center[0]
])
offset_dist_squared = np.sum(
np.power(offsets, 2.0), 0)
index = np.argmax(
bounding_box_size -
offset_dist_squared * 2.0
) # some extra weight on the centering
det_arr.append(det[index, :])
else:
det_arr.append(np.squeeze(det))
for i, det in enumerate(det_arr):
det = np.squeeze(det)
bb = np.zeros(4, dtype=np.int32)
bb[0] = np.maximum(det[0] - args.margin / 2, 0)
bb[1] = np.maximum(det[1] - args.margin / 2, 0)
bb[2] = np.minimum(det[2] + args.margin / 2,
img_size[1])
bb[3] = np.minimum(det[3] + args.margin / 2,
img_size[0])
cropped = img[bb[1]:bb[3], bb[0]:bb[2], :]
scaled = misc.imresize(
cropped,
(args.image_size, args.image_size),
interp='bilinear')
scaled = facenet.prewhiten(scaled)
nrof_successfully_aligned += 1
filename_base, file_extension = os.path.splitext(
output_filename)
if args.detect_multiple_faces:
output_filename_n = "{}_{}{}".format(
filename_base, i, file_extension)
else:
output_filename_n = "{}{}".format(
filename_base, file_extension)
misc.imsave(output_filename_n, scaled)
text_file.write('%s %d %d %d %d\n' %
(output_filename_n, bb[0],
bb[1], bb[2], bb[3]))
else:
print('Unable to align "%s"' % image_path)
text_file.write('%s\n' % (output_filename))
print('Total number of images: %d' % nrof_images_total)
print('Number of successfully aligned images: %d' %
nrof_successfully_aligned)
def main_train(self):
with tf.Graph().as_default():
with tf.Session() as sess:
img_data = facenet.get_dataset(self.datadir)
path, label = facenet.get_image_paths_and_labels(img_data)
print("label")
print(label)
print('Classes: %d' % len(img_data))
print('Images: %d' % len(path))
facenet.load_model(self.modeldir)
images_placeholder = tf.get_default_graph().get_tensor_by_name(
"input:0")
embeddings = tf.get_default_graph().get_tensor_by_name(
"embeddings:0")
phase_train_placeholder = tf.get_default_graph(
).get_tensor_by_name("phase_train:0")
embedding_size = embeddings.get_shape()[1]
print('Extracting features of images for model')
batch_size = 10000
image_size = 160
nrof_images = len(path)
nrof_batches_per_epoch = int(
math.ceil(1.0 * nrof_images / batch_size))
emb_array = np.zeros((nrof_images, embedding_size))
#print(nrof_batches_per_epoch)
#for i in range(nrof_batches_per_epoch):
start_index = 0 * batch_size
end_index = min((0 + 1) * batch_size, nrof_images)
paths_batch = path[start_index:end_index]
images = facenet.load_data(paths_batch, False, False,
image_size)
feed_dict = {
images_placeholder: images,
phase_train_placeholder: False
}
emb_array[start_index:end_index, :] = sess.run(
embeddings, feed_dict=feed_dict)
print("emb_array[0]")
print(emb_array[0])
class_names = [cls.name.replace('_', ' ') for cls in img_data]
classifier_file_name = os.path.expanduser(
self.classifier_filename)
print('emb_array')
print(emb_array)
X_embedded = TSNE(n_components=2).fit_transform(emb_array)
X_embedded -= X_embedded.min(axis=0)
X_embedded /= X_embedded.max(axis=0)
print("X_embedded")
print(X_embedded)
#for i in range(0, nrof_images-1):
# plt.plot(X_embedded[i, 0], X_embedded[i, 1],'bo')
plt.legend(bbox_to_anchor=(1, 1))
plt.show()
out_dim = round(math.sqrt(nrof_images))
out_res = 160
to_plot = np.square(out_dim)
grid = np.dstack(
np.meshgrid(np.linspace(0, 1, out_dim),
np.linspace(0, 1, out_dim))).reshape(-1, 2)
cost_matrix = cdist(grid, X_embedded,
"sqeuclidean").astype(np.float32)
cost_matrix = cost_matrix * (100000 / cost_matrix.max())
print(cost_matrix)
#rids, cids = solve_dense(costs)
#print(rids)
print("zaczalem to robic")
#row_ind, col_ind = linear_sum_assignment(cost_matrix)
row_asses, col_asses, _ = lapjv(cost_matrix)
#print("To cos")
#print (col_asses)
print("teraz to!")
#print (row_ind)
#print (col_ind)
#for r,c in zip(row_ind, col_asses):
# print(r,c) # Row/column pairings
grid_jv = grid[col_asses]
out = np.ones((out_dim * out_res, out_dim * out_res, 3))
print(grid_jv)
for pos, img in zip(grid_jv, images[0:to_plot]):
h_range = int(np.floor(pos[0] * (out_dim - 1) * out_res))
w_range = int(np.floor(pos[1] * (out_dim - 1) * out_res))
out[h_range:h_range + out_res,
w_range:w_range + out_res] = image.img_to_array(img)
print(out)
im = image.array_to_img(out)
im.save("obrazekV2.jpg", quality=100)
def main_train(self):
with tf.Graph().as_default():
with tf.Session() as sess:
img_data = facenet.get_dataset(self.datadir)
path, label = facenet.get_image_paths_and_labels(img_data)
print("label")
print(label)
print('Classes: %d' % len(img_data))
print('Images: %d' % len(path))
facenet.load_model(self.modeldir)
images_placeholder = tf.get_default_graph().get_tensor_by_name(
"input:0")
embeddings = tf.get_default_graph().get_tensor_by_name(
"embeddings:0")
phase_train_placeholder = tf.get_default_graph(
).get_tensor_by_name("phase_train:0")
embedding_size = embeddings.get_shape()[1]
print('Extracting features of images for model')
batch_size = 1000
image_size = 160
nrof_images = len(path)
nrof_batches_per_epoch = int(
math.ceil(1.0 * nrof_images / batch_size))
emb_array = np.zeros((nrof_images, embedding_size))
print(nrof_batches_per_epoch)
for i in range(nrof_batches_per_epoch):
start_index = i * batch_size
end_index = min((i + 1) * batch_size, nrof_images)
paths_batch = path[start_index:end_index]
images = facenet.load_data(paths_batch, False, False,
image_size)
feed_dict = {
images_placeholder: images,
phase_train_placeholder: False
}
emb_array[start_index:end_index, :] = sess.run(
embeddings, feed_dict=feed_dict)
class_names = [cls.name.replace('_', ' ') for cls in img_data]
classifier_file_name = os.path.expanduser(
self.classifier_filename)
print('emb_array')
print(emb_array)
X_embedded = TSNE(n_components=2).fit_transform(emb_array)
print('X_embedded')
print(X_embedded)
faces_group = np.zeros((nrof_images, embedding_size))
for i in range(0, nrof_images - 1):
print("i: ")
print(i)
j = label[i]
print("j: ")
print(j)
faces_group[j].append(X_embedded[i])
#plt.plot(X_embedded[i, 0], X_embedded[i, 1], label=name)#label=name)
#plt.scatter(X_embedded[i, 0], X_embedded[i, 1], label=name)
for i in enumerate(set(faces_group)):
name = class_names[i]
plt.scatter(faces_group[i, 0],
faces_group[i, 1],
label=name)
plt.legend(bbox_to_anchor=(1, 1))
#plt.axis([-50, 50, -50, 50])
plt.show()
#time.sleep(5)
#plt.imshow()
# Training Started
print('Training Started')
model = SVC(kernel='linear', probability=True)
model.fit(emb_array, label)
print(class_names)
# Saving model
with open(classifier_file_name, 'wb') as outfile:
pickle.dump((model, class_names), outfile)
return classifier_file_name
import numpy as np
import tensorflow as tf
import time
from sklearn.svm import SVC
from packages import facenet
from scipy.spatial.distance import cdist
from scipy.optimize import linear_sum_assignment
from tensorflow.python.keras.preprocessing import image
from lapjv import lapjv
datadir = "align_img"
modeldir = "model"
with tf.Session() as sess:
#tf.Session() as sess
img_data = facenet.get_dataset(datadir)
path, label = facenet.get_image_paths_and_labels(img_data)
print("label")
print(label)
print('Classes: %d' % len(img_data))
print('Images: %d' % len(path))
facenet.load_model(modeldir)
images_placeholder = tf.get_default_graph().get_tensor_by_name("input:0")
embeddings = tf.get_default_graph().get_tensor_by_name("embeddings:0")
phase_train_placeholder = tf.get_default_graph().get_tensor_by_name(
"phase_train:0")
embedding_size = embeddings.get_shape()[1]
print('Extracting features of images for model')
batch_size = 10000
image_size = 160
def main_train(self):
with tf.Graph().as_default():
gpu_options = tf.GPUOptions(allow_growth=True)
with tf.Session(config=tf.ConfigProto(
gpu_options=gpu_options,
log_device_placement=False)).as_default() as sess:
img_data = facenet.get_dataset(self.datadir)
path, label = facenet.get_image_paths_and_labels(img_data)
print('Classes: %d' % len(img_data))
print('Images: %d' % len(path))
facenet.load_model(self.modeldir)
images_placeholder = tf.get_default_graph().get_tensor_by_name(
"input:0")
embeddings = tf.get_default_graph().get_tensor_by_name(
"embeddings:0")
phase_train_placeholder = tf.get_default_graph(
).get_tensor_by_name("phase_train:0")
embedding_size = embeddings.get_shape()[1]
print('Extracting features of images for model')
batch_size = 100 #batch size 100
image_size = 160
nrof_images = len(path)
nrof_batches_per_epoch = int(
math.ceil(1.0 * nrof_images / batch_size))
emb_array = np.zeros((nrof_images, embedding_size))
for i in range(nrof_batches_per_epoch):
start_index = i * batch_size
end_index = min((i + 1) * batch_size, nrof_images)
paths_batch = path[start_index:end_index]
images = facenet.load_data(paths_batch, False, False,
image_size)
feed_dict = {
images_placeholder: images,
phase_train_placeholder: False
}
emb_array[start_index:end_index, :] = sess.run(
embeddings, feed_dict=feed_dict)
classifier_file_name = os.path.expanduser(
self.classifier_filename)
score_path = os.path.expanduser(self.score_path)
# Training Started
print('Training Started')
#parameters tuning
param_grid = {
'C': [1, 10, 100, 1000],
'gamma': [1, 0.1, 0.001, 0.0001],
'kernel': ['linear', 'rbf']
}
grid = GridSearchCV(SVC(), param_grid, refit=True, verbose=2)
grid.fit(emb_array, label)
best_param = grid.best_params_
print('Best Parameters: ', best_param)
print('Train Using Best Parameters...')
model = SVC(C=best_param['C'],
gamma=best_param['gamma'],
kernel=best_param['kernel'],
probability=True)
model.fit(emb_array, label)
score = model.score(emb_array, label)
print('Model Accuracy:', score)
#Saving acc
with open(score_path, 'w') as out_score:
out_score.write('Accuracy: {}\n '.format(score))
class_names = [cls.name.replace('_', ' ') for cls in img_data]
# Saving model
with open(classifier_file_name, 'wb') as outfile:
pickle.dump((model, class_names), outfile)
return classifier_file_name
