Python循环产生批量数据batch
 
 
 
目录
 
Python循环产生批量数据batch
 
一、Python循环产生批量数据batch
 
二、TensorFlow循环产生批量数据batch 
 
(1) tf.train.slice_input_producer
 
(2) tf.train.batch和tf.train.shuffle_batch
 
(3) TF循环产生批量数据batch 的完整例子
 
三、更加实用的方法：数据巨大的情况
 

一、Python循环产生批量数据batch
 
   在机器学习中，经常需要产生一个batch的数据用于训练模型，比如tensorflow的接口tf.train.batch就可以实现数据批量读取的操作。本博客将不依赖TensorFlow，实现一个类似于tensorflow接口tf.train.batch的方法，循环产生批量数据batch。实现的代码和测试的代码如下：
 
   TXT文本如下，格式：图片名 label1 label2 ，注意label可以多个
 
1.jpg 1 11
2.jpg 2 12
3.jpg 3 13
4.jpg 4 14
5.jpg 5 15
6.jpg 6 16
7.jpg 7 17
8.jpg 8 18
 
    要想产生batch数据，关键是要用到Python的关键字yield，实现一个batch一个batch的返回数据，代码实现主要有两个方法：
 
 
 
def get_data_batch(inputs, batch_size=None, shuffle=False):
    '''
    循环产生批量数据batch
    :param inputs: list数据
    :param batch_size: batch大小
    :param shuffle: 是否打乱inputs数据
    :return: 返回一个batch数据
    '''
 
 
def get_next_batch(batch):
    return batch.__next__()
 
 
    使用时，将数据传到 get_data_batch( )方法，然后使用get_next_batch( )获得一个batch数据，完整的Python代码如下：
 
# -*-coding: utf-8 -*-
"""
    @Project: create_batch_data
    @File   : create_batch_data.py
    @Author : panjq
    @E-mail : pan_jinquan@163.com
    @Date   : 2017-10-27 18:20:15
"""
import math
import random
import os
import glob
import numpy as np


def get_data_batch(inputs, batch_size=None, shuffle=False):
    '''
    循环产生批量数据batch
    :param inputs: list类型数据，多个list,请[list0,list1,...]
    :param batch_size: batch大小
    :param shuffle: 是否打乱inputs数据
    :return: 返回一个batch数据
    '''
    rows = len(inputs[0])
    indices = list(range(rows))
    # 如果输入是list,则需要转为list
    if shuffle:
        random.seed(100)
        random.shuffle(indices)
    while True:
        batch_indices = np.asarray(indices[0:batch_size])  # 产生一个batch的index
        indices = indices[batch_size:] + indices[:batch_size]  # 循环移位，以便产生下一个batch
        batch_data = []
        for data in inputs:
            data = np.asarray(data)
            temp_data=data[batch_indices] #使用下标查找，必须是ndarray类型类型
            batch_data.append(temp_data.tolist())
        yield batch_data

def get_data_batch2(inputs, batch_size=None, shuffle=False):
    '''
    循环产生批量数据batch
    :param inputs: list类型数据，多个list,请[list0,list1,...]
    :param batch_size: batch大小
    :param shuffle: 是否打乱inputs数据
    :return: 返回一个batch数据
    '''
    # rows,cols=inputs.shape
    rows = len(inputs[0])
    indices = list(range(rows))
    if shuffle:
        random.seed(100)
        random.shuffle(indices)
    while True:
        batch_indices = indices[0:batch_size]  # 产生一个batch的index
        indices = indices[batch_size:] + indices[:batch_size]  # 循环移位，以便产生下一个batch
        batch_data = []
        for data in inputs:
            temp_data = find_list(batch_indices, data)
            batch_data.append(temp_data)
        yield batch_data



def get_data_batch_one(inputs, batch_size=None, shuffle=False):
    '''
    产生批量数据batch,非循环迭代
    迭代次数由:iter_nums= math.ceil(sample_nums / batch_size)
    :param inputs: list类型数据，多个list,请[list0,list1,...]
    :param batch_size: batch大小
    :param shuffle: 是否打乱inputs数据
    :return: 返回一个batch数据
    '''
    # rows,cols=inputs.shape
    rows = len(inputs[0])
    indices = list(range(rows))
    if shuffle:
        random.seed(100)
        random.shuffle(indices)
    while True:
        batch_data = []
        cur_nums = len(indices)
        batch_size = np.where(cur_nums > batch_size, batch_size, cur_nums)
        batch_indices = indices[0:batch_size]  # 产生一个batch的index
        indices = indices[batch_size:]
        # indices = indices[batch_size:] + indices[:batch_size]  # 循环移位，以便产生下一个batch
        for data in inputs:
            temp_data = find_list(batch_indices, data)
            batch_data.append(temp_data)
        yield batch_data


def find_list(indices, data):
    out = []
    for i in indices:
        out = out + [data[i]]
    return out


def get_list_batch(inputs, batch_size=None, shuffle=False):
    '''
    循环产生batch数据
    :param inputs: list数据
    :param batch_size: batch大小
    :param shuffle: 是否打乱inputs数据
    :return: 返回一个batch数据
    '''
    if shuffle:
        random.shuffle(inputs)
    while True:
        batch_inouts = inputs[0:batch_size]
        inputs = inputs[batch_size:] + inputs[:batch_size]  # 循环移位，以便产生下一个batch
        yield batch_inouts


def load_file_list(text_dir):
    text_dir = os.path.join(text_dir, '*.txt')
    text_list = glob.glob(text_dir)
    return text_list


def get_next_batch(batch):
    return batch.__next__()


def load_image_labels(finename):
    '''
    载图txt文件，文件中每行为一个图片信息，且以空格隔开：图像路径 标签1 标签1，如：test_image/1.jpg 0 2
    :param test_files:
    :return:
    '''
    images_list = []
    labels_list = []
    with open(finename) as f:
        lines = f.readlines()
        for line in lines:
            # rstrip：用来去除结尾字符、空白符(包括\n、\r、\t、' '，即：换行、回车、制表符、空格)
            content = line.rstrip().split(' ')
            name = content[0]
            labels = []
            for value in content[1:]:
                labels.append(float(value))
            images_list.append(name)
            labels_list.append(labels)
    return images_list, labels_list


if __name__ == '__main__':
    filename = './training_data/test.txt'
    images_list, labels_list = load_image_labels(filename)

    # 若输入为np.arange数组，则需要tolist()为list类型，如：
    # images_list = np.reshape(np.arange(8*3), (8,3))
    # labels_list = np.reshape(np.arange(8*3), (8,3))
    # images_list=images_list.tolist()
    # labels_list=labels_list.tolist()

    iter = 5  # 迭代3次，每次输出一个batch个
    # batch = get_data_batch([images_list, labels_list], batch_size=3, shuffle=False)
    batch = get_data_batch2(inputs=[images_list,labels_list], batch_size=5, shuffle=True)

    for i in range(iter):
        print('**************************')
        batch_images, batch_labels = get_next_batch(batch)
        print('batch_images:{}'.format(batch_images))
        print('batch_labels:{}'.format(batch_labels))


 
   运行输出结果为：
 
 
 
**************************
 batch_images:['1.jpg', '2.jpg', '3.jpg']
 batch_labels:[[1.0, 11.0], [2.0, 12.0], [3.0, 13.0]]
 **************************
 batch_images:['4.jpg', '5.jpg', '6.jpg']
 batch_labels:[[4.0, 14.0], [5.0, 15.0], [6.0, 16.0]]
 **************************
 batch_images:['7.jpg', '8.jpg', '1.jpg']
 batch_labels:[[7.0, 17.0], [8.0, 18.0], [1.0, 11.0]]
 **************************
 batch_images:['2.jpg', '3.jpg', '4.jpg']
 batch_labels:[[2.0, 12.0], [3.0, 13.0], [4.0, 14.0]]
 **************************
 batch_images:['5.jpg', '6.jpg', '7.jpg']
 batch_labels:[[5.0, 15.0], [6.0, 16.0], [7.0, 17.0]]
 
 
Process finished with exit code 0
 
 
二、TensorFlow循环产生批量数据batch 
 
    使用TensorFlow实现产生批量数据batch，需要几个接口，
 
(1) tf.train.slice_input_producer
 
 
 
tf.train.slice_input_producer是一个tensor生成器，作用是按照设定，每次从一个tensor列表中按顺序或者随机抽取出一个tensor放入文件名队列。
 
 
slice_input_producer(tensor_list,
                     num_epochs=None,
                     shuffle=True,
                     seed=None,
                     capacity=32,
                     shared_name=None,
                     name=None)
# 第一个参数
#           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：设置tensor列表的容量。
# 第六个参数shared_name：可选参数，如果设置一个‘shared_name’，则在不同的上下文环境（Session）中可以通过这个名字共享生成的tensor。
# 第七个参数name：可选，设置操作的名称
 
    tf.train.slice_input_producer定义了样本放入文件名队列的方式，包括迭代次数，是否乱序等，要真正将文件放入文件名队列，还需要调用tf.train.start_queue_runners 函数来启动执行文件名队列填充的线程，之后计算单元才可以把数据读出来，否则文件名队列为空的，计算单元就会处于一直等待状态，导致系统阻塞。
 
    例子：
 
import tensorflow as tf
 
images = ['img1', 'img2', 'img3', 'img4', 'img5']
labels= [1,2,3,4,5]
 
epoch_num=8
 
f = 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()
    threads = tf.train.start_queue_runners(sess=sess, coord=coord)
    for i in range(epoch_num):
        k = sess.run(f)
        print '************************'
        print (i,k)
 
    coord.request_stop()
    coord.join(threads)
 
(2) tf.train.batch和tf.train.shuffle_batch
 
    tf.train.batch是一个tensor队列生成器，作用是按照给定的tensor顺序，把batch_size个tensor推送到文件队列，作为训练一个batch的数据，等待tensor出队执行计算。
 
tf.train.batch(tensors, 
               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)
# 第一个参数tensors：tensor序列或tensor字典，可以是含有单个样本的序列;
# 第二个参数batch_size: 生成的batch的大小;
# 第三个参数num_threads：执行tensor入队操作的线程数量，可以设置使用多个线程同时并行执行，提高运行效率，但也不是数量越多越好;
# 第四个参数capacity： 定义生成的tensor序列的最大容量;
# 第五个参数enqueue_many： 定义第一个传入参数tensors是多个tensor组成的序列，还是单个tensor;
# 第六个参数shapes： 可选参数，默认是推测出的传入的tensor的形状;
# 第七个参数dynamic_pad： 定义是否允许输入的tensors具有不同的形状，设置为True，会把输入的具有不同形状的tensor归一化到相同的形状;
# 第八个参数allow_smaller_final_batch： 设置为True，表示在tensor队列中剩下的tensor数量不够一个batch_size的情况下，允许最后一个batch的数量少于batch_size， 设置为False，则不管什么情况下，生成的batch都拥有batch_size个样本;
# 第九个参数shared_name： 可选参数，设置生成的tensor序列在不同的Session中的共享名称;
# 第十个参数name： 操作的名称;
 
    如果tf.train.batch的第一个参数 tensors 传入的是tenor列表或者字典，返回的是tensor列表或字典，如果传入的是只含有一个元素的列表，返回的是单个的tensor，而不是一个列表。
 
    与tf.train.batch函数相对的还有一个tf.train.shuffle_batch函数，两个函数作用一样，都是生成一定数量的tensor,组成训练一个batch需要的数据集，区别是tf.train.shuffle_batch会打乱样本顺序。
 
(3) TF循环产生批量数据batch 的完整例子
 
# -*-coding: utf-8 -*-
"""
    @Project: LSTM
    @File   : tf_create_batch_data.py
    @Author : panjq
    @E-mail : pan_jinquan@163.com
    @Date   : 2018-10-28 17:50:24
"""
import tensorflow as tf


def get_data_batch(inputs,batch_size,labels_nums,one_hot=False,shuffle=False,num_threads=1):
    '''
    :param inputs: 输入数据，可以是多个list
    :param batch_size:
    :param labels_nums:标签个数
    :param one_hot:是否将labels转为one_hot的形式
    :param shuffle:是否打乱顺序,一般train时shuffle=True,验证时shuffle=False
    :return:返回batch的images和labels
    '''
    # 生成队列
    inputs_que= tf.train.slice_input_producer(inputs, shuffle=shuffle)
    min_after_dequeue = 200
    capacity = min_after_dequeue + 3 * batch_size  # 保证capacity必须大于min_after_dequeue参数值
    if shuffle:
        out_batch = tf.train.shuffle_batch(inputs_que,
                                            batch_size=batch_size,
                                            capacity=capacity,
                                            min_after_dequeue=min_after_dequeue,
                                            num_threads=num_threads)
    else:
        out_batch = tf.train.batch(inputs_que,
                                    batch_size=batch_size,
                                    capacity=capacity,
                                    num_threads=num_threads)
    return out_batch

def get_batch_images(images,labels,batch_size,labels_nums,one_hot=False,shuffle=False):
    '''
    :param images:图像
    :param labels:标签
    :param batch_size:
    :param labels_nums:标签个数
    :param one_hot:是否将labels转为one_hot的形式
    :param shuffle:是否打乱顺序,一般train时shuffle=True,验证时shuffle=False
    :return:返回batch的images和labels
    '''
    images_que, labels_que= tf.train.slice_input_producer([images,labels], shuffle=shuffle)
    min_after_dequeue = 200
    capacity = min_after_dequeue + 3 * batch_size  # 保证capacity必须大于min_after_dequeue参数值
    if shuffle:
        images_batch, labels_batch = tf.train.shuffle_batch([images_que, labels_que],
                                                            batch_size=batch_size,
                                                            capacity=capacity,
                                                            min_after_dequeue=min_after_dequeue)
    else:
        images_batch, labels_batch = tf.train.batch([images_que, labels_que],
                                                    batch_size=batch_size,
                                                    capacity=capacity)
    if one_hot:
        labels_batch = tf.one_hot(labels_batch, labels_nums, 1, 0)
    return images_batch,labels_batch

def load_image_labels(finename):
    '''
    载图txt文件，文件中每行为一个图片信息，且以空格隔开：图像路径 标签1 标签1，如：test_image/1.jpg 0 2
    :param test_files:
    :return:
    '''
    images_list=[]
    labels_list=[]
    with open(finename) as f:
        lines = f.readlines()
        for line in lines:
            #rstrip：用来去除结尾字符、空白符(包括\n、\r、\t、' '，即：换行、回车、制表符、空格)
            content=line.rstrip().split(' ')
            name=content[0]
            labels=[]
            for value in content[1:]:
                labels.append(float(value))
            images_list.append(name)
            labels_list.append(labels)
    return images_list,labels_list

if __name__ == '__main__':
    filename='./training_data/train.txt'
    # 输入数据可以是list,也可以是np.array
    images_list, labels_list=load_image_labels(filename)
    # np.arange数组如：
    # images_list = np.reshape(np.arange(8*3), (8,3))
    # labels_list = np.reshape(np.arange(8*3), (8,3))

    iter = 5  # 迭代5次，每次输出一个batch个
    # batch_images, batch_labels = get_data_batch( inputs=[images_list, labels_list],batch_size=3,labels_nums=2,one_hot=False,shuffle=False,num_threads=1)
    # 或者
    batch_images, batch_labels = get_batch_images(images_list,labels_list,batch_size=3,labels_nums=2,one_hot=False,shuffle=False)
    with tf.Session() as sess:  # 开始一个会话
        sess.run(tf.global_variables_initializer())
        coord = tf.train.Coordinator()
        threads = tf.train.start_queue_runners(coord=coord)
        for i in range(iter):
            # 在会话中取出images和labels
            images, labels = sess.run([batch_images, batch_labels] )
            print('**************************')
            print('batch_images:{}'.format(images ))
            print('batch_labels:{}'.format(labels))

        # 停止所有线程
        coord.request_stop()
        coord.join(threads)

 
    运行输出结果：
 
 
 
**************************
 batch_images:[b'1.jpg' b'2.jpg' b'3.jpg']
 batch_labels:[[ 1. 11.] [ 2. 12.][ 3. 13.]]
 **************************
 batch_images:[b'4.jpg' b'5.jpg' b'6.jpg']
 batch_labels:[[ 4. 14.] [ 5. 15.][ 6. 16.]]
 **************************
 batch_images:[b'7.jpg' b'8.jpg' b'1.jpg']
 batch_labels:[[ 7. 17.][ 8. 18.][ 1. 11.]]
 **************************
 batch_images:[b'2.jpg' b'3.jpg' b'4.jpg']
 batch_labels:[[ 2. 12.] [ 3. 13.][ 4. 14.]]
 **************************
 batch_images:[b'5.jpg' b'6.jpg' b'7.jpg']
 batch_labels:[[ 5. 15.][ 6. 16.][ 7. 17.]]
 
 
三、更加实用的方法：数据巨大的情况
 
    当数据量很大很大时，超过2T的数据时，我们不可能把所以数据都保存为一个文件，也不可能把数据都加载到内存。为了避免内存耗尽的情况，最简单的思路是：把数据分割成多个文件保存到硬盘（每个文件不超过2G），训练时，按batch大小逐个加载文件，再获取一个batch的训练数据。这种方法，也可以用TensorFlow TFRecord格式，利用队列方法读取文件，然后再产生一个batch数据，可以参考：《Tensorflow生成自己的图片数据集TFrecords》：https://blog.csdn.net/guyuealian/article/details/80857228
 
   但TensorFlow TFRecord格式存储的内容，有很多限制， 这里将实现一种类似于TensorFlow TFRecord的方法，但存储的内容没有限制，你可稍微修改保存不同的数据，基本思路是：
 
 
 
数据产生：利用numpy，把数据分割成多个*.npy文件保存到硬盘（每个文件不超过1G），当然你可以用其他Python工具保存其他文件格式，只要你能读取文件即可
获得训练数据：获取所有文件*.npy的列表，逐个读取文件的数据，并根据batch的大小，循环返回数据
 
     完整代码如下：
 
    这里将数据保存为data1.npy，data2.npy，data3.npy，其中*.npy文件的数据保存是二维矩阵Mat:第一列为样本的labels,剩余的列为样本的数据，
 
indexMat1:
[[0 0 5]
 [1 1 6]
 [2 2 7]
 [3 3 8]
 [4 4 9]]
indexMat2:
[[ 5 15 20]
 [ 6 16 21]
 [ 7 17 22]
 [ 8 18 23]
 [ 9 19 24]]
indexMat3:
[[10 30 35]
 [11 31 36]
 [12 32 37]
 [13 33 38]
 [14 34 39]]
 
# -*-coding: utf-8 -*-
"""
    @Project: nlp-learning-tutorials
    @File   : create_batch_data.py
    @Author : panjq
    @E-mail : pan_jinquan@163.com
    @Date   : 2018-11-08 09:29:19
"""

import math
import random
import os
import glob
import numpy as np
from sklearn import preprocessing


def get_data_batch(file_list,labels_nums,batch_size=None, shuffle=False,one_hot=False):
    '''
    加载*.npy文件的数据，循环产生批量数据batch，其中*.npy文件的数据保存是二维矩阵Mat:
    二维矩阵Mat:第一列为样本的labels,剩余的列为样本的数据，
    np.concatenate([label,data], axis=1)
    :param file_list: *.npy文件路径,type->list->[file0.npy,file1.npy,....]
    :param labels_nums: labels种类数
    :param batch_size: batch大小
    :param shuffle: 是否打乱数据,PS:只能打乱一个batch的数据，不同batch的数据不会干扰
    :param one_hot: 是否独热编码
    :return: 返回一个batch数据
    '''
    height = 0
    indexMat_labels = None
    i = 0
    while True:
        while height < batch_size:
            i = i%len(file_list)
            tempFile = file_list[i]
            tempMat_labels = np.load(tempFile)
            if indexMat_labels is None:
                indexMat_labels = tempMat_labels
            else:
                indexMat_labels = np.concatenate([indexMat_labels, tempMat_labels], 0)
            i=i+1
            height = indexMat_labels.shape[0]

        indices = list(range(height))
        batch_indices = np.asarray(indices[0:batch_size])  # 产生一个batch的index
        if shuffle:
            random.seed(100)
            random.shuffle(batch_indices)

        batch_indexMat_labels = indexMat_labels[batch_indices] # 使用下标查找，必须是ndarray类型类型
        indexMat_labels=np.delete(indexMat_labels,batch_indices,axis=0)
        height = indexMat_labels.shape[0]

        # 将数据分割成indexMat和labels
        batch_labels=batch_indexMat_labels[:,0]     # 第一列是labels
        batch_indexMat=batch_indexMat_labels[:,1:]  # 其余是indexMat

        # 是否进行独热编码
        if one_hot:
            batch_labels = batch_labels.reshape(len(batch_labels), 1)
            onehot_encoder = preprocessing.OneHotEncoder(sparse=False,categories=[range(labels_nums)])
            batch_labels = onehot_encoder.fit_transform(batch_labels)
        yield batch_indexMat,batch_labels


def get_next_batch(batch):
    return batch.__next__()

def get_file_list(file_dir,postfix):
    '''
    获得后缀名为postfix所有文件列表
    :param file_dir:
    :param postfix:
    :return:
    '''
    file_dir=os.path.join(file_dir,postfix)
    file_list=glob.glob(file_dir)
    return file_list


def create_test_data(out_dir):
    '''
    产生测试数据
    :return:
    '''
    data1 = np.arange(0, 10)
    data1 = np.transpose(data1.reshape([2, 5]))
    label1 = np.arange(0, 5)
    label1 = label1.reshape([5, 1])

    path1 = os.path.join(out_dir,'data1.npy')
    indexMat1 = np.concatenate([label1, data1], axis=1)  # 矩阵拼接，第一列为labels
    np.save(path1, indexMat1)

    data2 = np.arange(15, 25)
    data2 = np.transpose(data2.reshape([2, 5]))
    label2 = np.arange(5, 10)
    label2 = label2.reshape([5, 1])

    path2 = os.path.join(out_dir,'data2.npy')
    indexMat2 = np.concatenate([label2, data2], axis=1)
    np.save(path2, indexMat2)

    data3 = np.arange(30, 40)
    data3 = np.transpose(data3.reshape([2, 5]))
    label3 = np.arange(10, 15)
    label3 = label3.reshape([5, 1])

    path3 = os.path.join(out_dir,'data3.npy')
    indexMat3 = np.concatenate([label3, data3], axis=1)
    np.save(path3, indexMat3)

    print('indexMat1:\n{}'.format(indexMat1))
    print('indexMat2:\n{}'.format(indexMat2))
    print('indexMat3:\n{}'.format(indexMat3))


if __name__ == '__main__':
    out_dir='./output'
    create_test_data(out_dir)
    file_list=get_file_list(file_dir=out_dir, postfix='*.npy')
    iter = 3  # 迭代3次，每次输出一个batch个
    batch = get_data_batch(file_list, labels_nums=15,batch_size=8, shuffle=False,one_hot=False)
    for i in range(iter):
        print('**************************')
        batch_data, batch_label = get_next_batch(batch)
        print('batch_images:\n{}'.format(batch_data))
        print('batch_labels:\n{}'.format(batch_label))

 
运行结果： 
 
**************************
batch_images:
[[ 0  5]
 [ 1  6]
 [ 2  7]
 [ 3  8]
 [ 4  9]
 [15 20]
 [16 21]
 [17 22]]
batch_labels:
[0 1 2 3 4 5 6 7]
**************************
batch_images:
[[18 23]
 [19 24]
 [30 35]
 [31 36]
 [32 37]
 [33 38]
 [34 39]
 [ 0  5]]
batch_labels:
[ 8  9 10 11 12 13 14  0]
**************************
batch_images:
[[ 1  6]
 [ 2  7]
 [ 3  8]
 [ 4  9]
 [15 20]
 [16 21]
 [17 22]
 [18 23]]
batch_labels:
[1 2 3 4 5 6 7 8]
 
 

机器学习0007 每次应该训练多少数据batch_size应该设成多少
 

 
 
下面是整理的一些经验：
 
1.batch_size 的值越大，训练（收敛）速度越快；batch_size 的值越小，训练（收敛）速度越慢。
 
 
2.batch_size 的值越小，模型泛化能力越好；batch_size 的值越大，模型泛化能力越差。
 
3.batch_size=1时，模型很难收敛，可能不收敛。只有很特殊的情况下才可以收敛。
 
一般情况下，batch_size 应该设置成2^n。网上有人说是方便内存/显存分配，GPU在这2^n的条件下，速度会更快。batch不能太大，也不能太小。
 
综上所述：batch_size的推荐值是32，64，128
 

 

前段时间写了一个小功能，一个port对应多个userId
 当插入和删除这个表里的数据时就需要用到批量更新
 直接粘代码吧：
 public void saveSmsPortAuth(final SmsPortAuthVo smsPortAuthVo) throws Exception {
 try {
 StringBuilder sqlBuilder = new StringBuilder();
 sqlBuilder.append(" INSERT INTO MCD_SMS_PORT_AUTH (PORT,USER_ID) " ) //user_id多个
 .append(" VALUES (?,?)" );
 final String port = smsPortAuthVo.getPort();
 final String[] userId = smsPortAuthVo.getUserId();
 
		 this.getJdbcTemplate().batchUpdate(sqlBuilder.toString(), new BatchPreparedStatementSetter() {
			
			@Override
			public void setValues(PreparedStatement ps, int i) throws SQLException {
				ps.setString(1, port);
				ps.setString(2, userId[i]);//
			}
			
			@Override
			public int getBatchSize() {
				return userId.length;
			}
		});
	}catch (Exception e) {
		log.error("添加短信端口外部可见用户数据异常(DAO)",e);
	}
}
//定义实体类时 userId 为String数组  private String[] userId;

 
 
本文主要参考两篇文献： 
 1、《深度学习theano/tensorflow多显卡多人使用问题集》 
 2、基于双向LSTM和迁移学习的seq2seq核心实体识别
 
 
运行机器学习算法时，很多人一开始都会有意无意将数据集默认直接装进显卡显存中，如果处理大型数据集（例如图片尺寸很大）或是网络很深且隐藏层很宽，也可能造成显存不足。
 
这个情况随着工作的深入会经常碰到，解决方法其实很多人知道，就是分块装入。以keras为例，默认情况下用fit方法载数据，就是全部载入。换用fit_generator方法就会以自己手写的方法用yield逐块装入。这里稍微深入讲一下fit_generator方法。 
 .
 
— fit_generator源码
 
def fit_generator(self, generator, samples_per_epoch, nb_epoch,
                      verbose=1, callbacks=[],
                      validation_data=None, nb_val_samples=None,
                      class_weight=None, max_q_size=10, **kwargs):
 
.
 
— generator 该怎么写？
 
其中generator参数传入的是一个方法，validation_data参数既可以传入一个方法也可以直接传入验证数据集，通常我们都可以传入方法。这个方法需要我们自己手写，伪代码如下：
 
def generate_batch_data_random(x, y, batch_size):
    """逐步提取batch数据到显存，降低对显存的占用"""
    ylen = len(y)
    loopcount = ylen // batch_size
    while (True):
        i = randint(0,loopcount)
        yield x[i * batch_size:(i + 1) * batch_size], y[i * batch_size:(i + 1) * batch_size]
 
. 
 为什么推荐在自己写的方法中用随机呢？
 
因为fit方法默认shuffle参数也是True，fit_generator需要我们自己随机打乱数据。
另外，在方法中需要用while写成死循环，因为每个epoch不会重新调用方法，这个是新手通常会碰到的问题。
 
当然，如果原始数据已经随机打乱过，那么可以不在这里做随机处理。否则还是建议加上随机取数逻辑（如果数据集比较大则可以保证基本乱序输出）。深度学习中随机打乱数据是非常重要的，具体参见《深度学习Deep Learning》一书的8.1.3节：《Batch and Minibatch Algorithm》。（2017年5月25日补充说明） 
 .
 
调用示例：
 
model.fit_generator(self.generate_batch_data_random(x_train, y_train, batch_size),                                                      
    samples_per_epoch=len(y_train)//batch_size*batch_size,
    nb_epoch=epoch, 
    validation_data=self.generate_valid_data(x_valid, y_valid,batch_size),
    nb_val_samples=(len(y_valid)//batch_size*batch_size), 
    verbose=verbose,
    callbacks=[early_stopping])
 
这样就可以将对显存的占用压低了，配合第一部分的方法可以方便同时执行多程序。
 
 
. 
 来看看一个《基于双向LSTM和迁移学习的seq2seq核心实体识别》实战案例：
 
'''
gen_matrix实现从分词后的list来输出训练样本
gen_target实现将输出序列转换为one hot形式的目标
超过maxlen则截断，不足补0
'''
gen_matrix = lambda z: np.vstack((word2vec[z[:maxlen]], np.zeros((maxlen-len(z[:maxlen]), word_size))))
gen_target = lambda z: np_utils.to_categorical(np.array(z[:maxlen] + [0]*(maxlen-len(z[:maxlen]))), 5)

#从节省内存的角度，通过生成器的方式来训练
def data_generator(data, targets, batch_size): 
    idx = np.arange(len(data))
    np.random.shuffle(idx)
    batches = [idx[range(batch_size*i, min(len(data), batch_size*(i+1)))] for i in range(len(data)/batch_size+1)]
    while True:
        for i in batches:
            xx, yy = np.array(map(gen_matrix, data[i])), np.array(map(gen_target, targets[i]))
            yield (xx, yy)


batch_size = 1024
history = model.fit_generator(data_generator(d['words'], d['label'], batch_size), samples_per_epoch=len(d), nb_epoch=200)
model.save_weights('words_seq2seq_final_1.model')
 
延伸一：edwardlib/observations 规范数据导入、数据Batch化
 
def generator(array, batch_size):
  """Generate batch with respect to array's first axis."""
  start = 0  # pointer to where we are in iteration
  while True:
    stop = start + batch_size
    diff = stop - array.shape[0]
    if diff <= 0:
      batch = array[start:stop]
      start += batch_size
    else:
      batch = np.concatenate((array[start:], array[:diff]))
      start = diff
    yield batch
 
To use it, simply write
 
from observations import cifar10
(x_train, y_train), (x_test, y_test) = cifar10("~/data")
x_train_data = generator(x_train, 256)
 
 

 
 公众号“素质云笔记”定期更新博客内容：