我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用theano.tensor.iscalar()。
def input_batch(layer): idx = T.iscalar() X = T.tensor4() layer_input = lasagne.layers.get_output(layer.input_layer, X, deterministic=True) layer_input = layer_input.flatten(2) if layer_input.ndim > layer.inp_ndim \ else layer_input b_size = X.shape[0] X_layer = T.set_subtensor(layer.X_layer[idx, :b_size, :], layer_input) updates = [(layer.X_layer, X_layer)] return theano.function([idx, X], updates=updates)
def compile_grad(nnet, layer): """ """ assert layer.issvm y = T.ivector() idx = T.iscalar() dW, db, loss = symbolic_grad(nnet, layer, idx, y) updates = [(layer.dW, dW), (layer.db, db), (layer.loss, loss)] # return compiled function return theano.function([idx, y], updates=updates, profile=nnet.profile)
def compile_update_conv(nnet, layer): assert layer.isconv and Configuration.store_on_gpu X = T.tensor4("X") y = T.ivector("y") idx = T.iscalar("idx") dW, db, loss = grad_conv(nnet=nnet, layer=layer, X=X, y=y) updates = _update_std(nnet=nnet, layer=layer, dW=dW, db=db, loss=loss, idx=idx) return theano.function([idx, X, y], updates=updates, profile=nnet.profile)
def compile_update_svm(nnet, layer): assert layer.issvm and Configuration.store_on_gpu idx = T.iscalar() y = T.ivector() X = layer.X_layer[idx, :y.shape[0]] dW, db, loss = grad_svm(nnet=nnet, layer=layer, X=X, y=y) updates = _update_std(nnet=nnet, layer=layer, dW=dW, db=db, loss=loss, idx=idx) return theano.function([idx, y], updates=updates, profile=nnet.profile)
def multi_label_ACE(outputs,y_labels): data_shape=outputs.shape loss_buff=0 # num=T.iscalar(data_shape[0]) #theano int to get value from tensor # for i in range(int(num)): # for j in range(12): # y_exp=outputs[i,j] # y_tru=y_labels[i,0,0,j] # if y_tru==0: # loss_ij=math.log(1-outputs[i,j]) # loss_buff-=loss_ij # if y_tru>0: # loss_ij=math.log(outputs[i,j]) # loss_buff-=loss_ij # wts=[ 0.24331649, 0.18382575, 0.23082499, 0.44545567, 0.52901483, 0.58482504, \ # 0.57321465, 0.43411294, 0.15502839, 0.36377019, 0.19050646, 0.16083916] # for i in [3,4,5,6,7,9]: for i in range(12): target=y_labels[:,i] output=outputs[:,i] loss_au=T.sum(-(target * T.log((output+0.05)/1.05) + (1.0 - target) * T.log((1.05 - output)/1.05))) loss_buff+=loss_au return loss_buff/(12*BATCH_SIZE)
def _create_constant_uas_across_datapoints(self): """ Helper function. Creates and returns new theano variables representing noise, where noise is the same across datapoints in the minibatch. Useful for binding the original noise variables in evaluation function where randomness is required but same predictions are needed across minibatch. """ n_data = tt.iscalar('n_data') net_uas = [tt.tile(self.srng.normal((n_units,), dtype=dtype), [n_data, 1]) for n_units in self.net.n_units[1:]] uaa = tt.tile(self.srng.normal((self.n_components,), dtype=dtype), [n_data, 1]) uams = [tt.tile(self.srng.normal((self.n_outputs,), dtype=dtype), [n_data, 1]) for _ in xrange(self.n_components)] uaUs = [tt.tile(self.srng.normal((self.n_outputs**2,), dtype=dtype), [n_data, 1]) for _ in xrange(self.n_components)] # NOTE: order matters here uas = net_uas + [uaa] + uams + uaUs return n_data, uas
def __init__(self, in_size, out_size, dim_y, dim_pos, hidden_size_encoder, hidden_size_decoder, cell = "gru", optimizer = "rmsprop", p = 0.5, num_sents = 1): self.X = T.matrix("X") self.Y_y = T.matrix("Y_y") self.Y_pos = T.matrix("Y_pos") self.in_size = in_size self.out_size = out_size self.dim_y = dim_y self.dim_pos = dim_pos self.hidden_size_encoder = hidden_size_encoder self.hidden_size_decoder = hidden_size_decoder self.cell = cell self.drop_rate = p self.num_sents = num_sents self.is_train = T.iscalar('is_train') # for dropout self.batch_size = T.iscalar('batch_size') # for mini-batch training self.mask = T.matrix("mask") self.mask_y = T.matrix("mask_y") self.optimizer = optimizer print "seq2seq out size ", self.out_size if self.out_size == self.dim_y + self.dim_pos: print "size right !" self.define_layers() self.define_train_test_funcs()
def __init__(self, in_size, out_size, hidden_size_encoder, hidden_size_decoder, cell = "gru", optimizer = "rmsprop", p = 0.5, num_sents = 1): self.X = T.matrix("X") self.Y = T.matrix("Y") self.in_size = in_size self.out_size = out_size self.hidden_size_encoder = hidden_size_encoder self.hidden_size_decoder = hidden_size_decoder self.cell = cell self.drop_rate = p self.num_sents = num_sents self.is_train = T.iscalar('is_train') # for dropout self.batch_size = T.iscalar('batch_size') # for mini-batch training self.mask = T.matrix("mask") self.mask_y = T.matrix("mask_y") self.optimizer = optimizer self.define_layers() self.define_train_test_funcs()
def __init__(self, in_size, out_size, dim_y, dim_pos, hidden_size_encoder, hidden_size_decoder, cell = "gru", optimizer = "rmsprop", p = 0.5, num_sents = 1): self.X = T.matrix("X") self.Y_y = T.matrix("Y_y") self.Y_pos = T.matrix("Y_pos") self.in_size = in_size self.out_size = out_size self.dim_y = dim_y self.dim_pos = dim_pos self.hidden_size_encoder = hidden_size_encoder self.hidden_size_decoder = hidden_size_decoder self.cell = cell self.drop_rate = p self.num_sents = num_sents self.is_train = T.iscalar('is_train') # for dropout self.batch_size = T.iscalar('batch_size') # for mini-batch training self.mask = T.matrix("mask") self.mask_y = T.matrix("mask_y") self.optimizer = optimizer if self.out_size == self.dim_y + self.dim_pos: print "size right !" self.define_layers() self.define_train_test_funcs()
def __init__(self, in_size, out_size, dim_y, dim_pos, hidden_size_encoder, hidden_size_decoder, cell = "gru", optimizer = "rmsprop", p = 0.5, num_sents = 1): self.X = T.matrix("X") self.Y = T.matrix("Y") self.in_size = in_size self.out_size = out_size self.dim_y = dim_y self.dim_pos = dim_pos self.hidden_size_encoder = hidden_size_encoder self.hidden_size_decoder = hidden_size_decoder self.cell = cell self.drop_rate = p self.num_sents = num_sents self.is_train = T.iscalar('is_train') # for dropout self.batch_size = T.iscalar('batch_size') # for mini-batch training self.mask = T.matrix("mask") self.mask_y = T.matrix("mask_y") self.optimizer = optimizer self.define_layers() self.define_train_test_funcs()
def setupVariables(self): floatX = theano.config.floatX # @UndefinedVariable # params self.learning_rate = T.scalar('learning_rate',dtype=floatX) self.momentum = T.scalar('momentum',dtype=floatX) # input self.tvIndex = T.lscalar() # index to a [mini]batch #self.tvIndex.tag.test_value = 10 self.tvX = self.descrNet.inputVar # targets self.tvY = T.ivector('y') self.tvYr = T.tensor4('yr') self.tvPairIdx = T.imatrix('pairIdx') self.tvPairLabels = T.ivector('pairLabels') self.tvTripletIdx = T.imatrix('tripletIdx') self.tvTripletThresh = T.scalar('tripletThresh') self.tvTripletPoolIdx = T.imatrix('tripletPoolIdx') self.tvTripletPoolThresh = T.scalar('tripletPoolThresh') self.tvPosTripletPoolSize = T.iscalar('posTripletPoolSize') self.tvNegTripletPoolSize = T.iscalar('negTripletPoolSize')
def test_select_distinct(self): """ Tests that MultinomialWOReplacementFromUniform always selects distinct elements """ p = tensor.fmatrix() u = tensor.fvector() n = tensor.iscalar() m = multinomial.MultinomialWOReplacementFromUniform('auto')(p, u, n) f = function([p, u, n], m, allow_input_downcast=True) n_elements = 1000 all_indices = range(n_elements) numpy.random.seed(12345) for i in [5, 10, 50, 100, 500, n_elements]: uni = numpy.random.rand(i).astype(config.floatX) pvals = numpy.random.randint(1, 100, (1, n_elements)).astype(config.floatX) pvals /= pvals.sum(1) res = f(pvals, uni, i) res = numpy.squeeze(res) assert len(res) == i, res assert numpy.all(numpy.in1d(numpy.unique(res), all_indices)), res
def test_fail_select_alot(self): """ Tests that MultinomialWOReplacementFromUniform fails when asked to sample more elements than the actual number of elements """ p = tensor.fmatrix() u = tensor.fvector() n = tensor.iscalar() m = multinomial.MultinomialWOReplacementFromUniform('auto')(p, u, n) f = function([p, u, n], m, allow_input_downcast=True) n_elements = 100 n_selected = 200 numpy.random.seed(12345) uni = numpy.random.rand(n_selected).astype(config.floatX) pvals = numpy.random.randint(1, 100, (1, n_elements)).astype(config.floatX) pvals /= pvals.sum(1) self.assertRaises(ValueError, f, pvals, uni, n_selected)
def test_select_distinct(self): """ Tests that multinomial_wo_replacement always selects distinct elements """ th_rng = RandomStreams(12345) p = tensor.fmatrix() n = tensor.iscalar() m = th_rng.multinomial_wo_replacement(pvals=p, n=n) f = function([p, n], m, allow_input_downcast=True) n_elements = 1000 all_indices = range(n_elements) numpy.random.seed(12345) for i in [5, 10, 50, 100, 500, n_elements]: pvals = numpy.random.randint(1, 100, (1, n_elements)).astype(config.floatX) pvals /= pvals.sum(1) res = f(pvals, i) res = numpy.squeeze(res) assert len(res) == i assert numpy.all(numpy.in1d(numpy.unique(res), all_indices)), res
def test_fail_select_alot(self): """ Tests that multinomial_wo_replacement fails when asked to sample more elements than the actual number of elements """ th_rng = RandomStreams(12345) p = tensor.fmatrix() n = tensor.iscalar() m = th_rng.multinomial_wo_replacement(pvals=p, n=n) f = function([p, n], m, allow_input_downcast=True) n_elements = 100 n_selected = 200 numpy.random.seed(12345) pvals = numpy.random.randint(1, 100, (1, n_elements)).astype(config.floatX) pvals /= pvals.sum(1) self.assertRaises(ValueError, f, pvals, n_selected)
def test_lazy_if(self): # Tests that lazy if works .. even if the two results have different # shapes but the same type (i.e. both vectors, or matrices or # whatnot of same dtype) x = tensor.vector('x', dtype=self.dtype) y = tensor.vector('y', dtype=self.dtype) c = tensor.iscalar('c') f = theano.function([c, x, y], ifelse(c, x, y), mode=self.mode) self.assertFunctionContains1(f, self.get_ifelse(1)) rng = numpy.random.RandomState(utt.fetch_seed()) xlen = rng.randint(200) ylen = rng.randint(200) vx = numpy.asarray(rng.uniform(size=(xlen,)), self.dtype) vy = numpy.asarray(rng.uniform(size=(ylen,)), self.dtype) assert numpy.allclose(vx, f(1, vx, vy)) assert numpy.allclose(vy, f(0, vx, vy))
def test_sparse_tensor_error(self): import theano.sparse if not theano.sparse.enable_sparse: raise SkipTest("Optimization temporarily disabled") rng = numpy.random.RandomState(utt.fetch_seed()) data = rng.rand(2, 3).astype(self.dtype) x = self.shared(data) y = theano.sparse.matrix('csc', dtype=self.dtype, name='y') z = theano.sparse.matrix('csr', dtype=self.dtype, name='z') cond = theano.tensor.iscalar('cond') self.assertRaises(TypeError, ifelse, cond, x, y) self.assertRaises(TypeError, ifelse, cond, y, x) self.assertRaises(TypeError, ifelse, cond, x, z) self.assertRaises(TypeError, ifelse, cond, z, x) self.assertRaises(TypeError, ifelse, cond, y, z) self.assertRaises(TypeError, ifelse, cond, z, y)
def test_pushout3(self): raise SkipTest("Optimization temporarily disabled") x1 = tensor.scalar('x1') y1 = tensor.scalar('x2') y2 = tensor.scalar('y2') c = tensor.iscalar('c') two = numpy.asarray(2, dtype=theano.config.floatX) x, y = ifelse(c, (x1, y1), (two, y2), name='f1') o3 = numpy.asarray(0.3, dtype=theano.config.floatX) o2 = numpy.asarray(0.2, dtype=theano.config.floatX) z = ifelse(c, o3, o2, name='f2') out = x * z * y f = theano.function([x1, y1, y2, c], out, allow_input_downcast=True) assert isinstance(f.maker.fgraph.toposort()[-1].op, IfElse) rng = numpy.random.RandomState(utt.fetch_seed()) vx1 = rng.uniform() vy1 = rng.uniform() vy2 = rng.uniform() assert numpy.allclose(f(vx1, vy1, vy2, 1), vx1 * vy1 * 0.3) assert numpy.allclose(f(vx1, vy1, vy2, 0), 2 * vy2 * 0.2)
def test_printing_scan(): # Skip test if pydot is not available. if not theano.printing.pydot_imported: raise SkipTest('pydot not available') def f_pow2(x_tm1): return 2 * x_tm1 state = theano.tensor.scalar('state') n_steps = theano.tensor.iscalar('nsteps') output, updates = theano.scan(f_pow2, [], state, [], n_steps=n_steps, truncate_gradient=-1, go_backwards=False) f = theano.function([state, n_steps], output, updates=updates, allow_input_downcast=True) theano.printing.pydotprint(output, scan_graphs=True) theano.printing.pydotprint(f, scan_graphs=True)
def __getitem__(self, args): if not isinstance(args, tuple): args = args, if len(args) == 2: scalar_arg_1 = (numpy.isscalar(args[0]) or getattr(args[0], 'type', None) == tensor.iscalar) scalar_arg_2 = (numpy.isscalar(args[1]) or getattr(args[1], 'type', None) == tensor.iscalar) if scalar_arg_1 and scalar_arg_2: ret = get_item_scalar(self, args) elif isinstance(args[0], list): ret = get_item_2lists(self, args[0], args[1]) else: ret = get_item_2d(self, args) elif isinstance(args[0], list): ret = get_item_list(self, args[0]) else: ret = get_item_2d(self, args) return ret
def test_scalar3(self): # var[::-1][:int] -> var[-1] x = tensor.matrix('x') y = tensor.iscalar('y') f = function([x, y], x[::-1][:y], mode=mode_opt) # Check stacktrace was copied over correctly after opt was applied self.assertTrue(check_stack_trace(f, ops_to_check=Subtensor)) #theano.printing.debugprint(f, print_type=True) topo = f.maker.fgraph.toposort() # print [t for t in topo if isinstance(t.op, tensor.Subtensor)] assert len([t for t in topo if isinstance(t.op, tensor.Subtensor)]) == 1 # print topo[-1].op assert isinstance(topo[-1].op, DeepCopyOp) for x_s in self.x_shapes: x_val = self.rng.uniform(size=x_s).astype(config.floatX) for idx in xrange(-7, 7): f(x_val, idx) # let debugmode test something
def test_scalar4(self): # var[int1:][:int2] x = tensor.matrix('x') y = tensor.iscalar('y') z = tensor.iscalar('y') f = function([x, y, z], x[y:][:z], mode=mode_opt) # Check stacktrace was copied over correctly after opt was applied self.assertTrue(check_stack_trace(f, ops_to_check=Subtensor)) #theano.printing.debugprint(f, print_type=True) topo = f.maker.fgraph.toposort() # print [t for t in topo if isinstance(t.op, tensor.Subtensor)] assert len([t for t in topo if isinstance(t.op, tensor.Subtensor)]) == 1 # print topo[-1].op assert isinstance(topo[-1].op, DeepCopyOp) for x_s in self.x_shapes: x_val = self.rng.uniform(size=x_s).astype(config.floatX) for idx1 in xrange(-11, 11): for idx2 in xrange(-11, 11): f(x_val, idx1, idx2) # let debugmode test something
def test_infer_shape(self): adscal = dscalar() bdscal = dscalar() aiscal = iscalar() biscal = iscalar() ciscal = iscalar() discal = iscalar() adscal_val = numpy.random.rand() bdscal_val = numpy.random.rand() aiscal_val = numpy.random.randint(10) biscal_val = numpy.random.randint(10) ciscal_val = numpy.random.randint(10) discal_val = numpy.random.randint(10) self._compile_and_check([adscal, aiscal], [MakeVector('float64')(adscal, aiscal)], [adscal_val, aiscal_val], MakeVector) self._compile_and_check([adscal, bdscal, aiscal], [MakeVector('float64')(adscal, bdscal, aiscal)], [adscal_val, bdscal_val, aiscal_val], MakeVector) self._compile_and_check([aiscal, biscal, ciscal, discal], [MakeVector('int32')(aiscal, biscal, ciscal, discal)], [aiscal_val, biscal_val, ciscal_val, discal_val], MakeVector)
def test_shape_i_scalar(self): # Each axis is treated independently by shape_i/shape operators mode_opt = self.mode.including("fast_run") v_data = numpy.array(numpy.arange(5), dtype=self.dtype) t_data = self.shared(v_data) start = tensor.iscalar('b') stop = tensor.iscalar('e') step = tensor.iscalar('s') f = self.function([start, stop, step], t_data[start:stop:step].shape, mode=mode_opt, op=self.ops, N=0) assert tensor.Subtensor not in [x.op for x in f.maker. fgraph.toposort()] for start in [-8, -5, -4, -1, 0, 1, 4, 5, 8]: for stop in [-8, -5, -4, -1, 0, 1, 4, 5, 8]: for step in [-3, -1, 2, 5]: assert numpy.all(f(start, stop, step) == v_data[start:stop:step].shape)
def test_slice_canonical_form_0(self): start = tensor.iscalar('b') stop = tensor.iscalar('e') step = tensor.iscalar('s') length = tensor.iscalar('l') cnf = get_canonical_form_slice(slice(start, stop, step), length) f = self.function([start, stop, step, length], [ tensor.as_tensor_variable(cnf[0].start), tensor.as_tensor_variable(cnf[0].stop), tensor.as_tensor_variable(cnf[0].step), tensor.as_tensor_variable(cnf[1])], N=0, op=self.ops) length = 5 a = numpy.arange(length) for start in [-8, -5, -4, -1, 0, 1, 4, 5, 8]: for stop in [-8, -5, -4, -1, 0, 1, 4, 5, 8]: for step in [-6, -3, -1, 2, 5]: out = f(start, stop, step, length) t_out = a[out[0]:out[1]:out[2]][::out[3]] v_out = a[start:stop:step] assert numpy.all(t_out == v_out) assert numpy.all(t_out.shape == v_out.shape)
def test_slice_canonical_form_1(self): stop = tensor.iscalar('e') step = tensor.iscalar('s') length = tensor.iscalar('l') cnf = get_canonical_form_slice(slice(None, stop, step), length) f = self.function([stop, step, length], [ tensor.as_tensor_variable(cnf[0].start), tensor.as_tensor_variable(cnf[0].stop), tensor.as_tensor_variable(cnf[0].step), tensor.as_tensor_variable(cnf[1])], N=0, op=self.ops) length = 5 a = numpy.arange(length) for stop in [-8, -5, -4, -1, 0, 1, 4, 5, 8]: for step in [-6, -3, -1, 2, 5]: out = f(stop, step, length) t_out = a[out[0]:out[1]:out[2]][::out[3]] v_out = a[:stop:step] assert numpy.all(t_out == v_out) assert numpy.all(t_out.shape == v_out.shape)
def test_slice_canonical_form_2(self): start = tensor.iscalar('b') step = tensor.iscalar('s') length = tensor.iscalar('l') cnf = get_canonical_form_slice(slice(start, None, step), length) f = self.function([start, step, length], [ tensor.as_tensor_variable(cnf[0].start), tensor.as_tensor_variable(cnf[0].stop), tensor.as_tensor_variable(cnf[0].step), tensor.as_tensor_variable(cnf[1])], N=0, op=self.ops) length = 5 a = numpy.arange(length) for start in [-8, -5, -4, -1, 0, 1, 4, 5, 8]: for step in [-6, -3, -1, 2, 5]: out = f(start, step, length) t_out = a[out[0]:out[1]:out[2]][::out[3]] v_out = a[start:None:step] assert numpy.all(t_out == v_out) assert numpy.all(t_out.shape == v_out.shape)
def test_slice_canonical_form_4(self): step = tensor.iscalar('s') length = tensor.iscalar('l') cnf = get_canonical_form_slice(slice(None, None, step), length) f = self.function([step, length], [ tensor.as_tensor_variable(cnf[0].start), tensor.as_tensor_variable(cnf[0].stop), tensor.as_tensor_variable(cnf[0].step), tensor.as_tensor_variable(cnf[1])], N=0, op=self.ops) length = 5 a = numpy.arange(length) for step in [-6, -3, -1, 2, 5]: out = f(step, length) t_out = a[out[0]:out[1]:out[2]][::out[3]] v_out = a[None:None:step] assert numpy.all(t_out == v_out) assert numpy.all(t_out.shape == v_out.shape)
def test_slice_canonical_form_5(self): start = tensor.iscalar('b') length = tensor.iscalar('l') cnf = get_canonical_form_slice(slice(start, None, None), length) f = self.function([start, length], [ tensor.as_tensor_variable(cnf[0].start), tensor.as_tensor_variable(cnf[0].stop), tensor.as_tensor_variable(cnf[0].step), tensor.as_tensor_variable(cnf[1])], N=0, op=self.ops) length = 5 a = numpy.arange(length) for start in [-8, -5, -4, -1, 0, 1, 4, 5, 8]: out = f(start, length) t_out = a[out[0]:out[1]:out[2]][::out[3]] v_out = a[start:None:None] assert numpy.all(t_out == v_out) assert numpy.all(t_out.shape == v_out.shape)
def test_slice_canonical_form_6(self): stop = tensor.iscalar('e') length = tensor.iscalar('l') cnf = get_canonical_form_slice(slice(None, stop, None), length) f = self.function([stop, length], [ tensor.as_tensor_variable(cnf[0].start), tensor.as_tensor_variable(cnf[0].stop), tensor.as_tensor_variable(cnf[0].step), tensor.as_tensor_variable(cnf[1])], N=0, op=self.ops) length = 5 a = numpy.arange(length) for stop in [-8, -5, -4, -1, 0, 1, 4, 5, 8]: out = f(stop, length) t_out = a[out[0]:out[1]:out[2]][::out[3]] v_out = a[None:stop:None] assert numpy.all(t_out == v_out) assert numpy.all(t_out.shape == v_out.shape)
def test_impls(self): i = iscalar() ii = lscalar() d = dscalar() f = fscalar() c = cscalar() assert numpy.allclose(function([i, d], i / d)(5, 7.0), (5.0 / 7.0)) assert numpy.allclose(function([i, d], d / i)(5, 7.0), (7.0 / 5.0)) assert numpy.allclose(function([i, f], i / f)(5, 11.0), (5.0 / 11.0)) assert numpy.allclose(function([i, f], f / i)(5, 11.0), (11.0 / 5.0)) assert numpy.allclose(function([i, ii], i // ii)(5, 3), (5 // 3)) assert numpy.allclose(function([i, ii], ii // i)(5, 3), (3 // 5)) assert numpy.allclose(function([i, ii], true_div(i, ii))(5, 3), (5. / 3.)) assert numpy.allclose(function([i, ii], true_div(ii, i))(5, 3), (3. / 5.)) assert numpy.allclose(function([i, c], i / c)(5, numpy.complex(5, 3)), (5. / (5 + 3j))) assert numpy.allclose(function([i, c], c / i)(5, numpy.complex(5, 3)), ((5 + 3j) / 5.))
def test_get_scalar_constant_value(self): a = tensor.stack([1, 2, 3]) assert get_scalar_constant_value(a[0]) == 1 assert get_scalar_constant_value(a[1]) == 2 assert get_scalar_constant_value(a[2]) == 3 b = tensor.iscalar() a = tensor.stack([b, 2, 3]) self.assertRaises(tensor.basic.NotScalarConstantError, get_scalar_constant_value, a[0]) assert get_scalar_constant_value(a[1]) == 2 assert get_scalar_constant_value(a[2]) == 3 # For now get_scalar_constant_value goes through only MakeVector and Join of # scalars. v = tensor.ivector() a = tensor.stack([v, [2], [3]]) self.assertRaises(tensor.NotScalarConstantError, get_scalar_constant_value, a[0]) self.assertRaises(tensor.NotScalarConstantError, get_scalar_constant_value, a[1]) self.assertRaises(tensor.NotScalarConstantError, get_scalar_constant_value, a[2]) # Test the case SubTensor(Shape(v)) when the dimensions # is broadcastable. v = tensor.row() assert get_scalar_constant_value(v.shape[0]) == 1
def test_infer_shape(self): a = tensor.dvector() self._compile_and_check([a], [self.op(a, 16, 0)], [numpy.random.rand(12)], self.op_class) a = tensor.dmatrix() for var in [self.op(a, 16, 1), self.op(a, None, 1), self.op(a, 16, None), self.op(a, None, None)]: self._compile_and_check([a], [var], [numpy.random.rand(12, 4)], self.op_class) b = tensor.iscalar() for var in [self.op(a, 16, b), self.op(a, None, b)]: self._compile_and_check([a, b], [var], [numpy.random.rand(12, 4), 0], self.op_class)
def setUp(self): self.k = T.iscalar("k") self.A = T.vector("A") result, _ = theano.scan( fn=lambda prior_result, A: prior_result * A, outputs_info=T.ones_like(self.A), non_sequences=self.A, n_steps=self.k) result_check, _ = theano.scan_checkpoints( fn=lambda prior_result, A: prior_result * A, outputs_info=T.ones_like(self.A), non_sequences=self.A, n_steps=self.k, save_every_N=100) self.result = result[-1] self.result_check = result_check[-1] self.grad_A = T.grad(self.result.sum(), self.A) self.grad_A_check = T.grad(self.result_check.sum(), self.A)
def test_grad_dtype_change(self): x = tensor.fscalar('x') y = tensor.fscalar('y') c = tensor.iscalar('c') def inner_fn(cond, x, y): new_cond = tensor.cast(tensor.switch(cond, x, y), 'int32') new_x = tensor.switch(cond, tensor.nnet.sigmoid(y * x), x) new_y = tensor.switch(cond, y, tensor.nnet.sigmoid(x)) return new_cond, new_x, new_y values, _ = theano.scan( inner_fn, outputs_info=[c, x, y], n_steps=10, truncate_gradient=-1, go_backwards=False) gX, gY = tensor.grad(values[1].sum(), [x, y]) f = theano.function([c, x, y], [gX, gY], allow_input_downcast=True) # Check for runtime errors f(numpy.int32(0), numpy.float32(1.), numpy.float32(.5))
def test_only_shared_no_input_no_output(self): rng = numpy.random.RandomState(utt.fetch_seed()) v_state = asarrayX(rng.uniform()) state = theano.shared(v_state, 'vstate') def f_2(): return OrderedDict([(state, 2 * state)]) n_steps = theano.tensor.iscalar('nstep') output, updates = theano.scan(f_2, [], [], [], n_steps=n_steps, truncate_gradient=-1, go_backwards=False) this_f = theano.function([n_steps], output, updates=updates, allow_input_downcast=True) n_steps = 3 this_f(n_steps) numpy_state = v_state * (2 ** (n_steps)) utt.assert_allclose(state.get_value(), numpy_state)
def test_n_samples_2(): p = tensor.fmatrix() u = tensor.fvector() n = tensor.iscalar() m = multinomial.MultinomialFromUniform('auto')(p, u, n) f = function([p, u, n], m, allow_input_downcast=True) numpy.random.seed(12345) for i in [1, 5, 10, 100, 1000]: uni = numpy.random.rand(i).astype(config.floatX) pvals = numpy.random.randint(1, 1000, (1, 1000)).astype(config.floatX) pvals /= pvals.sum(1) res = f(pvals, uni, i) assert res.sum() == i for i in [1, 5, 10, 100, 1000]: uni = numpy.random.rand(i).astype(config.floatX) pvals = numpy.random.randint( 1, 1000000, (1, 1000000)).astype(config.floatX) pvals /= pvals.sum(1) res = f(pvals, uni, i) assert res.sum() == i
def setUp(self): super(Test_local_elemwise_alloc, self).setUp() self.fast_run_mode = mode_with_gpu # self.vec = tensor.vector('vec', dtype=dtype) # self.mat = tensor.matrix('mat', dtype=dtype) # self.tens = tensor.tensor3('tens', dtype=dtype) # self.alloc_wo_dep = basic_ops.gpu_alloc(self.vec, 2, 2) # self.alloc_w_dep = basic_ops.gpu_alloc(self.vec, *self.mat.shape) self.alloc_wo_dep = basic_ops.gpu_alloc(self.vec, 2, 2) self.alloc_w_dep = basic_ops.gpu_alloc(self.vec, *self.mat.shape) self.alloc_w_dep_tens = basic_ops.gpu_alloc( self.vec, self.tens.shape[0], self.tens.shape[1] ) self.tv_wo_dep = basic_ops.gpu_alloc(self.vec, 5, 5) self.tm_wo_dep = basic_ops.gpu_alloc(self.mat, 5, 5, 5) self.s = tensor.iscalar('s') self.tv_w_dep = basic_ops.gpu_alloc(self.vec, self.s, self.s) self.tm_w_dep = basic_ops.gpu_alloc(self.mat, 5, 5, 5) self.row = tensor.row(dtype=self.dtype) self.o = basic_ops.gpu_alloc(self.row, 5, 5)
def test_load_params(self): window = T.iscalar('theta') inputs1 = T.tensor3('inputs1', dtype='float32') mask = T.matrix('mask', dtype='uint8') network = deltanet_majority_vote.load_saved_model('../oulu/results/best_models/1stream_mfcc_w3s3.6.pkl', ([500, 200, 100, 50], [rectify, rectify, rectify, linear]), (None, None, 91), inputs1, (None, None), mask, 250, window, 10) d = deltanet_majority_vote.extract_encoder_weights(network, ['fc1', 'fc2', 'fc3', 'bottleneck'], [('w1', 'b1'), ('w2', 'b2'), ('w3', 'b3'), ('w4', 'b4')]) b = deltanet_majority_vote.extract_lstm_weights(network, ['f_blstm1', 'b_blstm1'], ['flstm', 'blstm']) expected_keys = ['w1', 'w2', 'w3', 'w4', 'b1', 'b2', 'b3', 'b4'] keys = d.keys() for k in keys: assert k in expected_keys assert type(d[k]) == np.ndarray save_mat(d, '../oulu/models/oulu_1stream_mfcc_w3s3.mat')
def main(): """ test runner, computes delta for an array of sequences :return: None """ A = T.tensor3('A', dtype='float32') theta = T.iscalar('theta') # compute delta coefficients for multiple sequences results, updates = theano.scan(append_delta_coeff, sequences=A, non_sequences=theta) compute_deltas = theano.function([A, theta], outputs=results, updates=updates) seqs = np.array([[[1, 2, 3, 4, 5], [10, 12, 13, 14, 15], [300, 1, 23, 56, 22]], [[1, 1, 1, 1, 1], [1, 1, 100, 1, 1], [1, 1, 1, 1, 1]]], dtype='float32') res = compute_deltas(seqs, 1) print(res)
def main(): options = parse_options() print(options) window = T.iscalar('theta') inputs1 = T.tensor3('inputs1', dtype='float32') mask = T.matrix('mask', dtype='uint8') shape = [int(i) for i in options['shape'].split(',')] nonlinearities = [select_nonlinearity(s) for s in options['nonlinearities'].split(',')] network = deltanet_majority_vote.load_saved_model(options['input'], (shape, nonlinearities), (None, None, options['input_dim']), inputs1, (None, None), mask, options['lstm_size'], window, options['output_classes'], use_blstm=options['use_blstm']) d = deltanet_majority_vote.extract_encoder_weights(network, ['fc1', 'fc2', 'fc3', 'bottleneck'], [('w1', 'b1'), ('w2', 'b2'), ('w3', 'b3'), ('w4', 'b4')]) expected_keys = ['w1', 'w2', 'w3', 'w4', 'b1', 'b2', 'b3', 'b4'] keys = d.keys() for k in keys: assert k in expected_keys assert type(d[k]) == np.ndarray if 'output' in options: print('save extracted weights to {}'.format(options['output'])) save_mat(d, options['output'])
def create_model(dbn, input_shape, input_var, mask_shape, mask_var, lstm_size=250, win=T.iscalar('theta)'), output_classes=26): dbn_layers = dbn.get_all_layers() weights = [] biases = [] weights.append(dbn_layers[1].W.astype('float32')) weights.append(dbn_layers[2].W.astype('float32')) weights.append(dbn_layers[3].W.astype('float32')) weights.append(dbn_layers[4].W.astype('float32')) biases.append(dbn_layers[1].b.astype('float32')) biases.append(dbn_layers[2].b.astype('float32')) biases.append(dbn_layers[3].b.astype('float32')) biases.append(dbn_layers[4].b.astype('float32')) return create_model_using_pretrained_encoder(weights, biases, input_shape, input_var, mask_shape, mask_var, lstm_size, win, output_classes)
def __init__(self, in_size, out_size, hidden_size, cell = "gru", optimizer = "rmsprop", p = 0.5, num_sents = 1): self.X = T.matrix("X") self.Y_left = T.matrix("Y_left") self.Y_right = T.matrix("Y_right") self.in_size = in_size self.out_size = out_size self.hidden_size = hidden_size self.cell = cell self.drop_rate = p self.num_sents = num_sents self.is_train = T.iscalar('is_train') # for dropout self.batch_size = T.iscalar('batch_size') # for mini-batch training self.mask = T.matrix("mask") self.mask_y_left = T.matrix("mask_y_left") self.mask_y_right = T.matrix("mask_y_right") self.optimizer = optimizer self.define_layers() self.define_train_test_funcs()
def run(self, params, loss): m = theano.shared(np.zeros(params.shape.eval()), borrow=True, name='m') v = theano.shared(np.zeros(params.shape.eval()), borrow=True, name='v') grad = T.grad(loss, params) norm_grad = grad.norm(2) m_t = self.beta1 * m + (1 - self.beta1) * grad v_t = self.beta2 * v + (1 - self.beta2) * T.pow(grad, 2) step = T.iscalar(name='step') update_rules = [(params, params - self.lr * (m_t / (1.0 - T.pow(self.beta1, step)) / (T.sqrt(v_t / (1.0 - T.pow(self.beta2, step))) + self.stable))), (m, m_t), (v, v_t)] train_epoch = theano.function([step], [loss, norm_grad], updates=update_rules) for epoch in xrange(self.max_epoch): loss, grad = train_epoch(epoch + 1) norm_l2 = norm(grad) print("epoch = %d\t loss = %f\t norm = %f" %(epoch + 1, loss, norm_l2), end='') print() if norm_l2 < self.eps: break
def __init__(self, game_params, arch_params, solver_params, trained_model, sn_dir): params=None if trained_model: params = common.load_params(trained_model) self.lr_func = create_learning_rate_func(solver_params) self.v_h_0 = tt.fvector('v_h_0') self.x_h_0 = tt.fvector('x_h_0') self.v_t_0 = tt.fmatrix('v_t_0') self.x_t_0 = tt.fmatrix('x_t_0') self.a_t_0 = tt.fmatrix('a_t_0') self.is_aggressive = tt.fmatrix('is_aggressive') self.lr_ = tt.fscalar('lr') self.n_steps_ = tt.iscalar('n_steps') self.sn_dir = sn_dir self.game_params = game_params self.arch_params = arch_params self.solver_params = solver_params self.model = CONTROLLER(self.v_h_0, self.x_h_0, self.v_t_0, self.x_t_0, self.a_t_0, self.is_aggressive, self.lr_, self.n_steps_, self.game_params, self.arch_params, self.solver_params, params)
