keras 产品 大数据平台_keras安keras中mnist数据集 - CSDN
  • 说明:我是在keras的官方demo上进行修改https://github.com/fchollet/keras/blob/master/examples/imdb_cnn.py 1、几点说明,从文件中读入数据,会降低GPU的使用率,如果能够直接将数据载入内存,GPU的使用率会比较...

    说明:我是在keras的官方demo上进行修改https://github.com/fchollet/keras/blob/master/examples/imdb_cnn.py

    1、几点说明,从文件中读入数据,会降低GPU的使用率,如果能够直接将数据载入内存,GPU的使用率会比较高。下面进行对比:

    全部数据载入内存,GPU的使用率:

    使用队列,边读数据边进行训练:


    结论:全部载入内存,GPU的使用率可以达到82%,如果边载入数据边训练,只能达到48%


    2、keras 使用迭代器来实现大数据的训练,其简单的思想就是,使用迭代器从文件中去顺序读取数据。所以,自己的训练数据一定要先随机打散。因为,我们的迭代器也是每次顺序读取一个batch_size的数据进行训练。

    举例如下:数据如下,前400维是特征,后一维是label


    keras 官方的demo 如下:

    def generate_arrays_from_file(path):
        while 1:
        f = open(path)
        for line in f:
            # create Numpy arrays of input data
            # and labels, from each line in the file
            x, y = process_line(line)
            yield (x, y)
        f.close()
    
    model.fit_generator(generate_arrays_from_file('/my_file.txt'),
            samples_per_epoch=10000, nb_epoch=10)
    说明:官方的demo还是有瑕疵的,没有实现batch_size,该demo每次只能提取一个样本。我针对上述的数据集,实现的batch_size数据提取的迭代器,代码如下:

    def process_line(line):
        tmp = [int(val) for val in line.strip().split(',')]
        x = np.array(tmp[:-1])
        y = np.array(tmp[-1:])
        return x,y
    
    def generate_arrays_from_file(path,batch_size):
        while 1:
            f = open(path)
            cnt = 0
            X =[]
            Y =[]
            for line in f:
                # create Numpy arrays of input data
                # and labels, from each line in the file
                x, y = process_line(line)
                X.append(x)
                Y.append(y)
                cnt += 1
                if cnt==batch_size:
                    cnt = 0
                    yield (np.array(X), np.array(Y))
                    X = []
                    Y = []
        f.close()
    

    训练时候的代码如下:

    model.fit_generator(generate_arrays_from_file('./train',batch_size=batch_size),
            samples_per_epoch=25024,nb_epoch=nb_epoch,validation_data=(X_test, y_test),max_q_size=1000,verbose=1,nb_worker=1)

    3、关于samples_per_epoch的说明:

    我的训练数据,train只有25000行,batch_size=32。照理说samples_per_epoch=32,但是会有警告.UserWarning: Epoch comprised more than `samples_per_epoch` samples, which might affect learning results


    说明:这个出错的原因是train的数目/batch_size不是整数。可以将samples_per_epoch = ceil(train_num/batch_size) *batch_size.设置完的结果为88.72%:


    keras的demo使用的方法是将全部数据载入进来训练:


    demo的结果为88.86%,所以,该数据读取的方式基本没问题。但是,一定要将数据先进行打乱。如果能全部载入内存,就全部载入内存,速度会快不少



    展开全文
  • 在使用keras的model.fit(x, y)训练模型时,需要全部加载训练的数据,如果数据较小时(如mnist数据集),加载全部的数据没什么问题,但是当自己的数据集很大时(如10G),全部加载数据可能会导致内存溢出,或者仅仅...

            在使用keras的model.fit(x, y)训练模型时,需要全部加载训练的数据,如果数据较小时(如mnist数据集),加载全部的数据没什么问题,但是当自己的数据集很大时(如10G),全部加载数据可能会导致内存溢出,或者仅仅加载数据就需要用了很多等待时间,这样对使用Keras做实验非常不方便。当然,keras也提供另外的训练接口model.fit_generator,然后该方法的其中一个参数generator可以使用keras的ImageDataGenerator类,这个类封装得很完善,特别适用于多分类的模型读取数据集,但是有个缺点是文件的目录格式是固定的。具体的使用可以参考keras的文档,或者参考这个博客。但是,如果自己的数据存储格式和keras要求的格式不一致,就会有很多麻烦,当然你也可以把数据调整为keras的格式,不过由于数据集比较大,调整格式比较麻烦,那有没有其他的办法呢?

           答案是有的。比如创建自己的generator。如下就是我的创建过程:

    dataset.py (本次例子是一个二分类问题)

    from PIL import Image
    import os
    import numpy as np
    import keras
    from sklearn.model_selection import train_test_split
    from keras.preprocessing.image import ImageDataGenerator, load_img, img_to_array
    import glob
    from keras.datasets import cifar100
    
    # 加载数据, 全部加载数据的类型,数据集比较大,等待时间长,而且可能内存溢出
    def load_data(seq_names=['BOSSbase_1.01', './data/bossbase_wow040']):
        root_path = os.getcwd()
        tran_images = []
        labels = []
        # seq_names = ['BOSSbase_1.01', 'bossbase_hill040']
        for seq_name in seq_names:
            frames = sorted(os.listdir(os.path.join(root_path, seq_name)))
            i = 0
            for frame in frames:
                img_path = [os.path.join(root_path, seq_name, frame)]
                # print(img_path[0])
                imgs = Image.open(img_path[0])
                imgs = np.array(imgs, dtype=np.float32) # .resize((512, 512))
                # imgs /= 255
                # print(imgs.shape)
                tran_images.append(imgs)
                if seq_name == seq_names[0]:
                    labels.append(0)
                else:
                    labels.append(1)
                # i = i + 1
                # if i == 100:
                #     break
    
        tran_images = np.array(tran_images)
        tran_images = np.expand_dims(tran_images, axis=-1)
        labels = np.array(labels)
        # print('images_shape:'+str(tran_images.shape)+" labels_shape:"+str(labels.shape))
    
        return change_data(tran_images, labels)
    
    # 保证每个batch的stego和cover个数相同
    def change_data(tran_images, labels):
        lenght = tran_images.shape[0]
        tran_images_a = tran_images[:int(lenght/2)]
        tran_images_b = tran_images[int(lenght/2):]
        # print('tran_images_a.shape:'+str(tran_images_a.shape)+ ' tran_images_b.shape:'+str(tran_images_b.shape))
        labels_a = labels[:int(lenght/2)]
        labels_b = labels[int(lenght/2):]
        # print('labels_a.shape:' + str(labels_a.shape) + ' labels_b.shape:' + str(labels_b.shape))
    
        train_x = []
        train_y = []
    
        for i in range(int(lenght/2)):
            train_x.append(tran_images_a[i])
            train_x.append(tran_images_b[i])
            train_y.append(labels_a[i])
            train_y.append(labels_b[i])
    
        train_x = np.array(train_x)
        train_y = np.array(train_y)
    
        return train_x, train_y
    
    '''
    以下是创建自己的generator的具体代码
    '''
    
    # 同步对应打乱两个数组
    def shuffle_two_array(a, b):
        state = np.random.get_state()
        np.random.shuffle(a)
        np.random.set_state(state)
        np.random.shuffle(b)
        return a, b
    
    # 加载自己的数据,然后进行训练集和验证集分割,分割比例是9:1,这是是二分类为例子
    def load_game_data(cover_dir='./BOSSbase_1.01', stego_dir='bossbase_hill040', train_set=True):
        val_size = 0.1
        cover_files = sorted(glob.glob(os.path.join(cover_dir, '*')))
        stego_files = sorted(glob.glob(os.path.join(stego_dir, '*')))
        train_cover_files, valid_cover_files, train_stego_files, valid_stego_files = \
            train_test_split(cover_files, stego_files, test_size=val_size, random_state=0)
        # print("Using", len(train_cover_files) * 2, "samples for training and", len(valid_cover_files) * 2, "for validation.")
    
        train_images = []
        valid_images = []
        train_labels = []
        valid_labels = []
        # cover-stego交叉处理
        for i in range(len(train_cover_files)):
            # cover
            train_images.append(train_cover_files[i])
            train_labels.append(0)
            # stego
            train_images.append(train_stego_files[i])
            train_labels.append(1)
    
        for i in range(len(valid_cover_files)):
            # cover
            valid_images.append(valid_cover_files[i])
            valid_labels.append(0)
            # stego
            valid_images.append(valid_stego_files[i])
            valid_labels.append(1)
        train_images = np.array(train_images)
        train_labels = np.array(train_labels)
        valid_images = np.array(valid_images)
        valid_labels = np.array(valid_labels)
        # print(train_images)
        # print(train_images.shape)
        # print(train_labels.shape)
    
        if train_set:
            data = (train_images, train_labels) # 训练集
        else:
            data = (valid_images, valid_labels) # 验证集
        return data
    
    # 读取图片,代用了keras的接口
    def load_batch_image(img_path, target_size=(512, 512)):
        img = load_img(img_path, target_size)
        img = img_to_array(img)[:, :, 0] # convertd image to numpy array, only read r channel
        img = np.expand_dims(img, axis=-1)
        return img
    
    # 建立一个数据迭代器---generator
    def my_dataset_generator(batch_size,
                             cover_dir = '/home/chenbaoying/py_project/aletheia/BOSSbase_1.01',
                             stego_dir='/home/chenbaoying/py_project/aletheia/data/bossbase_wow040',
                             train_set=True): # train set:True, valid set:False
        X_samples, Y_samples = load_game_data(cover_dir=cover_dir,stego_dir=stego_dir, train_set=train_set)
        batch_num = int(len(X_samples) / batch_size)
        max_len = batch_num * batch_size
        X_samples = np.array(X_samples[:max_len])
        Y_samples = np.array(Y_samples[:max_len])
    
        X_batches = np.split(X_samples, batch_num)
        Y_batches = np.split(Y_samples, batch_num)
    
        i = 0 # 这个下标标记变量 i 一定要放在true外面
        n = len(X_batches)
        while True:
            for b in range(len(X_batches)):  # 这里使用一个没用的变量 b ,后面没使用
                i %= n # 求余防止数组溢出
                X_batches[i], Y_batches[i] = shuffle_two_array(X_batches[i], Y_batches[i])  # 打乱每个batch数据 
                X = np.array(list(map(load_batch_image, X_batches[i])))
                Y = np.array(Y_batches[i])
                # print(X.shape)
                i += 1
                yield X, keras.utils.to_categorical(Y)
    
    # Data augmentation,这个是keras的ImageDataGenerator的使用例子
    def DataGenerator():
        root_path = '/home'
        # train_datagen = ImageDataGenerator(rescale=1. / 255, shear_range=0.2, zoom_range=0.2, horizontal_flip=True)
        train_datagen = ImageDataGenerator()
        test_datagen = ImageDataGenerator()
        training_set = train_datagen.flow_from_directory(os.path.join(root_path, 'images', 'train'),
                                                         target_size=(1024, 1024),
                                                         batch_size=4,
                                                         class_mode='categorical',
                                                         color_mode='grayscale')
        test_set = test_datagen.flow_from_directory(os.path.join(root_path, 'images', 'my_valid'),
                                                    target_size=(1024, 1024),
                                                    batch_size=4,
                                                    class_mode='categorical',
                                                    color_mode='grayscale')
    
        return training_set, test_set
    
    if __name__ == '__main__':
        # X_samples, Y_samples = load_game_data(cover_dir='/home/images/train/cover', stego_dir='/home/images/train/stego')
        # print(X_samples.shape)
        # print(Y_samples.shape)
        generator = my_dataset_generator(batch_size=8, train_set=True)
        # generator = MyGenerator(batch_size=8)
        x, y = next(generator)
        print(x.shape)
        print(y.shape)
        # x, y = load_data()
        # print(x.shape)
        # print(y[0:10])
        # DataGenerator()
        pass
    

    下面是我的模型训练代码 model_test.py

     

    from keras_preprocessing.image import ImageDataGenerator
    from keras.optimizers import Adam, SGD, Adamax, Adadelta
    from keras.callbacks import TensorBoard, ModelCheckpoint
    import keras
    import os
    from network_keras import ye_Net # 导入自己的模型
    from dataset import load_data, my_dataset_generator # 导入dataset里面的my_dataset_generator
    from keras.utils import multi_gpu_model
    
    os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
    os.environ["CUDA_VISIBLE_DEVICES"] = "2,3"
    
    
    # print('start load data ...')
    # train_x, train_y = load_data()
    # training_set, test_set = DataGenrator()
    
    
    
    model = ye_Net(input_shape=(512, 512, 1))  # 这里的ye_Net是自己搭建的一个深度模型
    model = multi_gpu_model(model, gpus=2)
    model_path = './model_weight/ye_Net--10--0.3865.hdf5' # 这个是加载模型预训练模型的路劲
    
    try:
        model.load_weights(model_path)  # 加载模型
        print("...Previous weight data...")
    except:
        print("...New weight data...")
        pass
    
    train = True
    if train:
        adadelta = Adadelta(lr=0.4, decay=0.0005)
        model.compile(optimizer=adadelta, loss='categorical_crossentropy', metrics=['accuracy'])
        tensorboard = TensorBoard(log_dir='./logs', write_graph=True)
        checkpoint = ModelCheckpoint(filepath='./model_weight/ye_Net_hill020--{epoch:02d}--{val_loss:.4f}.hdf5',
                                     monitor='val_loss',
                                     verbose=1,
                                     save_best_only=True,
                                     period=5)
    
        batch_size = 8
        num_val = 2000  # 我的数据集总共有20000张,在dataset里面train:val=9:1分割数据,一定要填自己的文件分割后的个数
        num_train = 18000 # 同上
        history = model.fit_generator(my_dataset_generator(batch_size=8, stego_dir='./data/bossbase_hill020'),
                                      steps_per_epoch=max(1, num_train//batch_size),
                                      validation_data=my_dataset_generator(batch_size=8),
                                      validation_steps=max(1, num_val//batch_size),
                                      epochs=200,
                                      initial_epoch=0,
                                      shuffle=True)
    

     

    展开全文
  • keras中7大数据集datasets介绍 转载于:https://www.cnblogs.com/liuys635/p/11184217.html

    keras中7大数据集datasets介绍

    转载于:https://www.cnblogs.com/liuys635/p/11184217.html

    展开全文
  • 哈喽。...比如自己写个next,边读边训练】,那么keras同样也可以,比如DataGenerater和fit_generator,下面我就试试我占用内存30多个G的数据。 1-首先我先把模型修改好,能训练数据。 采用tf.keras...

    哈喽。模型落地过程中遇到很多问题,我都要去经历、填坑。人生何处不是坑??

    有坑才有坑!

    如果tf可以分批次读入内存数据【比如tfrecords,这个我最不推荐了,麻烦;比如自己写个next,边读边训练】,那么keras同样也可以,比如DataGenerater和fit_generator,下面我就试试我占用内存30多个G的数据。

    1-首先我先把模型修改好,能训练数据。

    采用tf.keras中的Dense可以重新写一个dense,然后进行训练数据。

    大佬说让我看这个链接,比较难搞啊,它这是图像中的,而我需要将它读懂,简化成返回X,y这种形式。

     

     

     

    另外有相关问题可以加入QQ群讨论,不设微信群

    QQ群:868373192 

    语音深度学习及信号处理群

    展开全文
  • 简介 官方提供的.flow_from_directory(directory)函数可以读取并训练大规模训练数据,基本可以满足大部分需求,可以参考我的笔记。但是在有些场合下,需要自己读取大规模数据以及对应标签,下面提供一种方法。...
  • 在本文中,我们将讨论如何使用Keras在不适合内存的大数据集上训练我们的深度学习网络。 介绍 深度学习算法优于所有其他算法,能够在大多数问题上产生最先进的结果。深度学习算法成功的主要原因是数据集的大小...
  • 浅谈大数据平台架构

    2019-04-29 00:00:40
    什么是大数据平台 有三个疑问: 1.使用Cloudera或Hortonworks之类的Hadoop发行版本公司的提供的Hadoop套件,配置些参数,找几台服务器部署起来就算是一套大数据平台吗? 2.数据开发人员平时的工作是不是写些MR或者SQL...
  • 使用Keras如果要使用大规模数据集对网络进行训练,就没办法先加载进内存再从内存直接传到显存了,除了使用Sequence类以外,还可以使用迭代器去生成数据,但迭代器无法在fit_generation里开启多进程,会影响数据的...
  • 参考1 参考2 train_on_batch
  • 基于大数据风控方向的大数据计算平台需求整理 背景 为响应国家深化金融体制改革的要求,各大金融机构都在探索服务下沉,包括信托行业在内,很多金融机构都在尝试消费金融各种场景。而信托行业在进军消费金融的路上...
  • 什么是大数据平台 有三个疑问: 1.使用Cloudera或Hortonworks之类的Hadoop发行版本公司的提供的Hadoop套件,配置些参数,找几台服务器部署起来就算是一套大数据平台吗? 2.数据开发人员平时的工作是不是写些MR或者...
  • 在本文中,作者提出了用于大数据平台大数据工作流的分布式深度学习框架BigDL。它是基于Apache Spark实现的,允许用户将其深度学习应用程序编写为标准的Spark程序(以分布式方式直接在大型数据集群上运行)。它提供...
  • 官方提供的.flow_from_directory(directory)函数可以读取并训练大规模训练数据,基本可以满足大部分需求。但是在有些场合下,需要自己读取大规模数据以及对应标签,下面...from keras.preprocessing.image import ...
  • http://blog.csdn.net/zhoubl668/article/details/45559955 http://keras-cn.readthedocs.io/en/latest/#keras_1
  • Keras实现自定义层

    2020-01-31 18:38:17
    Keras是一个高度封装的库,它的优点是可以进行快速的建模,缺点是它不处理底层运算,如张量内积等。为了弥补这个问题,Keras提供“后端引擎”来实现底层运算操作。目前Keras支持的后端引擎有tensorflow,CNTK,...
  • 转载:https://blog.csdn.net/leadai/article/details/79999785内存溢出问题是参加kaggle比赛或者做大数据量实验的第一个拦路虎。以前做的练手小项目导致新手产生一个惯性思维——读取训练集图片的时候把所有图读到...
  • 大数据开发必备技能

    2019-04-26 18:07:26
    所谓ABC者,AI + Big Data + Cloud也,即人工智能、大数据和云计算(云平台)。每个领域目前都有行业领袖在引领前行,今天我们来讨论下大数据Big Data这个方向。 二,大数据里面的角色 角色一:大数据工程 大数据工程...
  • 大数据组件图谱 ...文件系统数据存储内存技术数据搜集消息系统数据处理查询引擎分析和报告工具调度与管理服务机器学习开发平台 文件系统  HDFS Hadoop Distributed File S
1 2 3 4 5 ... 20
收藏数 4,044
精华内容 1,617
关键字:

keras 产品 大数据平台