精华内容
下载资源
问答
  • 使用一维卷积神经网络处理序列数据,数据类型为一维
  • 一维CNN对多维数据进行分类

    千次阅读 热门讨论 2020-11-15 10:26:45
    第二天起来查看资料,还真有CNN网络模型用来对单列多维数据进行分类,用的就是一维卷积神经网络,而图像处理的是用二维卷积神经网络。现在我们就来仔细聊聊一维卷积神经网络。 相信大家都很熟悉一张灰度图的数据结构...

    近日,老板突发奇想想让我用CNN模型对他研究的项目数据进行一个分类预测。他是快凌晨一点给我发的消息,当时一想,CNN不是用来搞图像数据用的吗?这分明是牛头不对马嘴呀,当时也没急着回他,假装睡着了,可是那晚确实没睡着,脑子里就净想这事。。。
    第二天起来查看资料,还真有CNN网络模型用来对单列多维数据进行分类,用的就是一维卷积神经网络,而图像处理的是用二维卷积神经网络。现在我们就来仔细聊聊一维卷积神经网络。
    相信大家都很熟悉一张灰度图的数据结构是是个二维矩阵,彩色图就是一个三维矩阵。
    然而我要进行处理的数据却是一维的向量。一维卷积操作如下图所示:

    在这里插入图片描述

    • 图中的输入的数据维度为8,过滤器的维度为5。与二维卷积类似,卷积后输出的数据维度为8−5+1=4。
    • 如果过滤器数量仍为1,输入数据的channel数量变为16,即输入数据维度为8×16。这里channel的概念相当于自然语言处理中的embedding,而该输入数据代表8个单词,其中每个单词的词向量维度大小为16。在这种情况下,过滤器的维度由5变为5×16,最终输出的数据维度仍为4。
    • 如果过滤器数量为n,那么输出的数据维度就变为4×n。

    老板给我的数据样本一共是3600个数据样本,每个样本数据为128维;为了其能进行一维卷积操作,必须先对所有数据进行扩维,就是将其增加一个维度;简单来说,我们把原先的矩阵当成一个平摊在桌面的纸片,变化以后,相当于给它立起来了,把原先的X轴“厚度”变为1;此时数据还是原来的数据,但是多了一个轴。对此数据而言,因为数据样本有3600个,维度是128维,整个数据格式是一个3600x128的二维矩阵,对其进行扩维,得到一个3600x128x1的三维矩阵。

    还是拿代码来详细说明

    代码是基于python环境的tensorflow框架编写
    python版本是:3.7.0
    tensorflow版本:2.3.1
    预先导入相应的包,有些是没有用的,自行斟酌

    import numpy as np
    import pandas as pd
    import keras
    from keras.models import Sequential
    from keras.wrappers.scikit_learn import KerasClassifier
    from keras.utils import np_utils, plot_model
    import matplotlib.pyplot as pl
    from sklearn import metrics
    from sklearn.model_selection import cross_val_score, train_test_split, KFold
    from sklearn.preprocessing import LabelEncoder
    from keras.layers import Dense, Dropout, Flatten, Conv1D, MaxPooling1D
    from keras.models import model_from_json
    import matplotlib.pyplot as plt
    from sklearn.metrics import confusion_matrix
    import seaborn as sns
    import os
    import itertools
    

    1.加载数据:

    # 载入数据
    B_data = np.load('./data/data.npy')
    B_label = np.load('./data/label.npy')
    # B_data = np.transpose(B_data)
    #print(B_data)
    X = np.expand_dims(B_data[:, 0:128].astype(float), axis=2)
    #print(X[1])
    # print(X)
    # print(X.shape)
    # print('--------------')
    Y = B_label
    # print(X)
    # print(X.shape)
    # print('---------------')
    # print(Y)
    # print(Y.shape)
    # print(type(X))
    # print(type(Y))
    # 湿度分类编码为数字
    encoder = LabelEncoder()
    Y_encoded = encoder.fit_transform(Y)
    # print(Y_encoded)
    Y_onehot = np_utils.to_categorical(Y_encoded)  # one-hot编码
    # truelabel1 = Y_onehot.argmax(axis=-1)  # 将one-hot转化为label
    # print('truelabel1\n')
    # print(truelabel1)
    # print(Y_onehot)
    # print(Y_onehot.shape)
    # print(Y_onehot[1])
    # print(Y_onehot[898])
    

    2.划分训练集、测试集

    X_train, X_test, Y_train, Y_test = train_test_split(X, Y_onehot, test_size=0.5, random_state=0)
    
    
    # print('X_train\n')
    # print(X_train)
    # print(X_train.shape)
    # print('Y_train\n')
    # print(Y_train)
    # print(Y_train.shape)
    # print('Y_test\n')
    # print(Y_test)   # 对应标签onehot编码
    

    3.定义一维卷积神经网络

    # 定义神经网络
    def baseline_model():
        model = Sequential()
        model.add(Conv1D(16, 3, input_shape=(128, 1)))
        model.add(Conv1D(16, 3, activation='tanh'))
        model.add(MaxPooling1D(3))
        model.add(Conv1D(64, 3, activation='tanh'))
        model.add(Conv1D(64, 3, activation='tanh'))
        model.add(MaxPooling1D(3))
        model.add(Conv1D(64, 3, activation='tanh'))
        model.add(Conv1D(64, 3, activation='tanh'))
        model.add(MaxPooling1D(3))
        model.add(Flatten())
        model.add(Dense(6, activation='softmax'))
        plot_model(model, to_file='model_classifier.png', show_shapes=True)
        print(model.summary())
        model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
        return model
    

    4.训练分类器

    # 训练分类器
    estimator = KerasClassifier(build_fn=baseline_model, epochs=20, batch_size=1, verbose=1)  # 模型,轮数,每次数据批数,显示进度条
    estimator.fit(X_train, Y_train)  # 训练模型
    

    5.将模型转化为json文件

    # 将其模型转换为json
    model_json = estimator.model.to_json()
    with open(r"model.json", 'w')as json_file:
        json_file.write(model_json)  # 权重不在json中,只保存网络结构
    estimator.model.save_weights('model.h5')
    

    6.加载模型作预测

    # 加载模型用做预测
    json_file = open(r"model.json", "r")
    loaded_model_json = json_file.read()
    json_file.close()
    loaded_model = model_from_json(loaded_model_json)
    loaded_model.load_weights("model.h5")
    print("loaded model from disk")
    loaded_model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
    
    

    7.测试效果

    # 分类准确率
    print("The accuracy of the classification model:")
    scores = loaded_model.evaluate(X_test, Y_test, verbose=0)
    print('%s: %.2f%%' % (loaded_model.metrics_names[1], scores[1] * 100))
    
    # 输出预测类别
    predicted = loaded_model.predict(X)  # 返回对应概率值
    print('predicted\n')
    # print(predicted)
    # predicted_label = loaded_model.predict_classes(X)  # 返回对应概率最高的标签
    predicted_label = np.argmax(loaded_model.predict(X), axis=-1)
    # print("\npredicted label: " + str(predicted_label))
    # print(11111111111111111111111111111111111)
    # # 显示混淆矩阵
    # plot_confuse(estimator.model, X_test, Y_test)  # 模型,测试集,测试集标签
    #
    # # 可视化卷积层
    # visual(estimator.model, X_train, 1)
    
    展开全文
  • 一维卷积代码,基本的网络结构,输入 卷积 池化 卷积 池化 输出,可实现分类的功能
  • CNN卷积神经网络Matlab实现例程,使用了matlabR2019a自带的深度学习工具箱,一维数据分类,二维cnn
  • 【keras】一维卷积神经网络多分类

    万次阅读 多人点赞 2020-06-20 13:05:05
    刚刚接触到深度学习,前2个月的时间里,我用一维的卷积神经网络实现了对于一维数据集的分类和回归。由于在做这次课题之前,我对深度学习基本上没有过接触,所以期间走了很弯路。 在刚刚收到题目的要求时,我选择...

    刚刚接触到深度学习,前2个月的时间里,我用一维的卷积神经网络实现了对于一维数据集的分类和回归。由于在做这次课题之前,我对深度学习基本上没有过接触,所以期间走了很多弯路。

    在刚刚收到题目的要求时,我选择使用TensorFlow来直接编写函数,结果由于没有什么基础,写了一个周我就放弃了,改用keras来完成我的任务。

    用keras来搭建神经网络其实很简单。我把自己的网络模型和数据集分享给大家,一起交流一起进步。

    我们要完成的任务是对一些给定的湿度特征数据进行分类,多分类就是最简单最入门的深度学习案例。

    我们要完成分类任务的数据集,247*900大小的一个矩阵,其中包含900条湿度信息,每条湿度信息由246位比特构成,最后一位表示湿度的类别,数值1-9,也就是每种湿度有100条。大家可以点击下边的链接自取。

    数据集-用做分类.csv

    或者百度网盘:

    链接:https://pan.baidu.com/s/1R0Ok5lB_RaI2cVHychZuxQ 
    提取码:9nwi 
    复制这段内容后打开百度网盘手机App,操作更方便哦

    首先是数据的导入:

    # 载入数据
    df = pd.read_csv(r"数据集-用做分类.csv")
    X = np.expand_dims(df.values[:, 0:246].astype(float), axis=2)
    Y = df.values[:, 246]

    X是900条数据的特征信息,Y表示真实类别。特别注意:这里的X在读取的时候矩阵增加了一维。使用一维卷积神经网络Conv1D的时候必须要事先这样对数据集进行处理,而只使用深度网络Dense时不需要额外的增加一维。

    具体细节大家可以看我之前写过的一篇博客,比较细的区分了这两种情况:

    Conv1D层与Dense层的连接

    没有接触过的读者可以查一下只使用深度层和使用卷积层的区别。CNN眼里只有局部小特征,而DNN只有全局大特征。

    最普通的深层神经网络包含多层神经元,从输入信号中提取信息。每个神经元接受来自前一层神经元的输入,并通过权重和非线性将它们组合起来。与普通神经网络中每个神经元与前一层的所有神经元连接不同,CNN中的每个神经元只与前一层的少数神经元局部连接。而且,CNN同一层的所有神经元都有相同的权重。CNN层中神经元的值通常被称为特征映射(features maps),因为它们可以被看作是对应于输入的不同部分的特征。卷积神经网络可以很好地捕获出原数据中的局部简单特征,随着层数的增加,产生的特征映射会捕获输入信号越来越多的全局和更复杂的属性。它可以在一条数据中较短的片段中获得感兴趣的特征,并且该特征在该数据片段中的位置不具有高度相关性

    紧接着是对湿度类别的编码:

    # 湿度分类编码为数字
    encoder = LabelEncoder()
    Y_encoded = encoder.fit_transform(Y)
    Y_onehot = np_utils.to_categorical(Y_encoded)

    Y_onehot编码是为了让程序自己来区分每一条特征信息而添加的编码。一个简单的例子解释一下:

    这一步转化工作我们可以利用keras中的np_utils.to_categorical函数来进行。

    “one-hot编码。one-hot编码的定义是用N位状态寄存器来对N个状态进行编码。比如[0,...,0],[1,...,1],[2,...,2]有3个分类值,因此N为3,对应的one-hot编码可以表示为100,010,001。”

    我们将原始的数据集划分为训练集和测试集:

    # 划分训练集,测试集
    X_train, X_test, Y_train, Y_test = train_test_split(X, Y_onehot, test_size=0.3, random_state=0)

    我这里把原始数据集以7:3的比例划分为训练集和测试集。训练集用来逼近真实类别,测试集来测试效果。

    接着的是网络模型的搭建:

    # 定义神经网络
    def baseline_model():
        model = Sequential()
        model.add(Conv1D(16, 3, input_shape=(246, 1)))
        model.add(Conv1D(16, 3, activation='tanh'))
        model.add(MaxPooling1D(3))
        model.add(Conv1D(64, 3, activation='tanh'))
        model.add(Conv1D(64, 3, activation='tanh'))
        model.add(MaxPooling1D(3))
        model.add(Conv1D(64, 3, activation='tanh'))
        model.add(Conv1D(64, 3, activation='tanh'))
        model.add(MaxPooling1D(3))
        model.add(Flatten())
        model.add(Dense(9, activation='softmax'))
        plot_model(model, to_file='./model_classifier.png', show_shapes=True) # 保存网络结构为图片,这一步可以直接去掉
        print(model.summary()) # 显示网络结构
        model.compile(loss='categorical_crossentropy',optimizer='adam', metrics=['accuracy'])
        return model

    这一步往往是最核心的一步,网络模型通过卷积层来提取特征,在分类任务中,网络的最后一层为每个类。分类算法得到的是一个决策面,通过对比湿度信息属于每一类湿度的概率,进而对号入座。

    经过多次调参尝试,最后我使用7层Conv1D来提取特征值,每两层Conv1D后添加一层MaxPooling1D来保留主要特征,减少计算量。每层卷积层使用双曲正切函数tanh(hyperbolic tangent function)来提高神经网络对模型的表达能力。tanh经常被运用到多分类任务中用做激活函数。

    神经网络本就具有不可解释性,一般卷积核和全连接的结点数按照2的指数次幂来取。

    Flatten()层作为中间层来链接卷积神经网络和全连接层。

    神经网络被训练来最小化一个损失函数(Softmax loss),该函数捕捉到网络的特征输出与给定的期望输出之间的差异。9个输出结点对应九个类别的湿度,Softmax将每个特征数据匹配到概率最大的特征类别。

    交叉熵损失函数(categorical crossentropy)作为模型训练的损失函数,它刻画的是当前学习到的概率分布与实际概率分布的距离,也就是损失函数越小,两个概率分布越相似,此时损失函数接近于0。

    我将网络模型绘制成了AlexNet风格的示意图:

    这里也给大家安利下这个很好用的绘制神经网络的工具:

    http://alexlenail.me/NN-SVG/AlexNet.html

    搭建好网络之后就可以开始训练了。

    # 训练分类器
    estimator = KerasClassifier(build_fn=baseline_model, epochs=40, batch_size=1, verbose=1)
    estimator.fit(X_train, Y_train)

    batch_size设为1,然后一共训练40期。

    这些数据大家都可以根据自己的实际情况做出调整和优化。

    到这一步已经是搭建和训练的部分全部结束了。

    紧接着是测试集来验证训练的准确性。

    为了每次测试前不重复训练,我们将训练的模型保存下来:

    # 将其模型转换为json
    model_json = estimator.model.to_json()
    with open(r"C:\Users\Desktop\model.json",'w')as json_file:
        json_file.write(model_json)# 权重不在json中,只保存网络结构
    estimator.model.save_weights('model.h5')

    下面是读取模型的部分,这一部分完全可以写到另一个函数里:

    # 加载模型用做预测
    json_file = open(r"C:\Users\Desktop\model.json", "r")
    loaded_model_json = json_file.read()
    json_file.close()
    loaded_model = model_from_json(loaded_model_json)
    loaded_model.load_weights("model.h5")
    print("loaded model from disk")
    loaded_model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
    # 分类准确率
    print("The accuracy of the classification model:")
    scores = loaded_model.evaluate(X_test, Y_test, verbose=0)
    print('%s: %.2f%%' % (loaded_model.metrics_names[1], scores[1] * 100))
    # 输出预测类别
    predicted = loaded_model.predict(X)
    predicted_label = loaded_model.predict_classes(X)
    print("predicted label:\n " + str(predicted_label))

    当然我们也希望可以直观的显示出模型的分类精度,和训练的过程。

    混淆矩阵经常用来表示分类的效果。

    #显示混淆矩阵
    plot_confuse(estimator.model, X_test, Y_test)

    当然也需要我们自己写出来:

    # 混淆矩阵定义
    def plot_confusion_matrix(cm, classes,title='Confusion matrix',cmap=plt.cm.jet):
        cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]
        plt.imshow(cm, interpolation='nearest', cmap=cmap)
        plt.rcParams['font.sans-serif'] = ['SimHei']  # 用来正常显示中文标签
        plt.rcParams['axes.unicode_minus'] = False  # 用来正常显示负号
        plt.colorbar()
        tick_marks = np.arange(len(classes))
        plt.xticks(tick_marks,('0%','3%','5%','8%','10%','12%','15%','18%','20%','25%'))
        plt.yticks(tick_marks,('0%','3%','5%','8%','10%','12%','15%','18%','20%','25%'))
        thresh = cm.max() / 2.
        for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):
            plt.text(j, i, '{:.2f}'.format(cm[i, j]), horizontalalignment="center",color="white" if cm[i, j] > thresh else "black")
        plt.tight_layout()
        plt.ylabel('真实类别')
        plt.xlabel('预测类别')
        plt.savefig('test_xx.png', dpi=200, bbox_inches='tight', transparent=False)
        plt.show()
    
    # 显示混淆矩阵
    def plot_confuse(model, x_val, y_val):
        predictions = model.predict_classes(x_val)
        truelabel = y_val.argmax(axis=-1)   # 将one-hot转化为label
        conf_mat = confusion_matrix(y_true=truelabel, y_pred=predictions)
        plt.figure()
        plot_confusion_matrix(conf_mat, range(np.max(truelabel)+1))
    

    如果好奇的话你也可以看看每层卷积层到底学到了什么:

    # 可视化卷积层
    visual(estimator.model, X_train, 1)

    但是我觉得看一维卷积层的特征没啥意义,毕竟都是一些点,看起来有点非人类。

    # 卷积网络可视化
    def visual(model, data, num_layer=1):
        # data:图像array数据
        # layer:第n层的输出
        layer = keras.backend.function([model.layers[0].input], [model.layers[num_layer].output])
        f1 = layer([data])[0]
        print(f1.shape)
        num = f1.shape[-1]
        print(num)
        plt.figure(figsize=(8, 8))
        for i in range(num):
            plt.subplot(np.ceil(np.sqrt(num)), np.ceil(np.sqrt(num)), i+1)
            plt.imshow(f1[:, :, i] * 255, cmap='gray')
            plt.axis('off')
        plt.show()

    最后运行的所有结果如下:

    这个结果这么好纯粹是因为数据比较好,分类的准确率很大程度都是依赖你数据集本身的区分度的。

    下面是数据集的特征图,从图上就可以看出数据的层次性很直观。

    当然我给大家上传的这部分数据是我这边结果最好的一批,其他数据集准确度达不到这么高。

    下面贴出整个分类过程的完整代码:

    # -*- coding: utf8 -*-
    import numpy as np
    import pandas as pd
    import keras
    from keras.models import Sequential
    from keras.wrappers.scikit_learn import KerasClassifier
    from keras.utils import np_utils,plot_model
    from sklearn.model_selection import cross_val_score,train_test_split,KFold
    from sklearn.preprocessing import LabelEncoder
    from keras.layers import Dense,Dropout,Flatten,Conv1D,MaxPooling1D
    from keras.models import model_from_json
    import matplotlib.pyplot as plt
    from sklearn.metrics import confusion_matrix
    import itertools
    
    # 载入数据
    df = pd.read_csv(r"C:\Users\Desktop\数据集-用做分类.csv")
    X = np.expand_dims(df.values[:, 0:246].astype(float), axis=2)
    Y = df.values[:, 246]
    
    # 湿度分类编码为数字
    encoder = LabelEncoder()
    Y_encoded = encoder.fit_transform(Y)
    Y_onehot = np_utils.to_categorical(Y_encoded)
    
    # 划分训练集,测试集
    X_train, X_test, Y_train, Y_test = train_test_split(X, Y_onehot, test_size=0.3, random_state=0)
    
    # 定义神经网络
    def baseline_model():
        model = Sequential()
        model.add(Conv1D(16, 3, input_shape=(246, 1)))
        model.add(Conv1D(16, 3, activation='tanh'))
        model.add(MaxPooling1D(3))
        model.add(Conv1D(64, 3, activation='tanh'))
        model.add(Conv1D(64, 3, activation='tanh'))
        model.add(MaxPooling1D(3))
        model.add(Conv1D(64, 3, activation='tanh'))
        model.add(Conv1D(64, 3, activation='tanh'))
        model.add(MaxPooling1D(3))
        model.add(Flatten())
        model.add(Dense(9, activation='softmax'))
        plot_model(model, to_file='./model_classifier.png', show_shapes=True)
        print(model.summary())
        model.compile(loss='categorical_crossentropy',optimizer='adam', metrics=['accuracy'])
        return model
    
    # 训练分类器
    estimator = KerasClassifier(build_fn=baseline_model, epochs=40, batch_size=1, verbose=1)
    estimator.fit(X_train, Y_train)
    
    # 卷积网络可视化
    # def visual(model, data, num_layer=1):
    #     # data:图像array数据
    #     # layer:第n层的输出
    #     layer = keras.backend.function([model.layers[0].input], [model.layers[num_layer].output])
    #     f1 = layer([data])[0]
    #     print(f1.shape)
    #     num = f1.shape[-1]
    #     print(num)
    #     plt.figure(figsize=(8, 8))
    #     for i in range(num):
    #         plt.subplot(np.ceil(np.sqrt(num)), np.ceil(np.sqrt(num)), i+1)
    #         plt.imshow(f1[:, :, i] * 255, cmap='gray')
    #         plt.axis('off')
    #     plt.show()
    
    # 混淆矩阵定义
    def plot_confusion_matrix(cm, classes,title='Confusion matrix',cmap=plt.cm.jet):
        cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]
        plt.imshow(cm, interpolation='nearest', cmap=cmap)
        plt.rcParams['font.sans-serif'] = ['SimHei']  # 用来正常显示中文标签
        plt.rcParams['axes.unicode_minus'] = False  # 用来正常显示负号
        plt.colorbar()
        tick_marks = np.arange(len(classes))
        plt.xticks(tick_marks,('0%','3%','5%','8%','10%','12%','15%','18%','20%','25%'))
        plt.yticks(tick_marks,('0%','3%','5%','8%','10%','12%','15%','18%','20%','25%'))
        thresh = cm.max() / 2.
        for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):
            plt.text(j, i, '{:.2f}'.format(cm[i, j]), horizontalalignment="center",color="white" if cm[i, j] > thresh else "black")
        plt.tight_layout()
        plt.ylabel('真实类别')
        plt.xlabel('预测类别')
        plt.savefig('test_xx.png', dpi=200, bbox_inches='tight', transparent=False)
        plt.show()
    
    # seed = 42
    # np.random.seed(seed)
    # kfold = KFold(n_splits=10, shuffle=True, random_state=seed)
    # result = cross_val_score(estimator, X, Y_onehot, cv=kfold)
    # print("Accuracy of cross validation, mean %.2f, std %.2f\n" % (result.mean(), result.std()))
    
    # 显示混淆矩阵
    def plot_confuse(model, x_val, y_val):
        predictions = model.predict_classes(x_val)
        truelabel = y_val.argmax(axis=-1)   # 将one-hot转化为label
        conf_mat = confusion_matrix(y_true=truelabel, y_pred=predictions)
        plt.figure()
        plot_confusion_matrix(conf_mat, range(np.max(truelabel)+1))
    
    # 将其模型转换为json
    model_json = estimator.model.to_json()
    with open(r"C:\Users\316CJW\Desktop\毕设代码\model.json",'w')as json_file:
        json_file.write(model_json)# 权重不在json中,只保存网络结构
    estimator.model.save_weights('model.h5')
    
    # 加载模型用做预测
    json_file = open(r"C:\Users\Desktop\model.json", "r")
    loaded_model_json = json_file.read()
    json_file.close()
    loaded_model = model_from_json(loaded_model_json)
    loaded_model.load_weights("model.h5")
    print("loaded model from disk")
    loaded_model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
    # 分类准确率
    print("The accuracy of the classification model:")
    scores = loaded_model.evaluate(X_test, Y_test, verbose=0)
    print('%s: %.2f%%' % (loaded_model.metrics_names[1], scores[1] * 100))
    # 输出预测类别
    predicted = loaded_model.predict(X)
    predicted_label = loaded_model.predict_classes(X)
    print("predicted label:\n " + str(predicted_label))
    #显示混淆矩阵
    plot_confuse(estimator.model, X_test, Y_test)
    
    # 可视化卷积层
    # visual(estimator.model, X_train, 1)

    但是,湿度值到底是连续的数值,分类任务验证了我们数据集特征的可分辨性。

    下一篇博客中,我将对数据集稍作修改,将湿度类别改为真实湿度值。

    利用卷积神经网络来提取特征,实现线性回归,二者同出一脉。

    【keras】一维卷积神经网络做回归

    比起其他科普的博客,我这篇文章更像是在学习如何利用工具做深度学习。

    希望大家多多支持,不足之处互相交流(●ˇ∀ˇ●)!

     

    展开全文
  • CNN_matlab.m

    2020-01-10 16:24:33
    CNN卷积神经网络Matlab实现例程,使用了matlabR2019a自带的深度学习工具箱,一维数据分类,二维cnn
  • python深度学习--一维cnn处理序列

    千次阅读 热门讨论 2019-03-20 16:37:55
    要想结合卷积神经网络的速度与轻量以及RNN的顺序敏感性,一种方法是在RNN前面使用一维CNN作预处理。对于那些非常长,以至于RNN无法处理的序列(比如包含上千个时间步的序列),这种方法尤其有用。 ''' #卷积神经网络...
    import numpy as np
    import pandas as pd
    import matplotlib.pyplot as plt
    import pylab
    from pandas import DataFrame, Series
    from keras import models, layers, optimizers, losses, metrics
    from keras.models import Sequential
    from keras.utils.np_utils import to_categorical
    
    #一维卷积神经网络[通常与空洞卷积核(dilated kernel)一起使用]已经在音 频生成和机器翻译领域取得了巨大成功。另外,对于文本分类和时间序列预测等简单任务,小型的一维卷积神经网络可以替代RNN,而且速度更快
    
    #序列的一维卷积:可以识别序列中的局部模式。因为对每个序列段执行相同的输入变换,所以在句子中某个位置学到的模式稍后可以在其他位置被识别,这使得一维卷积神经网络具有平移不变性(对于时间平移而言)
    #一维卷积神经网络的工作原理:每个输出时间步都是利用输入序列在时间维度上的一小段得到的
    
    #序列的一维池化:从输入中提取一维序列段(即子序列),然后输出其最大值(最大池化)或平均值(平均池化)。与二维卷积神经网络一样,该运算也是 用于降低一维输入的长度(子采样)
    
    #实现一维卷积神经网络
    #Keras 中的一维卷积神经网络是 Conv1D 层,其接口类似于 Conv2D
    from keras.datasets import imdb
    from keras.preprocessing import sequence
    fname='F:/jena_climate_2009_2016.csv'#jena天气数据集(2009—2016 年的数据,每 10 分钟记录 14 个不同的量)
    #对于.csv数据格式等用pandas操作更加方便
    df=pd.read_csv(fname,)
    
    #数据类型不同,所以需要标准化
    #预处理数据的方法是,将每个时间序列减去其平均值,然后除以其标准差
    df=df.drop(['Date Time'],axis=1)
    float_data=df.ix[:,:]
    # print(train_data)
    mean=float_data.mean(axis=0)
    # print(mean)
    float_data-=mean
    std=float_data.std(axis=0)
    float_data /=std
    # print(float_data)
    
    #生成时间序列样本及其目标的生成器
    def generator(data,lookback,delay,min_index,max_index,shuffle=False,batch_size=128,step=6):
        if max_index is None:
            max_index=len(data)-delay-1
            #[0--min_index--lookback--max_index--delay--len(data)]
            #                       i
        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:#表明取到最后一批(数量<batch_size)
                    i=min_index+lookback
                rows=np.arange(i,min(i+batch_size,max_index))
                i+=len(rows)
            samples=np.zeros((len(rows),lookback//step,data.shape[-1]))#按小时批量抽取数据点,每个点包含14个特征
            # print(samples)
            targets=np.zeros((len(rows),))
            for j,row in enumerate(rows):
                indices=range(rows[j]-lookback,rows[j],step)#6步(每小时)一个点索引
                samples[j]=data.ix[indices,:]
                t=data.ix[rows[j]+delay,:]
                targets[j]=t[1]#144步(24小时后的温度数组)
            yield samples,targets
    
    #准备训练生成器、验证生成器和测试生成器
    #因为这种方法允许操作更长 的序列,所以我们可以查看更早的数据(通过增大数据生成器的 lookback 参数)或查看分辨 率更高的时间序列(通过减小生成
    # 器的 step 参数)。这里我们任意地将 step 减半,得到时间序列的长度变为之前的两倍,温度数据的采样频率变为每 30 分钟一个数据点。
    lookback=720
    step=3#每30分钟观测一次
    delay=144
    
    train_gen=generator(
        float_data,
        lookback=lookback,
        delay=delay,
        min_index=0,
        max_index=200000,
        shuffle=True,
        step=step)
    val_gen=generator(
        float_data,
        lookback=lookback,
        delay=delay,
        min_index=200001,
        max_index=300000,
        step=step)
    test_gen=generator(
        float_data,
        lookback=lookback,
        delay=delay,
        min_index=300001,
        max_index=None,
        step=step)
    
    val_steps = (300000 - 200001 - lookback) //128
    print(val_steps)
    test_steps = (len(float_data) - 300001 - lookback) //128
    
    def acc_loss_plot(history):
        fig=plt.figure()
        ax1=fig.add_subplot(2,1,1)
        acc = history.history['acc']
        val_acc = history.history['val_acc']
        loss = history.history['loss']
        val_loss = history.history['val_loss']
        epochs = range(1, len(loss) + 1)
        ax1.plot(epochs, acc, 'bo', label='Training acc')
        ax1.plot(epochs, val_acc, 'b', label='Validation acc')
        ax1.set_title('Training and validation accuracy')
        ax2=fig.add_subplot(2,1,2)
        ax2.plot(epochs, loss, 'bo', label='Training loss')
        ax2.plot(epochs, val_loss, 'b', label='Validation loss')
        ax2.set_title('Training and validation loss')
        plt.legend()
        plt.tight_layout()
        plt.show()
    ###---------------------------------------------------------------------
    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)
    
    from keras.optimizers import RMSprop
    def build_1D_cnn_imdb():
        model=Sequential()
        model.add(layers.Embedding(max_features,128,input_length=max_len))
        model.add(layers.Conv1D(32,7,activation='relu'))
        model.add(layers.MaxPooling1D(5,))
        model.add(layers.Conv1D(32,7,activation='relu'))
        model.add(layers.GlobalAveragePooling1D())
        model.add(layers.Dense(1))
        print(model.summary())
    
        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)
        return history
    
    # acc_loss_plot(build_1D_cnn_imdb())#验证精度略低于LSTM,83%
    ###-----------------------------------------------------------------------
    #结合CNN和RNN来处理长序列
    #为了识别更长期的模式,你可以将许多卷积层和池化层堆叠在一起,这样上面的层能够观察到原始输入中更长的序列段,但仅仅使用CNN不是一种引入顺序敏感性的好方法,可用jena温度预测问题上使用1D CNN进行验证
    def build_1D_cnn_jena():
        model = Sequential()
        model.add(layers.Conv1D(32, 5, activation='relu', input_shape=(None, float_data.shape[-1])))
        model.add(layers.MaxPooling1D(3))
        model.add(layers.Conv1D(32, 5, activation='relu'))
        model.add(layers.MaxPooling1D(3))
        model.add(layers.Conv1D(32, 5, activation='relu'))
        model.add(layers.GlobalMaxPooling1D())
        model.add(layers.Dense(1))
        model.compile(optimizer=RMSprop(), loss='mae')
        history = model.fit_generator(train_gen,
                                      steps_per_epoch=500, epochs=20,
                                      validation_data=val_gen,
                                      validation_steps=val_steps)
        return history
    # acc_loss_plot(build_1D_cnn_jena())#0.46左右
    # 比基于常识的基准还要高
    '''
    因为卷积神经网络在输入时间序列的所有位置寻找模式,它并不知道所看到某个模式的时间位置(距开始多长时间,距结束多长时间等)。对于这个具体的预测问题,对最新数据点的解释与对较早数据点的解释应该并不相同,所以卷积神经网络无法得到有意义的结果.
    卷积神经网络的这种限制对于 IMDB 数据来说并不是问题,因为对于与正面情绪或负面情绪相关联的关键词模式,无论出现在输入句子中的什么位置,它所包含的信息量是一样的
    '''
    
    '''
    要想结合卷积神经网络的速度与轻量以及RNN的顺序敏感性,一种方法是在RNN前面使用一维CNN作预处理。对于那些非常长,以至于RNN无法处理的序列(比如包含上千个时间步的序列),这种方法尤其有用。
    '''
    #卷积神经网络可以将长的输入序列转换为高级特征组成的更短序列(下采样)。然后,提取的特征组成的这些序列成为网络中RNN的输入
    
    def build_cnn_joint_rnn():
        model = Sequential()
        model.add(layers.Conv1D(32, 5, activation='relu', input_shape=(None, float_data.shape[-1])))
        model.add(layers.MaxPooling1D(3))
        model.add(layers.Conv1D(32, 5, activation='relu'))
        model.add(layers.GRU(32, dropout=0.1, recurrent_dropout=0.5))
        model.add(layers.Dense(1))
        model.summary()
        model.compile(optimizer=RMSprop(), loss='mae')
        history = model.fit_generator(train_gen,
                                      steps_per_epoch=500,
                                      epochs=20,
                                      validation_data=val_gen,
                                      validation_steps=val_steps)
        return history
    acc_loss_plot(build_cnn_joint_rnn())#[注意修改acc_loss_plot(),history中没有acc]#0.25
    #从验证损失来看,这种架构的效果不如只用正则化 GRU,但速度要快很多。它查看了两倍的数据量,在本例中可能不是非常有用,但对于其他数据集可能非常重要。
    
    

     IMDB数据集使用一维cnn

     

    jena温度预测数据集使用一维cnn


    '''
        1.二维卷积神经网络在二维空间中处理视觉模式时表现很好,与此相同,一维卷积神经网络在处理时间模式时表现也很好。对于某些问题,特别是自然语言处理任务,它可以替代RNN,并且速度更快。
        2.通常情况下,一维卷积神经网络的架构与计算机视觉领域的二维卷积神经网络很相似,它将 Conv1D 层和 MaxPooling1D 层堆叠在一起,最后是一个全局池化运算或展平操作。
        3.因为RNN在处理非常长的序列时计算代价很大,但一维卷积神经网络的计算代价很小, 所以在RNN之前使用一维卷积神经网络作为预处理步骤是一个好主意,这样可以使序列变短,并提取出有用的表示交给RNN来处理
    '''
    '''
    你可以用RNN进行时间序列回归(“预测未来”)、时间序列分类、时间序列异常检测和序列标记(比如找出句子中的人名或日期)。
    同样,你可以将一维卷积神经网络用于机器翻译(序列到序列的卷积模型,比如 SliceNet)、文档分类和拼写校正。
    '''

     

     

     

    展开全文
  • 主要介绍了在Keras中CNN联合LSTM进行分类实例,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • TensorflowTutorial_一维数据构造简单CNN

    万次阅读 热门讨论 2018-02-07 10:09:03
    使用一维数据构造简单卷积神经网络 觉得有用的话,欢迎一起讨论相互学习~Follow Me 神经网络对于一维数据非常重要,时序数据集...希望给大家使用CNN处理一维数据一些帮助。 参考代码 # Implementing Different

    使用一维数据构造简单卷积神经网络

    觉得有用的话,欢迎一起讨论相互学习~

    我的微博我的github我的B站

    神经网络对于一维数据非常重要,时序数据集、信号处理数据集和一些文本嵌入数据集都是一维数据,会频繁的使用到神经网络。我们在此利用一组一维数据构造卷积层-最大池化层-全连接层的卷积神经网络。希望给大家使用CNN处理一维数据一些帮助。

    参考代码

    # Implementing Different Layers
    # ---------------------------------------
    #
    # We will illustrate how to use different types
    # of layers in TensorFlow
    #
    # The layers of interest are:
    #  (1) Convolutional Layer卷积层
    #  (2) Activation Layer激活层
    #  (3) Max-Pool Layer池化层
    #  (4) Fully Connected Layer 全连接层
    #
    # We will generate two different data sets for this
    #  script, a 1-D data set (row of data) and
    #  a 2-D data set (similar to picture)
    
    import tensorflow as tf
    import matplotlib.pyplot as plt
    import csv
    import os
    import random
    import numpy as np
    import random
    from tensorflow.python.framework import ops
    
    ops.reset_default_graph()
    
    # ---------------------------------------------------|
    # -------------------1D-data-------------------------|
    # ---------------------------------------------------|
    
    # Create graph session 创建初始图结构
    ops.reset_default_graph()
    sess = tf.Session()
    
    # parameters for the run运行参数
    data_size = 25
    conv_size = 5  # 卷积核宽度方向的大小
    maxpool_size = 5  # 池化层核宽度方向上的大小
    stride_size = 1  # 卷积核宽度方向上的步长
    
    # ensure reproducibility 确保复现性
    seed = 13
    np.random.seed(seed)
    tf.set_random_seed(seed)
    
    # Generate 1D data 生成一维数据
    data_1d = np.random.normal(size=data_size)
    
    # Placeholder
    x_input_1d = tf.placeholder(dtype=tf.float32, shape=[data_size])
    
    
    # --------Convolution--------
    def conv_layer_1d(input_1d, my_filter, stride):
        # TensorFlow's 'conv2d()' function only works with 4D arrays:
        # [batch, height, width, channels], we have 1 batch, and
        # width = 1, but height = the length of the input, and 1 channel.
        # So next we create the 4D array by inserting dimension 1's.
        # 关于数据维度的处理十分关键,因为tensorflow中卷积操作只支持四维的张量,
        # 所以要人为的把数据补充为4维数据[1,1,25,1]
        input_2d = tf.expand_dims(input_1d, 0)
        input_3d = tf.expand_dims(input_2d, 0)
        input_4d = tf.expand_dims(input_3d, 3)
        # Perform convolution with stride = 1, if we wanted to increase the stride,
        # to say '2', then strides=[1,1,2,1]
        convolution_output = tf.nn.conv2d(input_4d, filter=my_filter, strides=[1, 1, stride, 1], padding="VALID")
        # Get rid of extra dimensions 去掉多余的层数,只保留数字
        conv_output_1d = tf.squeeze(convolution_output)
        return (conv_output_1d)
    
    
    # Create filter for convolution.
    my_filter = tf.Variable(tf.random_normal(shape=[1, conv_size, 1, 1]))
    # Create convolution layer
    my_convolution_output = conv_layer_1d(x_input_1d, my_filter, stride=stride_size)
    
    
    # --------Activation--------
    def activation(input_1d):
        return (tf.nn.relu(input_1d))
    
    
    # Create activation layer
    my_activation_output = activation(my_convolution_output)
    
    
    # --------Max Pool--------
    def max_pool(input_1d, width, stride):
        # Just like 'conv2d()' above, max_pool() works with 4D arrays.
        # [batch_size=1, width=1, height=num_input, channels=1]
        # 因为在处理卷积层的结果时,使用squeeze函数对结果输出进行降维,所以此处要将最大池化层的维度提升为4维
        input_2d = tf.expand_dims(input_1d, 0)
        input_3d = tf.expand_dims(input_2d, 0)
        input_4d = tf.expand_dims(input_3d, 3)
        # Perform the max pooling with strides = [1,1,1,1]
        # If we wanted to increase the stride on our data dimension, say by
        # a factor of '2', we put strides = [1, 1, 2, 1]
        # We will also need to specify the width of the max-window ('width')
        pool_output = tf.nn.max_pool(input_4d, ksize=[1, 1, width, 1],
                                     strides=[1, 1, stride, 1],
                                     padding='VALID')
        # Get rid of extra dimensions
        pool_output_1d = tf.squeeze(pool_output)
        return (pool_output_1d)
    
    
    my_maxpool_output = max_pool(my_activation_output, width=maxpool_size, stride=stride_size)
    
    
    # --------Fully Connected--------
    def fully_connected(input_layer, num_outputs):
        # First we find the needed shape of the multiplication weight matrix:
        # The dimension will be (length of input) by (num_outputs)
        weight_shape = tf.squeeze(tf.stack([tf.shape(input_layer), [num_outputs]]))
        # squeeze函数用于去掉维度为1的维度。保留数据。
    
        # Initialize such weight
        # 初始化weight
        weight = tf.random_normal(weight_shape, stddev=0.1)
        # Initialize the bias
        # 初始化bias
        bias = tf.random_normal(shape=[num_outputs])
        # Make the 1D input array into a 2D array for matrix multiplication
        # 将一维的数组添加一维成为2维数组
        input_layer_2d = tf.expand_dims(input_layer, 0)
        # Perform the matrix multiplication and add the bias
        full_output = tf.add(tf.matmul(input_layer_2d, weight), bias)
        # Get rid of extra dimensions
        # 去掉多余的维度只保留数据
        full_output_1d = tf.squeeze(full_output)
        return (full_output_1d)
    
    
    my_full_output = fully_connected(my_maxpool_output, 5)
    
    # Run graph
    # Initialize Variables
    init = tf.global_variables_initializer()
    sess.run(init)
    
    feed_dict = {x_input_1d: data_1d}
    
    print('>>>> 1D Data <<<<')
    
    # Convolution Output
    print('Input = array of length %d'%(x_input_1d.shape.as_list()[0]))  # 25
    print('Convolution w/ filter, length = %d, stride size = %d, results in an array of length %d:'%
          (conv_size, stride_size, my_convolution_output.shape.as_list()[0]))  # 21
    print(sess.run(my_convolution_output, feed_dict=feed_dict))
    
    # Activation Output
    print('\nInput = above array of length %d'%(my_convolution_output.shape.as_list()[0]))  # 21
    print('ReLU element wise returns an array of length %d:'%(my_activation_output.shape.as_list()[0]))  # 21
    print(sess.run(my_activation_output, feed_dict=feed_dict))
    
    # Max Pool Output
    print('\nInput = above array of length %d'%(my_activation_output.shape.as_list()[0]))  # 21
    print('MaxPool, window length = %d, stride size = %d, results in the array of length %d'%
          (maxpool_size, stride_size, my_maxpool_output.shape.as_list()[0]))  # 17
    print(sess.run(my_maxpool_output, feed_dict=feed_dict))
    
    # Fully Connected Output
    print('\nInput = above array of length %d'%(my_maxpool_output.shape.as_list()[0]))  # 17
    print('Fully connected layer on all 4 rows with %d outputs:'%
          (my_full_output.shape.as_list()[0]))  # 5
    print(sess.run(my_full_output, feed_dict=feed_dict))
    
    # >>>> 1D Data <<<<
    # Input = array of length 25
    # Convolution w/ filter, length = 5, stride size = 1, results in an array of length 21:
    # [-2.63576341 -1.11550486 -0.95571411 -1.69670296 -0.35699379  0.62266493
    #   4.43316031  2.01364899  1.33044648 -2.30629659 -0.82916248 -2.63594174
    #   0.76669347 -2.46465087 -2.2855041   1.49780679  1.6960566   1.48557389
    #  -2.79799461  1.18149185  1.42146575]
    #
    # Input = above array of length 21
    # ReLU element wise returns an array of length 21:
    # [ 0.          0.          0.          0.          0.          0.62266493
    #   4.43316031  2.01364899  1.33044648  0.          0.          0.
    #   0.76669347  0.          0.          1.49780679  1.6960566   1.48557389
    #   0.          1.18149185  1.42146575]
    #
    # Input = above array of length 21
    # MaxPool, window length = 5, stride size = 1, results in the array of length 17
    # [ 0.          0.62266493  4.43316031  4.43316031  4.43316031  4.43316031
    #   4.43316031  2.01364899  1.33044648  0.76669347  0.76669347  1.49780679
    #   1.6960566   1.6960566   1.6960566   1.6960566   1.6960566 ]
    #
    # Input = above array of length 17
    # Fully connected layer on all 4 rows with 5 outputs:
    # [ 1.71536088 -0.72340977 -1.22485089 -2.5412786  -0.16338299]
    

    参考文献
    TensorFlow机器学习实战指南

    展开全文
  • 一维CNN+MLP

    千次阅读 2018-08-09 18:23:50
    利用Sequential模型构造个二层CNN+MLP的多分类任务。任务描述,有个有向网络,现在需要对网络中的节点进行分类。这里节点的类别就是节点本身,对同个节点进行次随机游走得到不同的随机游走序列表示。通过...
  • 用卷积滤波器matlab代码深眼运动(EM)分类器:一维CNN-BLSTM模型 这是“ 1D CNN和BLSTM对注视,扫视和平滑追踪的自动分类”一文中对眼睛运动分类的深度学习方法的实现。 如果您使用此代码,请引用为 @Article{...
  • CNN-文本分类-keras 它是中作为功​​能api的简化实现 要求 训练 运行以下命令,如果要更改它将运行100个纪元,只需打开 python model.py 对于新数据 您必须重建词汇表然后进行培训。 引文 @misc{bhaveshoswal,...
  • 行业分类-物理装置-种基于改进三R-CNN算法的目标检测方法.zip
  • TensorFlow使用CNN实现中文文本分类

    万次阅读 多人点赞 2018-11-14 19:23:21
    读研期间使用过TensorFlow实现过简单的CNN情感分析(分类),当然这是比较low的二分类情况,后来进行多分类情况。但之前的学习基本上都是在英文词库上训练的。断断续续,想整理一下手头的项目资料,于是就拾起读研...
  • CNN

    万次阅读 多人点赞 2019-06-07 22:20:47
    CNN在图像分类数据集上有非常突出的表现。 DNN与CNN 下图为DNN: 下图为CNN: 虽然两张图的结构直观上差异较大,但实际上它们的整体架构是非常相似的。 CNN通过层的节点组织起来。 和DNN一样,CNN的每...
  • 卷积神经网络CNN一维信号输入

    万次阅读 多人点赞 2018-08-30 11:22:25
    时光荏苒,转眼间已经过去两个月了,这段日子大概是我研究生生涯中最忙碌的段时光,从个python小白,深度学习小白,到现在感觉自己总算摸到了深度学习的门槛,心中还是有一些欣慰和感慨,可能对于很多人来说,我...
  • 这个CNN工具箱只用改两个地方就可以对自己的数据集分类了 比github上的deeplearning的工具箱里的CNN改动要简单
  • pytorch一维线性回归程序pytorch一维线性回归程序pytorch一维线性回归程序
  • 基于二维CNN的西褚大学轴承故障诊断

    千次阅读 多人点赞 2019-10-30 15:20:47
    最近用二维CNN做了个西储大学轴承故障诊断Demo级别的例子。 数据集选用了48K驱动端故障的数据,分为10种类型的故障,每种类型的故障一共有240000左右的采样点,以4096个点为个样本,转变成6464的矩阵,进而转变...
  • cnn实现一维震动信号故障诊断

    千次阅读 2020-03-15 11:25:32
    cnn实现一维震动信号故障诊断 import os os.environ[‘TF_CPP_MIN_LOG_LEVEL’] = ‘2’ import numpy as np import scipy.io as sio import tensorflow.compat.v1 as tf tf.disable_v2_behavior() import xlrd from...
  • CNN进行分类

    万次阅读 多人点赞 2018-07-04 21:40:16
    本文讲解计算机如何处理图像进行分类的,这里我们以CNN(卷积神经网络)对汪汪图片进行分类为例!1:问题空间 图像分类是对输入图像的操作,最终输出组最好地描述了图像内容的分类(如猫、狗等)或分类的概率。对...
  • 本文将2D-CNN与1D-CNN融合,同时对轴承数据集进行训练,然后在汇聚层将两者池化层的输出连接成个向量,送进全连接层。模型训练结束之后,取FC层的输出作为提取到的故障特征信号。数据来源,西储大学滚动轴承故障...
  • Kim的CharCNN最初是经过端到端训练的语言建模管道的部分,但已被改编为文本分类。 用法 安装依赖项(Tensorflow 1.3和Keras 2.1.3): $ pip install -r requirements.txt 在config.json文件中指定训练和测试...
  • CNN一般用来做图像数据处理,比较少见用于做普通数据预估。写了3个例子分享给大家参考参考。环境python37
  • 使用LSTM +CNN对EGG 进行分类预测,一维CNN提取数字信息特征,LSTM 进行分类预测
  • TensorFlow2 学习——CNN图像分类

    千次阅读 2020-03-11 13:10:31
    文章目录TensorFlow2 学习——CNN图像分类1. 导包2. 图像分类 fashion_mnist3. 图像分类 cat_vs_dog3.1 原始数据3.2 利用Dataset加载图片3.3 构建CNN模型,并训练 TensorFlow2 学习——CNN图像分类 1. 导包 import ...
  • CNN文本分类原理讲解与实战

    万次阅读 多人点赞 2018-12-22 10:33:35
    本文先介绍了CNN,然后分析了CNN为什么能用在NLP中,最后讲解了Yoon Kim (2014)提出的CNN文本分类模型,代码见github。 什么是卷积 简单介绍一下卷积运算,卷积运算作用就是用滤波器来学习或者检测图片的特征。 ...
  • 前面两篇文章介绍的是卷积神经网络处理二维数据,那么对于应用更一维时间序列数据,该如何用卷积神经网络来处理呢?概述许多文章都关注于二维卷积神经网络(2D CNN)的使用,特别是图像识别...
  • 算是个简单的deep-learning框架。从加载数据集开始,包括了模型设计、训练、测试等过程。 . 加载数据 二. 模型设计 三. 训练 四. 测试
  • Matlab实现CNN

    千次阅读 2019-05-10 19:43:35
    卷积神经网络CNN是深度学习的个重要组成部分,由于其优异的学习性能(尤其是对图片的识别)。近年来研究异常火爆,出现了很模型LeNet、Alex net、ZF net等等。由于大多高校在校生使用matlab比较,而网上的教程...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 34,364
精华内容 13,745
关键字:

一维cnn多分类