def train_input_fn(): """Prepare data for training.""" # When choosing shuffle buffer sizes, larger sizes result in better # randomness, while smaller sizes use less memory. MNIST is a small # enough dataset that we can easily shuffle the full epoch. ds = dataset.train(flags_obj.data_dir) def invert(image, label): return (image * -1.0) + 1.0, label def brightness(image, label): return tf.image.random_brightness(image, max_delta=0.2), label if INVERT: inverted = ds.map(invert) ds = ds.concatenate(inverted) if BRIGHTNESS: ds = ds.concatenate(ds.map(brightness)) ds = ds.cache().shuffle(buffer_size=50000).batch(flags_obj.batch_size) # Iterate through the dataset a set number (`epochs_between_evals`) of times # during each training session. ds = ds.repeat(flags_obj.epochs_between_evals) return ds
def train_input_fn(): ds = mnist_dataset.train('/tmp/mnist') ds = ds.cache() ds = ds.shuffle(buffer_size=50000) ds = ds.repeat(5) # Do not call `ds.batch(batch_size)` here if `batch_size` is a # hyperparameter, this must be handled in `BaseParamSearch`. return ds
def train_input_fn(): """Prepare data for training.""" # When choosing shuffle buffer sizes, larger sizes result in better # randomness, while smaller sizes use less memory. MNIST is a small # enough dataset that we can easily shuffle the full epoch. ds = dataset.train(FLAGS.data_dir) # ds_batched = ds.cache().shuffle(buffer_size=50000).batch(FLAGS.batch_size) ds_batched = ds.cache().batch(FLAGS.batch_size) # Iterate through the dataset a set number (`epochs_between_evals`) of times # during each training session. ds = ds_batched.repeat(FLAGS.epochs_between_evals) return ds
def train_input_fn(data_dir, params): """Train input function for the MNIST dataset. Args: data_dir: (string) path to the data directory params: (dict) contains hyperparameters of the model """ dataset = mnist_dataset.train(data_dir) dataset = dataset.shuffle( params['train_size']) # whole dataset into the buffer dataset = dataset.repeat( params['num_epochs']) # repeat for multiple epochs dataset = dataset.batch(params['batch_size']) dataset = dataset.prefetch( 1) # make sure you always have one batch ready to serve return dataset
def make_datasets_unbatched(): # Scaling MNIST data from (0, 255] to (0., 1.] if tf.__version__ == '2.0.0': import tensorflow_datasets as tfds def scale(image, label): image = tf.cast(image, tf.float32) image /= 255 return image, label tfds.disable_progress_bar() datasets, info = tfds.load(name='mnist', with_info=True, as_supervised=True) return datasets['train'].map(scale).cache().shuffle(BUFFER_SIZE) else: import mnist_dataset as dataset ds = dataset.train('/bg/mnist') ds = ds.cache().shuffle(buffer_size=50000) return ds
def train_data(): data = dataset.train(FLAGS.data_dir) data = data.cache() data = data.batch(FLAGS.batch_size) return data
def forward(self, x, labels, train): with tf.GradientTape() as tape: y = self.input(x) for layer in self.layers: y = layer(y, train=train) loss = tf.reduce_mean( tf.losses.sparse_softmax_cross_entropy(labels=labels, logits=y.outputs)) grads = tape.gradient(loss, self.layers[-1].weights) return y, grads, loss def update(self, grads): self.optimiser.apply_gradients(zip(grads, self.layers[-1].weights)) train_ds = mnist_dataset.train("../data/") test_ds = mnist_dataset.test("../data/").batch(32) network = Net() log_interval = 1000 for epoch in range(3): start_time = time.time() # Training train_ds_shuffle = train_ds.shuffle(60000).batch(32) for (batch, (images, labels)) in enumerate(train_ds_shuffle): logits, grads, loss = network.forward(images, labels, train=True)