tensorflow读取mysql_TensorFlow读取数据的三种方法

placehold feed_dict:从内存中读取数据,占位符填充数据

queue队列:从硬盘读取数据

Dataset:同时支持内存和硬盘读取数据

placehold-feed_dict

先用placehold 占位数据,在Graph中读取数据,数据直接内嵌到Graph中,然后当Graph传入Session是,用feed_dict喂补数据。当数据量比较大的时候,Graph的传输会遇到效率底下问题,特别是数据转换。

importtensorflow as tfimportlibrosa#把数据加载在Graph中

x1 = librosa.load("temp_1.wav", sr=16000)

x2= librosa.load("temp_2.wav", sr=16000)

y=tf.add(x1, x2)

with tf.Session() as sess:print(sess.run(y))

queue队列

如果我们的数据读取算法没有设计多线程的话(即单线程),由于读取数据和处理数据在同一个进程是有先后关系的,意味着数据处理完后必须花时间读取数据,然后才能进行计算处理。这样的一来GPU并没有高效的专一做一件事情,从而大大的降低的效率,queue创建多线程彻底的解决了这个问题。

tensorflow中为了充分的利用时间,减少GPU等待的空闲时间,使用了两个线程(文件名队列和内存队列)分别执行数据读入和数据计算。文件名队列源源不断的将硬盘中的图片数据,内存队列负责给GPU送数据,所需数据直接从内存队列中获取。两个线程之间互不干扰,同时运行。

tensorflow读取mysql_TensorFlow读取数据的三种方法_第1张图片

因此 tensorflow 在内存队列之前,还要使用tf.train.slice_input_producer函数,创建一个文件名队列,文件名队列存放的是参与训练的文件名,要训练N个epoch,则文件名队列中就含有N个批次的所有文件名。

tf.train.slice_in put_producer()

使用到 tf.train.slice_input_producer 函数创建文件名队列。在N个epoch的文件名最后是一个结束标志,当tf读到这个结束标志的时候,会抛出一个OutofRange 的异常,外部捕获到这个异常之后就可以结束程序了。

slice_input_producer(tensor_list,

num_epochs=None,

shuffle=True,

seed=None,

capacity=32,

shared_name=None,

name=None)

返回tensor生成器,作用是按照设定,每次从一个tensor_list中按顺序或者随机抽取出一个tensor放入文件名队列。

参数:

tensor_list:tensor的列表,表中tensor的第一维度的值必须相等,即个数必须相等,有多少个图像,就应该有多少个对应的标签

num_epochs: 迭代的次数,num_epochs=None,生成器可以无限次遍历tensor列表;num_epochs=N,生成器只能遍历tensor列表N次

shuffle: bool,是否打乱样本的顺序。一般情况下,如果shuffle=True,生成的样本顺序就被打乱了,在批处理的时候不需要再次打乱样本,使用 tf.train.batch函数就可以了;如果shuffle=False,就需要在批处理时候使用 tf.train.shuffle_batch函数打乱样本

seed: 生成随机数的种子,shuffle=True的情况下才有用

capacity:队列容量的大小,为整数

shared_name:可选参数,如果设置一个"shared_name",则在不同的上下文Session中可以通过这个名字共享生成的tensor

name:设置操作的名称

如果tensor_list=[data, lable],其中data.shape=(4000,10),label.shape=[4000,2],则生成器生成的第一个队列

input_quenue[0].shape=(10,)

input_quenue[1].shape=(2,)

要真正将文件放入文件名队列,还需要调用tf.train.start_queue_runners 函数来启动执行文件名队列填充的线程,之后计算单元才可以把数据读出来,否则文件名队列为空的,计算单元就会处于一直等待状态,导致系统阻塞。

importtensorflow as tf

images= ["img1", "img2", "img3", "img4", "img5"]

labels= [1, 2, 3, 4, 5]

epoch_num= 8

#文件名队列

input_queue = tf.train.slice_input_producer([images, labels], num_epochs=None, shuffle=False)

with tf.Session() as sess:

sess.run(tf.global_variables_initializer())

coord= tf.train.Coordinator() #创建一个协调器,管理线程

#启动QueueRunner, 执行文件名队列的填充

threads = tf.train.start_queue_runners(sess=sess, coord=coord)for i inrange(epoch_num):

k=sess.run(input_queue)print(i, k)#0[b'img1', 1]

#1[b'img2', 2]

#2[b'img3', 3]

#3[b'img4', 4]

#4[b'img5', 5]

#5[b'img1', 1]

#6[b'img2', 2]

#7[b'img3', 3]

coord.request_stop()

coord.join(threads)

tf.train.batch & tf.train.shuffle_batch()

tf.train.batch(

tensors_list,

batch_size,

num_threads=1,

capacity=32,

enqueue_many=False,

shapes=None,

dynamic_pad=False,

allow_smaller_final_batch=False,

shared_name=None,

name=None

)

tf.train.batch & tf.train.shuffle_batch()这两个函数的参数是一样的,下面我以tf.train.batch讲解为例

tf.train.batch是一个tensor队列生成器,作用是按照给定的tensor顺序,把batch_size个tensor推送到文件队列,作为训练一个batch的数据,等待tensor出队执行计算。

tensors:一个列表或字典的tensor用来进行入队

batch_size: 每次从队列中获取出队数据的数量

num_threads:用来控制入队tensors线程的数量,如果num_threads大于1,则batch操作将是非确定性的,输出的batch可能会乱序

capacity: 设置队列中元素的最大数量

enqueue_many: 在第一个参数tensors中的tensor是否是单个样本

shapes: 可选,每个样本的shape,默认是tensors的shape

dynamic_pad: Boolean值;允许输入变量的shape,出队后会自动填补维度,来保持与batch内的shapes相同

allow_smaller_final_batch: 设置为True,表示在tensor队列中剩下的tensor数量不够一个batch_size的情况下,允许最后一个batch的数量少于batch_size进行出队, 设置为False,小于batch_size的样本不会做出队处理

shared_name: 可选参数,设置生成的tensor序列在不同的Session中的共享名称;

name: 操作的名称;

以下举例: 一共有5个样本,设置迭代次数是2次,每个batch中含有3个样本,不打乱样本顺序:

importtensorflow as tfimportnumpy as np

sample_num= 5 #样本个数

epoch_num = 2 #设置迭代次数

batch_size = 3 #设置一个批次中包含样本个数

batch_total = int(sample_num / batch_size) + 1 #计算每一轮epoch中含有的batch个数

#生成4个数据和标签

def generate_data(sample_num=sample_num):

labels=np.asarray(range(0, sample_num))

images= np.random.random([sample_num, 224, 224, 3])print("image size {}, label size: {}".format(images.shape, labels.shape))#image size (5, 224, 224, 3), label size: (5,)

returnimages, labelsdef get_batch_data(batch_size=batch_size):

images, label=generate_data()

images= tf.cast(images, tf.float32) #数据类型转换为tf.float32

label = tf.cast(label, tf.int32) #数据类型转换为tf.int32

#从tensor列表中按顺序或随机抽取一个tensor,主要代码

input_queue = tf.train.slice_input_producer([images, label], shuffle=False)

image_batch, label_batch= tf.train.batch(input_queue, batch_size=batch_size,

num_threads=1, capacity=64)returnimage_batch, label_batch

image_batch, label_batch= get_batch_data(batch_size=batch_size)

with tf.Session() as sess:

coord=tf.train.Coordinator()

threads=tf.train.start_queue_runners(sess, coord)try:for i in range(epoch_num): #每一轮迭代

print("** ** ** ** ** **")for j in range(batch_total): #遍历每一个batch

#获取每一个batch中batch_size个样本和标签

image_batch_v, label_batch_v =sess.run([image_batch, label_batch])#for k in

print(image_batch_v.shape, label_batch_v)#** ** ** ** ** **

#(3, 224, 224, 3) [0 1 2]

#(3, 224, 224, 3) [3 4 0]

#** ** ** ** ** **

#(3, 224, 224, 3) [1 2 3]

#(3, 224, 224, 3) [4 0 1]

excepttf.errors.OutOfRangeError:print("done")finally:

coord.request_stop()

coord.join(threads)

与tf.train.batch函数相对的还有一个tf.train.shuffle_batch函数,两个函数作用一样,都是生成一定数量的tensor,组成训练一个batch需要的数据集,区别是tf.train.shuffle_batch会打乱样本顺序。

下面这段代码和上面想表达的相同,但是如果tf.train.slice_input_producer中设置了epoch,则后面训练的时候,不需要for循环epoch,只需要设置coord.should_stop。

importnumpy as npimporttensorflow as tfdefnext_batch():

datasets= np.asarray(range(0, 20))

input_queue= tf.train.slice_input_producer([datasets], shuffle=False, num_epochs=1)

data_batchs= tf.train.batch(input_queue, batch_size=5, num_threads=1,

capacity=20, allow_smaller_final_batch=False)returndata_batchsif __name__ == "__main__":

data_batchs=next_batch()

sess=tf.Session()

sess.run(tf.initialize_local_variables())

coord= tf.train.Coordinator() #创建一个协调器,管理线程

threads = tf.train.start_queue_runners(sess, coord) #启动线程

try:while notcoord.should_stop():

data=sess.run([data_batchs])print(data)#[array([0, 1, 2, 3, 4])]

#[array([5, 6, 7, 8, 9])]

#[array([10, 11, 12, 13, 14])]

#[array([15, 16, 17, 18, 19])]

#complete

excepttf.errors.OutOfRangeError:print("complete")finally:

coord.request_stop()

coord.join(threads)

sess.close()

注意:tf.train.batch这个函数的实现是使用queue,需要使用tf.initialize_local_variables(),如果使用tf.global_varialbes_initialize()时,会报: Attempting to use uninitialized value 。并不是tf.initialize_local_variables()替换了tf.global_varialbes_initialize(),而是他们有不同的功能,并要的时候都要使用

batch的使用方法,实现感知机。

8f900a89c6347c561fdf2122f13be562.png

961ddebeb323a10fe0623af514929fc1.png

importtensorflow as tfimportscipy.io as siodefget_Batch(data, label, batch_size):print(data.shape, label.shape)

input_queue= tf.train.slice_input_producer([data, label], num_epochs=1, shuffle=True, capacity=32)

x_batch, y_batch= tf.train.batch(input_queue, batch_size=batch_size, num_threads=1, capacity=32,

allow_smaller_final_batch=False)returnx_batch, y_batch

data= sio.loadmat('data.mat')

train_x= data['train_x']

train_y= data['train_y']

test_x= data['test_x']

test_y= data['test_y']

x= tf.placeholder(tf.float32, [None, 10])

y= tf.placeholder(tf.float32, [None, 2])

w= tf.Variable(tf.truncated_normal([10, 2], stddev=0.1))

b= tf.Variable(tf.truncated_normal([2], stddev=0.1))

pred= tf.nn.softmax(tf.matmul(x, w) +b)

loss= tf.reduce_mean(-tf.reduce_sum(y * tf.log(pred), reduction_indices=[1]))

optimizer= tf.train.AdamOptimizer(2e-5).minimize(loss)

correct_prediction= tf.equal(tf.argmax(y, 1), tf.argmax(pred, 1))

accuracy= tf.reduce_mean(tf.cast(correct_prediction, tf.float32), name='evaluation')

x_batch, y_batch= get_Batch(train_x, train_y, 1000)#训练

with tf.Session() as sess:#初始化参数

sess.run(tf.global_variables_initializer())

sess.run(tf.local_variables_initializer())#开启协调器

coord =tf.train.Coordinator()#使用start_queue_runners 启动队列填充

threads =tf.train.start_queue_runners(sess, coord)

epoch=0try:while notcoord.should_stop():#获取训练用的每一个batch中batch_size个样本和标签

data, label =sess.run([x_batch, y_batch])

sess.run(optimizer, feed_dict={x: data, y: label})

train_accuracy=accuracy.eval({x: data, y: label})

test_accuracy=accuracy.eval({x: test_x, y: test_y})print("Epoch %d, Training accuracy %g, Testing accuracy %g" %(epoch, train_accuracy, test_accuracy))

epoch= epoch + 1

except tf.errors.OutOfRangeError: #num_epochs 次数用完会抛出此异常

print("---Train end---")finally:#协调器coord发出所有线程终止信号

coord.request_stop()print('---Programm end---')

coord.join(threads)#把开启的线程加入主线程,等待threads结束

View Code

tf.data.Dataset

官方推荐用tf.data.Dateset,看到这个是不是有点心累,哈哈哈。

Tensorflow中之前主要用的数据读取方式主要有:

1、建立placeholder,然后使用feed_dict将数据feed进placeholder进行使用。使用这种方法十分灵活,可以一下子将所有数据读入内存,然后分batch进行feed;也可以建立一个Python的generator,一个batch一个batch的将数据读入,并将其feed进placeholder。这种方法很直观,用起来也比较方便灵活jian,但是这种方法的效率较低,难以满足高速计算的需求。

2、使用TensorFlow的QueueRunner,通过一系列的Tensor操作,将磁盘上的数据分批次读入并送入模型进行使用。这种方法效率很高,但因为其牵涉到Tensor操作,不够直观,也不方便调试,所有有时候会显得比较困难。使用这种方法时,常用的一些操作包括tf.TextLineReader,tf.FixedLengthRecordReader以及tf.decode_raw等等。如果需要循环,条件操作,还需要使用TensorFlow的tf.while_loop,tf.case等操作。

3、上面的方法我觉得已经要被tensorflow放弃了,现在官方推荐用tf.data.Dataset模块,使其数据读入的操作变得更为方便,而支持多线程(进程)的操作,也在效率上获得了一定程度的提高。

tensorflow读取mysql_TensorFlow读取数据的三种方法_第2张图片

tf.data.Dataset.from_tensor_slices

创建了一个dataset,这个dataset中含有5个元素[1.0, 2.0, 3.0, 4.0, 5.0],为了将5个元素取出,方法是从Dataset中示例化一个iterator,然后对iterator进行迭代。

importtensorflow as tfimportnumpy as np

dataset= tf.data.Dataset.from_tensor_slices(np.array([1.0, 2.0, 3.0, 4.0, 5.0]))

iterator= dataset.make_one_shot_iterator() #从dataset中实例化一个iterator,只能从头到尾取一次,指名了顺序

one_element = iterator.get_next() #从iterator中取一个元素

with tf.Session() as sess:try:for i in range(5):print(sess.run(one_element))except tf.errors.OutOfRangeError: #iterator迭代完会抛出此异常

print("数据迭代完了")

dataset = tf.data.Dataset.from_tensor_slices(np.random.uniform(size=(5, 2)))

数据的第一维度是个数,这个函数会切分第一维度,最后生成的dataset中含有5个元素,每个元素的形状是(2,)

dataset =tf.data.Dataset.from_tensor_slices(

{"a": np.array([1.0, 2.0, 3.0, 4.0, 5.0]),"b": np.random.uniform(size=(5, 2))

})

tf.data.Dataset.from_tensor_slices的参数,可以是列表也可以是字典,{"image": "image_tensor", "label": "label_tensor"}

Trainformation

Dataset支持一类特殊的操作Trainformation,即一个Dataset通过Trainformation变成一个新的Dataset,可以理解为数据变换,对Dataset中的元素做变换(打乱、生成epoch...等操作)。

常用的Trainformation有:

map

batch

shuffle

repeat

1、dataset.map

这个函数很重要也经常用到,他接收一个函数,Dataset中的每一个元素都会被当做这个函数的输入,并将函数返回值作为新的Dataset,

例如:对dataset中每一个元素的值加1

dataset = tf.data.Dataset.from_tensor_slices(np.array([1.0, 2.0, 3.0, 4.0, 5.0]))

dataset= dataset.map(lambda x: x + 1) #2.0, 3.0, 4.0, 5.0, 6.0

2、dataset.batch

batch就是将多个元素组合成batch,如下面的程序将dataset中的每个元素组成了大小为6的batch:

#创建0-10的数据集,每个6个数取一个batch。

dataset = tf.data.Dataset.range(10).batch(6)

iterator=dataset.make_one_shot_iterator()

next_element=iterator.get_next()

with tf.Session() as sess:for i in range(2):

value=sess.run(next_element)print(value)#[0 1 2 3 4 5]#[6 7 8 9]

tensorflow很好的帮我们自动处理最后的一个batch,但是,上面的for循环次数超过2,会报错,超过范围了,没值可取。

4、datasets.repeat

repeat的功能就是将整个序列重复多次,主要用来处理机器学习中的epoch,假设原先的数据是一个epoch,使用repeat(5)就可以将之变成5个epoch,当for循环取值超过一个epoch的时候,会开始下一个epoch。

dataset = tf.data.Dataset.range(10).batch(6)

dataset= dataset.repeat(2)

iterator=dataset.make_one_shot_iterator()

next_element=iterator.get_next()

with tf.Session() as sess:for i in range(4):

value=sess.run(next_element)print(value)#[0 1 2 3 4 5]#[6 7 8 9]#[0 1 2 3 4 5]#[6 7 8 9]

repeat只是将数据集重复了指定的次数,但是如果for循环大于4还是会报错,所以简单的方法是repeat不设次数,生成的序列就会无限重复下去,没有结束,因此也不会抛出tf.errors.OutOfRangeError异常:dataset = dataset.repeat()

dataset = tf.data.Dataset.range(10).batch(6)

dataset=dataset.repeat()

iterator=dataset.make_one_shot_iterator()

next_element=iterator.get_next()

with tf.Session() as sess:for i in range(6):

value=sess.run(next_element)print(value)#[0 1 2 3 4 5]#[6 7 8 9]#[0 1 2 3 4 5]#[6 7 8 9]#[0 1 2 3 4 5]#[6 7 8 9]

3、dataset.shuffle

打乱dataset中的元素,它有一个参数buffer_size表示打乱顺序,buffer_size=1表示不打乱顺序,buffer_size越大,打乱程度越大,不设置会报错:

dataset = dataset.shuffle(buffer_size=10000)

shuffle打乱顺序很重要,建议先打乱顺序,再batch取值,因为如果是先执行batch操作的话,那么此时就只是对batch进行shuffle,而batch里面的数据顺序依旧是有序的,那么随机程度会减弱。

建议:dataset = tf.data.Dataset.range(10).shuffle(10).batch(6)

读入磁盘图片与对应label

我们可以来考虑一个简单,但同时也非常常用的例子:读入磁盘中的图片和图片相应的label,并将其打乱,组成batch_size=32的训练样本。在训练时重复10个epoch。

#函数的功能时将filename对应的图片文件读进来,并缩放到统一的大小

def_parse_function(filename, label):

image_string=tf.read_file(filename)

image_decoded=tf.image.decode_image(image_string)

image_resized= tf.image.resize_images(image_decoded, [28, 28])returnimage_resized, label#图片文件的列表

filenames = tf.constant(["/var/data/image1.jpg", "/var/data/image2.jpg", ...])#label[i]就是图片filenames[i]的label

labels = tf.constant([0, 37, ...])#filename是图片的文件名,label是图片对应的标签

dataset =tf.data.Dataset.from_tensor_slices((filenames, labels))#将filename对应的图片读入,并缩放为28x28的大小,

dataset =dataset.map(_parse_function)#在每个epoch内将图片打乱组成大小为32的batch,并重复10次。#image_resized_batch(32, 28, 28, 3),label_batch(32, )

dataset = dataset.shuffle(buffer_size=1000).batch(32).repeat(10)

Dataset的其他创建方法

除了tf.data.Dataset.from_tensor_slices外,目前Dataset API还提供了另外三种创建Dataset的方式:

tf.data.TextLineDataset():这个函数的输入是一个文件的列表,输出是一个dataset。dataset中的每一个元素就对应了文件中的一行。可以使用这个函数来读入CSV文件。

tf.data.FixedLengthRecordDataset():这个函数的输入是一个文件的列表和一个record_bytes,之后dataset的每一个元素就是文件中固定字节数record_bytes的内容。通常用来读取以二进制形式保存的文件,如CIFAR10数据集就是这种形式。

tf.data.TFRecordDataset():顾名思义,这个函数是用来读TFRecord文件的,dataset中的每一个元素就是一个TFExample。

iterator

在非Eager模式下,最简单的创建Iterator的方法就是通过dataset.make_one_shot_iterator()来创建一个one_shot_iterator。除了这种iterator外,还有三个更复杂的Iterator,即:

make_initializable_iterator

make_reinitializable_iterator

make_feedable_iterator

initializable_iterator必须要在使用前通过sess.run()来初始化。使用initializable iterator,可以将placeholder-feed_dict代入Iterator中,这可以方便我们通过参数快速定义新的Iterator。一个简单的initializable_iterator使用示例:

limit = tf.placeholder(dtype=tf.int32, shape=[])#此时的limit相当于一个“可变参数”,它规定了Dataset中数的“上限”。

dataset = tf.data.Dataset.from_tensor_slices(tf.range(start=0, limit=limit))

iterator=dataset.make_initializable_iterator()

next_element=iterator.get_next()

with tf.Session() as sess:#初始化并feed initializable_iterator

sess.run(iterator.initializer, feed_dict={limit: 10})for i in range(10):

value=sess.run(next_element)assert i == value

initializable_iterator还有一个功能:读入较大的数组。

在使用tf.data.Dataset.from_tensor_slices(array)时,实际上发生的事情是将array作为一个tf.constants保存到了计算图中。当array很大时,会导致计算图变得很大,给传输、保存带来不便。这时,我们可以用一个placeholder取代这里的array,并使用initializable_iterator,只在需要时将array传进去,这样就可以避免把大数组保存在图里,示例代码为(来自官方例程):

#读取numpy数据

with np.load("/var/data/training_data.npy") as data:

features= data["features"]

labels= data["labels"]#查看图像和标签维度是否保持一致

assert features.shape[0] ==labels.shape[0]#创建placeholder

features_placeholder =tf.placeholder(features.dtype, features.shape)

labels_placeholder=tf.placeholder(labels.dtype, labels.shape)#创建dataset

dataset =tf.data.Dataset.from_tensor_slices((features_placeholder, labels_placeholder))#批量读取,打散数据,repeat()

dataset = dataset.shuffle(20).batch(5).repeat()#[Other transformations on `dataset`...]

dataset_other =...

iterator=dataset.make_initializable_iterator()

data_element=iterator.get_nex()

sess=tf.Session()#注意迭代器要在循环语句之前初始化

sess.run(iterator.initializer, feed_dict={features_placeholder: features,

labels_placeholder: labels})for e inrange(EPOCHS):for step inrange(num_batches):

x_batch, y_batch=sess.run(data_element)

y_pred=model(x_batch)

...

...

sess.close()

自定义方法

上面几种方法,都是官方可调用的方法,如果大家想自定义可以参考我的代码,这段代码是从tensorflow教程中偷来的。代码太长我的折叠起来了哈,这段代码大家可以直接拿去用(亲测可用)。

8f900a89c6347c561fdf2122f13be562.png

961ddebeb323a10fe0623af514929fc1.png

importnumpy as npfrom tensorflow.contrib.learn.python.learn.datasets importbasefrom tensorflow.python.framework importdtypesclassDataSet(object):def __init__(self,

datapoints,

labels,

fake_data=False,

one_hot=False,

dtype=dtypes.float32):"""Construct a DataSet.

one_hot arg is used only if fake_data is true. `dtype` can be either

`uint8` to leave the input as `[0, 255]`, or `float32` to rescale into

`[0, 1]`."""dtype=dtypes.as_dtype(dtype).base_dtypeif dtype not in(dtypes.uint8, dtypes.float32):raise TypeError('Invalid image dtype %r, expected uint8 or float32' %dtype)if labels isNone:

labels=np.zeros((len(datapoints),))iffake_data:

self._num_examples= 10000self.one_hot=one_hotelse:assert datapoints.shape[0] ==labels.shape[0], ('datapoints.shape: %s labels.shape: %s' %(datapoints.shape, labels.shape))

self._num_examples=datapoints.shape[0]

self._datapoints=datapoints

self._labels=labels

self._epochs_completed=0

self._index_in_epoch=0

@propertydefdatapoints(self):returnself._datapoints

@propertydeflabels(self):returnself._labels

@propertydefnum_examples(self):returnself._num_examples

@propertydefepochs_completed(self):returnself._epochs_completeddef next_batch(self, batch_size, fake_data=False, shuffle=True):"""Return the next `batch_size` examples from this data set."""

iffake_data:

fake_image= [1] * 784

ifself.one_hot:

fake_label= [1] + [0] * 9

else:

fake_label=0return [fake_image for _ inrange(batch_size)], [

fake_labelfor _ inrange(batch_size)

]

start=self._index_in_epoch#Shuffle for the first epoch

if self._epochs_completed == 0 and start == 0 andshuffle:

perm0=np.arange(self._num_examples)

np.random.shuffle(perm0)

self._datapoints=self.datapoints[perm0]

self._labels=self.labels[perm0]#Go to the next epoch

if start + batch_size > self._num_examples: #如果初始epoch+batch_size(0+128)>样本总数

#Finished epoch

self._epochs_completed += 1

#Get the rest examples in this epoch

rest_num_examples = self._num_examples -start

datapoints_rest_part=self._datapoints[start:self._num_examples]

labels_rest_part=self._labels[start:self._num_examples]#Shuffle the data

ifshuffle:

perm=np.arange(self._num_examples)

np.random.shuffle(perm)

self._datapoints=self.datapoints[perm]

self._labels=self.labels[perm]#Start next epoch

start =0

self._index_in_epoch= batch_size -rest_num_examples

end=self._index_in_epoch

datapoints_new_part=self._datapoints[start:end]

labels_new_part=self._labels[start:end]return np.concatenate((datapoints_rest_part, datapoints_new_part), axis=0), np.concatenate(

(labels_rest_part, labels_new_part), axis=0)else:

self._index_in_epoch+=batch_size

end=self._index_in_epochreturn self._datapoints[start:end], self._labels[start:end]

View Code

想要真正弄懂建议自己写一个,虽然上面那个已经写的非常完美了。

要求1:每一个epoch之后都要shuff数据,

要求2:训练数据集不用去batch_size的整数。

打乱顺序

defshuffle_set(train_image, train_label, test_image, test_label):

train_row=range(len(train_label))

random.shuffle(train_row)

train_image=train_image[train_row]

train_label=train_label[train_row]

test_row=range(len(test_label))

random.shuffle(test_row)

test_image=test_image[test_row]

test_label=test_label[test_row]return train_image, train_label, test_image, test_label

取下一个batch

defget_batch(image, label, batch_size, now_batch, total_batch):if now_batch < total_batch-1:

image_batch= image[now_batch*batch_size:(now_batch+1)*batch_size]

label_batch= label[now_batch*batch_size:(now_batch+1)*batch_size]else:

image_batch= image[now_batch*batch_size:]

label_batch= label[now_batch*batch_size:]return image_batch, label_batch

epoch、 iteration和batchsize的区别:epoch是周期的意思,代表要重复训练epoch次,每个epoch包括样本数/batch个iteration

总结

本文主要介绍了tensortlfow三种读取数据方式的,placehold-feed_dict,queue队列还介绍了Dataset API的基本架构:Dataset类和Iterator类,以及它们的基础使用方法。

在非Eager模式下,Dataset中读出的一个元素一般对应一个batch的Tensor,我们可以使用这个Tensor在计算图中构建模型。

在Eager模式下,Dataset建立Iterator的方式有所不同,此时通过读出的数据就是含有值的Tensor,方便调试。

参考文献

你可能感兴趣的:(tensorflow读取mysql_TensorFlow读取数据的三种方法)