def __init__(self, depth=9): self.depth = depth depth = 9 train = (3, 32, 32) nfms = [2**(stage + 4) for stage in sorted(list(range(3)) * depth)] strides = [1 if cur == prev else 2 for cur, prev in zip(nfms[1:], nfms[:-1])] # Now construct the network layers = [Conv(**self.conv_params(3, 16))] layers.append(self.module_s1(nfms[0], True)) for nfm, stride in zip(nfms[1:], strides): res_module = self.module_s1(nfm) if stride == 1 else self.module_s2(nfm) layers.append(res_module) layers.append(BatchNorm()) layers.append(Activation(Rectlin())) layers.append(Pooling('all', op='avg')) layers.append(Affine(10, init=Kaiming(local=False), batch_norm=True, activation=Softmax())) self.layers = layers model = Model(layers=layers) cost = GeneralizedCost(costfunc=CrossEntropyMulti()) model.initialize(train, cost=cost) self.model = model
def test_model_get_outputs(backend_default): (X_train, y_train), (X_test, y_test), nclass = load_mnist() train_set = DataIterator(X_train[:backend_default.bsz * 3]) init_norm = Gaussian(loc=0.0, scale=0.1) layers = [Affine(nout=20, init=init_norm, bias=init_norm, activation=Rectlin()), Affine(nout=10, init=init_norm, activation=Logistic(shortcut=True))] mlp = Model(layers=layers) out_list = [] mlp.initialize(train_set) for x, t in train_set: x = mlp.fprop(x) out_list.append(x.get().T.copy()) ref_output = np.vstack(out_list) train_set.reset() output = mlp.get_outputs(train_set) assert np.allclose(output, ref_output)
class TreeModel(object): """ Container for Tree style test model" """ def __init__(self): self.in_shape = (1, 32, 32) init_norm = Gaussian(loc=0.0, scale=0.01) normrelu = dict(init=init_norm, activation=Rectlin()) normsigm = dict(init=init_norm, activation=Logistic(shortcut=True)) normsoft = dict(init=init_norm, activation=Softmax()) # setup model layers b1 = BranchNode(name="b1") b2 = BranchNode(name="b2") p1 = [Affine(nout=100, name="main1", **normrelu), b1, Affine(nout=32, name="main2", **normrelu), Affine(nout=160, name="main3", **normrelu), b2, Affine(nout=32, name="main2", **normrelu), # make next layer big to check sizing Affine(nout=320, name="main2", **normrelu), Affine(nout=10, name="main4", **normsoft)] p2 = [b1, Affine(nout=16, name="branch1_1", **normrelu), Affine(nout=10, name="branch1_2", **normsigm)] p3 = [b2, Affine(nout=16, name="branch2_1", **normrelu), Affine(nout=10, name="branch2_2", **normsigm)] self.cost = Multicost(costs=[GeneralizedCost(costfunc=CrossEntropyMulti()), GeneralizedCost(costfunc=CrossEntropyBinary()), GeneralizedCost(costfunc=CrossEntropyBinary())], weights=[1, 0., 0.]) self.layers = SingleOutputTree([p1, p2, p3], alphas=[1, .2, .2]) self.model = Model(layers=self.layers) self.model.initialize(self.in_shape, cost=self.cost)
def run(be, fake_dilation, fsz, stride, pad, dilation): K = 8 strides = stride padding = pad be.rng = be.gen_rng(be.rng_seed) in_shape = 16 while out_shape(in_shape, fsz, stride, dilation, pad) < 3: in_shape *= 2 train_shape = (1, in_shape, in_shape) inp = be.array(be.rng.randn(np.prod(train_shape), be.bsz)) init = Gaussian() layers = [Conv((5, 5, K), init=init), Conv((fsz, fsz, K), strides=strides, padding=padding, init=init, dilation=dict(dil_d=1, dil_h=dilation, dil_w=dilation)), Conv((3, 3, K), init=init), Affine(nout=1, init=init)] model = Model(layers=layers) cost = GeneralizedCost(costfunc=CrossEntropyBinary()) model.initialize(train_shape, cost) if fake_dilation: # Perform regular convolution with an expanded filter. weights = save(model) new_layers = layers # Replace the middle layers. new_fsz = dilated_fsz(fsz, dilation) new_layers[1] = Conv((new_fsz, new_fsz, K), strides=strides, padding=padding, init=init) model = Model(layers=new_layers) cost = GeneralizedCost(costfunc=CrossEntropyBinary()) model.initialize(train_shape, cost) load(weights, model, K, fsz, dilation) print(model) model.optimizer = GradientDescentMomentum(learning_rate=0.01, momentum_coef=0.9) outputs = fprop(model, inp) weights = bprop(model, outputs) model.optimizer.optimize(model.layers_to_optimize, epoch=0) return outputs.get(), weights.get()
def test_conv_rnn(backend_default): train_shape = (1, 17, 142) be = NervanaObject.be inp = be.array(be.rng.randn(np.prod(train_shape), be.bsz)) delta = be.array(be.rng.randn(10, be.bsz)) init_norm = Gaussian(loc=0.0, scale=0.01) bilstm = DeepBiLSTM(128, init_norm, activation=Rectlin(), gate_activation=Rectlin(), depth=1, reset_cells=True) birnn_1 = DeepBiRNN(128, init_norm, activation=Rectlin(), depth=1, reset_cells=True, batch_norm=False) birnn_2 = DeepBiRNN(128, init_norm, activation=Rectlin(), depth=2, reset_cells=True, batch_norm=False) bibnrnn = DeepBiRNN(128, init_norm, activation=Rectlin(), depth=1, reset_cells=True, batch_norm=True) birnnsum = DeepBiRNN(128, init_norm, activation=Rectlin(), depth=1, reset_cells=True, batch_norm=False, bi_sum=True) rnn = Recurrent(128, init=init_norm, activation=Rectlin(), reset_cells=True) lstm = LSTM(128, init_norm, activation=Rectlin(), gate_activation=Rectlin(), reset_cells=True) gru = GRU(128, init_norm, activation=Rectlin(), gate_activation=Rectlin(), reset_cells=True) rlayers = [bilstm, birnn_1, birnn_2, bibnrnn, birnnsum, rnn, lstm, gru] for rl in rlayers: layers = [ Conv((2, 2, 4), init=init_norm, activation=Rectlin(), strides=dict(str_h=2, str_w=4)), Pooling(2, strides=2), Conv((3, 3, 4), init=init_norm, batch_norm=True, activation=Rectlin(), strides=dict(str_h=1, str_w=2)), rl, RecurrentMean(), Affine(nout=10, init=init_norm, activation=Rectlin()), ] model = Model(layers=layers) cost = GeneralizedCost(costfunc=CrossEntropyBinary()) model.initialize(train_shape, cost) model.fprop(inp) model.bprop(delta)
def test_model_get_outputs(backend_default, data): dataset = MNIST(path=data) train_set = dataset.train_iter init_norm = Gaussian(loc=0.0, scale=0.1) layers = [Affine(nout=20, init=init_norm, bias=init_norm, activation=Rectlin()), Affine(nout=10, init=init_norm, activation=Logistic(shortcut=True))] mlp = Model(layers=layers) out_list = [] mlp.initialize(train_set) for x, t in train_set: x = mlp.fprop(x) out_list.append(x.get().T.copy()) ref_output = np.vstack(out_list) train_set.reset() output = mlp.get_outputs(train_set) assert allclose_with_out(output, ref_output[:output.shape[0], :]) # test model benchmark inference mlp.benchmark(train_set, inference=True, niterations=5)
class MultistreamModel(object): """ Container for a multistream test model """ def __init__(self): self.in_shape = [1024, (2538, 38)] init = Constant(0) image_path = Sequential([Affine(20, init, bias=init), Affine(10, init, bias=init)]) sent_path = Sequential([Affine(30, init, bias=init), Affine(10, init)]) layers = [MergeMultistream(layers=[image_path, sent_path], merge="recurrent"), Dropout(keep=0.5), LSTM(4, init, activation=Logistic(), gate_activation=Tanh(), reset_cells=True), Affine(20, init, bias=init, activation=Softmax())] self.layers = layers self.cost = GeneralizedCostMask(CrossEntropyMulti()) self.model = Model(layers=layers) self.model.initialize(self.in_shape, cost=self.cost)
def __init__(self): self.in_shape = (3, 32, 32) relu = Rectlin() init_use = Constant(0) conv = dict(init=init_use, batch_norm=False, activation=relu) convp1 = dict(init=init_use, batch_norm=False, bias=init_use, activation=relu, padding=1) convp1s2 = dict(init=init_use, batch_norm=False, bias=init_use, padding=1, strides=2) layers = [Dropout(keep=.8), Conv((3, 3, 96), **convp1), Conv((3, 3, 96), **convp1), Conv((3, 3, 96), **convp1s2), Dropout(keep=.5), Conv((3, 3, 192), **convp1), Conv((3, 3, 192), **convp1), Conv((3, 3, 192), **convp1s2), Dropout(keep=.5), Conv((3, 3, 192), **convp1), Conv((1, 1, 192), **conv), Conv((1, 1, 16), **conv), Pooling(8, op="avg"), Activation(Softmax())] self.layers = layers model = Model(layers=layers) cost = GeneralizedCost(costfunc=CrossEntropyMulti()) model.initialize(self.in_shape, cost=cost) self.model = model
# parse the command line arguments parser = NeonArgparser(__doc__) parser.add_argument("hdf5") parser.add_argument("model_pkl") args = parser.parse_args() model = Model(args.model_pkl) h5s = [h5py.File(args.hdf5)] num_moves = sum(h['X'].shape[0] for h in h5s) print("Found {} HDF5 files with {} moves".format(len(h5s), num_moves)) inputs = HDF5Iterator([h['X'] for h in h5s], [h['y'] for h in h5s], ndata=(1024 * 1024)) out_predict = h5s[0].require_dataset("predictions", (num_moves, 362), dtype=np.float32) out_score = h5s[0].require_dataset("scores", (num_moves,), dtype=np.float32) out_max = h5s[0].require_dataset("best", (num_moves,), dtype=np.float32) model.initialize(inputs) for indata, actual, sl in inputs.predict(): prediction = model.fprop(indata, inference=False).get().T actual = actual.astype(int) actual_idx = actual[:, 0] * 19 + actual[:, 1] actual_idx[actual_idx < 0] = 361 out_predict[sl, :] = prediction out_score[sl] = prediction[range(prediction.shape[0]), actual_idx] out_max[sl] = prediction.max(axis=1) print (sl)
nlp = spacy.load('en') pos_tokens = [] for doc in [nlp(t) for t in input_texts]: vec = [pos_vocab[t.tag_.lower()] if t.tag_.lower( ) in pos_vocab else len(pos_vocab) + 1 for t in doc] pos_tokens.append(vec) pos_features, _ = get_paddedXY_sequence( pos_tokens, [], sentence_length=sentence_len, shuffle=False) input_features.append(TaggedTextSequence( sentence_len, pos_features, vec_input=False)) if len(input_features) > 1: x = MultiSequenceDataIterator(input_features, ignore_y=True) else: x = input_features[0] model = Model(args.model) model.initialize(dataset=x) preds = model.get_outputs(x).argmax(2) # print inferred tags and original text print_nps = args.print_only_nps rev_y = {v + 1: k for k, v in mp['y_vocab'].items()} for sen, text in zip(preds, input_texts): text_tokens = text.lower().split() text_tags = [rev_y[i] for i in sen if i > 0] if print_nps is True: print(extract_nps(text_tokens, text_tags)) else: print(list(zip(text_tokens, text_tags)))
def test_model_serialize(backend_default, data): dataset = MNIST(path=data) (X_train, y_train), (X_test, y_test), nclass = dataset.load_data() train_set = ArrayIterator( [X_train, X_train], y_train, nclass=nclass, lshape=(1, 28, 28)) init_norm = Gaussian(loc=0.0, scale=0.01) # initialize model path1 = Sequential([Conv((5, 5, 16), init=init_norm, bias=Constant(0), activation=Rectlin()), Pooling(2), Affine(nout=20, init=init_norm, bias=init_norm, activation=Rectlin())]) path2 = Sequential([Affine(nout=100, init=init_norm, bias=Constant(0), activation=Rectlin()), Dropout(keep=0.5), Affine(nout=20, init=init_norm, bias=init_norm, activation=Rectlin())]) layers = [MergeMultistream(layers=[path1, path2], merge="stack"), Affine(nout=20, init=init_norm, batch_norm=True, activation=Rectlin()), Affine(nout=10, init=init_norm, activation=Logistic(shortcut=True))] tmp_save = 'test_model_serialize_tmp_save.pickle' mlp = Model(layers=layers) mlp.optimizer = GradientDescentMomentum(learning_rate=0.1, momentum_coef=0.9) mlp.cost = GeneralizedCost(costfunc=CrossEntropyBinary()) mlp.initialize(train_set, cost=mlp.cost) n_test = 3 num_epochs = 3 # Train model for num_epochs and n_test batches for epoch in range(num_epochs): for i, (x, t) in enumerate(train_set): x = mlp.fprop(x) delta = mlp.cost.get_errors(x, t) mlp.bprop(delta) mlp.optimizer.optimize(mlp.layers_to_optimize, epoch=epoch) if i > n_test: break # Get expected outputs of n_test batches and states of all layers outputs_exp = [] pdicts_exp = [l.get_params_serialize() for l in mlp.layers_to_optimize] for i, (x, t) in enumerate(train_set): outputs_exp.append(mlp.fprop(x, inference=True)) if i > n_test: break # Serialize model mlp.save_params(tmp_save, keep_states=True) # Load model mlp = Model(tmp_save) mlp.initialize(train_set) outputs = [] pdicts = [l.get_params_serialize() for l in mlp.layers_to_optimize] for i, (x, t) in enumerate(train_set): outputs.append(mlp.fprop(x, inference=True)) if i > n_test: break # Check outputs, states, and params are the same for output, output_exp in zip(outputs, outputs_exp): assert allclose_with_out(output.get(), output_exp.get()) for pd, pd_exp in zip(pdicts, pdicts_exp): for s, s_e in zip(pd['states'], pd_exp['states']): if isinstance(s, list): # this is the batch norm case for _s, _s_e in zip(s, s_e): assert allclose_with_out(_s, _s_e) else: assert allclose_with_out(s, s_e) for p, p_e in zip(pd['params'], pd_exp['params']): assert type(p) == type(p_e) if isinstance(p, list): # this is the batch norm case for _p, _p_e in zip(p, p_e): assert allclose_with_out(_p, _p_e) elif isinstance(p, np.ndarray): assert allclose_with_out(p, p_e) else: assert p == p_e os.remove(tmp_save)
class InceptionModel(object): """ Container for the inception-like test model """ def __init__(self): self.in_shape = (3, 299, 299) self.nout = 100 self.pool3s1p1 = dict(fshape=3, padding=1, strides=1, op='avg') self.pool3s2p0 = dict(fshape=3, strides=2, op='max') layers = self.main_branch(nout=self.nout) self.cost = GeneralizedCost(costfunc=CrossEntropyMulti()) self.model = Model(layers=layers) self.model.initialize(self.in_shape, cost=self.cost) self.layers = layers @staticmethod def conv_params(fsize, nfm, padding='SAME', strides=1, activation=Rectlin(), batch_norm=True): fsize = fsize if isinstance(fsize, tuple) else (fsize, fsize) fshape = fsize + (nfm,) padding = {'pad_h': (fsize[0] // 2 if padding == 'SAME' else 0), 'pad_w': (fsize[1] // 2 if padding == 'SAME' else 0), 'pad_d': 0} strides = {'str_h': strides, 'str_w': strides, 'str_d': 1} return dict(fshape=fshape, strides=strides, activation=activation, padding=padding, batch_norm=batch_norm, init=Kaiming(local=True)) def inception(self, kvals, b2fsz=5): (p1, p2, p3, p4) = kvals branch1 = [Conv(**self.conv_params(1, p1[0], padding=0, strides=1))] branch2 = [Conv(**self.conv_params(1, p2[0], padding=0, strides=1)), Conv(**self.conv_params(b2fsz, p2[1], padding='SAME', strides=1))], branch3 = [Conv(**self.conv_params(1, p3[0], padding=0, strides=1)), Conv(**self.conv_params(3, p3[1], padding='SAME', strides=1)), Conv(**self.conv_params(3, p3[1], padding='SAME', strides=1))] branch4 = [Pooling(**self.pool3s1p1), Conv(**self.conv_params(1, p4[0], padding=0, strides=1))] return MergeBroadcast(layers=[branch1, branch2, branch3, branch4], merge="depth") def inception_inception(self, kvals): (p1, p2, p3, p4) = kvals branch1 = [Conv(**self.conv_params(1, p1[0], padding=0, strides=1))] i2_branch1 = [Conv(**self.conv_params((1, 3), p2[1], padding='SAME', strides=1))] i2_branch2 = [Conv(**self.conv_params((3, 1), p2[1], padding='SAME', strides=1))] branch2 = [Conv(**self.conv_params(1, p2[0], padding=0, strides=1)), MergeBroadcast(layers=[i2_branch1, i2_branch2], merge="depth")] i3_branch1 = [Conv(**self.conv_params((1, 3), p3[2], padding='SAME', strides=1))] i3_branch2 = [Conv(**self.conv_params((3, 1), p3[2], padding='SAME', strides=1))] branch3 = [Conv(**self.conv_params(1, p3[0], padding=0, strides=1)), Conv(**self.conv_params(3, p3[1], padding='SAME', strides=1)), MergeBroadcast(layers=[i3_branch1, i3_branch2], merge="depth")] branch4 = [Pooling(**self.pool3s1p1), Conv(**self.conv_params(1, p4[0], padding=0, strides=1))] return MergeBroadcast(layers=[branch1, branch2, branch3, branch4], merge="depth") def main_branch(self, nout=100): return [Conv(**self.conv_params(3, 32, strides=2, padding=0)), Pooling(**self.pool3s2p0), Conv(**self.conv_params(1, 80, strides=1, padding=0)), Pooling(**self.pool3s2p0), self.inception([(64, ), (48, 64), (64, 96), (32, )], b2fsz=5), self.inception([(64, ), (48, 64), (64, 96), (64, )], b2fsz=5), self.inception_inception([(64, ), (64, 64), (64, 64, 64), (192, )]), self.inception_inception([(64, ), (64, 64), (64, 64, 64), (192, )]), Pooling(fshape='all', strides=1, op="avg"), Dropout(keep=0.8), Conv(**self.conv_params(1, nout, activation=Softmax()))]
class ModelRunnerNeon(): def __init__(self, args, max_action_no, batch_dimension): self.args = args self.train_batch_size = args.train_batch_size self.discount_factor = args.discount_factor self.use_gpu_replay_mem = args.use_gpu_replay_mem self.be = gen_backend(backend='gpu', batch_size=self.train_batch_size) self.input_shape = (batch_dimension[1], batch_dimension[2], batch_dimension[3], batch_dimension[0]) self.input = self.be.empty(self.input_shape) self.input.lshape = self.input_shape # HACK: needed for convolutional networks self.targets = self.be.empty((max_action_no, self.train_batch_size)) if self.use_gpu_replay_mem: self.history_buffer = self.be.zeros(batch_dimension, dtype=np.uint8) self.input_uint8 = self.be.empty(self.input_shape, dtype=np.uint8) else: self.history_buffer = np.zeros(batch_dimension, dtype=np.float32) self.train_net = Model(self.create_layers(max_action_no)) self.cost = GeneralizedCost(costfunc=SumSquared()) # Bug fix for l in self.train_net.layers.layers: l.parallelism = 'Disabled' self.train_net.initialize(self.input_shape[:-1], self.cost) self.target_net = Model(self.create_layers(max_action_no)) # Bug fix for l in self.target_net.layers.layers: l.parallelism = 'Disabled' self.target_net.initialize(self.input_shape[:-1]) if self.args.optimizer == 'Adam': # Adam self.optimizer = Adam(beta_1=args.rms_decay, beta_2=args.rms_decay, learning_rate=args.learning_rate) else: # Neon RMSProp self.optimizer = RMSProp(decay_rate=args.rms_decay, learning_rate=args.learning_rate) self.max_action_no = max_action_no self.running = True def get_initializer(self, input_size): dnnInit = self.args.dnn_initializer if dnnInit == 'xavier': initializer = Xavier() elif dnnInit == 'fan_in': std_dev = 1.0 / math.sqrt(input_size) initializer = Uniform(low=-std_dev, high=std_dev) else: initializer = Gaussian(0, 0.01) return initializer def create_layers(self, max_action_no): layers = [] initializer = self.get_initializer(input_size = 4 * 8 * 8) layers.append(Conv(fshape=(8, 8, 32), strides=4, init=initializer, bias=initializer, activation=Rectlin())) initializer = self.get_initializer(input_size = 32 * 4 * 4) layers.append(Conv(fshape=(4, 4, 64), strides=2, init=initializer, bias=initializer, activation=Rectlin())) initializer = self.get_initializer(input_size = 64 * 3 * 3) layers.append(Conv(fshape=(3, 3, 64), strides=1, init=initializer, bias=initializer, activation=Rectlin())) initializer = self.get_initializer(input_size = 7 * 7 * 64) layers.append(Affine(nout=512, init=initializer, bias=initializer, activation=Rectlin())) initializer = self.get_initializer(input_size = 512) layers.append(Affine(nout=max_action_no, init=initializer, bias=initializer)) return layers def clip_reward(self, reward): if reward > self.args.clip_reward_high: return self.args.clip_reward_high elif reward < self.args.clip_reward_low: return self.args.clip_reward_low else: return reward def set_input(self, data): if self.use_gpu_replay_mem: self.be.copy_transpose(data, self.input_uint8, axes=(1, 2, 3, 0)) self.input[:] = self.input_uint8 / 255 else: self.input.set(data.transpose(1, 2, 3, 0).copy()) self.be.divide(self.input, 255, self.input) def predict(self, history_buffer): self.set_input(history_buffer) output = self.train_net.fprop(self.input, inference=True) return output.T.asnumpyarray()[0] def print_weights(self): pass def train(self, minibatch, replay_memory, learning_rate, debug): if self.args.prioritized_replay == True: prestates, actions, rewards, poststates, terminals, replay_indexes, heap_indexes, weights = minibatch else: prestates, actions, rewards, poststates, terminals = minibatch # Get Q*(s, a) with targetNet self.set_input(poststates) post_qvalue = self.target_net.fprop(self.input, inference=True).T.asnumpyarray() if self.args.double_dqn == True: # Get Q*(s, a) with trainNet post_qvalue2 = self.train_net.fprop(self.input, inference=True).T.asnumpyarray() # Get Q(s, a) with trainNet self.set_input(prestates) pre_qvalue = self.train_net.fprop(self.input, inference=False) label = pre_qvalue.asnumpyarray().copy() for i in range(0, self.train_batch_size): if self.args.clip_reward: reward = self.clip_reward(rewards[i]) else: reward = rewards[i] if terminals[i]: label[actions[i], i] = reward else: if self.args.double_dqn == True: max_index = np.argmax(post_qvalue2[i]) label[actions[i], i] = reward + self.discount_factor* post_qvalue[i][max_index] else: label[actions[i], i] = reward + self.discount_factor* np.max(post_qvalue[i]) # copy targets to GPU memory self.targets.set(label) delta = self.cost.get_errors(pre_qvalue, self.targets) if self.args.prioritized_replay == True: delta_value = delta.asnumpyarray() for i in range(self.train_batch_size): if debug: print 'weight[%s]: %.5f, delta: %.5f, newDelta: %.5f' % (i, weights[i], delta_value[actions[i], i], weights[i] * delta_value[actions[i], i]) replay_memory.update_td(heap_indexes[i], abs(delta_value[actions[i], i])) delta_value[actions[i], i] = weights[i] * delta_value[actions[i], i] delta.set(delta_value.copy()) if self.args.clip_loss: self.be.clip(delta, -1.0, 1.0, out = delta) self.train_net.bprop(delta) self.optimizer.optimize(self.train_net.layers_to_optimize, epoch=0) def update_model(self): # have to serialize also states for batch normalization to work pdict = self.train_net.get_description(get_weights=True, keep_states=True) self.target_net.deserialize(pdict, load_states=True) #print ('Updated target model') def finish_train(self): self.running = False def load(self, file_name): self.train_net.load_params(file_name) self.update_model() def save(self, file_name): self.train_net.save_params(file_name)
class DeepQNetwork: def __init__(self, state_size, num_actions, args): # remember parameters self.state_size = state_size self.num_actions = num_actions self.batch_size = args.batch_size self.discount_rate = args.discount_rate self.clip_error = args.clip_error self.action_count = np.zeros(21) # create Neon backend self.be = gen_backend(backend = args.backend, batch_size = args.batch_size, rng_seed = args.random_seed, device_id = args.device_id, datatype = np.dtype(args.datatype).type, stochastic_round = args.stochastic_round) # prepare tensors once and reuse them self.input_shape = (self.state_size, self.batch_size) self.input = self.be.empty(self.input_shape) self.targets = self.be.empty((self.num_actions, self.batch_size)) # create model layers = self._createLayers(num_actions) self.model = Model(layers = layers) self.cost = GeneralizedCost(costfunc = SumSquared()) self.model.initialize(self.input_shape[:-1], self.cost) if args.optimizer == 'rmsprop': self.optimizer = RMSProp(learning_rate = args.learning_rate, decay_rate = args.decay_rate, stochastic_round = args.stochastic_round) elif args.optimizer == 'adam': self.optimizer = Adam(learning_rate = args.learning_rate, stochastic_round = args.stochastic_round) elif args.optimizer == 'adadelta': self.optimizer = Adadelta(decay = args.decay_rate, stochastic_round = args.stochastic_round) else: assert False, "Unknown optimizer" # create target model self.target_steps = args.target_steps self.train_iterations = 0 if self.target_steps: self.target_model = Model(layers = self._createLayers(num_actions)) self.target_model.initialize(self.input_shape[:-1]) self.save_weights_prefix = args.save_weights_prefix else: self.target_model = self.model def _createLayers(self, num_actions): # create network init_norm = Gaussian(loc=0.0, scale=0.01) layers = [] # The final hidden layer is fully-connected and consists of 512 rectifier units. layers.append(Affine(nout=64, init=init_norm, bias=init_norm, activation=Rectlin())) # The output layer is a fully-connected linear layer with a single output for each valid action. layers.append(Affine(nout=num_actions, init=init_norm, bias=init_norm)) return layers def _setInput(self, states): # change order of axes to match what Neon expects states = np.transpose(states) # copy() shouldn't be necessary here, but Neon doesn't work otherwise self.input.set(states.copy()) # normalize network input between 0 and 1 # self.be.divide(self.input, 255, self.input) def train(self, minibatch, epoch): # expand components of minibatch prestates, actions, speed_actions, rewards, poststates, terminals = minibatch assert len(prestates.shape) == 2 assert len(poststates.shape) == 2 assert len(actions.shape) == 1 assert len(rewards.shape) == 1 assert len(terminals.shape) == 1 assert prestates.shape == poststates.shape assert prestates.shape[0] == actions.shape[0] == rewards.shape[0] == poststates.shape[0] == terminals.shape[0] #print "WE ARE ACTUALLY TRAINING IN HERE" if self.target_steps and self.train_iterations % self.target_steps == 0: # HACK: serialize network to disk and read it back to clone filename = self.save_weights_prefix + "_target.pkl" save_obj(self.model.serialize(keep_states = False), filename) self.target_model.load_weights(filename) # feed-forward pass for poststates to get Q-values self._setInput(poststates) postq = self.target_model.fprop(self.input, inference = True) assert postq.shape == (self.num_actions, self.batch_size) # calculate max Q-value for each poststate postq = postq.asnumpyarray() maxpostq = np.max(postq, axis=0) #print maxpostq.shape assert maxpostq.shape == (self.batch_size,) # feed-forward pass for prestates self._setInput(prestates) preq = self.model.fprop(self.input, inference = False) assert preq.shape == (self.num_actions, self.batch_size) # make copy of prestate Q-values as targets targets = preq.asnumpyarray().copy() # update Q-value targets for actions taken for i, action in enumerate(actions): self.action_count[action] += 1 if terminals[i]: targets[action, i] = float(rewards[i]) if rewards[i] == -1000: print "######################### action ", action, "should never be sampled again" print "sampled_terminal" else: targets[action, i] = float(rewards[i]) + self.discount_rate * maxpostq[i] #targets[i,action] = float(rewards[i]) + self.discount_rate * maxpostq[i] #print "action count", self.action_count # copy targets to GPU memory self.targets.set(targets) # calculate errors deltas = self.cost.get_errors(preq, self.targets) assert deltas.shape == (self.num_actions, self.batch_size) #assert np.count_nonzero(deltas.asnumpyarray()) == 32 print "nonzero deltas", np.count_nonzero(deltas.asnumpyarray()) # calculate cost, just in case cost = self.cost.get_cost(preq, self.targets) assert cost.shape == (1,1) print "cost:", cost.asnumpyarray() # clip errors #if self.clip_error: # self.be.clip(deltas, -self.clip_error, self.clip_error, out = deltas) # perform back-propagation of gradients self.model.bprop(deltas) # perform optimization self.optimizer.optimize(self.model.layers_to_optimize, epoch) # increase number of weight updates (needed for target clone interval) self.train_iterations += 1 def predict(self, states): # minibatch is full size, because Neon doesn't let change the minibatch size assert states.shape == (self.batch_size, self.state_size) # calculate Q-values for the states self._setInput(states) qvalues = self.model.fprop(self.input, inference = True) assert qvalues.shape == (self.num_actions, self.batch_size) if logger.isEnabledFor(logging.DEBUG): logger.debug("Q-values: " + str(qvalues.asnumpyarray()[:,0])) # transpose the result, so that batch size is first dimension return qvalues.T.asnumpyarray() def load_weights(self, load_path): self.model.load_weights(load_path) def save_weights(self, save_path): save_obj(self.model.serialize(keep_states = True), save_path)
class DeepQNetwork: def __init__(self, num_actions, args): # remember parameters self.num_actions = num_actions self.batch_size = args.batch_size self.discount_rate = args.discount_rate self.history_length = args.history_length self.screen_dim = (args.screen_height, args.screen_width) self.clip_error = args.clip_error self.min_reward = args.min_reward self.max_reward = args.max_reward self.batch_norm = args.batch_norm # create Neon backend self.be = gen_backend(backend = args.backend, batch_size = args.batch_size, rng_seed = args.random_seed, device_id = args.device_id, datatype = np.dtype(args.datatype).type, stochastic_round = args.stochastic_round) # prepare tensors once and reuse them self.input_shape = (self.history_length,) + self.screen_dim + (self.batch_size,) self.input = self.be.empty(self.input_shape) self.input.lshape = self.input_shape # HACK: needed for convolutional networks self.targets = self.be.empty((self.num_actions, self.batch_size)) # create model layers = self._createLayers(num_actions) self.model = Model(layers = layers) self.cost = GeneralizedCost(costfunc = SumSquared()) # Bug fix for l in self.model.layers.layers: l.parallelism = 'Disabled' self.model.initialize(self.input_shape[:-1], self.cost) if args.optimizer == 'rmsprop': self.optimizer = RMSProp(learning_rate = args.learning_rate, decay_rate = args.decay_rate, stochastic_round = args.stochastic_round) elif args.optimizer == 'adam': self.optimizer = Adam(learning_rate = args.learning_rate, stochastic_round = args.stochastic_round) elif args.optimizer == 'adadelta': self.optimizer = Adadelta(decay = args.decay_rate, stochastic_round = args.stochastic_round) else: assert false, "Unknown optimizer" # create target model self.train_iterations = 0 if args.target_steps: self.target_model = Model(layers = self._createLayers(num_actions)) # Bug fix for l in self.target_model.layers.layers: l.parallelism = 'Disabled' self.target_model.initialize(self.input_shape[:-1]) self.save_weights_prefix = args.save_weights_prefix else: self.target_model = self.model self.callback = None def _createLayers(self, num_actions): # create network init_xavier_conv = Xavier(local=True) init_xavier_affine = Xavier(local=False) layers = [] # The first hidden layer convolves 32 filters of 8x8 with stride 4 with the input image and applies a rectifier nonlinearity. layers.append(Conv((8, 8, 32), strides=4, init=init_xavier_conv, activation=Rectlin(), batch_norm=self.batch_norm)) # The second hidden layer convolves 64 filters of 4x4 with stride 2, again followed by a rectifier nonlinearity. layers.append(Conv((4, 4, 64), strides=2, init=init_xavier_conv, activation=Rectlin(), batch_norm=self.batch_norm)) # This is followed by a third convolutional layer that convolves 64 filters of 3x3 with stride 1 followed by a rectifier. layers.append(Conv((3, 3, 64), strides=1, init=init_xavier_conv, activation=Rectlin(), batch_norm=self.batch_norm)) # The final hidden layer is fully-connected and consists of 512 rectifier units. layers.append(Affine(nout=512, init=init_xavier_affine, activation=Rectlin(), batch_norm=self.batch_norm)) # The output layer is a fully-connected linear layer with a single output for each valid action. layers.append(Affine(nout=num_actions, init = init_xavier_affine)) return layers def _setInput(self, states): # change order of axes to match what Neon expects states = np.transpose(states, axes = (1, 2, 3, 0)) # copy() shouldn't be necessary here, but Neon doesn't work otherwise self.input.set(states.copy()) # normalize network input between 0 and 1 self.be.divide(self.input, 255, self.input) def update_target_network(self): # have to serialize also states for batch normalization to work pdict = self.model.get_description(get_weights=True, keep_states=True) self.target_model.deserialize(pdict, load_states=True) def train(self, minibatch, epoch): # expand components of minibatch prestates, actions, rewards, poststates, terminals = minibatch assert len(prestates.shape) == 4 assert len(poststates.shape) == 4 assert len(actions.shape) == 1 assert len(rewards.shape) == 1 assert len(terminals.shape) == 1 assert prestates.shape == poststates.shape assert prestates.shape[0] == actions.shape[0] == rewards.shape[0] == poststates.shape[0] == terminals.shape[0] # feed-forward pass for poststates to get Q-values self._setInput(poststates) postq = self.target_model.fprop(self.input, inference = True) assert postq.shape == (self.num_actions, self.batch_size) # calculate max Q-value for each poststate maxpostq = self.be.max(postq, axis=0).asnumpyarray() assert maxpostq.shape == (1, self.batch_size) # feed-forward pass for prestates self._setInput(prestates) preq = self.model.fprop(self.input, inference = False) assert preq.shape == (self.num_actions, self.batch_size) # make copy of prestate Q-values as targets targets = preq.asnumpyarray().copy() # clip rewards between -1 and 1 rewards = np.clip(rewards, self.min_reward, self.max_reward) # update Q-value targets for actions taken for i, action in enumerate(actions): if terminals[i]: targets[action, i] = float(rewards[i]) else: targets[action, i] = float(rewards[i]) + self.discount_rate * maxpostq[0,i] # copy targets to GPU memory self.targets.set(targets) # calculate errors deltas = self.cost.get_errors(preq, self.targets) assert deltas.shape == (self.num_actions, self.batch_size) #assert np.count_nonzero(deltas.asnumpyarray()) == 32 # calculate cost, just in case cost = self.cost.get_cost(preq, self.targets) assert cost.shape == (1,1) # clip errors if self.clip_error: self.be.clip(deltas, -self.clip_error, self.clip_error, out = deltas) # perform back-propagation of gradients self.model.bprop(deltas) # perform optimization self.optimizer.optimize(self.model.layers_to_optimize, epoch) # increase number of weight updates (needed for stats callback) self.train_iterations += 1 # calculate statistics if self.callback: self.callback.on_train(cost[0,0]) def predict(self, states): # minibatch is full size, because Neon doesn't let change the minibatch size assert states.shape == ((self.batch_size, self.history_length,) + self.screen_dim) # calculate Q-values for the states self._setInput(states) qvalues = self.model.fprop(self.input, inference = True) assert qvalues.shape == (self.num_actions, self.batch_size) if logger.isEnabledFor(logging.DEBUG): logger.debug("Q-values: " + str(qvalues.asnumpyarray()[:,0])) # transpose the result, so that batch size is first dimension return qvalues.T.asnumpyarray() def load_weights(self, load_path): self.model.load_params(load_path) def save_weights(self, save_path): self.model.save_params(save_path)
class ModelRunnerNeon(): def __init__(self, args, max_action_no, batch_dimension): self.args = args self.train_batch_size = args.train_batch_size self.discount_factor = args.discount_factor self.use_gpu_replay_mem = args.use_gpu_replay_mem self.be = gen_backend(backend='gpu', batch_size=self.train_batch_size) self.input_shape = (batch_dimension[1], batch_dimension[2], batch_dimension[3], batch_dimension[0]) self.input = self.be.empty(self.input_shape) self.input.lshape = self.input_shape # HACK: needed for convolutional networks self.targets = self.be.empty((max_action_no, self.train_batch_size)) if self.use_gpu_replay_mem: self.history_buffer = self.be.zeros(batch_dimension, dtype=np.uint8) self.input_uint8 = self.be.empty(self.input_shape, dtype=np.uint8) else: self.history_buffer = np.zeros(batch_dimension, dtype=np.float32) self.train_net = Model(self.create_layers(max_action_no)) self.cost = GeneralizedCost(costfunc=SumSquared()) # Bug fix for l in self.train_net.layers.layers: l.parallelism = 'Disabled' self.train_net.initialize(self.input_shape[:-1], self.cost) self.target_net = Model(self.create_layers(max_action_no)) # Bug fix for l in self.target_net.layers.layers: l.parallelism = 'Disabled' self.target_net.initialize(self.input_shape[:-1]) if self.args.optimizer == 'Adam': # Adam self.optimizer = Adam(beta_1=args.rms_decay, beta_2=args.rms_decay, learning_rate=args.learning_rate) else: # Neon RMSProp self.optimizer = RMSProp(decay_rate=args.rms_decay, learning_rate=args.learning_rate) self.max_action_no = max_action_no self.running = True def get_initializer(self, input_size): dnnInit = self.args.dnn_initializer if dnnInit == 'xavier': initializer = Xavier() elif dnnInit == 'fan_in': std_dev = 1.0 / math.sqrt(input_size) initializer = Uniform(low=-std_dev, high=std_dev) else: initializer = Gaussian(0, 0.01) return initializer def create_layers(self, max_action_no): layers = [] initializer = self.get_initializer(input_size=4 * 8 * 8) layers.append( Conv(fshape=(8, 8, 32), strides=4, init=initializer, bias=initializer, activation=Rectlin())) initializer = self.get_initializer(input_size=32 * 4 * 4) layers.append( Conv(fshape=(4, 4, 64), strides=2, init=initializer, bias=initializer, activation=Rectlin())) initializer = self.get_initializer(input_size=64 * 3 * 3) layers.append( Conv(fshape=(3, 3, 64), strides=1, init=initializer, bias=initializer, activation=Rectlin())) initializer = self.get_initializer(input_size=7 * 7 * 64) layers.append( Affine(nout=512, init=initializer, bias=initializer, activation=Rectlin())) initializer = self.get_initializer(input_size=512) layers.append( Affine(nout=max_action_no, init=initializer, bias=initializer)) return layers def clip_reward(self, reward): if reward > self.args.clip_reward_high: return self.args.clip_reward_high elif reward < self.args.clip_reward_low: return self.args.clip_reward_low else: return reward def set_input(self, data): if self.use_gpu_replay_mem: self.be.copy_transpose(data, self.input_uint8, axes=(1, 2, 3, 0)) self.input[:] = self.input_uint8 / 255 else: self.input.set(data.transpose(1, 2, 3, 0).copy()) self.be.divide(self.input, 255, self.input) def predict(self, history_buffer): self.set_input(history_buffer) output = self.train_net.fprop(self.input, inference=True) return output.T.asnumpyarray()[0] def print_weights(self): pass def train(self, minibatch, replay_memory, learning_rate, debug): if self.args.prioritized_replay == True: prestates, actions, rewards, poststates, terminals, replay_indexes, heap_indexes, weights = minibatch else: prestates, actions, rewards, poststates, terminals = minibatch # Get Q*(s, a) with targetNet self.set_input(poststates) post_qvalue = self.target_net.fprop(self.input, inference=True).T.asnumpyarray() if self.args.double_dqn == True: # Get Q*(s, a) with trainNet post_qvalue2 = self.train_net.fprop( self.input, inference=True).T.asnumpyarray() # Get Q(s, a) with trainNet self.set_input(prestates) pre_qvalue = self.train_net.fprop(self.input, inference=False) label = pre_qvalue.asnumpyarray().copy() for i in range(0, self.train_batch_size): if self.args.clip_reward: reward = self.clip_reward(rewards[i]) else: reward = rewards[i] if terminals[i]: label[actions[i], i] = reward else: if self.args.double_dqn == True: max_index = np.argmax(post_qvalue2[i]) label[actions[i], i] = reward + self.discount_factor * post_qvalue[i][ max_index] else: label[actions[i], i] = reward + self.discount_factor * np.max( post_qvalue[i]) # copy targets to GPU memory self.targets.set(label) delta = self.cost.get_errors(pre_qvalue, self.targets) if self.args.prioritized_replay == True: delta_value = delta.asnumpyarray() for i in range(self.train_batch_size): if debug: print 'weight[%s]: %.5f, delta: %.5f, newDelta: %.5f' % ( i, weights[i], delta_value[actions[i], i], weights[i] * delta_value[actions[i], i]) replay_memory.update_td(heap_indexes[i], abs(delta_value[actions[i], i])) delta_value[actions[i], i] = weights[i] * delta_value[actions[i], i] delta.set(delta_value.copy()) if self.args.clip_loss: self.be.clip(delta, -1.0, 1.0, out=delta) self.train_net.bprop(delta) self.optimizer.optimize(self.train_net.layers_to_optimize, epoch=0) def update_model(self): # have to serialize also states for batch normalization to work pdict = self.train_net.get_description(get_weights=True, keep_states=True) self.target_net.deserialize(pdict, load_states=True) #print ('Updated target model') def finish_train(self): self.running = False def load(self, file_name): self.train_net.load_params(file_name) self.update_model() def save(self, file_name): self.train_net.save_params(file_name)
Affine(train_set.nfeatures, init, bias=init, activation=Identity()) ] else: layers = [ LSTM(recurrent_units, init, activation=Logistic(), gate_activation=Tanh(), reset_cells=False), RecurrentLast(), Affine(train_set.nfeatures, init, bias=init, activation=Identity()) ] model_new = Model(layers=layers) model_new.load_params(args.save_path) model_new.initialize(dataset=(train_set.nfeatures, seq_len)) num_predict = 200 seed_seq_len = 30 output = np.zeros((train_set.nfeatures, num_predict)) seed = time_series.train[:seed_seq_len] x = model_new.be.empty((train_set.nfeatures, seq_len)) for s_in in seed: x.set(s_in.reshape(train_set.nfeatures, seq_len)) y = model_new.fprop(x, inference=False) for i in range(num_predict): # Take last prediction and feed into next fprop pred = y.get()[:, -1]
padding=0, strides=1, init=init_uni, bias=Constant(0), activation=Tanh())) layers.append(Pooling(2, strides=2, op='max')) layers.append(Affine(nout=500, init=init_norm, activation=Rectlin())) layers.append(Affine(nout=config.ydim, init=init_norm, activation=Softmax())) # setup cost function as CrossEntropy cost = GeneralizedCost(costfunc=CrossEntropyMulti()) # initialize model object network = Model(layers=layers) network.cost = cost network.initialize(data, cost) if config.backend == 'gpu': start = drv.Event() end = drv.Event() num_iterations = config.num_warmup_iters + config.num_timing_iters forward_time = np.zeros(config.num_timing_iters) backward_time = np.zeros(config.num_timing_iters) iter = 0 flag = True while flag: for (x, t) in data: iter += 1 if iter > num_iterations: flag = False break
class DQNNeon(Learner): """ This class is an implementation of the DQN network based on Neon. The modules that interact with the agent, the replay memory and the statistic calls are implemented here, taking the individual requirements of the Lasagne framework into account. The code is adapted from: https://github.com/tambetm/simple_dqn Attributes: input_shape (tuple[int]): Dimension of the network input. dummy_batch (numpy.ndarray): Dummy batche used to calculate Q-values for single states. batch_norm (bool): Indicates if normalization is wanted for a certain layer (default=False). be (neon.backends.nervanagpu.NervanaGPU): Describes the backend for the Neon implementation. input (neon.backends.nervanagpu.GPUTensor): Definition of network input shape. targets(neon.backends.nervanagpu.GPUTensor): Definition of network output shape. model (neon.models.model.Model): Generated Neon model. target_model (neon.models.model.Model): Generated target Neon model. cost_func (neon.layers.layer.GeneralizedCost): Cost function for model training. callback (Statistics): Hook for the statistics object to pass train and test information. Note: More attributes of this class are defined in the base class Learner. """ def __init__(self, env, args, rng, name = "DQNNeon"): """ Initializes a network based on the Neon framework. Args: env (AtariEnv): The envirnoment in which the agent actuates. args (argparse.Namespace): All settings either with a default value or set via command line arguments. rng (mtrand.RandomState): initialized Mersenne Twister pseudo-random number generator. name (str): The name of the network object. Note: This function should always call the base class first to initialize the common values for the networks. """ _logger.info("Initializing new object of type " + str(type(self).__name__)) super(DQNNeon, self).__init__(env, args, rng, name) self.input_shape = (self.sequence_length,) + self.frame_dims + (self.batch_size,) self.dummy_batch = np.zeros((self.batch_size, self.sequence_length) + self.frame_dims, dtype=np.uint8) self.batch_norm = args.batch_norm self.be = gen_backend( backend = args.backend, batch_size = args.batch_size, rng_seed = args.random_seed, device_id = args.device_id, datatype = np.dtype(args.datatype).type, stochastic_round = args.stochastic_round) # prepare tensors once and reuse them self.input = self.be.empty(self.input_shape) self.input.lshape = self.input_shape # HACK: needed for convolutional networks self.targets = self.be.empty((self.output_shape, self.batch_size)) # create model layers = self._create_layer() self.model = Model(layers = layers) self.cost_func = GeneralizedCost(costfunc = SumSquared()) # Bug fix for l in self.model.layers.layers: l.parallelism = 'Disabled' self.model.initialize(self.input_shape[:-1], self.cost_func) self._set_optimizer() if not self.args.load_weights == None: self.load_weights(self.args.load_weights) # create target model if self.target_update_frequency: layers = self._create_layer() self.target_model = Model(layers) # Bug fix for l in self.target_model.layers.layers: l.parallelism = 'Disabled' self.target_model.initialize(self.input_shape[:-1]) else: self.target_model = self.model self.callback = None _logger.debug("%s" % self) def _create_layer(self): """ Build a network consistent with the DeepMind Nature paper. """ _logger.debug("Output shape = %d" % self.output_shape) # create network init_norm = Gaussian(loc=0.0, scale=0.01) layers = [] # The first hidden layer convolves 32 filters of 8x8 with stride 4 with the input image and applies a rectifier nonlinearity. layers.append( Conv((8, 8, 32), strides=4, init=init_norm, activation=Rectlin(), batch_norm=self.batch_norm)) # The second hidden layer convolves 64 filters of 4x4 with stride 2, again followed by a rectifier nonlinearity. layers.append( Conv((4, 4, 64), strides=2, init=init_norm, activation=Rectlin(), batch_norm=self.batch_norm)) # This is followed by a third convolutional layer that convolves 64 filters of 3x3 with stride 1 followed by a rectifier. layers.append( Conv((3, 3, 64), strides=1, init=init_norm, activation=Rectlin(), batch_norm=self.batch_norm)) # The final hidden layer is fully-connected and consists of 512 rectifier units. layers.append( Affine( nout=512, init=init_norm, activation=Rectlin(), batch_norm=self.batch_norm)) # The output layer is a fully-connected linear layer with a single output for each valid action. layers.append( Affine( nout= self.output_shape, init = init_norm)) return layers def _set_optimizer(self): """ Initializes the selected optimization algorithm. """ _logger.debug("Optimizer = %s" % str(self.args.optimizer)) if self.args.optimizer == 'rmsprop': self.optimizer = RMSProp( learning_rate = self.args.learning_rate, decay_rate = self.args.decay_rate, stochastic_round = self.args.stochastic_round) elif self.args.optimizer == 'adam': self.optimizer = Adam( learning_rate = self.args.learning_rate, stochastic_round = self.args.stochastic_round) elif self.args.optimizer == 'adadelta': self.optimizer = Adadelta( decay = self.args.decay_rate, stochastic_round = self.args.stochastic_round) else: assert false, "Unknown optimizer" def _prepare_network_input(self, states): """ Transforms and normalizes the states from one minibatch. Args: states (): a set of states with the size of minibatch """ _logger.debug("Normalizing and transforming input") # change order of axes to match what Neon expects states = np.transpose(states, axes = (1, 2, 3, 0)) # copy() shouldn't be necessary here, but Neon doesn't work otherwise self.input.set(states.copy()) # normalize network input between 0 and 1 self.be.divide(self.input, self.grayscales, self.input) def train(self, minibatch, epoch): """ Prepare, perform and document a complete train step for one minibatch. Args: minibatch (numpy.ndarray): Mini-batch of states, shape=(batch_size,sequence_length,frame_width,frame_height) epoch (int): Current train epoch """ _logger.debug("Complete trainig step for one minibatch") prestates, actions, rewards, poststates, terminals = minibatch assert len(prestates.shape) == 4 assert len(poststates.shape) == 4 assert len(actions.shape) == 1 assert len(rewards.shape) == 1 assert len(terminals.shape) == 1 assert prestates.shape == poststates.shape assert prestates.shape[0] == actions.shape[0] == rewards.shape[0] == poststates.shape[0] == terminals.shape[0] # feed-forward pass for poststates to get Q-values self._prepare_network_input(poststates) postq = self.target_model.fprop(self.input, inference = True) assert postq.shape == (self.output_shape, self.batch_size) # calculate max Q-value for each poststate maxpostq = self.be.max(postq, axis=0).asnumpyarray() assert maxpostq.shape == (1, self.batch_size) # average maxpostq for stats maxpostq_avg = maxpostq.mean() # feed-forward pass for prestates self._prepare_network_input(prestates) preq = self.model.fprop(self.input, inference = False) assert preq.shape == (self.output_shape, self.batch_size) # make copy of prestate Q-values as targets targets = preq.asnumpyarray() # clip rewards between -1 and 1 rewards = np.clip(rewards, self.min_reward, self.max_reward) # update Q-value targets for each state only at actions taken for i, action in enumerate(actions): if terminals[i]: targets[action, i] = float(rewards[i]) else: targets[action, i] = float(rewards[i]) + self.discount_rate * maxpostq[0,i] # copy targets to GPU memory self.targets.set(targets) # calculate errors errors = self.cost_func.get_errors(preq, self.targets) assert errors.shape == (self.output_shape, self.batch_size) # average error where there is a error (should be 1 in every row) #TODO: errors_avg = np.sum(errors)/np.size(errors[errors>0.]) # clip errors if self.clip_error: self.be.clip(errors, -self.clip_error, self.clip_error, out = errors) # calculate cost, just in case cost = self.cost_func.get_cost(preq, self.targets) assert cost.shape == (1,1) # perform back-propagation of gradients self.model.bprop(errors) # perform optimization self.optimizer.optimize(self.model.layers_to_optimize, epoch) # increase number of weight updates (needed for target clone interval) self.update_iterations += 1 if self.target_update_frequency and self.update_iterations % self.target_update_frequency == 0: self._copy_theta() _logger.info("Network update #%d: Cost = %s, Avg Max Q-value = %s" % (self.update_iterations, str(cost.asnumpyarray()[0][0]), str(maxpostq_avg))) # update statistics if self.callback: self.callback.from_learner(cost.asnumpyarray()[0,0], maxpostq_avg) def get_Q(self, state): """ Calculates the Q-values for one mini-batch. Args: state(numpy.ndarray): Single state, shape=(sequence_length,frame_width,frame_height). Returns: q_values (numpy.ndarray): Results for first element of mini-batch from one forward pass through the network, shape=(self.output_shape,) """ _logger.debug("State shape = %s" % str(state.shape)) # minibatch is full size, because Neon doesn't let change the minibatch size # so we need to run 32 forward steps to get the one we actually want self.dummy_batch[0] = state states = self.dummy_batch assert states.shape == ((self.batch_size, self.sequence_length,) + self.frame_dims) # calculate Q-values for the states self._prepare_network_input(states) qvalues = self.model.fprop(self.input, inference = True) assert qvalues.shape == (self.output_shape, self.batch_size) _logger.debug("Qvalues: %s" % (str(qvalues.asnumpyarray()[:,0]))) return qvalues.asnumpyarray()[:,0] def _copy_theta(self): """ Copies the weights of the current network to the target network. """ _logger.debug("Copying weights") pdict = self.model.get_description(get_weights=True, keep_states=True) self.target_model.deserialize(pdict, load_states=True) def save_weights(self, target_dir, epoch): """ Saves the current network parameters to disk. Args: target_dir (str): Directory where the network parameters are stored for each episode. epoch (int): Current epoch. """ filename = "%s_%s_%s_%d.prm" % (str(self.args.game.lower()), str(self.args.net_type.lower()), str(self.args.optimizer.lower()), (epoch + 1)) self.model.save_params(os.path.join(target_dir, filename)) def load_weights(self, source_file): """ Loads the network parameters from a given file. Args: source_file (str): Complete path to a file with network parameters. """ self.model.load_params(source_file)
init_glorot, activation=Tanh(), gate_activation=Logistic(), reset_cells=True), RecurrentSum(), Dropout(keep=0.5), Affine(nclass, init_glorot, bias=init_glorot, activation=Softmax()) ] # load the weights print("Initialized the models - ") model_new = Model(layers=layers) print("Loading the weights from {0}".format(args.model_weights)) model_new.load_params(args.model_weights) model_new.initialize(dataset=(sentence_length, batch_size)) # setup buffers before accepting reviews xdev = be.zeros((sentence_length, 1), dtype=np.int32) # bsz is 1, feature size xbuf = np.zeros((1, sentence_length), dtype=np.int32) oov = 2 start = 1 index_from = 3 pad_char = 0 vocab, rev_vocab = pickle.load(open(args.vocab_file, 'rb')) while True: line = input('Enter a Review from testData.tsv file \n') # clean the input tokens = clean_string(line).strip().split()
class Vectorizer: model = None layer = None patch_width = None patch_height = None backend = None cores = None generated_backend_object= None def __init__(self, prm_path=default_prm_path, layer=-4, backend='gpu', cores=32): print 'Log::Vectorizer:: Initialising Vectorizer' self.layer = layer if not os.path.isfile(prm_path): raise Exception('FileNotFound: Cannot find the file %s' % prm_path) print 'Log::Vectorizer:: Generating backend, backend: {}'.format(backend) if backend == 'cpu': cores = 1 self.cores = cores self.generated_backend_object = gen_backend(batch_size=self.cores, backend=backend) self.backend = backend print 'Log::Vectorizer:: Loading model from %s' % prm_path model_dict = load_obj(prm_path) print 'Log::Vectorizer:: Generating model with loaded file' self.model = Model(model_dict) # now we are going to extract the middle patch from the image, # based on the size used to train the model self.patch_height = model_dict['train_input_shape'][1] self.patch_width = model_dict['train_input_shape'][2] print 'Log::Vectorizer:: Initialising Model' # initialise the model so that internally the arrays are allocated to the correct size self.model.initialize(model_dict['train_input_shape']) print 'Log::Vectorizer:: DONE!' def get_attribute_vector(self, img_path): if not image_is_local(img_path): print 'Error::Vectorizer:: File Not Found: The image at %s does not exist' % img_path return -1 im = imread(img_path).astype(float) # Fix the image into a flat array organised as [RRRRR..GGGGG..BBBB] patch_array = self.patch_image(im) # make an image buffer on host, pad out to batch size host_buf = np.zeros((3 * self.patch_height * self.patch_width, self.model.be.bsz)) # set the first image to be the image data loaded above host_buf[:, 0] = patch_array.copy() # make buffer on the device dev_buf = self.model.be.zeros((3 * self.patch_height * self.patch_width, self.model.be.bsz)) # copy host buffer to device buffer dev_buf[:] = host_buf # Send through the network. Note that in the returned array there # will be one column for each item in the batch; as we only put data # in the first item, we only want the first column predictions = self.model.fprop(dev_buf, True).asnumpyarray()[:, 0] # print predictions # Print the activations of the 4th layer from the end of the model # Note 1: model.layers represents a SingleOutputTree when using GoogLeNet; # during inference only the main branch (index 0) outputs are considered # Note 2: in the returned array there will be one column for each item # in the batch; as we only put data in the first item, we only want the # first column return self.model.layers.layers[0].layers[self.layer].outputs.asnumpyarray()[:, 0] def get_batch_attribute_vectors(self, img_path_array): """ Given you are running on a GPU, you batch process self.cores number of images at a time. :param img_path_array: An array of self.cores number of images :return: A dict of the paths and their respective attribute vectors :raise GpuNotSupportedException -- This method will only work when your `self.backend == 'gpu'` """ # Ensure that a cpu user is not accessing a GPU command if self.backend is not 'gpu': raise GpuNotSupportedException(self.backend) imgs_to_process, failed_images = self.get_images_to_process(img_path_array) # make an image buffer on host, pad out to batch size # Note: self.model.be.bsz == self.cores host_buf = np.zeros((3 * self.patch_height * self.patch_width, self.model.be.bsz)) for img_index in range(len(imgs_to_process)): im = imread(imgs_to_process[img_index]).astype(float) # Fix the image into a flat array organised as [RRRRR..GGGGG..BBBB] patch_array = self.patch_image(im) # set the first image to be the image data loaded above host_buf[:, img_index] = patch_array.copy() # make buffer on the device dev_buf = self.model.be.zeros((3 * self.patch_height * self.patch_width, self.model.be.bsz)) # copy host buffer to device buffer dev_buf[:] = host_buf # Send through the network. predictions = self.model.fprop(dev_buf, True).asnumpyarray()[:, 0] # print predictions # Print the activations of the 4th layer from the end of the model # Note 1: model.layers represents a SingleOutputTree when using GoogLeNet; # during inference only the main branch (index 0) outputs are considered img_vector_dict = {} for img_index in range(len(imgs_to_process)): img_path = imgs_to_process[img_index] img_vect = self.model.layers.layers[0].layers[self.layer].outputs.asnumpyarray()[:, img_index].tolist() img_vector_dict[img_path] = img_vect return img_vector_dict, failed_images def get_NSEW_batch_attribute_vectors(self, img_path_array): """ Given you are running on a GPU, you batch process self.cores number of images at a time. :param img_path_array: An array of self.cores number of images :return: A dict of the paths and their respective attribute vectors :raise GpuNotSupportedException -- This method will only work when your `self.backend == 'gpu'` """ # Ensure that a cpu user is not accessing a GPU command if self.backend is not 'gpu': raise GpuNotSupportedException(self.backend) # Ensure there are enough (& not too many images) that are also available locally imgs_to_process, failed_images = self.get_images_to_process_for_NSEW(img_path_array) # Shift the focus around the 9 locations with the image imgs_urls_with_direction = [] patches = [] for local_img_url in imgs_to_process: im_data = imread(local_img_url).astype(float) # Get each patch around the image: NW, N, NE, W, mid, E, SW, S, SE # Fix the image into a flat array organised as [RRRRR..GGGGG..BBBB] for direction, patch in self.make_NSEW_image_patches(im_data).items(): imgs_urls_with_direction.append(local_img_url+direction) patches.append(patch) # make an image buffer on host, pad out to batch size # Note: self.model.be.bsz == self.cores # Then fill it with each image patch host_buf = np.zeros((3 * self.patch_height * self.patch_width, self.model.be.bsz)) for img_index in range(len(patches)): host_buf[:, img_index] = patches[img_index].copy() # make buffer on the device dev_buf = self.model.be.zeros((3 * self.patch_height * self.patch_width, self.model.be.bsz)) # copy host buffer to device buffer dev_buf[:] = host_buf # Send through the network. predictions = self.model.fprop(dev_buf, True).asnumpyarray()[:, 0] # print predictions # Print the activations of the 4th layer from the end of the model # Note 1: model.layers represents a SingleOutputTree when using GoogLeNet; # during inference only the main branch (index 0) outputs are considered img_vector_dict = {} for img_index in range(len(imgs_urls_with_direction)): img_path = imgs_urls_with_direction[img_index] img_vect = self.model.layers.layers[0].layers[self.layer].outputs.asnumpyarray()[:, img_index].tolist() img_vector_dict[img_path] = img_vect return img_vector_dict, failed_images # Expects 256x256 def patch_image(self, im): # convert to BGR im = im[:, :, ::-1] # approximately mean-centre it im = im - [128, 128, 128] # Finding the co-ordinates for each corner of the centre patch padY = int(self.patch_height / 2.0) padX = int(self.patch_width / 2.0) y = im.shape[0] - 2 * padY x = im.shape[1] - 2 * padX col = int(x / 2) row = int(y / 2) right = col + self.patch_width left = col top = row bottom = row + self.patch_height # Cropping the image patch = im[top:bottom, left:right, :] # Neon wants the data as a flat array organised as [RRRRR..GGGGG..BBBB] patch_array = patch.transpose((2, 0, 1)).flatten() return patch_array # Expects 256x256 def make_NSEW_image_patches(self, im): # convert to BGR im = im[:, :, ::-1] # approximately mean-centre it im = im - [128, 128, 128] # Determine the region of the image not used to process image_width = im.shape[1] image_height = im.shape[0] x_remainder = image_width - 2 * int(self.patch_width / 2.0) # makes it even y_remainder = image_height - 2 * int(self.patch_height / 2.0) # Determine the width of the horiz and vertical borders west_x = 0 mid_x = x_remainder / 2 east_x = image_width - self.patch_width north_y = 0 mid_y = y_remainder / 2 south_y = image_height - self.patch_height # Describe the position of the image (based on its top left point of the patch) # Assuming [0,0] is the top left point in the whole image factors = { # North Level '#NW': [west_x, north_y], '#N': [mid_x, north_y], '#NE': [east_x, north_y], # Mid Level '#W': [west_x, mid_y], '#mid': [mid_x, mid_y], '#E': [east_x, mid_y], # South Level '#SW': [west_x, south_y], '#S': [mid_x, south_y], '#SE': [east_x, south_y], } patch_array_dict = {} for direction, coord in factors.items(): top = coord[1] left = coord[0] bottom = top + self.patch_height right = left + self.patch_width # Cropping the image patch = im[top:bottom, left:right, :] # Neon wants the data as a flat array organised as [RRRRR..GGGGG..BBBB] patch_array_dict[direction] = patch.transpose((2, 0, 1)).flatten() return patch_array_dict def get_images_to_process(self, img_path_array): """ Keeps the first self.cores number of images that can be found locally. :param img_path_array: :return: passed_images (array<string>) -- Up to self.cores number of images that it can process failed_images (dict<string,string>) -- The images that could not be found or excess images """ failed_images = {} local_images = [] for img_path in img_path_array: if image_is_local(img_path): local_images.append(img_path) else: failed_images[img_path] = 'Image not found locally' # If there are any more than self.cores number of images, ignore them for excess_img in local_images[self.cores:]: failed_images[excess_img] = 'Skipped, more than {} images'.format(self.cores) return local_images[:self.cores], failed_images def get_images_to_process_for_NSEW(self, img_path_array): """ Keeps the first number of images that can be found locally. Given that there is enough for 9 of them to be processed. :param img_path_array: :return: passed_images (array<string>) -- Up to self.cores number of images that it can process failed_images (dict<string,string>) -- The images that could not be found or excess images """ failed_images = {} local_images = [] for img_path in img_path_array: if image_is_local(img_path): local_images.append(img_path) else: failed_images[img_path] = 'Image not found locally' # If there are any more than self.cores number of images, ignore them max_local_images = self.cores / 9 for excess_img in local_images[max_local_images:]: failed_images[excess_img] = 'Skipped, more than {} images, as ({}+1) > {}' \ .format(max_local_images, max_local_images, self.cores) return local_images[:max_local_images], failed_images
# INPUT: load the model model_name = raw_input('Specify file name and extension--> ') if model_name == '': model_name = 'imdb.p' # INPIT: how many to validate how_many_inputs = int(input('How many reviews to validate? (0 for all)--> ')) print '' # Load model including layers, parameters, and weights model = Model('[1]model/' + model_name) # initialize model model.initialize(dataset=(sentence_length, 1)) # CPU-only buffer input_numpy = np.zeros((sentence_length, 1), dtype=np.int32) correct_predictions = 0 neg_files = 0 total_filecount = 0 neg_predictions = 0 pos_predictions = 0 for file in os.listdir('[0]data/test/neg'): if file.endswith('.txt'): filename = '[0]data/test/neg/' + str(file) file = open(filename, 'r') movie_review = file.read()
class DeepQNetwork: def __init__(self, num_actions, args): # remember parameters self.num_actions = num_actions self.batch_size = args.batch_size self.discount_rate = args.discount_rate self.history_length = args.history_length self.screen_dim = (args.screen_height, args.screen_width) self.clip_error = args.clip_error # create Neon backend self.be = gen_backend(backend=args.backend, batch_size=args.batch_size, rng_seed=args.random_seed, device_id=args.device_id, default_dtype=np.dtype(args.datatype).type, stochastic_round=args.stochastic_round) # prepare tensors once and reuse them self.input_shape = (self.history_length, ) + self.screen_dim + ( self.batch_size, ) self.tensor = self.be.empty(self.input_shape) self.tensor.lshape = self.input_shape # needed for convolutional networks self.targets = self.be.empty((self.num_actions, self.batch_size)) # create model layers = self.createLayers(num_actions) self.model = Model(layers=layers) self.cost = GeneralizedCost(costfunc=SumSquared()) self.model.initialize(self.tensor.shape, self.cost) self.optimizer = RMSProp(learning_rate=args.learning_rate, decay_rate=args.rmsprop_decay_rate, stochastic_round=args.stochastic_round) # create target model self.target_steps = args.target_steps self.train_iterations = 0 if self.target_steps: self.target_model = Model(layers=self.createLayers(num_actions)) self.target_model.initialize(self.tensor.shape) self.save_weights_path = args.save_weights_path else: self.target_model = self.model self.callback = None def createLayers(self, num_actions): # create network init_norm = Gaussian(loc=0.0, scale=0.01) layers = [] # The first hidden layer convolves 32 filters of 8x8 with stride 4 with the input image and applies a rectifier nonlinearity. layers.append( Conv((8, 8, 32), strides=4, init=init_norm, activation=Rectlin())) # The second hidden layer convolves 64 filters of 4x4 with stride 2, again followed by a rectifier nonlinearity. layers.append( Conv((4, 4, 64), strides=2, init=init_norm, activation=Rectlin())) # This is followed by a third convolutional layer that convolves 64 filters of 3x3 with stride 1 followed by a rectifier. layers.append( Conv((3, 3, 64), strides=1, init=init_norm, activation=Rectlin())) # The final hidden layer is fully-connected and consists of 512 rectifier units. layers.append(Affine(nout=512, init=init_norm, activation=Rectlin())) # The output layer is a fully-connected linear layer with a single output for each valid action. layers.append(Affine(nout=num_actions, init=init_norm)) return layers def setTensor(self, states): # change order of axes to match what Neon expects states = np.transpose(states, axes=(1, 2, 3, 0)) # copy() shouldn't be necessary here, but Neon doesn't work otherwise self.tensor.set(states.copy()) # normalize network input between 0 and 1 self.be.divide(self.tensor, 255, self.tensor) def train(self, minibatch, epoch): # expand components of minibatch prestates, actions, rewards, poststates, terminals = minibatch assert len(prestates.shape) == 4 assert len(poststates.shape) == 4 assert len(actions.shape) == 1 assert len(rewards.shape) == 1 assert len(terminals.shape) == 1 assert prestates.shape == poststates.shape assert prestates.shape[0] == actions.shape[0] == rewards.shape[ 0] == poststates.shape[0] == terminals.shape[0] if self.target_steps and self.train_iterations % self.target_steps == 0: # HACK: push something through network, so that weights exist self.model.fprop(self.tensor) # HACK: serialize network to disk and read it back to clone filename = os.path.join(self.save_weights_path, "target_network.pkl") save_obj(self.model.serialize(keep_states=False), filename) self.target_model.load_weights(filename) # feed-forward pass for poststates to get Q-values self.setTensor(poststates) postq = self.target_model.fprop(self.tensor, inference=True) assert postq.shape == (self.num_actions, self.batch_size) # calculate max Q-value for each poststate maxpostq = self.be.max(postq, axis=0).asnumpyarray() assert maxpostq.shape == (1, self.batch_size) # feed-forward pass for prestates self.setTensor(prestates) preq = self.model.fprop(self.tensor, inference=False) assert preq.shape == (self.num_actions, self.batch_size) # make copy of prestate Q-values as targets targets = preq.asnumpyarray() # update Q-value targets for actions taken for i, action in enumerate(actions): if terminals[i]: targets[action, i] = float(rewards[i]) else: targets[action, i] = float( rewards[i]) + self.discount_rate * maxpostq[0, i] # copy targets to GPU memory self.targets.set(targets) # calculate errors deltas = self.cost.get_errors(preq, self.targets) assert deltas.shape == (self.num_actions, self.batch_size) #assert np.count_nonzero(deltas.asnumpyarray()) == 32 # calculate cost, just in case cost = self.cost.get_cost(preq, self.targets) assert cost.shape == (1, 1) # clip errors if self.clip_error: self.be.clip(deltas, -self.clip_error, self.clip_error, out=deltas) # perform back-propagation of gradients self.model.bprop(deltas) # perform optimization self.optimizer.optimize(self.model.layers_to_optimize, epoch) # increase number of weight updates (needed for target clone interval) self.train_iterations += 1 # calculate statistics if self.callback: self.callback.on_train(cost.asnumpyarray()[0, 0]) def predict(self, states): # minibatch is full size, because Neon doesn't let change the minibatch size assert states.shape == (( self.batch_size, self.history_length, ) + self.screen_dim) # calculate Q-values for the states self.setTensor(states) qvalues = self.model.fprop(self.tensor, inference=True) assert qvalues.shape == (self.num_actions, self.batch_size) if logger.isEnabledFor(logging.DEBUG): logger.debug("Q-values: " + str(qvalues.asnumpyarray()[:, 0])) # find the action with highest q-value actions = self.be.argmax(qvalues, axis=0) assert actions.shape == (1, self.batch_size) # take only the first result return actions.asnumpyarray()[0, 0] def getMeanQ(self, states): assert states.shape == (( self.batch_size, self.history_length, ) + self.screen_dim) # calculate Q-values for the states self.setTensor(states) qvalues = self.model.fprop(self.tensor, inference=True) assert qvalues.shape == (self.num_actions, self.batch_size) # take maximum Q-value for each state actions = self.be.max(qvalues, axis=0) assert actions.astensor().shape == (1, self.batch_size) # calculate mean Q-value of all states meanq = self.be.mean(actions, axis=1) assert meanq.astensor().shape == (1, 1) # return the mean return meanq.asnumpyarray()[0, 0] def load_weights(self, load_path): self.model.load_weights(load_path) def save_weights(self, save_path): save_obj(self.model.serialize(keep_states=True), save_path)
reset_cells=True), Affine(train_set.vocab_size, init, bias=init2, activation=Softmax()) ] cost = GeneralizedCostMask(costfunc=CrossEntropyMulti(usebits=True)) model = Model(layers=layers) callbacks = Callbacks(model, **args.callback_args) opt = RMSProp(decay_rate=0.997, learning_rate=0.0005, epsilon=1e-8, gradient_clip_value=1) # train model if not args.test_only: model.fit(train_set, optimizer=opt, num_epochs=num_epochs, cost=cost, callbacks=callbacks) else: if args.model_file is None: raise ValueError('To run test only need to specify a model file') model.initialize(train_set, cost=cost) test_set = ImageCaptionTest(path=data_path) sents, targets = test_set.predict(model) test_set.bleu_score(sents, targets)
prob = prob / (prob.sum() + 1e-6) return np.argmax(np.random.multinomial(1, prob, 1)) # Set batch size and time_steps to 1 for generation and reset buffers model.be.bsz = 1 time_steps = 1 num_predict = 1000 layers = [ LSTM(hidden_size, init, activation=Logistic(), gate_activation=Tanh()), Affine(len(train_set.vocab), init, bias=init, activation=Softmax()) ] model_new = Model(layers=layers) model_new.load_params(args.save_path) model_new.initialize(dataset=(train_set.shape[0], time_steps)) # Generate text text = [] seed_tokens = list('ROMEO:') x = model_new.be.zeros((len(train_set.vocab), time_steps)) for s in seed_tokens: x.fill(0) x[train_set.token_to_index[s], 0] = 1 y = model_new.fprop(x) for i in range(num_predict): # Take last prediction and feed into next fprop pred = sample(y.get()[:, -1])
import os from neon.util.argparser import NeonArgparser from neon.util.persist import load_obj from neon.transforms import Misclassification, CrossEntropyMulti from neon.optimizers import GradientDescentMomentum from neon.layers import GeneralizedCost from neon.models import Model from neon.data import DataLoader, ImageParams # parse the command line arguments (generates the backend) parser = NeonArgparser(__doc__) args = parser.parse_args() # setup data provider test_dir = os.path.join(args.data_dir, 'val') shape = dict(channel_count=3, height=32, width=32) test_params = ImageParams(center=True, flip=False, **shape) common = dict(target_size=1, nclasses=10) test_set = DataLoader(set_name='val', repo_dir=test_dir, media_params=test_params, **common) model = Model(load_obj(args.model_file)) cost = GeneralizedCost(costfunc=CrossEntropyMulti()) opt = GradientDescentMomentum(0.1, 0.9, wdecay=0.0001) model.initialize(test_set, cost=cost) acc = 1.0 - model.eval(test_set, metric=Misclassification())[0] print 'Accuracy: %.1f %% (Top-1)' % (acc*100.0) model.benchmark(test_set, cost=cost, optimizer=opt)
class DeepQNetwork: def __init__(self, state_size, num_steers, num_speeds, args): # remember parameters self.state_size = state_size self.num_steers = num_steers self.num_speeds = num_speeds self.num_actions = num_steers + num_speeds self.num_layers = args.hidden_layers self.hidden_nodes = args.hidden_nodes self.batch_size = args.batch_size self.discount_rate = args.discount_rate self.clip_error = args.clip_error # create Neon backend self.be = gen_backend(backend = args.backend, batch_size = args.batch_size, rng_seed = args.random_seed, device_id = args.device_id, datatype = np.dtype(args.datatype).type, stochastic_round = args.stochastic_round) # prepare tensors once and reuse them self.input_shape = (self.state_size, self.batch_size) self.input = self.be.empty(self.input_shape) self.targets = self.be.empty((self.num_actions, self.batch_size)) # create model self.model = Model(layers = self._createLayers()) self.cost = GeneralizedCost(costfunc = SumSquared()) self.model.initialize(self.input_shape[:-1], self.cost) if args.optimizer == 'rmsprop': self.optimizer = RMSProp(learning_rate = args.learning_rate, decay_rate = args.decay_rate, stochastic_round = args.stochastic_round) elif args.optimizer == 'adam': self.optimizer = Adam(learning_rate = args.learning_rate, stochastic_round = args.stochastic_round) elif args.optimizer == 'adadelta': self.optimizer = Adadelta(decay = args.decay_rate, stochastic_round = args.stochastic_round) else: assert false, "Unknown optimizer" # create target model self.target_steps = args.target_steps self.train_iterations = 0 if self.target_steps: self.target_model = Model(layers = self._createLayers()) self.target_model.initialize(self.input_shape[:-1]) self.save_weights_prefix = args.save_weights_prefix else: self.target_model = self.model def _createLayers(self): # create network init_norm = Gaussian(loc=0.0, scale=0.01) layers = [] for i in xrange(self.num_layers): layers.append(Affine(nout=self.hidden_nodes, init=init_norm, activation=Rectlin())) layers.append(Affine(nout=self.num_actions, init = init_norm)) return layers def _setInput(self, states): # change order of axes to match what Neon expects states = np.transpose(states) # copy() shouldn't be necessary here, but Neon doesn't work otherwise self.input.set(states.copy()) # normalize network input between 0 and 1 #self.be.divide(self.input, 200, self.input) def train(self, minibatch, epoch = 0): # expand components of minibatch prestates, steers, speeds, rewards, poststates, terminals = minibatch assert len(prestates.shape) == 2 assert len(poststates.shape) == 2 assert len(steers.shape) == 1 assert len(speeds.shape) == 1 assert len(rewards.shape) == 1 assert len(terminals.shape) == 1 assert prestates.shape == poststates.shape assert prestates.shape[0] == steers.shape[0] == speeds.shape[0] == rewards.shape[0] == poststates.shape[0] == terminals.shape[0] if self.target_steps and self.train_iterations % self.target_steps == 0: # HACK: serialize network to disk and read it back to clone filename = self.save_weights_prefix + "_target.pkl" save_obj(self.model.serialize(keep_states = False), filename) self.target_model.load_weights(filename) # feed-forward pass for poststates to get Q-values self._setInput(poststates) postq = self.target_model.fprop(self.input, inference = True) assert postq.shape == (self.num_actions, self.batch_size) # calculate max Q-value for each poststate postq = postq.asnumpyarray() maxsteerq = np.max(postq[:self.num_steers,:], axis=0) assert maxsteerq.shape == (self.batch_size,), "size: %s" % str(maxsteerq.shape) maxspeedq = np.max(postq[-self.num_speeds:,:], axis=0) assert maxspeedq.shape == (self.batch_size,) # feed-forward pass for prestates self._setInput(prestates) preq = self.model.fprop(self.input, inference = False) assert preq.shape == (self.num_actions, self.batch_size) # make copy of prestate Q-values as targets # HACK: copy() was needed to make it work on CPU targets = preq.asnumpyarray().copy() # update Q-value targets for actions taken for i, (steer, speed) in enumerate(zip(steers, speeds)): if terminals[i]: targets[steer, i] = float(rewards[i]) targets[self.num_steers + speed, i] = float(rewards[i]) else: targets[steer, i] = float(rewards[i]) + self.discount_rate * maxsteerq[i] targets[self.num_steers + speed, i] = float(rewards[i]) + self.discount_rate * maxspeedq[i] # copy targets to GPU memory self.targets.set(targets) # calculate errors deltas = self.cost.get_errors(preq, self.targets) assert deltas.shape == (self.num_actions, self.batch_size) #assert np.count_nonzero(deltas.asnumpyarray()) == 2 * self.batch_size, str(np.count_nonzero(deltas.asnumpyarray())) # calculate cost, just in case cost = self.cost.get_cost(preq, self.targets) assert cost.shape == (1,1) #print "cost:", cost.asnumpyarray() # clip errors if self.clip_error: self.be.clip(deltas, -self.clip_error, self.clip_error, out = deltas) # perform back-propagation of gradients self.model.bprop(deltas) # perform optimization self.optimizer.optimize(self.model.layers_to_optimize, epoch) ''' if np.any(rewards < 0): preqq = preq.asnumpyarray().copy() self._setInput(prestates) qvalues = self.model.fprop(self.input, inference = True).asnumpyarray().copy() indexes = rewards < 0 print "indexes:", indexes print "preq:", preqq[:, indexes].T print "preq':", qvalues[:, indexes].T print "diff:", (qvalues[:, indexes]-preqq[:, indexes]).T print "steers:", steers[indexes] print "speeds:", speeds[indexes] print "rewards:", rewards[indexes] print "terminals:", terminals[indexes] print "preq[0]:", preqq[:, 0] print "preq[0]':", qvalues[:, 0] print "diff:", qvalues[:, 0] - preqq[:, 0] print "deltas:", deltas.asnumpyarray()[:, indexes].T raw_input("Press Enter to continue...") ''' # increase number of weight updates (needed for target clone interval) self.train_iterations += 1 def predict(self, states): # minibatch is full size, because Neon doesn't let change the minibatch size assert states.shape == (self.batch_size, self.state_size) # calculate Q-values for the states self._setInput(states) qvalues = self.model.fprop(self.input, inference = True) assert qvalues.shape == (self.num_actions, self.batch_size) if logger.isEnabledFor(logging.DEBUG): logger.debug("Q-values: " + str(qvalues.asnumpyarray()[:,0])) # transpose the result, so that batch size is first dimension return qvalues.T.asnumpyarray() def load_weights(self, load_path): self.model.load_weights(load_path) def save_weights(self, save_path): save_obj(self.model.serialize(keep_states = True), save_path)
class DeepQNetwork: def __init__(self, num_actions, args): # remember parameters self.num_actions = num_actions self.batch_size = args.batch_size self.discount_rate = args.discount_rate self.history_length = args.history_length self.screen_dim = (args.screen_height, args.screen_width) self.clip_error = args.clip_error self.min_reward = args.min_reward self.max_reward = args.max_reward self.batch_norm = args.batch_norm # create Neon backend self.be = gen_backend(backend = args.backend, batch_size = args.batch_size, rng_seed = args.random_seed, device_id = args.device_id, datatype = np.dtype(args.datatype).type, stochastic_round = args.stochastic_round) # prepare tensors once and reuse them self.input_shape = (self.history_length,) + self.screen_dim + (self.batch_size,) self.input = self.be.empty(self.input_shape) self.input.lshape = self.input_shape # HACK: needed for convolutional networks self.targets = self.be.empty((self.num_actions, self.batch_size)) # create model layers = self._createLayers(num_actions) self.model = Model(layers = layers) self.cost = GeneralizedCost(costfunc = SumSquared()) # Bug fix for l in self.model.layers.layers: l.parallelism = 'Disabled' self.model.initialize(self.input_shape[:-1], self.cost) if args.optimizer == 'rmsprop': self.optimizer = RMSProp(learning_rate = args.learning_rate, decay_rate = args.decay_rate, stochastic_round = args.stochastic_round) elif args.optimizer == 'adam': self.optimizer = Adam(learning_rate = args.learning_rate, stochastic_round = args.stochastic_round) elif args.optimizer == 'adadelta': self.optimizer = Adadelta(decay = args.decay_rate, stochastic_round = args.stochastic_round) else: assert false, "Unknown optimizer" # create target model self.target_steps = args.target_steps self.train_iterations = 0 if self.target_steps: self.target_model = Model(layers = self._createLayers(num_actions)) # Bug fix for l in self.target_model.layers.layers: l.parallelism = 'Disabled' self.target_model.initialize(self.input_shape[:-1]) self.save_weights_prefix = args.save_weights_prefix else: self.target_model = self.model self.callback = None def _createLayers(self, num_actions): # create network init_norm = Gaussian(loc=0.0, scale=0.01) layers = [] # The first hidden layer convolves 32 filters of 8x8 with stride 4 with the input image and applies a rectifier nonlinearity. layers.append(Conv((8, 8, 32), strides=4, init=init_norm, activation=Rectlin(), batch_norm=self.batch_norm)) # The second hidden layer convolves 64 filters of 4x4 with stride 2, again followed by a rectifier nonlinearity. layers.append(Conv((4, 4, 64), strides=2, init=init_norm, activation=Rectlin(), batch_norm=self.batch_norm)) # This is followed by a third convolutional layer that convolves 64 filters of 3x3 with stride 1 followed by a rectifier. layers.append(Conv((3, 3, 64), strides=1, init=init_norm, activation=Rectlin(), batch_norm=self.batch_norm)) # The final hidden layer is fully-connected and consists of 512 rectifier units. layers.append(Affine(nout=512, init=init_norm, activation=Rectlin(), batch_norm=self.batch_norm)) # The output layer is a fully-connected linear layer with a single output for each valid action. layers.append(Affine(nout=num_actions, init = init_norm)) return layers def _setInput(self, states): # change order of axes to match what Neon expects states = np.transpose(states, axes = (1, 2, 3, 0)) # copy() shouldn't be necessary here, but Neon doesn't work otherwise self.input.set(states.copy()) # normalize network input between 0 and 1 self.be.divide(self.input, 255, self.input) def train(self, minibatch, epoch): # expand components of minibatch prestates, actions, rewards, poststates, terminals = minibatch assert len(prestates.shape) == 4 assert len(poststates.shape) == 4 assert len(actions.shape) == 1 assert len(rewards.shape) == 1 assert len(terminals.shape) == 1 assert prestates.shape == poststates.shape assert prestates.shape[0] == actions.shape[0] == rewards.shape[0] == poststates.shape[0] == terminals.shape[0] if self.target_steps and self.train_iterations % self.target_steps == 0: # have to serialize also states for batch normalization to work pdict = self.model.get_description(get_weights=True, keep_states=True) self.target_model.deserialize(pdict, load_states=True) # feed-forward pass for poststates to get Q-values self._setInput(poststates) postq = self.target_model.fprop(self.input, inference = True) assert postq.shape == (self.num_actions, self.batch_size) # calculate max Q-value for each poststate maxpostq = self.be.max(postq, axis=0).asnumpyarray() assert maxpostq.shape == (1, self.batch_size) # feed-forward pass for prestates self._setInput(prestates) preq = self.model.fprop(self.input, inference = False) assert preq.shape == (self.num_actions, self.batch_size) # make copy of prestate Q-values as targets # It seems neccessary for cpu backend. targets = preq.asnumpyarray().copy() # clip rewards between -1 and 1 rewards = np.clip(rewards, self.min_reward, self.max_reward) # update Q-value targets for actions taken for i, action in enumerate(actions): if terminals[i]: targets[action, i] = float(rewards[i]) else: targets[action, i] = float(rewards[i]) + self.discount_rate * maxpostq[0,i] # copy targets to GPU memory self.targets.set(targets) # calculate errors deltas = self.cost.get_errors(preq, self.targets) assert deltas.shape == (self.num_actions, self.batch_size) #assert np.count_nonzero(deltas.asnumpyarray()) == 32 # calculate cost, just in case cost = self.cost.get_cost(preq, self.targets) assert cost.shape == (1,1) # clip errors if self.clip_error: self.be.clip(deltas, -self.clip_error, self.clip_error, out = deltas) # perform back-propagation of gradients self.model.bprop(deltas) # perform optimization self.optimizer.optimize(self.model.layers_to_optimize, epoch) # increase number of weight updates (needed for target clone interval) self.train_iterations += 1 # calculate statistics if self.callback: self.callback.on_train(cost[0,0]) def predict(self, states): # minibatch is full size, because Neon doesn't let change the minibatch size assert states.shape == ((self.batch_size, self.history_length,) + self.screen_dim) # calculate Q-values for the states self._setInput(states) qvalues = self.model.fprop(self.input, inference = True) assert qvalues.shape == (self.num_actions, self.batch_size) if logger.isEnabledFor(logging.DEBUG): logger.debug("Q-values: " + str(qvalues.asnumpyarray()[:,0])) # transpose the result, so that batch size is first dimension return qvalues.T.asnumpyarray() def load_weights(self, load_path): self.model.load_params(load_path) def save_weights(self, save_path): self.model.save_params(save_path)
class DeepQNetwork: def __init__(self, num_actions, batch_size=32, discount_rate=0.99, history_length=4, cols=64, rows=64, clip_error=1, min_reward=-1, max_reward=1, batch_norm=False): self.num_actions = num_actions self.batch_size = batch_size self.discount_rate = discount_rate self.history_length = history_length self.board_dim = (cols, rows) self.clip_error = clip_error self.min_reward = min_reward self.max_reward = max_reward self.batch_norm = batch_norm self.be = gen_backend(backend='gpu', batch_size=self.batch_size, datatype=np.dtype('float32').type) self.input_shape = (self.history_length, ) + self.board_dim + ( self.batch_size, ) self.input = self.be.empty(self.input_shape) self.input.lshape = self.input_shape # hack from simple_dqn "needed for convolutional networks" self.targets = self.be.empty((self.num_actions, self.batch_size)) layers = self._createLayers(self.num_actions) self.model = Model(layers=layers) self.cost = GeneralizedCost(costfunc=SumSquared()) # for l in self.model.layers.layers: # l.parallelism = 'Disabled' self.model.initialize(self.input_shape[:-1], cost=self.cost) self.optimizer = RMSProp(learning_rate=0.002, decay_rate=0.95, stochastic_round=True) self.train_iterations = 0 self.target_model = Model(layers=self._createLayers(num_actions)) # for l in self.target_model.layers.layers: # l.parallelism = 'Disabled' self.target_model.initialize(self.input_shape[:-1]) self.callback = None def _createLayers(self, num_actions): init_xavier_conv = Xavier(local=True) init_xavier_affine = Xavier(local=False) layers = [] layers.append( Conv((8, 8, 32), strides=4, init=init_xavier_conv, activation=Rectlin(), batch_norm=self.batch_norm)) layers.append( Conv((4, 4, 64), strides=2, init=init_xavier_conv, activation=Rectlin(), batch_norm=self.batch_norm)) layers.append( Conv((2, 2, 128), strides=1, init=init_xavier_conv, activation=Rectlin(), batch_norm=self.batch_norm)) layers.append( Affine(nout=256, init=init_xavier_affine, activation=Rectlin(), batch_norm=self.batch_norm)) layers.append(Affine(nout=num_actions, init=init_xavier_affine)) return layers def _setInput(self, states): states = np.transpose(states, axes=(1, 2, 3, 0)) self.input.set(states.copy()) self.be.add(self.input, 1, self.input) self.be.divide(self.input, 2, self.input) def update_target_network(self): pdict = self.model.get_description(get_weights=True, keep_states=True) self.target_model.deserialize(pdict, load_states=True) def train(self, minibatch, epoch): prestates, actions, rewards, poststates, terminals = minibatch self._setInput(poststates) postq = self.target_model.fprop(self.input, inference=True) assert postq.shape == (self.num_actions, self.batch_size) maxpostq = self.be.max(postq, axis=0).asnumpyarray() assert maxpostq.shape == (1, self.batch_size) self._setInput(prestates) preq = self.model.fprop(self.input, inference=False) assert preq.shape == (self.num_actions, self.batch_size) targets = preq.asnumpyarray().copy() rewards = np.clip(rewards, -1, 1) for i, action in enumerate(actions): if terminals[i]: targets[action, i] = float(rewards[i]) else: targets[action, i] = float( rewards[i]) + self.discount_rate * maxpostq[0, i] self.targets.set(targets) deltas = self.cost.get_errors(preq, self.targets) assert deltas.shape == (self.num_actions, self.batch_size) cost = self.cost.get_cost(preq, self.targets) assert cost.shape == (1, 1) if self.clip_error: self.be.clip(deltas, -self.clip_error, self.clip_error, out=deltas) self.model.bprop(deltas) self.optimizer.optimize(self.model.layers_to_optimize, epoch) self.train_iterations += 1 self.callback.on_train(cost[0, 0]) def predict(self, states): assert states.shape == (( self.batch_size, self.history_length, ) + self.board_dim) self._setInput(states) qvalues = self.model.fprop(self.input, inference=True) assert qvalues.shape == (self.num_actions, self.batch_size) return qvalues.T.asnumpyarray() def load_weights(self, load_path): self.model.load_params(load_path) def save_weights(self, save_path): self.model.save_params(save_path)
def main(): # larger batch sizes may not fit on GPU parser = NeonArgparser(__doc__, default_overrides={'batch_size': 4}) parser.add_argument("--bench", action="store_true", help="run benchmark instead of training") parser.add_argument("--num_classes", type=int, default=12, help="number of classes in the annotation") parser.add_argument("--height", type=int, default=256, help="image height") parser.add_argument("--width", type=int, default=512, help="image width") args = parser.parse_args(gen_be=False) # check that image dimensions are powers of 2 if((args.height & (args.height - 1)) != 0): raise TypeError("Height must be a power of 2.") if((args.width & (args.width - 1)) != 0): raise TypeError("Width must be a power of 2.") (c, h, w) = (args.num_classes, args.height, args.width) # need to use the backend with the new upsampling layer implementation be = NervanaGPU_Upsample(rng_seed=args.rng_seed, device_id=args.device_id) # set batch size be.bsz = args.batch_size # couple backend to global neon object NervanaObject.be = be shape = dict(channel_count=3, height=h, width=w, subtract_mean=False) train_params = ImageParams(center=True, flip=False, scale_min=min(h, w), scale_max=min(h, w), aspect_ratio=0, **shape) test_params = ImageParams(center=True, flip=False, scale_min=min(h, w), scale_max=min(h, w), aspect_ratio=0, **shape) common = dict(target_size=h*w, target_conversion='read_contents', onehot=False, target_dtype=np.uint8, nclasses=args.num_classes) train_set = PixelWiseImageLoader(set_name='train', repo_dir=args.data_dir, media_params=train_params, shuffle=False, subset_percent=100, index_file=os.path.join(args.data_dir, 'train_images.csv'), **common) val_set = PixelWiseImageLoader(set_name='val', repo_dir=args.data_dir,media_params=test_params, index_file=os.path.join(args.data_dir, 'val_images.csv'), **common) # initialize model object layers = gen_model(c, h, w) segnet_model = Model(layers=layers) # configure callbacks callbacks = Callbacks(segnet_model, eval_set=val_set, **args.callback_args) opt_gdm = GradientDescentMomentum(1.0e-6, 0.9, wdecay=0.0005, schedule=Schedule()) opt_biases = GradientDescentMomentum(2.0e-6, 0.9, schedule=Schedule()) opt_bn = GradientDescentMomentum(1.0e-6, 0.9, schedule=Schedule()) opt = MultiOptimizer({'default': opt_gdm, 'Bias': opt_biases, 'BatchNorm': opt_bn}) cost = GeneralizedCost(costfunc=CrossEntropyMulti()) if args.bench: segnet_model.initialize(train_set, cost=cost) segnet_model.benchmark(train_set, cost=cost, optimizer=opt) sys.exit(0) else: segnet_model.fit(train_set, optimizer=opt, num_epochs=args.epochs, cost=cost, callbacks=callbacks) # get the trained segnet model outputs for valisation set outs_val = segnet_model.get_outputs(val_set) with open('outputs.pkl', 'w') as fid: pickle.dump(outs_val, fid, -1)
class DeepQNetwork: def __init__(self, num_actions, args): # remember parameters self.num_actions = num_actions self.batch_size = args.batch_size self.discount_rate = args.discount_rate self.history_length = args.history_length self.screen_dim = (args.screen_height, args.screen_width) self.clip_error = args.clip_error # create Neon backend self.be = gen_backend(backend = args.backend, batch_size = args.batch_size, rng_seed = args.random_seed, device_id = args.device_id, default_dtype = np.dtype(args.datatype).type, stochastic_round = args.stochastic_round) # prepare tensors once and reuse them self.input_shape = (self.history_length,) + self.screen_dim + (self.batch_size,) self.tensor = self.be.empty(self.input_shape) self.tensor.lshape = self.input_shape # needed for convolutional networks self.targets = self.be.empty((self.num_actions, self.batch_size)) # create model layers = self.createLayers(num_actions) self.model = Model(layers = layers) self.cost = GeneralizedCost(costfunc = SumSquared()) self.model.initialize(self.tensor.shape, self.cost) self.optimizer = RMSProp(learning_rate = args.learning_rate, decay_rate = args.rmsprop_decay_rate, stochastic_round = args.stochastic_round) # create target model self.target_steps = args.target_steps self.train_iterations = 0 if self.target_steps: self.target_model = Model(layers = self.createLayers(num_actions)) self.target_model.initialize(self.tensor.shape) self.save_weights_path = args.save_weights_path else: self.target_model = self.model self.callback = None def createLayers(self, num_actions): # create network init_norm = Gaussian(loc=0.0, scale=0.01) layers = [] # The first hidden layer convolves 32 filters of 8x8 with stride 4 with the input image and applies a rectifier nonlinearity. layers.append(Conv((8, 8, 32), strides=4, init=init_norm, activation=Rectlin())) # The second hidden layer convolves 64 filters of 4x4 with stride 2, again followed by a rectifier nonlinearity. layers.append(Conv((4, 4, 64), strides=2, init=init_norm, activation=Rectlin())) # This is followed by a third convolutional layer that convolves 64 filters of 3x3 with stride 1 followed by a rectifier. layers.append(Conv((3, 3, 64), strides=1, init=init_norm, activation=Rectlin())) # The final hidden layer is fully-connected and consists of 512 rectifier units. layers.append(Affine(nout=512, init=init_norm, activation=Rectlin())) # The output layer is a fully-connected linear layer with a single output for each valid action. layers.append(Affine(nout = num_actions, init = init_norm)) return layers def setTensor(self, states): # change order of axes to match what Neon expects states = np.transpose(states, axes = (1, 2, 3, 0)) # copy() shouldn't be necessary here, but Neon doesn't work otherwise self.tensor.set(states.copy()) # normalize network input between 0 and 1 self.be.divide(self.tensor, 255, self.tensor) def train(self, minibatch, epoch): # expand components of minibatch prestates, actions, rewards, poststates, terminals = minibatch assert len(prestates.shape) == 4 assert len(poststates.shape) == 4 assert len(actions.shape) == 1 assert len(rewards.shape) == 1 assert len(terminals.shape) == 1 assert prestates.shape == poststates.shape assert prestates.shape[0] == actions.shape[0] == rewards.shape[0] == poststates.shape[0] == terminals.shape[0] if self.target_steps and self.train_iterations % self.target_steps == 0: # HACK: push something through network, so that weights exist self.model.fprop(self.tensor) # HACK: serialize network to disk and read it back to clone filename = os.path.join(self.save_weights_path, "target_network.pkl") save_obj(self.model.serialize(keep_states = False), filename) self.target_model.load_weights(filename) # feed-forward pass for poststates to get Q-values self.setTensor(poststates) postq = self.target_model.fprop(self.tensor, inference = True) assert postq.shape == (self.num_actions, self.batch_size) # calculate max Q-value for each poststate maxpostq = self.be.max(postq, axis=0).asnumpyarray() assert maxpostq.shape == (1, self.batch_size) # feed-forward pass for prestates self.setTensor(prestates) preq = self.model.fprop(self.tensor, inference = False) assert preq.shape == (self.num_actions, self.batch_size) # make copy of prestate Q-values as targets targets = preq.asnumpyarray() # update Q-value targets for actions taken for i, action in enumerate(actions): if terminals[i]: targets[action, i] = float(rewards[i]) else: targets[action, i] = float(rewards[i]) + self.discount_rate * maxpostq[0,i] # copy targets to GPU memory self.targets.set(targets) # calculate errors deltas = self.cost.get_errors(preq, self.targets) assert deltas.shape == (self.num_actions, self.batch_size) #assert np.count_nonzero(deltas.asnumpyarray()) == 32 # calculate cost, just in case cost = self.cost.get_cost(preq, self.targets) assert cost.shape == (1,1) # clip errors if self.clip_error: self.be.clip(deltas, -self.clip_error, self.clip_error, out = deltas) # perform back-propagation of gradients self.model.bprop(deltas) # perform optimization self.optimizer.optimize(self.model.layers_to_optimize, epoch) # increase number of weight updates (needed for target clone interval) self.train_iterations += 1 # calculate statistics if self.callback: self.callback.on_train(cost.asnumpyarray()[0,0]) def predict(self, states): # minibatch is full size, because Neon doesn't let change the minibatch size assert states.shape == ((self.batch_size, self.history_length,) + self.screen_dim) # calculate Q-values for the states self.setTensor(states) qvalues = self.model.fprop(self.tensor, inference = True) assert qvalues.shape == (self.num_actions, self.batch_size) if logger.isEnabledFor(logging.DEBUG): logger.debug("Q-values: " + str(qvalues.asnumpyarray()[:,0])) # find the action with highest q-value actions = self.be.argmax(qvalues, axis = 0) assert actions.shape == (1, self.batch_size) # take only the first result return actions.asnumpyarray()[0,0] def getMeanQ(self, states): assert states.shape == ((self.batch_size, self.history_length,) + self.screen_dim) # calculate Q-values for the states self.setTensor(states) qvalues = self.model.fprop(self.tensor, inference = True) assert qvalues.shape == (self.num_actions, self.batch_size) # take maximum Q-value for each state actions = self.be.max(qvalues, axis = 0) assert actions.astensor().shape == (1, self.batch_size) # calculate mean Q-value of all states meanq = self.be.mean(actions, axis = 1) assert meanq.astensor().shape == (1, 1) # return the mean return meanq.asnumpyarray()[0,0] def load_weights(self, load_path): self.model.load_weights(load_path) def save_weights(self, save_path): save_obj(self.model.serialize(keep_states = True), save_path)
valmetric = TopKMisclassification(k=5) # dummy optimizer for benchmarking # training implementation coming soon opt_gdm = GradientDescentMomentum(0.0, 0.0) opt_biases = GradientDescentMomentum(0.0, 0.0) opt = MultiOptimizer({'default': opt_gdm, 'Bias': opt_biases}) # setup cost function as CrossEntropy cost = Multicost(costs=[GeneralizedCost(costfunc=CrossEntropyMulti()), GeneralizedCost(costfunc=CrossEntropyMulti()), GeneralizedCost(costfunc=CrossEntropyMulti())], weights=[1, 0., 0.]) # We only want to consider the CE of the main path assert os.path.exists(args.model_file), 'script requires the trained weights file' model.load_params(args.model_file) model.initialize(test, cost) print 'running speed benchmark...' model.benchmark(test, cost, opt) print '\nCalculating performance on validation set...' test.reset() mets = model.eval(test, metric=valmetric) print 'Validation set metrics:' print 'LogLoss: %.2f, Accuracy: %.1f %% (Top-1), %.1f %% (Top-5)' % (mets[0], (1.0-mets[1])*100, (1.0-mets[2])*100)
Conv((3, 3, 256), init=Gaussian(scale=0.03), activation=Rectlin(), padding=1), Conv((3, 3, 256), init=Gaussian(scale=0.03), activation=Rectlin(), padding=1), Pooling(3, strides=2), Affine(nout=4096, init=Gaussian(scale=0.01), activation=Rectlin()), Affine(nout=4096, init=Gaussian(scale=0.01), activation=Rectlin()), Affine(nout=1000, init=Gaussian(scale=0.01), activation=Softmax()) ] weight_sched = Schedule([22, 44, 65], (1 / 250.)**(1 / 3.)) opt_gdm = GradientDescentMomentum(0.01, 0.0, wdecay=0.0005, schedule=weight_sched) opt = MultiOptimizer({'default': opt_gdm}) model = Model(layers=layers, optimizer=opt) cost = GeneralizedCost(costfunc=CrossEntropyMulti()) model.initialize(train, cost=cost) b = Benchmark(model) print("Forward and backward") res = b.time(train, niterations=5) b.print_stats(res, nskip=2)
encoder2 = Affine(nout=config.encoder_size[1], init=init_norm, activation=Logistic(), name='encoder2') decoder2 = Affine(nout=config.encoder_size[0], init=init_norm, activation=Logistic(), name='decoder2') encoder3 = Affine(nout=config.encoder_size[2], init=init_norm, activation=Logistic(), name='encoder3') decoder3 = Affine(nout=config.encoder_size[1], init=init_norm, activation=Logistic(), name='decoder3') classifier = Affine(nout=config.ydim, init=init_norm, activation=Softmax()) cost_reconst = GeneralizedCost(costfunc=SumSquared()) cost_classification = GeneralizedCost(costfunc=CrossEntropyMulti()) # Setting model layers for AE1 AE1 = Model([encoder1, decoder1]) AE1.cost = cost_reconst AE1.initialize(data, cost_reconst) # AE1.optimizer = optimizer_default measure_time(data, AE1, config, 'AE1') # Setting model layers for AE2 # It has an extra encoder layer compared to what AE should really be. This is # done to avoid saving the outputs for each AE. AE2_mimic = Model([encoder1, encoder2, decoder2]) AE2_mimic.cost = cost_reconst AE2_mimic.initialize(data, cost_reconst) # Learning rates for extra layers that should not be updated are set to zero. # opt = MultiOptimizer({'default': optimizer_default, # 'encoder1': optimizer_helper}) # AE2_mimic.optimizer = opt measure_time(data, AE2_mimic, config, 'AE2', create_target=True)
def test_model_serialize(backend_default, data): (X_train, y_train), (X_test, y_test), nclass = load_mnist(path=data) train_set = ArrayIterator([X_train, X_train], y_train, nclass=nclass, lshape=(1, 28, 28)) init_norm = Gaussian(loc=0.0, scale=0.01) # initialize model path1 = Sequential([ Conv((5, 5, 16), init=init_norm, bias=Constant(0), activation=Rectlin()), Pooling(2), Affine(nout=20, init=init_norm, bias=init_norm, activation=Rectlin()) ]) path2 = Sequential([ Affine(nout=100, init=init_norm, bias=Constant(0), activation=Rectlin()), Dropout(keep=0.5), Affine(nout=20, init=init_norm, bias=init_norm, activation=Rectlin()) ]) layers = [ MergeMultistream(layers=[path1, path2], merge="stack"), Affine(nout=20, init=init_norm, batch_norm=True, activation=Rectlin()), Affine(nout=10, init=init_norm, activation=Logistic(shortcut=True)) ] tmp_save = 'test_model_serialize_tmp_save.pickle' mlp = Model(layers=layers) mlp.optimizer = GradientDescentMomentum(learning_rate=0.1, momentum_coef=0.9) mlp.cost = GeneralizedCost(costfunc=CrossEntropyBinary()) mlp.initialize(train_set, cost=mlp.cost) n_test = 3 num_epochs = 3 # Train model for num_epochs and n_test batches for epoch in range(num_epochs): for i, (x, t) in enumerate(train_set): x = mlp.fprop(x) delta = mlp.cost.get_errors(x, t) mlp.bprop(delta) mlp.optimizer.optimize(mlp.layers_to_optimize, epoch=epoch) if i > n_test: break # Get expected outputs of n_test batches and states of all layers outputs_exp = [] pdicts_exp = [l.get_params_serialize() for l in mlp.layers_to_optimize] for i, (x, t) in enumerate(train_set): outputs_exp.append(mlp.fprop(x, inference=True)) if i > n_test: break # Serialize model mlp.save_params(tmp_save, keep_states=True) # Load model mlp = Model(layers=layers) mlp.load_params(tmp_save) outputs = [] pdicts = [l.get_params_serialize() for l in mlp.layers_to_optimize] for i, (x, t) in enumerate(train_set): outputs.append(mlp.fprop(x, inference=True)) if i > n_test: break # Check outputs, states, and params are the same for output, output_exp in zip(outputs, outputs_exp): assert np.allclose(output.get(), output_exp.get()) for pd, pd_exp in zip(pdicts, pdicts_exp): for s, s_e in zip(pd['states'], pd_exp['states']): if isinstance(s, list): # this is the batch norm case for _s, _s_e in zip(s, s_e): assert np.allclose(_s, _s_e) else: assert np.allclose(s, s_e) for p, p_e in zip(pd['params'], pd_exp['params']): assert type(p) == type(p_e) if isinstance(p, list): # this is the batch norm case for _p, _p_e in zip(p, p_e): assert np.allclose(_p, _p_e) elif isinstance(p, np.ndarray): assert np.allclose(p, p_e) else: assert p == p_e os.remove(tmp_save)
# input image parameters - channel_count is 3 for color images, 1 for B/W shape = dict(channel_count=3, height=h, width=w, subtract_mean=False) test_params = ImageParams(center=True, flip=False, scale_min=min(h, w), scale_max=min(h, w), aspect_ratio=0, **shape) common = dict(target_size=h*w, target_conversion='read_contents', onehot=False, target_dtype=np.uint8, nclasses=c) data_dir = args.image_path test_set = PixelWiseImageLoader(set_name='test', repo_dir=data_dir,media_params=test_params, index_file=os.path.join(data_dir, 'test_images.csv'), **common) # initialize model object segnet_model = Model(layers=gen_model(c, h, w)) segnet_model.initialize(test_set) # load up the serialized model model_desc = ModelDescription(load_obj(args.save_model_file)) for layer in segnet_model.layers_to_optimize: name = layer.name trained_layer = model_desc.getlayer(name) layer.load_weights(trained_layer) fig = plt.figure() if args.display: plt.ion() im1 = None im2 = None
bias=Constant(0), activation=Tanh())) layers.append(Pooling(2, strides=2, op='max')) # cannot be 50!!! should be multiple of 4 layers.append(Conv((5, 5, 52), padding=0, strides=1, init=init_uni, bias=Constant(0), activation=Tanh())) layers.append(Pooling(2, strides=2, op='max')) layers.append(Affine(nout=500, init=init_norm, activation=Rectlin())) layers.append(Affine(nout=config.ydim, init=init_norm, activation=Softmax())) # setup cost function as CrossEntropy cost = GeneralizedCost(costfunc=CrossEntropyMulti()) # initialize model object network = Model(layers=layers) network.cost = cost network.initialize(data, cost) if config.backend == 'gpu': start = drv.Event() end = drv.Event() num_iterations = config.num_warmup_iters + config.num_timing_iters forward_time = np.zeros(config.num_timing_iters) backward_time = np.zeros(config.num_timing_iters) iter = 0 flag = True while flag: for (x, t) in data: iter += 1 if iter > num_iterations: flag = False break
if not args.resume: # build the model from scratch and run it # Now construct the model branch_nodes = [BranchNode(name='branch{}'.format(i)) for i in (0, 1)] main1 = main_branch(branch_nodes) aux1 = aux_branch(branch_nodes[0], ind=1) aux2 = aux_branch(branch_nodes[1], ind=2) model = Model(layers=Tree([main1, aux1, aux2], alphas=[1.0, 0.3, 0.3])) else: # load up the save model model = Model('serialize_test_2.pkl') model.initialize(train, cost=cost) # configure callbacks callbacks = Callbacks(model, progress_bar=True, output_file='temp1.h5', serialize=1, history=3, save_path='serialize_test.pkl') lr_sched = PolySchedule(total_epochs=10, power=0.5) opt_gdm = GradientDescentMomentum(0.01, 0.9, wdecay=0.0002, schedule=lr_sched) opt_biases = GradientDescentMomentum(0.02, 0.9, schedule=lr_sched) opt = MultiOptimizer({'default': opt_gdm, 'Bias': opt_biases}) if not args.resume: # fit the model for 3 epochs model.fit(train, optimizer=opt, num_epochs=3, cost=cost, callbacks=callbacks) train.reset()
""" prob = prob / (prob.sum() + 1e-6) return np.argmax(np.random.multinomial(1, prob, 1)) # Set batch size and time_steps to 1 for generation and reset buffers model.be.bsz = 1 time_steps = 1 num_predict = 1000 layers = [ LSTM(hidden_size, init, activation=Logistic(), gate_activation=Tanh()), Affine(len(train_set.vocab), init, bias=init, activation=Softmax()) ] model_new = Model(layers=layers) model_new.load_params(args.save_path) model_new.initialize(dataset=(train_set.shape[0], time_steps)) # Generate text text = [] seed_tokens = list('ROMEO:') x = model_new.be.zeros((len(train_set.vocab), time_steps)) for s in seed_tokens: x.fill(0) x[train_set.token_to_index[s], 0] = 1 y = model_new.fprop(x) for i in range(num_predict): # Take last prediction and feed into next fprop pred = sample(y.get()[:, -1])
def test_conv_rnn(backend_default): train_shape = (1, 17, 142) be = backend_default inp = be.array(be.rng.randn(np.prod(train_shape), be.bsz)) delta = be.array(be.rng.randn(10, be.bsz)) init_norm = Gaussian(loc=0.0, scale=0.01) bilstm = DeepBiLSTM(128, init_norm, activation=Rectlin(), gate_activation=Rectlin(), depth=1, reset_cells=True) birnn_1 = DeepBiRNN(128, init_norm, activation=Rectlin(), depth=1, reset_cells=True, batch_norm=False) birnn_2 = DeepBiRNN(128, init_norm, activation=Rectlin(), depth=2, reset_cells=True, batch_norm=False) bibnrnn = DeepBiRNN(128, init_norm, activation=Rectlin(), depth=1, reset_cells=True, batch_norm=True) birnnsum = DeepBiRNN(128, init_norm, activation=Rectlin(), depth=1, reset_cells=True, batch_norm=False, bi_sum=True) rnn = Recurrent(128, init=init_norm, activation=Rectlin(), reset_cells=True) lstm = LSTM(128, init_norm, activation=Rectlin(), gate_activation=Rectlin(), reset_cells=True) gru = GRU(128, init_norm, activation=Rectlin(), gate_activation=Rectlin(), reset_cells=True) rlayers = [bilstm, birnn_1, birnn_2, bibnrnn, birnnsum, rnn, lstm, gru] for rl in rlayers: layers = [ Conv((2, 2, 4), init=init_norm, activation=Rectlin(), strides=dict(str_h=2, str_w=4)), Pooling(2, strides=2), Conv((3, 3, 4), init=init_norm, batch_norm=True, activation=Rectlin(), strides=dict(str_h=1, str_w=2)), rl, RecurrentMean(), Affine(nout=10, init=init_norm, activation=Rectlin()), ] model = Model(layers=layers) cost = GeneralizedCost(costfunc=CrossEntropyBinary()) model.initialize(train_shape, cost) model.fprop(inp) model.bprop(delta)
if return_sequences is True: layers = [ LSTM(hidden, init, activation=Logistic(), gate_activation=Tanh(), reset_cells=False), Affine(train_set.nfeatures, init, bias=init, activation=Identity()) ] else: layers = [ LSTM(hidden, init, activation=Logistic(), gate_activation=Tanh(), reset_cells=False), RecurrentLast(), Affine(train_set.nfeatures, init, bias=init, activation=Identity()) ] model_new = Model(layers=layers) model_new.load_params(args.save_path) model_new.initialize(dataset=(train_set.nfeatures, seq_len)) output = np.zeros((train_set.nfeatures, num_predict)) seed = time_series.train[:seed_seq_len] x = model_new.be.empty((train_set.nfeatures, seq_len)) for s_in in seed: x.set(s_in.reshape(train_set.nfeatures, seq_len)) y = model_new.fprop(x, inference=False) for i in range(num_predict): # Take last prediction and feed into next fprop pred = y.get()[:, -1] output[:, i] = pred x[:] = pred.reshape(train_set.nfeatures, seq_len) y = model_new.fprop(x, inference=False)
class InceptionModel(object): """ Container for the inception-like test model """ def __init__(self): self.in_shape = (3, 299, 299) self.nout = 100 self.pool3s1p1 = dict(fshape=3, padding=1, strides=1, op='avg') self.pool3s2p0 = dict(fshape=3, strides=2, op='max') layers = self.main_branch(nout=self.nout) self.cost = GeneralizedCost(costfunc=CrossEntropyMulti()) self.model = Model(layers=layers) self.model.initialize(self.in_shape, cost=self.cost) self.layers = layers @staticmethod def conv_params(fsize, nfm, padding='SAME', strides=1, activation=Rectlin(), batch_norm=True): fsize = fsize if isinstance(fsize, tuple) else (fsize, fsize) fshape = fsize + (nfm, ) padding = { 'pad_h': (fsize[0] // 2 if padding == 'SAME' else 0), 'pad_w': (fsize[1] // 2 if padding == 'SAME' else 0), 'pad_d': 0 } strides = {'str_h': strides, 'str_w': strides, 'str_d': 1} return dict(fshape=fshape, strides=strides, activation=activation, padding=padding, batch_norm=batch_norm, init=Kaiming(local=True)) def inception(self, kvals, b2fsz=5): (p1, p2, p3, p4) = kvals branch1 = [Conv(**self.conv_params(1, p1[0], padding=0, strides=1))] branch2 = [ Conv(**self.conv_params(1, p2[0], padding=0, strides=1)), Conv(**self.conv_params(b2fsz, p2[1], padding='SAME', strides=1)) ], branch3 = [ Conv(**self.conv_params(1, p3[0], padding=0, strides=1)), Conv(**self.conv_params(3, p3[1], padding='SAME', strides=1)), Conv(**self.conv_params(3, p3[1], padding='SAME', strides=1)) ] branch4 = [ Pooling(**self.pool3s1p1), Conv(**self.conv_params(1, p4[0], padding=0, strides=1)) ] return MergeBroadcast(layers=[branch1, branch2, branch3, branch4], merge="depth") def inception_inception(self, kvals): (p1, p2, p3, p4) = kvals branch1 = [Conv(**self.conv_params(1, p1[0], padding=0, strides=1))] i2_branch1 = [ Conv(**self.conv_params((1, 3), p2[1], padding='SAME', strides=1)) ] i2_branch2 = [ Conv(**self.conv_params((3, 1), p2[1], padding='SAME', strides=1)) ] branch2 = [ Conv(**self.conv_params(1, p2[0], padding=0, strides=1)), MergeBroadcast(layers=[i2_branch1, i2_branch2], merge="depth") ] i3_branch1 = [ Conv(**self.conv_params((1, 3), p3[2], padding='SAME', strides=1)) ] i3_branch2 = [ Conv(**self.conv_params((3, 1), p3[2], padding='SAME', strides=1)) ] branch3 = [ Conv(**self.conv_params(1, p3[0], padding=0, strides=1)), Conv(**self.conv_params(3, p3[1], padding='SAME', strides=1)), MergeBroadcast(layers=[i3_branch1, i3_branch2], merge="depth") ] branch4 = [ Pooling(**self.pool3s1p1), Conv(**self.conv_params(1, p4[0], padding=0, strides=1)) ] return MergeBroadcast(layers=[branch1, branch2, branch3, branch4], merge="depth") def main_branch(self, nout=100): return [ Conv(**self.conv_params(3, 32, strides=2, padding=0)), Pooling(**self.pool3s2p0), Conv(**self.conv_params(1, 80, strides=1, padding=0)), Pooling(**self.pool3s2p0), self.inception([(64, ), (48, 64), (64, 96), (32, )], b2fsz=5), self.inception([(64, ), (48, 64), (64, 96), (64, )], b2fsz=5), self.inception_inception([(64, ), (64, 64), (64, 64, 64), (192, )]), self.inception_inception([(64, ), (64, 64), (64, 64, 64), (192, )]), Pooling(fshape='all', strides=1, op="avg"), Dropout(keep=0.8), Conv(**self.conv_params(1, nout, activation=Softmax())) ]
def test_fw_bw_no_cost_or_optimizer(): model = Model(test_layers) model.initialize(test_dataset) b = Benchmark(model=model) with pytest.raises(RuntimeError): b.time(test_dataset, niterations=1)
# model initialization image_path = Sequential([Affine(hidden_size, init, bias=Constant(val=0.0))]) sent_path = Sequential([Affine(hidden_size, init, name='sent')]) layers = [ MergeMultistream(layers=[image_path, sent_path], merge="recurrent"), Dropout(keep=0.5), LSTM(hidden_size, init, activation=Logistic(), gate_activation=Tanh(), reset_cells=True), Affine(train_set.vocab_size, init, bias=init2, activation=Softmax()) ] cost = GeneralizedCostMask(costfunc=CrossEntropyMulti(usebits=True)) model = Model(layers=layers) callbacks = Callbacks(model, **args.callback_args) opt = RMSProp(decay_rate=0.997, learning_rate=0.0005, epsilon=1e-8, gradient_clip_value=1) # train model if not args.test_only: model.fit(train_set, optimizer=opt, num_epochs=num_epochs, cost=cost, callbacks=callbacks) else: if args.model_file is None: raise ValueError('To run test only need to specify a model file') model.initialize(train_set, cost=cost) test_set = ImageCaptionTest(path=data_path) sents, targets = test_set.predict(model) test_set.bleu_score(sents, targets)
# dummy optimizer for benchmarking # training implementation coming soon opt_gdm = GradientDescentMomentum(0.0, 0.0) opt_biases = GradientDescentMomentum(0.0, 0.0) opt = MultiOptimizer({'default': opt_gdm, 'Bias': opt_biases}) # setup cost function as CrossEntropy cost = Multicost( costs=[ GeneralizedCost(costfunc=CrossEntropyMulti()), GeneralizedCost(costfunc=CrossEntropyMulti()), GeneralizedCost(costfunc=CrossEntropyMulti()) ], weights=[1, 0., 0.]) # We only want to consider the CE of the main path assert os.path.exists( args.model_file), 'script requires the trained weights file' model.load_params(args.model_file) model.initialize(test, cost) print 'running speed benchmark...' model.benchmark(test, cost, opt) print '\nCalculating performance on validation set...' test.reset() mets = model.eval(test, metric=valmetric) print 'Validation set metrics:' print 'LogLoss: %.2f, Accuracy: %.1f %% (Top-1), %.1f %% (Top-5)' % ( mets[0], (1.0 - mets[1]) * 100, (1.0 - mets[2]) * 100)
def test_reshape_layer_model(backend_default, fargs): """ test cases: - conv before RNNs - conv after RNNs - conv after LUT """ np.random.seed(seed=0) nin, nout, bsz = fargs be = backend_default be.bsz = bsz input_size = (nin, be.bsz) init = Uniform(-0.1, 0.1) g_uni = GlorotUniform() inp_np = np.random.rand(nin, be.bsz) delta_np = np.random.rand(nout, be.bsz) inp = be.array(inp_np) delta = be.array(delta_np) conv_lut_1 = [ LookupTable(vocab_size=2000, embedding_dim=400, init=init), Reshape(reshape=(4, 100, -1)), Conv((3, 3, 16), init=init), LSTM(64, g_uni, activation=Tanh(), gate_activation=Logistic(), reset_cells=True), RecurrentSum(), Affine(nout, init, bias=init, activation=Softmax()) ] conv_lut_2 = [ LookupTable(vocab_size=1000, embedding_dim=400, init=init), Reshape(reshape=(4, 50, -1)), Conv((3, 3, 16), init=init), Pooling(2, strides=2), Affine(nout=nout, init=init, bias=init, activation=Softmax()), ] conv_rnn_1 = [ LookupTable(vocab_size=2000, embedding_dim=400, init=init), LSTM(64, g_uni, activation=Tanh(), gate_activation=Logistic(), reset_cells=True), Reshape(reshape=(4, 32, -1)), Conv((3, 3, 16), init=init), Affine(nout, init, bias=init, activation=Softmax()) ] conv_rnn_2 = [ LookupTable(vocab_size=2000, embedding_dim=400, init=init), Recurrent(64, g_uni, activation=Tanh(), reset_cells=True), Reshape(reshape=(4, -1, 32)), Conv((3, 3, 16), init=init), Affine(nout, init, bias=init, activation=Softmax()) ] lut_sum_1 = [ LookupTable(vocab_size=1000, embedding_dim=128, init=init), RecurrentSum(), Affine(nout=nout, init=init, bias=init, activation=Softmax()), ] lut_birnn_1 = [ LookupTable(vocab_size=1000, embedding_dim=200, init=init), DeepBiRNN(32, init=GlorotUniform(), batch_norm=True, activation=Tanh(), reset_cells=True, depth=1), Reshape((4, 32, -1)), Conv((3, 3, 16), init=init), Affine(nout=nout, init=init, bias=init, activation=Softmax()) ] layers_test = [conv_lut_1, conv_lut_2, conv_rnn_1, conv_rnn_2, lut_sum_1, lut_birnn_1] for lg in layers_test: model = Model(layers=lg) cost = GeneralizedCost(costfunc=CrossEntropyBinary()) model.initialize(input_size, cost) model.fprop(inp) model.bprop(delta)
args = parser.parse_args() # load the cnn model gen_backend(batch_size=1, backend='cpu') # gen_backend(batch_size=32, backend='gpu') model_dict = load_obj(args.prm_name) model = Model(model_dict) # now we are going to extract the middle patch from the image, # based on the size used to train the model patch_height = model_dict['train_input_shape'][1] patch_width = model_dict['train_input_shape'][2] # initialise the model so that internally the arrays are allocated to the correct size model.initialize(model_dict['train_input_shape']) # load the image im = imread(args.image).astype(float) # convert to BGR im = im[:, :, ::-1] # approximately mean-centre it im = im - [128,128,128] # Finding the co-ordinates for each corner of the centre patch padY = int(patch_height / 2.0) padX = int(patch_width / 2.0) y = im.shape[0] - 2 * padY