def _sanitize_value(shape, value, dtype, device, is_param=False):
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)
if is_param:
# TODO: expose the initialization params
ndav = NDArrayView.random_uniform_float(shape, -0.05, 0.05, 1,
device)
else:
ndav = utils.create_NDArrayView(shape, cntk_dtype, device)
else:
if not isinstance(value, np.ndarray) or value.dtype != np_dtype:
value = np.asarray(value, dtype=np_dtype)
#TODO: check whether this copy operation from cpu to gpu is not needed
if device != DeviceDescriptor_cpudevice():
ndav_cpu = utils.create_NDArrayView_from_NumPy(value)
ndav = utils.create_NDArrayView(value.shape,
data_type=cntk_dtype,
dev=device)
ndav.copy_from(ndav_cpu)
else:
ndav = utils.create_NDArrayView_from_NumPy(value, device)
return ndav
def value(self, val):
if isinstance(val, np.ndarray):
ndarray = NDArrayView.from_dense(val.astype(self.dtype))
super(Parameter, self).set_value(ndarray)
elif isinstance(val, cntk_py.NDArrayView):
super(Parameter, self).set_value(val)
else:
raise TypeError("Unsupported value type: %s", type(val))
def value(self, val):
if isinstance(val, np.ndarray):
ndarray = NDArrayView.from_dense(val.astype(self.dtype))
super(Parameter, self).set_value(ndarray)
elif isinstance(val, cntk_py.NDArrayView):
super(Parameter, self).set_value(val)
else:
raise TypeError("Unsupported value type: %s", type(val))
def test_native_binary_function():
# user functions need to be registered before being callable by python
if not nopt.native_convolve_function_registered:
pytest.skip("Could not find {0} library. "
"Please check if HALIDE_PATH is configured properly "
"and try building {1} again".format(
'Cntk.BinaryConvolution-' + C.__version__.rstrip('+'),
'Extnsibiliy\BinaryConvolution'))
# be sure to only run on CPU, binary convolution does not have GPU support for now
dev = C.cpu()
# create an arbitrary input mimicking a realistic cifar input
x = input((64, 28, 28))
# random filter weights for testing
w = parameter((64, 64, 3, 3),
init=np.reshape(2 * (np.random.rand(64 * 64 * 3 * 3) - .5),
(64, 64, 3, 3)),
dtype=np.float32,
device=dev)
# set the convolution parameters by passing in an attribute dictionary
#attributes = {'stride' : 1, 'padding' : False, 'size' : 3}
attributes = {
'stride': 1,
'padding': False,
'size': 3,
'h': 28,
'w': 28,
'channels': 64,
'filters': 64
}
# define the binary convolution op
op = ops.native_user_function('NativeBinaryConvolveFunction', [w, x],
attributes, 'native_binary_convolve')
# also define an op using python custom functions that should have the same output
op2 = C.convolution(CustomMultibitKernel(w, 1),
CustomSign(x),
auto_padding=[False])
# create random input data
x_data = NDArrayView.from_dense(np.asarray(np.reshape(
2 * (np.random.rand(64 * 28 * 28) - .5), (64, 28, 28)),
dtype=np.float32),
device=dev)
# evaluate the CPP binary convolve
result = op.eval({x: x_data}, device=dev)
# evaluate the python emulator
result2 = op2.eval({x: x_data}, device=dev)
native_times_primitive = op.find_by_name('native_binary_convolve')
# assert that both have the same result
'''
def _to_cntk_dict_value(py_value):
if isinstance(py_value, dict):
return DictionaryValueFromDict(_py_dict_to_cntk_dict(py_value))
if isinstance(py_value, list):
py_list = list(map(_to_cntk_dict_value, py_value))
return DictionaryValue(py_list)
if isinstance(py_value, np.ndarray):
py_value = NDArrayView.from_dense(py_value)
return DictionaryValueFromNDArrayView(py_value)
if py_value is None:
return DictionaryValue()
return DictionaryValue(py_value)
def _to_cntk_dict_value(py_value):
if isinstance(py_value, dict):
return DictionaryValueFromDict(_py_dict_to_cntk_dict(py_value))
if isinstance(py_value, list):
py_list = list(map(_to_cntk_dict_value, py_value))
return DictionaryValue(py_list)
if isinstance(py_value, np.ndarray):
py_value = NDArrayView.from_dense(py_value)
return DictionaryValueFromNDArrayView(py_value)
if py_value is None:
return DictionaryValue()
return DictionaryValue(py_value)
def _to_cntk_dict_value(py_value):
if isinstance(py_value, dict):
return DictionaryValueFromDict(_py_dict_to_cntk_dict(py_value))
if isinstance(py_value, list):
py_list = list(map(_to_cntk_dict_value, py_value))
return DictionaryValue(py_list)
if isinstance(py_value, np.ndarray):
py_value = NDArrayView.from_dense(py_value)
return DictionaryValueFromNDArrayView(py_value)
if isinstance(py_value, cntk_py.training_double_parameter_schedule):
return cntk_py.DictionaryValueFromTrainingDoubleParameterSchedule(py_value)
if py_value is None:
return DictionaryValue()
return DictionaryValue(py_value)
def test_native_binary_function():
# user functions need to be registered before being callable by python
if not nopt.native_convolve_function_registered:
pytest.skip("Could not find {0} library. "
"Please check if HALIDE_PATH is configured properly "
"and try building {1} again"
.format('Cntk.BinaryConvolution-' + C.__version__.rstrip('+'),
'Extnsibiliy\\BinaryConvolution'))
# be sure to only run on CPU, binary convolution does not have GPU support for now
dev = C.cpu()
# create an arbitrary input mimicking a realistic cifar input
x = input((64, 28, 28))
# random filter weights for testing
w = parameter((64, 64, 3, 3), init=np.reshape(2*(np.random.rand(64*64*3*3)-.5), (64, 64, 3, 3)), dtype=np.float32, device=dev)
# set the convolution parameters by passing in an attribute dictionary
#attributes = {'stride' : 1, 'padding' : False, 'size' : 3}
attributes = {'stride' : 1,
'padding' : False,
'size' : 3,
'h' : 28,
'w' : 28,
'channels' : 64,
'filters' : 64 }
# define the binary convolution op
op = ops.native_user_function('NativeBinaryConvolveFunction', [w, x], attributes, 'native_binary_convolve')
# also define an op using python custom functions that should have the same output
op2 = C.convolution(CustomMultibitKernel(w, 1), CustomSign(x), auto_padding = [False])
# create random input data
x_data = NDArrayView.from_dense(np.asarray(np.reshape(2*(np.random.rand(64*28*28)-.5), (64, 28, 28)),dtype=np.float32), device=dev)
# evaluate the CPP binary convolve
result = op.eval({x : x_data}, device=dev)
# evaluate the python emulator
result2 = op2.eval({x : x_data}, device=dev)
native_times_primitive = op.find_by_name('native_binary_convolve')
# assert that both have the same result
'''
def _to_cntk_dict_value(py_value):
if isinstance(py_value, dict):
return DictionaryValueFromDict(_py_dict_to_cntk_dict(py_value))
if isinstance(py_value, list):
py_list = list(map(_to_cntk_dict_value, py_value))
return DictionaryValue(py_list)
if isinstance(py_value, np.ndarray):
py_value = NDArrayView.from_dense(py_value)
return DictionaryValueFromNDArrayView(py_value)
if isinstance(py_value, cntk_py.training_double_parameter_schedule):
return cntk_py.DictionaryValueFromTrainingDoubleParameterSchedule(
py_value)
if py_value is None:
return DictionaryValue()
return DictionaryValue(py_value)
def test_native_binary_function():
# user functions need to be registered before being callable by python
ops.register_native_user_function(
'NativeBinaryConvolveFunction',
'Cntk.BinaryConvolutionExample-' + C.__version__.rstrip('+'),
'CreateBinaryConvolveFunction')
# be sure to only run on CPU, binary convolution does not have GPU support for now
dev = cpu()
# create an arbitrary input mimicking a realistic cifar input
x = input((64, 30, 30))
# random filter weights for testing
w = parameter((64, 64, 3, 3),
init=np.reshape(2 * (np.random.rand(64 * 64 * 3 * 3) - .5),
(64, 64, 3, 3)),
dtype=np.float32,
device=dev)
# set the convolution parameters by passing in an attribute dictionary
attributes = {'stride': 1, 'padding': False, 'size': 3}
# define the binary convolution op
op = ops.native_user_function('NativeBinaryConvolveFunction', [w, x],
attributes,
'native_binary_convolve_function')
# also define an op using python custom functions that should have the same output
op2 = C.convolution(CustomMultibitKernel(w, 1),
CustomSign(x),
auto_padding=[False])
# create random input data
x_data = NDArrayView.from_dense(np.asarray(np.reshape(
2 * (np.random.rand(64 * 30 * 30) - .5), (64, 30, 30)),
dtype=np.float32),
device=dev)
# evaluate the CPP binary convolve
result = op.eval({x: x_data}, device=dev)
# evaluate the python emulator
result2 = op2.eval({x: x_data}, device=dev)
native_times_primitive = op.find_by_name('native_binary_convolve_function')
# assert that both have the same result
assert np.allclose(result, result2, atol=0.001)
def test_native_binary_function():
# user functions need to be registered before being callable by python
ops.register_native_user_function('NativeBinaryConvolveFunction', 'Cntk.BinaryConvolutionExample-' + C.__version__.rstrip('+'), 'CreateBinaryConvolveFunction')
# be sure to only run on CPU, binary convolution does not have GPU support for now
dev = cpu()
# create an arbitrary input mimicking a realistic cifar input
x = input((64, 30, 30))
# random filter weights for testing
w = parameter((64, 64, 3, 3), init=np.reshape(2*(np.random.rand(64*64*3*3)-.5), (64, 64, 3, 3)), dtype=np.float32, device=dev)
# set the convolution parameters by passing in an attribute dictionary
attributes = {'stride' : 1, 'padding' : False, 'size' : 3}
# define the binary convolution op
op = ops.native_user_function('NativeBinaryConvolveFunction', [w, x], attributes, 'native_binary_convolve_function')
# also define an op using python custom functions that should have the same output
op2 = C.convolution(CustomMultibitKernel(w, 1), CustomSign(x), auto_padding = [False])
# create random input data
x_data = NDArrayView.from_dense(np.asarray(np.reshape(2*(np.random.rand(64*30*30)-.5), (64, 30, 30)),dtype=np.float32), device=dev)
# evaluate the CPP binary convolve
result = op.eval({x : x_data}, device=dev)
# evaluate the python emulator
result2 = op2.eval({x : x_data}, device=dev)
native_times_primitive = op.find_by_name('native_binary_convolve_function')
# assert that both have the same result
assert np.allclose(result, result2, atol=0.001)
def test_Value_raises():
from cntk import NDArrayView, Value
with pytest.raises(ValueError):
nd = NDArrayView.from_dense(np.asarray([[[4, 5]]], dtype=np.float32))
val = Value(nd)
def test_Value_raises():
from cntk import NDArrayView, Value
with pytest.raises(ValueError):
nd = NDArrayView.from_dense(np.asarray([[[4,5]]], dtype=np.float32))
val = Value(nd)