Python tensorflow.split() Examples
The following are 30
code examples of tensorflow.split().
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example.
You may also want to check out all available functions/classes of the module
tensorflow
, or try the search function
.
Example #1
Source File: video_utils.py From fine-lm with MIT License | 6 votes |
def is_generate_per_split(self): """A single call to `generate_samples` generates for all `dataset_splits`. Set to True if you already have distinct subsets of data for each dataset split specified in `self.dataset_splits`. `self.generate_samples` will be called once for each split. Set to False if you have a unified dataset that you'd like to have split out into training and evaluation data automatically. `self.generate_samples` will be called only once and the data will be sharded across the dataset splits specified in `self.dataset_splits`. Returns: bool """ raise NotImplementedError()
Example #2
Source File: gru_cell.py From DOTA_models with Apache License 2.0 | 6 votes |
def __call__(self, inputs, state, scope=None): """GRU cell with layer normalization.""" input_dim = inputs.get_shape().as_list()[1] num_units = self._num_units with tf.variable_scope(scope or "gru_cell"): with tf.variable_scope("gates"): w_h = tf.get_variable( "w_h", [num_units, 2 * num_units], initializer=self._w_h_initializer()) w_x = tf.get_variable( "w_x", [input_dim, 2 * num_units], initializer=self._w_x_initializer(input_dim)) z_and_r = (_layer_norm(tf.matmul(state, w_h), scope="layer_norm/w_h") + _layer_norm(tf.matmul(inputs, w_x), scope="layer_norm/w_x")) z, r = tf.split(tf.sigmoid(z_and_r), 2, 1) with tf.variable_scope("candidate"): w = tf.get_variable( "w", [input_dim, num_units], initializer=self._w_initializer) u = tf.get_variable( "u", [num_units, num_units], initializer=self._u_initializer) h_hat = (r * _layer_norm(tf.matmul(state, u), scope="layer_norm/u") + _layer_norm(tf.matmul(inputs, w), scope="layer_norm/w")) new_h = (1 - z) * state + z * self._activation(h_hat) return new_h, new_h
Example #3
Source File: real_nvp_utils.py From DOTA_models with Apache License 2.0 | 6 votes |
def batch_random_flip(input_): """Simultaneous horizontal random flip.""" if isinstance(input_, (float, int)): return input_ shape = input_.get_shape().as_list() batch_size = shape[0] height = shape[1] width = shape[2] channels = shape[3] res = tf.split(axis=0, num_or_size_splits=batch_size, value=input_) res = [elem[0, :, :, :] for elem in res] res = [tf.image.random_flip_left_right(elem) for elem in res] res = [tf.reshape(elem, [1, height, width, channels]) for elem in res] res = tf.concat(axis=0, values=res) return res # build a one hot representation corresponding to the integer tensor # the one-hot dimension is appended to the integer tensor shape
Example #4
Source File: utils.py From neural-fingerprinting with BSD 3-Clause "New" or "Revised" License | 6 votes |
def preprocess_batch(images_batch, preproc_func=None): """ Creates a preprocessing graph for a batch given a function that processes a single image. :param images_batch: A tensor for an image batch. :param preproc_func: (optional function) A function that takes in a tensor and returns a preprocessed input. """ if preproc_func is None: return images_batch with tf.variable_scope('preprocess'): images_list = tf.split(images_batch, int(images_batch.shape[0])) result_list = [] for img in images_list: reshaped_img = tf.reshape(img, img.shape[1:]) processed_img = preproc_func(reshaped_img) result_list.append(tf.expand_dims(processed_img, axis=0)) result_images = tf.concat(result_list, axis=0) return result_images
Example #5
Source File: tfutil.py From disentangling_conditional_gans with MIT License | 6 votes |
def init_uninited_vars(vars=None): if vars is None: vars = tf.global_variables() test_vars = []; test_ops = [] with tf.control_dependencies(None): # ignore surrounding control_dependencies for var in vars: assert is_tf_expression(var) try: tf.get_default_graph().get_tensor_by_name(var.name.replace(':0', '/IsVariableInitialized:0')) except KeyError: # Op does not exist => variable may be uninitialized. test_vars.append(var) with absolute_name_scope(var.name.split(':')[0]): test_ops.append(tf.is_variable_initialized(var)) init_vars = [var for var, inited in zip(test_vars, run(test_ops)) if not inited] run([var.initializer for var in init_vars]) #---------------------------------------------------------------------------- # Set the values of given tf.Variables. # Equivalent to the following, but more efficient and does not bloat the tf graph: # tfutil.run([tf.assign(var, value) for var, value in var_to_value_dict.items()]
Example #6
Source File: tfutil.py From disentangling_conditional_gans with MIT License | 6 votes |
def create_session(config_dict=dict(), force_as_default=False): config = tf.ConfigProto() for key, value in config_dict.items(): fields = key.split('.') obj = config for field in fields[:-1]: obj = getattr(obj, field) setattr(obj, fields[-1], value) session = tf.Session(config=config) if force_as_default: session._default_session = session.as_default() session._default_session.enforce_nesting = False session._default_session.__enter__() return session #---------------------------------------------------------------------------- # Initialize all tf.Variables that have not already been initialized. # Equivalent to the following, but more efficient and does not bloat the tf graph: # tf.variables_initializer(tf.report_unitialized_variables()).run()
Example #7
Source File: network_units.py From DOTA_models with Apache License 2.0 | 6 votes |
def get_layer_size(self, layer_name): if layer_name == 'logits': return self._component.num_actions if layer_name == 'last_layer': return self._hidden_layer_sizes[-1] if not layer_name.startswith('layer_'): logging.fatal( 'Invalid layer name: "%s" Can only retrieve from "logits", ' '"last_layer", and "layer_*".', layer_name) # NOTE(danielandor): Since get_layer_size is called before the # model has been built, we compute the layer size directly from # the hyperparameters rather than from self._layers. layer_index = int(layer_name.split('_')[1]) return self._hidden_layer_sizes[layer_index]
Example #8
Source File: keypoint_ops.py From DOTA_models with Apache License 2.0 | 6 votes |
def clip_to_window(keypoints, window, scope=None): """Clips keypoints to a window. This op clips any input keypoints to a window. Args: keypoints: a tensor of shape [num_instances, num_keypoints, 2] window: a tensor of shape [4] representing the [y_min, x_min, y_max, x_max] window to which the op should clip the keypoints. scope: name scope. Returns: new_keypoints: a tensor of shape [num_instances, num_keypoints, 2] """ with tf.name_scope(scope, 'ClipToWindow'): y, x = tf.split(value=keypoints, num_or_size_splits=2, axis=2) win_y_min, win_x_min, win_y_max, win_x_max = tf.unstack(window) y = tf.maximum(tf.minimum(y, win_y_max), win_y_min) x = tf.maximum(tf.minimum(x, win_x_max), win_x_min) new_keypoints = tf.concat([y, x], 2) return new_keypoints
Example #9
Source File: box_list_ops.py From DOTA_models with Apache License 2.0 | 6 votes |
def scale(boxlist, y_scale, x_scale, scope=None): """scale box coordinates in x and y dimensions. Args: boxlist: BoxList holding N boxes y_scale: (float) scalar tensor x_scale: (float) scalar tensor scope: name scope. Returns: boxlist: BoxList holding N boxes """ with tf.name_scope(scope, 'Scale'): y_scale = tf.cast(y_scale, tf.float32) x_scale = tf.cast(x_scale, tf.float32) y_min, x_min, y_max, x_max = tf.split( value=boxlist.get(), num_or_size_splits=4, axis=1) y_min = y_scale * y_min y_max = y_scale * y_max x_min = x_scale * x_min x_max = x_scale * x_max scaled_boxlist = box_list.BoxList( tf.concat([y_min, x_min, y_max, x_max], 1)) return _copy_extra_fields(scaled_boxlist, boxlist)
Example #10
Source File: box_list_ops.py From DOTA_models with Apache License 2.0 | 6 votes |
def intersection(boxlist1, boxlist2, scope=None): """Compute pairwise intersection areas between boxes. Args: boxlist1: BoxList holding N boxes boxlist2: BoxList holding M boxes scope: name scope. Returns: a tensor with shape [N, M] representing pairwise intersections """ with tf.name_scope(scope, 'Intersection'): y_min1, x_min1, y_max1, x_max1 = tf.split( value=boxlist1.get(), num_or_size_splits=4, axis=1) y_min2, x_min2, y_max2, x_max2 = tf.split( value=boxlist2.get(), num_or_size_splits=4, axis=1) all_pairs_min_ymax = tf.minimum(y_max1, tf.transpose(y_max2)) all_pairs_max_ymin = tf.maximum(y_min1, tf.transpose(y_min2)) intersect_heights = tf.maximum(0.0, all_pairs_min_ymax - all_pairs_max_ymin) all_pairs_min_xmax = tf.minimum(x_max1, tf.transpose(x_max2)) all_pairs_max_xmin = tf.maximum(x_min1, tf.transpose(x_min2)) intersect_widths = tf.maximum(0.0, all_pairs_min_xmax - all_pairs_max_xmin) return intersect_heights * intersect_widths
Example #11
Source File: box_list_ops.py From DOTA_models with Apache License 2.0 | 6 votes |
def matched_intersection(boxlist1, boxlist2, scope=None): """Compute intersection areas between corresponding boxes in two boxlists. Args: boxlist1: BoxList holding N boxes boxlist2: BoxList holding N boxes scope: name scope. Returns: a tensor with shape [N] representing pairwise intersections """ with tf.name_scope(scope, 'MatchedIntersection'): y_min1, x_min1, y_max1, x_max1 = tf.split( value=boxlist1.get(), num_or_size_splits=4, axis=1) y_min2, x_min2, y_max2, x_max2 = tf.split( value=boxlist2.get(), num_or_size_splits=4, axis=1) min_ymax = tf.minimum(y_max1, y_max2) max_ymin = tf.maximum(y_min1, y_min2) intersect_heights = tf.maximum(0.0, min_ymax - max_ymin) min_xmax = tf.minimum(x_max1, x_max2) max_xmin = tf.maximum(x_min1, x_min2) intersect_widths = tf.maximum(0.0, min_xmax - max_xmin) return tf.reshape(intersect_heights * intersect_widths, [-1])
Example #12
Source File: preprocessor.py From DOTA_models with Apache License 2.0 | 6 votes |
def flip_boxes(boxes): """Left-right flip the boxes. Args: boxes: rank 2 float32 tensor containing the bounding boxes -> [N, 4]. Boxes are in normalized form meaning their coordinates vary between [0, 1]. Each row is in the form of [ymin, xmin, ymax, xmax]. Returns: Flipped boxes. """ # Flip boxes. ymin, xmin, ymax, xmax = tf.split(value=boxes, num_or_size_splits=4, axis=1) flipped_xmin = tf.subtract(1.0, xmax) flipped_xmax = tf.subtract(1.0, xmin) flipped_boxes = tf.concat([ymin, flipped_xmin, ymax, flipped_xmax], 1) return flipped_boxes
Example #13
Source File: blocks_lstm.py From DOTA_models with Apache License 2.0 | 6 votes |
def _Apply(self, *args): xtransform = self._TransformInputs(*args) depth_axis = len(self._output_shape) - 1 if self.hidden is not None: htransform = self._TransformHidden(self.hidden) f, i, j, o = tf.split( value=htransform + xtransform, num_or_size_splits=4, axis=depth_axis) else: f, i, j, o = tf.split( value=xtransform, num_or_size_splits=4, axis=depth_axis) if self.cell is not None: self.cell = tf.sigmoid(f) * self.cell + tf.sigmoid(i) * tf.tanh(j) else: self.cell = tf.sigmoid(i) * tf.tanh(j) self.hidden = tf.sigmoid(o) * tf.tanh(self.cell) return self.hidden
Example #14
Source File: blocks_lstm.py From DOTA_models with Apache License 2.0 | 6 votes |
def _Apply(self, *args): xtransform = self._TransformInputs(*args) depth_axis = len(self._output_shape) - 1 if self.hidden is not None: htransform = self._TransformHidden(self.hidden) f, i, j, o = tf.split( value=htransform + xtransform, num_or_size_splits=4, axis=depth_axis) else: f, i, j, o = tf.split( value=xtransform, num_or_size_splits=4, axis=depth_axis) if self.cell is not None: self.cell = tf.sigmoid(f) * self.cell + tf.sigmoid(i) * tf.tanh(j) else: self.cell = tf.sigmoid(i) * tf.tanh(j) self.hidden = tf.sigmoid(o) * tf.tanh(self.cell) self._iter += 1 return self.hidden
Example #15
Source File: nn.py From cs294-112_hws with MIT License | 6 votes |
def call(self, inputs): mean_and_log_std = self.model(inputs) mean, log_std = tf.split(mean_and_log_std, num_or_size_splits=2, axis=1) log_std = tf.clip_by_value(log_std, -20., 2.) distribution = tfp.distributions.MultivariateNormalDiag( loc=mean, scale_diag=tf.exp(log_std) ) raw_actions = distribution.sample() if not self._reparameterize: ### Problem 1.3.A ### YOUR CODE HERE raw_actions = tf.stop_gradient(raw_actions) log_probs = distribution.log_prob(raw_actions) log_probs -= self._squash_correction(raw_actions) ### Problem 2.A ### YOUR CODE HERE self.actions = tf.tanh(raw_actions) return self.actions, log_probs
Example #16
Source File: network.py From view-finding-network with GNU General Public License v3.0 | 6 votes |
def conv(input, kernel, biases, k_h, k_w, c_o, s_h, s_w, padding="VALID", group=1): '''From https://github.com/ethereon/caffe-tensorflow ''' c_i = input.get_shape()[-1] assert c_i%group==0 assert c_o%group==0 convolve = lambda i, k: tf.nn.conv2d(i, k, [1, s_h, s_w, 1], padding=padding) if group==1: conv = convolve(input, kernel) else: input_groups = tf.split(input, group, 3) kernel_groups = tf.split(kernel, group, 3) output_groups = [convolve(i, k) for i,k in zip(input_groups, kernel_groups)] conv = tf.concat(output_groups, 3) return tf.reshape(tf.nn.bias_add(conv, biases), [-1]+conv.get_shape().as_list()[1:])
Example #17
Source File: vfn_train.py From view-finding-network with GNU General Public License v3.0 | 6 votes |
def read_and_decode(filename_queue): reader = tf.TFRecordReader() _, serialized_example = reader.read(filename_queue) features = tf.parse_single_example( serialized_example, # Defaults are not specified since both keys are required. features={ 'image_raw': tf.FixedLenFeature([], tf.string), }) image = tf.decode_raw(features['image_raw'], tf.uint8) image = tf.reshape(image, [227, 227, 6]) # Convert from [0, 255] -> [-0.5, 0.5] floats. image = tf.cast(image, tf.float32) * (1. / 255) - 0.5 return tf.split(image, 2, 2) # 3rd dimension two parts
Example #18
Source File: vfn_train.py From view-finding-network with GNU General Public License v3.0 | 6 votes |
def read_and_decode_aug(filename_queue): reader = tf.TFRecordReader() _, serialized_example = reader.read(filename_queue) features = tf.parse_single_example( serialized_example, # Defaults are not specified since both keys are required. features={ 'image_raw': tf.FixedLenFeature([], tf.string), }) image = tf.decode_raw(features['image_raw'], tf.uint8) image = tf.image.random_flip_left_right(tf.reshape(image, [227, 227, 6])) # Convert from [0, 255] -> [-0.5, 0.5] floats. image = tf.cast(image, tf.float32) * (1. / 255) - 0.5 image = tf.image.random_brightness(image, 0.01) image = tf.image.random_contrast(image, 0.95, 1.05) return tf.split(image, 2, 2) # 3rd dimension two parts
Example #19
Source File: tf_atari_wrappers.py From fine-lm with MIT License | 6 votes |
def simulate(self, action): with tf.name_scope("environment/simulate"): # Do we need this? initializer = (tf.zeros(self.old_shape, dtype=tf.float32), tf.fill((len(self),), 0.0), tf.fill((len(self),), False)) def not_done_step(a, _): reward, done = self._batch_env.simulate(action) with tf.control_dependencies([reward, done]): r0 = self._batch_env.observ + 0 r1 = tf.add(a[1], reward) r2 = tf.logical_or(a[2], done) return (r0, r1, r2) simulate_ret = tf.scan(not_done_step, tf.range(self.skip), initializer=initializer, parallel_iterations=1, infer_shape=False) observations, rewards, dones = simulate_ret split_observations = tf.split(observations, self.skip, axis=0) split_observations = [tf.squeeze(o, axis=0) for o in split_observations] observation = tf.concat(split_observations, axis=-1) with tf.control_dependencies([self._observ.assign(observation)]): return tf.identity(rewards[-1, ...]), tf.identity(dones[-1, ...])
Example #20
Source File: expert_utils.py From fine-lm with MIT License | 6 votes |
def combine(self, expert_out, multiply_by_gates=True): """Sum together the expert output, multiplied by the corresponding gates. Args: expert_out: a list of `num_experts` `Tensor`s, each with shape `[expert_batch_size_i, <extra_output_dims>]`. multiply_by_gates: a boolean. Returns: a list of num_datashards `Tensor`s with shapes `[batch_size[d], <extra_output_dims>]`. """ expert_part_sizes = tf.unstack( tf.stack([d.part_sizes for d in self._dispatchers]), num=self._ep.n, axis=1) # list of lists of shape [num_experts][num_datashards] expert_output_parts = self._ep(tf.split, expert_out, expert_part_sizes) expert_output_parts_t = transpose_list_of_lists(expert_output_parts) def my_combine(dispatcher, parts): return dispatcher.combine( common_layers.convert_gradient_to_tensor(tf.concat(parts, 0)), multiply_by_gates=multiply_by_gates) return self._dp(my_combine, self._dispatchers, expert_output_parts_t)
Example #21
Source File: common_layers.py From fine-lm with MIT License | 6 votes |
def conv_lstm(x, kernel_size, filters, padding="SAME", dilation_rate=(1, 1), name=None, reuse=None): """Convolutional LSTM in 1 dimension.""" with tf.variable_scope( name, default_name="conv_lstm", values=[x], reuse=reuse): gates = conv( x, 4 * filters, kernel_size, padding=padding, dilation_rate=dilation_rate) g = tf.split(layer_norm(gates, 4 * filters), 4, axis=3) new_cell = tf.sigmoid(g[0]) * x + tf.sigmoid(g[1]) * tf.tanh(g[3]) return tf.sigmoid(g[2]) * tf.tanh(new_cell)
Example #22
Source File: common_layers.py From fine-lm with MIT License | 6 votes |
def gated_linear_unit_layer(x, name=None): """Gated linear unit layer. Paper: Language Modeling with Gated Convolutional Networks. Link: https://arxiv.org/abs/1612.08083 x = Wx * sigmoid(W'x). Args: x: A tensor name: A string Returns: A tensor of the same shape as x. """ with tf.variable_scope(name, default_name="glu_layer", values=[x]): depth = shape_list(x)[-1] x = tf.layers.dense(x, depth * 2, activation=None) x, gating_x = tf.split(x, 2, axis=-1) return x * tf.nn.sigmoid(gating_x)
Example #23
Source File: modalities_test.py From fine-lm with MIT License | 6 votes |
def testSymbolModalityInputs(self): batch_size = 10 num_datashards = 5 length = 5 vocab_size = 5000 hidden_size = 9 model_hparams = common_hparams.basic_params1() model_hparams.hidden_size = hidden_size model_hparams.mode = tf.estimator.ModeKeys.TRAIN x = -1 + np.random.random_integers( vocab_size, size=(batch_size, length, 1, 1)) m = modalities.SymbolModality(model_hparams, vocab_size) data_parallelism = expert_utils.Parallelism( ["/device:CPU:0"] * num_datashards) with self.test_session() as session: xs = tf.split(x, num_datashards) sharded_output = m.bottom_sharded(xs, data_parallelism) output = tf.concat(sharded_output, 0) session.run(tf.global_variables_initializer()) res = session.run(output) self.assertEqual(res.shape, (batch_size, length, 1, hidden_size))
Example #24
Source File: rev_block_test.py From fine-lm with MIT License | 6 votes |
def testForwardBackward(self): def f(x): return tf.layers.dense(x, self.CHANNELS // 2, use_bias=True) def g(x): return tf.layers.dense(x, self.CHANNELS // 2, use_bias=True) x = tf.random_uniform([self.BATCH_SIZE, self.CHANNELS], dtype=tf.float32) x1, x2 = tf.split(x, 2, axis=-1) block = rev_block.RevBlock(f, g, num_layers=3) y1, y2 = block.forward(x1, x2) x1_inv, x2_inv = block.backward(y1, y2) with self.test_session() as sess: sess.run(tf.global_variables_initializer()) x1, x2, x1_inv, x2_inv = sess.run([x1, x2, x1_inv, x2_inv]) self.assertAllClose(x1, x1_inv) self.assertAllClose(x2, x2_inv)
Example #25
Source File: rev_block_test.py From fine-lm with MIT License | 6 votes |
def testBackwardForward(self): def f(x): return tf.layers.dense(x, self.CHANNELS // 2, use_bias=True) def g(x): return tf.layers.dense(x, self.CHANNELS // 2, use_bias=True) y = tf.random_uniform([self.BATCH_SIZE, self.CHANNELS], dtype=tf.float32) y1, y2 = tf.split(y, 2, axis=-1) block = rev_block.RevBlock(f, g, num_layers=3) x1, x2 = block.backward(y1, y2) y1_inv, y2_inv = block.forward(x1, x2) with self.test_session() as sess: sess.run(tf.global_variables_initializer()) y1, y2, y1_inv, y2_inv = sess.run([y1, y2, y1_inv, y2_inv]) self.assertAllClose(y1, y1_inv) self.assertAllClose(y2, y2_inv)
Example #26
Source File: common_image_attention.py From fine-lm with MIT License | 6 votes |
def get_channel_embeddings(io_depth, targets, hidden_size, name="channel"): """Get separate embedding for each of the channels.""" targets_split = tf.split(targets, io_depth, axis=3) rgb_embedding_var = tf.get_variable("rgb_target_emb_%s" % name, [256 * io_depth, hidden_size]) rgb_embedding_var = tf.identity(rgb_embedding_var) rgb_embedding_var *= float(hidden_size)**0.5 channel_target_embs = [] for i in range(io_depth): # Adding the channel offsets to get the right embedding since the # embedding tensor has shape 256 * io_depth, hidden_size target_ids = tf.squeeze(targets_split[i], axis=3) + i * 256 target_embs = common_layers.gather(rgb_embedding_var, target_ids) channel_target_embs.append(target_embs) return tf.concat(channel_target_embs, axis=-1)
Example #27
Source File: model.py From DOTA_models with Apache License 2.0 | 6 votes |
def _CrossConv(self, encoded_images): """Apply the motion kernel on the encoded_images.""" cross_conved_images = [] kernels = tf.split(axis=3, num_or_size_splits=4, value=self.kernel) for (i, encoded_image) in enumerate(encoded_images): with tf.variable_scope('cross_conv_%d' % i): kernel = kernels[i] encoded_image = tf.unstack(encoded_image, axis=0) kernel = tf.unstack(kernel, axis=0) assert len(encoded_image) == len(kernel) assert len(encoded_image) == self.params['batch_size'] conved_image = [] for j in xrange(len(encoded_image)): conved_image.append(self._CrossConvHelper( encoded_image[j], kernel[j])) cross_conved_images.append(tf.concat(axis=0, values=conved_image)) sys.stderr.write('cross_conved shape: %s\n' % cross_conved_images[-1].get_shape()) return cross_conved_images
Example #28
Source File: common_layers.py From fine-lm with MIT License | 5 votes |
def subseparable_conv(inputs, filters, kernel_size, **kwargs): """Sub-separable convolution. If separability == 0 it's a separable_conv.""" def conv_fn(inputs, filters, kernel_size, **kwargs): """Sub-separable convolution, splits into separability-many blocks.""" separability = None if "separability" in kwargs: separability = kwargs.pop("separability") if separability: parts = [] abs_sep = separability if separability > 0 else -1 * separability for split_idx, split in enumerate(tf.split(inputs, abs_sep, axis=3)): with tf.variable_scope("part_%d" % split_idx): if separability > 0: parts.append( tf.layers.conv2d(split, filters // separability, kernel_size, **kwargs)) else: parts.append( tf.layers.separable_conv2d(split, filters // abs_sep, kernel_size, **kwargs)) if separability > 1: result = tf.layers.conv2d(tf.concat(parts, axis=3), filters, (1, 1)) elif abs_sep == 1: # If we have just one block, return it. assert len(parts) == 1 result = parts[0] else: result = tf.concat(parts, axis=3) else: result = tf.layers.separable_conv2d(inputs, filters, kernel_size, **kwargs) if separability is not None: kwargs["separability"] = separability return result return conv_internal(conv_fn, inputs, filters, kernel_size, **kwargs)
Example #29
Source File: common_layers.py From fine-lm with MIT License | 5 votes |
def __call__(self, inputs_t, state_t): cur_x_times_one_minus_f, cur_f = tf.split(inputs_t, 2, axis=-1) state_next = cur_f * state_t + cur_x_times_one_minus_f outputs_t = state_next return outputs_t, state_next
Example #30
Source File: tfutil.py From disentangling_conditional_gans with MIT License | 5 votes |
def import_module(module_or_obj_name): parts = module_or_obj_name.split('.') parts[0] = {'np': 'numpy', 'tf': 'tensorflow'}.get(parts[0], parts[0]) for i in range(len(parts), 0, -1): try: module = importlib.import_module('.'.join(parts[:i])) relative_obj_name = '.'.join(parts[i:]) return module, relative_obj_name except ImportError: pass raise ImportError(module_or_obj_name)