import tensorflow as tf def initialize_uninitialized(sess):
global_vars = tf.global_variables()
is_not_initialized = sess.run([tf.is_variable_initialized(var) for var in global_vars])
not_initialized_vars = [v for (v, f) in zip(global_vars, is_not_initialized) if not f] print [str(i.name) for i in not_initialized_vars] # only for testing
if len(not_initialized_vars):
sess.run(tf.variables_initializer(not_initialized_vars))
上述代码是用于初始化剩余未被初始化的变量的函数
需要注意的是，我们一般采用tf.global_variables_initializer()作为初始化op会覆盖原来通过saver.restore()方式加载的变量状态，因此，不可采用此方法。
另外，如果采用sess.run(tf.global_variables_initializer())在 saver.restore()之前，是不起作用的，原因未知，restore函数似乎能屏蔽掉global_variables_initializer()
的初始化效果。
选择性加载变量时可以采用scope进行隔离，提取出name:var这样的键值对的字典作为saver的加载根据。如下代码：
# stage_merged.py
# transform from single frame into multi-frame enhanced single raw
from __future__ import division
import os, time, scipy.io
import tensorflow as tf
import numpy as np
import rawpy
import glob
from model_sid_latest import network_stages_merged, network_my_unet, network_enhance_raw
import platform
from PIL import Image if platform.system() == 'Windows':
data_dir = 'D:/data/Sony/dataset/bbf-raw-selected/'
elif platform.system() == 'Linux':
data_dir = './dataset/bbf-raw-selected/'
else:
print('platform not supported!')
assert False os.environ["CUDA_VISIBLE_DEVICES"] = ""
checkpoint_dir = './model_stage_merged/'
result_dir = './out_stage_merged/'
log_dir = './log_stage_merged/'
learning_rate = 1e-4
epoch_bound = 20000
save_model_every_n_epoch = 10 if platform.system() == 'Windows':
output_every_n_steps = 1
else:
output_every_n_steps = 100 if platform.system() == 'Windows':
ckpt_enhance_raw = 'D:/model/enhance_raw/'
ckpt_raw2rgb = 'D:/model/raw2rgb-c1/'
else:
ckpt_enhance_raw = './model/enhance_raw/'
ckpt_raw2rgb = './model/raw2rgb-c1/' # BBF100-2
bbf_w = 4032
bbf_h = 3024 patch_w = 512
patch_h = 512 max_level = 1023
black_level = 64 patch_w = 512
patch_h = 512 # set up dataset
input_files = glob.glob(data_dir + '/*.dng')
input_files.sort() def preprocess(raw, bl, wl):
im = raw.raw_image_visible.astype(np.float32)
im = np.maximum(im - bl, 0)
return im / (wl - bl) def pack_raw_bbf(path):
raw = rawpy.imread(path)
bl = 64
wl = 1023
im = preprocess(raw, bl, wl)
im = np.expand_dims(im, axis=2)
H = im.shape[0]
W = im.shape[1]
if raw.raw_pattern[0, 0] == 0: # CFA=RGGB
out = np.concatenate((im[0:H:2, 0:W:2, :],
im[0:H:2, 1:W:2, :],
im[1:H:2, 1:W:2, :],
im[1:H:2, 0:W:2, :]), axis=2)
elif raw.raw_pattern[0,0] == 2: # BGGR
out = np.concatenate((im[1:H:2, 1:W:2, :],
im[0:H:2, 1:W:2, :],
im[0:H:2, 0:W:2, :],
im[1:H:2, 0:W:2, :]), axis=2)
elif raw.raw_pattern[0,0] == 1 and raw.raw_pattern[0,1] == 0: # GRBG
out = np.concatenate((im[0:H:2, 1:W:2, :],
im[0:H:2, 0:W:2, :],
im[1:H:2, 0:W:2, :],
im[1:H:2, 1:W:2, :]), axis=2)
elif raw.raw_pattern[0,0] == 1 and raw.raw_pattern[0,1] == 2: # GBRG
out = np.concatenate((im[1:H:2, 0:W:2, :],
im[0:H:2, 0:W:2, :],
im[0:H:2, 1:W:2, :],
im[1:H:2, 1:W:2, :]), axis=2)
else:
assert False
wb = np.array(raw.camera_whitebalance)
wb[3] = wb[1]
wb = wb / wb[1]
out = np.minimum(out * wb, 1.0) h_, w_ = im.shape[0]//2, im.shape[1]//2
out_16bit_ = np.zeros([h_, w_, 4], dtype=np.uint16)
out_16bit_[:, :, :] = np.uint16(out[:, :, :] * (wl - bl))
del out
return out_16bit_ tf.reset_default_graph()
gpu_options = tf.GPUOptions(allow_growth=True)
sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options))
in_im = tf.placeholder(tf.float32, [1, patch_h, patch_w, 4], name='input') with tf.variable_scope('enhance_raw', reuse=tf.AUTO_REUSE):
enhanced_raw = network_enhance_raw(in_im, patch_h, patch_w)
with tf.variable_scope('raw2rgb', reuse=tf.AUTO_REUSE):
gt_im = network_my_unet(enhanced_raw, patch_h, patch_w)
with tf.variable_scope('stage_merged', reuse=tf.AUTO_REUSE):
out_im = network_stages_merged(in_im, patch_h, patch_w) gt_im_cut = tf.minimum(tf.maximum(gt_im, 0.0), 1.0)
out_im_cut = tf.minimum(tf.maximum(out_im, 0.0), 1.0)
ssim_loss = 1 - tf.image.ssim_multiscale(gt_im_cut[0], out_im_cut[0], 1.0)
l1_loss = tf.reduce_mean(tf.reduce_sum(tf.abs(gt_im_cut - out_im_cut), axis=-1))
l2_loss = tf.reduce_mean(tf.reduce_sum(tf.square(gt_im_cut - out_im_cut), axis=-1))
G_loss = ssim_loss
# G_loss = l1_loss + l2_loss tf.summary.scalar('G_loss', G_loss)
tf.summary.scalar('L1 Loss', l1_loss)
tf.summary.scalar('L2 Loss', l2_loss) ########## LOADING MODELS #############
scope_ = 'enhance_raw'
enhance_raw_var_list = tf.global_variables(scope_)
enhance_raw_var_names = [v.name.replace(scope_+'/', '').replace(':0', '') for v in enhance_raw_var_list]
enhance_raw_map = dict()
for i in range(len(enhance_raw_var_names)):
enhance_raw_map[enhance_raw_var_names[i]] = enhance_raw_var_list[i] saver_enhance_raw = tf.train.Saver(var_list=enhance_raw_map)
ckpt = tf.train.get_checkpoint_state(ckpt_enhance_raw)
if ckpt:
saver_enhance_raw.restore(sess, ckpt.model_checkpoint_path)
print('loaded enhance_raw model: ' + ckpt.model_checkpoint_path)
else:
print('Error: failed to load enhance_raw model!')
#----------------------------------------
scope_ = 'raw2rgb'
raw2rgb_var_list = tf.global_variables(scope_)
raw2rgb_var_names = [v.name.replace(scope_+'/', '').replace(':0', '') for v in raw2rgb_var_list]
raw2rgb_map = dict()
for i in range(len(raw2rgb_var_names)):
raw2rgb_map[raw2rgb_var_names[i]] = raw2rgb_var_list[i] saver_raw2rgb = tf.train.Saver(var_list=raw2rgb_map)
ckpt = tf.train.get_checkpoint_state(ckpt_raw2rgb)
if ckpt:
saver_raw2rgb.restore(sess, ckpt.model_checkpoint_path)
print('loaded raw2rgb model: ' + ckpt.model_checkpoint_path)
else:
print('Error: failed to load raw2rgb model!')
assert False
#---------------------------------------- def initialize_uninitialized(sess):
global_vars = tf.global_variables()
bool_inits = sess.run([tf.is_variable_initialized(var) for var in global_vars])
uninit_vars = [v for (v, b) in zip(global_vars, bool_inits) if not b]
for v in uninit_vars:
print(str(v.name))
if len(uninit_vars):
sess.run(tf.variables_initializer(uninit_vars)) t_vars = tf.trainable_variables(scope='stage_merged')
lr = tf.placeholder(tf.float32)
G_opt = tf.train.AdamOptimizer(learning_rate=lr).minimize(G_loss, var_list=t_vars) saver = tf.train.Saver(var_list=t_vars)
ckpt = tf.train.get_checkpoint_state(checkpoint_dir)
if ckpt:
saver.restore(sess, ckpt.model_checkpoint_path)
print('loaded ' + ckpt.model_checkpoint_path)
else:
sess.run(tf.variables_initializer(var_list=t_vars))
initialize_uninitialized(sess)
#######################################
if not os.path.isdir(result_dir):
os.mkdir(result_dir) input_images = [None] * len(input_files)
g_loss = np.zeros([500, 1]) merged = tf.summary.merge_all()
writer = tf.summary.FileWriter(log_dir, sess.graph) steps = 0
st = time.time() for epoch in range(0, epoch_bound):
for ind in np.random.permutation(len(input_images)):
steps += 1
if input_images[ind] is None:
input_images[ind] = np.expand_dims(pack_raw_bbf(input_files[ind]), axis=0) # random cropping
xx = np.random.randint(0, bbf_w // 2 - patch_w)
yy = np.random.randint(0, bbf_h // 2 - patch_h)
input_patch = np.float32(input_images[ind][:, yy:yy + patch_h, xx:xx + patch_w, :]) / (
max_level - black_level) # random flipping
if np.random.randint(2, size=1)[0] == 1: # random flip
input_patch = np.flip(input_patch, axis=1)
if np.random.randint(2, size=1)[0] == 1:
input_patch = np.flip(input_patch, axis=0)
if np.random.randint(2, size=1)[0] == 1: # random transpose
input_patch = np.transpose(input_patch, (0, 2, 1, 3)) summary, _, G_current, output, gt_im_ = sess.run(
[merged, G_opt, G_loss, out_im_cut, gt_im_cut],
feed_dict={
in_im: input_patch,
lr: learning_rate})
g_loss[steps % len(g_loss)] = G_current if steps % output_every_n_steps == 0:
loss_ = np.mean(g_loss[np.where(g_loss)])
cost_ = (time.time() - st) / output_every_n_steps
st = time.time()
print("%d %d Loss=%.6f Speed=%.6f" % (epoch, steps, loss_, cost_))
writer.add_summary(summary, global_step=steps)
temp = np.concatenate(
(input_patch[0, :, :, :3],
gt_im_[0, 0:patch_h*2:2, 0:patch_w*2:2, :3],
output[0, 0:patch_h*2:2, 0:patch_w*2:2, :3]), axis=1)
scipy.misc.toimage(temp * 255, high=255, low=0, cmin=0, cmax=255) \
.save(result_dir + '/%d_%d.jpg' % (epoch, steps)) # clean up the memory if necessary
if platform.system() == 'Windows':
input_images[ind] = None if epoch % save_model_every_n_epoch == 0:
saver.save(sess, checkpoint_dir + '%d.ckpt' % epoch)
print('model saved.')