TensorFlow神经网络如何实现自己数据的Batch_Size

目录

1.遇到的问题

2.解决的办法
1.遇到的问题

自己在运行神经网络时，刚开始的时候数据样本较少，可以直接输入到神经网络输入层。但是处理大样本数据有时候才能真正体现出数据的本来面目以及神经网络的优势，于是考虑增大样本个数。
但是当样本个数增大到以万为单位时发现运行时间变长，搜索解决办法，发现可以通过Batch_Size将自己的数据分开成几个批次，一批一批喂给神经网络。
通过一些视频的学习发现别人直接.train.next_batch(100)就可以实现，而自己的数据集是numpy形式的trainx，trainy。下面就是自己的解决办法。诚然我只是学习如何实现，但是对于内部细节仍是不太了解。
2.解决的办法

实现Batch_Size主要是通过两个tf自带的函数
tf.train.slice_input_producer（）
tf.train.batch（）
接下来是如何实现自己的数据的Batch_Size
首先：需要定义一个函数，将上述两个代码写道自己定义的函数当中。
#数据批处理
def get_Batch(datax, datay, batch_size):        
    input_queue = tf.train.slice_input_producer([datax, datay], num_epochs=None, shuffle=False, 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)    
    return x_batch, y_batch
这里提醒一下：shuffle= False是顺序提取批尺寸数据，shuffle= True是随机提取批尺寸数据。可以根据自己需要进行选择。
接下来：调用上述函数就可以将自己的数据实现一批一批的形式，但是数据的形式将成为TF的格式，在喂入神经网络中还需要再处理（最后一步会讲解如何在处理）。
#datax_norm 和 datay_norm是自己的全部数据
#x_batch 和 y_batch是batch_size的一段一段数据
batch_size = 2000
x_batch, y_batch = get_Batch(datax_norm, datay_norm, batch_size)
最后一步：如何输入到神经网络中。
training_epochs = 2000
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)
    try:
        a = 0
        for epoch in range(training_epochs):
            total_batch = 5500 // batch_size +1
            for i in range(total_batch):
                a += 1
                batch_x, batch_y = sess.run([x_batch, y_batch])
                sess.run(train_step,feed_dict={xs:batch_x,ys:batch_y,keep_prob:0.7})
                lost = sess.run(loss,feed_dict={xs:batch_x,ys:batch_y,keep_prob:1})
                if a%100 == 0:
                    print(a,sess.run(loss,feed_dict={xs:batch_x,ys:batch_y,keep_prob:1}))
                if lost < 0.15:
                    print("结束")
                    print(a,sess.run(loss,feed_dict={xs:batch_x,ys:batch_y,keep_prob:1}))
                    break
            else: continue
            break
    except tf.errors.OutOfRangeError:  # num_epochs 次数用完会抛出此异常
        print("---Train end---")
    finally:
        # 协调器coord发出所有线程终止信号
        coord.request_stop()
        print('---Programm end---')
    coord.join(threads)  # 把开启的线程加入主线程，等待threads结束
    saver = tf.train.Saver()
    saver.save(sess,data_path)#储存模型
上述代码就可以实现神经网络自己数据的Batch_Size。
简单讲解一下。
#这一步就是对上述数据的在处理，
#通过这样的方式，可以将数据转换成np形式
 batch_x, batch_y = sess.run([x_batch, y_batch])
#以下内容是为了启动和关闭协调器，是必须要存在的步骤。
 # 开启协调器
 coord = tf.train.Coordinator()
 # 使用start_queue_runners 启动队列填充
 threads = tf.train.start_queue_runners(sess, coord)
  
  finally:
        # 协调器coord发出所有线程终止信号
        coord.request_stop()
        print('---Programm end---')
    coord.join(threads)  # 把开启的线程加入主线程，等待threads结束
   
下面的内容是真正开始一批一批的训练自己的数据
 try:
        a = 0
        for epoch in range(training_epochs):
            total_batch = 5500 // batch_size +1
            for i in range(total_batch):
                a += 1
                batch_x, batch_y = sess.run([x_batch, y_batch])
                sess.run(train_step,feed_dict={xs:batch_x,ys:batch_y,keep_prob:0.7})
                lost = sess.run(loss,feed_dict={xs:batch_x,ys:batch_y,keep_prob:1})
                if a%100 == 0:
                    print(a,sess.run(loss,feed_dict={xs:batch_x,ys:batch_y,keep_prob:1}))
                if lost < 0.15:
                    print("结束")
                    print(a,sess.run(loss,feed_dict={xs:batch_x,ys:batch_y,keep_prob:1}))
                    break
            else: continue
            break
#这个代码相当于运行全部数据时迭代的次数
for epoch in range(training_epochs):
#这个代码是将自己的数据分成几批，5500是我数据的行数，
#当数据是整除时不需要+1，比如我选一批500，那么数据会划分11份，
#但是我要选600，数据会划分9份还剩100，如果想要100也参与训练，
#就可以通过+1实现，而这+1的一份也是600行数据，
#它是选完最后100个之后又重新从头开始选取500个。
 total_batch = 5500 // batch_size +1
#这个代码的意思是训练每批的数据，比如上述的11次，
#那就会在这个循环里循环11次将所有的数据进行训练，
#所有数据训练完之后再训练直到迭代次数达到自己上述
#所列的training_epochs次数或者损失函数达到自己
#想要的要求跳出循环结束训练。
for i in range(total_batch):
                a += 1
                batch_x, batch_y = sess.run([x_batch, y_batch])
                sess.run(train_step,feed_dict={xs:batch_x,ys:batch_y,keep_prob:1})
                lost = sess.run(loss,feed_dict={xs:batch_x,ys:batch_y,keep_prob:1})
   
以上是自己再用神经网络处理自己数据时面对的问题以及解决的办法，如果有理解不正确的地方，还希望大佬批评指正，如果有疑问请留言，看到留言后我会及时回复。

在上一篇文章tensorflow入门：tfrecord 和tf.data.TFRecordDataset里，讲到了使用如何使用tf.data.TFRecordDatase来对tfrecord文件进行batch读取，即使用dataset的batch方法进行；但如果每条数据的长度不一样（常见于语音、视频、NLP等领域），则不能直接用batch方法获取数据，这时则有两个解决办法：
1.在把数据写入tfrecord时，先把数据pad到统一的长度再写入tfrecord；这个方法的问题在于：若是有大量数据的长度都远远小于最大长度，则会造成存储空间的大量浪费。
--------------------------------------------------------------------------------------------------------------
2.使用dataset中的padded_batch方法来进行，参数padded_shapes #指明每条记录中各成员要pad成的形状，成员若是scalar，则用[]，若是list，则用[mx_length]，若是array，则用[d1,...,dn]，假如各成员的顺序是scalar数据、list数据、array数据，则padded_shapes=([], [mx_length], [d1,...,dn])；该方法的函数说明如下：
padded_batch(
    batch_size,
    padded_shapes,
    padding_values=None    #默认使用各类型数据的默认值，一般使用时可忽略该项
)
使用mnist数据来举例说明，首先在把mnist写入tfrecord之前，把mnist数据进行更改，以使得每个mnist图像的大小不等，如下：
import tensorflow as tf
from tensorflow.contrib.learn.python.learn.datasets.mnist import read_data_sets

mnist = read_data_sets("MNIST_data/", one_hot=True)


def get_tfrecords_example(feature, label):
	tfrecords_features = {}
	feat_shape = feature.shape
	tfrecords_features['feature'] = tf.train.Feature(float_list=tf.train.FloatList(value=feature))
	tfrecords_features['shape'] = tf.train.Feature(int64_list=tf.train.Int64List(value=list(feat_shape)))
	tfrecords_features['label'] = tf.train.Feature(float_list=tf.train.FloatList(value=label))
	return tf.train.Example(features=tf.train.Features(feature=tfrecords_features))


def make_tfrecord(data, outf_nm='mnist-train'):
	feats, labels = data
	outf_nm += '.tfrecord'
	tfrecord_wrt = tf.python_io.TFRecordWriter(outf_nm)
	ndatas = len(labels)
	print(feats[0].dtype, feats[0].shape, ndatas)
	assert len(labels[0]) > 1
	for inx in range(ndatas):
		ed = random.randint(0,3)  #随机丢掉几个数据点，以使长度不等
		exmp = get_tfrecords_example(feats[inx][:-ed], labels[inx])
		exmp_serial = exmp.SerializeToString()
		tfrecord_wrt.write(exmp_serial)
	tfrecord_wrt.close()

import random
nDatas = len(mnist.train.labels)
inx_lst = range(nDatas)
random.shuffle(inx_lst)
random.shuffle(inx_lst)
ntrains = int(0.85*nDatas)

# make training set
data = ([mnist.train.images[i] for i in inx_lst[:ntrains]], \
	[mnist.train.labels[i] for i in inx_lst[:ntrains]])
make_tfrecord(data, outf_nm='mnist-train')

# make validation set
data = ([mnist.train.images[i] for i in inx_lst[ntrains:]], \
	[mnist.train.labels[i] for i in inx_lst[ntrains:]])
make_tfrecord(data, outf_nm='mnist-val')

# make test set
data = (mnist.test.images, mnist.test.labels)
make_tfrecord(data, outf_nm='mnist-test')
用dataset加载批量数据，在解析数据时用到tf.VarLenFeature(tf.datatype)，而非tf.FixedLenFeature([], tf.datatype)}，且要配合tf.sparse_tensor_to_dense函数使用，如下：
import tensorflow as tf

train_f, val_f, test_f = ['mnist-%s.tfrecord'%i for i in ['train', 'val', 'test']]

def parse_exmp(serial_exmp):
	feats = tf.parse_single_example(serial_exmp, features={'feature':tf.VarLenFeature(tf.float32),\
		'label':tf.FixedLenFeature([10],tf.float32), 'shape':tf.FixedLenFeature([], tf.int64)})
	image = tf.sparse_tensor_to_dense(feats['feature']) #使用VarLenFeature读入的是一个sparse_tensor，用该函数进行转换
	label = tf.reshape(feats['label'],[2,5])  #把label变成[2,5]，以说明array数据如何padding
	shape = tf.cast(feats['shape'], tf.int32)
	return image, label, shape

def get_dataset(fname):
	dataset = tf.data.TFRecordDataset(fname)
	return dataset.map(parse_exmp) # use padded_batch method if padding needed

epochs = 16
batch_size = 50  
padded_shapes = ([784],[3,5],[]) #把image pad至784，把label pad至[3,5]，shape是一个scalar，不输入数字
# training dataset
dataset_train = get_dataset(train_f)
dataset_train = dataset_train.repeat(epochs).shuffle(1000).padded_batch(batch_size, padded_shapes=padded_shapes)

简介

在《实战google深度学习框架》中的9.2.2节中，介绍了如何对文本数据进行batching的方法，主要包含两种，一种是填充式（padding），另一种则是batching方法。为了方便查看代码中的参数的含义，这里做一下简单的记录。

内容

代码中的各参数如下图所示：



说明：在图中，假设数据为data_size=100，batch_size的大小为4，每个batch中截取的片段包含的字符数为num_step=5,则每个batch中包含的单词数量为batch_size*num_step=4*5=20,总的batch的数量为num_batch = data_size/(batch_size*num_step)=100/(4*5)=5。这里面主要需要理解num_step、batch的大小、batch_size、num_batches的含义。num_step可以理解为每个序列截取片段中包含的字符数，batch的大小可以理解为，神经网络每训练一次，可以同时处理的字符数量，num_batches可以理解为整个训练过程总共需要经过多少次迭代，batches_size可以理解为将整个训练数据分为多少个子序列。

以上仅为个人理解，共勉。

《实战google深度学习框架》中的9.2.2节中涉及的代码如下

import numpy as np
import tensorflow as tf

TRAIN_DATA = 'ptb.train'
TRAIN_BATCH_SIZE = 20
TRAIN_NUM_STEP = 35

#从文件中获取数据，并返回包含单词编号的数组
def read_data(file_path):
    with open(TRAIN_DATA,"r") as fin:
        id_string = ' '.join([line.strip() for line in fin.readlines()])
    id_list = [int(w) for w in id_string.split()]
    return id_list

def make_batches(id_list, batch_size, num_step):
    num_batches = (len(id_list)-1)//(batch_size*num_step)

    #整理数据为一个维度为[batch_size, num_batches*num_step]的二维数组
    data = np.array(id_list[:num_batches*batch_size*num_step])
    data = np.reshape(data, [batch_size, num_batches*num_step])
    #沿着第二个维度，将数据切分成num_batches个batch, 存入数组
    data_batches = np.split(data, num_batches, axis=1)

    #重复上述操作，但是每个位置向右移动一位，这里得到的是RNN每一步输出所需要预测的下一个单词
    label = np.array(id_list[1:num_batches*batch_size*num_step+1])
    label = np.reshap(label, [batch_size, num_batches*num_step])
    label_batches = np.split(label, num_batches, axis=1)
    return list(zip(data_batches,label_batches))

def main():
    train_batchws = make_batches(read_data(TRAIN_DATA), TRAIN_BATCH_SIZE, TRAIN_NUM_STEP)
    #在这里插入训练代码，训练代码将在下一节中介绍

if __name__ == '__main__':
    main()

 

在pytorch训练数据，发现迭代到某一个次数时，就会报错，大概意思是输入的数据的batch size变了，不是预设置的了，后来发现是在DataLoader中有一个参数，控制dataset中的数据个数不是batch_size的整数倍时，剩下的不足batch size个的数据是否会被丢弃。
DataLoader的函数定义如下：
DataLoader(dataset, batch_size=1, shuffle=False, sampler=None, 
num_workers=0, collate_fn=default_collate, pin_memory=False, 
drop_last=False)

drop_last：dataset中的数据个数可能不是batch_size的整数倍，drop_last为True会将多出来不足一个batch的数据丢弃。
所以就在代码里加上了这个参数为True，继续训练就不再报错了。