def get_real_activations(batch_size, num_batches, shuffle_buffer_size=100000, split='validation', get_logits=False): """Fetches batches inception pools and images. NOTE: This function runs inference on an Inception network, so it would be more efficient to run this on GPU or TPU than on CPU. Args: batch_size: The number of elements in a single minibatch. num_batches: The number of batches to fetch at a time. shuffle_buffer_size: The number of records to load before shuffling. Larger means more likely randomization. split: Shuffle if 'train', else deterministic. get_logits: If `True`, return (logits, pools). Otherwise just return pools. Returns: A Tensor of `real_pools` or (`real_logits`, `real_pools`) with batch dimension (batch_size * num_batches). """ ds = data_provider.provide_dataset(batch_size, shuffle_buffer_size, split) ds = ds.map(lambda img, lbl: img) # Remove labels. return get_activations_from_dataset(ds, num_batches, get_logits)
def train_eval_input_fn(mode, params): """Mode-aware input function.""" is_train = mode == tf.estimator.ModeKeys.TRAIN split = 'train' if is_train else 'validation' if params['tpu_params'].use_tpu_estimator: bs = params['batch_size'] else: bs = { tf.estimator.ModeKeys.TRAIN: params['train_batch_size'], tf.estimator.ModeKeys.EVAL: params['eval_batch_size'], tf.estimator.ModeKeys.PREDICT: params['predict_batch_size'], }[mode] if params['debug_params'].fake_data: fake_noise = tf.zeros([bs, params['z_dim']]) if mode == tf.estimator.ModeKeys.PREDICT: return tf.data.Dataset.from_tensors(fake_noise).repeat() fake_imgs = tf.zeros([bs, 128, 128, 3]) fake_lbls = tf.zeros([bs], dtype=tf.int32) ds = tf.data.Dataset.from_tensors((fake_noise, { 'images': fake_imgs, 'labels': fake_lbls })) ds = ds.repeat() _verify_dataset_shape(ds, params['z_dim']) return ds num_towers = 1 def _make_noise(_): noise = gen_module.make_z_normal(num_towers, bs, params['z_dim']) return noise[0] # one tower noise_ds = tf.data.Dataset.from_tensors(0).repeat().map(_make_noise) if mode == tf.estimator.ModeKeys.PREDICT: return noise_ds images_ds = data_provider.provide_dataset( bs, shuffle_buffer_size=params['shuffle_buffer_size'], split=split) images_ds = images_ds.map(lambda img, lbl: { 'images': img, 'labels': lbl }) # map to dict. ds = tf.data.Dataset.zip((noise_ds, images_ds)) _verify_dataset_shape(ds, params['z_dim']) return ds
def train_eval_input_fn(mode, params, restrict_classes=None, shift_classes=0): """Mode-aware input function. restrict_classes: for use with intra fid shift_classes: for use with restrict_classes """ is_train = mode == tf.estimator.ModeKeys.TRAIN split = 'train' if is_train else flags.FLAGS.dataset_val_split_name if params['tpu_params'].use_tpu_estimator: bs = params['batch_size'] else: bs = { tf.estimator.ModeKeys.TRAIN: params['train_batch_size'], tf.estimator.ModeKeys.EVAL: params['eval_batch_size'], tf.estimator.ModeKeys.PREDICT: params['predict_batch_size'], }[mode] if params['debug_params'].fake_data: fake_noise = tf.zeros([bs, params['z_dim']]) if mode == tf.estimator.ModeKeys.PREDICT: return tf.data.Dataset.from_tensors(fake_noise).repeat() fake_imgs = tf.zeros( [bs, flags.FLAGS.image_size, flags.FLAGS.image_size, 3]) fake_lbls = tf.zeros([bs], dtype=tf.int32) ds = tf.data.Dataset.from_tensors((fake_noise, { 'images': fake_imgs, 'labels': fake_lbls })) ds = ds.repeat() _verify_dataset_shape(ds, params['z_dim']) return ds num_towers = 1 def _make_noise(_): noise = gen_module.make_z_normal(num_towers, bs, params['z_dim']) return noise[0] # one tower noise_ds = tf.data.Dataset.from_tensors(0).repeat().map(_make_noise) if mode == tf.estimator.ModeKeys.PREDICT and not flags.FLAGS.mode == 'gen_images': return noise_ds images_ds = data_provider.provide_dataset( bs, shuffle_buffer_size=params['shuffle_buffer_size'], split=split, restrict_classes=restrict_classes) if flags.FLAGS.unlabelled_dataset_name is not None: unl_images_ds = data_provider_unlabelled.provide_dataset( bs, shuffle_buffer_size=params['shuffle_buffer_size'], split=flags.FLAGS.unlabelled_dataset_split_name) images_ds = tf.data.Dataset.zip((images_ds, unl_images_ds)) images_ds = images_ds.map( lambda img_lab_tup, unl_img: { 'images': img_lab_tup[0], 'labels': img_lab_tup[1], 'unlabelled_images': unl_img }) # map to dict. else: images_ds = images_ds.map(lambda img, lbl: { 'images': img, 'labels': lbl }) # map to dict. ds = tf.data.Dataset.zip((noise_ds, images_ds)) if restrict_classes is not None or flags.FLAGS.mode == 'intra_fid_eval': ds = ds.map(lambda noise_ds, images_ds: ({ 'z': noise_ds, 'labels': images_ds['labels'] - shift_classes }, { 'images': images_ds['images'], 'labels': images_ds['labels'] - shift_classes })) elif flags.FLAGS.mode == 'gen_images': def _make_labels_for_class(y): return gen_module.make_one_batch_constant_labels(bs, y) labels_todo = [900] #labels_todo = list(range(flags.FLAGS.num_classes)) # hack to print your favorite classes # labels_todo = list(sorted([130,96,90,88,164,175,281,289,290,292,294,323,441,475,555,581,607,654,661,663,688,779] * 5)) # okay, this is a ugly papercut, but an easy one-line modification of the above def _make_one_batch_unif_random_labels(index): del index return gen_module.make_class_labels(bs, flags.FLAGS.num_classes) if flags.FLAGS.gen_images_uniform_random_labels: labs_ds = tf.data.Dataset.from_tensor_slices( labels_todo).repeat().map(_make_one_batch_unif_random_labels) else: labs_ds = tf.data.Dataset.from_tensor_slices( labels_todo).repeat().map(_make_labels_for_class) ds = tf.data.Dataset.zip((noise_ds, images_ds, labs_ds)) ds = ds.map(lambda noise_ds_, images_ds_, labs_ds_: { 'z': noise_ds_, 'labels': labs_ds_ }) # fake data only # ds = ds.map(lambda noise_ds_, images_ds_, labs_ds_: ({'z': noise_ds_, 'labels': labs_ds_}, images_ds_) ) else: _verify_dataset_shape(ds, params['z_dim']) return ds