def __init__(self,
config,
batchsize,
n_classes=0,
softmax=True,
comm=None,
test=False):
self.softmax = softmax
if not test:
self.l_emd = config.l_emd
self.l_re = config.l_re
self.l_patch_dis = config.l_patch_dis
self.l_gp = config.l_gp
self.l_per = config.l_per
self.comm = comm
self.config = config
self.normalize_stat = self.config.normalize_stat if hasattr(
self.config, "normalize_stat") else False
if self.normalize_stat:
self.l_re = 0
self.batchsize = batchsize
self.gen = SNGAN(n_classes=n_classes,
normalize_stat=self.normalize_stat)
self.gen.initialize_params() # initialize gamma and beta
self.dim_z = 128
params = {}
if config.initial_z == "zero":
params["z"] = L.Parameter(
np.zeros((batchsize, self.dim_z)).astype("float32"))
elif config.initial_z == "random":
params["z"] = L.Parameter(
np.random.normal(size=(batchsize,
self.dim_z)).astype("float32"))
gamma = self.gen.get_gamma()
beta = self.gen.get_beta()
for i in range(len(gamma)):
if not config.not_initial_gamma:
params[f"gamma{i + 1}"] = gamma[i]
if not config.not_initial_beta:
params[f"beta{i + 1}"] = beta[i]
# get variables of parameters
self.gamma = [g.W for g in gamma]
self.beta = [b.W for b in beta]
if config.lr_g_linear > 0:
params["g_linear"] = self.gen.l1
super(AdaSNGAN, self).__init__(**params)
if not test:
self.setup_optimizer(config.init_lr)
if config.lr_g_linear > 0:
self.g_linear.W.update_rule.hyperparam.alpha = config.lr_g_linear
def get_beta(self):
xp = self.xp
beta = [
L.Parameter(xp.zeros(self.ch * i, dtype="float32"))
for i in [16, 16, 16, 16, 8, 8, 4, 4, 2, 2, 1]
]
return beta
def get_gamma(self):
xp = self.xp
gamma = [
L.Parameter(xp.ones(self.ch * i, dtype="float32"))
for i in [16, 16, 16, 16, 8, 8, 4, 4, 2, 2, 1]
]
return gamma
def __init__(self, n_hidden, n_out, n_input=None):
super(BasicGeneratorNetwork, self).__init__()
self.n_input = n_input
with self.init_scope():
self.z = L.Parameter(np.random.randn(1, self.n_input))
self.l1 = L.Linear(n_input, n_input)
self.l2 = L.BatchNormalization(n_input)
self.l3 = L.Linear(n_input, n_out)
def __init__(self, n_docs, n_topics, n_dim, n_vocab):
factors = np.random.random((n_topics, n_dim)).astype('float32')
super(LDA, self).__init__(proportions=L.EmbedID(n_docs, n_topics),
factors=L.Parameter(factors),
embedding=L.Linear(n_dim, n_vocab))
self.n_docs = n_docs
self.n_topics = n_topics
self.n_vocab = n_vocab
self.n_dim = n_dim
def __init__(self, ch):
self.ch = ch
super(NonLocalBlock, self).__init__()
with self.init_scope():
self.theta = SNConvolution2D(ch, ch // 8, 1, 1, 0, nobias=True)
self.phi = SNConvolution2D(ch, ch // 8, 1, 1, 0, nobias=True)
self.g = SNConvolution2D(ch, ch // 2, 1, 1, 0, nobias=True)
self.o_conv = SNConvolution2D(ch // 2, ch, 1, 1, 0, nobias=True)
self.gamma = L.Parameter(np.array(0, dtype="float32"))
def __init__(self,
config,
batchsize,
n_classes=0,
softmax=True,
comm=None,
test=False):
self.softmax = softmax
if not test:
self.l_emd = config.l_emd
self.l_re = config.l_re
self.l_patch_dis = config.l_patch_dis
self.l_gp = config.l_gp
self.l_per = config.l_per
self.config = config
self.comm = comm
self.gen = BIGGAN()
self.dim_z = 140
params = {}
if config.initial_z == "zero":
params["z"] = L.Parameter(
np.zeros((batchsize, self.dim_z)).astype("float32"))
elif config.initial_z == "random":
params["z"] = L.Parameter(
np.random.normal(size=(batchsize,
self.dim_z)).astype("float32"))
initialW = initializers.HeNormal(0.001**0.5)
params["linear"] = L.Linear(1, 128, initialW=initialW, nobias=True)
params["BSA_linear"] = L.Scale(W_shape=(16 * self.gen.ch),
bias_term=True)
for i, (k, l) in enumerate(self.gen.namedlinks()):
if "Hyper" in k.split("/")[-1]:
params[f"hyper_bn{i}"] = l
if config.lr_g_linear > 0:
params["g_linear"] = self.gen.G_linear
super(AdaBIGGAN, self).__init__(**params)
if not test:
self.setup_optimizer()
self.z.W.update_rule.hyperparam.alpha = 0.05
self.linear.W.update_rule.hyperparam.alpha = 0.001
if config.lr_g_linear > 0:
self.g_linear.W.update_rule.hyperparam.alpha = config.lr_g_linear
def __init__(self, n_documents, n_topics, n_dim):
self.n_documents = n_documents
self.n_topics = n_topics
self.n_dim = n_dim
factors = np.random.randn(n_topics, n_dim).astype('float32')
factors /= np.sqrt(n_topics + n_dim)
super(EmbedMixture, self).__init__(
weights=L.EmbedID(n_documents, n_topics),
factors=L.Parameter(factors))
self.weights.W.data[...] /= np.sqrt(n_documents + n_topics)
def __init__(self, n_documents, n_topics, n_dim, dropout_ratio=0.2):
self.n_documents = n_documents
self.n_topics = n_topics
self.n_dim = n_dim
self.dropout_ratio = dropout_ratio
factors = _orthogonal_matrix((n_topics, n_dim)).astype('float32')
factors /= np.sqrt(n_topics + n_dim)
super(EmbedMixture,
self).__init__(weights=L.EmbedID(n_documents, n_topics),
factors=L.Parameter(factors))
self.weights.W.data[...] /= np.sqrt(n_documents + n_topics)
def __init__(self, counts, n_docs, n_topics, n_dim, n_vocab, n_samples=5):
factors = np.random.random((n_topics, n_dim)).astype('float32')
loss_func = L.NegativeSampling(n_dim, counts, n_samples)
loss_func.W.data[:, :] = np.random.randn(*loss_func.W.data.shape)
loss_func.W.data[:, :] /= np.sqrt(np.prod(loss_func.W.data.shape))
super(NSLDA, self).__init__(proportions=L.EmbedID(n_docs, n_topics),
factors=L.Parameter(factors),
loss_func=loss_func)
self.n_docs = n_docs
self.n_topics = n_topics
self.n_vocab = n_vocab
self.n_dim = n_dim
def __init__(self,
model,
label,
initialImg=None,
layers=[],
beta=2,
p=6,
lambda_a=1,
lambda_tv=10,
lambda_lp=10):
eval_model = model.copy()
eval_model.train = False
self.labelsize = model.labelsize
self.label = label
self.insize = model.insize
if initialImg is None:
initialImg = np.random.randn(3, self.insize, self.insize).astype(
np.float32)[np.newaxis]
initialImg = initialImg * 64
self.model = eval_model
super(Inverter, self).__init__(
#model = eval_model,
img=L.Parameter(initialImg))
self.beta = beta
self.p = p
self.lambda_a = lambda_a
self.lambda_tv = lambda_tv
self.lambda_lp = lambda_lp
self.train = True
self.add_persistent('Wh_data', np.array([[[[1], [-1], [0]]]],
dtype='f'))
self.add_persistent('Ww_data', np.array([[[[1, -1, 0]]]], dtype='f'))
truth_probabiliry = np.zeros(self.labelsize)[np.newaxis].astype(
np.float32)
truth_probabiliry[0, label] = 1
self.add_persistent('truth_probabiliry', truth_probabiliry)
self.add_persistent('t_dummy', np.asarray([label]).astype(np.int32))
def __init__(self,
n_documents,
n_topics,
n_dim,
dropout_ratio=0.2,
temperature=1.0,
docu_initialW=None):
self.n_documents = n_documents
self.n_topics = n_topics
self.n_dim = n_dim
self.dropout_ratio = dropout_ratio
factors = _orthogonal_matrix((n_topics, n_dim)).astype('float32')
factors /= np.sqrt(n_topics + n_dim)
document_weights = L.EmbedID(n_documents,
n_topics,
initialW=docu_initialW)
logger.info('>>>>>{},{}'.format(n_documents, n_topics))
super(EmbedMixture, self).__init__(
# weights=L.Parameter(document_weights.W.data),
weights=document_weights,
factors=L.Parameter(factors))
self.temperature = temperature
def set_(self, y_xp):
self.x = L.Parameter(y_xp.copy())
self.opt.setup(self.x)
def __init__(self,
num_io,
num_context,
tau_context,
num_classes,
init_state_init=None,
init_state_learning=True,
weights_learning=True,
bias_learning=True,
tau_learning=False,
aberrant_sensory_precision=0,
hyp_prior=1,
external_signal_variance=None,
pretrained_model=None):
"""
Implements the Stochastic Continuous-Time Recurrent Neural Network
num_io: Number of input and output neurons
num_context: Number of recurrent layer neurons
tau_context: Time scale (initialization) (if large: slow update;
if small: fast update of context neuron activations)
num_classes: Number of different attractors that the network can
maximally represent (=> number of initial states)
init_state_init (None): Numpy 2-d matrix for initializing the initial
states; must be of size (num_classes x num_context). If None
initialized with zeros.
init_state_learning (True): if True initial states are updated during
optimization, if False they are fixed to the given initial values.
weights_learning (True): Whether to update weights.
bias_learning (True): Whether to update the bias values while learning.
tau_learning (False): if True, the tau factor is updated during
optimization, if False tau is fixed
hyp_prior (1): Increases (hyp_prior < 1) or decreases (hyp_prior > 1) the reliance
on the networks own prediction during learning. Parameter H.
external_signal_variance (None): If (None), external signal variance is set
identical to the estimated variance, otherwise to fixed value (per
dimension)
aberrant_sensory_precision (0): If != 0, the network under- or overestimates
its estimated variance during training.
pretrained_model (None): If given, initial states and network weights
are copied from the other (previously trained) SCTRNN instance.
"""
super(SCTRNN, self).__init__()
if pretrained_model:
# reuse initial states from pretraining and add new ones according to number of classes
if num_classes - pretrained_model.initial_states.W.array.shape[
0] < 1:
init_state_init = np.zeros((num_classes, num_context),
dtype=np.float32)
else:
init_state_init = np.concatenate(
(pretrained_model.initial_states.W.array,
np.zeros(
(num_classes -
pretrained_model.initial_states.W.array.shape[0],
num_context),
dtype=np.float32)))
print("Reuse initial states from pretrained model!")
elif init_state_init is None:
init_state_init = np.zeros((num_classes, num_context),
dtype=np.float32)
print("Initialize initial states with zeros!")
# define learning parameters of net
with self.init_scope():
# define initialization methods
W_init = chainer.initializers.LeCunUniform()
b_init = chainer.initializers.Normal(scale=1 / num_context)
if init_state_learning:
self.initial_states = L.Parameter(init_state_init)
if weights_learning and bias_learning:
# Links
self.x_to_h = L.Linear(num_io,
num_context,
initialW=W_init,
initial_bias=b_init)
self.h_to_h = L.Linear(num_context,
num_context,
initialW=W_init,
initial_bias=b_init)
self.h_to_y = L.Linear(num_context,
num_io,
initialW=W_init,
initial_bias=b_init)
self.h_to_v = L.Linear(num_context,
num_io,
initialW=W_init,
initial_bias=b_init)
elif weights_learning:
# Links
self.x_to_h = L.Linear(num_io,
num_context,
initialW=W_init,
nobias=True)
self.h_to_h = L.Linear(num_context,
num_context,
initialW=W_init,
nobias=True)
self.h_to_y = L.Linear(num_context,
num_io,
initialW=W_init,
nobias=True)
self.h_to_v = L.Linear(num_context,
num_io,
initialW=W_init,
nobias=True)
if tau_learning:
self.tau_c = L.Parameter(np.float32(np.asarray([tau_context])))
if not init_state_learning:
self.initial_states = L.Parameter(init_state_init)
if not weights_learning:
self.x_to_h = L.Linear(num_io,
num_context,
initialW=W_init,
initial_bias=b_init)
self.h_to_h = L.Linear(num_context,
num_context,
initialW=W_init,
initial_bias=b_init)
self.h_to_y = L.Linear(num_context,
num_io,
initialW=W_init,
initial_bias=b_init)
self.h_to_v = L.Linear(num_context,
num_io,
initialW=W_init,
initial_bias=b_init)
if not tau_learning:
self.tau_c = L.Parameter(np.float32(np.asarray([tau_context])))
if not bias_learning:
# define fixed bias values which are added in each __call__() call and initialize it
self.x_to_h_bias = L.Bias(axis=1, shape=(num_context, ))
fixed_bias = chainer.Parameter(b_init, (num_context, ))
self.x_to_h_bias.b = fixed_bias
self.h_to_h_bias = L.Bias(axis=1, shape=(num_context, ))
fixed_bias = chainer.Parameter(b_init, (num_context, ))
self.h_to_h_bias.b = fixed_bias
# other class properties
self.num_io = num_io
self.num_c = num_context
self.aberrant_sensory_precision = aberrant_sensory_precision
# store which initial states were determined when using init_state policy 'best' in generate()
self.used_is_idx = []
self.reset_current_output()
self.gpu_id = -1
self.bias_learning = bias_learning
# Whether to [True] sample from the resulting distribution of the BI (or [False] just take the mean)
self.add_BI_variance = True
self.hyp_prior = hyp_prior
self.external_signal_variance = external_signal_variance
if pretrained_model:
self.x_to_h.W.array = pretrained_model.x_to_h.W.array
self.x_to_h.b.array = pretrained_model.x_to_h.b.array
self.h_to_h.W.array = pretrained_model.h_to_h.W.array
self.h_to_h.b.array = pretrained_model.h_to_h.b.array
self.h_to_y.W.array = pretrained_model.h_to_y.W.array
self.h_to_y.b.array = pretrained_model.h_to_y.b.array
self.h_to_v.W.array = pretrained_model.h_to_v.W.array
self.h_to_v.b.array = pretrained_model.h_to_v.b.array
self.classes = []
parser = argparse.ArgumentParser("Maximize SSIM")
parser.add_argument("--device", type=int, default=-1)
parser.add_argument("--noplot", dest="is_plot", action="store_false")
args = parser.parse_args()
device = chainer.get_device(args.device)
img1 = cv2.imread("assets/einstein.png")
img1 = img1.astype(np.float32).transpose(2, 0, 1) / 255.0
img1 = np.expand_dims(img1, 0)
img1 = Variable(img1)
img1.to_device(device)
img2 = L.Parameter(np.random.rand(*img1.shape).astype(np.float32))
img2.to_device(device)
optimizer = Adam(0.1)
optimizer.setup(img2)
device.use()
print(type(img1), type(img2()))
ssim_value = ssim_loss(img1, img2(), 11, 11)
print("Initial ssim:", ssim_value)
step = 1
while ssim_value.data < 0.95:
optimizer.update(loss, img1, img2())
ssim_value = -loss(img1, img2())
def main():
# command line argument parsing
parser = argparse.ArgumentParser(description='Digraph Embedding')
parser.add_argument('input', help='Path to the digraph description file')
parser.add_argument(
'--validation',
'-val',
default=None,
help='Path to the digraph description file for validation')
parser.add_argument('--coordinates',
'-c',
help='Path to the coordinate file for initialization')
parser.add_argument('--batchsize_edge',
'-be',
type=int,
default=100,
help='Number of samples in each edge mini-batch')
parser.add_argument('--batchsize_anchor',
'-ba',
type=int,
default=-1,
help='Number of samples in each anchor mini-batch')
parser.add_argument(
'--batchsize_vert',
'-bv',
type=int,
default=-1,
help=
'Number of samples in each vertex mini-batch (used for sampling negative edges)'
)
parser.add_argument(
'--batchsize_negative',
'-bn',
type=int,
default=0,
help=
'Number of negative edges sampled for each vertex mini-batch (positive: exact negative edge sampling, negative: random sampling to approximate negative edges)'
)
parser.add_argument('--vertex_offset',
type=int,
default=0,
help='the smallest index of vertices')
parser.add_argument('--epoch',
'-e',
type=int,
default=100,
help='Number of sweeps over the dataset to train')
parser.add_argument('--gpu',
'-g',
type=int,
default=-1,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--dim',
'-d',
type=int,
default=2,
help='Embedding dimension')
parser.add_argument('--dag',
type=float,
default=0,
help='0:non-acyclic, 1:acyclic')
parser.add_argument('--margin',
'-m',
type=float,
default=0.01,
help='margin for the metric boundary')
parser.add_argument('--weight_decay',
'-wd',
type=float,
default=0,
help='weight decay for regularization on coordinates')
parser.add_argument('--wd_norm',
'-wn',
choices=['l1', 'l2'],
default='l2',
help='norm of weight decay for regularization')
parser.add_argument('--learning_rate',
'-lr',
type=float,
default=5e-2,
help='learning rate')
parser.add_argument('--learning_rate_drop',
'-ld',
type=int,
default=5,
help='how many times to half learning rate')
# parser.add_argument('--lambda_super_neg', '-lsn', type=float, default=0,
# help='Super negative samples')
parser.add_argument('--lambda_pos',
'-lp',
type=float,
default=1,
help='weight for loss for positive edges')
parser.add_argument('--lambda_neg',
'-ln',
type=float,
default=1,
help='weight for loss for negative edges')
parser.add_argument(
'--lambda_anchor',
'-la',
type=float,
default=1,
help=
'anchor should reside in the disk. if set to 0, anchors are fixed to the centre of the spheres'
)
parser.add_argument('--lambda_uniform_radius',
'-lur',
type=float,
default=0,
help='all radiuses should be similar')
parser.add_argument('--outdir',
'-o',
default='result',
help='Directory to output the result')
parser.add_argument('--optimizer',
'-op',
choices=optim.keys(),
default='Adam',
help='optimizer')
parser.add_argument('--vis_freq',
'-vf',
type=int,
default=-1,
help='evaluation frequency in iteration')
parser.add_argument('--mpi',
action='store_true',
help='parallelise with MPI')
parser.add_argument('--reconstruct',
'-r',
action='store_true',
help='reconstruct graph during evaluation')
parser.add_argument('--plot',
'-p',
action='store_true',
help='plot result (dim=2 only)')
# parser.add_argument('--training', '-t', action='store_false',help='reconstruct graph')
args = parser.parse_args()
# default batchsize
if args.batchsize_anchor < 0:
args.batchsize_anchor = 10 * args.batchsize_edge
if args.batchsize_vert < 0:
if args.batchsize_negative == 0:
args.batchsize_vert = 10 * args.batchsize_edge
else:
args.batchsize_vert = args.batchsize_edge
args.outdir = os.path.join(args.outdir, dt.now().strftime('%m%d_%H%M'))
save_args(args, args.outdir)
chainer.config.autotune = True
vert, pos_edge = read_graph(args.input, args.vertex_offset)
vnum = np.max(vert) + 1
## ChainerMN
if args.mpi:
import chainermn
if args.gpu >= 0:
comm = chainermn.create_communicator()
chainer.cuda.get_device(comm.intra_rank).use()
else:
comm = chainermn.create_communicator('naive')
if comm.rank == 0:
primary = True
print(args)
chainer.print_runtime_info()
print("#edges {}, #vertices {}".format(len(pos_edge), len(vert)))
else:
primary = False
print("process {}".format(comm.rank))
else:
primary = True
print(args)
chainer.print_runtime_info()
print("#edges {}, #vertices {}".format(len(pos_edge), len(vert)))
if args.gpu >= 0:
chainer.cuda.get_device(args.gpu).use()
# data
edge_iter = iterators.SerialIterator(datasets.TupleDataset(
pos_edge[:, 0], pos_edge[:, 1]),
args.batchsize_edge,
shuffle=True)
vert_iter = iterators.SerialIterator(datasets.TupleDataset(vert),
args.batchsize_vert,
shuffle=True)
anchor_iter = iterators.SerialIterator(datasets.TupleDataset(vert),
args.batchsize_anchor,
shuffle=True)
graph = nx.from_edgelist(pos_edge, nx.DiGraph())
if args.validation and primary:
val_vert, val_edge = read_graph(args.validation, args.vertex_offset)
val_graph = nx.from_edgelist(val_edge, nx.DiGraph())
print("validation #edges {}, #vertices {}".format(
len(val_edge), len(val_vert)))
else:
val_graph = graph
if args.vis_freq < 0:
args.vis_freq = int(len(pos_edge) * args.epoch / 10)
# initial embedding
if args.coordinates:
coords = np.loadtxt(args.coordinates, delimiter=",")
else:
coords = np.zeros((vnum, 1 + 2 * args.dim))
# anchor = centre
X = 2 * np.random.rand(vnum, args.dim) - 1
coords[:, 1:args.dim + 1] = X
coords[:, args.dim + 1:] = X
# the first coordinate corresponds to the radius r=0.1
coords[:, 0] = 0.1
coords = L.Parameter(coords)
# set up an optimizer
def make_optimizer(model):
if args.optimizer in [
'SGD', 'Momentum', 'CMomentum', 'AdaGrad', 'RMSprop',
'NesterovAG', 'LBFGS'
]:
optimizer = optim[args.optimizer](lr=args.learning_rate)
elif args.optimizer in ['AdaDelta']:
optimizer = optim[args.optimizer]()
elif args.optimizer in ['Adam', 'AdaBound', 'Eve']:
optimizer = optim[args.optimizer](
alpha=args.learning_rate, weight_decay_rate=args.weight_decay)
if args.mpi:
optimizer = chainermn.create_multi_node_optimizer(optimizer, comm)
optimizer.setup(model)
return optimizer
opt = make_optimizer(coords)
if args.weight_decay > 0 and (not args.optimizer
in ['Adam', 'AdaBound', 'Eve']):
if args.wd_norm == 'l2':
opt.add_hook(chainer.optimizer_hooks.WeightDecay(
args.weight_decay))
else:
opt.add_hook(chainer.optimizer_hooks.Lasso(args.weight_decay))
if args.gpu >= 0:
coords.to_gpu()
updater = Updater(
models=coords,
iterator={
'main': edge_iter,
'vertex': vert_iter,
'anchor': anchor_iter
},
optimizer={'main': opt},
device=args.gpu,
# converter=convert.ConcatWithAsyncTransfer(),
params={
'args': args,
'graph': graph
})
trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.outdir)
if primary:
log_interval = 20, 'iteration'
log_keys = [
'iteration', 'lr', 'elapsed_time', 'main/loss_pos',
'main/loss_neg', 'main/loss_anc'
]
if args.validation:
log_keys.extend(
['myval/prc', 'myval/rec', 'myval/f1', 'myval/anc'])
if args.lambda_uniform_radius > 0:
log_keys.append('main/loss_rad')
trainer.extend(extensions.observe_lr('main'), trigger=log_interval)
trainer.extend(
extensions.LogReport(keys=log_keys, trigger=log_interval))
# trainer.extend(extensions.LogReport(keys=log_keys, trigger=log_interval))
trainer.extend(extensions.PrintReport(log_keys), trigger=log_interval)
# trainer.extend(extensions.PrintReport(log_keys), trigger=(1, 'iteration'))
if extensions.PlotReport.available():
trainer.extend(
extensions.PlotReport(log_keys[3:],
'epoch',
file_name='loss.png',
postprocess=plot_log))
trainer.extend(extensions.ProgressBar(update_interval=10))
trainer.extend(extensions.LogReport(trigger=log_interval))
trainer.extend(extensions.snapshot_object(opt,
'opt{.updater.epoch}.npz'),
trigger=(args.epoch, 'epoch'))
if args.vis_freq > 0:
trainer.extend(Evaluator({'main': edge_iter},
coords,
params={
'args': args,
'graph': val_graph
},
device=args.gpu),
trigger=(args.vis_freq, 'iteration'))
# trainer.extend(extensions.ParameterStatistics(coords))
# ChainerUI
save_args(args, args.outdir)
if args.optimizer in [
'Momentum', 'CMomentum', 'AdaGrad', 'RMSprop', 'NesterovAG'
]:
trainer.extend(extensions.ExponentialShift('lr', 0.5, optimizer=opt),
trigger=(args.epoch / args.learning_rate_drop, 'epoch'))
elif args.optimizer in ['Adam', 'AdaBound', 'Eve']:
trainer.extend(extensions.ExponentialShift("alpha", 0.5,
optimizer=opt),
trigger=(args.epoch / args.learning_rate_drop, 'epoch'))
# if args.training:
trainer.run()
# result
if primary:
# save DAG data file
if (args.gpu > -1):
dat = coords.xp.asnumpy(coords.W.data)
else:
dat = coords.W.data
if args.lambda_anchor == 0: # anchor = centre
dat[:, 1:(args.dim + 1)] = dat[:, (args.dim + 1):]
redge = reconstruct(dat, dag=args.dag)
np.savetxt(os.path.join(args.outdir, "original.csv"),
pos_edge,
fmt='%i',
delimiter=",")
np.savetxt(os.path.join(args.outdir, "reconstructed.csv"),
redge,
fmt='%i',
delimiter=",")
np.savetxt(os.path.join(args.outdir, "coords.csv"),
dat,
fmt='%1.5f',
delimiter=",")
f1, prc, rec, acc = compare_graph(
val_graph, nx.from_edgelist(redge, nx.DiGraph()))
if args.plot:
plot_digraph(pos_edge, os.path.join(args.outdir, "original.png"))
plot_digraph(redge, os.path.join(args.outdir, "reconstructed.png"))
plot_disks(dat, os.path.join(args.outdir, "plot.png"))
with open(os.path.join(args.outdir, "args.txt"), 'w') as fh:
fh.write(" ".join(sys.argv))
fh.write(
f"f1: {f1}, precision: {prc}, recall: {rec}, accuracy: {acc}")
def main():
args = arguments()
chainer.config.autotune = True
chainer.print_runtime_info()
print(args)
if args.dp:
from net_dp import Encoder, Decoder
else:
from net import Encoder, Decoder
if args.gpu >= 0:
cuda.get_device(args.gpu).use()
xp = cuda.cupy
sp = cupyx.scipy.sparse
else:
print("runs desperately slowly without a GPU!")
xp = np
sp = scipy.sparse
## Input information ##
# InputFile = scanconf.ScanConfig()
# InputFile.reconSize = args.crop_width
## setup trainable links
decoder = Decoder(args)
if args.use_enc:
encoder = Encoder(args)
else:
encoder = L.Linear(1)
if args.use_dis:
dis = Discriminator(args)
else:
dis = L.Linear(1)
if args.model_dis:
serializers.load_npz(args.model_dis, dis)
print('discriminator model loaded: {}'.format(args.model_dis))
if args.model_gen:
if 'enc' in args.model_gen and not args.decoder_only:
serializers.load_npz(args.model_gen, encoder)
print('encoder model loaded: {}'.format(args.model_gen))
serializers.load_npz(args.model_gen.replace('enc', 'dec'), decoder)
print('decoder model loaded: {}'.format(
args.model_gen.replace('enc', 'dec')))
if args.lambda_sd > 0 and args.lr_sd < 0.05:
print(
"\n\n for usual iterative reconstruction (-ls), --lr_sd should be around 0.1. \n\n"
)
if args.latent_dim > 0:
init = xp.zeros((args.batchsize, args.latent_dim)).astype(np.float32)
elif args.decoder_only:
init = xp.zeros((args.batchsize, decoder.latent_c, decoder.latent_h,
decoder.latent_w)).astype(np.float32)
else:
init = xp.zeros((args.batchsize, 1, args.crop_height,
args.crop_width)).astype(np.float32)
# init = xp.random.uniform(-0.1,0.1,(1,1,args.crop_height,args.crop_width)).astype(np.float32)
print("Initial image {} shape {}".format(args.model_image, init.shape))
seed = L.Parameter(init)
if args.gpu >= 0:
decoder.to_gpu()
seed.to_gpu()
encoder.to_gpu()
dis.to_gpu()
# setup optimisers
def make_optimizer(model, lr, opttype='Adam'):
# eps = 1e-5 if args.dtype==np.float16 else 1e-8
optimizer = optim[opttype](lr)
#from profiled_optimizer import create_marked_profile_optimizer
# optimizer = create_marked_profile_optimizer(optim[opttype](lr), sync=True, sync_level=2)
optimizer.setup(model)
if args.weight_decay > 0:
if opttype in ['Adam', 'Adam_d', 'AdaBound', 'Eve']:
optimizer.weight_decay_rate = args.weight_decay
else:
optimizer.add_hook(
chainer.optimizer_hooks.WeightDecay(args.weight_decay))
# optimizer.add_hook(chainer.optimizer_hooks.GradientClipping(100))
return optimizer
optimizer_sd = make_optimizer(seed, args.lr_sd, args.optimizer)
optimizer_dec = make_optimizer(decoder, args.lr_gen, args.optimizer)
optimizer_enc = make_optimizer(encoder, args.lr_gen, args.optimizer)
optimizer_dis = make_optimizer(dis, args.lr_dis, args.optimizer_dis)
# unify CPU and GPU memory to load big matrices
if args.unified_memory_pool and args.crop_height > 256:
pool = cp.cuda.MemoryPool(cp.cuda.malloc_managed)
cp.cuda.set_allocator(pool.malloc)
# projection matrices
prMats, conjMats = None, None
if args.lambda_sd > 0 or args.lambda_nn > 0:
prMat = scipy.sparse.load_npz(
os.path.join(args.root, args.projection_matrix)).tocsr(copy=False)
# cx = prMat.tocsr()
# rows,cols = cx.nonzero()
# for i,j in zip(rows,cols):
# if cx[i,j] < 1e-5:
# cx[i,j] = 0
# prMat = cx.tocoo()
# scipy.sparse.save_npz("d:/ml/reconst/pr.npz",prMat)
prMats = [
sp.coo_matrix((prMat[np.arange(i, prMat.shape[0], args.osem), :]),
dtype=np.float32) for i in range(args.osem)
]
prMats = [
chainer.utils.CooMatrix(p.data, p.row, p.col, p.shape)
for p in prMats
]
print("Projection matrix {} shape {}, thinned {} x {}".format(
args.projection_matrix, prMat.shape, prMats[0].shape, len(prMats)))
if args.system_matrix:
conjMat = scipy.sparse.load_npz(
os.path.join(args.root, args.system_matrix)).tocsr(copy=False)
conjMats = [
sp.coo_matrix(
(conjMat[np.arange(i, conjMat.shape[0], args.osem), :]),
dtype=np.float32) for i in range(args.osem)
]
conjMats = [
chainer.utils.CooMatrix(p.data, p.row, p.col, p.shape)
for p in conjMats
]
# conjMat = sp.coo_matrix(conjMat, dtype = np.float32)
# conjMat = chainer.utils.CooMatrix(conjMat.data, conjMat.row, conjMat.col, conjMat.shape)
print("Conjugate matrix {} shape {}, thinned {} x {}".format(
args.system_matrix, conjMat.shape, conjMats[0].shape,
len(conjMats)))
# setup updater
print("Setting up data iterators...")
planct_dataset = Dataset(path=args.planct_dir,
baseA=args.HU_base,
rangeA=args.HU_range,
crop=(args.crop_height, args.crop_width),
scale_to=args.scale_to,
random=args.random_translate)
planct_iter = chainer.iterators.SerialIterator(planct_dataset,
args.batchsize,
shuffle=True)
mvct_dataset = Dataset(path=args.mvct_dir,
baseA=args.HU_base,
rangeA=args.HU_range,
crop=(args.crop_height, args.crop_width),
scale_to=args.scale_to,
random=args.random_translate)
mvct_iter = chainer.iterators.SerialIterator(mvct_dataset,
args.batchsize,
shuffle=True)
data = prjData(args.sinogram, osem=args.osem)
proj_iter = chainer.iterators.SerialIterator(data,
args.batchsize,
shuffle=False) # True
updater = Updater(models=(seed, encoder, decoder, dis),
iterator={
'main': proj_iter,
'planct': planct_iter,
'mvct': mvct_iter
},
optimizer={
'main': optimizer_sd,
'enc': optimizer_enc,
'dec': optimizer_dec,
'dis': optimizer_dis
},
device=args.gpu,
params={
'args': args,
'prMats': prMats,
'conjMats': conjMats
})
# logging
if args.epoch < 0:
total_iter = -args.epoch * args.iter * math.ceil(
len(data) / args.batchsize)
else:
total_iter = args.epoch * args.iter
trainer = training.Trainer(updater, (total_iter, 'iteration'),
out=args.out)
log_interval = (50, 'iteration')
log_keys_main = []
log_keys_dis = []
log_keys_grad = [
'main/grad_sd', 'main/grad_gen', 'main/grad_sd_consistency',
'main/grad_gen_consistency', 'main/seed_diff'
]
loss_main_list = [(args.lambda_sd, 'main/loss_sd'),
(args.lambda_nn, 'main/loss_nn'),
(args.lambda_ae1, 'main/loss_ae1'),
(args.lambda_ae2, 'main/loss_ae2'),
(args.lambda_tv, 'main/loss_tv'),
(args.lambda_tvs, 'main/loss_tvs'),
(args.lambda_reg, 'main/loss_reg'),
(args.lambda_reg, 'main/loss_reg_ae')]
for a, k in loss_main_list:
if a > 0:
log_keys_main.append(k)
loss_dis_list = [(args.lambda_adv, 'main/loss_adv'),
(args.lambda_advs, 'main/loss_advs'),
(args.dis_freq, 'main/loss_dis'),
(args.lambda_gan, 'main/loss_gan')]
for a, k in loss_dis_list:
if a > 0:
log_keys_dis.append(k)
log_keys = ['iteration'] + log_keys_main + log_keys_dis + log_keys_grad
trainer.extend(extensions.observe_lr(), trigger=log_interval)
trainer.extend(extensions.LogReport(keys=log_keys, trigger=log_interval))
trainer.extend(extensions.PrintReport(log_keys), trigger=log_interval)
trainer.extend(extensions.ProgressBar(update_interval=10))
if extensions.PlotReport.available():
trainer.extend(
extensions.PlotReport(log_keys_main,
'iteration',
trigger=(100, 'iteration'),
file_name='loss.png',
postprocess=plot_log))
trainer.extend(
extensions.PlotReport(log_keys_dis,
'iteration',
trigger=(100, 'iteration'),
file_name='loss_dis.png'))
trainer.extend(
extensions.PlotReport(log_keys_grad,
'iteration',
trigger=(100, 'iteration'),
file_name='loss_grad.png',
postprocess=plot_log))
# trainer.extend(extensions.ParameterStatistics([seed,decoder])) ## very slow
trainer.extend(CommandsExtension())
if args.snapinterval <= 0:
args.snapinterval = total_iter
if args.lambda_nn > 0:
trainer.extend(
extensions.dump_graph('main/loss_nn', out_name='gen.dot'))
elif args.lambda_ae1 > 0:
trainer.extend(
extensions.dump_graph('main/loss_ae1', out_name='gen.dot'))
# save models
if args.use_enc:
trainer.extend(extensions.snapshot_object(
encoder, 'enc_{.updater.iteration}.npz'),
trigger=(args.snapinterval, 'iteration'))
trainer.extend(extensions.snapshot_object(
optimizer_enc, 'opt_enc_{.updater.iteration}.npz'),
trigger=(args.snapinterval, 'iteration'))
if args.use_dis:
trainer.extend(extensions.snapshot_object(
dis, 'dis_{.updater.iteration}.npz'),
trigger=(args.snapinterval, 'iteration'))
trainer.extend(extensions.snapshot_object(
optimizer_dis, 'opt_dis_{.updater.iteration}.npz'),
trigger=(args.snapinterval, 'iteration'))
# trainer.extend(extensions.dump_graph('main/loss_real', out_name='dis.dot'))
trainer.extend(extensions.snapshot_object(decoder,
'dec_{.updater.iteration}.npz'),
trigger=(args.snapinterval, 'iteration'))
trainer.extend(extensions.snapshot_object(
optimizer_dec, 'opt_dec_{.updater.iteration}.npz'),
trigger=(args.snapinterval, 'iteration'))
# save command line arguments
os.makedirs(args.out, exist_ok=True)
save_args(args, args.out)
with open(os.path.join(args.out, "args.txt"), 'w') as fh:
fh.write(" ".join(sys.argv))
trainer.run()
def main():
parser = argparse.ArgumentParser(description='A Neural Algorithm of Artistic Style')
parser.add_argument('input', default=None,
help='Original image')
parser.add_argument('--style', '-s', default=None,
help='Style image')
parser.add_argument('--reduced_image', '-r', default=None,
help='reduced contents image')
parser.add_argument('--init_image', '-i', default=None,
help="start optimisation using this image, otherwise start with a random image")
parser.add_argument('--out', '-o', default='result',
help='Output directory')
parser.add_argument('--gpu', '-g', default=0, type=int,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--iter', default=5000, type=int,
help='number of iterations')
parser.add_argument('--vis_freq', '-vf', default=500, type=int,
help='image output interval')
parser.add_argument('--ksize', '-k', default=4, type=int,
help='kernel size for reduction')
parser.add_argument('--lr', default=4.0, type=float,
help='learning rate')
parser.add_argument('--lambda_tv', '-ltv', default=1, type=float,
help='weight of total variation regularization')
parser.add_argument('--lambda_feat', '-lf', default=0.1, type=float,
help='weight for the original shape; increase to retain it')
parser.add_argument('--lambda_rfeat', '-lrf', default=0.1, type=float,
help='weight for the reduce shape; increase to retain it')
parser.add_argument('--lambda_style', '-ls', default=1.0, type=float,
help='weight for the style')
parser.add_argument('--median_filter', '-f', default=3, type=int,
help='kernel size of the median filter applied to the output')
parser.add_argument('--removebg', '-nbg', action='store_true',
help="remove background specified by alpha in png")
parser.add_argument('--crop_width', '-cw', type=int, default=0)
parser.add_argument('--crop_height', '-ch', type=int, default=0)
## dicom related
parser.add_argument('--image_size', default=448, type=int)
parser.add_argument('--CT_base', '-ctb', type=int, default=-250)
parser.add_argument('--CT_range', '-ctr', type=int, default=500)
parser.add_argument('--CT_A_scale', type=float, default=1.0)
parser.add_argument('--CT_B_scale', type=float, default=2.148/0.7634)
args = parser.parse_args()
chainer.config.autotune = True
chainer.print_runtime_info()
if not args.style:
args.lambda_style = 0
if not args.reduced_image:
args.lambda_rfeat = 0
print(args)
os.makedirs(args.out, exist_ok=True)
if args.gpu >= 0:
cuda.get_device(args.gpu).use()
xp = cuda.cupy
else:
print("runs desperately slowly without a GPU!")
xp = np
## use pretrained VGG for feature extraction
nn = L.VGG16Layers()
## load images
if os.path.splitext(args.input)[1] == '.dcm':
image = load_dicom(args.input, args.CT_base, args.CT_range, args.image_size, args.CT_A_scale)
image = xp.tile(image,(1,3,1,1))
style = load_dicom(args.style, args.CT_base, args.CT_range, args.image_size, args.CT_B_scale)
style = xp.tile(style,(1,3,1,1))
else:
image = xp.asarray(load_image(args.input,size=(args.crop_width,args.crop_height),removebg=args.removebg))
if args.lambda_style > 0:
style = xp.asarray(load_image(args.style,size=(image.shape[3],image.shape[2]), removebg=args.removebg))
bg = Image.open(args.input).convert('RGBA')
if args.crop_height>0 and args.crop_width>0:
bg = bg.resize((image.shape[3],image.shape[2]),Image.LANCZOS)
bg = np.array(bg)
bg[:,:,3] = 255-bg[:,:,3]
bkgnd = Image.fromarray(bg)
## initial image: original or random
if args.init_image:
img_gen = load_image(args.init_image,size=(image.shape[3],image.shape[2]), removebg=args.removebg)
else:
img_gen = xp.random.uniform(-20,20,image.shape).astype(np.float32)
print("input image:", image.shape, xp.min(image), xp.max(image))
## image to be generated
img_gen = L.Parameter(img_gen)
if args.gpu>=0:
nn.to_gpu()
img_gen.to_gpu()
optimizer = optimizers.Adam(alpha=args.lr)
optimizer.setup(img_gen)
## compute style matrix
layers = ["conv1_2","conv2_2","conv3_3","conv4_3"]
with chainer.using_config('train', False):
feature = nn(Variable(image),layers=layers)
if args.lambda_style > 0:
feature_s = nn(Variable(style),layers=layers)
gram_s = { k:gram_matrix(feature_s[k]) for k in layers}
else:
gram_s = None
if args.lambda_rfeat > 0:
reduced_image = xp.asarray(load_image(args.reduced_image,size=(image.shape[3],image.shape[2]),removebg=args.removebg))
reduced_feature = nn(F.average_pooling_2d(Variable(reduced_image),args.ksize),layers=layers)
else:
reduced_feature = None
# modify loss weights according to the feature vector size
args.lambda_rfeat /= args.ksize ** 2
# setup updater
dummy_iterator = chainer.iterators.SerialIterator(np.array([1]),1)
updater = Updater(
models=(img_gen,nn),
iterator=dummy_iterator,
optimizer=optimizer,
# converter=convert.ConcatWithAsyncTransfer(),
device=args.gpu,
params={'args': args, 'image': image, 'reduced_feature': reduced_feature,
'bkgnd': bkgnd, 'feature': feature, 'gram_s': gram_s, 'layers': layers}
)
trainer = training.Trainer(updater, (args.iter, 'iteration'), out=args.out)
log_interval = (100, 'iteration')
log_keys = ['iteration','lr','main/loss_tv','main/loss_f','main/loss_s','main/loss_r']
trainer.extend(extensions.observe_lr(), trigger=log_interval)
trainer.extend(extensions.LogReport(keys=log_keys, trigger=log_interval))
trainer.extend(extensions.PrintReport(log_keys), trigger=log_interval)
trainer.extend(extensions.ProgressBar(update_interval=10))
if extensions.PlotReport.available():
trainer.extend(extensions.PlotReport(
log_keys[2:], 'iteration',
trigger=(1000, 'iteration'), file_name='loss.png'))
trainer.run()
def set_(self, zy_xp):
self.z = L.Parameter(zy_xp)
self.z.to_gpu
self.opt.setup(self.z)
def main():
parser = argparse.ArgumentParser(description='Ranking learning')
parser.add_argument('input', help='Path to ply file')
parser.add_argument('--output', default="output.ply", help='output ply filename')
parser.add_argument('--target_curvature', '-K', default=None, type=str, help='file containing target gaussian curvature')
parser.add_argument('--target_curvature_scalar', '-Ks', default=0.01, type=float, help='target gaussian curvature value')
parser.add_argument('--constrained_vert', '-cv', default=None, type=str, help='file containing indices of vertices with curvature target')
parser.add_argument('--boundary_vertex', '-bv', default=None, help='Path to a csv specifying boundary position')
parser.add_argument('--lambda_bdvert', '-lv', type=float, default=0, help="weight for boundary constraint")
parser.add_argument('--strict_boundary', '-sbd', action='store_true',help='strict boundary constraint')
parser.add_argument('--lambda_upward', '-lu', type=float, default=0, help="weight for upwardness")
parser.add_argument('--batchsize', '-b', type=int, default=-1,
help='Number of vertices which are updated at a time')
parser.add_argument('--epoch', '-e', type=int, default=100,
help='Number of iterations')
parser.add_argument('--vis_freq', '-vf', type=int, default=-1,
help='visualisation frequency')
parser.add_argument('--gpu', '-g', type=int, default=-1,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--optimise_cos', '-cos', action='store_true', help='optimise cosine rather than curvature')
parser.add_argument('--outdir', '-o', default='result',
help='Directory to output the result')
parser.add_argument('--optimizer', '-op',choices=optim.keys(),default='Adam',
help='optimizer')
parser.add_argument('--learning_rate', '-lr', type=float, default=1e-3,
help='learning rate')
parser.add_argument('--salt', action='store_true',help='add salt to randomise initial coordinates')
parser.add_argument('--verbose', '-v', action='store_true',help='print debug information')
args = parser.parse_args()
chainer.config.autotune = True
#chainer.print_runtime_info()
# Read mesh data
plydata = PlyData.read(args.input)
vert = np.vstack([plydata['vertex']['x'],plydata['vertex']['y'],plydata['vertex']['z']]).astype(np.float64).T
face = plydata['face']['vertex_indices']
print(args)
# plot_trimesh(vert,face,"out.png")
# set target curvature
if args.target_curvature:
args.target_curvature = np.loadtxt(args.target_curvature)
else:
# args.target_curvature = np.full((len(vert),),4*np.pi/len(vert)) ## constant curvature with euler char = 2
args.target_curvature = np.full((len(vert),),args.target_curvature_scalar) ## constant curvature with euler char = 2
if len(args.target_curvature) != len(vert):
print("Curvatures and vertices have different length!")
exit(-1)
# determine fixed vertices
args.vert = range(len(vert))
if args.boundary_vertex:
bddat = np.loadtxt(args.boundary_vertex,delimiter=",")
args.fixed_vert = bddat[:,0].astype(np.uint32)
fixed_coords = bddat[:,1:]
else:
args.fixed_vert = np.where( args.target_curvature > 2*np.pi )[0]
fixed_coords = vert[args.fixed_vert]
# np.savetxt("boundary.csv", np.hstack([args.fixed_vert[:,np.newaxis],fixed_coords]),delimiter=",",fmt='%i,%f,%f,%f')
args.free_vert = list(set(args.vert) - set(args.fixed_vert))
if args.constrained_vert:
args.constrained_vert = np.loadtxt(args.constrained_vert).astype(np.uint16)
else:
args.constrained_vert = list(set(args.free_vert) - set(np.where( args.target_curvature == -99 )[0]))
# np.savetxt("cv.txt", args.constrained_vert, fmt='%i')
if args.salt:
vert[args.free_vert] += np.random.randn(*vert[args.free_vert].shape)*1e-4
print("\nvertices {}, faces {}, fixed vertices {}, vertices with target curvature {}".format(len(vert),len(face),len(args.fixed_vert),len(args.constrained_vert)))
if args.batchsize < 0:
args.batchsize = (len(args.constrained_vert)+1) //2
######################################
N = neighbour(len(vert),face)
# ca = compute_curvature(vert,face,np)
ca = compute_curvature_sub(vert,N,args.constrained_vert,verbose=True)
# ca = compute_cos_angle_sub(vert,N,np.zeros(len(vert)),args.vert,np)
print("\n\n Initial Curvature: ", [round(c.item(),5) for c in ca], "\n\n")
coords = L.Parameter(vert)
opt = optim[args.optimizer](args.learning_rate)
opt.setup(coords)
id_iter = chainer.iterators.SerialIterator(chainer.dataset.tabular.from_data(args.constrained_vert),args.batchsize)
if args.gpu >= 0:
coords.to_gpu()
updater = Updater(
models=coords,
iterator=id_iter,
optimizer={'opt': opt},
device=args.gpu,
params={'args': args, 'faces': face, 'N': N, 'fixed_coords': fixed_coords}
)
trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.outdir)
log_interval = 5, 'iteration'
trainer.extend(extensions.LogReport(trigger=log_interval))
if extensions.PlotReport.available():
trainer.extend(extensions.PlotReport(['opt/loss', 'opt/loss_bdv', 'opt/loss_up'],'iteration', file_name='loss.png', postprocess=plot_log))
trainer.extend(extensions.PrintReport([
'iteration', 'lr', 'opt/loss', 'opt/loss_bdv', 'opt/loss_up','elapsed_time',
]),trigger=log_interval)
trainer.extend(extensions.ProgressBar(update_interval=1))
trainer.extend(extensions.observe_lr('opt'), trigger=log_interval)
trainer.extend(extensions.LogReport(trigger=log_interval))
## annealing
if args.optimizer in ['Adam','AdaBound','Eve']:
lr_target = 'eta'
else:
lr_target = 'lr'
trainer.extend(CosineShift(lr_target, args.epoch//2, optimizer=opt), trigger=(1, 'epoch'))
trainer.run()
####################################################
## result
if args.gpu >= 0:
vert2 = coords.W.array.get()
else:
vert2 = coords.W.array
ca_final = compute_curvature_sub(vert2,N,args.constrained_vert,verbose=True)
print("\n\n (final,target) Curvature: ", [(round(ca_final[i].item(),5),args.target_curvature[j]) for i,j in enumerate(args.constrained_vert)])
print("boundary squared-error: ", (np.sum( (fixed_coords-vert2[args.fixed_vert])**2 ) ))
# output
plydata['vertex']['x']=vert2[:,0]
plydata['vertex']['y']=vert2[:,1]
plydata['vertex']['z']=vert2[:,2]
plydata.write(os.path.join(args.outdir,args.output))
# graphs
n = len(ca)
sns.violinplot(x=np.array([0]*n ), y=[c.item() for c in ca_final])
plt.savefig(os.path.join(args.outdir,"curvature_final.png"))
plt.close()
sns.violinplot(x=np.array([0]*n ), y=[c.item() for c in ca])
plt.savefig(os.path.join(args.outdir,"curvature_init.png"))
plt.close()
error = [abs(ca_final[i].item()-args.target_curvature[j]) for i,j in enumerate(args.constrained_vert)]
sns.violinplot(x=np.array([0]*n), y=error, cut=0)
plt.savefig(os.path.join(args.outdir,"error_final.png"))
plt.close()
error = [abs(ca[i].item()-args.target_curvature[j]) for i,j in enumerate(args.constrained_vert)]
sns.violinplot(x=np.array([0]*n), y=error, cut=0)
plt.savefig(os.path.join(args.outdir,"error_init.png"))
plt.close()
def test_gpu_initialize_by_cupy_ndarray(self):
W = cuda.to_gpu(self.W)
p = links.Parameter(W)
self.check(p, cuda.cupy)
def setUp(self):
self.W = numpy.random.uniform(-1, 1, (4, 3)).astype(numpy.float32)
self.link = links.Parameter(self.W)
def __init__(self,
ch=64,
dim_z=128,
bottom_width=4,
activation=F.relu,
n_classes=0,
distribution="normal",
dim_a=1000,
dim_b=1000,
dim_zeta=10000,
T=1,
learned_lr=False,
initial_fast_alpha=0.001,
limit_fast_alpha=0.01,
step_fast_alpha=0.000001):
super(ResNetAuxABGenerator, self).__init__()
initializer = chainer.initializers.GlorotUniform()
self.ch = ch
self.bottom_width = bottom_width
self.activation = activation
self.distribution = distribution
self.dim_z = dim_z
self.dim_zeta = dim_zeta
self.n_classes = n_classes
self.T = T
self.learned_lr = learned_lr
self.initial_fast_alpha = initial_fast_alpha
self.limit_fast_alpha = limit_fast_alpha
self.step_fast_alpha = step_fast_alpha
self.fast_loss = None
with self.init_scope():
# parameters to be slow-updated
self.lA1 = L.Linear(dim_z, dim_a, initialW=initializer)
self.lA2 = L.Linear(dim_a, dim_zeta, initialW=initializer)
self.lB1 = L.Linear(dim_zeta, dim_b, initialW=initializer)
self.lB2 = L.Linear(dim_b, dim_z, initialW=initializer)
self.preluW = L.Parameter(
np.ones((dim_z, ), dtype=np.float32) * 0.25)
self.preluMiddleW = L.Parameter(
np.ones((dim_zeta, ), dtype=np.float32) * 0.25)
# inherited from ResNetGenerator
self.l1 = L.Linear(dim_z, (bottom_width**2) * ch * 16,
initialW=initializer)
self.block2 = Block(ch * 16,
ch * 16,
activation=activation,
upsample=True,
n_classes=n_classes)
self.block3 = Block(ch * 16,
ch * 8,
activation=activation,
upsample=True,
n_classes=n_classes)
self.block4 = Block(ch * 8,
ch * 8,
activation=activation,
upsample=True,
n_classes=n_classes)
self.block5 = Block(ch * 8,
ch * 4,
activation=activation,
upsample=True,
n_classes=n_classes)
self.block6 = Block(ch * 4,
ch * 2,
activation=activation,
upsample=True,
n_classes=n_classes)
self.block7 = Block(ch * 2,
ch,
activation=activation,
upsample=True,
n_classes=n_classes)
self.b8 = L.BatchNormalization(ch)
self.l8 = L.Convolution2D(ch,
3,
ksize=3,
stride=1,
pad=1,
initialW=initializer)
if self.learned_lr:
self._fast_alpha = chainer.links.Parameter(
self.xp.ones((dim_zeta, ), dtype=self.xp.float32) *
initial_fast_alpha)
else:
self._fast_alpha = initial_fast_alpha
def setUp(self):
self.W = numpy.random.uniform(-1, 1, (4, 3)).astype(numpy.float32)
self.gW = numpy.random.uniform(-1, 1,
self.W.shape).astype(numpy.float32)
self.link = links.Parameter(self.W)
self.link.zerograds()
