精华内容
下载资源
问答
  • 本文将介绍如何使用较数据从头开始训练一个新的深度学习模型。首先在一个2000个训练样本上训练一个简单的小型卷积神经网络,不任何正则化,为模型目标设定一个基准。这会得到71%的分类精度。此时的主要问题...

    使用深度学习分类猫狗图片

     


    前言

    本文将介绍如何使用较少的数据从头开始训练一个新的深度学习模型。首先在一个2000个训练样本上训练一个简单的小型卷积神经网络,不做任何正则化,为模型目标设定一个基准。这会得到71%的分类精度。此时的主要问题在于过拟合。然后我们将会介绍数据增强(data augmentation),它在计算机领域是一种非常强大的降低过拟合de技术。使用数据增强后,网络精度将达到82%。


    提示:本案例使用keras作为训练架构

    一、下载数据

     1.引入库

     本节用到的猫狗分类数据集不包含在 Keras 中。它由 Kaggle 在 2013 年末公开并作为一项 计算视觉竞赛的一部分,当时卷积神经网络还不是主流算法。你可以从 https://www.kaggle.com/ c/dogs-vs-cats/data 下载原始数据集。这些图像都是中等分辨率的彩色 JPEG 图像。

      2.将图像复制到训练、验证和测试的目录

    分别为猫,狗创建训练、验证、测试文件夹

    import os, shutil
    
    #原始数据集解压目录的路径
    original_dataset_dir = '/Users/fchollet/Downloads/kaggle_original_data'
    
    #保存较小数据集的目录
    base_dir = '/Users/fchollet/Downloads/cats_and_dogs_small' 
    os.mkdir(base_dir)
    
    #分别对应划分后的训练、 验证和测试的目录
    train_dir = os.path.join(base_dir, 'train') 
    os.mkdir(train_dir)
    validation_dir = os.path.join(base_dir, 'validation') 
    os.mkdir(validation_dir)
    test_dir = os.path.join(base_dir, 'test') 
    os.mkdir(test_dir)
    # 猫、狗的训练集
    train_cats_dir = os.path.join(train_dir, 'cats') 
    os.mkdir(train_cats_dir)
    train_dogs_dir = os.path.join(train_dir, 'dogs')
    os.mkdir(train_dogs_dir)
    # 猫、狗的验证集
    validation_cats_dir = os.path.join(validation_dir, 'cats') 
    os.mkdir(validation_cats_dir)
    validation_dogs_dir = os.path.join(validation_dir, 'dogs') 
    os.mkdir(validation_dogs_dir)
    # 猫、狗的测试集
    test_cats_dir = os.path.join(test_dir, 'cats') 
    os.mkdir(test_cats_dir)
    test_dogs_dir = os.path.join(test_dir, 'dogs') 
    os.mkdir(test_dogs_dir)
    
    

    将猫咪的图片复制到对应的文件夹中

    """
    将前 1000 张猫的图像复制 到 train_cats_dir
    """
    fnames = ['cat.{}.jpg'.format(i) for i in range(1000)] 
    for fname in fnames:
        src = os.path.join(original_dataset_dir, fname) 
        dst = os.path.join(train_cats_dir, fname) 
        shutil.copyfile(src, dst)
    """
    将接下来 500 张猫的图像复 制到 validation_cats_dir
    """
    fnames = ['cat.{}.jpg'.format(i) for i in range(1000, 1500)] 
    for fname in fnames:
        src = os.path.join(original_dataset_dir, fname) 
        dst = os.path.join(validation_cats_dir, fname) 
        shutil.copyfile(src, dst)
    """
    将接下来的 500 张猫的图像 复制到 test_cats_dir
    """
    fnames = ['cat.{}.jpg'.format(i) for i in range(1500, 2000)] 
    for fname in fnames:
        src = os.path.join(original_dataset_dir, fname) 
        dst = os.path.join(test_cats_dir, fname) 
        shutil.copyfile(src, dst)

     将狗的照片复制到对应的文件夹中

    """
    将前 1000 张狗的图像复制 到 train_dogs_dir
    """
    fnames = ['dog.{}.jpg'.format(i) for i in range(1000)] 
    for fname in fnames:
        src = os.path.join(original_dataset_dir, fname) 
        dst = os.path.join(train_dogs_dir, fname) 
        shutil.copyfile(src, dst)
    """
    将接下来 500 张狗的图像复 制到 validation_dogs_dir
    """
    fnames = ['dog.{}.jpg'.format(i) for i in range(1000, 1500)] 
    for fname in fnames:
        src = os.path.join(original_dataset_dir, fname) 
        dst = os.path.join(validation_dogs_dir, fname) 
        shutil.copyfile(src, dst)
    """
    将接下来 500 张狗的图像复 制到 test_dogs_dir
    """
    fnames = ['dog.{}.jpg'.format(i) for i in range(1500, 2000)] 
    for fname in fnames:
        src = os.path.join(original_dataset_dir, fname) 
        dst = os.path.join(test_dogs_dir, fname) 
        shutil.copyfile(src, dst)

    我们来检查一下,看看每个分组(训练 / 验证 / 测试)中分别包含多少张图像。

    >>> print('total training cat images:', len(os.listdir(train_cats_dir))) 
    total training cat images: 1000
    >>> print('total training dog images:', len(os.listdir(train_dogs_dir))) 
    total training dog images: 1000
    >>> print('total validation cat images:', len(os.listdir(validation_cats_dir))) 
    total validation cat images: 500
    >>> print('total validation dog images:', len(os.listdir(validation_dogs_dir))) 
    total validation dog images: 500
    >>> print('total test cat images:', len(os.listdir(test_cats_dir))) 
    total test cat images: 500
    >>> print('total test dog images:', len(os.listdir(test_dogs_dir))) 
    total test dog images: 500
    

    所以我们的确有 2000 张训练图像、1000 张验证图像和 1000 张测试图像。每个分组中两个 类别的样本数相同,这是一个平衡的二分类问题,分类精度可作为衡量成功的指标。 

    二、建立模型

    我将要构建一个小型卷积神经网络,即复用相同的总体结构,即卷积神经网络由 Conv2D 层(使用 relu 激活)和 MaxPooling2D 层交替堆叠构成。

    但由于这里要处理的是更大的图像和更复杂的问题,你需要相应地增大网络,即再增加一 个 Conv2D+MaxPooling2D 的组合。这既可以增大网络容量,也可以进一步减小特征图的尺寸, 使其在连接 Flatten 层时尺寸不会太大。本例中初始输入的尺寸为 150×150(有些随意的选 择),所以最后在 Flatten 层之前的特征图大小为 7×7。

    注意:网络中特征图的深度在逐渐增大(从 32 增大到 128),而特征图的尺寸在逐渐减小(从 150×150 减小到 7×7)。这几乎是所有卷积神经网络的模式。

    1.小型卷积神经网络实例化

    代码如下(示例):

    from keras import layers
    from keras import models
    
    model = models.Sequential() 
    model.add(layers.Conv2D(32, (3, 3), activation='relu',
                                    input_shape=(150, 150, 3)))     
    model.add(layers.MaxPooling2D((2, 2)))
    model.add(layers.Conv2D(64, (3, 3), activation='relu')) 
    model.add(layers.MaxPooling2D((2, 2))) 
    model.add(layers.Conv2D(128, (3, 3), activation='relu')) 
    model.add(layers.MaxPooling2D((2, 2))) 
    model.add(layers.Conv2D(128, (3, 3), activation='relu')) 
    model.add(layers.MaxPooling2D((2, 2)))
    
    model.add(layers.Flatten()) 
    model.add(layers.Dense(512, activation='relu')) 
    model.add(layers.Dense(1, activation='sigmoid'))

    2.我们来看一下特征图的维度如何随着每层变化。

    代码如下(示例):

    >>> model.summary()
    _________________________________________________________________
    
    Layer (type) Output Shape Param # 
    =================================================================
    conv2d_1 (Conv2D) (None, 148, 148, 32) 896 
    _________________________________________________________________
    max_pooling2d_1 (MaxPooling2D) (None, 74, 74, 32) 0 
    _________________________________________________________________
    conv2d_2 (Conv2D) (None, 72, 72, 64) 18496 
    _________________________________________________________________
    max_pooling2d_2 (MaxPooling2D) (None, 36, 36, 64) 0 
    _________________________________________________________________
    conv2d_3 (Conv2D) (None, 34, 34, 128) 73856 
    _________________________________________________________________
    max_pooling2d_3 (MaxPooling2D) (None, 17, 17, 128) 0 
    _________________________________________________________________
    conv2d_4 (Conv2D) (None, 15, 15, 128) 147584 
    _________________________________________________________________
    max_pooling2d_4 (MaxPooling2D) (None, 7, 7, 128) 0 
    _________________________________________________________________
    flatten_1 (Flatten) (None, 6272) 0 
    _________________________________________________________________ 
    5 dense_1 (Dense) (None, 512) 3211776 
    _________________________________________________________________
    dense_2 (Dense) (None, 1) 513 
    =================================================================
    Total params: 3,453,121
    Trainable params: 3,453,121
    Non-trainable params: 0

    在编译这一步,和前面一样,我们将使用 RMSprop 优化器。因为网络最后一层是单一 sigmoid 单元,所以我们将使用二元交叉熵作为损失函数

    3.配置模型用于训练

    from keras import optimizers
    
    model.compile(loss='binary_crossentropy', 
                optimizer=optimizers.RMSprop(lr=1e-4),
                metrics=['acc'])
    

    三、数据预处理

    将数据输入神经网络之前,应该将数据格式化为经过预处理的浮点数张量。 现在,数据以 JPEG 文件的形式保存在硬盘中,所以数据预处理步骤大致如下。

    1.  读取图像文件。

    2.  将 JPEG 文件解码为 RGB 像素网格。

    3.  将这些像素网格转换为浮点数张量。

    4.  将像素值(0~255 范围内)缩放到 [0, 1] 区间(正如你所知,神经网络喜欢处理较小的输入值)。

    Keras 拥有自动完成这些步骤的工具。Keras 有一个图像处理辅助工具的模块,位于 keras.preprocessing.image。特别地,它包含 ImageDataGenerator 类,可以快速创建 Python 生成器,能够将硬盘上的图像文件自动转换 为预处理好的张量批量。下面我们将用到这个类。

    使用 ImageDataGenerator 从目录中读取图像

    from keras.preprocessing.image import ImageDataGenerator
    
    """
    将所有的像素除以255,保证数值大小在[0,1]之间
    """
    train_datagen = ImageDataGenerator(rescale=1./255) 
    test_datagen = ImageDataGenerator(rescale=1./255)
    
    """
    Python 生成器(Python generator)是一个类似于迭代器的对象,一个可以和 for ... in 运算符一起使用的对象。生成器是用 yield 运算符来构造的。
    将图像大小调整为150*150
    """
    train_generator = train_datagen.flow_from_directory(
        train_dir, 
        target_size=(150, 150), 
        batch_size=20, 
        class_mode='binary')
    
    """
    因为使用了binary_crossentropy损失,所以需要用二进制标签
    """
    validation_generator = test_datagen.flow_from_directory( 
        validation_dir,
        target_size=(150, 150), 
        batch_size=20, 
        class_mode='binary')
    
    
    

     我们来看一下其中一个生成器的输出:它生成了 150×150 的 RGB 图像[形状为 (20, 150, 150, 3)]与二进制标签[形状为 (20,)]组成的批量。每个批量中包含 20 个样本(批 量大小)。注意,生成器会不停地生成这些批量,它会不断循环目标文件夹中的图像。因此,你 需要在某个时刻终止(break)迭代循环。

    >>> for data_batch, labels_batch in train_generator:
    >>> print('data batch shape:', data_batch.shape)
    >>> print('labels batch shape:', labels_batch.shape) 
    >>> break
    data batch shape: (20, 150, 150, 3) labels batch shape: (20,)

     利用生成器,我们让模型对数据进行拟合。我们将使用 fit_generator 方法来拟合,它 在数据生成器上的效果和 fit 相同。它的第一个参数应该是一个 Python 生成器,可以不停地生 成输入和目标组成的批量,比如 train_generator。因为数据是不断生成的,所以 Keras 模型 要知道每一轮需要从生成器中抽取多少个样本。这是 steps_per_epoch 参数的作用:从生成 器中抽取 steps_per_epoch 个批量后(即运行了 steps_per_epoch 次梯度下降),拟合过程 将进入下一个轮次。本例中,每个批量包含 20 个样本,所以读取完所有 2000 个样本需要 100 个批量。

    使用 fit_generator 时,你可以传入一个 validation_data 参数,其作用和在 fit 方 法中类似。值得注意的是,这个参数可以是一个数据生成器,但也可以是 Numpy 数组组成的元 组。如果向 validation_data 传入一个生成器,那么这个生成器应该能够不停地生成验证数 据批量,因此你还需要指定 validation_steps 参数,说明需要从验证生成器中抽取多少个批 次用于评估。

    利用批量生成器拟合模型

    history = model.fit_generator( 
        train_generator,
        steps_per_epoch=100,
        epochs=30, 
        validation_data=validation_generator, 
        validation_steps=50)
    model.save('cats_and_dogs_small_1.h5')

    绘制训练过程中的损失曲线和精度曲线

    import matplotlib.pyplot as plt
    
    acc = history.history['acc']
    val_acc = history.history['val_acc'] 
    loss = history.history['loss'] 
    val_loss = history.history['val_loss']
    
    epochs = range(1, len(acc) + 1)
    
    plt.plot(epochs, acc, 'bo', label='Training acc') 
    plt.plot(epochs, val_acc, 'b', label='Validation acc') 
    plt.title('Training and validation accuracy') 
    plt.legend()
    
    plt.figure()
    
    plt.plot(epochs, loss, 'bo', label='Training loss') 
    plt.plot(epochs, val_loss, 'b', label='Validation loss') 
    plt.title('Training and validation loss')
    plt.legend()
    
    plt.show()

    训练精度曲线如下:

    训练损失和验证损失:

    从这些图像中都能看出过拟合的特征。训练精度随着时间线性增加,直到接近 100%,而验 证精度则停留在 70%~72%。验证损失仅在 5 轮后就达到最小值,然后保持不变,而训练损失则 一直线性下降,直到接近于 0。

    因为训练样本相对较少(2000 个),所以过拟合是你最关心的问题。前面已经介绍过几种 降低过拟合的技巧,比如 dropout 和权重衰减(L2 正则化)。现在我们将使用一种针对于计算 机视觉领域的新方法,在用深度学习模型处理图像时几乎都会用到这种方法,它就是数据增强(data augmentation)。

    四、使用数据增强

    在 Keras 中,这可以通过对 ImageDataGenerator 实例读取的图像执行多次随机变换来实 现。我们先来看一个例子。

    datage = ImageDataGenerator(
            rotation_range = 40,      # 是角度值(在 0~180 范围内),表示图像随机旋转的角度范围。
            width_shift_range = 0.2,  # 是图像在水平或垂直方向上平移的范围(相对于总宽度或总高度的比例)。
            height_shift_range= 0.2,
            shear_range= 0.2,         # 是随机错切变换的角度。
            zoom_range= 0.2,          # 是图像随机缩放的范围
            horizontal_flip= True,    # 是随机将一半图像水平翻转。如果没有水平不对称的假设
            fill_mode= 'nearest'      # 是用于填充新创建像素的方法,
        )

    显示几个增强训练后的训练图像,代码如下:

    from keras.preprocessing import image
    
    fnames = [os.path.join(train_cats_dir, fname) for fname in os.listdir(train_cats_dir)]
    img_path = fnames[100]
    img = image.load_img(img_path, target_size=(150, 150))
    x = image.img_to_array(img) # 将其转换为形状 (150, 150, 3) 的 Numpy 数组
    x = x.reshape((1,) + x.shape) # 将其形状改变为 (1, 150, 150, 3)
    
    i =0
    train_generator = datage.flow(x, batch_size=1)
    for batch in train_generator:
        plt.figure(i)
        imgplot = plt.imshow(image.array_to_img(batch[0]))
        i += 1
        if i%4 == 0:
            break
    plt.show()

    如果你使用这种数据增强来训练一个新网络,那么网络将不会两次看到同样的输入。但网络看到的输入仍然是高度相关的,因为这些输入都来自于少量的原始图像。你无法生成新信息, 而只能混合现有信息。因此,这种方法可能不足以完全消除过拟合。为了进一步降低过拟合, 你还需要向模型中添加一个 Dropout 层,添加到密集连接分类器之前。

    model = models.Sequential() 
    model.add(layers.Conv2D(32, (3, 3), activation='relu',
                                input_shape=(150, 150, 3))) 
    model.add(layers.MaxPooling2D((2, 2)))
    model.add(layers.Conv2D(64, (3, 3), activation='relu')) 
    model.add(layers.MaxPooling2D((2, 2))) 
    model.add(layers.Conv2D(128, (3, 3), activation='relu')) 
    model.add(layers.MaxPooling2D((2, 2))) 
    model.add(layers.Conv2D(128, (3, 3), activation='relu')) 
    model.add(layers.MaxPooling2D((2, 2))) model.add(layers.Flatten()) model.add(layers.Dropout(0.5)) 
    model.add(layers.Dense(512, activation='relu')) model.add(layers.Dense(1, activation='sigmoid'))
    model.compile(loss='binary_crossentropy', optimizer=optimizers.RMSprop(lr=1e-4),
                metrics=['acc'])

    更改完成神经网络模型后,再利用数据增强生成器训练卷积神经网络

        train_datagen = ImageDataGenerator( rescale=1./255,
            rotation_range=40,
            width_shift_range=0.2, 
            height_shift_range=0.2,
            shear_range=0.2, 
            zoom_range=0.2, 
            horizontal_flip=True,)
    
        test_datagen = ImageDataGenerator(rescale=1./255)#  不能增强验证数据集
    
        train_generator = train_datagen.flow_from_directory(
            dataProcess.train_dir,  # 路径
            target_size=(150, 150),  # 图像大小
            batch_size=20,  # 每批量样本大小
            class_mode='binary'  # 因为使用了binary_crossentropy损失函数,所以用二进制标签
        )
    
        validation_generator = test_datagen.flow_from_directory(
            dataProcess.validation_dir,
            target_size=(150, 150),
            batch_size=20,
            class_mode='binary'
        )
    
    
        history = model.fit_generator(
            train_generator,
            steps_per_epoch=100,  # 2000/20
            epochs=100,
            validation_data=validation_generator,  # 也可以用元组作为参数
            validation_steps=50  # 说明要从验证生成器中抽取多少个批次用于评估
        )
    
        # 记得讲训练好的模型保存下来
        model.save('cats_and_dogs_small_1.h5')

    最后,将训练、验证数据集中的acc与loss打印出来,绘制出图表,代码如下:

        acc = history.history['acc']
        val_acc = history.history['val_acc']
        loss = history.history['loss']
        val_loss = history.history['val_loss']
    
        print("acc", acc)
        print("val_acc", val_acc)
        print("loss", loss)
        print("val_loss", val_loss)
    
    
    
    
    
        epochs = range(1, len(acc) + 1)
        plt.plot(epochs, acc, 'bo', label='Training acc')
        plt.plot(epochs, val_acc, 'b', label='Validation acc')
        plt.title('Training and validation accuracy')
        plt.legend()
        plt.figure()
        plt.plot(epochs, loss, 'bo', label='Training loss')
        plt.plot(epochs, val_loss, 'b', label='Validation loss')
        plt.title('Training and validation loss')
        plt.legend()
    
        plt.show()

    最后显示出来的loss变化图像如下:

    acc变化图像如下:

    可以看到,最后的验证准确率可以到达82%

     

    总结

    懒得写了

    展开全文
  • 大话数据结构

    2018-12-14 16:02:18
    《璇玑图》共八百四十字,纵横各十九字,纵、横、斜、交互、正、反读或退一字、迭一字读均可成诗,诗有三、四、五、六、七言不等,目前有人统计可组成七千九百五十八首诗。听清楚哦,是7958首。 第6章树 149 6.1...
  • 数据运营思维导图

    2018-04-26 14:24:22
    —怎么好“运筹”,数据分析告诉你 以往鉴来,未卜先知 —怎么发现历史的规律以预测未来,数据分析告诉你 工作思维 对业务的透彻理解是数据分析的前提 数据分析是精细化运营,要建立起体系化思维(金字塔思维...
  • 即我期望能够对文本数据(并非词向量)语义分割(二分类),其中原始数据行列分别为10000、39,但标签为1的行特别,可以想象的是,如果在图像中,仅仅只有若隐若现的几个白点,其余都是黑点,如何很好的考虑行列...

    以前没有接触过计算机和深度学习,因此对于很多问题不太了解,望海涵。
    本文主要是梳理个人对卷积神经网络输入的相关问题,即我期望能够对文本数据(并非词向量)做语义分割(二分类),其中原始数据行列分别为10000、39,但标签为1的行特别少,可以想象的是,如果在图像中,仅仅只有若隐若现的几个白点,其余都是黑点,如何很好的考虑行列间的关系呢?
    我最初是怀着无限的热忱从事卷积网络的应用的,因为在数据处理与分析中它无疑是一把很锋利的“刀”,但现在冷静下来,我必须要重新考虑和回顾卷积网络的某些问题,它能否帮助我实现我最初的目的呢?

    网上相关资料有很多,我这里也是在阅读中摘取一下给我灵感的句子:

    1. 用 CNN 做图像识别,输入层是图像的像素点,且图片中的单个物体像素点是连续的,卷积核在输入层滑动时可以方便的提取到图片中的物体特征;另外,图片的像素点组成一个矩阵,这便于卷积核上下左右滑动提取特征。然而对于文本数据,文本中的词语却是离散的,比如“虽然……但是……”,这里“虽然”和“但是”显然具有关联的关系,但是它们之间却可能在句子中相隔很远,卷积核很难提取到这样的具有长距离依赖的词语之间的关系。

    2. 相比于图像的像素点矩阵中的元素具有天然的稠密性,传统机器学习中的文本分类方法一般使用 bag of words 模型来表示文本的向量,它具有高维、稀疏的特性,这不适合作为 CNN 的输入,所以用词嵌入的方法来解决,即作为输入层,我们必须要得到一个二维矩阵,矩阵中的每一行对应着不同的词,不同的词用不同的向量表示。相比于图像的像素点矩阵中的元素具有天然的稠密性,传统机器学习中的文本分类方法一般使用 bag of words 模型来表示文本的向量,它具有高维、稀疏的特性,这不适合作为 CNN 的输入,所以用词嵌入的方法来解决,即作为输入层,我们必须要得到一个二维矩阵,矩阵中的每一行对应着不同的词,不同的词用不同的向量表示。

    3.卷积操作其实就是卷积核矩阵和对应的输入层中一小块矩阵的点积相乘,卷积核通过权重共享的方式,按照步幅上下左右的在输入层滑动提取特征,以此将输入层做特征映射(features map)作为输出层,但在 NLP 中,由于词嵌入层中每一行都表示一个词语,我们在句子里面提取有利于分类的特征肯定是需要从词语(word)或者字符(char)级别去提取,也就是卷积宽口的宽度应该覆盖完全单个词向量,也就是 CNN 的卷积核宽度必须要等于词向量的维度
    ——————————————————————————————————————————————————————上面三点是我在知乎上看一位大神所写,给我茅塞顿开的感觉,但是细思一下,虽然不太懂词向量和文本分类这些知识点,但是大致明白一个词会有一个对应的一维向量,而每个卷积核能够对这一组向量直接提取进行分类,但是很明显的,如果我用这样的方式,我无法考虑20列数据之间的内在关系,仅仅考虑10000行的关系。(这或许也正是语义分割中往往是单通道的原因吧?tensor = 1)
    ——————————————————————————————————————————————————————
    显然,我最初的目的是考虑行列之间的潜在关系,例如,图像上像素点之间的空间关系,还包括每个像素点RGB值的数据关系,很不幸,我的数据tensor等于20。
    然而,我在学习之初尝试仅仅对数据列属性值关系的考虑,这个用很简单的全连接网络就可以实现,网上也有很多资料,但是这仅仅像是非线性的聚类分析,无法考虑数据点间的空间关系,我老板是不满意的。

    当然,我算是比较固执的人,必须要反驳他,至于对不对就另做他想。以下是我当初坚持的依据:

    (1)卷积网络大多是用于图像分析,而对于图像识别任务来说,每个像素和其周围像素的联系是比较紧密的,和离得很远的像素的联系可能就很小了。如果一个神经元和上一层所有神经元相连,那么就相当于对于一个像素来说,把图像的所有像素都等同看待。(这是卷积网络与全连接网络的区别,但是也显示了卷积网络的优点,但是不知道各位发现没有,如果我分析的对象只有一个点,如果和周围像素本来存在联系差异就不大,会出现什么状况?)
    (2)我这样的数据,如果用语义分割的方法来得到关于每个点的分类概率值,是极易出现正负样本不均衡的现象的,在网上提到过很多解决的方法,但是效果甚微。
    (3)…忘词了
    ——————————————————————————————————————————————————
    总的来说,我开始犹豫和局促,样本输入问题该如何解决,到底是从网络结构着手还是训练数据着手,我实在是无法肯定,静下心看过部分文献以后,例如地震预测等,发现应用文本点数据应该是可以的,但是我应该将每个点数据转化为tensor为1的矩阵形式?
    ——————————————————————————————————————————————————
    嗯,仅仅随心的记录一下

    展开全文
  • 2019数据运营思维导图

    2019-03-29 21:34:09
    数据运营 作用&意义 知错能改,善莫大焉 —错在哪里,数据分析告诉你 运筹帷幄,决胜千里 —怎么好“运筹”,数据分析告诉你 以往鉴来,未卜先知 —怎么发现历史的规律以预测未来,数据分析告诉你 工作思维 对业务...
  • 内容简介 《Origin 8.0实用教程:科技...然而,当时Origin7 0/7.5的教材已经有两本,而且Origin7.5已经升级到SR6,7.5版已经出现了一些明显的不足之处,必须更大的改进才行,因此笔者感觉到8.0的推出应该为期不远吧。
  • LCQMC任务是在口语化描述的数据集上文本的相似性预测。 We will use LCQMC dataset for fine-tuning, it is oral language corpus, it is used to train and predict semantic similarity of a pair of sentences....
  • 如何将弱分类器组合成一个强分类器。 先简单的回答: 提高那些被前一轮弱分类器错误分类样本的权值(因为它们的数量。需要在下一轮训练的时候给予他们更大的关注)。 -加权多数表决,误差率小的分类器...

    提升方法需要回答两个问题

    • 一是在每一轮如何改变训练数据的权值和概率分布
    • 二是如何将弱分类器组合成一个强分类器。

    先对上述问题做简单的回答:

    • 提高那些被前一轮弱分类器错误分类样本的权值(因为它们的数量少。需要在下一轮训练的时候给予他们更大的关注)。
    • 加权多数表决,误差率小的分类器权值比较大。

    Adaboost

    输入: 训练集T=(x1,y1),(x2,y2),(x3,y3),...,(xN,yN)T=(x1,y1),(x2,y2),(x3,y3),...,(xN,yN), 其中xXRn,yiY={+1,1}x∈XRn,yi∈Y={+1,−1} ; 弱学习算法
    输出:最终分类器G(x)

    1. 初始化权值分布D1=(w1,1,...,w1,i,...,w1,N)D1=(w1,1,...,w1,i,...,w1,N)
    2. 对 m = 1, … , M

      1) 训练弱分类器GiGi
      2) 计算当前弱学习器的误差率emem:

      em=P(Gm(xi)yi)=Gm(xiyi)wmiem=P(Gm(xi)≠yi)=∑Gm(xi≠yi)wmi
      emem的本质是被Gm(x)Gm(x)误分类样本分类器的G_i(x).
      3) 计算权值αmαm,
      αm=12log1ememαm=12log1−emem
      可以看出,emem越大,则αmαm越小(误差大的权重小)。
      4) 更新数据集的权值分布
      Dm+1=(wm+1,1,...,wm+1,i,...,wm+1,N)Dm+1=(wm+1,1,...,wm+1,i,...,wm+1,N)
      wm+1,i=wmiZmexp(αmyiGm(xi)),i=1,2,3,...Nwm+1,i=wmiZmexp(−αmyiGm(xi)),i=1,2,3,...N
      Zm=j=1Nwmjexp(αmyjGm(xj))Zm=∑j=1Nwmjexp(−αmyjGm(xj))

      ZmZm是归一化因子,它使Dm+1Dm+1 成为一个概率分布
      wm+1,iwm+1,i 还可以写成:
      wm+1,i=wmiZmexp(αm),Gm(xi)=yiwm+1,i=wmiZmexp(−αm),Gm(xi)=yi

      wm+1,i=wmiZmexp(αm),Gm(xi)yiwm+1,i=wmiZmexp(αm),Gm(xi)≠yi

      所以,我们可以再次看出,误分类的样本的权值比正确分类的样本权值高。误分类样本的权值被放大e2αm=em1eme2αm=em1−em
    3. 构建弱分类器的组合
      f(x)=mMαmGm(x)f(x)=∑mMαmGm(x)

      αmαm将决定不同分类器的权重 4.
    展开全文
  • 索引介绍 ...、索引的业务逻辑功能分类 索引的本质目的是帮助我们快速定位想要查找的数据 普通索引 无任何约束,主要用于提高查询效率 唯一索引 有数据唯一性约束,一张表可以存在多个唯一索引 主键索引

    索引介绍

    索引是用来优化sql的,索引可以提升效率,但是也有可能引起效率降低,所以我们必须要知道如何合理使用索引!

    一、确定何时使用索引

    • 整个数据表的数据量少时不需要索引(万级以下)
    • 字段的重复度较大,即不同值较少,例如性别,不需要索引
    • 也有例外,如果性别比是9:1,那么对比例少的做索引也可以加快查询,即留意分布情况

    二、索引的业务逻辑功能分类

    索引的本质目的是帮助我们快速定位想要查找的数据
    1. 普通索引
      无任何约束,主要用于提高查询效率
    2. 唯一索引
      有数据唯一性约束,一张表可以存在多个唯一索引
    3. 主键索引
      唯一且不能为空的约束,一张表最多只有一个主键索引
    4. 全文索引
      使用不多,musql只支持英文,我们可采用elasticsearch和Solr

    三、索引的物理实现分类

    • 非聚集索引
    1. 数据库系统会有单独存储空间存放非聚集索引
    2. 索引按顺序存储,维护一个索引表
    3. 索引指向的内容是随机存储的
    4. 系统做两次查找,先找索引,再找索引对应内容
    • 聚集索引
    1. 数据行按照索引排序方式进行存储
    2. 一个表只能有一个聚集索引,因为数据要只能按一种顺序存储嘛
    • 区别:
    1. 聚集索引叶子节点存储的是数据记录,而非聚集索引是数据位置。即非聚集索引不影响数据表的物理存储顺序
    2. 聚集索引一表仅一个,非聚集可以多个
    3. 聚集索引查询效率高,但增删改的效率比非聚集索引低
    • 一些结论
      对 WHERE 子句的字段建立索引,可以大幅提升查询效率。
      采用聚集索引进行数据查询,比使用非聚集索引的查询效率略高。如果查询次数比较多,还是尽量使用主键索引进行数据查询。

    四、索引的字段个数分类

    • 单一索引
      索引列为一列

    • 联合索引
      多个列组合在一起创建的索引,需注意创建的顺序问题。遵从最左匹配原则。即按照最左优先的方式进行索引匹配,左边匹配不到,后面都搞不了。联合索引就可能没用上了

    • 应用:联合主键

    总结

    索引缺点:占用存储空间,降低数据库写操作的性能,多个索引的存在增加了索引选择时间

    平衡索引的利弊:提高查询效率or维护索引的代价?

    展开全文
  • asp.net知识库

    2015-06-18 08:45:45
    与DotNet数据对象结合的自定义数据对象设计 () 数据集合与DataTable 与DotNet数据对象结合的自定义数据对象设计 (一) 数据对象与DataRow ASP.NET中大结果集的分页[翻译] .net 2.0 访问Oracle --与Sql Server的...
  • 如何做到每天比别人写200行代码? 三天撸了个中国象棋!! 如何将电脑上的“小电影”隐藏为一张图片?这波操作绝了!! 2.5万字54张图爆肝计算机与操作系统基础!!(建议收藏 Java中一个逐渐被遗忘的强大功能,强...
  • D) 解决系统是“如何做的问题” 2. 需求分析的主要方法有(C D)。 A) 形式化分析方法 B) PAD图描述 C) 结构化分析(SA)方法 D) OOA法 3. 面向对象的分析方法主要是建立三类模型,即(D)。 A) 系统...
  • 持续交付-发布可靠软件的系统方法

    热门讨论 2014-03-02 01:32:14
    3.5 必不可的实践 52 3.5.1 构建失败之后不要提交新代码 52 3.5.2 提交前在本地运行所有的提交测试,或者让持续集成服务器完成此事 53 3.5.3 等提交测试通过后再继续工作 54 3.5.4 回家之前,构建必须处于成功...
  • 应用案例 - 用户身份验证 / 英制单位与公制单位互换 / 掷骰子决定什么 / 百分制成绩转等级制 / 分段函数求值 / 输入三条边的长度如果能构成三角形就计算周长和面积 Day04 - 循环结构 循环结构的应用场景 - ...
  • pytorch教程

    2019-01-18 00:34:18
     3.3.4 二分类的Logistics回归 P(Y=0|x)=11+ew×x+b P(Y=0|x)=11+ew×x+b P(Y=1|x)=ew×x+b1+ew×x+b P(Y=1|x)=ew×x+b1+ew×x+b 事件发生的几率(odd): 事件发生的概率和不发生的概率之比 logP(Y=1|x)1−P(Y=1|...
  • 第四部分简要介绍了xml、数据挖掘和数据仓库等几种新兴技术。  本书是高等院校计算机及相关专业本科生、研究生数据库系统课程的理想教材,也是对相关技术人员非常有价值的参考书。 作译者  Ramez elmasri是世界...
  • C++程序员面试宝典

    热门讨论 2013-04-01 13:36:19
    许多开发者对C/C++语言及其底层原理掌握不牢固,在面试过程中经常漏洞百出,无法取得好成绩。而招聘单位为了得到高素质的员工往往采用各种形式的面试考察...面试题169 GOF的23个设计模式是如何进行分类的 193 第15章 ...
  • DDR2Layout指导手册

    2018-04-20 16:10:59
    在本人设计的这些产品中,地址线,数据线都了25mil的Relative Propagation Delay的等长规则设定。关于等长规则设定的细节在这里不再赘述,有兴趣的话,可以发邮件给正旗通信(Zencheer Studio)。 第七步,绕等长...

空空如也

空空如也

1 2 3 4 5
收藏数 98
精华内容 39
关键字:

数据少如何做二分类