def triangular_matrix_seq(mode: int = 1):
X = C.placeholder(1)
ones = C.ones_like(X[0])
perm_1 = C.layers.Recurrence(C.plus, return_full_state=True)(ones)
perm_2 = C.layers.Recurrence(C.plus,
go_backwards=True,
return_full_state=True)(ones)
arr_1 = C.sequence.unpack(perm_1, 0, True)
arr_2 = C.sequence.unpack(perm_2, 0, True)
mat = C.times_transpose(arr_1, arr_2)
mat_c = arr_1 * arr_2
diagonal_mat = mat - mat_c
final_mat = diagonal_mat
if mode == 0:
final_mat = C.equal(final_mat, 0)
elif mode == 1:
final_mat = C.less_equal(final_mat, 0)
elif mode == 2:
final_mat = C.less(final_mat, 0)
elif mode == -1:
final_mat = C.greater_equal(final_mat, 0)
elif mode == -2:
final_mat = C.greater(final_mat, 0)
result = C.as_block(final_mat, [(X, X)], 'triangular_matrix')
return C.stop_gradient(result)
def _inner(x, y):
length_x = length(x)
positions_y = position(y) + 1 # +1 because position starts from zero
valid_x = C.less_equal(positions_y,
C.sequence.broadcast_as(length_x, positions_y))
padded = C.sequence.scatter(x, valid_x)
return padded, valid_x
def gradFunc(self, arg):
# create an input variable corresponding the inputs of the forward prop function
gradIn = C.input(shape=arg.shape, dynamic_axes=arg.dynamic_axes)
# create an input variable for the gradient passed from the next stage
gradRoot = C.input(shape=arg.shape, dynamic_axes=arg.dynamic_axes)
# first step is to take absolute value of input arg
signGrad = C.abs(gradIn)
# then compare its magnitude to 1
signGrad = C.less_equal(signGrad, 1)
# finish by multiplying this result with the input gradient
return C.element_times(gradRoot, signGrad), gradIn, gradRoot
def gradFunc(self, arg):
# create an input variable corresponding the inputs of the forward prop function
gradIn = C.input(shape=arg.shape, dynamic_axes=arg.dynamic_axes)
# create an input variable for the gradient passed from the next stage
gradRoot = C.input(shape=arg.shape, dynamic_axes=arg.dynamic_axes)
# first step is to take absolute value of input arg
signGrad = C.abs(gradIn)
# then compare its magnitude to 1
signGrad = C.less_equal(signGrad, 1)
# finish by multiplying this result with the input gradient
return C.element_times(gradRoot, signGrad), gradIn, gradRoot
def true_density(z):
z1, z2 = z[0], z[1]
w1 = lambda x: C.sin(2 * np.pi * x/4)
u = 0.5 * C.square((z2 - w1(z1))/0.4)
dummy = C.ones_like(u) * 1e7
# u = C.element_select(C.less_equal(z1,4), u, dummy)
cond = C.less_equal(z1,4)
u = C.element_select(cond, u, dummy) # u = cond*u + (1-cond)*dummy
return C.exp(-u)
def gradFunc(self, arg):
# create an input variable corresponding the inputs of the forward prop function
gradIn = C.input(shape=arg.shape, dynamic_axes=arg.dynamic_axes)
# create an input variable for the gradient passed from the next stage
gradRoot = C.input(shape=arg.shape, dynamic_axes=arg.dynamic_axes)
signGrad = C.abs(gradIn)
# new idea, bound of clipping should be a function of the bit map since higher bits can represent higher numbers
bit_map = C.constant(self.bit_map)
signGrad = C.less_equal(signGrad, bit_map)
outGrad = signGrad
outGrad = element_times(gradRoot, outGrad)
return outGrad, gradIn, gradRoot
def gradFunc(self, arg):
# create an input variable corresponding the inputs of the forward prop function
gradIn = C.input(shape=arg.shape, dynamic_axes=arg.dynamic_axes)
# create an input variable for the gradient passed from the next stage
gradRoot = C.input(shape=arg.shape, dynamic_axes=arg.dynamic_axes)
signGrad = C.abs(gradIn)
# new idea, bound of clipping should be a function of the bit map since higher bits can represent higher numbers
bit_map = C.constant(self.bit_map)
signGrad = C.less_equal(signGrad, bit_map)
outGrad = signGrad
outGrad = element_times(gradRoot, outGrad)
return outGrad, gradIn, gradRoot
def less_equal(left, right, name=''):
'''
Elementwise 'less equal' comparison of two tensors. Result is 1 if left <= right else 0.
Example:
>>> C.eval(C.less_equal([41., 42., 43.], [42., 42., 42.]))
[array([[1., 1., 0.]])]
>>> C.eval(C.eq([-1,0,1], [0]))
[array([[1., 1., 0.]])]
Args:
left: left side tensor
right: right side tensor
name (str): the name of the node in the network
Returns:
:class:`cntk.Function`
'''
from cntk import less_equal
left = sanitize_input(left, get_data_type(right))
right = sanitize_input(right, get_data_type(left))
return less_equal(left, right, name).output()
def less_equal(left, right, name=''):
'''
Elementwise 'less equal' comparison of two tensors. Result is 1 if left <= right else 0.
Example:
>>> C.eval(C.less_equal([41., 42., 43.], [42., 42., 42.]))
[array([[1., 1., 0.]])]
>>> C.eval(C.eq([-1,0,1], [0]))
[array([[1., 1., 0.]])]
Args:
left: left side tensor
right: right side tensor
name (str): the name of the node in the network
Returns:
:class:`cntk.Function`
'''
from cntk import less_equal
left = sanitize_input(left, get_data_type(right))
right = sanitize_input(right, get_data_type(left))
return less_equal(left, right, name).output()
import cntk
A = [1, 3, 4]
B = [4, 3, 2]
print("less(A,B):")
less = cntk.less(A, B).eval()
print("{}\n".format(less))
print("equal(A,B):")
equal = cntk.equal(A, B).eval()
print("{}\n".format(equal))
print("greater(A,B)")
greater = cntk.greater(A, B).eval()
print("{}\n".format(greater))
print("greater_equal(A,B):")
greater_equal = cntk.greater_equal(A, B).eval()
print("{}\n".format(greater_equal))
print("not_equal(A,B):")
not_equal = cntk.not_equal(A, B).eval()
print("{}\n".format(not_equal))
print("less_equal(A,B):")
less_equal = cntk.less_equal(A, B).eval()
print("{}\n".format(less_equal))
def inner(a):
p = position(a)
integers = p / s # every s sequence item will be an integer
valid = C.less_equal(C.abs(C.sin(integers * pi)), tol) # sin of integer multiple of pi will return close to zero
result = C.sequence.gather(a, valid)
return result