def create_from_pkl_img(tfrecord_dir, image_dir, pickle_dir, shuffle):
print('Loading images from "%s"' % image_dir)
image_filenames = sorted(glob.glob(os.path.join(image_dir, '*')))
pickle_filenames = sorted(glob.glob(os.path.join(pickle_dir, '*')))
if len(image_filenames) == 0:
error('No input images found')
# good_ids = mio.import_pickle('/vol/construct3dmm/visualizations/nicp/mein3d/good_ids.pkl')
img = mio.import_pickle(pickle_filenames[0])
resolution = img.shape[2]
channels = img.shape[0] if img.ndim == 3 else 1
if img.shape[1] != resolution:
error('Input images must have the same width and height')
if resolution != 2**int(np.floor(np.log2(resolution))):
error('Input image resolution must be a power-of-two')
if channels not in [1, 3]:
error('Input images must be stored as RGB or grayscale')
with TFRecordExporter(tfrecord_dir, len(image_filenames)) as tfr:
order = tfr.choose_shuffled_order() if shuffle else np.arange(
len(image_filenames))
for idx in range(order.size):
img = mio.import_image(image_filenames[order[idx]]).pixels.astype(
np.float32) * 2 - 1
pkl = mio.import_pickle(pickle_filenames[order[idx]]).astype(
np.float32)
# pkl[0, :, :] = scipy.ndimage.gaussian_filter(pkl[0, :, :], 2)
# pkl[1, :, :] = scipy.ndimage.gaussian_filter(pkl[1, :, :], 2)
# pkl[2, :, :] = scipy.ndimage.gaussian_filter(pkl[2, :, :], 2)
# img_resized = np.stack((cv2.resize(img[0],dsize=(256,256)),cv2.resize(img[1],dsize=(256,256)),cv2.resize(img[2],dsize=(256,256))))
tfr.add_both(np.concatenate([img, pkl]))
def test_importing_pickle_encoding_ignored_py2(version_info, is_file,
mock_open, mock_pickle):
version_info.major = 2
mock_pickle.return_value = {'test': 1}
is_file.return_value = True
mio.import_pickle('mocked.pkl', encoding='latin1')
assert 'encoding' not in mock_pickle.call_args[1]
def test_importing_pickle_encoding_py3(version_info, is_file, mock_open,
mock_pickle):
version_info.major = 3
mock_pickle.return_value = {"test": 1}
is_file.return_value = True
mio.import_pickle("mocked.pkl", encoding="latin1")
assert mock_pickle.call_args[1].get("encoding") == "latin1"
def test_importing_pickle_encoding_py3(version_info, is_file, mock_open,
mock_pickle):
version_info.major = 3
mock_pickle.return_value = {'test': 1}
is_file.return_value = True
mio.import_pickle('mocked.pkl', encoding='latin1')
assert mock_pickle.call_args[1].get('encoding') == 'latin1'
def test_importing_pickle_encoding_ignored_py2(version_info, is_file,
mock_open, mock_pickle):
version_info.major = 2
mock_pickle.return_value = {"test": 1}
is_file.return_value = True
mio.import_pickle("mocked.pkl", encoding="latin1")
assert "encoding" not in mock_pickle.call_args[1]
def test_importing_pickle_encoding_ignored_py2(version_info, is_file, mock_open,
mock_pickle):
version_info.major = 2
mock_pickle.return_value = {'test': 1}
is_file.return_value = True
mio.import_pickle('mocked.pkl', encoding='latin1')
assert 'encoding' not in mock_pickle.call_args[1]
def test_importing_pickle_encoding_py3(version_info, is_file, mock_open,
mock_pickle):
version_info.major = 3
mock_pickle.return_value = {'test': 1}
is_file.return_value = True
mio.import_pickle('mocked.pkl', encoding='latin1')
assert mock_pickle.call_args[1].get('encoding') == 'latin1'
def load_fw_expression_fwc():
expression_model = mio.import_pickle('./identity_texture_emotion.pkl')['expression']
expression_model._components /= 100000
expression_model._mean /= 100000
tr = mio.import_pickle('/vol/atlas/databases/lsfm/corrective_translation.pkl')
expression_model._components = tr.apply(expression_model._components.reshape(29, -1, 3)).reshape(29, -1)
expression_model._mean = tr.apply(expression_model._mean.reshape(-1, 3)).reshape(-1)
expression_model.n_active_components = 5
return expression_model
def __init__(self, batch_size=32):
self.name = 'JamesRenders'
self.batch_size = batch_size
self.root = Path('/data/datasets/renders/v1')
self.tfrecord_names = ['train_v2.tfrecords']
self.model = mio.import_pickle(
'/vol/construct3dmm/experiments/models/nicp/mein3d/full_unmasked_good_200.pkl')[
'model']
self.settings = mio.import_pickle(
'/vol/construct3dmm/experiments/nicptexture/settings.pkl',
encoding='latin1')
def load_fitter(name):
r"""
Load a fitter with identifier ``name``, pulling it from a remote URL if
needed.
Parameters
----------
name : `str`
The identifier of the fitter, e.g. `balanced_frontal_face_aam`
Returns
-------
fitter : `Fitter`
A pre-trained menpofit `Fitter` that is ready to use.
"""
path = path_of_fitter(name)
if not path.exists():
print('Downloading {} fitter'.format(name))
url = url_of_fitter(name)
print(url, path)
download_file(url, path, verbose=True)
# Load the pickle and immediately invoke it.
try:
return import_pickle(path)()
except Exception as e:
# Hmm something went wrong, and we couldn't load this fitter.
# Purge it so next time we will redownload.
print('Error loading fitter - purging damaged file: {}'.format(path))
print('Please try running again')
path.unlink()
raise e
def load_fitter(name):
r"""
Load a fitter with identifier ``name``, pulling it from a remote URL if
needed.
Parameters
----------
name : `str`
The identifier of the fitter, e.g. `balanced_frontal_face_aam`
Returns
-------
fitter : `Fitter`
A pre-trained menpofit `Fitter` that is ready to use.
"""
path = path_of_fitter(name)
if not path.exists():
print('Downloading {} fitter'.format(name))
url = url_of_fitter(name)
print(url, path)
download_file(url, path, verbose=True)
# Load the pickle and immediately invoke it.
try:
return import_pickle(path)()
except Exception as e:
# Hmm something went wrong, and we couldn't load this fitter.
# Purge it so next time we will redownload.
print('Error loading fitter - purging damaged file: {}'.format(path))
print('Please try running again')
path.unlink()
raise e
def create_from_images(tfrecord_dir, image_dir, shuffle):
print('Loading images from "%s"' % image_dir)
image_filenames = sorted(glob.glob(os.path.join(image_dir, '*')))
if len(image_filenames) == 0:
error('No input images found')
good_ids = mio.import_pickle(
'/vol/construct3dmm/visualizations/nicp/mein3d/good_ids.pkl')
img = np.asarray(PIL.Image.open(image_filenames[0]))
resolution = img.shape[0]
channels = img.shape[2] if img.ndim == 3 else 1
# if img.shape[1] != resolution:
# error('Input images must have the same width and height')
# if resolution != 2 ** int(np.floor(np.log2(resolution))):
# error('Input image resolution must be a power-of-two')
if channels not in [1, 3]:
error('Input images must be stored as RGB or grayscale')
with TFRecordExporter(tfrecord_dir, len(image_filenames)) as tfr:
order = tfr.choose_shuffled_order() if shuffle else np.arange(
len(image_filenames))
for idx in range(order.size):
img = PIL.Image.open(image_filenames[order[idx]])
# img.crop((41, 0, img.size[0]-42, resolution))
# new_im = PIL.Image.new("RGB", (512, 512),(0, 0, 0))
# new_im.paste(img, ((512 - img.size[0]) // 2,(512 - img.size[1]) // 2))
img = np.asarray(img)
if channels == 1:
img = img[np.newaxis, :, :] # HW => CHW
else:
img = img.transpose(2, 0, 1) # HWC => CHW
tfr.add_image(img)
def data_fn_h5py():
with h5py.File(dataset_path) as df:
if is_training:
all_cmesh = df['colour_mesh'][:8000]
else:
all_cmesh = df['colour_mesh'][8000:]
L, D, U, A = mio.import_pickle(
'/vol/phoebe/yz4009/databases/mesh/meta/mein3dcrop_LDUA.pkl',
encoding='latin1')
all_cmesh = D[0].dot(
all_cmesh.transpose([1, 0, 2]).reshape([
D[0].shape[1], -1
])).reshape([D[0].shape[0], -1,
config.inputs_channels]).transpose([1, 0, 2])
all_cmesh = all_cmesh.astype(np.float32)
input_fn = tf.estimator.inputs.numpy_input_fn(
x={
"cmesh": all_cmesh,
},
y={"mask": np.ones_like(all_cmesh)[..., :1]},
shuffle=True,
batch_size=BATCH_SIZE,
num_epochs=num_epochs,
num_threads=config.no_thread)
return input_fn
def wrapper(index):
path = self.root / (index + '.pkl')
p = mio.import_pickle(path)
px = p['img'].resize(shape).pixels_with_channels_at_back()
return px.astype(np.float32), p['weights'].astype(np.float32)
def evaluate(dataset_path):
"""Evaluate model on Dataset for a number of steps."""
with tf.Graph().as_default(), tf.device('/cpu:0'):
train_dir = Path(FLAGS.checkpoint_dir)
reference_shape = mio.import_pickle(train_dir / 'reference_shape.pkl')
images, gt_truth, inits, _ = data_provider.batch_inputs(
[dataset_path], reference_shape,
batch_size=FLAGS.batch_size, is_training=False)
mirrored_images, _, mirrored_inits, shapes = data_provider.batch_inputs(
[dataset_path], reference_shape,
batch_size=FLAGS.batch_size, is_training=False, mirror_image=True)
print('Loading model...')
# Build a Graph that computes the logits predictions from the
# inference model.
with tf.device(FLAGS.device):
patch_shape = (FLAGS.patch_size, FLAGS.patch_size)
pred, _, _ = mdm_model.model(images, inits, patch_shape=patch_shape)
tf.get_variable_scope().reuse_variables()
pred_mirrored, _, _ = mdm_model.model(
mirrored_images, mirrored_inits, patch_shape=patch_shape)
pred_images, = tf.py_func(utils.batch_draw_landmarks,
[images, pred], [tf.float32])
gt_images, = tf.py_func(utils.batch_draw_landmarks,
[images, gt_truth], [tf.float32])
summaries = []
summaries.append(tf.image_summary('images',
tf.concat(2, [gt_images, pred_images]), max_images=5))
avg_pred = pred + tf.py_func(flip_predictions, (pred_mirrored, shapes), (tf.float32, ))[0]
avg_pred /= 2.
# Calculate predictions.
norm_error = mdm_model.normalized_rmse(avg_pred, gt_truth)
# Restore the moving average version of the learned variables for eval.
variable_averages = tf.train.ExponentialMovingAverage(
mdm_train.MOVING_AVERAGE_DECAY)
variables_to_restore = variable_averages.variables_to_restore()
saver = tf.train.Saver(variables_to_restore)
# Build the summary operation based on the TF collection of Summaries.
summary_op = tf.merge_summary(summaries)
graph_def = tf.get_default_graph().as_graph_def()
summary_writer = tf.train.SummaryWriter(FLAGS.eval_dir,
graph_def=graph_def)
while True:
_eval_once(saver, summary_writer, norm_error, summary_op)
if FLAGS.run_once:
break
time.sleep(FLAGS.eval_interval_secs)
def wrapper(index):
index = index.decode("utf-8")
heatmap = mio.import_pickle(
self.root / '{}+hm.pkl'.format(index))
heatmap = heatmap.pixels_with_channels_at_back()
return heatmap.astype(np.float32)
def test_importing_pickle(is_file, mock_open, mock_pickle):
mock_pickle.return_value = {'test': 1}
is_file.return_value = True
objs = mio.import_pickle('mocked.pkl')
assert isinstance(objs, dict)
assert 'test' in objs
assert objs['test'] == 1
def test_importing_pickle(is_file, mock_open, mock_pickle):
mock_pickle.return_value = {'test': 1}
is_file.return_value = True
objs = mio.import_pickle('mocked.pkl')
assert isinstance(objs, dict)
assert 'test' in objs
assert objs['test'] == 1
def test_importing_pickle(is_file, mock_open, mock_pickle):
mock_pickle.return_value = {"test": 1}
is_file.return_value = True
objs = mio.import_pickle("mocked.pkl")
assert isinstance(objs, dict)
assert "test" in objs
assert objs["test"] == 1
def wrapper(index):
index = index.decode("utf-8")
result = []
for i in [0, 1, 2, 4]:
svs = mio.import_pickle(
self.root / '{}+svs_dark+{:02d}.pkl'.format(index, i))
svs = svs.pixels_with_channels_at_back()
result.append(svs)
return np.array(result).astype(np.float32)
def validate(self, valid_img_path):
assert (os.path.exists(
self.template_filename)), 'template.pts not exists!'
valid_imgs = self.load_database(valid_img_path)
valid_imgs = self.equalize_hist(valid_imgs)
if self.fitter is None and not os.path.exists(self.model_filename):
ValueError(
'neither model file nor fitter exists, please train first')
if self.fitter is None:
self.fitter = mio.import_pickle(self.model_filename)
self._validate_without_gt(valid_imgs, self.fitter)
def test_register_pickle_importer(is_file):
obj = object()
def foo_importer(filepath, **kwargs):
return obj
is_file.return_value = True
with patch.dict(mio.input.extensions.pickle_types, {}, clear=True):
mio.register_pickle_importer('.foo', foo_importer)
new_obj = mio.import_pickle('fake.foo')
assert new_obj is obj
def _load_landmark_fitter(self):
if self._fitter_type == 'aam':
self._aam_fitter = mio.import_pickle(self._aam_fitter_file)
fitter = LucasKanadeAAMFitter(self._aam_fitter, lk_algorithm_cls=WibergInverseCompositional,
n_shape=self._shape_components, n_appearance=self._appearance_components)
elif self._fitter_type == 'ert':
fitter = DlibWrapper(
path.join(current_path, '../pretrained/shape_predictor_68_face_landmarks.dat'))
else:
raise Exception('unknown fitter, did you mean aam/ert?')
self._landmark_fitter = fitter
def test_register_pickle_importer(is_file):
obj = object()
def foo_importer(filepath, **kwargs):
return obj
is_file.return_value = True
with patch.dict(mio.input.extensions.pickle_types, {}, clear=True):
mio.register_pickle_importer('.foo', foo_importer)
new_obj = mio.import_pickle('fake.foo')
assert new_obj is obj
def evaluate(dataset_path):
"""Evaluate model on Dataset for a number of steps."""
with tf.Graph().as_default(), tf.device('/cpu:0'):
# Get images and labels from the dataset.
#reference_shape = mio.import_pickle(
# FLAGS.checkpoint_dir + '/reference_shape.pkl')
reference_shape = mio.import_pickle('reference_shape.pkl')
print(reference_shape.shape)
images, gt_truth, inits = data_provider.batch_inputs(
[dataset_path],
reference_shape,
batch_size=FLAGS.batch_size,
is_training=False)
print('Loading model...')
# Build a Graph that computes the logits predictions from the
# inference model.
with tf.device(FLAGS.device):
pred, _, _ = mdm_model.model(images, inits)
pred_images, = tf.py_func(utils.batch_draw_landmarks, [images, pred],
[tf.float32])
gt_images, = tf.py_func(utils.batch_draw_landmarks, [images, gt_truth],
[tf.float32])
summaries = []
summaries.append(
tf.image_summary('images',
tf.concat(2, [gt_images, pred_images]),
max_images=5))
# Calculate predictions.
norm_error = mdm_model.normalized_rmse(pred, gt_truth)
# Restore the moving average version of the learned variables for eval.
variable_averages = tf.train.ExponentialMovingAverage(
mdm_train.MOVING_AVERAGE_DECAY)
variables_to_restore = variable_averages.variables_to_restore()
saver = tf.train.Saver(variables_to_restore)
# Build the summary operation based on the TF collection of Summaries.
summary_op = tf.merge_summary(summaries)
graph_def = tf.get_default_graph().as_graph_def()
summary_writer = tf.train.SummaryWriter(FLAGS.eval_dir,
graph_def=graph_def)
while True:
_eval_once(saver, summary_writer, norm_error, summary_op)
if FLAGS.run_once:
break
time.sleep(FLAGS.eval_interval_secs)
def _load_landmark_fitter(self):
if self._fitter_type == 'aam':
self._aam_fitter = mio.import_pickle(self._aam_fitter_file)
fitter = LucasKanadeAAMFitter(
self._aam_fitter,
lk_algorithm_cls=WibergInverseCompositional,
n_shape=self._shape_components,
n_appearance=self._appearance_components)
elif self._fitter_type == 'ert':
_, _, fitter68 = maybe_download_models()
fitter = DlibWrapper(fitter68)
else:
raise Exception('unknown fitter, did you mean aam/ert?')
self._landmark_fitter = fitter
def ckpt_pb(pb_path):
tf.reset_default_graph()
config = tf.ConfigProto(allow_soft_placement=True)
config.gpu_options.allow_growth = True
with tf.Session() as sess:
path_base = Path(g_config['eval_dataset']).parent.parent
_mean_shape = mio.import_pickle(path_base / 'reference_shape.pkl')
_mean_shape = data_provider.align_reference_shape_to_112(_mean_shape)
assert isinstance(_mean_shape, np.ndarray)
print(_mean_shape.shape)
tf_img = tf.placeholder(dtype=tf.float32,
shape=(1, 112, 112, 3),
name='inputs/input_img')
tf_dummy = tf.placeholder(dtype=tf.float32,
shape=(1, 73, 2),
name='inputs/input_shape')
tf_shape = tf.constant(_mean_shape,
dtype=tf.float32,
shape=(73, 2),
name='MeanShape')
model = mdm_model.MDMModel(tf_img,
tf_dummy,
tf_shape,
batch_size=1,
num_patches=g_config['num_patches'],
num_channels=3,
is_training=False)
saver = tf.train.Saver()
ckpt = tf.train.get_checkpoint_state(g_config['train_dir'])
if ckpt and ckpt.model_checkpoint_path:
saver.restore(sess, ckpt.model_checkpoint_path)
global_step = ckpt.model_checkpoint_path.split('/')[-1].split(
'-')[-1]
print('Successfully loaded model from {} at step={}.'.format(
ckpt.model_checkpoint_path, global_step))
else:
print('No checkpoint file found')
return
output_graph_def = tf.graph_util.convert_variables_to_constants(
sess,
tf.get_default_graph().as_graph_def(), ['Network/Predict/add'])
with tf.gfile.FastGFile(pb_path, mode='wb') as f:
f.write(output_graph_def.SerializeToString())
def __init__(self,
batch_size=64,
db_name='WPUTEDB-train',
shape=(250, 190),
num_classes=500,
root='/homes/yz4009/wd/PickleModel/EarRecognition/',
is_training=True):
self.name = db_name
self.batch_size = batch_size
self.root = Path(root)
self.dataset = mio.import_pickle(str(self.root /
'{}.pkl'.format(db_name)),
encoding='latin1')
self.num_classes = num_classes
self.shape = shape
self.is_training = is_training
def __init__(self, batch_size=1):
super().__init__(batch_size)
from menpo.transform import Translation, scale_about_centre
import menpo3d.io as m3dio
self.name = 'FDDB'
self.root = Path('/vol/atlas/databases/fddb_ibug')
template = m3dio.import_mesh(
'/vol/construct3dmm/regression/src/template.obj')
template = Translation(-template.centre()).apply(template)
self.template = scale_about_centre(template, 1. /
1000.).apply(template)
pca_path = '/homes/gt108/Projects/ibugface/pose_settings/pca_params.pkl'
self.eigenvectors, self.eigenvalues, self.h_mean, self.h_max = mio.import_pickle(
pca_path)
self.image_extension = '.jpg'
self.lms_extension = '.ljson'
def __init__(self, *args, **kwargs):
# hyperparameters
self.BATCH_SIZE = FLAGS.batch_size
self.LR = FLAGS.lr
self.opt = FLAGS.opt
self.NK = FLAGS.k_poly
self.use_colour = FLAGS.colour
self.inputs_channels = 6 if FLAGS.colour else 3
self.lr_decay = FLAGS.lr_decay
self.warm_start_from = FLAGS.warm_start_from
self.EMBEDING = FLAGS.embedding
self.LOGDIR = self.format_folder(FLAGS)
self.NUM_GPUS = len(FLAGS.gpu.split(','))
self.TOTAL_EPOCH = FLAGS.n_epoch
self.no_thread = FLAGS.no_thread
self.dataset_path = FLAGS.dataset_path
self.test_path = FLAGS.test_path
self.train_format = 'tf' if FLAGS.dataset_path.endswith(
'.tfrecord') else 'h5py'
self.test_format = 'tf' if FLAGS.test_path.endswith(
'.tfrecord') else 'h5py'
# constant
self.INPUT_SHAPE = 112
self.FILTERS = [16, 16, 16, 32]
self.DB_SIZE = 8000
self.EPOCH_STEPS = self.DB_SIZE // (self.BATCH_SIZE *
self.NUM_GPUS)
# graph constant
self.luda_file = 'mein3dcrop_7k_LDUA.pkl'
# self.luda_file = 'lsfm_LDUA.pkl'
self.symetric_index = np.load(FLAGS.meta_path +
'/symetric_index_full.npy').astype(
np.int32)
self.shape_model = mio.import_pickle(FLAGS.meta_path +
'/mein3dcrop_7k_mesh.pkl',
encoding='latin1')
self.trilist = self.shape_model.trilist
self.graph_laplacians, self.downsampling_matrices, self.upsamling_matrices, self.adj_matrices = mio.import_pickle(
FLAGS.meta_path + '/' + self.luda_file, encoding='latin1')
self.N_VERTICES = self.graph_laplacians[0].shape[0]
def process_data(dir):
dirlist = os.listdir(dir)
dirlist = [d for d in dirlist if not os.path.isfile(os.path.join(dir, d))]
dirlist = sorted(dirlist)
# load the aam model
aam = mio.import_pickle("aam.pkl")
# create fiiter
fitter = LucasKanadeAAMFitter(aam,
lk_algorithm_cls=WibergInverseCompositional,
n_shape=16,
n_appearance=104)
# Load detector
detector = load_dlib_frontal_face_detector()
#load the sentences
for j, subdir in enumerate(dirlist):
ids = os.listdir(os.path.join(dir, subdir, "video/"))
ids = [i for i in ids if "head" not in i]
ids = sorted(ids)
for k, id in enumerate(ids):
t = time.time()
video = os.path.join(dir, subdir, "video", id + '/')
process_one_sentence(video, fitter, detector)
print(j, k, time.time() - t)
import numpy as np
from pysofia import sofia_ml
import menpo.io as mio
n_samples, n_features = 500, 2000
# X = np.random.randn(n_samples, n_features)
# w = np.random.randn(n_features)
# y = (X.dot(w) + np.random.randn(n_samples)).astype(np.int)
#
# mio.export_pickle([X, y], 'tmp.pkl', overwrite=False)
data = mio.import_pickle('tmp.pkl')
X = data[0]
y = data[1]
coef = sofia_ml.sgd_train(X, y, None, 0.01, n_features=n_features)
coef2 = sofia_ml.sgd_train(X, y, None, 0.01, n_features=n_features)
# prediction = sofia_ml.svm_predict(X, coef, sofia_ml.predict_type.logistic)
print "done"
def build_data():
# ### load models
shape_model = mio.import_pickle('/homes/yz4009/wd/notebooks/Projects/MLProjects/models/all_all_all.pkl')
uv_shape = (INPUT_SHAPE, INPUT_SHAPE)
template = shape_model.instance([])
UV_template = optimal_cylindrical_unwrap(template).apply(template)
UV_template.points = UV_template.points[:, [1, 0]]
UV_template.points[:, 0] = UV_template.points[:, 0].max() - UV_template.points[:, 0]
UV_template.points -= UV_template.points.min(axis=0)
UV_template.points /= UV_template.points.max(axis=0)
UV_template.points *= np.array([uv_shape])
# ### Generate IUV
def rotation_matrix(angle, direction, point=None):
sina = math.sin(angle)
cosa = math.cos(angle)
direction = np.array(direction).astype(np.float64)
# rotation matrix around unit vector
R = np.diag([cosa, cosa, cosa])
R += np.outer(direction, direction) * (1.0 - cosa)
direction *= sina
R += np.array([[ 0.0, -direction[2], direction[1]],
[ direction[2], 0.0, -direction[0]],
[-direction[1], direction[0], 0.0]])
M = np.identity(4)
M[:3, :3] = R
if point is not None:
# rotation not around origin
point = np.array(point[:3], dtype=np.float64, copy=False)
M[:3, 3] = point - np.dot(R, point)
return M
def random_sample_UV(n_pcs = 50, random_angle = 45, shape = [INPUT_SHAPE, INPUT_SHAPE]):
# random mesh
sample_mesh = shape_model.instance(np.random.sample([n_pcs]) * 3, normalized_weights=True)
sample_mesh = ColouredTriMesh(sample_mesh.points, trilist=sample_mesh.trilist)
sample_mesh = lambertian_shading(sample_mesh)
sample_mesh = Homogeneous(rotation_matrix(np.deg2rad(90), [0,0,1])).apply(sample_mesh)
sample_mesh = Homogeneous(rotation_matrix(np.deg2rad(180), [1,0,0])).apply(sample_mesh)
sample_mesh = Scale([100,100,100]).apply(sample_mesh)
# random rotation and scale and translation
sample_mesh = Homogeneous(rotation_matrix(np.deg2rad(np.random.rand() * random_angle - random_angle / 2), [0,0,1])).apply(sample_mesh)
sample_mesh = Homogeneous(rotation_matrix(np.deg2rad(np.random.rand() * random_angle - random_angle / 2), [0,1,0])).apply(sample_mesh)
sample_mesh = Homogeneous(rotation_matrix(np.deg2rad(np.random.rand() * random_angle - random_angle / 2), [1,0,0])).apply(sample_mesh)
sample_mesh = Scale(np.tile(np.random.sample([1]), [3]) * 1. + 0.5).apply(sample_mesh)
# translate to image centre
sample_mesh = Translation([shape[0] / 2,shape[1] / 2,0]).apply(sample_mesh)
# random perturbation
sample_mesh = Translation(np.random.sample([3]) * 128 - 64).apply(sample_mesh)
u_mesh = ColouredTriMesh(
sample_mesh.points,
trilist=sample_mesh.trilist,
colours=UV_template.points[:,0,None])
u_image = rasterize_mesh(u_mesh, shape)
v_mesh = ColouredTriMesh(
sample_mesh.points,
trilist=sample_mesh.trilist,
colours=UV_template.points[:,1,None])
v_image = rasterize_mesh(v_mesh, shape)
IUV_image = Image(np.concatenate([u_image.mask.pixels,u_image.pixels / 255., v_image.pixels / 255.]).clip(0,1))
return IUV_image
def one_hot(a):
a = a.astype(np.int32)
n_parts = np.max(a) + 1
b = np.zeros((len(a), n_parts))
b[np.arange(len(a)), a] = 1
return b
def rgb_iuv(rgb):
# formation
iuv_mask = rgb[..., 0]
n_parts = int(np.max(iuv_mask) + 1)
iuv_one_hot = one_hot(iuv_mask.flatten()).reshape(iuv_mask.shape + (n_parts,))
# normalised uv
uv = rgb[..., 1:] / 255. if np.max(rgb[..., 1:]) > 1 else rgb[..., 1:]
u = iuv_one_hot * uv[..., 0][..., None]
v = iuv_one_hot * uv[..., 1][..., None]
iuv = np.concatenate([iuv_one_hot, u, v], 2)
return iuv
class FaceIUVSequence(dm.utils.Sequence):
def __init__(self, batch_size=16, is_validation=False, validation_size=BATCH_SIZE):
self.batch_size = validation_size if is_validation else batch_size
self.size = validation_size if is_validation else 10000 // BATCH_SIZE
super().__init__()
def __len__(self):
return self.size
def __getitem__(self, idx):
batch_img = [
rgb_iuv(random_sample_UV(shape = [256, 256]).pixels_with_channels_at_back()) for _ in range(self.batch_size)
]
batch_x = batch_y = batch_img = np.array(batch_img)
return [batch_x], [batch_y]
return FaceIUVSequence(batch_size=BATCH_SIZE)
def template_fw():
return mio.import_pickle('/vol/atlas/databases/itwmm/mein3d_fw_correspond_mean.pkl.gz')
def load_basel_shape():
shape_model = mio.import_pickle('/vol/atlas/databases/lsfm/shape_PCAModel.pkl', encoding='latin1')
landmarks = m3io.import_landmark_file(TEMPLATE_LMS_PATH)
return shape_model, landmarks
def train(scope=''):
"""Train on dataset for a number of steps."""
with tf.Graph().as_default() as graph, tf.device('/gpu:0'):
# Global steps
tf_global_step = tf.get_variable(
'GlobalStep', [],
initializer=tf.constant_initializer(0),
trainable=False)
# Learning rate
tf_lr = tf.train.exponential_decay(g_config['learning_rate'],
tf_global_step,
g_config['learning_rate_step'],
g_config['learning_rate_decay'],
staircase=True,
name='LearningRate')
tf.summary.scalar('learning_rate', tf_lr, collections=['train'])
# Create an optimizer that performs gradient descent.
opt = tf.train.AdamOptimizer(tf_lr)
data_provider.prepare_images(g_config['train_dataset'].split(':'),
num_patches=g_config['num_patches'],
verbose=True)
path_base = Path(g_config['train_dataset'].split(':')[0]).parent.parent
_mean_shape = mio.import_pickle(path_base / 'reference_shape.pkl')
_mean_shape = data_provider.align_reference_shape_to_112(_mean_shape)
assert (isinstance(_mean_shape, np.ndarray))
assert (_mean_shape.shape[0] == g_config['num_patches'])
tf_mean_shape = tf.constant(_mean_shape,
dtype=tf.float32,
name='MeanShape')
def get_random_sample(image, shape, rotation_stddev=10):
# Read a random image with landmarks and bb
image = menpo.image.Image(image.transpose((2, 0, 1)), copy=False)
image.landmarks['PTS'] = PointCloud(shape)
if np.random.rand() < .5:
image = utils.mirror_image(image)
if np.random.rand() < .5:
theta = np.random.normal(scale=rotation_stddev)
rot = menpo.transform.rotate_ccw_about_centre(
image.landmarks['PTS'], theta)
image = image.warp_to_shape(image.shape, rot)
bb = image.landmarks['PTS'].bounding_box().points
miny, minx = np.min(bb, 0)
maxy, maxx = np.max(bb, 0)
bbsize = max(maxx - minx, maxy - miny)
center = [(miny + maxy) / 2., (minx + maxx) / 2.]
shift = (np.random.rand(2) - 0.5) * 0.6 * bbsize
image.landmarks['bb'] = PointCloud([
[
center[0] - bbsize * 0.5 + shift[0],
center[1] - bbsize * 0.5 + shift[1]
],
[
center[0] + bbsize * 0.5 + shift[0],
center[1] + bbsize * 0.5 + shift[1]
],
]).bounding_box()
proportion = 1.0 / 6.0 + float(np.random.rand() - 0.5) / 6.
image = image.crop_to_landmarks_proportion(proportion, group='bb')
image = image.resize((112, 112))
random_image = image.pixels.transpose(1, 2, 0).astype('float32')
random_shape = image.landmarks['PTS'].points.astype('float32')
return random_image, random_shape
def decode_feature_and_augment(serialized):
feature = {
'train/image': tf.FixedLenFeature([], tf.string),
'train/shape': tf.VarLenFeature(tf.float32),
}
features = tf.parse_single_example(serialized, features=feature)
decoded_image = tf.decode_raw(features['train/image'], tf.float32)
decoded_image = tf.reshape(decoded_image, (448, 448, 3))
decoded_shape = tf.sparse.to_dense(features['train/shape'])
decoded_shape = tf.reshape(decoded_shape,
(g_config['num_patches'], 2))
random_image, random_shape = tf.py_func(
get_random_sample, [decoded_image, decoded_shape],
[tf.float32, tf.float32],
stateful=True,
name='RandomSample')
return data_provider.distort_color(random_image), random_shape
def decode_feature(serialized):
feature = {
'validate/image': tf.FixedLenFeature([], tf.string),
'validate/shape': tf.VarLenFeature(tf.float32),
}
features = tf.parse_single_example(serialized, features=feature)
decoded_image = tf.decode_raw(features['validate/image'],
tf.float32)
decoded_image = tf.reshape(decoded_image, (112, 112, 3))
decoded_shape = tf.sparse.to_dense(features['validate/shape'])
decoded_shape = tf.reshape(decoded_shape,
(g_config['num_patches'], 2))
return decoded_image, decoded_shape
with tf.name_scope('DataProvider'):
tf_dataset = tf.data.TFRecordDataset(
[str(path_base / 'train.bin')])
tf_dataset = tf_dataset.repeat()
tf_dataset = tf_dataset.map(decode_feature_and_augment,
num_parallel_calls=5)
tf_dataset = tf_dataset.batch(g_config['batch_size'], True)
tf_dataset = tf_dataset.prefetch(1)
tf_iterator = tf_dataset.make_one_shot_iterator()
tf_images, tf_shapes = tf_iterator.get_next(name='Batch')
tf_images.set_shape([g_config['batch_size'], 112, 112, 3])
tf_shapes.set_shape([g_config['batch_size'], 73, 2])
tf_dataset_v = tf.data.TFRecordDataset(
[str(path_base / 'validate.bin')])
tf_dataset_v = tf_dataset_v.repeat()
tf_dataset_v = tf_dataset_v.map(decode_feature,
num_parallel_calls=5)
tf_dataset_v = tf_dataset_v.batch(50, True)
tf_dataset_v = tf_dataset_v.prefetch(1)
tf_iterator_v = tf_dataset_v.make_one_shot_iterator()
tf_images_v, tf_shapes_v = tf_iterator_v.get_next(
name='ValidateBatch')
tf_images_v.set_shape([50, 112, 112, 3])
tf_shapes_v.set_shape([50, 73, 2])
print('Defining model...')
with tf.device(g_config['train_device']):
tf_model = mdm_model.MDMModel(tf_images,
tf_shapes,
tf_mean_shape,
batch_size=g_config['batch_size'],
num_patches=g_config['num_patches'],
num_channels=3)
tf_grads = opt.compute_gradients(tf_model.nme)
with tf.name_scope('Validate'):
tf_model_v = mdm_model.MDMModel(
tf_images_v,
tf_shapes_v,
tf_mean_shape,
batch_size=50,
num_patches=g_config['num_patches'],
num_channels=3,
is_training=False)
tf.summary.histogram('dx',
tf_model.prediction - tf_shapes,
collections=['train'])
bn_updates = tf.get_collection(tf.GraphKeys.UPDATE_OPS, scope)
# Add histograms for gradients.
for grad, var in tf_grads:
if grad is not None:
tf.summary.histogram(var.op.name + '/gradients',
grad,
collections=['train'])
# Apply the gradients to adjust the shared variables.
with tf.name_scope('Optimizer', values=[tf_grads, tf_global_step]):
apply_gradient_op = opt.apply_gradients(tf_grads,
global_step=tf_global_step)
# Add histograms for trainable variables.
for var in tf.trainable_variables():
tf.summary.histogram(var.op.name, var, collections=['train'])
with tf.name_scope('MovingAverage', values=[tf_global_step]):
variable_averages = tf.train.ExponentialMovingAverage(
g_config['MOVING_AVERAGE_DECAY'], tf_global_step)
variables_to_average = (tf.trainable_variables() +
tf.moving_average_variables())
variables_averages_op = variable_averages.apply(
variables_to_average)
# Group all updates to into a single train op.
bn_updates_op = tf.group(*bn_updates, name='BNGroup')
train_op = tf.group(apply_gradient_op,
variables_averages_op,
bn_updates_op,
name='TrainGroup')
# Create a saver.
saver = tf.train.Saver()
train_summary_op = tf.summary.merge_all('train')
validate_summary_op = tf.summary.merge_all('validate')
config = tf.ConfigProto(allow_soft_placement=True)
config.gpu_options.allow_growth = True
sess = tf.Session(graph=graph, config=config)
init = tf.global_variables_initializer()
print('Initializing variables...')
sess.run(init)
print('Initialized variables.')
# Assuming model_checkpoint_path looks something like:
# /ckpt/train/model.ckpt-0,
# extract global_step from it.
start_step = 0
ckpt = tf.train.get_checkpoint_state(g_config['train_dir'])
if ckpt and ckpt.model_checkpoint_path:
saver.restore(sess, ckpt.model_checkpoint_path)
start_step = int(
ckpt.model_checkpoint_path.split('/')[-1].split('-')[-1]) + 1
print('%s: Restart from %s' %
(datetime.now(), g_config['train_dir']))
else:
ckpt = tf.train.get_checkpoint_state(g_config['ckpt_dir'])
if ckpt and ckpt.model_checkpoint_path:
saver.restore(sess, ckpt.model_checkpoint_path)
tf_global_step_op = tf_global_step.assign(0)
sess.run(tf_global_step_op)
print('%s: Pre-trained model restored from %s' %
(datetime.now(), g_config['ckpt_dir']))
train_writer = tf.summary.FileWriter(g_config['train_dir'] + '/train',
sess.graph)
validate_writer = tf.summary.FileWriter(
g_config['train_dir'] + '/validate', sess.graph)
print('Starting training...')
steps_per_epoch = 15000 / g_config['batch_size']
for step in range(start_step, g_config['max_steps']):
if step % steps_per_epoch == 0:
start_time = time.time()
_, train_loss, train_summary = sess.run(
[train_op, tf_model.nme, train_summary_op])
duration = time.time() - start_time
validate_loss, validate_summary = sess.run(
[tf_model_v.nme, validate_summary_op])
train_writer.add_summary(train_summary, step)
validate_writer.add_summary(validate_summary, step)
print('%s: step %d, loss = %.4f (%.3f sec/batch)' %
(datetime.now(), step, train_loss, duration))
print('%s: step %d, validate loss = %.4f' %
(datetime.now(), step, validate_loss))
else:
start_time = time.time()
_, train_loss = sess.run([train_op, tf_model.nme])
duration = time.time() - start_time
if step % 100 == 0:
print('%s: step %d, loss = %.4f (%.3f sec/batch)' %
(datetime.now(), step, train_loss, duration))
assert not np.isnan(train_loss), 'Model diverged with loss = NaN'
if step % steps_per_epoch == 0 or (step +
1) == g_config['max_steps']:
checkpoint_path = os.path.join(g_config['train_dir'],
'model.ckpt')
saver.save(sess, checkpoint_path, global_step=step)
from menpo.shape import PointDirectedGraph
#预测
def file_name_except_format(file_dir):
L = []
for root, dirs, files in os.walk(file_dir):
for file in files:
if os.path.splitext(file)[1] == '.png':
L.append(os.path.splitext(file)[0])
return L
image_path_pred = "D:/电信研究院/人脸矫正/labelme-master/examples/transfer/pred"
#加载保存的模型
fitter = mio.import_pickle('pretrained12131_aam.pkl')()
pred_images = []
# load landmarked images
for i in mio.import_images(image_path_pred, max_images=None, verbose=True):
# convert it to grayscale if needed
if i.n_channels == 3:
i = i.as_greyscale(mode='luminosity')
# append it to the list
pred_images.append(i)
png_list = file_name_except_format(image_path_pred)
cnt = 0
for i in pred_images:
# Load detector
detect = load_dlib_frontal_face_detector()
# Detect
