def evaluation(trainer=None):
def _l2normalize(v, eps=1e-12):
return v / (((v**2).sum())**0.5 + eps)
xp = dis.xp
links = [[name, link] for name, link in sorted(dis.namedlinks())]
sigmas = []
for name, link in links:
if isinstance(link, SNConvolution2D):
W, u = link.W, link.u
W_mat = W.reshape(W.shape[0], -1)
sigma, _, _ = max_singular_value(W_mat, u)
W_bar = chainer.cuda.to_cpu(
(W_mat.data / xp.squeeze(sigma.data)))
_, s, _ = svd(W_bar)
_sigma = s[0]
print(name.strip('/'), _sigma)
sigmas.append([name.strip('/'), _sigma])
if dst is not None:
preview_dir = '{}/sigmas'.format(dst)
if not os.path.exists(preview_dir):
os.makedirs(preview_dir)
preview_path = preview_dir + '/sigmas_{:0>8}.txt'.format(
trainer.updater.iteration if trainer is not None else None)
with open(preview_path, 'wb') as f:
np.savetxt(f,
np.array(sigmas, dtype=np.str),
delimiter=" ",
fmt="%s")
def W_bar(self):
"""
Spectrally Normalized Weight
"""
if self.n % self.ncritic == 0:
W_mat = self.W.reshape(self.W.shape[0], -1)
xp = cuda.get_array_module(W_mat.data)
U, s, V = xp.linalg.svd(W_mat.data, full_matrices=True)
s = s / max(s)
S_shape = min(W_mat.data.shape)
half_shape = S_shape // 2
s[:half_shape] = xp.ones(half_shape)
S = xp.zeros(W_mat.data.shape)
S[:S_shape, :S_shape] = xp.diag(s)
W_mat.data = xp.dot(U, xp.dot(S, V))
self.W.copydata(W_mat.reshape(self.W.shape))
self.n = 1
return self.W
else:
self.n += 1
W_mat = self.W.reshape(self.W.shape[0], -1)
sigma, _u, _ = max_singular_value(W_mat, self.u, self.Ip)
if self.factor:
sigma = sigma / self.factor
sigma = broadcast_to(sigma.reshape((1, 1, 1, 1)), self.W.shape)
if chainer.config.train:
# Update estimated 1st singular vector
self.u[:] = _u
if hasattr(self, 'gamma'):
return broadcast_to(self.gamma, self.W.shape) * self.W / sigma
else:
return self.W / sigma
def W_bar(self):
"""
Spectral Normalized Weight
"""
sigma, _u, _ = max_singular_value(self.W, self.u, self.Ip)
if self.factor:
sigma = sigma / self.factor
sigma = broadcast_to(sigma.reshape((1, 1)), self.W.shape)
self.u[:] = _u
return self.W / sigma
def W_bar(self):
"""
Spectral Normalized Weight
"""
sigma, _u, _ = max_singular_value(self.W_sym, self.u, self.Ip)
sigma = broadcast_to(sigma.reshape((1, 1)), self.W_sym.shape)
self.u = _u
if hasattr(self, 'gamma'):
return broadcast_to(self.gamma,
self.W_sym.shape) * self.W_sym / sigma
else:
return self.W_sym / sigma
def W_bar(self):
"""
Spectral Normalized Weight
"""
xp = cuda.get_array_module(self.W.data)
W_mat = self.W.reshape(self.W.shape[0], -1)
sigma, _u, _ = max_singular_value(W_mat, self.u, self.Ip)
sigma = self.ratio * sigma if self.ratio is not None else sigma
sigma = broadcast_to(sigma.reshape((1, 1, 1, 1)), self.W.shape)
self.u = _u
if hasattr(self, 'gamma'):
return broadcast_to(self.gamma, self.W.shape) * self.W / sigma
else:
return self.W / sigma
def W_bar(self):
"""
Spectral Normalized Weight
"""
sigma, _u, _ = max_singular_value(self.W, self.u, self.Ip)
if self.factor:
sigma = sigma / self.factor
sigma = broadcast_to(sigma.reshape((1, 1)), self.W.shape)
if chainer.config.train:
self.u[:] = _u
if hasattr(self, 'gamma'):
return broadcast_to(self.gamma, self.W.shape) * self.W / sigma
else:
return self.W / sigma
def W_bar(self):
"""
Spectral Normalized Weight
"""
W_mat = self.W.reshape(self.W.shape[0], -1)
sigma, _u, _ = max_singular_value(W_mat, self.u, self.Ip)
if self.factor:
sigma = sigma / self.factor
sigma = broadcast_to(sigma.reshape([1] * len(self.W.shape)), self.W.shape)
self.u[:] = _u
if hasattr(self, 'gamma'):
return broadcast_to(self.gamma, self.W.shape) * self.W / sigma
else:
return self.W / sigma
def W_bar(self):
"""
Spectrally Normalized Weight
"""
xp = cuda.get_array_module(self.W.data)
W_mat = self.W.reshape(self.W.shape[0], -1)
sigma, _u, _ = max_singular_value(W_mat, self.u, self.Ip)
if self.factor:
sigma = sigma / self.factor
sigma = broadcast_to(sigma.reshape((1, 1, 1, 1)), self.W.shape)
self.u[:] = _u
if hasattr(self, 'gamma'):
return broadcast_to(self.gamma, self.W.shape) * self.W / sigma
else:
return self.W / sigma
def W_bar(self):
"""
Spectrally Normalized Weight
"""
W_mat = self.W.reshape(self.W.shape[0], -1)
sigma, _u, _ = max_singular_value(W_mat, self.u, self.Ip)
if self.factor:
sigma = sigma / self.factor
sigma = broadcast_to(sigma.reshape((1, 1, 1, 1)), self.W.shape)
if chainer.config.train:
# Update estimated 1st singular vector
self.u[:] = _u
if hasattr(self, 'gamma'):
return broadcast_to(self.gamma, self.W.shape) * self.W / sigma
else:
return self.W / sigma