本文整理汇总了Python中theano.tensor.tensor4方法的典型用法代码示例。如果您正苦于以下问题:Python tensor.tensor4方法的具体用法?Python tensor.tensor4怎么用?Python tensor.tensor4使用的例子?那么, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类theano.tensor
的用法示例。
在下文中一共展示了tensor.tensor4方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: test_cmrnorm
# 需要导入模块: from theano import tensor [as 别名]
# 或者: from theano.tensor import tensor4 [as 别名]
def test_cmrnorm():
from theano.tests.unittest_tools import verify_grad
xtest = np.random.rand(2,8,3,4)
xtest = xtest.astype(theano.config.floatX)
x = T.tensor4('x', dtype=theano.config.floatX)
x.tag.test_value = xtest
y = cmrnorm(x, input_shape=xtest.shape[1:])
f = theano.function([x], y, mode='DEBUG_MODE')
f(xtest)
f = theano.function([x], gpu_from_host(T.grad(T.sum(y), wrt=x)),
mode='DEBUG_MODE')
f(xtest)
theano.printing.debugprint(f)
T.verify_grad(lambda x: cmrnorm(x, input_shape=xtest.shape[1:]),
(xtest,),
rng=np.random.RandomState(0))
print 'cmrnorm passed'
示例2: __init__
# 需要导入模块: from theano import tensor [as 别名]
# 或者: from theano.tensor import tensor4 [as 别名]
def __init__(self, random_seed=dt.datetime.now().microsecond, compute_grad=True):
self.rng = np.random.RandomState(random_seed)
self.batch_size = cfg.CONST.BATCH_SIZE
self.img_w = cfg.CONST.IMG_W
self.img_h = cfg.CONST.IMG_H
self.n_vox = cfg.CONST.N_VOX
self.compute_grad = compute_grad
# (self.batch_size, 3, self.img_h, self.img_w),
# override x and is_x_tensor4 when using multi-view network
self.x = tensor.tensor4()
self.is_x_tensor4 = True
# (self.batch_size, self.n_vox, 2, self.n_vox, self.n_vox),
self.y = tensor5()
self.activations = [] # list of all intermediate activations
self.loss = [] # final loss
self.output = [] # final output
self.error = [] # final output error
self.params = [] # all learnable params
self.grads = [] # will be filled out automatically
self.setup()
示例3: __init__
# 需要导入模块: from theano import tensor [as 别名]
# 或者: from theano.tensor import tensor4 [as 别名]
def __init__(self,convolutional_layers,feature_maps,filter_shapes,poolsize,feedforward_layers,feedforward_nodes,classes,learning_rate,regularization):
self.input = T.tensor4()
self.convolutional_layers = []
self.convolutional_layers.append(convolutional_layer(self.input,feature_maps[1],feature_maps[0],filter_shapes[0][0],filter_shapes[0][1],poolsize[0]))
for i in range(1,convolutional_layers):
self.convolutional_layers.append(convolutional_layer(self.convolutional_layers[i-1].output,feature_maps[i+1],feature_maps[i],filter_shapes[i][0],filter_shapes[i][1],poolsize[i]))
self.feedforward_layers = []
self.feedforward_layers.append(feedforward_layer(self.convolutional_layers[-1].output.flatten(2),flattened,feedforward_nodes[0]))
for i in range(1,feedforward_layers):
self.feedforward_layers.append(feedforward_layer(self.feedforward_layers[i-1].output,feedforward_nodes[i-1],feedforward_nodes[i]))
self.output_layer = feedforward_layer(self.feedforward_layers[-1].output,feedforward_nodes[-1],classes)
self.params = []
for l in self.convolutional_layers + self.feedforward_layers:
self.params.extend(l.get_params())
self.params.extend(self.output_layer.get_params())
self.target = T.matrix()
self.output = self.output_layer.output
self.cost = -self.target*T.log(self.output)-(1-self.target)*T.log(1-self.output)
self.cost = self.cost.mean()
for i in range(convolutional_layers+feedforward_layers+1):
self.cost += regularization*(self.params[2*i]**2).mean()
self.gparams = [T.grad(self.cost, param) for param in self.params]
self.propogate = theano.function([self.input,self.target],self.cost,updates=[(param,param-learning_rate*gparam) for param,gparam in zip(self.params,self.gparams)],allow_input_downcast=True)
self.classify = theano.function([self.input],self.output,allow_input_downcast=True)
示例4: __init__
# 需要导入模块: from theano import tensor [as 别名]
# 或者: from theano.tensor import tensor4 [as 别名]
def __init__(self,convolutional_layers,feature_maps,filter_shapes,poolsize,feedforward_layers,feedforward_nodes,classes,regularization):
self.input = T.tensor4()
self.convolutional_layers = []
self.convolutional_layers.append(convolutional_layer(self.input,feature_maps[1],feature_maps[0],filter_shapes[0][0],filter_shapes[0][1],poolsize[0]))
for i in range(1,convolutional_layers):
self.convolutional_layers.append(convolutional_layer(self.convolutional_layers[i-1].output,feature_maps[i+1],feature_maps[i],filter_shapes[i][0],filter_shapes[i][1],poolsize[i]))
self.feedforward_layers = []
self.feedforward_layers.append(feedforward_layer(self.convolutional_layers[-1].output.flatten(2),flattened,feedforward_nodes[0]))
for i in range(1,feedforward_layers):
self.feedforward_layers.append(feedforward_layer(self.feedforward_layers[i-1].output,feedforward_nodes[i-1],feedforward_nodes[i]))
self.output_layer = feedforward_layer(self.feedforward_layers[-1].output,feedforward_nodes[-1],classes)
self.params = []
for l in self.convolutional_layers + self.feedforward_layers:
self.params.extend(l.get_params())
self.params.extend(self.output_layer.get_params())
self.target = T.matrix()
self.output = self.output_layer.output
self.cost = -self.target*T.log(self.output)-(1-self.target)*T.log(1-self.output)
self.cost = self.cost.mean()
for i in range(convolutional_layers+feedforward_layers+1):
self.cost += regularization*(self.params[2*i]**2).mean()
self.updates = self.adam(self.cost,self.params)
self.propogate = theano.function([self.input,self.target],self.cost,updates=self.updates,allow_input_downcast=True)
self.classify = theano.function([self.input],self.output,allow_input_downcast=True)
示例5: __init__
# 需要导入模块: from theano import tensor [as 别名]
# 或者: from theano.tensor import tensor4 [as 别名]
def __init__(self,convolutional_layers,feature_maps,filter_shapes,feedforward_layers,feedforward_nodes,classes):
self.input = T.tensor4()
self.convolutional_layers = []
self.convolutional_layers.append(convolutional_layer(self.input,feature_maps[1],feature_maps[0],filter_shapes[0][0],filter_shapes[0][1]))
for i in range(1,convolutional_layers):
if i==2 or i==4:
self.convolutional_layers.append(convolutional_layer(self.convolutional_layers[i-1].output,feature_maps[i+1],feature_maps[i],filter_shapes[i][0],filter_shapes[i][1],maxpool=(2,2)))
else:
self.convolutional_layers.append(convolutional_layer(self.convolutional_layers[i-1].output,feature_maps[i+1],feature_maps[i],filter_shapes[i][0],filter_shapes[i][1]))
self.feedforward_layers = []
self.feedforward_layers.append(feedforward_layer(self.convolutional_layers[-1].output.flatten(2),20480,feedforward_nodes[0]))
for i in range(1,feedforward_layers):
self.feedforward_layers.append(feedforward_layer(self.feedforward_layers[i-1].output,feedforward_nodes[i-1],feedforward_nodes[i]))
self.output_layer = feedforward_layer(self.feedforward_layers[-1].output,feedforward_nodes[-1],classes)
self.params = []
for l in self.convolutional_layers + self.feedforward_layers:
self.params.extend(l.get_params())
self.params.extend(self.output_layer.get_params())
self.target = T.matrix()
self.output = self.output_layer.output
self.cost = -self.target*T.log(self.output)-(1-self.target)*T.log(1-self.output)
self.cost = self.cost.mean()
self.updates = self.adam(self.cost, self.params)
self.propogate = theano.function([self.input,self.target],self.cost,updates=self.updates,allow_input_downcast=True)
self.classify = theano.function([self.input],self.output,allow_input_downcast=True)
示例6: __init__
# 需要导入模块: from theano import tensor [as 别名]
# 或者: from theano.tensor import tensor4 [as 别名]
def __init__(self,convolutional_layers,feature_maps,filter_shapes,feedforward_layers,feedforward_nodes,classes):
self.input = T.tensor4()
self.convolutional_layers = []
self.convolutional_layers.append(convolutional_layer(self.input,feature_maps[1],feature_maps[0],filter_shapes[0][0],filter_shapes[0][1]))
for i in range(1,convolutional_layers):
if i==3:
self.convolutional_layers.append(convolutional_layer(self.convolutional_layers[i-1].output,feature_maps[i+1],feature_maps[i],filter_shapes[i][0],filter_shapes[i][1],maxpool=(2,2)))
else:
self.convolutional_layers.append(convolutional_layer(self.convolutional_layers[i-1].output,feature_maps[i+1],feature_maps[i],filter_shapes[i][0],filter_shapes[i][1]))
self.feedforward_layers = []
self.feedforward_layers.append(feedforward_layer(self.convolutional_layers[-1].output.flatten(2),40000,feedforward_nodes[0]))
for i in range(1,feedforward_layers):
self.feedforward_layers.append(feedforward_layer(self.feedforward_layers[i-1].output,feedforward_nodes[i-1],feedforward_nodes[i]))
self.output_layer = feedforward_layer(self.feedforward_layers[-1].output,feedforward_nodes[-1],classes)
self.params = []
for l in self.convolutional_layers + self.feedforward_layers:
self.params.extend(l.get_params())
self.params.extend(self.output_layer.get_params())
self.target = T.matrix()
self.output = self.output_layer.output
self.cost = -self.target*T.log(self.output)-(1-self.target)*T.log(1-self.output)
self.cost = self.cost.mean()
self.updates = self.adam(self.cost, self.params)
self.propogate = theano.function([self.input,self.target],self.cost,updates=self.updates,allow_input_downcast=True)
self.classify = theano.function([self.input],self.output,allow_input_downcast=True)
示例7: test_broadcast_grad
# 需要导入模块: from theano import tensor [as 别名]
# 或者: from theano.tensor import tensor4 [as 别名]
def test_broadcast_grad():
rng = numpy.random.RandomState(utt.fetch_seed())
x1 = T.tensor4('x')
x1_data = rng.randn(1, 1, 300, 300)
sigma = T.scalar('sigma')
sigma_data = 20
window_radius = 3
filter_1d = T.arange(-window_radius, window_radius+1)
filter_1d = filter_1d.astype(theano.config.floatX)
filter_1d = T.exp(-0.5*filter_1d**2/sigma**2)
filter_1d = filter_1d / filter_1d.sum()
filter_W = filter_1d.dimshuffle(['x', 'x', 0, 'x'])
y = theano.tensor.nnet.conv2d(x1, filter_W, border_mode='full',
filter_shape=[1, 1, None, None])
theano.grad(y.sum(), sigma)
示例8: test_max_pool_2d_2D_same_size
# 需要导入模块: from theano import tensor [as 别名]
# 或者: from theano.tensor import tensor4 [as 别名]
def test_max_pool_2d_2D_same_size(self):
rng = numpy.random.RandomState(utt.fetch_seed())
test_input_array = numpy.array([[[
[1., 2., 3., 4.],
[5., 6., 7., 8.]
]]]).astype(theano.config.floatX)
test_answer_array = numpy.array([[[
[0., 0., 0., 0.],
[0., 6., 0., 8.]
]]]).astype(theano.config.floatX)
input = tensor.tensor4(name='input')
patch_size = (2, 2)
op = max_pool_2d_same_size(input, patch_size)
op_output = function([input], op)(test_input_array)
utt.assert_allclose(op_output, test_answer_array)
def mp(input):
return max_pool_2d_same_size(input, patch_size)
utt.verify_grad(mp, [test_input_array], rng=rng)
示例9: test_conv2d
# 需要导入模块: from theano import tensor [as 别名]
# 或者: from theano.tensor import tensor4 [as 别名]
def test_conv2d(x_shape, num_filters, filter_size, flip_filters, batch_size=2):
X_var = T.tensor4('X')
l_x = L.InputLayer(shape=(None,) + x_shape, input_var=X_var, name='x')
X = np.random.random((batch_size,) + x_shape).astype(theano.config.floatX)
l_conv = L.Conv2DLayer(l_x, num_filters, filter_size=filter_size, stride=1, pad='same',
flip_filters=flip_filters, untie_biases=True, nonlinearity=None, b=None)
conv_var = L.get_output(l_conv)
conv_fn = theano.function([X_var], conv_var)
tic()
conv = conv_fn(X)
toc("conv time for x_shape=%r, num_filters=%r, filter_size=%r, flip_filters=%r, batch_size=%r\n\t" %
(x_shape, num_filters, filter_size, flip_filters, batch_size))
tic()
loop_conv = conv2d(X, l_conv.W.get_value(), flip_filters=flip_filters)
toc("loop conv time for x_shape=%r, num_filters=%r, filter_size=%r, flip_filters=%r, batch_size=%r\n\t" %
(x_shape, num_filters, filter_size, flip_filters, batch_size))
assert np.allclose(conv, loop_conv, atol=1e-6)
示例10: test_locally_connected2d
# 需要导入模块: from theano import tensor [as 别名]
# 或者: from theano.tensor import tensor4 [as 别名]
def test_locally_connected2d(x_shape, num_filters, filter_size, flip_filters, batch_size=2):
X_var = T.tensor4('X')
l_x = L.InputLayer(shape=(None,) + x_shape, input_var=X_var, name='x')
X = np.random.random((batch_size,) + x_shape).astype(theano.config.floatX)
l_conv = LT.LocallyConnected2DLayer(l_x, num_filters, filter_size=filter_size, stride=1, pad='same',
flip_filters=flip_filters, untie_biases=True, nonlinearity=None, b=None)
conv_var = L.get_output(l_conv)
conv_fn = theano.function([X_var], conv_var)
tic()
conv = conv_fn(X)
toc("locally connected time for x_shape=%r, num_filters=%r, filter_size=%r, flip_filters=%r, batch_size=%r\n\t" %
(x_shape, num_filters, filter_size, flip_filters, batch_size))
tic()
loop_conv = locally_connected2d(X, l_conv.W.get_value(), flip_filters=flip_filters)
toc("loop locally connected time for x_shape=%r, num_filters=%r, filter_size=%r, flip_filters=%r, batch_size=%r\n\t" %
(x_shape, num_filters, filter_size, flip_filters, batch_size))
assert np.allclose(conv, loop_conv, atol=1e-6)
示例11: test_channelwise_locally_connected2d
# 需要导入模块: from theano import tensor [as 别名]
# 或者: from theano.tensor import tensor4 [as 别名]
def test_channelwise_locally_connected2d(x_shape, filter_size, flip_filters, batch_size=2):
X_var = T.tensor4('X')
l_x = L.InputLayer(shape=(None,) + x_shape, input_var=X_var, name='x')
X = np.random.random((batch_size,) + x_shape).astype(theano.config.floatX)
l_conv = LT.LocallyConnected2DLayer(l_x, x_shape[0], filter_size=filter_size, channelwise=True,
stride=1, pad='same', flip_filters=flip_filters,
untie_biases=True, nonlinearity=None, b=None)
conv_var = L.get_output(l_conv)
conv_fn = theano.function([X_var], conv_var)
tic()
conv = conv_fn(X)
toc("channelwise locally connected time for x_shape=%r, filter_size=%r, flip_filters=%r, batch_size=%r\n\t" %
(x_shape, filter_size, flip_filters, batch_size))
tic()
loop_conv = channelwise_locally_connected2d(X, l_conv.W.get_value(), flip_filters=flip_filters)
toc("loop channelwise locally connected time for x_shape=%r, filter_size=%r, flip_filters=%r, batch_size=%r\n\t" %
(x_shape, filter_size, flip_filters, batch_size))
assert np.allclose(conv, loop_conv, atol=1e-7)
示例12: build_bilinear_net
# 需要导入模块: from theano import tensor [as 别名]
# 或者: from theano.tensor import tensor4 [as 别名]
def build_bilinear_net(input_shapes, X_var=None, U_var=None, X_diff_var=None, axis=1):
x_shape, u_shape = input_shapes
X_var = X_var or T.tensor4('X')
U_var = U_var or T.matrix('U')
X_diff_var = X_diff_var or T.tensor4('X_diff')
X_next_var = X_var + X_diff_var
l_x = L.InputLayer(shape=(None,) + x_shape, input_var=X_var)
l_u = L.InputLayer(shape=(None,) + u_shape, input_var=U_var)
l_x_diff_pred = LT.BilinearLayer([l_x, l_u], axis=axis)
l_x_next_pred = L.ElemwiseMergeLayer([l_x, l_x_diff_pred], T.add)
l_y = L.flatten(l_x)
l_y_diff_pred = L.flatten(l_x_diff_pred)
X_next_pred_var = lasagne.layers.get_output(l_x_next_pred)
loss = ((X_next_var - X_next_pred_var) ** 2).mean(axis=0).sum() / 2.
net_name = 'BilinearNet'
input_vars = OrderedDict([(var.name, var) for var in [X_var, U_var, X_diff_var]])
pred_layers = OrderedDict([('y_diff_pred', l_y_diff_pred), ('y', l_y), ('x0_next_pred', l_x_next_pred)])
return net_name, input_vars, pred_layers, loss
示例13: test
# 需要导入模块: from theano import tensor [as 别名]
# 或者: from theano.tensor import tensor4 [as 别名]
def test():
energies_var = T.tensor4('energies', dtype=theano.config.floatX)
targets_var = T.imatrix('targets')
masks_var = T.matrix('masks', dtype=theano.config.floatX)
layer_input = lasagne.layers.InputLayer([2, 2, 3, 3], input_var=energies_var)
out = lasagne.layers.get_output(layer_input)
loss = crf_loss(out, targets_var, masks_var)
prediction, acc = crf_accuracy(energies_var, targets_var)
fn = theano.function([energies_var, targets_var, masks_var], [loss, prediction, acc])
energies = np.array([[[[10, 15, 20], [5, 10, 15], [3, 2, 0]], [[5, 10, 1], [5, 10, 1], [5, 10, 1]]],
[[[5, 6, 7], [2, 3, 4], [2, 1, 0]], [[0, 0, 0], [0, 0, 0], [0, 0, 0]]]], dtype=np.float32)
targets = np.array([[0, 1], [0, 2]], dtype=np.int32)
masks = np.array([[1, 1], [1, 0]], dtype=np.float32)
l, p, a = fn(energies, targets, masks)
print l
print p
print a
示例14: __init__
# 需要导入模块: from theano import tensor [as 别名]
# 或者: from theano.tensor import tensor4 [as 别名]
def __init__(self):
metric_names = ['Loss','L2','Accuracy','Dice']
super(UNetTrainer, self).__init__(metric_names)
input_var = T.tensor4('inputs')
target_var = T.tensor4('targets', dtype='int64')
weight_var = T.tensor4('weights')
logging.info("Defining network")
net_dict = unet.define_network(input_var)
self.network = net_dict['out']
train_fn, val_fn, l_r = unet.define_updates(self.network, input_var, target_var, weight_var)
self.train_fn = train_fn
self.val_fn = val_fn
self.l_r = l_r
示例15: __init__
# 需要导入模块: from theano import tensor [as 别名]
# 或者: from theano.tensor import tensor4 [as 别名]
def __init__(self, model, algorithm, X, path, n_samples=49, **kwargs):
"""
Generate samples from the model. The do() function is called as an extension during training.
Generates 3 types of samples:
- Sample from generative model
- Sample from image denoising posterior distribution (default signal to noise of 1)
- Sample from image inpainting posterior distribution (inpaint left half of image)
"""
super(PlotSamples, self).__init__(**kwargs)
self.model = model
self.path = path
n_samples = np.min([n_samples, X.shape[0]])
self.X = X[:n_samples].reshape(
(n_samples, model.n_colors, model.spatial_width, model.spatial_width))
self.n_samples = n_samples
X_noisy = T.tensor4('X noisy samp', dtype=theano.config.floatX)
t = T.matrix('t samp', dtype=theano.config.floatX)
self.get_mu_sigma = theano.function([X_noisy, t], model.get_mu_sigma(X_noisy, t),
allow_input_downcast=True)