精华内容
下载资源
问答
  • 一维卷积神经网络(1D CNNs)只在一定程度上有所涉及,比如在自然语言处理(NLP)中的应用。目前很少有文章能够提供关于如何构造一维卷积神经网络来解决你可能正面临的一些机器学习问题。本文试图补上这样一个短板...

    为了方便读者理解一维卷积应用,请配合笔者的实战文章一起食用:

    1.[深度应用]·首届中国心电智能大赛初赛开源Baseline(基于Keras val_acc: 0.88)

    2.[深度应用]·DC竞赛轴承故障检测开源Baseline(基于Keras1D卷积 val_acc:0.99780)

    3.https://github.com/xiaosongshine/bearing_detection_by_conv1d

    4.『带你学AI』带你学AI与TensorFlow2实战之入门初探:如何速成深度学习开发

    5.笔者深度学公众号《极简AI》:

    极简AI公众号
    极简AI公众号

     

    概述

    许多技术文章都关注于二维卷积神经网络(2D CNN)的使用,特别是在图像识别中的应用。而一维卷积神经网络(1D CNNs)只在一定程度上有所涉及,比如在自然语言处理(NLP)中的应用。目前很少有文章能够提供关于如何构造一维卷积神经网络来解决你可能正面临的一些机器学习问题。

    本文试图补上这样一个短板。

     

     

     

     

    何时应用 1D CNN?

    CNN 可以很好地识别出数据中的简单模式,然后使用这些简单模式在更高级的层中生成更复杂的模式。当你希望从整体数据集中较短的(固定长度)片段中获得感兴趣特征,并且该特性在该数据片段中的位置不具有高度相关性时,1D CNN 是非常有效的。

    1D CNN 可以很好地应用于传感器数据的时间序列分析(比如陀螺仪或加速度计数据);同样也可以很好地用于分析具有固定长度周期的信号数据(比如音频信号)。此外,它还能应用于自然语言处理的任务(由于单词的接近性可能并不总是一个可训练模式的好指标,因此 LSTM 网络在 NLP 中的应用更有前途)。

     

    1D CNN 和 2D CNN 之间有什么区别?

     

    无论是一维、二维还是三维,卷积神经网络(CNNs)都具有相同的特点和相同的处理方法。关键区别在于输入数据的维数以及特征检测器(或滤波器)如何在数据之间滑动:

     

     

     

     

     

    问题描述

    在本文中,我们将专注于基于时间片的加速度传感器数据的处理,这些数据来自于用户的腰带式智能手机设备。基于 x、y 和 z 轴的加速度计数据,1D CNN 用来预测用户正在进行的活动类型(比如“步行”、“慢跑”或“站立”)。你可以在我的另外两篇文章中找到更多的信息 这里 和 这里。对于各种活动,在每个时间间隔上的数据看起来都与此类似。

     

    来自加速度计数据的时间序列样例

     

    如何在 PYTHON 中构造一个 1D CNN?

     

    目前已经有许多得标准 CNN 模型可用。我选择了 Keras 网站 上描述的一个模型,并对它进行了微调,以适应前面描述的问题。下面的图片对构建的模型进行一个高级概述。其中每一层都将会进一步加以解释。

     

     

     

    让我们先来看一下对应的 Python 代码,以便构建这个模型:

    model_m = Sequential()
    model_m.add(Reshape((TIME_PERIODS, num_sensors), input_shape=(input_shape,)))
    model_m.add(Conv1D(100, 10, activation='relu', input_shape=(TIME_PERIODS, num_sensors)))
    model_m.add(Conv1D(100, 10, activation='relu'))
    model_m.add(MaxPooling1D(3))
    model_m.add(Conv1D(160, 10, activation='relu'))
    model_m.add(Conv1D(160, 10, activation='relu'))
    model_m.add(GlobalAveragePooling1D())
    model_m.add(Dropout(0.5))
    model_m.add(Dense(num_classes, activation='softmax'))
    print(model_m.summary())

    运行这段代码将得到如下的深层神经网络:

    _________________________________________________________________
    Layer (type)                 Output Shape              Param #   
    =================================================================
    reshape_45 (Reshape)         (None, 80, 3)             0         
    _________________________________________________________________
    conv1d_145 (Conv1D)          (None, 71, 100)           3100      
    _________________________________________________________________
    conv1d_146 (Conv1D)          (None, 62, 100)           100100    
    _________________________________________________________________
    max_pooling1d_39 (MaxPooling (None, 20, 100)           0         
    _________________________________________________________________
    conv1d_147 (Conv1D)          (None, 11, 160)           160160    
    _________________________________________________________________
    conv1d_148 (Conv1D)          (None, 2, 160)            256160    
    _________________________________________________________________
    global_average_pooling1d_29  (None, 160)               0         
    _________________________________________________________________
    dropout_29 (Dropout)         (None, 160)               0         
    _________________________________________________________________
    dense_29 (Dense)             (None, 6)                 966       
    =================================================================
    Total params: 520,486
    Trainable params: 520,486
    Non-trainable params: 0
    _________________________________________________________________
    None
    
    

    让我们深入到每一层中,看看到底发生了什么:

    • 输入数据: 数据经过预处理后,每条数据记录中包含有 80 个时间片(数据是以 20Hz 的采样频率进行记录的,因此每个时间间隔中就包含有 4 秒的加速度计数据)。在每个时间间隔内,存储加速度计的 x 轴、 y 轴和 z 轴的三个数据。这样就得到了一个 80 x 3 的矩阵。由于我通常是在 iOS 系统中使用神经网络的,所以数据必须平展成长度为 240 的向量后传入神经网络中。网络的第一层必须再将其变形为原始的 80 x 3 的形状。

    • 第一个 1D CNN 层: 第一层定义了高度为 10(也称为卷积核大小)的滤波器(也称为特征检测器)。只有定义了一个滤波器,神经网络才能够在第一层中学习到一个单一的特征。这可能还不够,因此我们会定义 100 个滤波器。这样我们就在网络的第一层中训练得到 100 个不同的特性。第一个神经网络层的输出是一个 71 x 100 的矩阵。输出矩阵的每一列都包含一个滤波器的权值。在定义内核大小并考虑输入矩阵长度的情况下,每个过滤器将包含 71 个权重值。

    • 第二个 1D CNN 层: 第一个 CNN 的输出结果将被输入到第二个 CNN 层中。我们将在这个网络层上再次定义 100 个不同的滤波器进行训练。按照与第一层相同的逻辑,输出矩阵的大小为 62 x 100。

    • 最大值池化层: 为了减少输出的复杂度和防止数据的过拟合,在 CNN 层之后经常会使用池化层。在我们的示例中,我们选择了大小为 3 的池化层。这意味着这个层的输出矩阵的大小只有输入矩阵的三分之一。

    • 第三和第四个 1D CNN 层: 为了学习更高层次的特征,这里又使用了另外两个 1D CNN 层。这两层之后的输出矩阵是一个 2 x 160 的矩阵。

    • 平均值池化层: 多添加一个池化层,以进一步避免过拟合的发生。这次的池化不是取最大值,而是取神经网络中两个权重的平均值。输出矩阵的大小为 1 x 160 。每个特征检测器在神经网络的这一层中只剩下一个权重。

    • Dropout 层: Dropout 层会随机地为网络中的神经元赋值零权重。由于我们选择了 0.5 的比率,则 50% 的神经元将会是零权重的。通过这种操作,网络对数据的微小变化的响应就不那么敏感了。因此,它能够进一步提高对不可见数据处理的准确性。这个层的输出仍然是一个 1 x 160 的矩阵。

    • 使用 Softmax 激活的全连接层: 最后一层将会把长度为 160 的向量降为长度为 6 的向量,因为我们有 6 个类别要进行预测(即 “慢跑”、“坐下”、“走路”、“站立”、“上楼”、“下楼”)。这里的维度下降是通过另一个矩阵乘法来完成的。Softmax 被用作激活函数。它强制神经网络的所有六个输出值的加和为一。因此,输出值将表示这六个类别中的每个类别出现的概率。

     

    训练和测试该神经网络

     

    下面是一段用以训练模型的 Python 代码,批大小为 400,其中训练集和验证集的分割比例是 80 比 20。

     

    callbacks_list = [
        keras.callbacks.ModelCheckpoint(
            filepath='best_model.{epoch:02d}-{val_loss:.2f}.h5',
            monitor='val_loss', save_best_only=True),
        keras.callbacks.EarlyStopping(monitor='acc', patience=1)
    ]
    
    model_m.compile(loss='categorical_crossentropy',
                    optimizer='adam', metrics=['accuracy'])
    
    BATCH_SIZE = 400
    EPOCHS = 50
    
    history = model_m.fit(x_train,
                          y_train,
                          batch_size=BATCH_SIZE,
                          epochs=EPOCHS,
                          callbacks=callbacks_list,
                          validation_split=0.2,
                          verbose=1)
    

    该模型在训练数据上的准确率可达 97%。

    ...
    Epoch 9/50
    16694/16694 [==============================] - 16s 973us/step - loss: 0.0975 - acc: 0.9683 - val_loss: 0.7468 - val_acc: 0.8031
    Epoch 10/50
    16694/16694 [==============================] - 17s 989us/step - loss: 0.0917 - acc: 0.9715 - val_loss: 0.7215 - val_acc: 0.8064
    Epoch 11/50
    16694/16694 [==============================] - 17s 1ms/step - loss: 0.0877 - acc: 0.9716 - val_loss: 0.7233 - val_acc: 0.8040
    Epoch 12/50
    16694/16694 [==============================] - 17s 1ms/step - loss: 0.0659 - acc: 0.9802 - val_loss: 0.7064 - val_acc: 0.8347
    Epoch 13/50
    16694/16694 [==============================] - 17s 1ms/step - loss: 0.0626 - acc: 0.9799 - val_loss: 0.7219 - val_acc: 0.8107
    
    

    根据测试集数据进行测试,其准确率为 92%。

    Accuracy on test data: 0.92
    
    Loss on test data: 0.39
    

     

     

    总结

    本文通过以智能手机的加速度计数据来预测用户的行为为例,绍了如何使用 1D CNN 来训练网络。

     

    补充阅读

     

    1.[深度应用]·首届中国心电智能大赛初赛开源Baseline(基于Keras val_acc: 0.88)

    2.[深度应用]·DC竞赛轴承故障检测开源Baseline(基于Keras1D卷积 val_acc:0.99780)

    3.https://github.com/xiaosongshine/bearing_detection_by_conv1d

     

    欢迎Fork+Star,觉得有用的话,麻烦小小鼓励一下 ><

     

    欢迎大家关注小宋公众号《极简AI》带你学深度学习:这里收集了一些比较适合入门实战的PDF书籍,覆盖TensorFlow、PyTorch与MXNet。推荐的理由是通俗易懂,适合初学者研究学习。书籍列表如下:《简单粗暴TensorFlow2最新中文版》《动手学深度学习PyTorch最新中文版》《动手学深度学习MXNet最新中文版》
    关注后,回复:书籍,领取。

    基于深度学习的理论学习与应用开发技术分享,笔者会经常分享深度学习干货内容,大家在学习或者应用深度学习时,遇到什么问题也可以与我在上面交流知无不答。

    出自CSDN博客专家&知乎深度学习专栏作家@小宋是呢

    展开全文
  • 在“卷积神经网络”中我们...其实,我们也可以将文本当作一维图像,从而可以用一维卷积神经网络来捕捉临近词之间的关联。TextCNN简介TextCNN 是利用卷积神经网络对文本进行分类的算法,由 Yoon Kim 在 《 Convolu...

    在“卷积神经网络”中我们探究了如何使用二维卷积神经网络来处理二维图像数据。在之前的语言模型和文本分类任务中,我们将文本数据看作是只有一个维度的时间序列,并很自然地使用循环神经网络来表征这样的数据。其实,我们也可以将文本当作一维图像,从而可以用一维卷积神经网络来捕捉临近词之间的关联。

    TextCNN简介

    TextCNN 是利用卷积神经网络对文本进行分类的算法,由 Yoon Kim 在 《 Convolutional Neural Networks for Sentence Classification 》中提出。

    TextCNN结构图:

    dba46a816608240bedff219b9372ee34.png

    第一层将单词嵌入到低维矢量中。下一层使用多个过滤器大小对嵌入的单词向量执行卷积。例如,一次滑动3,4或5个单词。接下来,将卷积层的结果最大池化为一个长特征向量,添加dropout正则,并使用softmax对结果进行分类。与传统图像的CNN网络相比, textCNN 在网络结构上没有任何变化(甚至更加简单了), 从图中可以看出textCNN 其实只有一层卷积,一层max-pooling, 最后将输出外接softmax 来n分类。

    与图像当中CNN的网络相比,textCNN 最大的不同便是在输入数据的不同:图像是二维数据, 图像的卷积核是从左到右, 从上到下进行滑动来进行特征抽取。自然语言是一维数据, 虽然经过word-embedding 生成了二维向量,但是对词向量做从左到右滑动来进行卷积没有意义. 比如 “今天” 对应的向量[0, 0, 0, 0, 1], 按窗口大小为 1* 2 从左到右滑动得到[0,0], [0,0], [0,0], [0, 1]这四个向量, 对应的都是”今天”这个词汇, 这种滑动没有帮助.

    TextCNN的成功, 不是网络结构的成功, 而是通过引入已经训练好的词向量来在多个数据集上达到了超越benchmark 的表现,进一步证明了构造更好的embedding, 是提升nlp 各项任务的关键能力。

    TextCNN最大优势网络结构简单 ,在模型网络结构如此简单的情况下,通过引入已经训练好的词向量依旧有很不错的效果,在多项数据数据集上超越benchmark。 网络结构简单导致参数数目少, 计算量少, 训练速度快,在单机单卡的v100机器上,训练165万数据, 迭代26万步,半个小时左右可以收敛。

    TextCNN 流程

    Word Embedding 分词构建词向量

    textcnn使用预先训练好的词向量作embedding layer。对于数据集里的所有词,因为每个词都可以表征成一个向量,因此我们可以得到一个嵌入矩阵M, M里的每一行都是词向量。这个M可以是静态(static)的,也就是固定不变。可以是非静态(non-static)的,也就是可以根据反向传播更新。

    如图所示, textCNN 首先将 “今天天气很好,出来玩” 分词成”今天/天气/很好/,/出来/玩, 通过word2vec或者GLOV 等embedding 方式将每个词成映射成一个5维(维数可以自己指定)词向量, 如 “今天” -> [0,0,0,0,1], “天气” ->[0,0,0,1,0], “很好” ->[0,0,1,0,0]等等。

    670afbcf1a76fdec19c9bbc47b35b2d9.png

    这样做的好处主要是将自然语言数值化,方便后续的处理。从这里也可以看出不同的映射方式对最后的结果是会产生巨大的影响, nlp 当中目前最火热的研究方向便是如何将自然语言映射成更好的词向量。我们构建完词向量后,将所有的词向量拼接起来构成一个6*5的二维矩阵,作为最初的输入。

    Convolution 卷积

    输入一个句子,首先对这个句子进行切词,假设有s个单词。对每个词,跟句嵌入矩阵M, 可以得到词向量。假设词向量一共有d维。那么对于这个句子,便可以得到s行d列的矩阵

    edb50766429279d53c745f170b663d5d.png

    。我们可以把矩阵A看成是一幅图像,使用卷积神经网络去提取特征。由于句子中相邻的单词关联性总是很高的,因此可以使用一维卷积。卷积核的宽度就是词向量的维度d,高度是超参数,可以设置。

    假设有一个卷积核,是一个宽度为d,高度为h的矩阵w,那么w有h∗d个参数需要被更新。对于一个句子,经过嵌入层之后可以得到矩阵

    77fbca4be74c10f8b3002b271646f707.png

    16e3e50b4fb482f42e3ed2219196a7d5.png

    表示A的第i行到第j行,那么卷积操作可以用如下公式表示:

    9b730053fc60abd96457247272f6f9ef.png

    叠加上偏置b,在使用激活函数f激活, 得到所需的特征。公式如下:

    52d0c1cb5afa7b01a1f83b03c5be33e6.png

    对一个卷积核,可以得到特征

    4e183fd7b7832860c61532ecab68010f.png

    , 总共个特征。我们可以使用更多高度不同的卷积核,得到更丰富的特征表达。

    df030416357546a8133409b4dee5c3c3.png

    卷积是一种数学算子。我们用一个简单的例子来说明一下

    • 1 将 “今天”/”天气”/”很好”/”,” 对应的4*5 矩阵 与卷积核做一个point wise 的乘法然后求和, 便是卷积操作
    • 2 将窗口向下滑动一格(滑动的距离可以自己设置),”天气”/”很好”/”,”/”出来” 对应的4*5 矩阵 与卷积核(权值不变) 继续做point wise 乘法后求和
    • 3 将窗口向下滑动一格(滑动的距离可以自己设置) “很好”/”,”/”出来”/”玩” 对应的4*5 矩阵 与卷积核(权值不变) 继续做point wise 乘法后求和

    feature_map 便是卷积之后的输出, 通过卷积操作 将输入的6*5 矩阵映射成一个 3*1 的矩阵,这个映射过程和特征抽取的结果很像,于是便将最后的输出称作feature map。一般来说在卷积之后会跟一个激活函数,在这里为了简化说明需要,我们将激活函数设置为f(x) = x

    channel

    abe4a60b3e10ef53dd63ad11c0143d39.png

    在CNN 中常常会提到一个词channel, 图中深红矩阵与浅红矩阵 便构成了两个channel 统称一个卷积核, 从这个图中也可以看出每个channel 不必严格一样, 每个4*5 矩阵与输入矩阵做一次卷积操作得到一个feature map. 在计算机视觉中,由于彩色图像存在 R, G, B 三种颜色, 每个颜色便代表一种channel。根据原论文作者的描述, 一开始引入channel 是希望防止过拟合(通过保证学习到的vectors 不要偏离输入太多)来在小数据集合获得比单channel更好的表现,后来发现其实直接使用正则化效果更好。不过使用多channel 相比与单channel, 每个channel 可以使用不同的word embedding, 比如可以在no-static(梯度可以反向传播) 的channel 来fine tune 词向量,让词向量更加适用于当前的训练。 对于channel在textCNN 是否有用, 从论文的实验结果来看多channels并没有明显提升模型的分类能力, 七个数据集上的五个数据集 单channel 的textCNN 表现都要优于 多channels的textCNN。

    0ec93854f43892ad19f8f327edc37b29.png

    我们在这里也介绍一下论文中四个model 的不同:

    • CNN-rand (单channel), 设计好 embedding_size 这个 Hyperparameter 后, 对不同单词的向量作随机初始化, 后续BP的时候作调整.
    • CNN-static(单channel), 拿 pre-trained vectors from word2vec, FastText or GloVe 直接用, 训练过程中不再调整词向量.
    • CNN-non-static(单channel), pre-trained vectors + fine tuning , 即拿word2vec训练好的词向量初始化, 训练过程中再对它们微调.
    • CNN-multiple channel(多channels), 类比于图像中的RGB通道, 这里也可以用 static 与 non-static 搭两个通道来做.

    Pooling 池化

    不同尺寸的卷积核得到的特征(feature map)大小也是不一样的,因此我们对每个feature map使用池化函数,使它们的维度相同。最常用的就是1-max pooling,提取出feature map照片那个的最大值。这样每一个卷积核得到特征就是一个值,对所有卷积核使用1-max pooling,再级联起来,可以得到最终的特征向量,这个特征向量再输入softmax layer做分类。这个地方可以使用drop out防止过拟合。

    bdae26e4c712a6a2c797ec172fba86de.png

    得到feamap = [1,1,2] 后, 从中选取一个最大值[2] 作为输出, 便是max-pooling。max-pooling 在保持主要特征的情况下, 大大降低了参数的数目, 从图中可以看出 feature map 从 三维变成了一维, 好处有如下两点:

    • 降低了过拟合的风险, feature map = [1, 1, 2] 或者[1, 0, 2] 最后的输出都是[2], 表明开始的输入即使有轻微变形, 也不影响最后的识别。
    • 参数减少, 进一步加速计算。

    pooling 本身无法带来平移不变性(图片有个字母A, 这个字母A 无论出现在图片的哪个位置, 在CNN的网络中都可以识别出来),卷积核的权值共享才能。max-pooling的原理主要是从多个值中取一个最大值,做不到这一点。cnn 能够做到平移不变性,是因为在滑动卷积核的时候,使用的卷积核权值是保持固定的(权值共享), 假设这个卷积核被训练的就能识别字母A, 当这个卷积核在整张图片上滑动的时候,当然可以把整张图片的A都识别出来。

    使用softmax k分类

    c0a49ba1c90c8be95a3ddd0be3e92133.png

    如图所示, 我们将 max-pooling的结果拼接起来, 送入到softmax当中, 得到各个类别比如 label 为1 的概率以及label 为-1的概率。如果是预测的话,到这里整个textCNN的流程遍结束了。如果是训练的话,此时便会根据预测label以及实际label来计算损失函数, 计算出softmax 函数,max-pooling 函数, 激活函数以及卷积核函数 四个函数当中参数需要更新的梯度, 来依次更新这四个函数中的参数,完成一轮训练。

    总结

    以上过程可以用下图直观表示:

    f9d4b300fcb263b574d3f2c4440190b9.png
    • 这里word embedding的维度是5。对于句子 i like this movie very much。可以转换成如上图所示的矩阵
    • 有6个卷积核,尺寸为(2×5)(2×5), (3×5)(3×5), 4×54×5,每个尺寸各2个.
    • AA分别与以上卷积核进行卷积操作,再用激活函数激活。每个卷积核都得到了特征向量(feature maps)
    • 使用1-max pooling提取出每个feature map的最大值,然后在级联得到最终的特征表达。
    • 将特征输入至softmax layer进行分类, 在这层可以进行正则化操作( l2-regulariation)

    使用Keras 搭建卷积神经网络来进行情感分析

    在自然语言领域,卷积的作用在于利用文字的局部特征。一个词的前后几个词必然和这个词本身相关,这组成该词所代表的词群。词群进而会对段落文字的意思进行影响,决定这个段落到底是正向的还是负向的。对比传统方法,利用词包,和TF-IDF 等,其思想有相通之处。但最大的不同点在于,传统方法是人为构造用于分类的特征,而深度学习中的卷积让神经网络去构造特征。以上便是卷积在自然语言处理中有着广泛应用的原因。接下来介绍如何利用Keras 搭建卷积神经网络来处理情感分析的分类问题。

    下面的代码构造了卷积神经网络的结构:

    from keras.layers import Dense, Dropout, Activation, Flattenfrom keras.layers import Conv1D, MaxPooling1Dfrom keras.models import Sequentialfrom keras.layers.embeddings import Embeddingfrom keras.datasets import imdbimport numpy as npfrom keras.preprocessing import sequence (X_train, y_train), (X_test, y_test) = imdb.load_data() max_word = 400X_train = sequence.pad_sequences(X_train, maxlen=max_word)X_test = sequence.pad_sequences(X_test, maxlen=max_word)vocab_size = np.max([np.max(X_train[i]) for i in range(X_train.shape[0])]) + 1  # 这里1 代表空格,其索引被认为是0。 model = Sequential()model.add(Embedding(vocab_size, 64, input_length=max_word))model.add(Conv1D(filters=64, kernel_size=3, padding='same', activation='relu'))model.add(MaxPooling1D(pool_size=2))model.add(Dropout(0.25))model.add(Conv1D(filters=128, kernel_size=3, padding='same', activation='relu'))model.add(MaxPooling1D(pool_size=2))model.add(Dropout(0.25))model.add(Flatten())model.add(Dense(64, activation='relu'))model.add(Dense(32, activation='relu'))model.add(Dense(1, activation='sigmoid')) model.compile(loss='binary_crossentropy', optimizer='rmsprop', metrics=['accuracy'])print(model.summary()) model.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=20, batch_size=100)scores = model.evaluate(X_test, y_test, verbose=1)print(scores)

    整个模型的结构如下:

    Model: "sequential_1"_________________________________________________________________Layer (type)                 Output Shape              Param #   =================================================================embedding_1 (Embedding)      (None, 400, 64)           5669568   _________________________________________________________________conv1d_1 (Conv1D)            (None, 400, 64)           12352     _________________________________________________________________max_pooling1d_1 (MaxPooling1 (None, 200, 64)           0         _________________________________________________________________dropout_1 (Dropout)          (None, 200, 64)           0         _________________________________________________________________conv1d_2 (Conv1D)            (None, 200, 128)          24704     _________________________________________________________________max_pooling1d_2 (MaxPooling1 (None, 100, 128)          0         _________________________________________________________________dropout_2 (Dropout)          (None, 100, 128)          0         _________________________________________________________________flatten_1 (Flatten)          (None, 12800)             0         _________________________________________________________________dense_1 (Dense)              (None, 64)                819264    _________________________________________________________________dense_2 (Dense)              (None, 32)                2080      _________________________________________________________________dense_3 (Dense)              (None, 1)                 33        =================================================================Total params: 6,528,001Trainable params: 6,528,001Non-trainable params: 0_________________________________________________________________

    TextCNN的超参数调参

    在最简单的仅一层卷积的TextCNN结构中,下面的超参数都对模型表现有影响:

    • 初始化词向量。使用word2vec和golve都可以,不要使用one-hot vectors
    • 卷积核的尺寸。1-10之间,具体情况具体分析,对最终结果影响较大。一般来讲,句子长度越长,卷积核的尺寸越大。另外,可以在寻找到了最佳的单个filter的大小后,尝试在该filter的尺寸值附近寻找其他合适值来进行组合。实践证明这样的组合效果往往比单个最佳filter表现更出色
    • 每种尺寸卷积核的数量。100-600之间,对模型性能影响较大,需要注意的是增加卷积核的数量会增加训练模型的实践。主要考虑的是当增加特征图个数时,训练时间也会加长,因此需要权衡好。当特征图数量增加到将性能降低时,可以加强正则化效果,如将dropout率提高过5
    • 激活函数的选择。使用relu函数
    • drop out rate。0-0.5, 当增加卷积核的数量时,可以尝试增加drop out rate,甚至可以大于0.5
    • 池化的选择。1-max pooling表现最佳
    • 正则项。相对于其他超参数来说,影响较小点
    展开全文
  • 这个系列一开始曾经用二维卷积神经网络对图像数据进行应用,本文主要是使用一维卷积神经网络,对序列数据进行机器学习,可以理解为将原始数据变换为一维的序列段,与二维卷积神经网络一样,这一步运算的作用也是为了...

    f3893dabb083d87288a84699ab315c58.png

    这个系列记录下自己的深度学习练习,本文主要尝试了使用简单的卷积神经网络(CNN)解进行机器学习,因为数据样本贴合度可能不hi很好,实际效果并不是很明显。请读者理解原理就好,本人也是在不断摸索中。

    这个系列一开始曾经用二维卷积神经网络对图像数据进行应用,本文主要是使用一维卷积神经网络,对序列数据进行机器学习,可以理解为将原始数据变换为一维的序列段,与二维卷积神经网络一样,这一步运算的作用也是为了降低以为输入的长度(子采样)

    首先用之前的imdb数据实验效果,数据获取的代码如下,和之前一样:

    #数据处理
    
    

    一维卷积神经网络的架构和之前的二维卷积网络相同,略微有区别的是一维卷积网络的卷积窗口可以更大,因为卷积的特征向量是1维的。

    #建模并训练
    
    from keras.models import Sequential
    from keras.layers import Embedding, MaxPooling1D, Conv1D, GlobalMaxPool1D, Dense
    from keras.optimizers import RMSprop
    
    model = Sequential()
    model.add(Embedding(max_features, 128, input_length=maxlen)) #这是是用来增维,满足Conv层的输入需要。如果后面要接Dense层,最后的参数必须设置
    model.add(Conv1D(32,7, activation='relu')) #第一个参数是由输入数据生成的新维度长度(列),第二个参数是提取出一维序列段的长度
    model.add(MaxPooling1D(5))
    model.add(Conv1D(32,7, activation='relu'))
    model.add(GlobalMaxPool1D())
    model.add(Dense(1))
    
    model.summary()
    
    model.compile(optimizer=RMSprop(lr=1e-4), loss='binary_crossentropy',metrics=['accuracy'])
    history = model.fit(
        x_train, y_train,
        epochs = 10,
        batch_size = 128,
        validation_split = 0.2
    )

    学习结果(代码见之前文章):

    cde311db1148187dd45fd3523aa824f1.png

    可以看到训练的精度结果与LSTM差不多,但是速度明显要快一些。并且需要注意的是,结果有一定的随机性,验证集的结果仅供参考,一切结果肯定以测试集为主。

    结合CNN和RNN来处理长序列

    卷积神经网络是属于对时间顺序不敏感的类型,这点与RNN不同。

    首先先使用单纯的卷积神经网络训练下时间敏感的数据,以耶拿天气为例,数据使用之前的生成器:

    #用Conv1D尝试耶拿天气数据
    
    import pandas
    import numpy as np
    
    data_dir = './jena_climate_2009_2016.csv'
    df = pandas.read_csv(data_dir)
    
    df.drop(['Date Time'], axis=1, inplace=True)
    df_array = df.values
    
    mean = df_array[:200000].mean(axis=0)
    df_array -= mean
    std = df_array[:200000].std(axis=0)
    df_array /= std
    
    def generator(data, lookback, delay, min_index, max_index, shuffle=False, batch_size=128, step=6):
        '''
        data:标准化后的原始数据
        lookback:输入数据包括的过去时间步
        delay:目标应该在未来多少个时间步
        min_index, max_index: 数据的始末索引,用于抽取对应的训练集
        shuffle: 是打乱还是顺序抽取样本
        batch_size:每批量样本数
        step:数据采样周期(时间步)
        '''
        if max_index is None:
            max_index = len(data) - delay - 1
        i = min_index + lookback
        while 1:
            if shuffle:
                rows = np.random.randint(min_index + lookback, max_index, size=batch_size)
            else:
                if i + batch_size >= max_index:
                    i = min_index + lookback
                rows = np.arange(i, min(i+batch_size, max_index))
                i = i + len(rows)
    
            samples = np.zeros((len(rows), lookback//step, data.shape[-1]))
            targets = np.zeros((len(rows),))
            for j, row in enumerate(rows):
                indices = range(rows[j] - lookback, rows[j], step)
                samples[j] = data[indices]
                targets[j] = data[rows[j] + delay][1]
            yield samples, targets
            #返回samples是输入数据的一个批量,targets是对应的目标温度数组
            
    #准备训练生成器,验证生成器和测试生成器
    lookback = 1440 
    steps = 6 #每个steps里6个时间步
    delay = 144
    batch_size = 128
    
    train_gen = generator(df_array, lookback=lookback, delay=delay, min_index=0, max_index=200000, shuffle=True, step=steps)
    val_gen = generator(df_array, lookback=lookback, delay=delay, min_index=200001, max_index=300000, step=steps)
    test_gen = generator(df_array, lookback=lookback, delay=delay, min_index=300001, max_index=None, step=steps)
    
    val_steps = (300000 - 200001 - lookback) // batch_size 
    test_steps = (len(df_array) - 300001 - lookback) // batch_size 
    #建模并训练
    
    from keras.models import Sequential
    from keras.layers import Embedding, MaxPooling1D, Conv1D, GlobalMaxPool1D, Dense
    from keras.optimizers import RMSprop
    
    model = Sequential()
    #model.add(Embedding(max_features, 128, input_length=maxlen)) #这是是用来增维,满足Conv层的输入需要。如果后面要接Dense层,最后的参数必须设置
    model.add(Conv1D(32,5, activation='relu', input_shape=(None, df_array.shape[-1]))) #第一个参数是由输入数据生成的新维度长度(列),第二个参数是提取出一维序列段的长度
    model.add(MaxPooling1D(3))
    model.add(Conv1D(32,5, activation='relu'))
    model.add(MaxPooling1D(3))
    model.add(Conv1D(32,5, activation='relu'))
    model.add(GlobalMaxPool1D())
    model.add(Dense(1))
    
    model.summary()
    
    model.compile(optimizer=RMSprop(lr=1e-4), loss='mae', metrics=['accuracy'])
    history = model.fit_generator(
        train_gen,
        steps_per_epoch = 500,
        epochs = 20,
        validation_data = val_gen,
        validation_steps = val_steps
    )

    学习结果:

    180e0105d3cc288116b687fb9c804cf9.png

    可以看出学习结果非常差,甚至低于基于常识的判断(0.29),所以说卷积网络并不适合对时间敏感的数据集。

    下面尝试下RNN和CNN的结合使用。我自己尝试了下在RNN前面使用CNN作为预处理步骤,因为RNN对于长序列的处理并不好。前面的耶拿数据,我们每次只分析前720或1440时间步的数据,这次的话可以使用增大lookback参数或减小步长来增大数据。

    #准备训练生成器,验证生成器和测试生成器
    lookback = 1440 
    steps = 3 #减少每个steps里的时间步,减一半
    delay = 144
    batch_size = 128
    
    train_gen = generator(df_array, lookback=lookback, delay=delay, min_index=0, max_index=200000, shuffle=True, step=steps)
    val_gen = generator(df_array, lookback=lookback, delay=delay, min_index=200001, max_index=300000, step=steps)
    test_gen = generator(df_array, lookback=lookback, delay=delay, min_index=300001, max_index=None, step=steps)
    
    val_steps = (300000 - 200001 - lookback) // batch_size #为了查看整个验证集,需要从val_gen中抽取多少次
    test_steps = (len(df_array) - 300001 - lookback) // batch_size #为了查看整个测试集,需要从test_gen中抽取多少次

    下面是模型,使用两个Conv1层和一个GRU层

    #组合建模学习
    
    from keras.models import Sequential
    from keras.layers import Embedding, MaxPooling1D, Conv1D, GlobalMaxPool1D, Dense, GRU
    from keras.optimizers import RMSprop
    
    model = Sequential()
    model.add(Conv1D(32,5, activation='relu', input_shape=(None, df_array.shape[-1]))) #第一个参数是由输入数据生成的新维度长度(列),第二个参数是提取出一维序列段的长度
    model.add(MaxPooling1D(3))
    model.add(Conv1D(32,5, activation='relu'))
    #model.add(MaxPooling1D(3))
    model.add(GRU(32, dropout=0.1, recurrent_dropout=0.5))
    #model.add(GlobalMaxPool1D())
    model.add(Dense(1))
    
    model.summary()
    
    model.compile(optimizer=RMSprop(lr=1e-4), loss='mae', metrics=['accuracy'])
    history = model.fit_generator(
        train_gen,
        steps_per_epoch = 500,
        epochs = 20,
        validation_data = val_gen,
        validation_steps = val_steps
    )

    学习结果:

    ce22278c8d2f29c65e339040277e1456.png

    从验证损失看,结果可能比使用正则化的GRU算法稍微差一些,但速度要快很多,且查看了2倍的数据量,在本例中可能不是非常有用,但对于其他数据集效果可能不错。

    这次简单就先到这里吧,虽然结果并不是很理想,可能是数据集不太合适问题,大家明白方法的使用就好。我自己也是在慢慢学习,基本上简单的keras模型构建就是这么多了,其实最麻烦的步骤还是构建数据集。之后可能会再写写keras的函数式API应用。如有不明白的地方可以在评论或私信里讨论学习。

    展开全文
  • 一维卷积神经网络在处理序列问题的作用在计算机视觉中我们经常使用卷积神经网络,由于其能够自动提取图像特征,并且可以高效的处理数据。对于序列处理问题,我们可以将序列看成一维空间,也就是我们前面说的数据维度...

    9042871bc38ca9e4d4d57def53dc3db0.png

    一维卷积神经网络

    在处理序列问题的作用

    在计算机视觉中我们经常使用卷积神经网络,由于其能够自动提取图像特征,并且可以高效的处理数据。对于序列处理问题,我们可以将序列看成一维空间,也就是我们前面说的数据维度:向量(1D张量)。

    主要的作用:在某些序列问题上,其效果跟RNN一样,而且计算代价更小; - 在音频生成和机器翻译领域取得了巨大成功; - 对于文本分类和时间序列预测等简单任务,小型的一维卷积神经网络可以替代 RNN,速度更快。

    一维卷积的形式

    参考二维卷积,对于图片中局部的区域进行变换,能够获得提取该区域的特征。对于一维卷积也可这样的理解,提取局部一维序列的特征。

    在深入的理解一下,例如对于文本的学习,在某个句子中的词,使得一维卷积能够学习到一个具体的表达模式,该模式可能在其他的位置上被识别。具体, - 比如下图中的长度为5的卷积窗口, - 在进行卷积的时候,能够学习长度不大于5的单词 - 这样能够在输入句子中任何位置识别到这些单词 - 字符级的一维卷积神经网络能够学会单词构词法

    1481e116c0d6941c6171abf5c0c48e8d.png

    序列数据的一维池化

    可以类比二维卷积神经的池化运算,从输入的一维序列中提取一段数据,然后对其进行计算最大值(最大化池化)或平均值(平均值池化),这个其实就一维采样。

    利用一维卷积神经网络构建IMDB模型

    Keras 中的一维卷积神经网络是 Conv1D 层 keras.layers.Conv1D( filters, kernel_size, strides=1, padding='valid', data_format='channels_last', dilation_rate=1, activation=None, use_bias=True, kernel_initializer='glorot_uniform', bias_initializer='zeros', kernel_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, bias_constraint=None)

    输入尺寸

    • 3D 张量 ,尺寸为 (batch_size, steps, input_dim)

    输出尺寸

    • 3D 张量,尺寸为 (batch_size, new_steps, filters)
    # 数据准备
    
    from keras.datasets import imdb
    from keras.preprocessing import sequence
    
    max_features = 10000
    max_len = 500
    
    print('Loading data...')
    (x_train,y_train),(x_test,y_test) = imdb.load_data(num_words=max_features)
    print(len(x_train),'train sequences')
    print(len(x_test),'test sequences')
    
    # 截断成一个相同长度的序列
    print('Pad sequences (samples x time)')
    x_train = sequence.pad_sequences(x_train,maxlen=max_len)
    x_test = sequence.pad_sequences(x_test,maxlen = max_len)
    print("x_train shape:",x_train.shape)
    print("x_test shape:",x_test.shape)
    Using TensorFlow backend.
    
    
    Loading data...
    25000 train sequences
    25000 test sequences
    Pad sequences (samples x time)
    x_train shape: (25000, 500)
    x_test shape: (25000, 500)

    模型的建立

    • Conv1D 层和 MaxPooling1D层的堆叠,
    • 最后是一个全局池化层或 Flatten 层,将三维输出转换为二维输出,
    • 模型中添加一个或多个 Dense 层,用于分类或回归。

    具体的coding 如下:

    from keras.models import Sequential
    from keras import layers
    from keras.optimizers import RMSprop
    
    model = Sequential()
    model.add(layers.Embedding(max_features,128,input_length = max_len))
    model.add(layers.Conv1D(32,7,activation = 'relu'))
    model.add(layers.MaxPool1D(5))
    model.add(layers.Conv1D(32,7,activation = 'relu'))
    model.add(layers.GlobalMaxPooling1D())
    model.add(layers.Dense(1))
    
    model.summary()
    _________________________________________________________________
    Layer (type)                 Output Shape              Param #   
    =================================================================
    embedding_2 (Embedding)      (None, 500, 128)          1280000   
    _________________________________________________________________
    conv1d_3 (Conv1D)            (None, 494, 32)           28704     
    _________________________________________________________________
    max_pooling1d_2 (MaxPooling1 (None, 98, 32)            0         
    _________________________________________________________________
    conv1d_4 (Conv1D)            (None, 92, 32)            7200      
    _________________________________________________________________
    global_max_pooling1d_2 (Glob (None, 32)                0         
    _________________________________________________________________
    dense_2 (Dense)              (None, 1)                 33        
    =================================================================
    Total params: 1,315,937
    Trainable params: 1,315,937
    Non-trainable params: 0
    _________________________________________________________________
    model.compile(optimizer=RMSprop(lr = 1e-4),
                 loss = 'binary_crossentropy',
                 metrics = ['acc'])
    
    history = model.fit(x_train,y_train,
                       epochs=10,
                       batch_size=128,
                       validation_split=0.2)
    WARNING:tensorflow:From D:Anaconda3envstfgpulibsite-packagestensorflowpythonopsmath_ops.py:3066: to_int32 (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.
    Instructions for updating:
    Use tf.cast instead.
    WARNING:tensorflow:From D:Anaconda3envstfgpulibsite-packagestensorflowpythonopsmath_grad.py:102: div (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.
    Instructions for updating:
    Deprecated in favor of operator or tf.math.divide.
    Train on 20000 samples, validate on 5000 samples
    Epoch 1/10
    20000/20000 [==============================] - 6s 276us/step - loss: 0.7679 - acc: 0.5200 - val_loss: 0.6864 - val_acc: 0.5700
    Epoch 2/10
    20000/20000 [==============================] - 2s 89us/step - loss: 0.6682 - acc: 0.6618 - val_loss: 0.6665 - val_acc: 0.6352
    Epoch 3/10
    20000/20000 [==============================] - 2s 90us/step - loss: 0.6258 - acc: 0.7547 - val_loss: 0.6145 - val_acc: 0.7174
    Epoch 4/10
    20000/20000 [==============================] - 2s 89us/step - loss: 0.5332 - acc: 0.8044 - val_loss: 0.4957 - val_acc: 0.8056
    Epoch 5/10
    20000/20000 [==============================] - 2s 88us/step - loss: 0.4122 - acc: 0.8430 - val_loss: 0.4312 - val_acc: 0.8338
    Epoch 6/10
    20000/20000 [==============================] - 2s 88us/step - loss: 0.3445 - acc: 0.8679 - val_loss: 0.4125 - val_acc: 0.8442
    Epoch 7/10
    20000/20000 [==============================] - 2s 89us/step - loss: 0.3053 - acc: 0.8723 - val_loss: 0.3937 - val_acc: 0.8370
    Epoch 8/10
    20000/20000 [==============================] - 2s 88us/step - loss: 0.2730 - acc: 0.8618 - val_loss: 0.4081 - val_acc: 0.8222
    Epoch 9/10
    20000/20000 [==============================] - 2s 89us/step - loss: 0.2480 - acc: 0.8425 - val_loss: 0.4634 - val_acc: 0.7872
    Epoch 10/10
    20000/20000 [==============================] - 2s 88us/step - loss: 0.2252 - acc: 0.8300 - val_loss: 0.4411 - val_acc: 0.7730
    #绘制相关的图
    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()

    afcf7e1270648119acf8fbe4dae091b3.png

    07267d1cf965e905bec037714dfba9aa.png

    结果对比

    如上图中给出了模型的训练结果和验证结果。验证精度略低于 LSTM ,但在 CPU 和 GPU 上的运行速度都要更快。


    分享关于人工智能,机器学习,深度学习以及计算机视觉的好文章,同时自己对于这个领域学习心得笔记。想要一起深入学习人工智能的小伙伴一起结伴学习吧!扫码上车!

    0f50f27621c79171d8da9c17dfa2c20e.png
    展开全文
  • 一维卷积神经网络在维度S上进行卷积 如下,设置一维卷积网络的输入通道为16维,输出通道为33维,卷积核大小为3,步长为2 # in_channels: 16 # out_channels: 33 # kernel_size: 3 m = nn.Conv1d(16, 33, 3, ...
  • 卷积 卷积神经网络中的卷积是指定义好卷积核(kernel),并对图像(或者特征图,feature map)进行滑动匹配,即对应位置相乘再相加。其特点就在于能够捕捉局部的空间特征。具体过程如下图所示:图1-二维卷积过程...
  • 卷积神经网络是一种源于人工神经网络的机器学习方法,从谷歌的GoogleNet、...需要在前面指出,全连接神经网络每层神经元是一维排列的,而卷积神经网络每层的神经元是按照三维排列的,且具有宽度、高度和深度。几个...
  • 【keras】一维卷积神经网络做回归

    千次阅读 多人点赞 2020-06-20 13:51:50
    【keras】一维卷积神经网络多分类 在这篇博客当中我将利用一个稍加修改的数据集来完成线性回归任务。相比较以往的线性回归处理方式,我认为使用神经网络实现线性回归要简单和准确得多。 数据集大小仍然是247*900,...
  • 实现一维卷积神经网络 1、准备IMDB数据 from keras.datasets import imdb from keras.preprocessing import sequence max_features=10000 max_len=500 print('loading data......') (x_train,y_train),(x_test,y_...
  • 一维卷积一维卷积的输入是一个向量和一个卷积核,输出也是一个向量。通常状况下,输入向量长度远大于卷积核的长度。输出向量的长度取决于卷积操作的填充方案,等宽卷积的输出向量的和输入的向量长度相等。卷积核的...
  • 卷积神经网络种具有局部连接,权值共享等特性的深层前馈神经网络。用全连接前馈网络来处理图像时,会存在参数太多,导致训练效率低和局部不变性特征等问题。卷积神经网络是怎样解决这些问题的? - 局部连接。每...
  • 网上对于卷积神经网络的介绍大部分都是2D的,一维卷积神经网络的比较少,使用新框架的就更少了。 代码如下: # 首先搭建网络,这里以最简单的sequential为例 # 先是卷积 sequential = [ tf.keras.layers.Conv1D(2, ...
  • 基于一维卷积神经网络对机械振动信号进行分类并加以预测 *使用一维卷积神经网络训练振动信号进行二分类 2020年7月16日,一学期没等到开学,然而又放假了。 总览CSDN中大多数卷积神经网络都是对二维图片进行分类的,...
  • 小白也能看懂的TensorFlow上手系列作者 | Divyanshu Mishra编译 | VK来源 | Towards DataScience卷积神经网络种特殊的神经网络结构,是自动驾驶汽车、人脸识别系统等计算机视觉应用的基础,其中基本的矩阵乘法...
  • 基于一维卷积神经网络的滚动轴承故障识别 提示:文章写完后,目录可以自动生成,如何生成可参考右边的帮助文档 文章目录基于一维卷积神经网络的滚动轴承故障识别一、数据预处理二、模型搭建三、使用步骤1.引入库2....
  • 卷积神经网络的来源卷积神经网络(Convolutional Neural Networks),简称CNN,是模仿人类视觉皮层功能的深度学习算法。我们先举个直观例子了解下人眼看到物体的情况,如下图所示:人眼看到物体的过程这张图实中...
  • 目的:针对传统机器学习算法对于流量分类的瓶颈问题,提出基于一维卷积神经网络模型的应用程序流量分类算法。 数据集:ICSX VPN-nonVPN 特征:数据预处理工具“USTC-TK2016, 本文选择同文献[12]相同的前784 Byte,...
  • 【keras】一维卷积神经网络多分类

    千次阅读 多人点赞 2020-06-20 13:05:05
    刚刚接触到深度学习,前2个月的时间里,我用一维卷积神经网络实现了对于一维数据集的分类和回归。由于在做这次课题之前,我对深度学习基本上没有过接触,所以期间走了很多弯路。 在刚刚收到题目的要求时,我选择...
  • 本文攻略:通过分析 YOLO 神经网络,理解卷积神经网络工作原理建议玩家等级:技术圈外人(建议只看图片,也能理解),AI新手,学生党,初级码农阅读此文先解锁技能:点点命令行基础点点 C++ 基础卷积神经网络基础...
  • MATLAB实现一维卷积神经网络 Crack Identification From Accelerometer Data
  • CNN图像识别原理卷积神经网络(CNN...卷积神经网络也是类似,它包含了至少层卷积层,由多个卷积核对图像的局部区域进行特征提取,最后进行合成。以经典的LeNet-5模型为例:原始输入数据(图中的input)为二图像...
  • 一维卷积神经网络(1D CNNs)只在一定程度上有所涉及,比如在自然语言处理(NLP)中的应用。目前很少有文章能够提供关于如何构造一维卷积神经网络来解决你可能正面临的一些机器学习问题。本文试图补上这样一个短板。​...
  • 一维卷积神经网络(1D CNNs)只在一定程度上有所涉及,比如在自然语言处理(NLP)中的应用。目前很少有文章能够提供关于如何构造一维卷积神经网络来解决你可能正面临的一些机器学习问题。本文试图补上这样一个短板...
  • 点击蓝字关注我们近年来,卷积神经网络热度很高,在短时间内,这类网络成为了种颠覆性技术,打破了从文本、视频到语音多个领域的大量最先进的算法,远远超出其最初在图像处理的应用范围。卷积神经网络个例子在...
  • 之前发过两个帖子,一个是改的别人的鸢尾花分类,另一个忘了改的那一篇一维卷积神经网络的了,两个代码都显得不尽人意。鸢尾花分类将一个样本转化成三个特征样本训练,会导致训练自己东西的时候样本要做的非常大。第...
  • 基于1DCNN(一维卷积神经网络)的机械振动故障诊断

    千次阅读 多人点赞 2020-09-14 20:52:07
    基于1DCNN(一维卷积神经网络)的机械振动故障诊断 机械振动故障诊断最为经典的还是凯斯西储实验室的轴承故障诊断,开学一周了,上次改编鸢尾花分类的代码可用,但是并不准确。开学一周重新改编了别人的一篇代码,亲...
  • 一维卷积神经网络的学习

    千次阅读 2019-10-31 15:41:24
    卷积神经网络的学习 https://www.cnblogs.com/szxspark/p/8439066.html
  • 前言上篇文章介绍了基本的基于注意力机制方法对序列特征的处理,这篇主要介绍一下基本的基于卷积神经网络方法对序列特征的处理,也就是TextCNN方法。序列特征的介绍,背景以及应用可以参考上篇的详细介绍,这里...
  • 为减少工作量,提高质量控制能力,提出一种基于一维卷积神经网络(1D-CNN)的CCPR方法,该方法不需要人工手动提取复杂产品质量特征,使用一维卷积神经网络通过特征学习从CCP的原始数据中获取最佳特征集,并完成CCPR,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,819
精华内容 727
关键字:

一维卷积神经网络