精华内容
下载资源
问答
  • Python循环产生批量数据batch

    万次阅读 2018-10-28 11:49:33
    Python循环产生批量数据batch 目录 Python循环产生批量数据batch 一、Python循环产生批量数据batch 二、TensorFlow循环产生批量数据batch (1)tf.train.slice_input_producer (2)tf.train.batch和tf.train....

    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的方法,但存储的内容没有限制,你可稍微修改保存不同的数据,基本思路是:

    1. 数据产生:利用numpy,把数据分割成多个*.npy文件保存到硬盘(每个文件不超过1G),当然你可以用其他Python工具保存其他文件格式,只要你能读取文件即可
    2. 获得训练数据:获取所有文件*.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 的值越小,...

    机器学习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


    展开全文
  • 批量插入数据batchUpdate

    千次阅读 2019-04-10 10:17:10
    当插入和删除这个表里的数据时就需要用到批量更新 直接粘代码吧: public void saveSmsPortAuth(final SmsPortAuthVo smsPortAuthVo) throws Exception { try { StringBuilder sqlBuilder = new StringBuilder(); ...

    前段时间写了一个小功能,一个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)
    

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

    这里写图片描述

    展开全文
  • Python产生batch数据的方法

    万次阅读 2018-10-21 16:09:54
    产生batch数据 输入data中每个样本可以有多个特征,和一个标签,最好都是numpy.array格式。 datas = [data1, data2, …, dataN ], labels = [label1, label2, …, labelN], 其中data[i] = [feature1, feature2,…...
  • Pytorch:批量数据batch)分割

    千次阅读 2020-02-18 09:01:51
    原文地址 分类目录——Pytorch 深度学习可行的一个前提是假设数据之间是相互...在大量数据中学习中,小批量(batch)梯度下降是一种比较好的方式,每次选取一小部分数据来进行参数更新,既能沿着较好的方向更新,又...
  • Spring Batch批量处理数据实战教程

    千人学习 2017-11-15 16:31:51
    本课程通过讲解Spring Batch的基础知识点以及一些实际的项目示例让大家熟悉如何使用Spring Batch进行大批量数据的同步、处理及转换等。
  • tensorflow用自己的数据创建batch

    千次阅读 2018-10-12 16:43:16
    使用自己的数据创建batch 下面以一个例子说明: data = np.array([x for x in range(1, 101)]).reshape(10, 10) label = np.array([x for x in range(1, 11)]).reshape(10, 1) 将data代表的矩阵作为输入的...
  • TensorFlow 中生成Batch数据

    千次阅读 2017-12-01 14:53:19
    TensorFlow 中生成Batch数据Reference: https://www.tensorflow.org/programmers_guide/datasets#simple_batching1. 利用sklearndef batch(self,STEPS=10000, BATCH=100): ss = ShuffleSplit(n_splits=STEPS, ...
  • PyTorch学习系列(一)——加载数据并生成batch数据

    万次阅读 多人点赞 2017-05-17 09:12:19
    加载数据并生成batch数据 数据预处理 构建神经网络 Tensor和Variable 定义loss 自动求导 优化器更新参数 训练神经网络 参数_定义 参数_初始化 如何在训练时固定一些层? 绘制loss和accuracy曲线 torch.nn.Container...
  • 近期用到同步数据的工具,就是将一个网站的订单信息同步到另一个后台订单系统中,由于订单数据量较大,所以就用到了"批量" --- 批量获取 批量插入
  • 模型训练batch数据抽样

    千次阅读 2018-12-20 16:24:01
    自定义DataGenerator 生成器,结合佛如循环以及yield来产生数据 但是以下代码暂时不能保证每个epoch,数据有且仅有一次参与训练 ... import numpy as np class DataGenerator... def __init__(self, batch_siz...
  • pytorch学习-数据处理生成batch

    千次阅读 2019-08-18 18:03:29
    开始学习PyTorch,在此记录学习过程。准备按顺序写以下系列: 加载数据并生成batch数据 数据预处理 构建神经网络 Tenso...
  • 这两天用了一下Spring Batch来导数据,感觉是个很强大的工具。网上的资料很多,没看到连续运行的示例。从mkong和spring官网上搞了几段代码,在本地跑了一下发现几个问题: 1. initialize-database执行官方的...
  • Tensorflow将自己的数据分割成batch训练

    万次阅读 多人点赞 2018-09-12 21:59:16
    目录 一、tf.slice_input_producer() ...学习神经网络的时候,网上的数据集已经分割成了batch,训练的时候直接使用batch.next()就可以获取batch,但是有的时候需要使用自己的数据集,然而自己的数...
  • 在上一篇文章tensorflow入门:tfrecord 和tf.data.TFRecordDataset里,...但如果每条数据的长度不一样(常见于语音、视频、NLP等领域),则不能直接用batch方法获取数据,这时则有两个解决办法:1.在把数据写入tfre...
  • 之所以把项目放到github上,主要是希望分享出来,同时也希望...SpringBatch数据迁移项目 (1)项目简介:主要解决两库的两个表数据迁移和同步问题(两个表的字段可以不一致,只要知道对应关系及转化规则即可),曾经
  • spring-batch+quartz处理mysql数据示例

    热门讨论 2016-01-14 16:39:00
    spring-batch+quartz处理mysql数据示例,功能:定时从mysql里读取数据,进行处理,再存入到mysql
  • 本文讨论的是不使用dataloader的情况下,怎么解决batchsize不能整除训练数据大小的问题。 方案1,寻找可以整除训练数据大小的batchsize 比如训练数据一共50000万个,每个批次35个数据就不合适,可以设置成50个。 ...
  • 使用paddle.batch自定义读取数据函数

    千次阅读 2020-08-14 17:04:04
    自定义读取数据函数时,想要使用paddle.batch数据进行读取时,train_reader需要返回list类型的data,且data[i]的类型为tuple,具体数据如下 train_reader = paddle.batch(paddle.reader.shuffle(reader('train')...
  • Springbatch数据建表语句及初始化

    千次阅读 2018-12-21 09:34:03
    Spring batch的运行过程中会将任务状态记录到框架预设的表中,表名有: batch_job_execution batch_job_execution_context batch_job_execution_params batch_job_execution_seq batch_job_instance batch_job_seq ...
  • 基于Spring Batch的大数据量并行处理 基于Spring Batch的大数据量并行处理
  • 数据批处理神器-Spring Batch(1)简介及使用场景 tags: springbatch 文章目录数据批处理神器-Spring Batch(1)简介及使用场景1.引言2.Spring Batch简介2.1 Spring Batch是批处理框架2.2 Spring Batch不是调度框架2.3...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 267,081
精华内容 106,832
关键字:

数据的batch