Returns a true if its input is a collections.Sequence (except strings). Args: seq: an input sequence. Returns: True if the seque

Returns a flat list from a given nested structure. If `nest` is not a sequence, tuple, or dict, then returns a single-element list: `[nest]`.

Converts the sequence `args` to the same type as `instance`. Args: instance: an instance of `tuple`, `list`, `namedtuple`, `dict`, or

Asserts that `shallow_tree` is a shallow structure of `input_tree`. That is, this function tests if the `input_tree` structure can be created fro

Returns a sorted list of the dict keys, with error if keys not sortable.

Args: caps_uhat: shape(b_sz, tstp, out_caps_num, out_caps_dim) seqLen: shape(b_sz) iter_num: number of iteration

Returns a given flattened sequence packed into a given structure. If `structure` is a scalar, `flat_sequence` must be a single-element list;

Adds extra dimmension to routing logits. This enables active capsules to be routed to the extra dim if they are not a good fit for any of the

Helper function for pack_sequence_as. Args: structure: Substructure (list / tuple / dict) to mimic. flat: Flattened values to output

Helper function for `assert_same_structure`.

Squashing function corresponding to Eq. 1 Args: in_caps: a tensor axes: dimensions along which to apply squash Retu

Applies norm nonlinearity (squash) to a capsule layer. Args: input_tensor: Input tensor. Shape is [batch, num_channels, num_atoms]

Sums over scaled votes and applies squash to compute the activations. Iteratively updates routing logits (scales) based on the similarity between

Logs a warning message, once per unique string.

Yields elements `input_tree` partially flattened up to `shallow_tree`.

Asserts that two structures are nested in the same way. Args: nest1: an arbitrarily nested structure. nest2: an arbitrarily nested st

Flattens `input_tree` up to `shallow_tree`. Any further depth in structure in `input_tree` is retained as elements in the partially flatten o

Linear map: sum_i(args[i] * W[i]), where W[i] is a variable. Args: args: a 2D Tensor or a list of 2D, batch x n, Tensors. output_size

Penalizes deviations from margin for each logit. Each wrong logit costs its distance to margin. For negative logits margin is 0.1 and for posi

Args: caps: # shape(b_sz, caps_num, caps_dim) out_caps_num: #number of output capsule out_caps_dim: #dimension of output

Routing while loop.

Helper function for softmax on variable-length sequences. Args: logits: The logits before softmax. Shape is [batch, type_num, clas

Gather slices from `params` according to `indices` with leading batch dims. This operation assumes that the leading dimensions of `indices` are de

embedding: shape(b_sz, tstp, emb_sz) ids : shape(b_sz, tstp)

Args: target: a tensor mask: a boolean tensor that broadcast to the rank of that to target tensor Returns: ret: a ten

Returns a dictionary with flattened keys and values. This function flattens the keys and values of a dictionary, which can be arbitrarily nes

Generates a shallow structure from a `traverse_fn` and `structure`. `traverse_fn` must accept any possible subtree of `structure` and return

Args: input: shape(b_sz, ..., rep_sz) output_size: a scalar, python number

Applies `func` to each entry in `structure` and returns a new structure. Applies `func(x[0], x[1], ...)` where x[i] is an entry in `structure

Applies a function or op to a number of partially flattened inputs. The `inputs` are flattened up to `shallow_tree` before being mapped. Use

:param y_true: [None, n_classes] :param y_pred: [None, n_classes] :return: a scalar loss value.

Args: reduce_target : shape(d_0, d_1,..,d_dim, .., d_k) lengths : shape(d0, .., d_(dim-1)) dim : which dimension to avera

Args: reduce_target : shape(d_0, d_1,..,d_dim, .., d_k) lengths : shape(d0, .., d_(dim-1)) dim : which dimension to avera