def build_paths_and_labels_iog_test(self):
# initialize list of image paths and labels
paths, face_centers, labels = [], [], []
mat = loadmat(self.config.MAT_TEST_PATH)
mat_paths, mat_centers, mat_labels = [
p[0].split('\\')[-1] for p in mat['tecoll'][0][0]['name'][0]
], mat['tecoll'][0][0]['facePosSize'][:, [4, 5]], mat['tecoll'][0][0][
'ageClass'][:, 0] if self.config.DATASET_TYPE == 'age' else mat[
'tecoll'][0][0]['genClass'][:, 0]
paths_info = {}
for i, mat_path in enumerate(mat_paths):
path_info = paths_info.get(mat_path, {
'face_centers': [],
'labels': []
})
path_info['face_centers'].append(mat_centers[i].tolist())
path_info['labels'].append(
self.to_label(str(mat_labels[i]), str(mat_labels[i])))
paths_info[mat_path] = path_info
for unique_path, path_info in paths_info.items():
path = os.path.sep.join(
[self.config.BASE_PATH, '*', f'{unique_path}'])
unique_path = glob.glob(path)[0]
paths.append(unique_path)
face_centers.append(path_info['face_centers'])
labels.append(path_info['labels'])
return paths, face_centers, labels
def get_paths_and_labels(splits):
result = []
paths = []
for data in splits:
buff = [x.split("/")[-1] for x in data]
label = [int(x.split("?")[0]) for x in buff]
buff1 = [str(x.split("?")[1]) for x in buff]
path = ["../train/" + x for x in buff1]
result.append(label)
paths.append(path)
print(
"[INFO]There are {} training, {} validation and {} test labels".format(
len(result[0]), len(result[1]), len(result[2])))
labels = [result[ind] for ind, x in enumerate(result)]
return paths, labels
def build_paths_and_labels_iog(self):
# initialize list of image paths and labels
paths, face_coords, labels = [], [], []
# grab all person data files
person_data_paths = os.path.sep.join(
[self.config.BASE_PATH, '*', 'PersonData.txt'])
person_data_paths = glob.glob(person_data_paths)
# loop over person data files
for person_data_path in person_data_paths:
# get folder containing person data file
folder = os.path.sep.join(
[p for p in person_data_path.split(os.path.sep)[:-1]])
# load contents of file
rows = open(person_data_path).read().strip().split('\n')
# loop over rows
for i, row in enumerate(rows):
# check to see the line is image name, if so append it to image paths
if 'jpg' in row:
if i > 0:
face_coords.append(face_coord)
labels.append(label)
paths.append(os.path.sep.join([folder, row]))
# initialize lists containing face coords and age, gender label of each image
face_coord, label = [], []
else:
# get face coords and append to face corrds list
face_coord.append([int(c) for c in row.split()[:4]])
# get age and gender and append to list
age, gender = row.split()[4:]
label.append(self.to_label(age, gender))
if i == len(rows) - 1:
face_coords.append(face_coord)
labels.append(label)
return paths, face_coords, labels
def build_paths_and_labels_adience(self):
# initialize list of image paths and labels
cross_paths, cross_labels, cross_paths_frontal, cross_labels_frontal = [], [], [], []
# grab paths to folds file
fold_paths = os.path.sep.join(
[self.config.LABELS_PATH, 'fold_[0-9]_data.txt'])
fold_paths_frontal = os.path.sep.join(
[self.config.LABELS_PATH, 'fold_frontal_*_data.txt'])
fold_paths = glob.glob(fold_paths)
fold_paths_frontal = glob.glob(fold_paths_frontal)
fold_paths.sort()
fold_paths_frontal.sort()
# loop over folds paths
for fold_path, fold_path_frontal in zip(fold_paths,
fold_paths_frontal):
paths, labels, paths_frontal, labels_frontal = [], [], [], []
# load contents of folds file, skipping header
rows = open(fold_path).read().strip().split('\n')[1:]
rows_frontal = open(fold_path_frontal).read().strip().split(
'\n')[1:]
# loop over rows
for row in rows:
# unpack needed components of row
user_id, image_path, face_id, age, gender = row.split('\t')[:5]
if self.config.DATASET_TYPE == 'age' and age[0] != '(':
continue
if self.config.DATASET_TYPE == 'gender' and gender not in (
'f', 'm'):
continue
# construct path to input image and build class label
p = os.path.sep.join([
self.config.IMAGES_PATH, user_id,
f'landmark_aligned_face.{face_id}.{image_path}'
])
label = self.to_label(age, gender)
if label is None:
continue
paths.append(p)
labels.append(label)
cross_paths.append(paths)
cross_labels.append(labels)
# loop over rows frontal
for row_frontal in rows_frontal:
# unpack needed components of row
user_id, image_path, face_id, age, gender = row_frontal.split(
'\t')[:5]
if self.config.DATASET_TYPE == 'age' and age[0] != '(':
continue
if self.config.DATASET_TYPE == 'gender' and gender not in (
'f', 'm'):
continue
# construct path to input image and build class label
p = os.path.sep.join([
self.config.IMAGES_PATH, user_id,
f'landmark_aligned_face.{face_id}.{image_path}'
])
label = self.to_label(age, gender)
if label is None:
continue
paths_frontal.append(p)
labels_frontal.append(label)
cross_paths_frontal.append(paths_frontal)
cross_labels_frontal.append(labels_frontal)
for i, (test_paths, test_labels, test_paths_frontal,
test_labels_frontal) in enumerate(
zip(cross_paths, cross_labels, cross_paths_frontal,
cross_labels_frontal)):
train_paths, train_labels = [], []
for j in range(len(fold_paths)):
if j != i:
train_paths.extend(cross_paths[j])
train_labels.extend(cross_labels[j])
yield train_paths, train_labels, test_paths, test_labels, test_paths_frontal, test_labels_frontal
from imutils import paths
import face_recognition
import argparse
import pickle
import cv2
import os
# grab the paths to the input images in our dataset
paths = []
cats = [f.path for f in os.scandir("Dataset/") if f.is_dir()]
# cats = [p.split("/")[-1] for p in cats]
print(cats)
for cat in cats:
image_paths = [f.path for f in os.scandir(cat)]
for ip in image_paths:
paths.append(ip)
print(paths)
# initialize the list of known encodings and known names
knownEncodings = []
knownNames = []
# loop over the image paths
for (i, imagePath) in enumerate(paths):
# extract the person name from the image path
print("[INFO] processing image {}/{}".format(i + 1, len(paths)))
name = imagePath.split(os.path.sep)[-2]
# load the input image and convert it from BGR (OpenCV ordering)
# to dlib ordering (RGB)
image = cv2.imread(imagePath)
rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
# detect the (x, y)-coordinates of the bounding boxes
total_duplicates = 0
# First part, loop through the input images and get their hashes
print("Generating hashes...")
for img_path in img_paths:
img = cv2.imread(img_path)
img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
img = cv2.resize(img, (hash_size + 1, hash_size))
# Compute a horizontal gradient between adjacent column pixels
diff = img[:, 1:] > img[:, :-1]
# Convert the difference image to a hash
img_hash = sum([2**i for (i, v) in enumerate(diff.flatten()) if v])
# Find any other image paths with the same hash and add the current image
paths = hashes.get(img_hash, [])
# And store the list of paths back in the hashes dictionary
paths.append(img_path)
hashes[img_hash] = paths
# Second part, loop through the hashes and find duplicates
print("Finding duplicates...")
for (img_hash, hashed_paths) in hashes.items():
# Is there more than one image at this place in the dictionary, these have the same hash
if len(hashed_paths) > 1:
# Display the duplicates
if args["show"]:
montage = None
for path in hashed_paths:
image = cv2.imread(path)
image = cv2.resize(image, (150, 150))
if montage is None:
montage = image
def train_PG(logdir, path, sim_mode=False):
start = time.time()
# Initialize the ROS/Sim Environment
env = ros_env.Env(path, train_mode=True, sim_mode=sim_mode)
# initialize the ROS agent
agent = Agent(path, sim_mode=sim_mode)
# Set Up Logger
setup_logger(logdir, locals())
# Set random seeds
tf.set_random_seed(agent.seed)
np.random.seed(agent.seed)
# Maximum length for episodes
max_path_length = agent.max_path_length
# Observation and action sizes
ob_dim = agent.ob_dim
ac_dim = agent.ac_dim
"""
Placeholders for batch observations/actions/advantages in policy gradient
loss function.
See Agent.build_computation_graph for notation
sy_ob_no: placeholder for observations
sy_ac_na: placeholder for actions
sy_adv_n: placeholder for advantages
"""
sy_ob_no = tf.placeholder(shape=[None, agent.ob_dim],
name="ob",
dtype=tf.float32)
sy_ac_na = tf.placeholder(shape=[None, agent.ac_dim],
name="ac",
dtype=tf.float32)
sy_adv_n = tf.placeholder(shape=[None], name="adv", dtype=tf.float32)
"""
The policy takes in an observation and produces a distribution
over the action space
Constructs the symbolic operation for the policy network outputs,
which are the parameters of the policy distribution p(a|s)
"""
# output activations are left linear by not passing any arg
sy_mean = build_mlp(sy_ob_no,
agent.ac_dim,
"policy-ddpg",
agent.n_layers,
agent.size,
activation=tf.tanh)
#print sy_mean.name
sy_logstd = tf.Variable(tf.zeros([1, agent.ac_dim]),
dtype=tf.float32,
name="logstd")
"""
Constructs a symbolic operation for stochastically sampling from
the policy distribution
use the reparameterization trick:
The output from a Gaussian distribution with mean 'mu' and std
'sigma' is
mu + sigma * z, z ~ N(0, I)
This reduces the problem to just sampling z.
(use tf.random_normal!)
"""
sy_sampled_ac = sy_mean + tf.exp(sy_logstd) * tf.random_normal(
tf.shape(sy_mean))
"""
We can also compute the logprob of the actions that were
actually taken by the policy. This is used in the loss function.
Constructs a symbolic operation for computing the log probability
of a set of actions that were actually taken according to the policy
use the log probability under a multivariate gaussian.
"""
action_normalized = (sy_ac_na - sy_mean) / tf.exp(sy_logstd)
sy_logprob_n = -0.5 * tf.reduce_sum(tf.square(action_normalized), axis=1)
#=================================================================#
# Loss Function and Training Operation
#=================================================================#
loss = -tf.reduce_mean(tf.multiply(sy_logprob_n, sy_adv_n))
update_op = tf.train.AdamOptimizer(agent.learning_rate).minimize(loss)
#==============================================================#
# Optional Baseline
#
# Define placeholders for targets, a loss function and an update op
# for fitting a neural network baseline. These will be used to fit the
# neural network baseline.
#===============================================================#
if agent.nn_baseline:
baseline_prediction = tf.squeeze(
build_mlp(sy_ob_no,
1,
"nn_baseline",
n_layers=agent.n_layers,
size=agent.size))
sy_target_n = tf.placeholder(shape=[None],
name="sy_target_n",
dtype=tf.float32)
baseline_loss = tf.nn.l2_loss(baseline_prediction - sy_target_n)
baseline_update_op = tf.train.AdamOptimizer(
agent.learning_rate).minimize(baseline_loss)
# tensorflow: config, session, variable initialization
tf_config = tf.ConfigProto(inter_op_parallelism_threads=1,
intra_op_parallelism_threads=1)
sess = tf.Session(config=tf_config)
sess.__enter__() # equivalent to `with sess:`
tf.global_variables_initializer().run() #pylint: disable=E1101
# Add ops to save and restore all the variables.
saver = tf.train.Saver()
#====================================================================#
# Training Loop
#====================================================================#
total_timesteps = 0
for itr in range(agent.n_iter):
print("********** Iteration %i ************" % itr)
itr_mesg = "Iteration started at "
itr_mesg += time.strftime("%d-%m-%Y_%H-%M-%S")
print(itr_mesg)
# Collect paths until we have enough timesteps
timesteps_this_batch = 0
paths = []
while True:
ob = env.reset()
obs, acs, rewards = [], [], []
steps = 0
while True:
#time.sleep(0.05)
obs.append(ob)
ac = sess.run(sy_sampled_ac, feed_dict={sy_ob_no: ob[None]})
#print sy_sampled_ac.name (add:0)
#print sy_ob_no.name (ob:0)
ac = ac[0]
acs.append(ac)
# returns obs, reward and done status
ob, rew, done = env.step(ac)
rewards.append(rew)
steps += 1
if done or steps > agent.max_path_length:
break
path = {
"observation": np.array(obs, dtype=np.float32),
"reward": np.array(rewards, dtype=np.float32),
"action": np.array(acs, dtype=np.float32)
}
paths.append(path)
timesteps_this_batch += pathlength(path)
if timesteps_this_batch > agent.min_timesteps_per_batch:
break
total_timesteps += timesteps_this_batch
'''
# Build arrays for observation and action for the
# policy gradient update by concatenating across paths
'''
ob_no = np.concatenate([path["observation"] for path in paths])
ac_na = np.concatenate([path["action"] for path in paths])
re_n = [path["reward"] for path in paths]
"""
Monte Carlo estimation of the Q function.
Estimates the returns over a set of trajectories.
Store the Q-values for all timesteps and all trajectories in a
variable 'q_n', like the 'ob_no' and 'ac_na' above.
"""
if agent.reward_to_go:
q_n = []
for path in paths:
q = np.zeros(pathlength(path))
q[-1] = path['reward'][-1]
for i in reversed(range(pathlength(path) - 1)):
q[i] = path['reward'][i] + agent.gamma * q[i + 1]
q_n.extend(q)
else:
q_n = []
for path in paths:
ret_tau = 0
for i in range(pathlength(path)):
ret_tau += (agent.gamma**i) * path['reward'][i]
q = np.ones(shape=[pathlength(path)]) * ret_tau
q_n.extend(q)
"""
Compute advantages by (possibly) subtracting a baseline from the
estimated Q values let sum_of_path_lengths be the sum of the
lengths of the paths sampled.
"""
#===========================================================#
#
# Computing Baselines
#===========================================================#
if agent.nn_baseline:
# If nn_baseline is True, use your neural network to predict
# reward-to-go at each timestep for each trajectory, and save the
# result in a variable 'b_n' like 'ob_no', 'ac_na', and 'q_n'.
#
# rescale the output from the nn_baseline to match the
# statistics (mean and std) of the current batch of Q-values.
b_n = sess.run(baseline_prediction, feed_dict={sy_ob_no: ob_no})
m1 = np.mean(b_n)
s1 = np.std(b_n)
m2 = np.mean(q_n)
s2 = np.std(q_n)
b_n = b_n - m1
b_n = m2 + b_n * (s2 / (s1 + 1e-8))
adv_n = q_n - b_n
else:
adv_n = q_n.copy()
#=========================================================#
# Advantage Normalization
#=========================================================#
if agent.normalize_advantages:
# On the next line, implement a trick which is known
# empirically to reduce variance
# in policy gradient methods: normalize adv_n to have mean
# zero and std=1.
adv_n = preprocessing.scale(adv_n)
"""
Update the parameters of the policy and (possibly) the neural
network baseline, which is trained to approximate the value function
"""
#========================================================#
# Optimizing Neural Network Baseline
#========================================================#
if agent.nn_baseline:
# If a neural network baseline is used, set up the targets and
# the inputs for the baseline.
#
# Fit it to the current batch in order to use for the next
# iteration. Use the baseline_update_op you defined earlier.
#
# Instead of trying to target raw Q-values directly,
# rescale the targets to have mean zero and std=1.
target_n = preprocessing.scale(q_n)
sess.run(baseline_update_op,
feed_dict={
sy_target_n: target_n,
sy_ob_no: ob_no
})
#=================================================================#
# Performing the Policy Update
#=================================================================#
# Call the update operation necessary to perform the policy
# gradient update based on the current batch of rollouts.
_, after_loss = sess.run([update_op, loss],
feed_dict={
sy_ob_no: ob_no,
sy_ac_na: ac_na,
sy_adv_n: adv_n
})
# Log diagnostics
returns = [path["reward"].sum() for path in paths]
ep_lengths = [pathlength(path) for path in paths]
logz.log_tabular("Time", time.time() - start)
logz.log_tabular("Iteration", itr)
logz.log_tabular("AverageReturn", np.mean(returns))
logz.log_tabular("StdReturn", np.std(returns))
logz.log_tabular("MaxReturn", np.max(returns))
logz.log_tabular("MinReturn", np.min(returns))
logz.log_tabular("EpLenMean", np.mean(ep_lengths))
logz.log_tabular("EpLenStd", np.std(ep_lengths))
logz.log_tabular("TimestepsThisBatch", timesteps_this_batch)
logz.log_tabular("TimestepsSoFar", total_timesteps)
logz.log_tabular("After-Loss", after_loss)
logz.dump_tabular()
logz.pickle_tf_vars()
model_file = os.path.join(logdir, "model.ckpt")
save_path = saver.save(sess, model_file)
print("Model saved in file: %s" % save_path)
env.close_env_log()
if __name__ == "__main__":
parser = ArgumentParser(description='Tool for performing homographies')
parser.add_argument('--input', required=True,
help='Input path for a catalog')
parser.add_argument('--outputDir', required=True,
help='Path for the output, will be wiped clean before any operation')
args = vars(parser.parse_args())
if not os.path.exists(args["outputDir"]):
os.makedirs(args["outputDir"])
cap = cv2.VideoCapture(args["input"])
paths = glob.glob(os.path.join(args["input"],"*.jpg"))
paths.append(glob.glob(os.path.join(args["input"],"*.png")))
paths.append(glob.glob(os.path.join(args["input"],"*.jpeg")))
paths.sort()
liste = []
for path in paths:
image = cv2.imread(path)
liste.append(variance_of_laplacian(image))
for i in range(10):
index = np.argmin(liste)
bestImage = cv2.imread(paths[i])
cv2.imwrite(os.path.join(args["output"],paths[i].split("/")[-1]))
del liste[i]