精华内容
下载资源
问答
  • TensorFlow神经网络如何实现自己数据的Batch_Size 目录 1.遇到的问题 2.解决的办法 1.遇到的问题 自己在运行神经网络时,刚开始的时候数据样本较少,可以直接输入到神经网络输入层。但是处理大样本数据有时候才能...

    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方法进行;但如果每条数据的长度不一样(常见...

    在上一篇文章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方法,主要包含两种,一种是填充...说明:在图中,假设数据为data_size=100,batch_size大小为4,每个batch中截取片段包...

    简介

    在《实战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的整数倍时,剩下的...

    在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,继续训练就不再报错了。

    展开全文
  • 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代表矩阵作为输入...
  • def get_batches(x, y, n_batches=10): ... """ 这是一个生成器函数,按照n_batches大小将数据划分了小块 """ batch_size = len(x)//n_batches for ii in range(0, n_batches*batch_size, batch_size): ...
  • Tensorflow将自己的数据分割成batch训练

    万次阅读 多人点赞 2018-09-12 21:59:16
    目录 一、tf.slice_input_producer() ...学习神经网络时候,网上的数据集已经分割成了batch,训练时候直接使用batch.next()就可以获取batch,但是有时候需要使用自己的数据集,然而自己数...
  • 首先 batch 就是把数据分成几组,前面己组的数据大小都是batch的大小,但是最后一组可以能数据量不多,就只有一点 如下,先创建一个20行3列的数据 temp = tf.Variable(tf.random.normal(shape=(20, 3), mean=0, ...
  • Python循环产生批量数据batch

    千次阅读 2018-10-28 11:49:33
    Python循环产生批量数据batch 目录 Python循环产生批量数据batch 一、Python循环产生批量数据batch 二、TensorFlow循环产生批量数据batch ...(1)tf.train.slice_input_...(3)TF循环产生批量数据batch 完...
  • Python产生batch数据的方法

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

    2019-06-21 23:59:19
    batch数据处理 之前很多文章可能都没有写数据如何处理batch向量这种数据。其实对于numpy包来说以下功能足够应付这些工作了,没必要些循环啥,又慢又啰嗦代码。 首先是生成函数,就是从无到有产生一些数据: ...
  • 学习神经网络时候,网上的数据集已经分割成了batch,训练时候直接使用batch.next()就可以获取batch,但是有时候需要使用自己的数据集,然而自己的数据集不是batch形式,就需要将其转换为batch形式,本文将介绍...
  • Python产生batch数据的方法发布时间:2018-10-21 16:09,浏览次数:767, 标签:Pythonbatch参考此文:https://blog.csdn.net/qq_33039859/article/details/79901667<>产生batch数据输入data中每个样本可以有多...
  • 1.) Term Batch Materials are produced and theoretically have the same properties. Nevertheless through minimal differences in the productionprocess a certain property may change e.g. steel may have di...
  • TFRecords数据中存储数据为一个病人45天特征数据,但是目前我们需要通过训练VAE模型对病人一天数据进行降维,因此我需要的数据为病人一天数据。 输入数据shape为[SEQ_LEN(序列天数),FEATURE_SIZE(特征维度)] ...
  • 因此不可能一下子将所有数据集都输入到网络中,便引入了batch_size概念,下面总结自己两种常用调用batch的方法 1、使用TensorFlow, tf.train.batch()。 2、 offset = (offset + batch_size) % len...
  • 基于Spring Batch的数据量并行处理 基于Spring Batch的数据量并行处理
  • tensorflow提供了tf.train.batch和tf.train.shuffle_batch函数来将单个样例组织成batch的形式输出。...唯一区别是是否会将数据顺序打乱。 1.tf.train.batch batch_size=3 capacity=1000+3*batch_...
  • 批量读取数据next_batch函数实现

    千次阅读 2019-04-09 16:21:05
    输入是训练数据路径data_path,label_path,还有batch_size; 输出是: train_data_batch,shape 是( [batch_size,img_row, img_col, 3]) # 可相应变化 train_label_batch,shape是([batch_size, img_row, img...
  • 这两天用了一下Spring Batch来导数据,感觉是个很强大工具。网上资料很多,没看到连续运行示例。从mkong和spring官网上搞了几段代码,在本地跑了一下发现几个问题: 1. initialize-database执行官方...
  • 就是记录一下,这个用于统计batch数据的长度,用于RNN或者LSTM的输入,由于使用了0进行数据填充,因此统计实际数据长度,输入到RNN的length中,其中输入为一个batch,输出为(batch_size,)为一个batch中所有数据...
  • 官方封装训练集batch生成器是ImageDataGenerator对象...其实主要就是建立并使用dataGenerator生成器从一个图像列表或者文件夹中生成一个batch_size的数据流。 keras中文文档解释链接:https://keras.io/zh/prepro...
  • 批量读取数据next_batch()理解

    千次阅读 2018-10-11 14:42:23
    批量读取数据 ...#train_data训练集特征,train_target训练集对应标签,batch_size def next_batch(train_data, train_target, batch_size): #打乱数据集 index = [ i for i in range(0,...
  • 读取数据: @Configuration public class ItemReadConfig { @Autowired private DataSource dataSource; @Value("classpath:/file*.txt") private Resource[] fileResource; @Bean public Jdbc...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,880
精华内容 3,552
关键字:

数据的batch