Python layers.accuracy() Examples
The following are 30
code examples of layers.accuracy().
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example.
You may also want to check out all available functions/classes of the module
layers
, or try the search function
.
Example #1
Source File: graphs.py From models with Apache License 2.0 | 5 votes |
def classifier_graph(self): """Constructs classifier graph from inputs to classifier loss. * Caches the VatxtInput object in `self.cl_inputs` * Caches tensors: `cl_embedded`, `cl_logits`, `cl_loss` Returns: loss: scalar float. """ inputs = _inputs('train', pretrain=False) self.cl_inputs = inputs embedded = self.layers['embedding'](inputs.tokens) self.tensors['cl_embedded'] = embedded _, next_state, logits, loss = self.cl_loss_from_embedding( embedded, return_intermediates=True) tf.summary.scalar('classification_loss', loss) self.tensors['cl_logits'] = logits self.tensors['cl_loss'] = loss if FLAGS.single_label: indices = tf.stack([tf.range(FLAGS.batch_size), inputs.length - 1], 1) labels = tf.expand_dims(tf.gather_nd(inputs.labels, indices), 1) weights = tf.expand_dims(tf.gather_nd(inputs.weights, indices), 1) else: labels = inputs.labels weights = inputs.weights acc = layers_lib.accuracy(logits, labels, weights) tf.summary.scalar('accuracy', acc) adv_loss = (self.adversarial_loss() * tf.constant( FLAGS.adv_reg_coeff, name='adv_reg_coeff')) tf.summary.scalar('adversarial_loss', adv_loss) total_loss = loss + adv_loss with tf.control_dependencies([inputs.save_state(next_state)]): total_loss = tf.identity(total_loss) tf.summary.scalar('total_classification_loss', total_loss) return total_loss
Example #2
Source File: graphs.py From object_detection_kitti with Apache License 2.0 | 5 votes |
def eval_graph(self, dataset='test'): """Constructs classifier evaluation graph. Args: dataset: the labeled dataset to evaluate, {'train', 'test', 'valid'}. Returns: eval_ops: dict<metric name, tuple(value, update_op)> var_restore_dict: dict mapping variable restoration names to variables. Trainable variables will be mapped to their moving average names. """ inputs = _inputs(dataset, pretrain=False, bidir=True) embedded = [self.layers['embedding'](inp.tokens) for inp in inputs] _, next_states, logits, _ = self.cl_loss_from_embedding( embedded, inputs=inputs, return_intermediates=True) f_inputs, _ = inputs eval_ops = { 'accuracy': tf.contrib.metrics.streaming_accuracy( layers_lib.predictions(logits), f_inputs.labels, f_inputs.weights) } # Save states on accuracy update saves = [inp.save_state(state) for (inp, state) in zip(inputs, next_states)] with tf.control_dependencies(saves): acc, acc_update = eval_ops['accuracy'] acc_update = tf.identity(acc_update) eval_ops['accuracy'] = (acc, acc_update) var_restore_dict = make_restore_average_vars_dict() return eval_ops, var_restore_dict
Example #3
Source File: graphs.py From object_detection_with_tensorflow with MIT License | 5 votes |
def classifier_graph(self): """Constructs classifier graph from inputs to classifier loss. * Caches the VatxtInput object in `self.cl_inputs` * Caches tensors: `cl_embedded`, `cl_logits`, `cl_loss` Returns: loss: scalar float. """ inputs = _inputs('train', pretrain=False) self.cl_inputs = inputs embedded = self.layers['embedding'](inputs.tokens) self.tensors['cl_embedded'] = embedded _, next_state, logits, loss = self.cl_loss_from_embedding( embedded, return_intermediates=True) tf.summary.scalar('classification_loss', loss) self.tensors['cl_logits'] = logits self.tensors['cl_loss'] = loss acc = layers_lib.accuracy(logits, inputs.labels, inputs.weights) tf.summary.scalar('accuracy', acc) adv_loss = (self.adversarial_loss() * tf.constant( FLAGS.adv_reg_coeff, name='adv_reg_coeff')) tf.summary.scalar('adversarial_loss', adv_loss) total_loss = loss + adv_loss tf.summary.scalar('total_classification_loss', total_loss) with tf.control_dependencies([inputs.save_state(next_state)]): total_loss = tf.identity(total_loss) return total_loss
Example #4
Source File: graphs.py From object_detection_with_tensorflow with MIT License | 5 votes |
def eval_graph(self, dataset='test'): """Constructs classifier evaluation graph. Args: dataset: the labeled dataset to evaluate, {'train', 'test', 'valid'}. Returns: eval_ops: dict<metric name, tuple(value, update_op)> var_restore_dict: dict mapping variable restoration names to variables. Trainable variables will be mapped to their moving average names. """ inputs = _inputs(dataset, pretrain=False) embedded = self.layers['embedding'](inputs.tokens) _, next_state, logits, _ = self.cl_loss_from_embedding( embedded, inputs=inputs, return_intermediates=True) eval_ops = { 'accuracy': tf.contrib.metrics.streaming_accuracy( layers_lib.predictions(logits), inputs.labels, inputs.weights) } with tf.control_dependencies([inputs.save_state(next_state)]): acc, acc_update = eval_ops['accuracy'] acc_update = tf.identity(acc_update) eval_ops['accuracy'] = (acc, acc_update) var_restore_dict = make_restore_average_vars_dict() return eval_ops, var_restore_dict
Example #5
Source File: graphs.py From object_detection_with_tensorflow with MIT License | 5 votes |
def classifier_graph(self): """Constructs classifier graph from inputs to classifier loss. * Caches the VatxtInput objects in `self.cl_inputs` * Caches tensors: `cl_embedded` (tuple of forward and reverse), `cl_logits`, `cl_loss` Returns: loss: scalar float. """ inputs = _inputs('train', pretrain=False, bidir=True) self.cl_inputs = inputs f_inputs, _ = inputs # Embed both forward and reverse with a shared embedding embedded = [self.layers['embedding'](inp.tokens) for inp in inputs] self.tensors['cl_embedded'] = embedded _, next_states, logits, loss = self.cl_loss_from_embedding( embedded, return_intermediates=True) tf.summary.scalar('classification_loss', loss) self.tensors['cl_logits'] = logits self.tensors['cl_loss'] = loss acc = layers_lib.accuracy(logits, f_inputs.labels, f_inputs.weights) tf.summary.scalar('accuracy', acc) adv_loss = (self.adversarial_loss() * tf.constant( FLAGS.adv_reg_coeff, name='adv_reg_coeff')) tf.summary.scalar('adversarial_loss', adv_loss) total_loss = loss + adv_loss tf.summary.scalar('total_classification_loss', total_loss) saves = [inp.save_state(state) for (inp, state) in zip(inputs, next_states)] with tf.control_dependencies(saves): total_loss = tf.identity(total_loss) return total_loss
Example #6
Source File: graphs.py From object_detection_with_tensorflow with MIT License | 5 votes |
def eval_graph(self, dataset='test'): """Constructs classifier evaluation graph. Args: dataset: the labeled dataset to evaluate, {'train', 'test', 'valid'}. Returns: eval_ops: dict<metric name, tuple(value, update_op)> var_restore_dict: dict mapping variable restoration names to variables. Trainable variables will be mapped to their moving average names. """ inputs = _inputs(dataset, pretrain=False, bidir=True) embedded = [self.layers['embedding'](inp.tokens) for inp in inputs] _, next_states, logits, _ = self.cl_loss_from_embedding( embedded, inputs=inputs, return_intermediates=True) f_inputs, _ = inputs eval_ops = { 'accuracy': tf.contrib.metrics.streaming_accuracy( layers_lib.predictions(logits), f_inputs.labels, f_inputs.weights) } # Save states on accuracy update saves = [inp.save_state(state) for (inp, state) in zip(inputs, next_states)] with tf.control_dependencies(saves): acc, acc_update = eval_ops['accuracy'] acc_update = tf.identity(acc_update) eval_ops['accuracy'] = (acc, acc_update) var_restore_dict = make_restore_average_vars_dict() return eval_ops, var_restore_dict
Example #7
Source File: graphs.py From g-tensorflow-models with Apache License 2.0 | 5 votes |
def classifier_graph(self): """Constructs classifier graph from inputs to classifier loss. * Caches the VatxtInput object in `self.cl_inputs` * Caches tensors: `cl_embedded`, `cl_logits`, `cl_loss` Returns: loss: scalar float. """ inputs = _inputs('train', pretrain=False) self.cl_inputs = inputs embedded = self.layers['embedding'](inputs.tokens) self.tensors['cl_embedded'] = embedded _, next_state, logits, loss = self.cl_loss_from_embedding( embedded, return_intermediates=True) tf.summary.scalar('classification_loss', loss) self.tensors['cl_logits'] = logits self.tensors['cl_loss'] = loss if FLAGS.single_label: indices = tf.stack([tf.range(FLAGS.batch_size), inputs.length - 1], 1) labels = tf.expand_dims(tf.gather_nd(inputs.labels, indices), 1) weights = tf.expand_dims(tf.gather_nd(inputs.weights, indices), 1) else: labels = inputs.labels weights = inputs.weights acc = layers_lib.accuracy(logits, labels, weights) tf.summary.scalar('accuracy', acc) adv_loss = (self.adversarial_loss() * tf.constant( FLAGS.adv_reg_coeff, name='adv_reg_coeff')) tf.summary.scalar('adversarial_loss', adv_loss) total_loss = loss + adv_loss with tf.control_dependencies([inputs.save_state(next_state)]): total_loss = tf.identity(total_loss) tf.summary.scalar('total_classification_loss', total_loss) return total_loss
Example #8
Source File: graphs.py From g-tensorflow-models with Apache License 2.0 | 5 votes |
def eval_graph(self, dataset='test'): """Constructs classifier evaluation graph. Args: dataset: the labeled dataset to evaluate, {'train', 'test', 'valid'}. Returns: eval_ops: dict<metric name, tuple(value, update_op)> var_restore_dict: dict mapping variable restoration names to variables. Trainable variables will be mapped to their moving average names. """ inputs = _inputs(dataset, pretrain=False) embedded = self.layers['embedding'](inputs.tokens) _, next_state, logits, _ = self.cl_loss_from_embedding( embedded, inputs=inputs, return_intermediates=True) if FLAGS.single_label: indices = tf.stack([tf.range(FLAGS.batch_size), inputs.length - 1], 1) labels = tf.expand_dims(tf.gather_nd(inputs.labels, indices), 1) weights = tf.expand_dims(tf.gather_nd(inputs.weights, indices), 1) else: labels = inputs.labels weights = inputs.weights eval_ops = { 'accuracy': tf.contrib.metrics.streaming_accuracy( layers_lib.predictions(logits), labels, weights) } with tf.control_dependencies([inputs.save_state(next_state)]): acc, acc_update = eval_ops['accuracy'] acc_update = tf.identity(acc_update) eval_ops['accuracy'] = (acc, acc_update) var_restore_dict = make_restore_average_vars_dict() return eval_ops, var_restore_dict
Example #9
Source File: graphs.py From g-tensorflow-models with Apache License 2.0 | 5 votes |
def classifier_graph(self): """Constructs classifier graph from inputs to classifier loss. * Caches the VatxtInput objects in `self.cl_inputs` * Caches tensors: `cl_embedded` (tuple of forward and reverse), `cl_logits`, `cl_loss` Returns: loss: scalar float. """ inputs = _inputs('train', pretrain=False, bidir=True) self.cl_inputs = inputs f_inputs, _ = inputs # Embed both forward and reverse with a shared embedding embedded = [self.layers['embedding'](inp.tokens) for inp in inputs] self.tensors['cl_embedded'] = embedded _, next_states, logits, loss = self.cl_loss_from_embedding( embedded, return_intermediates=True) tf.summary.scalar('classification_loss', loss) self.tensors['cl_logits'] = logits self.tensors['cl_loss'] = loss acc = layers_lib.accuracy(logits, f_inputs.labels, f_inputs.weights) tf.summary.scalar('accuracy', acc) adv_loss = (self.adversarial_loss() * tf.constant( FLAGS.adv_reg_coeff, name='adv_reg_coeff')) tf.summary.scalar('adversarial_loss', adv_loss) total_loss = loss + adv_loss saves = [inp.save_state(state) for (inp, state) in zip(inputs, next_states)] with tf.control_dependencies(saves): total_loss = tf.identity(total_loss) tf.summary.scalar('total_classification_loss', total_loss) return total_loss
Example #10
Source File: graphs.py From g-tensorflow-models with Apache License 2.0 | 5 votes |
def eval_graph(self, dataset='test'): """Constructs classifier evaluation graph. Args: dataset: the labeled dataset to evaluate, {'train', 'test', 'valid'}. Returns: eval_ops: dict<metric name, tuple(value, update_op)> var_restore_dict: dict mapping variable restoration names to variables. Trainable variables will be mapped to their moving average names. """ inputs = _inputs(dataset, pretrain=False, bidir=True) embedded = [self.layers['embedding'](inp.tokens) for inp in inputs] _, next_states, logits, _ = self.cl_loss_from_embedding( embedded, inputs=inputs, return_intermediates=True) f_inputs, _ = inputs eval_ops = { 'accuracy': tf.contrib.metrics.streaming_accuracy( layers_lib.predictions(logits), f_inputs.labels, f_inputs.weights) } # Save states on accuracy update saves = [inp.save_state(state) for (inp, state) in zip(inputs, next_states)] with tf.control_dependencies(saves): acc, acc_update = eval_ops['accuracy'] acc_update = tf.identity(acc_update) eval_ops['accuracy'] = (acc, acc_update) var_restore_dict = make_restore_average_vars_dict() return eval_ops, var_restore_dict
Example #11
Source File: graphs.py From object_detection_kitti with Apache License 2.0 | 5 votes |
def classifier_graph(self): """Constructs classifier graph from inputs to classifier loss. * Caches the VatxtInput objects in `self.cl_inputs` * Caches tensors: `cl_embedded` (tuple of forward and reverse), `cl_logits`, `cl_loss` Returns: loss: scalar float. """ inputs = _inputs('train', pretrain=False, bidir=True) self.cl_inputs = inputs f_inputs, _ = inputs # Embed both forward and reverse with a shared embedding embedded = [self.layers['embedding'](inp.tokens) for inp in inputs] self.tensors['cl_embedded'] = embedded _, next_states, logits, loss = self.cl_loss_from_embedding( embedded, return_intermediates=True) tf.summary.scalar('classification_loss', loss) self.tensors['cl_logits'] = logits self.tensors['cl_loss'] = loss acc = layers_lib.accuracy(logits, f_inputs.labels, f_inputs.weights) tf.summary.scalar('accuracy', acc) adv_loss = (self.adversarial_loss() * tf.constant( FLAGS.adv_reg_coeff, name='adv_reg_coeff')) tf.summary.scalar('adversarial_loss', adv_loss) total_loss = loss + adv_loss tf.summary.scalar('total_classification_loss', total_loss) saves = [inp.save_state(state) for (inp, state) in zip(inputs, next_states)] with tf.control_dependencies(saves): total_loss = tf.identity(total_loss) return total_loss
Example #12
Source File: graphs.py From models with Apache License 2.0 | 5 votes |
def eval_graph(self, dataset='test'): """Constructs classifier evaluation graph. Args: dataset: the labeled dataset to evaluate, {'train', 'test', 'valid'}. Returns: eval_ops: dict<metric name, tuple(value, update_op)> var_restore_dict: dict mapping variable restoration names to variables. Trainable variables will be mapped to their moving average names. """ inputs = _inputs(dataset, pretrain=False) embedded = self.layers['embedding'](inputs.tokens) _, next_state, logits, _ = self.cl_loss_from_embedding( embedded, inputs=inputs, return_intermediates=True) if FLAGS.single_label: indices = tf.stack([tf.range(FLAGS.batch_size), inputs.length - 1], 1) labels = tf.expand_dims(tf.gather_nd(inputs.labels, indices), 1) weights = tf.expand_dims(tf.gather_nd(inputs.weights, indices), 1) else: labels = inputs.labels weights = inputs.weights eval_ops = { 'accuracy': tf.contrib.metrics.streaming_accuracy( layers_lib.predictions(logits), labels, weights) } with tf.control_dependencies([inputs.save_state(next_state)]): acc, acc_update = eval_ops['accuracy'] acc_update = tf.identity(acc_update) eval_ops['accuracy'] = (acc, acc_update) var_restore_dict = make_restore_average_vars_dict() return eval_ops, var_restore_dict
Example #13
Source File: graphs.py From models with Apache License 2.0 | 5 votes |
def classifier_graph(self): """Constructs classifier graph from inputs to classifier loss. * Caches the VatxtInput objects in `self.cl_inputs` * Caches tensors: `cl_embedded` (tuple of forward and reverse), `cl_logits`, `cl_loss` Returns: loss: scalar float. """ inputs = _inputs('train', pretrain=False, bidir=True) self.cl_inputs = inputs f_inputs, _ = inputs # Embed both forward and reverse with a shared embedding embedded = [self.layers['embedding'](inp.tokens) for inp in inputs] self.tensors['cl_embedded'] = embedded _, next_states, logits, loss = self.cl_loss_from_embedding( embedded, return_intermediates=True) tf.summary.scalar('classification_loss', loss) self.tensors['cl_logits'] = logits self.tensors['cl_loss'] = loss acc = layers_lib.accuracy(logits, f_inputs.labels, f_inputs.weights) tf.summary.scalar('accuracy', acc) adv_loss = (self.adversarial_loss() * tf.constant( FLAGS.adv_reg_coeff, name='adv_reg_coeff')) tf.summary.scalar('adversarial_loss', adv_loss) total_loss = loss + adv_loss saves = [inp.save_state(state) for (inp, state) in zip(inputs, next_states)] with tf.control_dependencies(saves): total_loss = tf.identity(total_loss) tf.summary.scalar('total_classification_loss', total_loss) return total_loss
Example #14
Source File: graphs.py From models with Apache License 2.0 | 5 votes |
def eval_graph(self, dataset='test'): """Constructs classifier evaluation graph. Args: dataset: the labeled dataset to evaluate, {'train', 'test', 'valid'}. Returns: eval_ops: dict<metric name, tuple(value, update_op)> var_restore_dict: dict mapping variable restoration names to variables. Trainable variables will be mapped to their moving average names. """ inputs = _inputs(dataset, pretrain=False, bidir=True) embedded = [self.layers['embedding'](inp.tokens) for inp in inputs] _, next_states, logits, _ = self.cl_loss_from_embedding( embedded, inputs=inputs, return_intermediates=True) f_inputs, _ = inputs eval_ops = { 'accuracy': tf.contrib.metrics.streaming_accuracy( layers_lib.predictions(logits), f_inputs.labels, f_inputs.weights) } # Save states on accuracy update saves = [inp.save_state(state) for (inp, state) in zip(inputs, next_states)] with tf.control_dependencies(saves): acc, acc_update = eval_ops['accuracy'] acc_update = tf.identity(acc_update) eval_ops['accuracy'] = (acc, acc_update) var_restore_dict = make_restore_average_vars_dict() return eval_ops, var_restore_dict
Example #15
Source File: train_cifar.py From adanet with MIT License | 5 votes |
def build_eval_graph(x, y, ul_x): losses = {} logit = forward(x, is_training=False, update_batch_stats=False) nll_loss = L.ce_loss(logit, y) losses['NLL'] = nll_loss acc = L.accuracy(logit, y) losses['Acc'] = acc return losses
Example #16
Source File: train_svhn.py From adanet with MIT License | 5 votes |
def build_eval_graph(x, y, ul_x): losses = {} logit = forward(x, is_training=False, update_batch_stats=False) nll_loss = L.ce_loss(logit, y) losses['NLL'] = nll_loss acc = L.accuracy(logit, y) losses['Acc'] = acc return losses
Example #17
Source File: graphs.py From multilabel-image-classification-tensorflow with MIT License | 5 votes |
def classifier_graph(self): """Constructs classifier graph from inputs to classifier loss. * Caches the VatxtInput object in `self.cl_inputs` * Caches tensors: `cl_embedded`, `cl_logits`, `cl_loss` Returns: loss: scalar float. """ inputs = _inputs('train', pretrain=False) self.cl_inputs = inputs embedded = self.layers['embedding'](inputs.tokens) self.tensors['cl_embedded'] = embedded _, next_state, logits, loss = self.cl_loss_from_embedding( embedded, return_intermediates=True) tf.summary.scalar('classification_loss', loss) self.tensors['cl_logits'] = logits self.tensors['cl_loss'] = loss if FLAGS.single_label: indices = tf.stack([tf.range(FLAGS.batch_size), inputs.length - 1], 1) labels = tf.expand_dims(tf.gather_nd(inputs.labels, indices), 1) weights = tf.expand_dims(tf.gather_nd(inputs.weights, indices), 1) else: labels = inputs.labels weights = inputs.weights acc = layers_lib.accuracy(logits, labels, weights) tf.summary.scalar('accuracy', acc) adv_loss = (self.adversarial_loss() * tf.constant( FLAGS.adv_reg_coeff, name='adv_reg_coeff')) tf.summary.scalar('adversarial_loss', adv_loss) total_loss = loss + adv_loss with tf.control_dependencies([inputs.save_state(next_state)]): total_loss = tf.identity(total_loss) tf.summary.scalar('total_classification_loss', total_loss) return total_loss
Example #18
Source File: graphs.py From multilabel-image-classification-tensorflow with MIT License | 5 votes |
def eval_graph(self, dataset='test'): """Constructs classifier evaluation graph. Args: dataset: the labeled dataset to evaluate, {'train', 'test', 'valid'}. Returns: eval_ops: dict<metric name, tuple(value, update_op)> var_restore_dict: dict mapping variable restoration names to variables. Trainable variables will be mapped to their moving average names. """ inputs = _inputs(dataset, pretrain=False) embedded = self.layers['embedding'](inputs.tokens) _, next_state, logits, _ = self.cl_loss_from_embedding( embedded, inputs=inputs, return_intermediates=True) if FLAGS.single_label: indices = tf.stack([tf.range(FLAGS.batch_size), inputs.length - 1], 1) labels = tf.expand_dims(tf.gather_nd(inputs.labels, indices), 1) weights = tf.expand_dims(tf.gather_nd(inputs.weights, indices), 1) else: labels = inputs.labels weights = inputs.weights eval_ops = { 'accuracy': tf.contrib.metrics.streaming_accuracy( layers_lib.predictions(logits), labels, weights) } with tf.control_dependencies([inputs.save_state(next_state)]): acc, acc_update = eval_ops['accuracy'] acc_update = tf.identity(acc_update) eval_ops['accuracy'] = (acc, acc_update) var_restore_dict = make_restore_average_vars_dict() return eval_ops, var_restore_dict
Example #19
Source File: graphs.py From multilabel-image-classification-tensorflow with MIT License | 5 votes |
def classifier_graph(self): """Constructs classifier graph from inputs to classifier loss. * Caches the VatxtInput objects in `self.cl_inputs` * Caches tensors: `cl_embedded` (tuple of forward and reverse), `cl_logits`, `cl_loss` Returns: loss: scalar float. """ inputs = _inputs('train', pretrain=False, bidir=True) self.cl_inputs = inputs f_inputs, _ = inputs # Embed both forward and reverse with a shared embedding embedded = [self.layers['embedding'](inp.tokens) for inp in inputs] self.tensors['cl_embedded'] = embedded _, next_states, logits, loss = self.cl_loss_from_embedding( embedded, return_intermediates=True) tf.summary.scalar('classification_loss', loss) self.tensors['cl_logits'] = logits self.tensors['cl_loss'] = loss acc = layers_lib.accuracy(logits, f_inputs.labels, f_inputs.weights) tf.summary.scalar('accuracy', acc) adv_loss = (self.adversarial_loss() * tf.constant( FLAGS.adv_reg_coeff, name='adv_reg_coeff')) tf.summary.scalar('adversarial_loss', adv_loss) total_loss = loss + adv_loss saves = [inp.save_state(state) for (inp, state) in zip(inputs, next_states)] with tf.control_dependencies(saves): total_loss = tf.identity(total_loss) tf.summary.scalar('total_classification_loss', total_loss) return total_loss
Example #20
Source File: graphs.py From multilabel-image-classification-tensorflow with MIT License | 5 votes |
def eval_graph(self, dataset='test'): """Constructs classifier evaluation graph. Args: dataset: the labeled dataset to evaluate, {'train', 'test', 'valid'}. Returns: eval_ops: dict<metric name, tuple(value, update_op)> var_restore_dict: dict mapping variable restoration names to variables. Trainable variables will be mapped to their moving average names. """ inputs = _inputs(dataset, pretrain=False, bidir=True) embedded = [self.layers['embedding'](inp.tokens) for inp in inputs] _, next_states, logits, _ = self.cl_loss_from_embedding( embedded, inputs=inputs, return_intermediates=True) f_inputs, _ = inputs eval_ops = { 'accuracy': tf.contrib.metrics.streaming_accuracy( layers_lib.predictions(logits), f_inputs.labels, f_inputs.weights) } # Save states on accuracy update saves = [inp.save_state(state) for (inp, state) in zip(inputs, next_states)] with tf.control_dependencies(saves): acc, acc_update = eval_ops['accuracy'] acc_update = tf.identity(acc_update) eval_ops['accuracy'] = (acc, acc_update) var_restore_dict = make_restore_average_vars_dict() return eval_ops, var_restore_dict
Example #21
Source File: graphs.py From Gun-Detector with Apache License 2.0 | 5 votes |
def eval_graph(self, dataset='test'): """Constructs classifier evaluation graph. Args: dataset: the labeled dataset to evaluate, {'train', 'test', 'valid'}. Returns: eval_ops: dict<metric name, tuple(value, update_op)> var_restore_dict: dict mapping variable restoration names to variables. Trainable variables will be mapped to their moving average names. """ inputs = _inputs(dataset, pretrain=False) embedded = self.layers['embedding'](inputs.tokens) _, next_state, logits, _ = self.cl_loss_from_embedding( embedded, inputs=inputs, return_intermediates=True) if FLAGS.single_label: indices = tf.stack([tf.range(FLAGS.batch_size), inputs.length - 1], 1) labels = tf.expand_dims(tf.gather_nd(inputs.labels, indices), 1) weights = tf.expand_dims(tf.gather_nd(inputs.weights, indices), 1) else: labels = inputs.labels weights = inputs.weights eval_ops = { 'accuracy': tf.contrib.metrics.streaming_accuracy( layers_lib.predictions(logits), labels, weights) } with tf.control_dependencies([inputs.save_state(next_state)]): acc, acc_update = eval_ops['accuracy'] acc_update = tf.identity(acc_update) eval_ops['accuracy'] = (acc, acc_update) var_restore_dict = make_restore_average_vars_dict() return eval_ops, var_restore_dict
Example #22
Source File: graphs.py From DOTA_models with Apache License 2.0 | 5 votes |
def eval_graph(self, dataset='test'): """Constructs classifier evaluation graph. Args: dataset: the labeled dataset to evaluate, {'train', 'test', 'valid'}. Returns: eval_ops: dict<metric name, tuple(value, update_op)> var_restore_dict: dict mapping variable restoration names to variables. Trainable variables will be mapped to their moving average names. """ inputs = _inputs(dataset, pretrain=False) embedded = self.layers['embedding'](inputs.tokens) _, next_state, logits, _ = self.cl_loss_from_embedding( embedded, inputs=inputs, return_intermediates=True) eval_ops = { 'accuracy': tf.contrib.metrics.streaming_accuracy( layers_lib.predictions(logits), inputs.labels, inputs.weights) } with tf.control_dependencies([inputs.save_state(next_state)]): acc, acc_update = eval_ops['accuracy'] acc_update = tf.identity(acc_update) eval_ops['accuracy'] = (acc, acc_update) var_restore_dict = make_restore_average_vars_dict() return eval_ops, var_restore_dict
Example #23
Source File: graphs.py From DOTA_models with Apache License 2.0 | 5 votes |
def classifier_graph(self): """Constructs classifier graph from inputs to classifier loss. * Caches the VatxtInput objects in `self.cl_inputs` * Caches tensors: `cl_embedded` (tuple of forward and reverse), `cl_logits`, `cl_loss` Returns: loss: scalar float. """ inputs = _inputs('train', pretrain=False, bidir=True) self.cl_inputs = inputs f_inputs, _ = inputs # Embed both forward and reverse with a shared embedding embedded = [self.layers['embedding'](inp.tokens) for inp in inputs] self.tensors['cl_embedded'] = embedded _, next_states, logits, loss = self.cl_loss_from_embedding( embedded, return_intermediates=True) tf.summary.scalar('classification_loss', loss) self.tensors['cl_logits'] = logits self.tensors['cl_loss'] = loss acc = layers_lib.accuracy(logits, f_inputs.labels, f_inputs.weights) tf.summary.scalar('accuracy', acc) adv_loss = (self.adversarial_loss() * tf.constant( FLAGS.adv_reg_coeff, name='adv_reg_coeff')) tf.summary.scalar('adversarial_loss', adv_loss) total_loss = loss + adv_loss tf.summary.scalar('total_classification_loss', total_loss) saves = [inp.save_state(state) for (inp, state) in zip(inputs, next_states)] with tf.control_dependencies(saves): total_loss = tf.identity(total_loss) return total_loss
Example #24
Source File: graphs.py From DOTA_models with Apache License 2.0 | 5 votes |
def eval_graph(self, dataset='test'): """Constructs classifier evaluation graph. Args: dataset: the labeled dataset to evaluate, {'train', 'test', 'valid'}. Returns: eval_ops: dict<metric name, tuple(value, update_op)> var_restore_dict: dict mapping variable restoration names to variables. Trainable variables will be mapped to their moving average names. """ inputs = _inputs(dataset, pretrain=False, bidir=True) embedded = [self.layers['embedding'](inp.tokens) for inp in inputs] _, next_states, logits, _ = self.cl_loss_from_embedding( embedded, inputs=inputs, return_intermediates=True) f_inputs, _ = inputs eval_ops = { 'accuracy': tf.contrib.metrics.streaming_accuracy( layers_lib.predictions(logits), f_inputs.labels, f_inputs.weights) } # Save states on accuracy update saves = [inp.save_state(state) for (inp, state) in zip(inputs, next_states)] with tf.control_dependencies(saves): acc, acc_update = eval_ops['accuracy'] acc_update = tf.identity(acc_update) eval_ops['accuracy'] = (acc, acc_update) var_restore_dict = make_restore_average_vars_dict() return eval_ops, var_restore_dict
Example #25
Source File: train_semisup.py From vat_tf with MIT License | 5 votes |
def build_eval_graph(x, y, ul_x): losses = {} logit = vat.forward(x, is_training=False, update_batch_stats=False) nll_loss = L.ce_loss(logit, y) losses['NLL'] = nll_loss acc = L.accuracy(logit, y) losses['Acc'] = acc scope = tf.get_variable_scope() scope.reuse_variables() at_loss = vat.adversarial_loss(x, y, nll_loss, is_training=False) losses['AT_loss'] = at_loss ul_logit = vat.forward(ul_x, is_training=False, update_batch_stats=False) vat_loss = vat.virtual_adversarial_loss(ul_x, ul_logit, is_training=False) losses['VAT_loss'] = vat_loss return losses
Example #26
Source File: graphs.py From yolo_v2 with Apache License 2.0 | 5 votes |
def classifier_graph(self): """Constructs classifier graph from inputs to classifier loss. * Caches the VatxtInput object in `self.cl_inputs` * Caches tensors: `cl_embedded`, `cl_logits`, `cl_loss` Returns: loss: scalar float. """ inputs = _inputs('train', pretrain=False) self.cl_inputs = inputs embedded = self.layers['embedding'](inputs.tokens) self.tensors['cl_embedded'] = embedded _, next_state, logits, loss = self.cl_loss_from_embedding( embedded, return_intermediates=True) tf.summary.scalar('classification_loss', loss) self.tensors['cl_logits'] = logits self.tensors['cl_loss'] = loss acc = layers_lib.accuracy(logits, inputs.labels, inputs.weights) tf.summary.scalar('accuracy', acc) adv_loss = (self.adversarial_loss() * tf.constant( FLAGS.adv_reg_coeff, name='adv_reg_coeff')) tf.summary.scalar('adversarial_loss', adv_loss) total_loss = loss + adv_loss tf.summary.scalar('total_classification_loss', total_loss) with tf.control_dependencies([inputs.save_state(next_state)]): total_loss = tf.identity(total_loss) return total_loss
Example #27
Source File: graphs.py From yolo_v2 with Apache License 2.0 | 5 votes |
def eval_graph(self, dataset='test'): """Constructs classifier evaluation graph. Args: dataset: the labeled dataset to evaluate, {'train', 'test', 'valid'}. Returns: eval_ops: dict<metric name, tuple(value, update_op)> var_restore_dict: dict mapping variable restoration names to variables. Trainable variables will be mapped to their moving average names. """ inputs = _inputs(dataset, pretrain=False) embedded = self.layers['embedding'](inputs.tokens) _, next_state, logits, _ = self.cl_loss_from_embedding( embedded, inputs=inputs, return_intermediates=True) eval_ops = { 'accuracy': tf.contrib.metrics.streaming_accuracy( layers_lib.predictions(logits), inputs.labels, inputs.weights) } with tf.control_dependencies([inputs.save_state(next_state)]): acc, acc_update = eval_ops['accuracy'] acc_update = tf.identity(acc_update) eval_ops['accuracy'] = (acc, acc_update) var_restore_dict = make_restore_average_vars_dict() return eval_ops, var_restore_dict
Example #28
Source File: graphs.py From yolo_v2 with Apache License 2.0 | 5 votes |
def classifier_graph(self): """Constructs classifier graph from inputs to classifier loss. * Caches the VatxtInput objects in `self.cl_inputs` * Caches tensors: `cl_embedded` (tuple of forward and reverse), `cl_logits`, `cl_loss` Returns: loss: scalar float. """ inputs = _inputs('train', pretrain=False, bidir=True) self.cl_inputs = inputs f_inputs, _ = inputs # Embed both forward and reverse with a shared embedding embedded = [self.layers['embedding'](inp.tokens) for inp in inputs] self.tensors['cl_embedded'] = embedded _, next_states, logits, loss = self.cl_loss_from_embedding( embedded, return_intermediates=True) tf.summary.scalar('classification_loss', loss) self.tensors['cl_logits'] = logits self.tensors['cl_loss'] = loss acc = layers_lib.accuracy(logits, f_inputs.labels, f_inputs.weights) tf.summary.scalar('accuracy', acc) adv_loss = (self.adversarial_loss() * tf.constant( FLAGS.adv_reg_coeff, name='adv_reg_coeff')) tf.summary.scalar('adversarial_loss', adv_loss) total_loss = loss + adv_loss tf.summary.scalar('total_classification_loss', total_loss) saves = [inp.save_state(state) for (inp, state) in zip(inputs, next_states)] with tf.control_dependencies(saves): total_loss = tf.identity(total_loss) return total_loss
Example #29
Source File: graphs.py From yolo_v2 with Apache License 2.0 | 5 votes |
def eval_graph(self, dataset='test'): """Constructs classifier evaluation graph. Args: dataset: the labeled dataset to evaluate, {'train', 'test', 'valid'}. Returns: eval_ops: dict<metric name, tuple(value, update_op)> var_restore_dict: dict mapping variable restoration names to variables. Trainable variables will be mapped to their moving average names. """ inputs = _inputs(dataset, pretrain=False, bidir=True) embedded = [self.layers['embedding'](inp.tokens) for inp in inputs] _, next_states, logits, _ = self.cl_loss_from_embedding( embedded, inputs=inputs, return_intermediates=True) f_inputs, _ = inputs eval_ops = { 'accuracy': tf.contrib.metrics.streaming_accuracy( layers_lib.predictions(logits), f_inputs.labels, f_inputs.weights) } # Save states on accuracy update saves = [inp.save_state(state) for (inp, state) in zip(inputs, next_states)] with tf.control_dependencies(saves): acc, acc_update = eval_ops['accuracy'] acc_update = tf.identity(acc_update) eval_ops['accuracy'] = (acc, acc_update) var_restore_dict = make_restore_average_vars_dict() return eval_ops, var_restore_dict
Example #30
Source File: graphs.py From Gun-Detector with Apache License 2.0 | 5 votes |
def classifier_graph(self): """Constructs classifier graph from inputs to classifier loss. * Caches the VatxtInput object in `self.cl_inputs` * Caches tensors: `cl_embedded`, `cl_logits`, `cl_loss` Returns: loss: scalar float. """ inputs = _inputs('train', pretrain=False) self.cl_inputs = inputs embedded = self.layers['embedding'](inputs.tokens) self.tensors['cl_embedded'] = embedded _, next_state, logits, loss = self.cl_loss_from_embedding( embedded, return_intermediates=True) tf.summary.scalar('classification_loss', loss) self.tensors['cl_logits'] = logits self.tensors['cl_loss'] = loss if FLAGS.single_label: indices = tf.stack([tf.range(FLAGS.batch_size), inputs.length - 1], 1) labels = tf.expand_dims(tf.gather_nd(inputs.labels, indices), 1) weights = tf.expand_dims(tf.gather_nd(inputs.weights, indices), 1) else: labels = inputs.labels weights = inputs.weights acc = layers_lib.accuracy(logits, labels, weights) tf.summary.scalar('accuracy', acc) adv_loss = (self.adversarial_loss() * tf.constant( FLAGS.adv_reg_coeff, name='adv_reg_coeff')) tf.summary.scalar('adversarial_loss', adv_loss) total_loss = loss + adv_loss with tf.control_dependencies([inputs.save_state(next_state)]): total_loss = tf.identity(total_loss) tf.summary.scalar('total_classification_loss', total_loss) return total_loss