def qconv_model():
x = x_in = keras.layers.Input((23, 23, 1), name="input")
x = QActivation("quantized_relu(4)", name="QA_0")(x)
x = QConv2D(16,
2,
2,
kernel_quantizer=quantizers.binary(),
bias_quantizer=quantizers.ternary(),
name="qconv2d_1")(x)
x = QConv2D(8,
2,
2,
kernel_quantizer=quantizers.quantized_bits(4, 0, 1),
bias_quantizer=quantizers.quantized_bits(4, 0, 1),
activation=quantizers.quantized_relu(6, 2),
name="qconv2D_2")(x)
x = QConv2D(2,
2,
2,
kernel_quantizer=quantizers.quantized_bits(4, 0, 1),
bias_quantizer=quantizers.quantized_bits(4, 0, 1),
activation=quantizers.quantized_relu(6, 2),
name="qconv2d_3")(x)
x = QActivation("quantized_bits(6, 0, 1)", name="QA_4")(x)
model = keras.Model(inputs=[x_in], outputs=[x])
return model
def build_model(input_shape):
x = x_in = Input(shape=input_shape, name="input")
x = QConv2D(
32, (2, 2), strides=(2,2),
kernel_quantizer=quantized_bits(4,0,1),
bias_quantizer=quantized_bits(4,0,1),
name="conv2d_0_m")(x)
x = QActivation("quantized_relu(4,0)", name="act0_m")(x)
x = QConv2D(
64, (3, 3), strides=(2,2),
kernel_quantizer=quantized_bits(4,0,1),
bias_quantizer=quantized_bits(4,0,1),
name="conv2d_1_m")(x)
x = QActivation("quantized_relu(4,0)", name="act1_m")(x)
x = QConv2D(
64, (2, 2), strides=(2,2),
kernel_quantizer=quantized_bits(4,0,1),
bias_quantizer=quantized_bits(4,0,1),
name="conv2d_2_m")(x)
x = QActivation("quantized_relu(4,0)", name="act2_m")(x)
x = Flatten()(x)
x = QDense(num_classes, kernel_quantizer=quantized_bits(4,0,1),
bias_quantizer=quantized_bits(4,0,1),
name="dense")(x)
x = Activation("softmax", name="softmax")(x)
model = Model(inputs=[x_in], outputs=[x])
return model
def QDenseModel(weights_f, load_weights=False):
"""Construct QDenseModel."""
x = x_in = Input((RESHAPED, ), name="input")
x = QActivation("quantized_relu(4)", name="act_i")(x)
x = QDense(N_HIDDEN,
kernel_quantizer=ternary(),
bias_quantizer=quantized_bits(4, 0, 1),
name="dense0")(x)
x = QActivation("quantized_relu(2)", name="act0")(x)
x = QDense(NB_CLASSES,
kernel_quantizer=quantized_bits(4, 0, 1),
bias_quantizer=quantized_bits(4, 0, 1),
name="dense2")(x)
x = Activation("softmax", name="softmax")(x)
model = Model(inputs=[x_in], outputs=[x])
model.summary()
model.compile(loss="categorical_crossentropy",
optimizer=OPTIMIZER,
metrics=["accuracy"])
if load_weights and weights_f:
model.load_weights(weights_f)
print_qstats(model)
return model
def QDenseModel(weights_f, load_weights=False):
"""Construct QDenseModel."""
x = x_in = Input((28 * 28, ), name="input")
x = QActivation("quantized_relu(2)", name="act_i")(x)
x = Dense(100, name="d0")(x)
x = BatchNormalization(name="bn0")(x)
x = QActivation("quantized_relu(2)", name="act0_m")(x)
x = Flatten(name="flatten")(x)
x = QDense(NB_CLASSES,
kernel_quantizer=quantized_bits(4, 0, 1),
bias_quantizer=quantized_bits(4, 0, 1),
name="dense2")(x)
x = Activation("softmax", name="softmax")(x)
model = Model(inputs=[x_in], outputs=[x])
model.summary()
model.compile(loss="categorical_crossentropy",
optimizer=OPTIMIZER,
metrics=["accuracy"])
if load_weights and weights_f:
model.load_weights(weights_f)
return model
def _batch_norm_plus_activation(self, x):
if self.postactivation_bn:
x = Activation(self.activation_function)(x)
x = BatchNormalization(center=False, scale=False)(x)
x = QActivation(
"quantized_bits(bits=13, integer=2, symmetric=0, keep_negative=1)"
)(x)
else:
x = BatchNormalization()(x)
x = Activation(self.activation_function)(x)
x = QActivation(
"quantized_bits(bits=13, integer=2, symmetric=0, keep_negative=1)"
)(x)
return x
def test_conv2d():
input_quantizers = None
act = "quantized_bits(6, 0, 1)"
weight = quantizers.quantized_relu_po2(4, 2)
x = x_in = keras.layers.Input((23, 23, 1), name="input")
x = QActivation(act, name="QA_0")(x)
x = QConv2D(16,
2,
2,
kernel_quantizer=weight,
bias_quantizer=weight,
name="qconv2d_1")(x)
model = keras.Model(inputs=[x_in], outputs=[x])
dtype_dict = run(model, input_quantizers)
multiplier = dtype_dict["qconv2d_1"]["multiplier"]
accumulator = dtype_dict["qconv2d_1"]["accumulator"]
op_count = dtype_dict["qconv2d_1"]["operation_count"]
assert multiplier["quantizer_type"] == "quantized_bits"
assert multiplier["bits"] == 15
assert multiplier["int_bits"] == 2
assert multiplier["is_signed"] == 1
assert multiplier["op_type"] == "shifter"
assert accumulator["quantizer_type"] == "quantized_bits"
assert accumulator["bits"] == 18
assert accumulator["int_bits"] == 5
assert accumulator["is_signed"] == 1
assert accumulator["op_type"] == "add"
assert op_count == 7744
def _skip_connection(self, y, downsample, n_filters_in):
"""Implement skip connection."""
# Deal with downsampling
if downsample > 1:
y = MaxPooling1D(downsample, strides=downsample, padding='same')(y)
elif downsample == 1:
y = y
else:
raise ValueError("Number of samples should always decrease.")
# Deal with n_filters dimension increase
if n_filters_in != self.n_filters_out:
# This is one of the two alternatives presented in ResNet paper
# Other option is to just fill the matrix with zeros.
y = QConv1D(self.n_filters_out,
1,
padding='same',
use_bias=False,
kernel_initializer=self.kernel_initializer,
kernel_quantizer=quantized_bits(bits=10,
integer=2,
symmetric=0,
keep_negative=1),
bias_quantizer=quantized_bits(bits=10,
integer=2,
symmetric=0,
keep_negative=1))(y)
y = QActivation(
"quantized_bits(bits=13, integer=2, symmetric=0, keep_negative=1)"
)(y)
return y
def quantized_cnn(Inputs,
nclasses,
filters,
kernel,
strides,
pooling,
dropout,
activation="quantized_relu(32,16)",
quantizer_cnn=quantized_bits(1),
quantizer_dense=quantized_bits(1)):
length = len(filters)
if any(
len(lst) != length
for lst in [filters, kernel, strides, pooling, dropout]):
sys.exit(
"One value for stride and kernel must be added for each filter! Exiting"
)
x = x_in = Inputs
for i, (f, k, s, p,
d) in enumerate(zip(filters, kernel, strides, pooling, dropout)):
print((
"Adding layer with {} filters, kernel_size=({},{}), strides=({},{})"
).format(f, k, k, s, s))
x = QConv2D(int(f),
kernel_size=(int(k), int(k)),
strides=(int(s), int(s)),
kernel_quantizer=quantizer_cnn,
bias_quantizer=quantizer_cnn,
name='conv_%i' % i)(x)
x = QActivation(activation)(x)
x = BatchNormalization()(x)
if float(p) != 0:
x = MaxPooling2D(pool_size=(int(p), int(p)))(x)
# x = Dropout(float(d))(x)
x = Flatten()(x)
x = QDense(128,
kernel_quantizer=quantizer_dense,
bias_quantizer=quantizer_dense)(x)
x = QActivation(activation)(x)
x = BatchNormalization()(x)
x = Dense(nclasses)(x)
model = Model(inputs=[x_in], outputs=[x])
return model
def _setup_transforms(self, n_aggregators, n_filters, n_propagate):
self._transform_layers = []
# inputs are lists
for it, (p, a,
f) in enumerate(zip(n_propagate, n_aggregators, n_filters)):
if self._quantize_transforms != None:
input_feature_transform = NamedQDense(
p,
kernel_quantizer="quantized_bits(%i,%i,0,alpha=1)" %
(self._total_bits, self._int_bits),
bias_quantizer="quantized_bits(%i,%i,0,alpha=1)" %
(self._total_bits, self._int_bits),
name=('FLR%d' % it))
output_feature_transform = NamedQDense(
f,
kernel_quantizer="quantized_bits(%i,%i,0,alpha=1)" %
(self._total_bits, self._int_bits),
name=('Fout%d' % it))
if (self._output_activation == None
or self._output_activation == "linear"):
output_activation_transform = QActivation(
"quantized_bits(%i, %i)" %
(self._total_bits, self._int_bits))
else:
output_activation_transform = QActivation(
"quantized_%s(%i, %i)" %
(self._output_activation, self._total_bits,
self._int_bits))
else:
input_feature_transform = NamedDense(p, name=('FLR%d' % it))
output_feature_transform = NamedDense(f, name=('Fout%d' % it))
output_activation_transform = keras.layers.Activation(
self._output_activation)
aggregator_distance = NamedDense(a, name=('S%d' % it))
self._transform_layers.append(
(input_feature_transform, aggregator_distance,
output_feature_transform))
self._sublayers = sum(
(list(layers) for layers in self._transform_layers), [])
def build_baseline(image_size=16, nclasses=5,filters = [8,8,16]):
inputs = tf.keras.Input((16),name="Input")
x = QDense(64,
kernel_quantizer = quantized_bits(4,0,1),
bias_quantizer = quantized_bits(4,0,1),name="qdense_1")(inputs)
x = QActivation('quantized_relu(4,2)',name="qact_1")(x)
x = QDense(32,
kernel_quantizer = 'ternary',
bias_quantizer = 'ternary',name="qdense_2")(x)
x = QActivation('quantized_relu(3,1)',name="qact_2")(x)
x = QDense(32,
kernel_quantizer = quantized_bits(2,1,1),
bias_quantizer = quantized_bits(2,1,1),name="qdense_3")(x)
x = QActivation('quantized_relu(4,2)',name="qact_3")(x)
x = QDense(5,
kernel_quantizer = 'stochastic_binary',
bias_quantizer = quantized_bits(8,3,1),name="qdense_nclasses")(x)
predictions = tf.keras.layers.Activation('softmax',name="softmax")(x)
model = tf.keras.Model(inputs, predictions,name='baseline')
return model
def po2_qbits_model():
x = x_in = keras.layers.Input((23, 23, 1), name="input")
x = QActivation("quantized_relu_po2(3, 2)", name="QA_0")(x)
x = QConv2D(16,
2,
2,
kernel_quantizer=quantizers.quantized_bits(4, 0, 1),
bias_quantizer=quantizers.quantized_bits(4, 0, 1),
name="qconv2d_1")(x)
model = keras.Model(inputs=[x_in], outputs=[x])
return model
def test_populate_bias_quantizer_from_accumulator():
"""Test populate_bias_quantizer_from_accumulator function.
Define a qkeras model with a QConv2DBatchnorm layer. Set bias quantizer in the
layer as None. Call populate_bias_quantizer_from_accumulator function
to automatically generate bias quantizer type from the MAC accumulator type.
Set the bias quantizer accordingly in the model.
Call populate_bias_quantizer_from_accumulator again in this model. This time
since bias quantizer is already set, populate_bias_quantizer_from_accumulator
function should not change the bias quantizer.
"""
x_shape = (2, 2, 1)
# get a qkeras model with QConv2DBatchnorm layer. Set bias quantizer in the
# layer as None.
x = x_in = layers.Input(x_shape, name="input")
x1 = QConv2D(filters=1, kernel_size=(1, 1), strides=(1, 1), use_bias=False,
kernel_quantizer="quantized_bits(4, 0, 1)", name="conv2d_1")(x)
x2 = QConv2D(filters=1, kernel_size=(1, 1), strides=(1, 1), use_bias=False,
kernel_quantizer="quantized_bits(4, 0, 1)", name="conv2d_2")(x)
x = layers.Maximum()([x1, x2])
x = QActivation("quantized_relu(4, 1)")(x)
x = QConv2DBatchnorm(
filters=2, kernel_size=(2, 2), strides=(4, 4),
kernel_initializer="ones", bias_initializer="zeros", use_bias=False,
kernel_quantizer="quantized_bits(4, 0, 1)", bias_quantizer=None,
beta_initializer="zeros",
gamma_initializer="ones", moving_mean_initializer="zeros",
moving_variance_initializer="ones", folding_mode="batch_stats_folding",
ema_freeze_delay=10,
name="foldconv2d")(x)
x1 = x
x2 = layers.Flatten(name="flatten")(x)
x2 = QDense(2, use_bias=False, kernel_initializer="ones",
kernel_quantizer="quantized_bits(6, 2, 1)", name="dense")(x2)
model = Model(inputs=[x_in], outputs=[x1, x2])
assert_equal(model.layers[5].get_quantizers()[1], None)
# Call populate_bias_quantizer_from_accumulator function
# to automatically generate bias quantizer from the MAC accumulator type.
_ = bn_folding_utils.populate_bias_quantizer_from_accumulator(
model, ["quantized_bits(8, 0, 1)"])
q = model.layers[5].get_quantizers()[1]
assert_equal(q.__str__(), "quantized_bits(10,3,1)")
# Call populate_bias_quantizer_from_accumulator function again
# bias quantizer should not change
_ = bn_folding_utils.populate_bias_quantizer_from_accumulator(
model, ["quantized_bits(8, 0, 1)"])
q = model.layers[5].get_quantizers()[1]
assert_equal(q.__str__(), "quantized_bits(10,3,1)")
def test_dense():
data = getData()
nBits = 8
nBitsInt = 4
qbits_param_input = qkr.quantized_bits(bits=nBits,
integer=nBitsInt,
keep_negative=0)
qbits_param = qkr.quantized_bits(bits=nBits,
integer=nBitsInt,
keep_negative=1)
# simple model only quantizes
inputs = Input(shape=(4, 4, 3))
x = inputs
x = Flatten(name="flatten")(x)
x = QActivation(qbits_param_input, name='q_decoder_output')(x)
encodedLayer = QDense(10,
activation='relu',
name='encoded_vector',
kernel_quantizer=qbits_param,
bias_quantizer=qbits_param)(x)
model = Model(inputs, encodedLayer, name='encoder')
model.summary()
model.compile(loss='mse', optimizer='adam')
val_input, train_input = split(data, 0.5)
train_output = np.ones(50).reshape(5, 10) # garbage outputs for training
val_output = np.ones(50).reshape(5, 10) # garbage outputs for validation
es = kr.callbacks.EarlyStopping(monitor='val_loss',
mode='min',
verbose=1,
patience=3)
history = model.fit(train_input,
train_output,
epochs=1,
batch_size=500,
shuffle=True,
validation_data=(val_input, val_output),
callbacks=[es])
val_output = model.predict(val_input)
print('\nTEST DENSE')
print('\nRaw validation output: \n', val_output)
print(
'\nMultiplied by 2^(decimal bits): \n Results should be integers * weight precision... \n',
val_output * (2**(nBits - nBitsInt)))
return
def test_sequential_qnetwork():
model = tf.keras.Sequential()
model.add(Input((28, 28, 1), name='input'))
model.add(
QConv2D(32, (2, 2),
strides=(2, 2),
kernel_quantizer=quantized_bits(4, 0, 1),
bias_quantizer=quantized_bits(4, 0, 1),
name='conv2d_0_m'))
model.add(QActivation(quantized_relu(4, 0), name='act0_m'))
model.add(
QConv2D(64, (3, 3),
strides=(2, 2),
kernel_quantizer=quantized_bits(4, 0, 1),
bias_quantizer=quantized_bits(4, 0, 1),
name='conv2d_1_m'))
model.add(QActivation(quantized_relu(4, 0), name='act1_m'))
model.add(
QConv2D(64, (2, 2),
strides=(2, 2),
kernel_quantizer=quantized_bits(4, 0, 1),
bias_quantizer=quantized_bits(4, 0, 1),
name='conv2d_2_m'))
model.add(QActivation(quantized_relu(4, 0), name='act2_m'))
model.add(Flatten())
model.add(
QDense(10,
kernel_quantizer=quantized_bits(4, 0, 1),
bias_quantizer=quantized_bits(4, 0, 1),
name='dense'))
model.add(Activation('softmax', name='softmax'))
# Check that all model operation were found correctly
model_ops = extract_model_operations(model)
for layer in model_ops.keys():
assert model_ops[layer]['type'][0] != 'null'
return model
def _setup_transforms(self, n_aggregators, n_filters, n_propagate):
if self._quantize_transforms:
self._input_feature_transform = NamedQDense(
n_propagate,
kernel_quantizer="quantized_bits(%i,%i,0,alpha=1)" %
(self._total_bits, self._int_bits),
bias_quantizer="quantized_bits(%i,%i,0,alpha=1)" %
(self._total_bits, self._int_bits),
name='FLR')
self._output_feature_transform = NamedQDense(
n_filters,
kernel_quantizer="quantized_bits(%i,%i,0,alpha=1)" %
(self._total_bits, self._int_bits),
name='Fout')
if (self._output_activation == None
or self._output_activation == "linear"):
self._output_activation_transform = QActivation(
"quantized_bits(%i, %i)" %
(self._total_bits, self._int_bits))
else:
self._output_activation_transform = QActivation(
"quantized_%s(%i, %i)" %
(self._output_activation, self._total_bits,
self._int_bits))
else:
self._input_feature_transform = NamedDense(n_propagate, name='FLR')
self._output_feature_transform = NamedDense(
n_filters, activation=self._output_activation, name='Fout')
self._output_activation_transform = keras.layers.Activation(
self._output_activation)
self._aggregator_distance = NamedDense(n_aggregators, name='S')
self._sublayers = [
self._input_feature_transform, self._aggregator_distance,
self._output_feature_transform, self._output_activation_transform
]
def build_layerwise_model(input_shape, **pruning_params):
return Sequential([
prune.prune_low_magnitude(
QConv2D(
32, (2, 2), strides=(2,2),
kernel_quantizer=quantized_bits(4,0,1),
bias_quantizer=quantized_bits(4,0,1),
name="conv2d_0_m"),
input_shape=input_shape,
**pruning_params),
QActivation("quantized_relu(4,0)", name="act0_m"),
prune.prune_low_magnitude(
QConv2D(
64, (3, 3), strides=(2,2),
kernel_quantizer=quantized_bits(4,0,1),
bias_quantizer=quantized_bits(4,0,1),
name="conv2d_1_m"),
**pruning_params),
QActivation("quantized_relu(4,0)", name="act1_m"),
prune.prune_low_magnitude(
QConv2D(
64, (2, 2), strides=(2,2),
kernel_quantizer=quantized_bits(4,0,1),
bias_quantizer=quantized_bits(4,0,1),
name="conv2d_2_m"),
**pruning_params),
QActivation("quantized_relu(4,0)", name="act2_m"),
Flatten(),
prune.prune_low_magnitude(
QDense(
num_classes, kernel_quantizer=quantized_bits(4,0,1),
bias_quantizer=quantized_bits(4,0,1),
name="dense"),
**pruning_params),
Activation("softmax", name="softmax")
])
def qdense_model_fork():
x = x_in = keras.layers.Input((23, ), name="input")
x = QDense(10,
kernel_quantizer=quantizers.quantized_bits(5, 0, 1),
bias_quantizer=quantizers.quantized_bits(5, 0, 1),
activation=quantizers.quantized_po2(3, 1),
name="qdense_0")(x)
x = QDense(20,
kernel_quantizer=quantizers.quantized_bits(5, 0, 1),
bias_quantizer=quantizers.quantized_bits(5, 0, 1),
activation=quantizers.quantized_relu(6, 2),
name="qdense_1")(x)
x = QActivation("quantized_relu(4)", name="QA_2")(x)
x_1 = QDense(30,
kernel_quantizer=quantizers.binary(),
bias_quantizer=quantizers.binary(),
name="qdense_3")(x)
x_2 = QActivation("quantized_relu(6,2)", name="QA_3")(x)
model = keras.Model(inputs=[x_in], outputs=[
x_1,
x_2,
])
return model
def hybrid_model():
"""hybrid model that mixes qkeras and keras layers."""
x = x_in = keras.layers.Input((784, ), name="input")
x = keras.layers.Dense(300, name="d0")(x)
x = keras.layers.Activation("relu", name="d0_act")(x)
x = QDense(100,
kernel_quantizer=quantizers.quantized_bits(4, 0, 1),
bias_quantizer=quantizers.quantized_bits(4, 0, 1),
name="d1")(x)
x = QActivation("quantized_relu(4,0)", name="d1_qr4")(x)
x = QDense(10,
kernel_quantizer=quantizers.quantized_bits(4, 0, 1),
bias_quantizer=quantizers.quantized_bits(4, 0, 1),
name="d2")(x)
x = keras.layers.Activation("softmax", name="softmax")(x)
return keras.Model(inputs=[x_in], outputs=[x])
def gen_model(img_shape):
img_input = x = keras.Input(shape=img_shape)
x = QConv2D(filters=5,
kernel_size=4,
strides=4,
kernel_quantizer=quantizers.quantized_bits(
8, 3, alpha="auto_po2"),
bias_quantizer=quantizers.quantized_bits(8, 3),
name="conv")(x)
x = QActivation(activation=quantizers.quantized_relu(4, 0),
name="act")(x)
x = keras.layers.Flatten(name="flatten")(x)
x = QDense(5,
kernel_quantizer=quantizers.quantized_bits(
8, 0, alpha="auto_po2"),
bias_quantizer=quantizers.quantized_bits(8, 3),
name="dense")(x)
model = keras.Model(inputs=img_input, outputs=[x])
return model
def qbn_model(act="binary(use_01=0)",
gamma=quantizers.quantized_relu_po2(4, 2),
variance=quantizers.quantized_relu_po2(4, 2),
beta=None,
mean=None):
x = x_in = keras.layers.Input((23, 23, 1), name="input")
x = QActivation(act, name="QA_0")(x)
x = QBatchNormalization(gamma_quantizer=gamma,
variance_quantizer=variance,
beta_quantizer=beta,
mean_quantizer=mean,
gamma_range=8,
beta_range=4,
name="qbn_1")(x)
model = keras.Model(inputs=[x_in], outputs=[x])
return model
def test_inputs():
data = getData()
nBits = 8
nBitsInt = 4
qbits_param_input = qkr.quantized_bits(bits=nBits,
integer=nBitsInt,
keep_negative=0)
# simple model only quantizes
inputs = Input(shape=(4, 4, 3))
x = inputs
x = Flatten(name="flatten")(x)
x = QActivation(qbits_param_input, name='q_decoder_output')(x)
model = Model(inputs, x, name='encoder')
model.summary()
model.compile(loss='mse', optimizer='adam')
val_input, train_input = split(data, 0.5)
train_output = np.ones(240).reshape(5, 48) # garbage outputs for training
val_output = np.ones(240).reshape(5, 48) # garbage outputs for validation
es = kr.callbacks.EarlyStopping(monitor='val_loss',
mode='min',
verbose=1,
patience=3)
history = model.fit(train_input,
train_output,
epochs=1,
batch_size=500,
shuffle=True,
validation_data=(val_input, val_output),
callbacks=[es])
val_output = model.predict(val_input)
print('\nTEST INPUTS')
print('\nRaw validation output: \n', val_output)
print('\nMultiplied by 2^(decimal bits): \n',
val_output * (2**(nBits - nBitsInt)))
return
def get_model(quantize=False):
x1 = input1 = keras.layers.Input((16, 16, 3), name="input_0")
if quantize:
x1 = QConv2D(16,
2,
2,
kernel_quantizer=quantizers.quantized_bits(5, 0, 1),
bias_quantizer=quantizers.quantized_bits(5, 0, 1),
name="conv_0")(x1)
else:
x1 = keras.layers.Conv2D(16, 2, 2, name="conv_0")(x1)
x2 = input2 = keras.layers.Input(shape=(16, 16, 3), name="input_1")
if quantize:
x2 = QConv2D(16,
2,
2,
kernel_quantizer=quantizers.quantized_bits(5, 0, 1),
bias_quantizer=quantizers.quantized_bits(5, 0, 1),
name="conv_1")(x2)
else:
x2 = keras.layers.Conv2D(16, 2, 2, name="conv_1")(x2)
x = keras.layers.add([x1, x2], name="add")
if quantize:
x = QActivation(activation="quantized_relu(8, 2)", name="relu")(x)
else:
x = keras.layers.Activation("relu", name="relu")(x)
if quantize:
x = QConv2D(2,
2,
2,
kernel_quantizer=quantizers.quantized_bits(5, 0, 1),
bias_quantizer=quantizers.quantized_bits(5, 0, 1),
name="conv_2")(x)
else:
x = keras.layers.Conv2D(2, 2, 2, name="conv_2")(x)
model = keras.Model(inputs=[input1, input2], outputs=[x])
return model
def float_po2_model():
x = x_in = keras.layers.Input((23, 23, 1), name="input")
x = QConv2D(16,
2,
2,
kernel_quantizer=quantizers.quantized_po2(5, 0),
bias_quantizer=quantizers.quantized_po2(5, 0),
name="qconv2d_1")(x)
x = QActivation("quantized_relu_po2(3, 2)", name="QA_0")(x)
x = QConv2D(10,
2,
2,
kernel_quantizer=quantizers.quantized_bits(5, 2, 1),
bias_quantizer=quantizers.quantized_bits(5, 2, 1),
name="qconv2d_0")(x)
model = keras.Model(inputs=[x_in], outputs=[x])
for layer in model.layers:
print(layer)
print(layer.output_shape)
return model
def test_util_layers():
input_quantizers = None # quantizers.quantized_bits(4, 0, 1)
act = "quantized_bits(6, 0, 1)"
x = x_in = keras.layers.Input((24, 24, 1), name="input")
x = QActivation(act, name="QA_0")(x)
x = keras.layers.Reshape((12 * 12, 4, 1), name="reshape_1")(x)
x = keras.layers.MaxPooling2D(pool_size=(2, 2), name="maxpooling_2")(x)
x = keras.layers.Flatten(name="flatten_3")(x)
x = QDense(30,
kernel_quantizer=quantizers.binary(use_01=1),
bias_quantizer=quantizers.binary(use_01=1),
activation=quantizers.quantized_po2(3, 2),
name="qdense_4")(x)
model = keras.Model(inputs=[x_in], outputs=[x])
dtype_dict = run(model, input_quantizers)
multiplier = dtype_dict["qdense_4"]["multiplier"]
assert multiplier["quantizer_type"] == "quantized_bits"
assert multiplier["bits"] == 6
assert multiplier["int_bits"] == 1
assert multiplier["is_signed"] == 1
assert multiplier["op_type"] == "and"
accumulator = dtype_dict["qdense_4"]["accumulator"]
assert accumulator["quantizer_type"] == "quantized_bits"
assert accumulator["bits"] == 15
assert accumulator["int_bits"] == 10
assert accumulator["is_signed"] == 1
assert accumulator["op_type"] == "add"
output = dtype_dict["qdense_4"]["output_quantizer"]
assert output["quantizer_type"] == "quantized_po2"
assert output["bits"] == 3
assert output["is_signed"] == 1
assert output["max_value"] == 2
def init(
self,
printSummary=True
): # keep_negitive = 0 on inputs, otherwise for weights keep default (=1)
encoded_dim = self.pams['encoded_dim']
CNN_layer_nodes = self.pams['CNN_layer_nodes']
CNN_kernel_size = self.pams['CNN_kernel_size']
CNN_pool = self.pams['CNN_pool']
Dense_layer_nodes = self.pams[
'Dense_layer_nodes'] # does not include encoded layer
channels_first = self.pams['channels_first']
inputs = Input(
shape=self.pams['shape']
) # adapt this if using `channels_first` image data format
# load bits to quantize
nBits_input = self.pams['nBits_input']
nBits_accum = self.pams['nBits_accum']
nBits_weight = self.pams['nBits_weight']
nBits_encod = self.pams['nBits_encod']
nBits_dense = self.pams[
'nBits_dense'] if 'nBits_dense' in self.pams else nBits_weight
nBits_conv = self.pams[
'nBits_conv'] if 'nBits_conv' in self.pams else nBits_weight
input_Qbits = self.GetQbits(
nBits_input, keep_negative=1) #oddly fails if keep_neg=0
accum_Qbits = self.GetQbits(nBits_accum, keep_negative=1)
dense_Qbits = self.GetQbits(nBits_dense, keep_negative=1)
conv_Qbits = self.GetQbits(nBits_conv, keep_negative=1)
encod_Qbits = self.GetQbits(nBits_encod, keep_negative=1)
# keeping weights and bias same precision for now
# define model
x = inputs
x = QActivation(input_Qbits, name='input_qa')(x)
for i, n_nodes in enumerate(CNN_layer_nodes):
if channels_first:
x = QConv2D(n_nodes,
CNN_kernel_size[i],
activation='relu',
padding='same',
data_format='channels_first',
name="conv2d_" + str(i) + "_m",
kernel_quantizer=conv_Qbits,
bias_quantizer=conv_Qbits)(x)
else:
x = QConv2D(n_nodes,
CNN_kernel_size[i],
activation='relu',
padding='same',
name="conv2d_" + str(i) + "_m",
kernel_quantizer=conv_Qbits,
bias_quantizer=conv_Qbits)(x)
if CNN_pool[i]:
if channels_first:
x = MaxPooling2D((2, 2),
padding='same',
data_format='channels_first',
name="mp_" + str(i))(x)
else:
x = MaxPooling2D((2, 2),
padding='same',
name="mp_" + str(i))(x)
shape = K.int_shape(x)
x = QActivation(accum_Qbits, name='accum1_qa')(x)
x = Flatten(name="flatten")(x)
# encoder dense nodes
for i, n_nodes in enumerate(Dense_layer_nodes):
x = QDense(n_nodes,
activation='relu',
name="en_dense_" + str(i),
kernel_quantizer=dense_Qbits,
bias_quantizer=dense_Qbits)(x)
x = QDense(encoded_dim,
activation='relu',
name='encoded_vector',
kernel_quantizer=dense_Qbits,
bias_quantizer=dense_Qbits)(x)
encodedLayer = QActivation(encod_Qbits, name='encod_qa')(x)
# Instantiate Encoder Model
self.encoder = Model(inputs, encodedLayer, name='encoder')
if printSummary:
self.encoder.summary()
encoded_inputs = Input(shape=(encoded_dim, ), name='decoder_input')
x = encoded_inputs
# decoder dense nodes
for i, n_nodes in enumerate(Dense_layer_nodes):
x = Dense(n_nodes, activation='relu', name="de_dense_" + str(i))(x)
x = Dense(shape[1] * shape[2] * shape[3],
activation='relu',
name='de_dense_final')(x)
x = Reshape((shape[1], shape[2], shape[3]), name="de_reshape")(x)
for i, n_nodes in enumerate(CNN_layer_nodes):
if CNN_pool[i]:
if channels_first:
x = UpSampling2D((2, 2),
data_format='channels_first',
name="up_" + str(i))(x)
else:
x = UpSampling2D((2, 2), name="up_" + str(i))(x)
if channels_first:
x = Conv2DTranspose(n_nodes,
CNN_kernel_size[i],
activation='relu',
padding='same',
data_format='channels_first',
name="conv2D_t_" + str(i))(x)
else:
x = Conv2DTranspose(n_nodes,
CNN_kernel_size[i],
activation='relu',
padding='same',
name="conv2D_t_" + str(i))(x)
if channels_first:
# shape[0] will be # of channel
x = Conv2DTranspose(filters=self.pams['shape'][0],
kernel_size=CNN_kernel_size[0],
padding='same',
data_format='channels_first',
name="conv2d_t_final")(x)
else:
x = Conv2DTranspose(filters=self.pams['shape'][2],
kernel_size=CNN_kernel_size[0],
padding='same',
name="conv2d_t_final")(x)
x = QActivation(input_Qbits,
name='q_decoder_output')(x) #Verify this step needed?
outputs = Activation('sigmoid', name='decoder_output')(x)
self.decoder = Model(encoded_inputs, outputs, name='decoder')
if printSummary:
self.decoder.summary()
self.autoencoder = Model(inputs,
self.decoder(self.encoder(inputs)),
name='autoencoder')
if printSummary:
self.autoencoder.summary()
if self.pams['loss'] == "weightedMSE":
self.autoencoder.compile(loss=self.weightedMSE, optimizer='adam')
self.encoder.compile(loss=self.weightedMSE, optimizer='adam')
elif self.pams['loss'] != '':
self.autoencoder.compile(loss=self.pams['loss'], optimizer='adam')
self.encoder.compile(loss=self.pams['loss'], optimizer='adam')
else:
self.autoencoder.compile(loss='mse', optimizer='adam')
self.encoder.compile(loss='mse', optimizer='adam')
CNN_layers = ''
if len(CNN_layer_nodes) > 0:
CNN_layers += '_Conv'
for i, n in enumerate(CNN_layer_nodes):
CNN_layers += f'_{n}x{CNN_kernel_size[i]}'
if CNN_pool[i]:
CNN_layers += 'pooled'
Dense_layers = ''
if len(Dense_layer_nodes) > 0:
Dense_layers += '_Dense'
for n in Dense_layer_nodes:
Dense_layers += f'_{n}'
self.name = f'Autoencoded{CNN_layers}{Dense_layers}_Encoded_{encoded_dim}'
if not self.weights_f == '':
self.autoencoder.load_weights(self.weights_f)
def test_qnetwork():
x = x_in = Input((28, 28, 1), name='input')
x = QSeparableConv2D(
32, (2, 2),
strides=(2, 2),
depthwise_quantizer="binary",
pointwise_quantizer=quantized_bits(4, 0, 1),
depthwise_activation=quantized_bits(6, 2, 1),
bias_quantizer=quantized_bits(4, 0, 1),
name='conv2d_0_m')(
x)
x = QActivation('quantized_relu(6,2,1)', name='act0_m')(x)
x = QConv2D(
64, (3, 3),
strides=(2, 2),
kernel_quantizer="ternary",
bias_quantizer=quantized_bits(4, 0, 1),
name='conv2d_1_m',
activation=quantized_relu(6, 3, 1))(
x)
x = QConv2D(
64, (2, 2),
strides=(2, 2),
kernel_quantizer=quantized_bits(6, 2, 1),
bias_quantizer=quantized_bits(4, 0, 1),
name='conv2d_2_m')(
x)
x = QActivation('quantized_relu(6,4,1)', name='act2_m')(x)
x = Flatten(name='flatten')(x)
x = QDense(
10,
kernel_quantizer=quantized_bits(6, 2, 1),
bias_quantizer=quantized_bits(4, 0, 1),
name='dense')(
x)
x = Activation('softmax', name='softmax')(x)
model = Model(inputs=[x_in], outputs=[x])
# reload the model to ensure saving/loading works
json_string = model.to_json()
clear_session()
model = quantized_model_from_json(json_string)
# generate same output for weights
np.random.seed(42)
for layer in model.layers:
all_weights = []
for i, weights in enumerate(layer.get_weights()):
input_size = np.prod(layer.input.shape.as_list()[1:])
if input_size is None:
input_size = 576 * 10 # to avoid learning sizes
shape = weights.shape
assert input_size > 0, 'input size for {} {}'.format(layer.name, i)
# he normal initialization with a scale factor of 2.0
all_weights.append(
10.0 * np.random.normal(0.0, np.sqrt(2.0 / input_size), shape))
if all_weights:
layer.set_weights(all_weights)
# apply quantizer to weights
model_save_quantized_weights(model)
all_weights = []
for layer in model.layers:
for i, weights in enumerate(layer.get_weights()):
w = np.sum(weights)
all_weights.append(w)
all_weights = np.array(all_weights)
# test_qnetwork_weight_quantization
all_weights_signature = np.array(
[2., -6.75, -0.625, -2., -0.25, -56., 1.125, -1.625, -1.125])
assert all_weights.size == all_weights_signature.size
assert np.all(all_weights == all_weights_signature)
# test_qnetwork_forward:
expected_output = np.array([[0.e+00, 0.e+00, 0.e+00, 0.e+00, 0.e+00,
0.e+00, 1.e+00, 0.e+00, 0.e+00, 0.e+00],
[0.e+00, 0.e+00, 0.e+00, 0.e+00, 0.e+00,
0.e+00, 1.e+00, 0.e+00, 0.e+00, 0.e+00],
[0.e+00, 0.e+00, 0.e+00, 0.e+00, 0.e+00,
0.e+00, 0.e+00, 0.e+00, 6.e-08, 1.e+00],
[0.e+00, 0.e+00, 0.e+00, 0.e+00, 0.e+00,
0.e+00, 1.e+00, 0.e+00, 0.e+00, 0.e+00],
[0.e+00 ,0.e+00, 0.e+00, 0.e+00, 0.e+00,
0.e+00, 1.e+00, 0.e+00, 0.e+00, 0.e+00],
[0.e+00, 0.e+00, 0.e+00, 0.e+00, 0.e+00,
0.e+00, 0.e+00, 0.e+00, 5.e-07, 1.e+00],
[0.e+00, 0.e+00, 0.e+00, 0.e+00, 0.e+00,
0.e+00 ,1.e+00, 0.e+00, 0.e+00, 0.e+00],
[0.e+00, 1.e+00, 0.e+00, 0.e+00, 0.e+00,
0.e+00 ,0.e+00, 0.e+00, 0.e+00, 0.e+00],
[0.e+00, 0.e+00, 0.e+00, 0.e+00, 1.e+00,
0.e+00, 0.e+00, 0.e+00, 0.e+00, 0.e+00],
[0.e+00, 0.e+00, 0.e+00, 0.e+00, 0.e+00,
1.e+00, 0.e+00, 0.e+00, 0.e+00, 0.e+00]]).astype(np.float16)
inputs = 2 * np.random.rand(10, 28, 28, 1)
actual_output = model.predict(inputs).astype(np.float16)
assert_allclose(actual_output, expected_output, rtol=1e-4)
"quantized_bits(bits=13, integer=2, symmetric=0, keep_negative=1)"
)(x)
if self.dropout_rate > 0:
x = Dropout(self.dropout_rate)(x)
y = x
return [x, y]
# ----- Model ----- #
kernel_size = 16
kernel_initializer = 'he_normal'
signal = Input(shape=(4096, 12), dtype=np.float32, name='signal')
age_range = Input(shape=(6, ), dtype=np.float32, name='age_range')
is_male = Input(shape=(1, ), dtype=np.float32, name='is_male')
x = signal
x = QActivation(
"quantized_bits(bits=13, integer=2, symmetric=0, keep_negative=1)")(x)
x = QConv1D(64,
kernel_size,
padding='same',
use_bias=False,
kernel_initializer=kernel_initializer,
kernel_quantizer=quantized_bits(bits=10,
integer=2,
symmetric=0,
keep_negative=1),
bias_quantizer=quantized_bits(bits=10,
integer=2,
symmetric=0,
keep_negative=1))(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
def __call__(self, inputs):
"""Residual unit."""
x, y = inputs
n_samples_in = y.shape[
1] #.value ### BEFORE THERE WAS NO COMMENT HERE
downsample = n_samples_in // self.n_samples_out
n_filters_in = y.shape[
2] #.value ### BEFORE THERE WAS NO COMMENT HERE
y = self._skip_connection(y, downsample, n_filters_in)
# 1st layer
x = QConv1D(self.n_filters_out,
self.kernel_size,
padding='same',
use_bias=False,
kernel_initializer=self.kernel_initializer,
kernel_quantizer=quantized_bits(bits=10,
integer=2,
symmetric=0,
keep_negative=1),
bias_quantizer=quantized_bits(bits=10,
integer=2,
symmetric=0,
keep_negative=1))(x)
x = QActivation(
"quantized_bits(bits=13, integer=2, symmetric=0, keep_negative=1)"
)(x)
x = self._batch_norm_plus_activation(x)
if self.dropout_rate > 0:
x = Dropout(self.dropout_rate)(x)
# 2nd layer
x = QConv1D(self.n_filters_out,
self.kernel_size,
strides=downsample,
padding='same',
use_bias=False,
kernel_initializer=self.kernel_initializer,
kernel_quantizer=quantized_bits(bits=10,
integer=2,
symmetric=0,
keep_negative=1),
bias_quantizer=quantized_bits(bits=10,
integer=2,
symmetric=0,
keep_negative=1))(x)
if self.preactivation:
x = Add()([x, y]) # Sum skip connection and main connection
y = x
x = self._batch_norm_plus_activation(x)
if self.dropout_rate > 0:
x = Dropout(self.dropout_rate)(x)
else:
x = BatchNormalization()(x)
x = Add()([x, y]) # Sum skip connection and main connection
x = Activation(self.activation_function)(x)
x = QActivation(
"quantized_bits(bits=13, integer=2, symmetric=0, keep_negative=1)"
)(x)
if self.dropout_rate > 0:
x = Dropout(self.dropout_rate)(x)
y = x
return [x, y]
def test_qenergy():
x = x_in = keras.layers.Input((784, ), name="input")
x = QDense(300,
kernel_quantizer=quantizers.binary(),
bias_quantizer=quantizers.binary(),
name="d0")(x)
x = QActivation("quantized_relu(4,0)", name="d0_qr4")(x)
x = QDense(100,
kernel_quantizer=quantizers.quantized_bits(4, 0, 1),
bias_quantizer=quantizers.quantized_bits(4, 0, 1),
name="d1")(x)
x = QAdaptiveActivation("quantized_relu", 4, name="d1_qr4")(x)
x = QDense(10,
kernel_quantizer=quantizers.quantized_bits(4, 0, 1),
bias_quantizer=quantizers.quantized_bits(4, 0, 1),
name="d2")(x)
x = keras.layers.Activation("softmax", name="softmax")(x)
model = keras.Model(inputs=[x_in], outputs=[x])
# print(model.summary())
reference_internal = "int8"
reference_accumulator = "int32"
# get reference energy cost
q = run_qtools.QTools(model,
process="horowitz",
source_quantizers=reference_internal,
is_inference=False,
weights_path=None,
keras_quantizer=reference_internal,
keras_accumulator=reference_accumulator,
for_reference=True)
ref_energy_dict = q.pe(weights_on_memory="sram",
activations_on_memory="sram",
min_sram_size=8 * 16 * 1024 * 1024,
rd_wr_on_io=False)
reference_size = q.extract_energy_sum(qtools_settings.cfg.include_energy,
ref_energy_dict)
# get trial energy cost
q = run_qtools.QTools(model,
process="horowitz",
source_quantizers=reference_internal,
is_inference=False,
weights_path=None,
keras_quantizer=reference_internal,
keras_accumulator=reference_accumulator,
for_reference=False)
trial_energy_dict = q.pe(weights_on_memory="sram",
activations_on_memory="sram",
min_sram_size=8 * 16 * 1024 * 1024,
rd_wr_on_io=False)
trial_size = q.extract_energy_sum(qtools_settings.cfg.include_energy,
trial_energy_dict)
# Reference energy number is now updated with keras_accumulator as
# output quantizer
tmp = ref_energy_dict["d0"]["energy"]
assert tmp["inputs"] == pytest.approx(372.77, abs=0.1)
assert tmp["outputs"] == pytest.approx(570.57, abs=0.1)
assert tmp["parameters"] == pytest.approx(111975.96, abs=0.1)
assert tmp["op_cost"] == pytest.approx(70560.0, abs=0.1)
tmp = ref_energy_dict["d1"]["energy"]
assert tmp["inputs"] == pytest.approx(570.57, abs=0.1)
assert tmp["outputs"] == pytest.approx(190.19, abs=0.1)
assert tmp["parameters"] == pytest.approx(14313.66, abs=0.1)
assert tmp["op_cost"] == pytest.approx(26500.0, abs=0.1)
tmp = ref_energy_dict["d2"]["energy"]
assert tmp["inputs"] == pytest.approx(190.19, abs=0.1)
assert tmp["outputs"] == pytest.approx(19.02, abs=0.1)
assert tmp["parameters"] == pytest.approx(483.08, abs=0.1)
assert tmp["op_cost"] == pytest.approx(883.33, abs=0.1)
# Trial
tmp = trial_energy_dict["d0"]["energy"]
assert tmp["inputs"] == pytest.approx(372.77, abs=0.1)
assert tmp["outputs"] == pytest.approx(342.34, abs=0.1)
assert tmp["parameters"] == pytest.approx(13997.95, abs=0.1)
assert tmp["op_cost"] == pytest.approx(15729.0, abs=0.1)
tmp = trial_energy_dict["d1"]["energy"]
assert tmp["inputs"] == pytest.approx(72.27, abs=0.1)
assert tmp["outputs"] == pytest.approx(110.31, abs=0.1)
assert tmp["parameters"] == pytest.approx(7158.73, abs=0.1)
assert tmp["op_cost"] == pytest.approx(3250.0, abs=0.1)
tmp = trial_energy_dict["d2"]["energy"]
assert tmp["inputs"] == pytest.approx(26.63, abs=0.1)
assert tmp["outputs"] == pytest.approx(11.41, abs=0.1)
assert tmp["parameters"] == pytest.approx(243.44, abs=0.1)
assert tmp["op_cost"] == pytest.approx(102.08, abs=0.1)
# print(ref_energy_dict)
# print(trial_energy_dict)
assert int(reference_size) == 226629
assert int(trial_size) == 41070
def test_qnetwork():
x = x_in = Input((28, 28, 1), name='input')
x = QSeparableConv2D(32, (2, 2),
strides=(2, 2),
depthwise_quantizer=binary(),
pointwise_quantizer=quantized_bits(4, 0, 1),
depthwise_activation=quantized_bits(6, 2, 1),
bias_quantizer=quantized_bits(4, 0, 1),
name='conv2d_0_m')(x)
x = QActivation('quantized_relu(6,2,1)', name='act0_m')(x)
x = QConv2D(64, (3, 3),
strides=(2, 2),
kernel_quantizer=ternary(),
bias_quantizer=quantized_bits(4, 0, 1),
name='conv2d_1_m')(x)
x = QActivation('quantized_relu(6, 3, 1)', name='act1_m')(x)
x = QConv2D(64, (2, 2),
strides=(2, 2),
kernel_quantizer=quantized_bits(6, 2, 1),
bias_quantizer=quantized_bits(4, 0, 1),
name='conv2d_2_m')(x)
x = QActivation('quantized_relu(6,4,1)', name='act2_m')(x)
x = Flatten(name='flatten')(x)
x = QDense(10,
kernel_quantizer=quantized_bits(6, 2, 1),
bias_quantizer=quantized_bits(4, 0, 1),
name='dense')(x)
x = Activation('softmax', name='softmax')(x)
model = Model(inputs=[x_in], outputs=[x])
# generate same output for weights
np.random.seed(42)
for layer in model.layers:
all_weights = []
for i, weights in enumerate(layer.get_weights()):
input_size = np.prod(layer.input.shape.as_list()[1:])
if input_size is None:
input_size = 576 * 10 # hack to avoid learning sizes
shape = weights.shape
assert input_size > 0, 'input size for {} {}'.format(layer.name, i)
# he normal initialization with a scale factor of 2.0
all_weights.append(
10.0 * np.random.normal(0.0, np.sqrt(2.0 / input_size), shape))
if all_weights:
layer.set_weights(all_weights)
# apply quantizer to weights
model_save_quantized_weights(model)
all_weights = []
for layer in model.layers:
for i, weights in enumerate(layer.get_weights()):
w = np.sum(weights)
all_weights.append(w)
all_weights = np.array(all_weights)
# test_qnetwork_weight_quantization
all_weights_signature = np.array(
[2.0, -6.75, -0.625, -2.0, -0.25, -56.0, 1.125, -2.625, -0.75])
assert all_weights.size == all_weights_signature.size
assert np.all(all_weights == all_weights_signature)
# test_qnetwork_forward:
y = np.array([[
0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 5.341e-02,
9.468e-01, 0.000e+00, 0.000e+00, 0.000e+00
],
[
0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 5.960e-08,
0.000e+00, 1.919e-01, 0.000e+00, 0.000e+00, 8.081e-01
],
[
0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 2.378e-04,
0.000e+00, 0.000e+00, 0.000e+00, 2.843e-05, 9.995e-01
],
[
0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00,
0.000e+00, 1.000e+00, 0.000e+00, 0.000e+00, 0.000e+00
],
[
0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00,
0.000e+00, 1.000e+00, 0.000e+00, 2.623e-06, 0.000e+00
],
[
0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00,
7.749e-07, 0.000e+00, 0.000e+00, 1.634e-04, 1.000e+00
],
[
0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00,
0.000e+00, 1.000e+00, 0.000e+00, 0.000e+00, 0.000e+00
],
[
0.000e+00, 1.000e+00, 0.000e+00, 0.000e+00, 0.000e+00,
0.000e+00, 6.557e-07, 0.000e+00, 0.000e+00, 0.000e+00
],
[
0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 1.000e+00,
0.000e+00, 5.960e-08, 0.000e+00, 0.000e+00, 0.000e+00
],
[
0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 9.125e-03,
9.907e-01, 9.418e-06, 0.000e+00, 5.597e-05, 0.000e+00
]]).astype(np.float16)
inputs = 2 * np.random.rand(10, 28, 28, 1)
p = model.predict(inputs).astype(np.float16)
assert np.all(p == y)
