def _testConfMatrixOnTensors(self, tf_dtype, np_dtype):
with self.test_session() as sess:
m_neg = array_ops.placeholder(dtype=dtypes.float32)
m_pos = array_ops.placeholder(dtype=dtypes.float32)
s = array_ops.placeholder(dtype=dtypes.float32)
neg = random_ops.random_normal([20], mean=m_neg, stddev=s, dtype=dtypes.float32)
pos = random_ops.random_normal([20], mean=m_pos, stddev=s, dtype=dtypes.float32)
data = array_ops.concat([neg, pos], 0)
data = math_ops.cast(math_ops.round(data), tf_dtype)
data = math_ops.minimum(math_ops.maximum(data, 0), 1)
lab = array_ops.concat([array_ops.zeros([20], dtype=tf_dtype), array_ops.ones([20], dtype=tf_dtype)], 0)
cm = confusion_matrix.confusion_matrix(lab, data, dtype=tf_dtype, num_classes=2)
d, l, cm_out = sess.run([data, lab, cm], {m_neg: 0.0, m_pos: 1.0, s: 1.0})
truth = np.zeros([2, 2], dtype=np_dtype)
try:
range_builder = xrange
except NameError: # In Python 3.
range_builder = range
for i in range_builder(len(d)):
truth[l[i], d[i]] += 1
self.assertEqual(cm_out.dtype, np_dtype)
self.assertAllClose(cm_out, truth, atol=1e-10)
def update_state(self, y_true, y_pred, sample_weight=None):
"""Accumulates the confusion matrix statistics.
Args:
y_true: The ground truth values.
y_pred: The predicted values.
sample_weight: Optional weighting of each example. Defaults to 1. Can be a
`Tensor` whose rank is either 0, or the same rank as `y_true`, and must
be broadcastable to `y_true`.
Returns:
Update op.
"""
y_true = math_ops.cast(y_true, self._dtype)
y_pred = math_ops.cast(y_pred, self._dtype)
# Flatten the input if its rank > 1.
if y_pred.shape.ndims > 1:
y_pred = array_ops.reshape(y_pred, [-1])
if y_true.shape.ndims > 1:
y_true = array_ops.reshape(y_true, [-1])
if sample_weight is not None:
sample_weight = math_ops.cast(sample_weight, self._dtype)
if sample_weight.shape.ndims > 1:
sample_weight = array_ops.reshape(sample_weight, [-1])
# Accumulate the prediction to current confusion matrix.
current_cm = confusion_matrix.confusion_matrix(
y_true,
y_pred,
self.num_classes,
weights=sample_weight,
dtype=dtypes.float64)
return self.total_cm.assign_add(current_cm)
def _testConfMatrixOnTensors(self, tf_dtype, np_dtype):
with self.cached_session() as sess:
m_neg = array_ops.placeholder(dtype=dtypes.float32)
m_pos = array_ops.placeholder(dtype=dtypes.float32)
s = array_ops.placeholder(dtype=dtypes.float32)
neg = random_ops.random_normal(
[20], mean=m_neg, stddev=s, dtype=dtypes.float32)
pos = random_ops.random_normal(
[20], mean=m_pos, stddev=s, dtype=dtypes.float32)
data = array_ops.concat([neg, pos], 0)
data = math_ops.cast(math_ops.round(data), tf_dtype)
data = math_ops.minimum(math_ops.maximum(data, 0), 1)
lab = array_ops.concat(
[
array_ops.zeros(
[20], dtype=tf_dtype), array_ops.ones(
[20], dtype=tf_dtype)
],
0)
cm = confusion_matrix.confusion_matrix(
lab, data, dtype=tf_dtype, num_classes=2)
d, l, cm_out = sess.run([data, lab, cm], {m_neg: 0.0, m_pos: 1.0, s: 1.0})
truth = np.zeros([2, 2], dtype=np_dtype)
for i in xrange(len(d)):
truth[l[i], d[i]] += 1
self.assertEqual(cm_out.dtype, np_dtype)
self.assertAllClose(cm_out, truth, atol=1e-10)
def streaming_confusion_matrix_with_current_cm(labels,
predictions,
num_classes,
weights=None):
total_cm = metric_variable([num_classes, num_classes],
dtypes.float32,
name='total_confusion_matrix')
# Cast the type to int64 required by confusion_matrix_ops.
predictions = math_ops.to_int64(predictions)
labels = math_ops.to_int64(labels)
num_classes = math_ops.to_int64(num_classes)
# Flatten the input if its rank > 1.
if predictions.get_shape().ndims > 1:
predictions = array_ops.reshape(predictions, [-1])
if labels.get_shape().ndims > 1:
labels = array_ops.reshape(labels, [-1])
if (weights is not None) and (weights.get_shape().ndims > 1):
weights = array_ops.reshape(weights, [-1])
# Accumulate the prediction to current confusion matrix.
current_cm = confusion_matrix.confusion_matrix(labels,
predictions,
num_classes,
weights=weights,
dtype=dtypes.float32)
update_op = state_ops.assign_add(total_cm, current_cm)
return (total_cm, update_op, current_cm)
def testOutputIsInt64(self):
labels = np.arange(2)
predictions = np.arange(2)
with self.test_session():
cm = confusion_matrix.confusion_matrix(labels, predictions, dtype=dtypes.int64)
tf_cm = cm.eval()
self.assertEqual(tf_cm.dtype, np.int64)
def testExample(self):
"""This is a test of the example provided in pydoc."""
with self.test_session():
self.assertAllEqual(
[[0, 0, 0, 0, 0], [0, 0, 1, 0, 0], [0, 0, 1, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 1]],
confusion_matrix.confusion_matrix(labels=[1, 2, 4], predictions=[2, 2, 4]).eval(),
)
def streaming_confusion_matrix(labels,
predictions,
num_classes,
weights=None,
output_dir="./output/results_no_train"):
"""Calculate a streaming confusion matrix.
Calculates a confusion matrix. For estimation over a stream of data,
the function creates an `update_op` operation.
Args:
labels: A `Tensor` of ground truth labels with shape [batch size] and of
type `int32` or `int64`. The tensor will be flattened if its rank > 1.
predictions: A `Tensor` of prediction results for semantic labels, whose
shape is [batch size] and type `int32` or `int64`. The tensor will be
flattened if its rank > 1.
num_classes: The possible number of labels the prediction task can
have. This value must be provided, since a confusion matrix of
dimension = [num_classes, num_classes] will be allocated.
weights: Optional `Tensor` whose rank is either 0, or the same rank as
`labels`, and must be broadcastable to `labels` (i.e., all dimensions must
be either `1`, or the same as the corresponding `labels` dimension).
Returns:
total_cm: A `Tensor` representing the confusion matrix.
update_op: An operation that increments the confusion matrix.
"""
# Local variable to accumulate the predictions in the confusion matrix.
total_cm = metric_variable([num_classes, num_classes],
dtypes.float64,
name='total_confusion_matrix')
# Cast the type to int64 required by confusion_matrix_ops.
predictions = math_ops.to_int64(predictions)
labels = math_ops.to_int64(labels)
num_classes = math_ops.to_int64(num_classes)
debug_file = os.path.join(output_dir, "debugging.txt")
with open(debug_file, "a+") as wf:
wf.write("\n\n***** Debugging *****\n\n")
wf.write("Predictions: {} \n".format(predictions))
wf.write("Labels: {} \n".format(labels))
wf.write("Num of Classes: {} \n".format(num_classes))
# Flatten the input if its rank > 1.
if predictions.get_shape().ndims > 1:
predictions = array_ops.reshape(predictions, [-1])
if labels.get_shape().ndims > 1:
labels = array_ops.reshape(labels, [-1])
if (weights is not None) and (weights.get_shape().ndims > 1):
weights = array_ops.reshape(weights, [-1])
# Accumulate the prediction to current confusion matrix.
current_cm = confusion_matrix.confusion_matrix(labels,
predictions,
num_classes,
weights=weights,
dtype=dtypes.float64)
update_op = state_ops.assign_add(total_cm, current_cm)
return (total_cm, update_op)
def calculate_confusion_matrix(self, x_test, y_test):
"""Calculate the probabilities required for the confusion matrix and create a dataframe"""
y_pred = self.model.predict_classes(x_test)
y_test = argmax(y_test, axis=1)
con_mat = confusion_matrix(labels=y_test, predictions=y_pred).numpy()
con_mat_norm = np.around(con_mat.astype('float') / con_mat.sum(axis=1)[:, np.newaxis], decimals=2)
classes = self.le.inverse_transform(list(range(0, self.le.encoded_labels.shape[1])))
return pd.DataFrame(con_mat_norm, index=classes, columns=classes)
def _testConfMatrix(self, predictions, labels, truth, weights=None):
with self.test_session():
dtype = predictions.dtype
ans = confusion_matrix.confusion_matrix(
labels, predictions, dtype=dtype, weights=weights)
tf_ans = ans.eval()
self.assertAllClose(tf_ans, truth, atol=1e-10)
self.assertEqual(tf_ans.dtype, dtype)
def testOutputIsInt32(self):
labels = np.arange(2)
predictions = np.arange(2)
with self.cached_session():
cm = confusion_matrix.confusion_matrix(
labels, predictions, dtype=dtypes.int32)
tf_cm = self.evaluate(cm)
self.assertEqual(tf_cm.dtype, np.int32)
def testOutputIsInt32(self):
labels = np.arange(2)
predictions = np.arange(2)
with self.test_session():
cm = confusion_matrix.confusion_matrix(
labels, predictions, dtype=dtypes.int32)
tf_cm = cm.eval()
self.assertEqual(tf_cm.dtype, np.int32)
def testOutputIsInt64(self):
labels = np.arange(2)
predictions = np.arange(2)
with self.cached_session():
cm = confusion_matrix.confusion_matrix(
labels, predictions, dtype=dtypes.int64)
tf_cm = self.evaluate(cm)
self.assertEqual(tf_cm.dtype, np.int64)
def calculate_confusion_matrix(model, le, x_test, y_test):
y_pred = model.predict_classes(x_test)
y_test = argmax(y_test, axis=1)
con_mat = confusion_matrix(labels=y_test, predictions=y_pred).numpy()
con_mat_norm = np.around(con_mat.astype('float') /
con_mat.sum(axis=1)[:, np.newaxis],
decimals=2)
classes = le.inverse_transform([0, 1, 2, 3, 4])
return pd.DataFrame(con_mat_norm, index=classes, columns=classes)
def _testConfMatrix(self, labels, predictions, truth, weights=None,
num_classes=None):
with self.cached_session():
dtype = predictions.dtype
ans = confusion_matrix.confusion_matrix(
labels, predictions, dtype=dtype, weights=weights,
num_classes=num_classes).eval()
self.assertAllClose(truth, ans, atol=1e-10)
self.assertEqual(ans.dtype, dtype)
def _testConfMatrix(self, labels, predictions, truth, weights=None,
num_classes=None):
with self.cached_session():
dtype = predictions.dtype
ans = confusion_matrix.confusion_matrix(
labels, predictions, dtype=dtype, weights=weights,
num_classes=num_classes).eval()
self.assertAllClose(truth, ans, atol=1e-10)
self.assertEqual(ans.dtype, dtype)
def testExample(self):
"""This is a test of the example provided in pydoc."""
with self.cached_session():
self.assertAllEqual(
[[0, 0, 0, 0, 0], [0, 0, 1, 0, 0], [0, 0, 1, 0, 0],
[0, 0, 0, 0, 0], [0, 0, 0, 0, 1]],
self.evaluate(
confusion_matrix.confusion_matrix(labels=[1, 2, 4],
predictions=[2, 2, 4])))
def _testConfMatrix(self, predictions, labels, truth, weights=None):
with self.test_session():
dtype = predictions.dtype
ans = confusion_matrix.confusion_matrix(labels,
predictions,
dtype=dtype,
weights=weights)
tf_ans = ans.eval()
self.assertAllClose(tf_ans, truth, atol=1e-10)
self.assertEqual(tf_ans.dtype, dtype)
def cal_loss(self):
one_hot_annotations = tf.one_hot(self.annotations,
depth=self.conf.class_num,
axis=self.channel_axis,
name='annotations/one_hot')
losses = tf.losses.softmax_cross_entropy(one_hot_annotations,
self.predictions,
scope='loss/losses')
self.loss_op = tf.reduce_mean(losses, name='loss/loss_op')
self.decoded_predictions = tf.argmax(self.predictions,
self.channel_axis,
name='accuracy/decode_pred')
correct_prediction = tf.equal(self.annotations,
self.decoded_predictions,
name='accuracy/correct_pred')
self.accuracy_op = tf.reduce_mean(tf.cast(correct_prediction,
tf.float32,
name='accuracy/cast'),
name='accuracy/accuracy_op')
weights = tf.cast(tf.greater(self.decoded_predictions,
0,
name='m_iou/greater'),
tf.int32,
name='m_iou/weights')
self.m_iou, self.miou_op = tf.metrics.mean_iou(
self.annotations,
self.decoded_predictions,
self.conf.class_num,
weights,
name='m_iou/m_ious')
# Flatten the input if its rank > 1.
predictions = self.decoded_predictions
if predictions.get_shape().ndims > 1:
predictions = array_ops.reshape(predictions, [-1])
labels = self.annotations
if labels.get_shape().ndims > 1:
labels = array_ops.reshape(labels, [-1])
weights_conf = weights
if (weights_conf is not None) and (weights_conf.get_shape().ndims > 1):
weights_conf = array_ops.reshape(weights_conf, [-1])
# Cast the type to int64 required by confusion_matrix_ops.
predictions = math_ops.to_int64(predictions)
labels = math_ops.to_int64(labels)
self.confusion_matrix = confusion_matrix.confusion_matrix(
labels,
predictions,
self.conf.class_num,
weights=weights_conf,
dtype=tf.int32,
name='confu_matrix/confu_matrix_op')
def streaming_confusion_matrix_single_label(self,
labels,
logits,
num_label_classes,
weights=None):
"""Calculate a streaming confusion matrix.
Calculates a confusion matrix. For estimation over a stream of data,
the function creates an `update_op` operation.
Args:
labels: A `Tensor` of ground truth labels with shape [batch size] and of
type `int32` or `int64`. The tensor will be flattened if its rank > 1.
logits: A `Tensor` of prediction results for semantic labels, whose
shape is [batch size] and type `int32` or `int64`. The tensor will be
flattened if its rank > 1.
num_label_classes: The possible number of labels the prediction task can
have. This value must be provided, since a confusion matrix of
dimension = [num_label_classes, num_label_classes] will be allocated.
weights: Optional `Tensor` whose rank is either 0, or the same rank as
`labels`, and must be broadcastable to `labels` (i.e., all dimensions must
be either `1`, or the same as the corresponding `labels` dimension).
Returns:
total_cm: A `Tensor` representing the confusion matrix.
update_op: An operation that increments the confusion matrix.
"""
# Local variable to accumulate the logits in the confusion matrix.
total_cm = _create_local('total_confusion_matrix',
shape=[num_label_classes, num_label_classes],
dtype=dtypes.float64)
# Cast the type to int64 required by confusion_matrix_ops.
logits = math_ops.to_int64(logits)
labels = math_ops.to_int64(labels)
num_label_classes = math_ops.to_int64(num_label_classes)
# Flatten the input if its rank > 1.
if logits.get_shape().ndims > 1:
logits = array_ops.reshape(logits, [-1])
if labels.get_shape().ndims > 1:
labels = array_ops.reshape(labels, [-1])
if (weights is not None) and (weights.get_shape().ndims > 1):
weights = array_ops.reshape(weights, [-1])
# Accumulate the prediction to current confusion matrix.
current_cm = confusion_matrix.confusion_matrix(labels,
logits,
num_label_classes,
weights=weights,
dtype=dtypes.float64)
update_op = state_ops.assign_add(total_cm, current_cm)
return total_cm, update_op
def _streaming_confusion_matrix(labels, predictions, num_classes, weights=None,
metrics_collections=None,
updates_collections=None,
name=None):
"""Calculate a streaming confusion matrix.
Calculates a confusion matrix. For estimation over a stream of data,
the function creates an `update_op` operation.
Args:
labels: A `Tensor` of ground truth labels with shape [batch size] and of
type `int32` or `int64`. The tensor will be flattened if its rank > 1.
predictions: A `Tensor` of prediction results for semantic labels, whose
shape is [batch size] and type `int32` or `int64`. The tensor will be
flattened if its rank > 1.
num_classes: The possible number of labels the prediction task can
have. This value must be provided, since a confusion matrix of
dimension = [num_classes, num_classes] will be allocated.
weights: Optional `Tensor` whose rank is either 0, or the same rank as
`labels`, and must be broadcastable to `labels` (i.e., all dimensions must
be either `1`, or the same as the corresponding `labels` dimension).
Returns:
total_cm: A `Tensor` representing the confusion matrix.
update_op: An operation that increments the confusion matrix.
"""
# Local variable to accumulate the predictions in the confusion matrix.
with tf.variable_scope(name, 'confusion_matrix'):
total_cm = metric_variable(
[num_classes, num_classes], tf.float64, name='total_confusion_matrix')
# Cast the type to int64 required by confusion_matrix_ops.
predictions = tf.to_int64(predictions)
labels = tf.to_int64(labels)
num_classes = tf.to_int64(num_classes)
# Flatten the input if its rank > 1.
if predictions.get_shape().ndims > 1:
predictions = tf.reshape(predictions, [-1])
if labels.get_shape().ndims > 1:
labels = tf.reshape(labels, [-1])
if (weights is not None) and (weights.get_shape().ndims > 1):
weights = tf.reshape(weights, [-1])
# Accumulate the prediction to current confusion matrix.
current_cm = confusion_matrix.confusion_matrix(
labels, predictions, num_classes, weights=weights, dtype=tf.float64)
update_op = tf.assign_add(total_cm, current_cm)
if metrics_collections:
tf.add_to_collection(metrics_collections, total_cm)
if updates_collections:
tf.add_to_collection(updates_collections, update_op)
return total_cm, update_op
def compute_m_iou_accu(labels,
predictions,
num_classes,
weights=None,
name=None):
"""Calculate per-step mean Intersection-Over-Union (mIOU).
"""
# Check if shape is compatible.
predictions.get_shape().assert_is_compatible_with(labels.get_shape())
predictions = math_ops.to_int64(predictions)
labels = math_ops.to_int64(labels)
num_classes = math_ops.to_int64(num_classes)
current_cm = confusion_matrix.confusion_matrix(labels,
predictions,
num_classes,
weights=weights,
dtype=dtypes.float64)
sum_over_row = math_ops.to_float(math_ops.reduce_sum(current_cm, 0))
sum_over_col = math_ops.to_float(math_ops.reduce_sum(current_cm, 1))
cm_diag = math_ops.to_float(array_ops.diag_part(current_cm))
denominator = sum_over_row + sum_over_col - cm_diag
# The mean is only computed over classes that appear in the
# label or prediction tensor. If the denominator is 0, we need to
# ignore the class.
num_valid_entries = math_ops.reduce_sum(
math_ops.cast(math_ops.not_equal(denominator, 0),
dtype=dtypes.float32))
# If the value of the denominator is 0, set it to 1 to avoid
# zero division.
denominator = array_ops.where(math_ops.greater(denominator,
0), denominator,
array_ops.ones_like(denominator))
iou = math_ops.div(cm_diag, denominator)
# If the number of valid entries is 0 (no classes) we return 0.
m_iou = array_ops.where(math_ops.greater(num_valid_entries, 0),
math_ops.reduce_sum(iou) / num_valid_entries, 0)
class_count = array_ops.where(math_ops.greater(sum_over_col, 0),
sum_over_col,
array_ops.ones_like(sum_over_col))
accu_per_class = math_ops.div(cm_diag, class_count)
m_accu = array_ops.where(
math_ops.greater(num_valid_entries, 0),
math_ops.reduce_sum(accu_per_class) / num_valid_entries, 0)
return m_iou, m_accu
def confusion_matrix(labels,
predictions,
num_classes=None,
dtype=dtypes.int32,
name=None,
weights=None):
"""Deprecated. Use tf.math.confusion_matrix instead."""
return cm.confusion_matrix(labels=labels,
predictions=predictions,
num_classes=num_classes,
dtype=dtype,
name=name,
weights=weights)
def update_state(self, labels, predicts, weights=None):
predicts = engine.int64(predicts)
labels = engine.int64(labels)
if labels.get_shape().ndims > 1:
labels = array_ops.reshape(labels, [-1])
if predicts.get_shape().ndims > 1:
predicts = array_ops.reshape(predicts, [-1])
if weights is not None and weights.get_shape().ndims > 1:
weights = array_ops.reshape(weights, [-1])
add_value = confusion_matrix(labels,
predicts,
num_classes=self.num_classes,
weights=weights,
dtype=dtypes.float64)
with fops.control_dependencies([self.total_value]):
self.update_ops.append(
state_ops.assign_add(self.total_value, add_value))
sum_alone_row = engine.float32(math_ops.reduce_sum(
self.total_value, 0))
sum_alone_col = engine.float32(math_ops.reduce_sum(
self.total_value, 1))
diag = engine.float32(array_ops.diag_part(self.total_value))
denominator = sum_alone_row + sum_alone_col - diag
valid_entries = math_ops.reduce_sum(
engine.float32(math_ops.not_equal(denominator, 0)))
denominator = array_ops.where(math_ops.greater(denominator, 0),
denominator,
array_ops.ones_like(denominator))
iou = math_ops.div(diag, denominator)
self._mean_iou = array_ops.where(math_ops.greater(valid_entries, 0),
math_ops.reduce_sum(iou) /
valid_entries,
0,
name='mean_iou')
self._classes_iou = array_ops.where(math_ops.not_equal(denominator, 0),
iou,
array_ops.zeros_like(denominator),
name='classes_iou')
def update_state(self, y_true, y_pred, sample_weight=None):
"""Accumulated the confusion matrix statistics with one hot truth and prediction data.
Parameters
----------
y_true: Tensor or numpy array.
One hot ground truth vectors.
y_pred: Tensor or numpy array.
One hot predicted vectors.
sample_weight: Tensor.
Optional weighting of each example. Defaults to 1. Can be a
`Tensor` whose rank is either 0, or the same rank as `y_true`, and must
be broadcastable to `y_true`.
Returns
-------
Update operator.
Operator
"""
# Convert one hot vectors and labels.
y_pred = K.argmax(y_pred)
y_true = math_ops.cast(y_true, self._dtype)
y_pred = math_ops.cast(y_pred, self._dtype)
# Flatten the input if its rank > 1.
if y_pred.shape.ndims > 1:
y_pred = array_ops.reshape(y_pred, [-1])
if y_true.shape.ndims > 1:
y_true = array_ops.reshape(y_true, [-1])
if sample_weight is not None and sample_weight.shape.ndims > 1:
sample_weight = array_ops.reshape(sample_weight, [-1])
# Accumulate the prediction to current confusion matrix.
current_cm = confusion_matrix.confusion_matrix(y_true,
y_pred,
self.num_classes,
weights=sample_weight,
dtype=dtypes.float64)
return self.total_cm.assign_add(current_cm) if self.accum_enable \
else self.total_cm.assign(current_cm)
def meanIOU(true_mask, pred_mask):
pred_mask = tf.argmax(pred_mask, axis=-1)
pred_mask = tf.reshape(tf.squeeze(pred_mask), [-1])
true_mask = tf.reshape(tf.squeeze(true_mask), [-1])
confusion_mat = confusion_matrix.confusion_matrix(true_mask,
pred_mask,
14,
weights=None)
sum_row = tf.reduce_sum(confusion_mat, 0)
sum_col = tf.reduce_sum(confusion_mat, 1)
true_pos = tf.matrix_diag_part(confusion_mat)
denominator = tf.cast(sum_row + sum_col - true_pos, tf.float32)
num_valid_entries = tf.reduce_sum(
tf.cast(tf.math.not_equal(denominator, 0), 'float32'))
iou = tf.math.divide_no_nan(tf.cast(true_pos, tf.float32), denominator)
mIOU = tf.math.divide_no_nan(tf.reduce_sum(iou, name='mean_iou'),
num_valid_entries)
return mIOU
def train(self, hands, poses, show_training_images=False):
x = {'train': [], 'val': [], 'test': []}
y = {'train': [], 'val': [], 'test': []}
enc = OneHotEncoder(handle_unknown='ignore', sparse=False)
if self.gesture_image_files is None:
self.gesture_image_files = self.scan_image_files()
for hand in hands:
for pose in poses:
for t in ['train', 'val', 'test']:
for file in self.gesture_image_files[hand][pose][
f'{t}_filenames']:
img = keras.preprocessing.image.load_img(
file, color_mode='rgb')
img_array = keras.preprocessing.image.img_to_array(img)
img_array = keras.preprocessing.image.smart_resize(
img_array, (40, 40), interpolation='bilinear')
x[t].append(img_array)
y[t].append('{}_{}'.format(hand, pose))
train_datagen = ImageDataGenerator(
#preprocessing_function=keras.applications.vgg16.preprocess_input,
width_shift_range=0.1,
height_shift_range=0.1,
fill_mode='nearest',
rescale=1. / 255)
val_datagen = ImageDataGenerator(
#preprocessing_function=keras.applications.vgg16.preprocess_input,
width_shift_range=0.1,
height_shift_range=0.1,
fill_mode='nearest',
rescale=1. / 255)
test_datagen = ImageDataGenerator(
#preprocessing_function=keras.applications.vgg16.preprocess_input,
rescale=1. / 255)
for t in ['train', 'val', 'test']:
x[t] = np.array(x[t])
y[t] = np.array(y[t]).reshape(-1, 1)
y[t] = enc.fit_transform(y[t]) # Encode Y using OneHot
train_datagen.fit(x['train'], augment=True)
val_datagen.fit(x['val'], augment=True)
test_datagen.fit(x['test'])
if show_training_images:
for x_batch, y_batch in train_datagen.flow(x['train'],
y['train'],
batch_size=100):
for i in range(0, len(x_batch)):
subplot = pyplot.subplot(10, 10, i + 1)
subplot.set_title(
enc.inverse_transform(y_batch[i].reshape(1, -1))[0][0])
pyplot.imshow(x_batch[i])
pyplot.subplots_adjust(left=0,
right=1.0,
bottom=0.025,
top=0.975,
wspace=0.155,
hspace=0.470)
pyplot.get_current_fig_manager().window.showMaximized()
pyplot.show()
break
print('About to train with {} training images'.format(len(x['train'])))
learning_rate = 0.001
epocs = 90
batch_size = 14
model_name = 'hand-pose-right-{}-{}.h5'.format(datetime.date.today(),
epocs)
train_gen = train_datagen.flow(x['train'],
y['train'],
batch_size=batch_size,
shuffle=True)
val_gen = val_datagen.flow(x['val'],
y['val'],
batch_size=batch_size,
shuffle=True)
test_gen = test_datagen.flow(x['test'],
y['test'],
batch_size=batch_size)
model = Sequential()
model.add(
Conv2D(filters=32,
kernel_size=(3, 3),
activation='relu',
input_shape=x['train'][0].shape))
model.add(Conv2D(filters=64, kernel_size=(3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(rate=0.25))
model.add(Flatten())
model.add(Dense(units=128, activation='relu'))
model.add(Dropout(rate=0.5))
model.add(Dense(units=len(enc.categories_[0]), activation='softmax'))
model.compile(
loss=keras.losses.categorical_crossentropy,
optimizer=keras.optimizers.Adam(learning_rate=learning_rate),
metrics=['accuracy'])
print("Training on {} training images, {} validation images model {}".
format(train_gen.n, val_gen.n, model_name))
model.fit(train_gen,
epochs=epocs,
steps_per_epoch=train_gen.n // train_gen.batch_size,
validation_data=val_gen,
verbose=2)
# Save the model and the one-hot encoding so we can decode later
model.save(model_name)
np.save(f'{model_name}', enc.categories_[0])
predictions = model.predict(x=test_gen.x, verbose=2)
y_pred = np.argmax(predictions, axis=1)
cm_labels = np.argmax(test_gen.y, axis=1)
cm = confusion_matrix(labels=cm_labels, predictions=y_pred).numpy()
cm_norm = np.around(cm.astype('float') / cm.sum(axis=1)[:, np.newaxis],
decimals=2)
cm_df = pd.DataFrame(cm_norm,
index=enc.categories_[0],
columns=enc.categories_[0])
figure = plt.figure(figsize=(8, 8))
sns.heatmap(cm_df, annot=True, cmap=plt.cm.Blues)
plt.tight_layout()
plt.ylabel('True label')
plt.xlabel('Predicted label')
plt.show()
model.fit(X_train_array,
y_train_array,
validation_data=(X_test_array, y_test_array),
epochs=5,
batch_size=64)
model.save("myModel.h5")
predications = model.predict(X_test_array)
predications = predications >= 0.5
model.summary()
scores = model.evaluate(X_test_array, y_test_array, verbose=0)
print("Accuracy: %.2f%%" % (scores[1] * 100))
print("Accuracy:", metrics.accuracy_score(y_test_array, predications))
y_pred2 = model.predict_classes(X_test_array)
print(confusion_matrix(y_test_array, y_pred2))
# emb_model.fit(x=X_train_seq_trunc, y=y_train, batch_size=128, epochs=10, validation_data=(X_test_seq_trunc, y_test))
doc = ["COVID does not exist"]
tk.fit_on_texts(doc)
test_text = tk.texts_to_sequences(doc)
print(test_text)
test_seq = pad_sequences(test_text, maxlen=100)
predications = model.predict(test_seq)
print(test_seq)
print(predications)
# print(predications)
predications = (predications < 0.5)
print(predications)
def confusion_matrix(labels, predictions, num_classes=None, dtype=dtypes.int32,
name=None, weights=None):
"""Deprecated. Use tf.confusion_matrix instead."""
return cm.confusion_matrix(labels=labels, predictions=predictions,
num_classes=num_classes, dtype=dtype, name=name,
weights=weights)
