def stabilize(operand):
scalar_constant = 4.0
f = Constant.scalar(sanitize_dtype_cntk(np.float32), scalar_constant);
fInv = Constant.scalar(sanitize_dtype_cntk(np.float32), 1.0 / scalar_constant)
beta = element_times(fInv, log(Constant.scalar(sanitize_dtype_cntk(np.float32), 1.0) + exp(element_times(f, parameter(shape=(), value=0.99537863)))))
return element_times(beta, operand)
def stabilize(operand):
scalar_constant = 4.0
f = constant(sanitize_dtype_cntk(np.float32), scalar_constant)
fInv = constant(sanitize_dtype_cntk(np.float32), 1.0 / scalar_constant)
beta = element_times(fInv, log(constant(sanitize_dtype_cntk(
np.float32), 1.0) + exp(element_times(f, parameter(init=0.99537863)))))
return element_times(beta, operand)
def stabilize(operand):
scalar_constant = 4.0
f = constant(sanitize_dtype_cntk(np.float32), scalar_constant)
fInv = constant(sanitize_dtype_cntk(np.float32), 1.0 / scalar_constant)
beta = element_times(fInv, log(constant(sanitize_dtype_cntk(
np.float32), 1.0) + exp(element_times(f, parameter(init=0.99537863)))))
return element_times(beta, operand)
def test_op_dropout(shape, dropout_rate, device_id, precision):
from cntk import dropout
count = 10
resulted_non_zeros = 0
# As the dropout node is stochastic, we run it a couple times and aggregate
# over the results to get more stable tests.
for i in range(count):
value = np.ones(shape=shape, dtype=PRECISION_TO_TYPE[precision])
a = I(shape=value.shape,
dtype=sanitize_dtype_cntk(PRECISION_TO_TYPE[precision]),
needs_gradient=True,
name='a')
dropout_node = dropout(a, dropout_rate=dropout_rate)
value.shape = (1, 1) + value.shape
forward_input = {a: value}
forward, backward = cntk_eval(dropout_node,
forward_input,
precision,
cntk_device(device_id),
backward_pass=True)
resulted_non_zeros += np.count_nonzero(forward[dropout_node.output])
resulted_non_zeros /= count
num_elements = np.multiply.reduce(shape)
expected_non_zeros = num_elements * (1 - dropout_rate)
max_off = 0.2 * num_elements
assert (abs(resulted_non_zeros - expected_non_zeros) < max_off)
def test_op_dropout(shape, dropout_rate, device_id, precision):
from cntk import dropout
from cntk.utils import eval, sanitize_dtype_cntk, cntk_device
count = 10
resulted_non_zeros = 0
# As the dropout node is stochastic, we run it a couple times and aggregate
# over the results to get more stable tests.
for i in range(count):
value = np.ones(shape=shape, dtype=PRECISION_TO_TYPE[precision])
a = I(
shape=value.shape,
data_type=sanitize_dtype_cntk(PRECISION_TO_TYPE[precision]),
needs_gradient=True,
name="a",
)
dropout_node = dropout(a, dropout_rate=dropout_rate)
value.shape = (1, 1) + value.shape
forward_input = {a: value}
forward, backward = eval(dropout_node, forward_input, precision, cntk_device(device_id), backward_pass=True)
resulted_non_zeros += np.count_nonzero(forward[dropout_node.output])
resulted_non_zeros /= count
num_elements = np.multiply.reduce(shape)
expected_non_zeros = num_elements * (1 - dropout_rate)
max_off = 0.2 * num_elements
assert abs(resulted_non_zeros - expected_non_zeros) < max_off
def __init__(self, shape=None, dtype=None, needs_gradient=False, is_sparse=False,
dynamic_axes=[cntk_py.Axis.default_dynamic_axis(), cntk_py.Axis.default_batch_axis()], name=''):
shape = utils.sanitize_shape(shape)
if dtype is None:
dtype = np.float32
dtype = utils.sanitize_dtype_cntk(dtype)
super(Variable, self).__init__(shape, is_sparse, dtype, needs_gradient, name,
dynamic_axes)
def load_model(data_type, filename, device=None):
'''
Load the network in `model_file`, that has been saved using
`:func:save_model`.
Args:
data_type ('float' or 'double', or NumPy type): data type of the operation
filename (`str`): filename to load the model from
device (:class:`cntk.DeviceDescriptor`, default to default device): instance of DeviceDescriptor
Returns:
root node
'''
from cntk.utils import sanitize_dtype_cntk
data_type = sanitize_dtype_cntk(data_type)
if not device:
device = cntk_py.DeviceDescriptor.use_default_device()
return cntk_py.load_legacy_model(data_type, filename)
def __init__(self, shape=None, init=None, data_type=None, device=None, name=""):
if data_type is None:
if not isinstance(init, np.ndarray):
data_type = FLOAT_32
else:
data_type = str(init.dtype)
if init is None:
init = 0
if isinstance(init, (np.ndarray, list, float, int)):
ndav = _sanitize_value(shape, init, data_type, device)
super(Parameter, self).__init__(ndav, name)
else:
shape = utils.sanitize_shape(shape)
data_type = utils.sanitize_dtype_cntk(data_type)
super(Parameter, self).__init__(shape, data_type, init, device, name)
def load_model(data_type, filename, device=None):
'''
Load the network in `model_file`, that has been saved using
`:func:save_model`.
Args:
data_type ('float' or 'double', or NumPy type): data type of the operation
filename (`str`): filename to load the model from
device (:class:`cntk.DeviceDescriptor`, default to default device): instance of DeviceDescriptor
Returns:
root node
'''
from cntk.utils import sanitize_dtype_cntk
data_type = sanitize_dtype_cntk(data_type)
if not device:
device = use_default_device()
return cntk_py.load_legacy_model(data_type, filename)
def _sanitize_value(shape, value, dtype, device):
np_dtype = utils.sanitize_dtype_numpy(dtype)
cntk_dtype = utils.sanitize_dtype_cntk(dtype)
if value is None:
if shape is None:
raise ValueError('you need to specify at least shape or value')
shape = utils.sanitize_shape(shape)
ndav = utils.create_NDArrayView(shape, cntk_dtype, device)
else:
if not isinstance(value, np.ndarray) or value.dtype != np_dtype:
if np.isscalar(value) and shape:
value = np.full(shape, value, dtype=np_dtype)
else:
value = np.asarray(value, dtype=np_dtype)
ndav = utils.create_NDArrayView_from_NumPy(value, device)
return ndav
def _sanitize_value(shape, value, dtype, device):
np_dtype = utils.sanitize_dtype_numpy(dtype)
cntk_dtype = utils.sanitize_dtype_cntk(dtype)
if value is None:
if shape is None:
raise ValueError("you need to specify at least shape or value")
shape = utils.sanitize_shape(shape)
ndav = utils.create_NDArrayView(shape, cntk_dtype, device)
else:
if not isinstance(value, np.ndarray) or value.dtype != np_dtype:
if np.isscalar(value) and shape:
value = np.full(shape, value, dtype=np_dtype)
else:
value = np.asarray(value, dtype=np_dtype)
ndav = utils.create_NDArrayView_from_NumPy(value, device)
return ndav
def __init__(self, shape=None, init=None, dtype=None,
device=None, name=''):
if dtype is None:
if isinstance(init, np.ndarray):
dtype = init.dtype
else:
dtype = np.float32
if init is None:
init = 0
if isinstance(init, (np.ndarray, list, float, int)):
ndav = sanitize_value(shape, init, dtype, device)
super(Parameter, self).__init__(ndav, name)
else:
shape = utils.sanitize_shape(shape)
cntk_dtype = utils.sanitize_dtype_cntk(dtype)
super(Parameter, self).__init__(shape, cntk_dtype, init,
device, name)
def load_model(filename, dtype=np.float32, device=None):
'''
Load the network in ``filename``, that has been saved using
`:func:save_model`.
Args:
filename (`str`): filename to load the model from
dtype ('float', 'double', or NumPy type, default ``np.float32``): data
type of the operation
device (:class:`cntk.DeviceDescriptor`, default is the default device):
instance of DeviceDescriptor
Returns:
root node
'''
from cntk.utils import sanitize_dtype_cntk
dtype = sanitize_dtype_cntk(dtype)
if not device:
device = use_default_device()
return cntk_py.Function.load_model(dtype, filename, device)
def load_model(filename, dtype=np.float32, device=None):
'''
Load the network in ``filename``, that has been saved using
`:func:save_model`.
Args:
filename (`str`): filename to load the model from
dtype ('float', 'double', or NumPy type, default ``np.float32``): data
type of the operation
device (:class:`cntk.DeviceDescriptor`, default is the default device):
instance of DeviceDescriptor
Returns:
root node
'''
from cntk.utils import sanitize_dtype_cntk
dtype = sanitize_dtype_cntk(dtype)
if not device:
device = use_default_device()
return cntk_py.Function.load_model(dtype, filename, device)
def __init__(self,
shape=None,
init=None,
data_type=None,
device=None,
name=''):
if data_type is None:
if not isinstance(init, np.ndarray):
data_type = FLOAT_32
else:
data_type = str(init.dtype)
if init is None:
init = 0
if isinstance(init, (np.ndarray, list, float, int)):
ndav = _sanitize_value(shape, init, data_type, device)
super(Parameter, self).__init__(ndav, name)
else:
shape = utils.sanitize_shape(shape)
data_type = utils.sanitize_dtype_cntk(data_type)
super(Parameter, self).__init__(shape, data_type, init, device,
name)
