TensorFlow next_batch + Examples

In this Python tutorial, we will learn how to execute a Tensorflow next_batch for data in Python TensorFlow. Also, we will cover the following topics.

• TensorFlow next_batch
• TensorFlow dataset next_batch
• TensorFlow dataset get next_batch
• Tensorflow mnist.train.next_batch

Also, check the related tutorial on TensorFlow: TensorFlow feed_dict

TensorFlow next_batch

• In this section, we will discuss how to implement a TensorFlow next_batch for data in Python TensorFlow.
• To perform this particular task, we are going to generate 100 random data points from the given training set and then use the global function to pass the number of samples in the form of an array.

Example:

Let’s take an example and check how to implement a TensorFlow next_batch for data in Python TensorFlow.

Source Code:

import numpy as np

def next_batch(new_num, new_dat, labels):

    new_indx = np.arange(0 , len(new_dat))
    np.random.shuffle(new_indx)
    idx = new_indx[:new_num]
    new_result = [new_dat[ i] for i in new_indx]
    new_output = [labels[ i] for i in new_indx]

    return np.asarray(new_result), np.asarray(new_output)

new_value, new_val = np.arange(0, 10), np.arange(0, 100).reshape(10, 10)
print(new_value)
print(new_val)

new_value, new_val = next_batch(5, new_value, new_val)
print('random samples')
print(new_value)
print(new_val)

In the following given code we have imported the NumPy library and then define the function next_batch(), within this function we have passed the new_num and new_data as an argument and it will return a total number of random samples.

After that, we have set the random 100 values by using the np.arange() function along with the reshape method. Once you will execute this code the output displays the NumPy array that stores 100 values in it.

Here is the Screenshot of the following given code.

Read: Tensorflow embedding_lookup

TensorFlow dataset next_batch

• In this section, we will discuss how to use the dataset to implement a TensorFlow next_batch in Python TensorFlow.
• To perform this particular task, we are going to use the tf.data.Dataset.from_tensor_slices() function and this function declared a potentially large set of values.

Syntax:

Let’s have a look at the Syntax and understand the working of tf.data.dataset() function in Python TensorFlow.

tf.data.Dataset
               (
                variant_tensor
               )

• It consists of a few parameters.
  • variant_tensor: This parameter defines the dataset of the tensor.

Example:

import tensorflow as tf

input_tensor = tf.range(7)

new_datset = tf.data.Dataset.from_tensor_slices(input_tensor)
print(new_datset)
for m in new_datset:    
    print(m)
new_datset2 = new_datset.batch(batch_size=2)
print("Batch method:")
for m in new_datset2:
    print(m) 

In the following given code, we have imported the Tensorflow library and then created the tensor by using the tf.range() function. After that, we created the dataset by using the tf.data.Dataset.from_tensor_slices() function and within this function we assigned the input tensor as an argument.

Once you will execute this code the output displays the range value which we have set in the tensor. After that, we used the new_dataset.batch() method for next_batch values.

Here is the Screenshot of the following given code.

Read: TensorFlow clip_by_value

TensorFlow dataset get next_batch

• In this section, we will discuss how to get the next_batch dataset in Python TensorFlow.
• To do this task we are going to use the tf.data.Dataset.from_tensorslices() function and within this function we are going to set the batch and epochs() value.
• Next, we will declare the variables for size and epoch value and then use the tf.variable scope() function this function declares new variables and it works as expected when the eager execution will be disabled.

Syntax:

Let’s have a look at the Syntax and understand the working of the tf.compat.v1.variable_scope() function in Python TensorFlow.

tf.compat.v1.variable_scope(
    name_or_scope,
    default_name=None,
    values=None,
    initializer=None,
    regularizer=None,
    caching_device=None,
    partitioner=None,
    custom_getter=None,
    reuse=None,
    dtype=None,
    use_resource=None,
    constraint=None,
    auxiliary_name_scope=True
)

Example:

Let’s take an example and check how to get the next_batch dataset in Python TensorFlow.

Source Code:

import tensorflow as tf
from __future__ import absolute_import
from __future__ import division


def ds_train(new_val_size, new_epochs):  
    new_val = (tf.data.Dataset.from_tensor_slices(([16.2,76.2,38.4,11.6,19.3], [-12,-15,-28,-45,-89]))
            .batch(new_val_size)
            .repeat(new_epochs)        
            )
    return new_val


new_val_size= 1
input_size = 1
new_epochs = 2

with tf.variable_scope("dataset"):       
    result= ds_train(new_val_size, new_epochs)

with tf.variable_scope("iterator"):
    val_iterate = result.make_initializable_iterator()
    new_iterate_handle = tf.placeholder(tf.string, shape=[])
    iterator = tf.data.Iterator.from_string_handle(new_iterate_handle, 
                                                val_iterate.output_types,
                                                val_iterate.output_shapes)

    def next_item():
        new_element = iterator.get_next(name="new_element")
        m, n = tf.cast(new_element[0], tf.float32), new_element[1]
        return m, n        


inputs = tf.Variable(tf.zeros(shape=[new_val_size,input_size]), dtype=tf.float32, name="inputs", trainable=False, use_resource=True)
target = tf.Variable(tf.zeros(shape=[new_val_size], dtype=tf.int32), dtype=tf.int32, name="target", trainable=False,use_resource=True)
is_new = tf.placeholder_with_default(tf.constant(False), shape=[], name="new_item_flag")

def new_data(new_val_size, input_size):
    
    next_inputs, next_target = next_item()
    next_inputs = tf.reshape(next_inputs, shape=[new_val_size, input_size])
    with tf.control_dependencies([tf.assign(inputs, next_inputs), tf.assign(target, next_target)]):
        return tf.identity(inputs), tf.identity(target)

def old_data():
    
    return inputs, target

next_inputs, next_target = next_item()

inputs, target =  tf.cond(is_new, lambda:new_data(new_val_size, input_size), old_data)

with tf.Session() as sess:
    sess.run([tf.global_variables_initializer(),tf.local_variables_initializer()])
    handle_t = sess.run(val_iterate.string_handle())
    sess.run(val_iterate.initializer)
    while True:
        try:
            print(sess.run([inputs, target], feed_dict={new_iterate_handle:handle_t, is_new: False}))
            print(sess.run([inputs, target], feed_dict={new_iterate_handle:handle_t, is_new: False}))
            print(sess.run([inputs, target], feed_dict={new_iterate_handle:handle_t, is_new: True}))
        except tf.errors.OutOfRangeError:
            print("End of training dataset.")
            break        

In the following given code, we have used the tf.data.Iterator.from_string_handle() function and this function indicate the state of iterating through a dataset and then declaring a tensor by using the tf.variables() function.

Here is the implementation of the following given code.

Read: Binary Cross Entropy TensorFlow

TensorFlow mnist.train.next_batch

• In this section, we will discuss how to use the mnist train dataset in next_batch by using Python TensorFlow.
• In Python, the mnist is a dataset that specifies the images of handwritten digit classification and in the mnist dataset, there are almost 70,000 images, and each image consists of 784 features.

Note: from TensorFlow.examples.tutorials.mnist import input_data() library is available only in TensorFlow 1.x version. If you are using the latest version of TensorFlow then you have to uninstall and installed the 1.x version of TensorFlow to execute this program.

Example:

Let’s take an example and check how to use the mnist train dataset in next_batch by using Python TensorFlow.

Source Code:

import matplotlib.pyplot as plt
import numpy as np
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("data")

new_index_val = 8
new_index_val -=2 
mnist.train.next_batch(-mnist.train._index_in_epoch)

mnist.train.next_batch(new_index_val) 
new_batc_x, new_batc_y = mnist.train.next_batch(1)

print("mnist train next batch")
plt.imshow(new_batc_x.reshape([28, 28]), cmap='Blues')
plt.show()
print(new_batc_y, np.argmax(new_batc_y), mnist.train._index_in_epoch)

new_img_x = mnist.train.images[new_index_val] 
new_img_y = mnist.train.labels[new_index_val] 

print("mnist image batch")
plt.imshow(new_img_x.reshape([28, 28]), cmap='Dark2')
plt.show()
print(new_img_y, np.argmax(new_img_y), mnist.train._index_in_epoch)

In the following given code, we have imported the from TensorFlow.examples.tutorials.mnist import input_data library and then use the index values.

After that, we have divided the batch into two parts new_batc_x and new_batc_y variables, and assign mnist.train.next_batch() value. In the plot imshow() function we have mentioned the pixel of image (28,28) with image color as an argument.

Here is the Screenshot of the following given code.

Also, take a look at some more Python TensorFlow tutorials.

• Gradient descent optimizer TensorFlow
• Tensorflow custom loss function
• Tensorflow convert string to int
• TensorFlow Get Variable + Examples
• Python TensorFlow Placeholder
• Tensorflow get static value
• Convert list to tensor TensorFlow

In this Python tutorial, we have learned how to execute a Tensorflow next_batch for data in Python TensorFlow. Also, we have covered the following topics.

• TensorFlow next_batch
• TensorFlow dataset next_batch
• TensorFlow dataset get next_batch
• TensorFlow mnist.train.next_batch