精华内容
下载资源
问答
  • 点击上方“小白学视觉”,选择加"星标"或“置顶”重磅干货,第时间送达 本文转自 | 人工智能与算法学习概述许多文章都关注于二卷积神经网络(2D CNN)的使用,特别是...

    点击上方“小白学视觉”,选择加"星标"或“置顶

    重磅干货,第一时间送达
    
    

    本文转自 | 人工智能与算法学习

    概述

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

    何时应用 1D CNN?

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

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

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

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

    问题描述

    在本文中,我们将专注于基于时间片的加速度传感器数据的处理,这些数据来自于用户的腰带式智能手机设备。基于 x、y 和 z 轴的加速度计数据,1D CNN 用来预测用户正在进行的活动类型(比如“步行”、“慢跑”或“站立”)。

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

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

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

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

    输入数据: 数据经过预处理后,每条数据记录中包含有 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。

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

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

    展望

    上面是以分类问题来举例的,对于回归预测问题,只需要把最后一层的全连接层使用linear激活即可~

    下载1:OpenCV-Contrib扩展模块中文版教程

    在「小白学视觉」公众号后台回复:扩展模块中文教程即可下载全网第一份OpenCV扩展模块教程中文版,涵盖扩展模块安装、SFM算法、立体视觉、目标跟踪、生物视觉、超分辨率处理等二十多章内容。

    下载2:Python视觉实战项目52讲

    在「小白学视觉」公众号后台回复:Python视觉实战项目即可下载包括图像分割、口罩检测、车道线检测、车辆计数、添加眼线、车牌识别、字符识别、情绪检测、文本内容提取、面部识别等31个视觉实战项目,助力快速学校计算机视觉。

    下载3:OpenCV实战项目20讲

    在「小白学视觉」公众号后台回复:OpenCV实战项目20讲即可下载含有20个基于OpenCV实现20个实战项目,实现OpenCV学习进阶。

    交流群

    欢迎加入公众号读者群一起和同行交流,目前有SLAM、三维视觉、传感器、自动驾驶、计算摄影、检测、分割、识别、医学影像、GAN、算法竞赛等微信群(以后会逐渐细分),请扫描下面微信号加群,备注:”昵称+学校/公司+研究方向“,例如:”张三 + 上海交大 + 视觉SLAM“。请按照格式备注,否则不予通过。添加成功后会根据研究方向邀请进入相关微信群。请勿在群内发送广告,否则会请出群,谢谢理解~

    展开全文
  • 卷积神经网络处理一维信号(故障诊断)

    千次阅读 热门讨论 2021-08-18 15:55:53
    卷积神经网络处理一维信号(故障诊断) (注:从小白角度出发,刚接触卷积神经网络的小伙伴,很多人和我一样就是想知道这段代码怎么把信号输入进去,怎么看输出结果,怎么把输出结果与测试集的数据进行对比,从而...

    卷积神经网络处理一维信号(故障诊断)

    (注:从小白角度出发,刚接触卷积神经网络的小伙伴,很多人和我一样就是想知道这段代码怎么把信号输入进去,怎么看输出结果,怎么把输出结果与测试集的数据进行对比,从而知道测试结果,这些我在下面有解释。本文最后会附有链接,包括我用的数据,源码。大家可以看一下数据格式,我当时就是不知道表格里的数据到底是什么格式,然后搞了好久!!!!如果有问题的小伙伴可以留言,我会尽力解答。。)
    编辑器:Anaconda+jupyter
    环境    :python :3.7.10
                   tensorflow::2.3.0

    代码如下

    import keras
    from scipy.io import loadmat
    import matplotlib.pyplot as plt
    import glob
    import numpy as np
    import pandas as pd
    import math
    import os
    from keras.layers import *
    from keras.models import *
    from keras.optimizers import *
    
    //这里是我导入的训练集数据训练集,大家对应自己的信号数据就好,数据我下面会发,大家可以看一下数据的格式;
    MANIFEST_DIR = r'C:\Users\Administrator\Desktop\test\frftdata\train\frfttrain1.0.csv'
    Batch_size = 30
    Long = 800
    Lens = 200
    def convert2oneHot(index, lens):
        hot = np.zeros((lens,))
        hot[int(index)] = 1
        return(hot)
    
    
    def xs_gen(path=MANIFEST_DIR, batch_size=Batch_size, train=True, Lens=Lens):
        img_list = pd.read_csv(path)
        if train:
            img_list = np.array(img_list)[:Lens]
            print("Found %s train items." % len(img_list))
            print("list 1 is", img_list[0, -1])
            steps = math.ceil(len(img_list) / batch_size)
        else:
            img_list = np.array(img_list)[Lens:]
            print("Found %s test items." % len(img_list))
            print("list 1 is", img_list[0, -1])
            steps = math.ceil(len(img_list) / batch_size)
        while True:
            for i in range(steps):
                batch_list = img_list[i * batch_size: i * batch_size + batch_size]
                np.random.shuffle(batch_list)
                batch_x = np.array([file for file in batch_list[:, 1:-1]])
                batch_y = np.array([convert2oneHot(label, 4) for label in batch_list[:, -1]])
                yield batch_x, batch_y
    //这里是导入的我测试集的数据
    TEST_MANIFEST_DIR = r'C:\Users\Administrator\Desktop\test\frftdata\test\frfttest1.0.csv'
    
    
    
    def ts_gen(path=TEST_MANIFEST_DIR, batch_size=Batch_size):
        img_list = pd.read_csv(path)
        img_list = np.array(img_list)[:Lens]
        print("Found %s test items." % len(img_list))
        print("list 1 is", img_list[0, -1])
        steps = math.ceil(len(img_list) / batch_size)
        while True:
            for i in range(steps):
                batch_list = img_list[i * batch_size:i * batch_size + batch_size]
                batch_x = np.array([file for file in batch_list[:, 1:]])
                yield batch_x
    TIME_PERIODS = 5000
    
    
    def build_model(input_shape=(TIME_PERIODS,), num_classes=4):
        model = Sequential()
        model.add(Reshape((TIME_PERIODS, 1), input_shape=input_shape))
    
        model.add(Conv1D(16, 8, strides=2, activation='relu', input_shape=(TIME_PERIODS, 1)))
        model.add(Conv1D(16, 8, strides=2, activation='relu', padding="same"))
        model.add(MaxPooling1D(2))
    
        model.add(Conv1D(64, 4, strides=2, activation='relu', padding="same"))
        model.add(Conv1D(64, 4, strides=2, activation='relu', padding="same"))
        model.add(MaxPooling1D(2))
    
        model.add(Conv1D(256, 4, strides=2, activation='relu', padding="same"))
        model.add(Conv1D(256, 4, strides=2, activation='relu', padding="same"))
        model.add(MaxPooling1D(2))
    
        model.add(Conv1D(512, 2, strides=1, activation='relu', padding="same"))
        model.add(Conv1D(512, 2, strides=1, activation='relu', padding="same"))
        model.add(MaxPooling1D(2))
    
        """ model.add(Flatten())
        model.add(Dropout(0.3))
        model.add(Dense(256, activation='relu'))"""
    
        model.add(GlobalAveragePooling1D())
        model.add(Dropout(0.3))
        model.add(Dense(num_classes, activation='softmax'))
        return(model)
    Train = True
    
    
    if __name__ == "__main__":
        if Train == True:
            train_iter = xs_gen()
            val_iter = xs_gen(train=False)
    
            ckpt = keras.callbacks.ModelCheckpoint(
                filepath='best_model.{epoch:02d}-{val_loss:.4f}.h5',
                monitor='val_loss', save_best_only=True, verbose=1
            )
    
            model = build_model()
            opt = Adam(0.0002)
            model.compile(loss='categorical_crossentropy',
                          optimizer = opt, metrics=['accuracy'])
            print(model.summary())
    
            train_history = model.fit_generator(
                generator=train_iter,
                steps_per_epoch=Lens // Batch_size,
                epochs=25,
                initial_epoch=0,
                validation_data=val_iter,
                validation_steps=(Long - Lens) // Batch_size,
                callbacks=[ckpt],
            )
    
            model.save("finishModel.h5")
        else:
            test_iter = ts_gen()
            model = load_model("best_model.49-0.00.h5")
            pres = model.predict_generator(generator=test_iter, steps=math.ceil(528 / Batch_size), verbose=1)
            print(pres.shape)
            ohpres = np.argmax(pres, axis=1)
            print(ohpres.shape)
            df = pd.DataFrame()
            df["id"] = np.arange(1, len(ohpres) + 1)
            df["label"] = ohpres
            df.to_csv("predicts.csv", index=None)
            test_iter = ts_gen()
            for x in test_iter:
                x1 = x[0]
                break
            plt.plot(x1)
            plt.show()
    
    
    
    def show_train_history(train_history, train, validation):
        plt.plot(train_history.history[train])
        plt.plot(train_history.history[validation])
        plt.ylabel('Train History')
        plt.ylabel(train)
        plt.xlabel('Epoch')
        plt.legend(['train', 'validation'], loc='upper left')
        plt.show()
    
    show_train_history(train_history, 'accuracy', 'val_accuracy')
    
    show_train_history(train_history, 'loss', 'val_loss')
    
    plt.rcParams['font.sans-serif'] = ['SimHei']
    plt.figure(figsize=(6, 4))
    plt.plot(train_history.history['accuracy'], "g--", label="训练集准确率")
    plt.plot(train_history.history['val_accuracy'], "g", label="验证集准确率")
    plt.plot(train_history.history['loss'], "r--", label="训练集损失函数")
    plt.plot(train_history.history['val_loss'], "r", label="验证集损失函数")
    plt.title('模型的准确率和损失函数', fontsize=14)
    plt.ylabel('准确率和损失函数', fontsize=12)
    plt.xlabel('世代数', fontsize=12)
    plt.ylim(0)
    plt.legend()
    plt.show()
    
    
    //这里是我导入的测试集的标签表格,用来对比神经网络的测试结果,并且后面生成混淆矩阵;
    //这里的标签就是200个测试集的数据的故障标签
    file = r"C:\Users\Administrator\Desktop\shiyong22.csv"
    all_df = pd.read_csv(file)
    ndarray = all_df.values
    ndarray[:2]
    
    test_iter = ts_gen()
    pres = model.predict_generator(generator=test_iter, steps=math.ceil(520 / Batch_size), verbose=1)
    print(pres.shape)
    
    print(ndarray.shape)
    
    ohpres = np.argmax(pres, axis=1)
    print(ohpres.shape)
    ohpres=ohpres[:200]
    ohpres
    
    
    import matplotlib.pyplot as plt
    from sklearn.metrics import confusion_matrix
    import numpy as np
    
    def cm_plot(original_label, predict_label, pic=None):
        cm = confusion_matrix(original_label, predict_label)
        plt.figure()
        plt.matshow(cm, cmap=plt.cm.GnBu)
        plt.colorbar()
        for x in range(len(cm)):
            for y in range(len(cm)):
                plt.annotate(cm[x, y], xy=(x, y), horizontalalignment='center', verticalalignment='center')
        plt.ylabel('Predicted label')
        plt.xlabel('True label')
        plt.title('Confusion Matrix')
        if pic is not None:
            plt.savefig(str(pic) + '.jpg')
        plt.show()
    
    
    plt.rcParams['font.sans-serif'] = 'SimHei'
    plt.rcParams['axes.unicode_minus'] = False
    cm_plot(ndarray, ohpres)
    
    from sklearn.metrics import accuracy_score
    accuracy_score(ndarray, ohpres)
    
    train_history.history['loss']
    
    train_history.history['val_loss']
    
    train_history.history['val_accuracy']
    
    train_history.history['accuracy']
    

    数据下载链接
    https://gitee.com/wjj_xiaoxiansheng/cnn_-frft_-data

    数据介绍
    类别:标签0、1、2、3分别为正常状态、内圈故障、外圈故障、滚动体故障;
    信号:每个样本信号5000个数据点,共有1000个样本。从中随机抽取800个样本作为训练集,另外200个样本作为测试集。
    :我是对分数阶傅里叶变换做训练和测试,阶次(从0到1,间隔0.05,阶次为0时就是原始时域信号,阶次为1是就是傅里叶变换的数据结果,从文件夹名称可以看出。大家可以只用0.0阶次就是原始时域信号试一下。

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

    概述

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

    何时应用 1D CNN?

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

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

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

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

    “一维和二维卷积神经网络” 由 Nils Ackermann 在知识共享许可 CC BY-ND 4.0 下授权。

    问题描述

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

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

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

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

    “一维卷积神经网络示例”由 Nils Ackermann 在知识共享许可 CC BY-ND 4.0 下授权。

    让我们先来看一下对应的 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 模型,得到这样的结果已经很好了。我们的模型在精度(precision)、召回率(recall)和 f1 值(f1-score)上的得分也很高。

    precision    recall  f1-score   support

    0                 0.76      0.78      0.77       650

    1                 0.98      0.96      0.97      1990

    2                 0.91      0.94      0.92       452

    3                 0.99      0.84      0.91       370

    4                 0.82      0.77      0.79       725

    5                 0.93      0.98      0.95      2397

    avg / total       0.92      0.92      0.92      6584

    下面对这些分数的含义做一个简要回顾:

    “预测和结果矩阵”由 Nils Ackermann 在知识共享 CC BY-ND 4.0 许可下授权。

    精确度(Accuracy): 正确预测的结果与所有预测的结果总和之比。即 ((TP + TN) / (TP + TN + FP + FN))

    精度(Precision): 当模型预测为正样本时,它是对的吗?所有的正确预测的正样本除以所有的正样本预测。即 (TP / (TP + FP))

    召回率(Recall): 为模型识别出的所有正样本中有多少是正确预测的正样本?正确预测的正样本除以所有的正样本预测。即 (TP / (TP + FN))

    F1值(F1-score): 是精度和召回率的加权平均值。即 (2 x recall x precision / (recall + precision))

    测试数据上对应的混淆矩阵如下所示。

    总结

    本文通过以智能手机的加速度计数据来预测用户的行为为例,绍了如何使用 1D CNN 来训练网络。完整的 Python 代码可以在 github 上找到。

    链接与引用

    Keras 文档 关于一维卷积神经网络部分

    Keras 用例 关于一维卷积神经网络部分

    一篇关于使用一维卷积神经网络进行自然语言处理的好 文章

    展开全文
  • 介绍生物医学信号在研究和数据科学领域始终发挥着重要作用。就卷积神经网络 (CNN) 而言,这种特殊算法在定义深度学习 (DL) 等最复杂和最高级算法的架构方面发挥着重要作用。谈到深度学习,...

    介绍

    生物医学信号在研究和数据科学领域始终发挥着重要作用。就卷积神经网络 (CNN) 而言,这种特殊算法在定义深度学习 (DL) 等最复杂和最高级算法的架构方面发挥着重要作用。

    谈到深度学习,大多数开源编码与图像类型相关,属于二维数据(关于维度细节及其类型相关请参阅:https://www.analyticsvidhya.com/blog/2021/07/artificial-neural-network-simplified-with-1-d-ecg-biomedical-data)

    这篇特别的文章给出了一个一维数据的清晰画面,以及我们需要从二维数据或一维数据中使用哪些基本层。

    卷积神经网络

    我们已经在下面的文章中详细讨论了卷积神经网络 (CNN),其中包含带有 Python 代码的图像处理领域(与计算机视觉相关)。请查看链接以获得更好的理解:

    https://www.analyticsvidhya.com/blog/2021/07/convolution-neural-network-better-understanding/

    在简单的 CNN 中可以解释为,

    c427d6f8e4a64c736f7822eaa10d3b9e.gif

    CNN 算法的一些重要层或步骤,

    1. 卷积层(CNN中最重要的层)

    2. 激活函数(Boosting power,尤其是ReLu层)

    3. 池化(像PCA一样降维)

    4. Flattening(将矩阵形式转换为单个大列)

    5. 激活层——SOFTMAX层(主要是输出层,概率分布)

    6. 全连接(取决于目标/因变量)

    二维到一维数据

    对于 CNN,我们将使用一些基本层,它们为 LeNet 5、Alexnet、Inception 等大多数算法奠定了基础,例如我们将使用的图像分析,一些基本块或基本的部分,我也给了如何在一维数据中使用的方法,

    1. 卷积层——Conv2D(二维)——Conv1D(一维)

    2. 最大池层——MaxPool2D(二维)——MaxPool1D(一维)

    3. 展平层——Flattening(1维和2维)

    4. Drop-Out 层——Dropout(一维和二维)

    5. 全连接层&输出层——Dense

    从上面的讨论我们可以得出结论,在功能方面不会有任何区别,但在特定于应用程序方面有点不同。

    这是我们在将数据集提供给模型/特征提取过程之前在编写代码时需要保留的另一个最重要的概念,我们的数据应该是

    3080e7ab0158085cf95aaf7094c022bc.png

    上述归一化过程截图概念的来源是:

    https://github.com/anandprems/cnn/blob/main/cnn_cifar10.ipynb

    谈到图像,对于像 ECG 这样的一维数据或任何时间序列数据,我们需要为 DL 算法格式重塑我们的数据,

    0d50b33a97441d437b967d4209c2ab55.png

    图片来源:作者

    上述重塑过程截图的概念取自一维数据,

    https://github.com/anandprems/mitbih_cnn/blob/main/mitbih_cnn.ipynb

    第一维指的是输入样本

    第二维是指样品的长度

    第三个维度是指通道数

    相同的条件,但对于 LSTM(循环神经网络),

    第一维——样品

    第二维——时间步长

    第三维——特征

    我们从上述条件推断,输入层需要一个 3 维数据数组来进一步处理数据建模或模型提取。

    心电图数据

    Physionet 是世界著名的开源生物信号数据(心电图、脑电图、PPG 或其他),使用实时数据集总是很冒险的,因此我们可以监控我们的模型如何开始与实时数据一起工作。

    我们的理想/开源数据需要时间和调整。这里我们从 www.physionet.org 获取数据库,我们有一个不同的特定疾病数据库,其中,我更喜欢使用 MIT-BIH 心律失常数据库,一个主要原因是它是多分类的而不是二分类的。

    重要规格——所有记录均以 360 Hz 和11 位分辨率采样。

    数据集:https : //www.physionet.org/content/mitdb/1.0.0/

    我们在本文中使用的信号将类似于下图,无需编码,借助 MS EXCEL,我们可以可视化数据集的样子

    f15388bd28a2153dfb1e3688f00aa0ff.png

    每一行代表一个样本,每一列代表样本每秒的变化状态(这里是 188 个),如果你想可视化它(PQRST-U 波形 - 原始信号),你可以用 excel 或借助python代码来实现。

    Python 代码——CNN

    #importing libraries
    import numpy as np
    import pandas as pd
    import matplotlib.pyplot as plt
    #importing datasets
    test = pd.read_csv('mitbih_test.csv')
    train = pd.read_csv('mitbih_train.csv')
    #viewing normal dataset
    test.head()
    #viewing abnormal dataset
    train.head()
    #dimenion for normal
    test.shape
    #dimension for abnormal
    train.shape
    #changing the random column names to sequential - normal
    #as we have some numbers name as columns we need to change that to numbers as
    for trains in train:
        train.columns = list(range(len(train.columns)))
    #viewing edited columns for normal data
    train.head()
    #changing the random column names to sequential - abnormal
    #as we have some numbers name as columns we need to change that to numbers as
    for tests in test:
        test.columns = list(range(len(test.columns)))
    #viewing edited columns for abnormal data
    test.head()
    #combining two data into one
    #suffling the dataset and dropping the index
    #As when concatenating we all have arranged 0 and 1 class in order manner
    dataset = pd.concat([train, test], axis=0).sample(frac=1.0, random_state =0).reset_index(drop=True)
    #viewing combined dataset
    dataset.head()
    dataset.shape
    #basic info of statistics
    dataset.describe()
    #basic information of dataset
    dataset.info()
    #viewing the uniqueness in dataset
    dataset.nunique()
    #skewness of the dataset
    #the deviation of the distribution of the data from a normal distribution
    #+ve mean > median > mode
    #-ve mean < median < mode
    dataset.skew()
    #kurtosis of dataset
    #identifies whether the tails of a given distribution contain extreme values
    #Leptokurtic indicates a positive excess kurtosis
    #mesokurtic distribution shows an excess kurtosis of zero or close to zero
    #platykurtic distribution shows a negative excess kurtosis
    dataset.kurtosis()
    #missing values any from the dataset
    print(str('Any missing data or NaN in the dataset:'), dataset.isnull().values.any())
    #data ranges in the dataset - sample
    print("The minimum and maximum values are {}, {}".format(np.min(dataset.iloc[-2,:].values), np.max(dataset.iloc[-2,:].values)))
    #correlation for all features in the dataset
    correlation_data =dataset.corr()
    print(correlation_data)
    import seaborn as sns
    #visulaization for correlation
    plt.figure(figsize=(10,7.5))
    sns.heatmap(correlation_data, annot=True, cmap='BrBG')
    #for target value count
    label_dataset = dataset[187].value_counts()
    label_dataset
    #visualization for target label
    label_dataset.plot.bar()
    #splitting dataset to dependent and independent variable
    X = dataset.iloc[:,:-1].values #independent values / features
    y = dataset.iloc[:,-1].values #dependent values / target
    #checking imbalance of the labels
    from collections import Counter
    counter_before = Counter(y)
    print(counter_before)
    #applying SMOTE for imbalance
    from imblearn.over_sampling import SMOTE
    oversample = SMOTE()
    X, y = oversample.fit_resample(X, y)
    #after applying SMOTE for imbalance condition
    counter_after = Counter(y)
    print(counter_after)
    #splitting the datasets for training and testing process
    from sklearn.model_selection import train_test_split
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size =0.3, random_state=42)
    #size for the sets
    print('size of X_train:', X_train.shape)
    print('size of X_test:', X_test.shape)
    print('size of y_train:', y_train.shape)
    print('size of y_test:', y_test.shape)

    深度学习算法

    卷积神经网络

    #CNN
    from tensorflow.keras.layers import Flatten, Dense, Conv1D, MaxPool1D, Dropout
    #Reshape train and test data to (n_samples, 187, 1), where each sample is of size (187, 1)
    X_train = np.array(X_train).reshape(X_train.shape[0], X_train.shape[1], 1)
    X_test = np.array(X_test).reshape(X_test.shape[0], X_test.shape[1], 1)
    print("X Train shape: ", X_train.shape)
    print("X Test shape: ", X_test.shape)
    # Create sequential model 
    cnn_model = tf.keras.models.Sequential()
    #First CNN layer  with 32 filters, conv window 3, relu activation and same padding
    cnn_model.add(Conv1D(filters=32, kernel_size=(3,), padding='same', activation=tf.keras.layers.LeakyReLU(alpha=0.001), input_shape = (X_train.shape[1],1)))
    #Second CNN layer  with 64 filters, conv window 3, relu activation and same padding
    cnn_model.add(Conv1D(filters=64, kernel_size=(3,), padding='same', activation=tf.keras.layers.LeakyReLU(alpha=0.001)))
    #Third CNN layer with 128 filters, conv window 3, relu activation and same padding
    cnn_model.add(Conv1D(filters=128, kernel_size=(3,), padding='same', activation=tf.keras.layers.LeakyReLU(alpha=0.001)))
    #Fourth CNN layer with Max pooling
    cnn_model.add(MaxPool1D(pool_size=(3,), strides=2, padding='same'))
    cnn_model.add(Dropout(0.5))
    #Flatten the output
    cnn_model.add(Flatten())
    #Add a dense layer with 256 neurons
    cnn_model.add(Dense(units = 256, activation=tf.keras.layers.LeakyReLU(alpha=0.001)))
    #Add a dense layer with 512 neurons
    cnn_model.add(Dense(units = 512, activation=tf.keras.layers.LeakyReLU(alpha=0.001)))
    #Softmax as last layer with five outputs
    cnn_model.add(Dense(units = 5, activation='softmax'))
    cnn_model.compile(optimizer='adam', loss = 'sparse_categorical_crossentropy', metrics=['accuracy'])
    cnn_model.summary()

    d8890e248a0b3df7a883d5544a462644.png

    cnn_model_history = cnn_model.fit(X_train, y_train, epochs=10, batch_size = 10, validation_data = (X_test, y_test))

    792d0f64685490cfd031e44ae8183b19.png

    plt.plot(cnn_model_history.history['accuracy'])
    plt.plot(cnn_model_history.history['val_accuracy'])
    plt.legend(["accuracy","val_accuracy"])
    plt.title('Accuracy Vs Val_Accuracy')
    plt.xlabel('Epoch')
    plt.ylabel('Accuracy')

    8caf691a8a79722e051f3144f99e1380.png

    plt.plot(cnn_model_history.history['loss'])
    plt.plot(cnn_model_history.history['val_loss'])
    plt.legend(["loss","val_loss"])
    plt.title('Loss Vs Val_loss')
    plt.xlabel('Epoch')
    plt.ylabel('Loss')

    36bd5b7b76cd88d923b7210f692092a8.png

    完整代码:https://github.com/anandprems/mitbih_cnn

    ☆ END ☆

    如果看到这里,说明你喜欢这篇文章,请转发、点赞。微信搜索「uncle_pn」,欢迎添加小编微信「 woshicver」,每日朋友圈更新一篇高质量博文。

    扫描二维码添加小编↓

    9d4a79007981c9fe28a7727eb16c4624.png

    展开全文
  • pre_params) # 得到D_pre网络的参数 # 对D网络进行参数初始化 for i, v in enumerate(self.d_params): session.run(v.assign(self.weightsD[i])) # 训练对抗神经网络 for step in range(self.num_steps): x = self....
  • 加载预训练的单词嵌入加载预训练的 fastText 单词嵌入。此函数需要 Text Analytics Toolbox™ Model for fastText English 16 Billion Token Word Embedding 支持包。...加载数据根据 factoryReports.csv 中...
  • 介绍许多文章专注于二维卷积神经网络。 它们特别用于图像识别问题。 一维CNN涵盖了一定范围,例如 用于自然语言处理(NLP)。 尽管我们可能会遇到其他机器学习问题,但很少文章提供有关如何构造一维CNN的解释性演练...
  • 文章目录 前言 、pandas是什么? 二、使用步骤 1.... 2.读入数据 ...提示:这里可以添加本文要记录的大概...数据处理 导入数据 #导入数据 X=pd.read_csv('data.csv',header=None) X=np.array(test_data) y=p...
  • 本帖最后由 yexu55066 于 2016-8-16 02:17 编辑我用的DeepLearnToolbox的代码改了改成一维卷积神经网络,来识别一维的心电信号,训练样本40000均分成三类,训练后...或者没有可以直接用的一维卷积神经网络能发给...
  • 众多师弟师妹在使用一维卷积神经网络对凯斯西储,哥伦比亚等大学开源的轴承故障数据集进行故障诊断时,不知道该怎么把Matlab文件中的数据直接导进伸进网络进行训练。 我之前也不会,我一直用matlab打开数据然后黏贴...
  • 1.CNN神经网络可以处理图像一样处理文本并“理解”它们 2.主要好处是高效率 3.在许多方面,由于池化层和卷积核大小所造成的限制(虽然可以将卷积核设置得更大),会导致丢弃信息,但这并不意味着它们不是有用的...
  • 有时在进行进行神经网络训练时,需要自己导入本地的csv数据,此篇文章介绍如何导入数据,读取数据,设置训练集和测试集的大小,以及获取样本的features和tags 首先使用panda导入数据。 import pandas as pd dataset ...
  • 对于数据量大,适合以一维数据作为输入且难以探索数据内部规律的数据集,可以尝试利用深度学习神经网络(DNN)来对数据进行分类。 由于是分类问题,使用Adam作为优化器,交叉熵作为损失函数,大概的网络结构代码如下...
  • 基于多通道的一维卷积神经网络故障诊断

    千次阅读 热门讨论 2021-04-07 15:38:09
    数据准备 本次采用的PHM 2009 Challenge Data的全套齿轮箱数据集...数据集划分好后,利用EMD处理信号,每条样本均可分解得到7个IMF分量,且每组分解得到的IMF分量对应着齿轮箱故障模式的个类,第种故障模式
  • 今天发现个有意思的地方 输入shape为:torch.Size([1, 8, 64]) 全连接层: nn.Linear(64, 1) 居然没有报错,而且输出为torch.Size([1, 8, 1])!nb
  • 为了提高三维数据的自主学习特征能力。当前深度学习在三维模型特征提取遇到的问题: 1)同个三维模型在不同视点下提取的视图 之间存在较大的差异,这会对训练过程产生一定的干扰; 2)三 维模型现有的数据规模...
  • 不一定要选择循环神经网络,与前馈网络或卷积神经网络相比,它训练和传递新样本的成本相对较高(循环层计算成本较高)。 但是循环网络在记忆能力方面的特殊优势即记住句子中出现过的词,这是进入包括 NLP 或所有其他...
  • LSTM循环神经网络展开后的结构: 其中某个时刻LSTM单元的结构: 包含3 个门:遗忘门、输入/候选门和输出门 了 LSTM,模型可以开始学习人类习以为常和在潜意识层面上处理的语言模式。了这些模式,我们不仅可以...
  • 点击蓝字关注我们AI TIME欢迎每位AI爱好者的加入!普通的神经网络不适用于比较大的网格(因为参数会过多),而传统的卷积神经网络又没法应用在拥有不规则结构的三网格上。因此,我们把传...
  • 吴恩达《神经网络和深度学习》—用层隐藏层的神经网络分类二维数据1 安装包2 数据集   现在是时候建立你的第神经网络了,它将具有层隐藏层。你将看到此模型与你使用逻辑回归实现的模型之间的巨大差异。 ...
  • tensorflow 1.x基础练习 import tensorflow as tf import numpy as np # 使用 NumPy 生成假数据(phony data), 总共 100 个点. x_data = np.float32(np.random.rand(2, 100)) y_data = np.dot([0.1, 0.2], x_data)...
  • 点上方人工智能算法与Python大数据获取更多干货在右上方···设为星标★,第时间获取资源仅做学术分享,如侵权,联系删除转载于 :https://zhuanlan.zhihu.c...
  • 样本顺序要打乱:因为使用 mini-batch 学习方法,防止个批次的样本顺序关系,消除收敛波动 特征维度: 缺失值处理:填充 -1,或者平均值填充等 离散、异常特征处理:去除异常特征对应的样本,按照分位截断填充...
  • 本文以CWRU轴承故障的振动信号数据库作为模型的训练集和...数据连接:https://csegroups.case.edu/bearingdatacenter/pages/download-data-file 论文链接:https://www.sci-hub.ren/10.1109/tie.2017.2774777 代码
  • 【时间序列】时间卷积神经网络

    千次阅读 2021-05-20 00:16:48
    在深度学习的知识宝库中,除了前面文章中介绍的RNN,还有个重要的分支:卷积神经网络(CNN),其广泛应用于视觉,视频等二或者多维的图像领域。卷积网络具有深度,可并行等多种特性,这种技术...
  • 通过使用Tensorflow卷积神经网络实现数据分析过程实践,让我们深入思考深度学习能为我们省去了手动构造高阶特征的工作量,节省专业人事的投入。而且简单的卷积神经网络进行数据分析就能达到较好的效果。
  • 入门-图神经网络——应用-常见数据集介绍、实际应用、未来方向
  • 图信号处理 图信号处理(Graph Signal Processing ,GSP)是离散信号处理(Discrete Signal Processing,DSP)理论在图信号领域的应用。其通过傅里叶变换、滤波等信号处理基本概念的迁移,来研究对图信号的压缩、...
  • 它是在BP网络基本结构的基础上,在隐含层增加个承接层,作为一步延时算子,达到记忆的目的,从而使系统具有适应时变特性的能力,增强了网络的全局稳定性,它比前馈型神经网络具有更强的计算能力,还可以用来解决...
  • 点击上方“3D视觉工坊”,选择“星标”干货第时间送达作者丨Pratik Shukla,Roberto Iriondo编译|McGL编辑丨极市平台导读目前深度学习中的神经网络种类繁多,用...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 75,534
精华内容 30,213
关键字:

有哪些神经网络可以处理一维数据