Python keras.backend.cos() Examples

The following are 23 code examples of keras.backend.cos(). 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 keras.backend , or try the search function

Example #1

Source File: position_embedding.py From nlp_toolkit with MIT License

6 votes

def call(self, x):
        if (self.size is None) or (self.mode == 'sum'):
            self.size = int(x.shape[-1])
        batch_size, seq_len = K.shape(x)[0], K.shape(x)[1]
        position_j = 1. / K.pow(10000.,
                                2 * K.arange(self.size / 2, dtype='float32'
                                             ) / self.size)
        position_j = K.expand_dims(position_j, 0)
        # K.arange不支持变长，只好用这种方法生成
        position_i = K.cumsum(K.ones_like(x[:, :, 0]), 1) - 1
        position_i = K.expand_dims(position_i, 2)
        position_ij = K.dot(position_i, position_j)
        position_ij = K.concatenate(
            [K.cos(position_ij), K.sin(position_ij)], 2)
        if self.mode == 'sum':
            return position_ij + x
        elif self.mode == 'concat':
            return K.concatenate([position_ij, x], 2)

Example #2

Source File: data_utils.py From RecurrentGaze with MIT License

6 votes

def euler2rot_mat(euler_angles):
    """
    Convert euler to rotation matrix, using the XYZ convention R = Rx * Ry * Rz, left-handed positive sign
    (from Openface)
    :param euler_angles: euler angles
    :return: rotation matrix
    """
    s1 = np.sin(euler_angles[0])
    s2 = np.sin(euler_angles[1])
    s3 = np.sin(euler_angles[2])
    c1 = np.cos(euler_angles[0])
    c2 = np.cos(euler_angles[1])
    c3 = np.cos(euler_angles[2])

    rot_mat = np.empty((3,3), dtype=np.float32)
    rot_mat[0, 0] = c2 * c3
    rot_mat[0, 1] = -c2 * s3
    rot_mat[0, 2] = s2
    rot_mat[1, 0] = c1 * s3 + c3 * s1 * s2
    rot_mat[1, 1] = c1 * c3 - s1 * s2 * s3
    rot_mat[1, 2] = -c2 * s1
    rot_mat[2, 0] = s1 * s3 - c1 * c3 * s2
    rot_mat[2, 1] = c3 * s1 + c1 * s2 * s3
    rot_mat[2, 2] = c1 * c2
    return np.linalg.inv(rot_mat)

Example #3

Source File: position.py From keras-transformer with MIT License

6 votes

def positional_signal(hidden_size: int, length: int,
                      min_timescale: float = 1.0, max_timescale: float = 1e4):
    """
    Helper function, constructing basic positional encoding.
    The code is partially based on implementation from Tensor2Tensor library
    https://github.com/tensorflow/tensor2tensor/blob/master/tensor2tensor/layers/common_attention.py
    """

    if hidden_size % 2 != 0:
        raise ValueError(
            f"The hidden dimension of the model must be divisible by 2."
            f"Currently it is {hidden_size}")
    position = K.arange(0, length, dtype=K.floatx())
    num_timescales = hidden_size // 2
    log_timescale_increment = K.constant(
        (np.log(float(max_timescale) / float(min_timescale)) /
         (num_timescales - 1)),
        dtype=K.floatx())
    inv_timescales = (
            min_timescale *
            K.exp(K.arange(num_timescales, dtype=K.floatx()) *
                  -log_timescale_increment))
    scaled_time = K.expand_dims(position, 1) * K.expand_dims(inv_timescales, 0)
    signal = K.concatenate([K.sin(scaled_time), K.cos(scaled_time)], axis=1)
    return K.expand_dims(signal, axis=0)

Example #4