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()