当前位置: 首页>编程语言>正文

TensorFlow识别性能 tensorflow读取数据

1、第一种方式通过占位符feed_dict的方式读入;

2、通过dataset的方式读入:

1)导入数据:从一些数据中创建一个Dataset实例;

2)创建一个迭代器:通过使用创建的数据集来制作一个迭代器实例迭代遍历数据集;

3)使用数据:通过使用创建的迭代器,我们可以得到数据集的元素馈送给模型;

1 从numpy导入数据

常见的情况下,我们有一个numpy数组,我们想通过它传送到tensorflow。


# create a random vector of shape (100,2)
x = np.random.sample((100,2))
# make a dataset from a numpy array
dataset = tf.data.Dataset.from_tensor_slices(x)


我们也可以通过多个numpy数组,一个典型的例子是当我们将数据分为特征和标签时


features, labels = (np.random.sample((100,2)), np.random.sample((100,1)))
dataset = tf.data.Dataset.from_tensor_slices((features,labels))


2 从tensor导入数据

当然,我们可以用一些张量来初始化我们的数据集


# using a tensor
dataset = tf.data.Dataset.from_tensor_slices(tf.random_uniform([100, 2]))


3 从placeholder(占位符)导入数据

当我们想动态地改变数据集里面的数据时,placeholder是很有用的,我们稍后会做。


x = tf.placeholder(tf.float32, shape=[None,2])
dataset = tf.data.Dataset.from_tensor_slices(x)


4 从生成器导入数据

我们也可以从一个生成器初始化一个数据集,当我们有一个长度不同的元素数组(例如一个序列)时,这种方法非常有用的:


sequence = np.array([[1],[2,3],[3,4]])
def generator():
    for el in sequence:
        yield el
dataset = tf.data.Dataset().from_generator(generator,
                                           output_types=tf.float32, 
                                           output_shapes=[tf.float32])


5创建迭代器(Iterator)

我们已经知道如何创建一个数据集,但是如何获取我们的数据呢? 那就必须使用迭代器,它使我们能够遍历数据集并找到数据的实际值。 有四种类型的迭代器。

1 One Shot迭代器

这是最简单的迭代器,请看下面的例子


x = np.random.sample((100,2))
# make a dataset from a numpy array
dataset = tf.data.Dataset.from_tensor_slices(x)
# create the iterator
iter = dataset.make_one_shot_iterator()


然后,您需要调用get_next()来获取包含你的数据的张量


...
# create the iterator
iter = dataset.make_one_shot_iterator()
el = iter.get_next()


我们可以运行el看到它的值


with tf.Session() as sess:
    print(sess.run(el)) # output: [ 0.42116176  0.40666069]


2 可初始化迭代器

如果我们要构建一个动态数据集,我们可以实时更改数据源,可以使用占位符创建数据集。然后我们可以使用feed-dict机制来初始化占位符。这是用一个可初始化的迭代器完成的。使用上一节的示例三


# using a placeholder
x = tf.placeholder(tf.float32, shape=[None,2])
dataset = tf.data.Dataset.from_tensor_slices(x)
data = np.random.sample((100,2))
iter = dataset.make_initializable_iterator() # create the iterator
el = iter.get_next()
with tf.Session() as sess:
    # feed the placeholder with data
    sess.run(iter.initializer, feed_dict={ x: data }) 
    print(sess.run(el)) # output [ 0.52374458  0.71968478]


我们调用make_initializable_iterator。 然后,在sess范围内,我们运行初始化操作来传递我们的数据,在这种情况下数据是一个随机的numpy数组。

想象一下,在实际场景中,我们有一个训练集和一个测试集:


train_data = (np.random.sample((100,2)), np.random.sample((100,1)))
test_data = (np.array([[1,2]]), np.array([[0]]))


我们想训练模型,然后在测试数据集上评估它,这可以通过在训练之后再次初始化迭代器来完成


# initializable iterator to switch between dataset
EPOCHS = 10
x, y = tf.placeholder(tf.float32, shape=[None,2]), tf.placeholder(tf.float32,
 shape=[None,1])
dataset = tf.data.Dataset.from_tensor_slices((x, y))
train_data = (np.random.sample((100,2)), np.random.sample((100,1)))
test_data = (np.array([[1,2]]), np.array([[0]]))
iter = dataset.make_initializable_iterator()
features, labels = iter.get_next()
with tf.Session() as sess:
#     initialise iterator with train data
    sess.run(iter.initializer, feed_dict={ x: train_data[0], 
y: train_data[1]})
    for _ in range(EPOCHS):
        sess.run([features, labels])
#     switch to test data
    sess.run(iter.initializer, feed_dict={ x: test_data[0], y: test_data[1]})
    print(sess.run([features, labels]))


3 重新初始化的迭代器

这个概念与上一个类似,我们要在数据之间进行动态切换。 但是,不是将新数据馈送到相同的数据集,而是切换数据集。和以前一样,我们要有一个训练数据集和一个测试数据集


# making fake data using numpy
train_data = (np.random.sample((100,2)), np.random.sample((100,1)))
test_data = (np.random.sample((10,2)), np.random.sample((10,1)))


我们可以创建两个数据集


# create two datasets, one for training and one for test
train_dataset = tf.data.Dataset.from_tensor_slices(train_data)
test_dataset = tf.data.Dataset.from_tensor_slices(test_data)


现在要使用一个技巧,即创建一个通用的迭代器


# create a iterator of the correct shape and type
iter = tf.data.Iterator.from_structure(train_dataset.output_types,
                                           train_dataset.output_shapes)


然后进行两次初始化操作:


# create the initialisation operations
train_init_op = iter.make_initializer(train_dataset)
test_init_op = iter.make_initializer(test_dataset)


我们像以前一样得到下一个元素


features, labels = iter.get_next()


现在,我们可以使用我们的会话直接运行两个初始化操作。综合起来,我们得到:


# Reinitializable iterator to switch between Datasets
EPOCHS = 10
# making fake data using numpy
train_data = (np.random.sample((100,2)), np.random.sample((100,1)))
test_data = (np.random.sample((10,2)), np.random.sample((10,1)))
# create two datasets, one for training and one for test
train_dataset = tf.data.Dataset.from_tensor_slices(train_data)
test_dataset = tf.data.Dataset.from_tensor_slices(test_data)
# create a iterator of the correct shape and type
iter = tf.data.Iterator.from_structure(train_dataset.output_types,
                                           train_dataset.output_shapes)
features, labels = iter.get_next()
# create the initialisation operations
train_init_op = iter.make_initializer(train_dataset)
test_init_op = iter.make_initializer(test_dataset)
with tf.Session() as sess:
    sess.run(train_init_op) # switch to train dataset
    for _ in range(EPOCHS):
        sess.run([features, labels])
    sess.run(test_init_op) # switch to val dataset
    print(sess.run([features, labels]))


4 可馈送的迭代器(Feedable Iterator)

老实说,我不认为这个方法是有用的。它不是在数据集之间切换,而是在迭代器之间切换,例如,您可以从make_one_shot_iterator()获得一个迭代器,而从make_initializable_iterator()获得另一个迭代器。

使用数据

 

在前面的例子中,我们使用会话来打印数据集中下一个元素的值


...
next_el = iter.get_next()
...
print(sess.run(next_el)) # will output the curr


为了将数据传递给模型,我们必须通过张量从get_next()生成。在下面的代码片段中,我们有一个包含两个numpy数组的数据集,使用第一节中的示例。注意我们需要将.random.sample封装到另一个numpy数组中,以添加一个维度,我们需要批量处理数据


# using two numpy arrays
features, labels = (np.array([np.random.sample((100,2))]), 
                    np.array([np.random.sample((100,1))]))
dataset = tf.data.Dataset.from_tensor_slices((features,labels)).
repeat().batch(BATCH_SIZE)


然后像往常一样,我们创建一个迭代器


iter = dataset.make_one_shot_iterator()
x, y = iter.get_next()


我们做一个模型,一个简单的神经网络


# make a simple model
net = tf.layers.dense(x, 8) # pass the first value from iter.get_next() 
as input
net = tf.layers.dense(net, 8)
prediction = tf.layers.dense(net, 1)
loss = tf.losses.mean_squared_error(prediction, y) # pass the second value 
from iter.get_net() as label
train_op = tf.train.AdamOptimizer().minimize(loss)


我们直接使用iter.get_next()中的张量作为第一层的输入,并作为损失函数的标签。 一起封装:


EPOCHS = 10
BATCH_SIZE = 16
# using two numpy arrays
features, labels = (np.array([np.random.sample((100,2))]), 
                    np.array([np.random.sample((100,1))]))
dataset = tf.data.Dataset.from_tensor_slices((features,labels)).repeat().
batch(BATCH_SIZE)
iter = dataset.make_one_shot_iterator()
x, y = iter.get_next()
# make a simple model
net = tf.layers.dense(x, 8, activation=tf.tanh) # pass the first value 
from iter.get_next() as input
net = tf.layers.dense(net, 8, activation=tf.tanh)
prediction = tf.layers.dense(net, 1, activation=tf.tanh)
loss = tf.losses.mean_squared_error(prediction, y) # pass the second value 
from iter.get_net() as label
train_op = tf.train.AdamOptimizer().minimize(loss)
with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    for i in range(EPOCHS):
        _, loss_value = sess.run([train_op, loss])
        print("Iter: {}, Loss: {:.4f}".format(i, loss_value))

https://www.xamrdz.com/lan/5sd1961260.html

相关文章: