def make_report(self, data): res = self.connect(data) exprs = AttrDict(loss=self._loss(data, res)) exprs.update(self._report(data, res)) for k, v in exprs.items(): if not isinstance(v, tf.Tensor): exprs[k] = tf.convert_to_tensor(v) return exprs
def collect_results(sess, tensors, n_batches): """Collects `n_batches` of tensors and aggregates the results.""" res = AttrDict({k: [] for k in tensors}) print('Collecting: 0/{}'.format(n_batches), end='') for i in range(n_batches): print('\rCollecting: {}/{}'.format(i + 1, n_batches), end='') vals = sess.run(tensors) for k, v in vals.items(): res[k].append(v) print('') for k, v in res.items(): if v[0].shape: res[k] = np.concatenate(v, 0) else: res[k] = np.stack(v) return res
def collect_results(sess, tensors, n_batches): """Collects `n_batches` of tensors and aggregates the results.""" res = AttrDict({k: [] for k in tensors}) print('Collecting: 0/{}'.format(n_batches), end='') run_options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE) run_metadata = tf.RunMetadata() for i in range(n_batches): print('\rCollecting: {}/{}'.format(i + 1, n_batches), end='') if i == 10: print('') print('herehereherehere it starts') vals = sess.run(tensors, options=run_options, run_metadata=run_metadata) tl = timeline.Timeline(run_metadata.step_stats) ctf = tl.generate_chrome_trace_format() print('herehereherehere it ends') with open('timeline_mnist_8.json', 'w') as f: f.write(ctf) print('') else: vals = sess.run(tensors) for k, v in vals.items(): res[k].append(v) print('') for k, v in res.items(): if v[0].shape: res[k] = np.concatenate(v, 0) else: res[k] = np.stack(v) return res
def main(_=None): FLAGS = flags.FLAGS # pylint: disable=invalid-name,redefined-outer-name config = FLAGS FLAGS.__dict__['config'] = config # Build the graph with tf.Graph().as_default(): model_dict = model_config.get(FLAGS) data_dict = data_config.get(FLAGS) model = model_dict.model trainset = data_dict.trainset validset = data_dict.validset # Optimisation target validset = tools.maybe_convert_dataset(validset) trainset = tools.maybe_convert_dataset(trainset) train_tensors = model(trainset) valid_tensors = model(validset) sess = tf.Session() saver = tf.train.Saver() saver.restore(sess, FLAGS.snapshot) valid_results = _collect_results(sess, valid_tensors, validset, 10000 // FLAGS.batch_size) train_results = _collect_results(sess, train_tensors, trainset, 60000 // FLAGS.batch_size) results = AttrDict(train=train_results, valid=valid_results) # Linear classification print('Linear classification accuracy:') for k, v in results.items(): print('\t{}: prior={:.04f}, posterior={:.04f}'.format( k, v.prior_acc.mean(), v.posterior_acc.mean())) # Unsupervised classification via clustering print('Bipartite matching classification accuracy:') for field in 'posterior_pres prior_pres'.split(): kmeans = sklearn.cluster.KMeans( n_clusters=10, precompute_distances=True, n_jobs=-1, max_iter=1000, ).fit(results.train[field]) train_acc = cluster_classify(results.train[field], results.train.label, 10, kmeans) valid_acc = cluster_classify(results.valid[field], results.valid.label, 10, kmeans) print('\t{}: train_acc={:.04f}, valid_acc={:.04f}'.format(field, train_acc, valid_acc)) checkpoint_folder = osp.dirname(FLAGS.snapshot) figure_filename = osp.join(checkpoint_folder, FLAGS.tsne_figure_name) print('Savign TSNE plot at "{}"'.format(figure_filename)) make_tsne_plot(valid_results.posterior_pres, valid_results.label, figure_filename)
def _build(self, h, x, presence=None): """Builds the module. Args: h: Tensor of encodings of shape [B, n_enc_dims]. x: Tensor of inputs of shape [B, n_points, n_input_dims] presence: Tensor of shape [B, n_points, 1] or None; if it exists, it indicates which input points exist. Returns: A bunch of stuff. """ batch_size, n_input_points, _ = x.shape.as_list() res = AttrDict( dynamic_weights_l2=tf.constant(0.) ) output_shapes = ( [1], # per-capsule presence [self._n_votes], # per-vote-presence [self._n_votes], # per-vote scale [self._n_votes, self._n_caps_dims] ) splits = [np.prod(i).astype(np.int32) for i in output_shapes] n_outputs = sum(splits) batch_mlp = neural.BatchMLP([self._n_hiddens, self._n_hiddens, n_outputs], use_bias=True) all_params = batch_mlp(h) all_params = tf.split(all_params, splits, -1) batch_shape = [batch_size, self._n_caps] all_params = [tf.reshape(i, batch_shape + s) for (i, s) in zip(all_params, output_shapes)] def add_noise(tensor): return tf.random.uniform(tensor.shape, minval=-.5, maxval=.5) * 4. res.pres_logit_per_caps = add_noise(all_params[0]) res.pres_logit_per_vote = add_noise(all_params[1]) res.scale = tf.nn.softplus(all_params[2] + .5) + 1e-6 res.vote_presence = (tf.nn.sigmoid(res.pres_logit_per_caps) * tf.nn.sigmoid(res.pres_logit_per_vote)) res.vote = all_params[3] for k, v in res.items(): if v.shape.ndims > 0: res[k] = snt.MergeDims(1, 2)(v) likelihood = _capsule.OrderInvariantCapsuleLikelihood(self._n_votes, res.vote, res.scale, res.vote_presence) ll_res = likelihood(x, presence) res.update(ll_res._asdict()) # post processing mixing_probs = tf.nn.softmax(ll_res.mixing_logits, 1) prior_mixing_log_prob = tf.log(1. / n_input_points) mixing_kl = mixing_probs * (ll_res.mixing_log_prob - prior_mixing_log_prob) mixing_kl = tf.reduce_mean(tf.reduce_sum(mixing_kl, -1)) wins_per_caps = tf.one_hot(ll_res.is_from_capsule, depth=self._n_caps) if presence is not None: wins_per_caps *= tf.expand_dims(presence, -1) wins_per_caps = tf.reduce_sum(wins_per_caps, 1) has_any_wins = tf.to_float(tf.greater(wins_per_caps, 0)) should_be_active = tf.to_float(tf.greater(wins_per_caps, 1)) sparsity_loss = tf.nn.sigmoid_cross_entropy_with_logits( labels=should_be_active, logits=res.pres_logit_per_caps) sparsity_loss = tf.reduce_sum(sparsity_loss * has_any_wins, -1) sparsity_loss = tf.reduce_mean(sparsity_loss) caps_presence_prob = tf.reduce_max( tf.reshape(res.vote_presence, [batch_size, self._n_caps, self._n_votes]), 2) res.update(dict( mixing_kl=mixing_kl, sparsity_loss=sparsity_loss, caps_presence_prob=caps_presence_prob, mean_scale=tf.reduce_mean(res.scale) )) return res