def __init__(self):
self.latents = torch.from_numpy(np.random.randn(1, G.latent_size)).to(device=device, dtype=torch.float32)
self.feature_direction = feature_direction
self.feature_lock_status = np.zeros(num_feature).astype('bool')
self.feature_directoion_disentangled = torch.from_numpy(feature_axis.disentangle_feature_axis_by_idx(
self.feature_direction, idx_base=np.flatnonzero(self.feature_lock_status))).to(device=device,
dtype=torch.float32)
def set_feature_lock(self, event, idx_feature, set_to=None):
if set_to is None:
self.feature_lock_status[idx_feature] = np.logical_not(self.feature_lock_status[idx_feature])
else:
self.feature_lock_status[idx_feature] = set_to
self.feature_directoion_disentangled = feature_axis.disentangle_feature_axis_by_idx(
self.feature_direction, idx_base=np.flatnonzero(self.feature_lock_status))
def load_tl_gan_model():
"""
Load the linear model (matrix) which maps the feature space
to the GAN's latent space.
"""
with open(FEATURE_DIRECTION_FILE, "rb") as f:
feature_direction_name = pickle.load(f)
# Pick apart the feature_direction_name data structure.
feature_direction = feature_direction_name["direction"]
feature_names = feature_direction_name["name"]
num_feature = feature_direction.shape[1]
feature_lock_status = np.zeros(num_feature).astype("bool")
# Rearrange feature directions using Shaobo's library function.
feature_direction_disentangled = feature_axis.disentangle_feature_axis_by_idx(
feature_direction, idx_base=np.flatnonzero(feature_lock_status))
return feature_direction_disentangled, feature_names
""" save_regression result to hard disk """
if not os.path.exists(path_feature_direction):
os.mkdir(path_feature_direction)
pathfile_feature_direction = os.path.join(
path_feature_direction, 'feature_direction_{}.pkl'.format(gen_time_str()))
dict_to_save = {'direction': feature_direction, 'name': y_name}
with open(pathfile_feature_direction, 'wb') as f:
pickle.dump(dict_to_save, f)
##
""" disentangle correlated feature axis """
pathfile_feature_direction = glob.glob(
os.path.join(path_feature_direction, 'feature_direction_*.pkl'))[-1]
with open(pathfile_feature_direction, 'rb') as f:
feature_direction_name = pickle.load(f)
feature_direction = feature_direction_name['direction']
feature_name = np.array(feature_direction_name['name'])
len_z, len_y = feature_direction.shape
feature_direction_disentangled = feature_axis.disentangle_feature_axis_by_idx(
feature_direction, idx_base=range(len_y // 4), idx_target=None)
feature_axis.plot_feature_cos_sim(feature_direction_disentangled,
feature_name=feature_name)
##
with torch.no_grad():
images = G(latents, labels=labels)
return torch.from_numpy(
np.clip((images.permute(0, 2, 3, 1).numpy() + 1.0) / 2.0, a_min=0.0, a_max=1.0))
# img_cur = gen_image(latents)
batch_size = 10
step_size = 0.2
counter = 0
feature_lock_status = np.zeros(num_feature).astype('bool')
feature_directoion_disentangled = feature_axis.disentangle_feature_axis_by_idx(
feature_direction, idx_base=np.flatnonzero(feature_lock_status))
for i_feature in range(feature_direction.shape[1]):
latents_0 = latents_c - feature_directoion_disentangled[:, i_feature] * step_size
latents_1 = latents_c + feature_directoion_disentangled[:, i_feature] * step_size
print(np.mean(latents_0 - latents_1) ** 2)
latents = np.zeros([batch_size, latent_size])
for i_alpha, alpha in enumerate(np.linspace(0, 1, batch_size)):
latents[i_alpha, :] = latents_0[0] * (1 - alpha) + latents_1[0] * alpha
latents = torch.from_numpy(latents).to(device=device, dtype=torch.float32)
# Generate dummy labels (not used by the official networks).
labels = None
