精华内容
下载资源
问答
  • 联合样本扩展和一维卷积神经网络进行肿瘤分类
  • 【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/1tZlpRVBjRoGe2jHTKwRm6A 
    提取码:bm94

    首先是数据的导入:

    # 载入数据
    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】一维卷积神经网络做回归

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

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

     

    展开全文
  • 在“卷积神经网络”中我们...其实,我们也可以将文本当作一维图像,从而可以用一维卷积神经网络来捕捉临近词之间的关联。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表现最佳
    • 正则项。相对于其他超参数来说,影响较小点
    展开全文
  • 利用二维卷积神经网络进行乳腺癌分类Submitted on 7 Jul 2020 (v1), last revised 29 Jul 2020 (this version, v2)回复 ts15获取论文及项目源码摘要乳腺癌是女性最常见的癌症。对有临床记录的癌症/非癌症患者的分类...

    8b1f3a89a332b72d4955a230f73d5bfd.png

    利用二维卷积神经网络进行乳腺癌分类

    Submitted on 7 Jul 2020 (v1), last revised 29 Jul 2020 (this version, v2)

    1c7a4529c98b45cfe30c6d5288827265.png

    回复 ts15获取论文及项目源码

    摘要

    乳腺癌是女性最常见的癌症。对有临床记录的癌症/非癌症患者的分类需要高的敏感性和特异性来进行可接受的诊断试验。然而,目前最先进的分类模型——卷积神经网络(CNN),却不能用于以一维格式表示的临床数据。CNN被设计用于处理一组二维矩阵,这些矩阵的元素与相邻元素有一定的相关性,比如图像数据。反之,除了时间序列数据以外,用一组一维向量表示的数据示例不能用于CNN,而可以用于其他分类模型,如人工神经网络或随机森林。我们提出了一些新的数据纠偏预处理方法,将一维数据矢量转换为CNN上待处理域之间具有适当相关性的二维图形图像。我们在威斯康星原始乳腺癌(WBC)和威斯康星诊断乳腺癌(WDBC)数据集上测试了我们的方法。据我们所知,这项工作在非时间序列数据的非图像到图像数据转换方面是新颖的。使用VGGnet-16与CNN处理的转换数据显示了WBC数据集的竞争性结果,并优于其他已知的WDBC数据集的方法。

    概述

    ML方法在医学应用领域广泛

    近年来,由于数字技术的进步和数据收集方法的改进,人们对医学数据集的机器学习(ML)模型的发展越来越感兴趣。越来越多的基于ML的系统被设计为慢性疾病的早期预警或诊断工具,例如诊断抑郁症、糖尿病和癌症[1]。乳腺癌可以说是女性最致命的癌症之一,全世界有数百万例报告病例,其中许多病例会致命[2,3]。乳腺癌是由乳腺或乳腺导管内壁的某些乳腺细胞(导管上皮细胞)异常生长引起的[4,5]。与健康细胞相比,这些细胞分裂更快,积累更快,形成肿块或团块。在这一阶段,细胞变为恶性,并可能通过乳腺扩散到淋巴结或身体的其他部位。

    CNN方法对二维数据处理较为有效

    CNN已经被证明对二维形式的数据最有效,比如图像和音频光谱图[33]。这是因为CNN的卷积技术要求数据样本至少有二维。相反,CNN也研究了特定于应用程序的一维数据。其中包括基因测序数据,如作为文本数据(词的序列)[34]处理的DNA序列,以及文本挖掘、词检测和自然语言处理(NLP)中的信号和序列[35,36]。

    2be45f2ea9588ed5424ad4a6d544d2e1.png

    CNN在时间序列分类(TSC)领域的研究背景

    更具体地说,用于时间序列分类(TSC)的CNN最近已经用一些新方法进行了探索,如多尺度CNN (MCNN)[25],以及在incep -v4架构上与AlexNet集成的CNN模型[37,38]。这些方法与最先进的集成方法(如Flat-COTE和hif - cote)一起,在分类器的准确性方面取得了显著的提高[39,40]。此外,原始时间序列数据也被用于一维CNN中,通过计算信号的面积进行卷积,具有更好的时间复杂度和可扩展性[41,42]。然而,很多数据仍然以一维的格式存在,如病历的临床数据,因此,CNN是否能够有效地训练这些数据进行分类,这是一个具有挑战性的研究问题。为了填补这一空白,本文提出了一种新的非时间序列一维数据到二维数据的转换方法,并用CNN对其进行处理。

    94b62272f45079965dd79ade141b9ed1.png

    图10所示,用CNN对非图像数据进行分类的完整过程

    总结

    本文的目的是将乳腺癌数据集WDBC和WBC的非图像数据(非时间序列形式)处理为CNN能输入的数据,因为它具有最先进的性能,并消除了在图像识别应用中手工特征提取的问题。CNN的使用主要局限于图像数据,除了一些特定领域的数据转换技术,如NLP和语音识别。我们提出了将非时间序列数据转换为图像数据的新方法。这个转换过程非常简单,效率不超过O(Nd^2)。分类准确率实验结果表明了这些方法的竞争力。进一步改进这些方法以取得更突出的结果也具有很大的潜力。例如,可以尝试不同形状、大小、颜色甚至排列的柱状图。类似地,距离矩阵可以增强,以获得更多的信息,如邻近元素的均值/方差。其他具有不同类型和不同方向的数值数据的应用在将非图像数据转换为图像数据后,如何响应CNN还有待观察。直观地说,数据上的信息越多,用组合方法观察到的结果就越好。最后,没有对1-D CNN进行任何复杂的数据变换的数值数据,其分类精度无法得到满意的结果。

    展开全文
  • 基于一维卷积神经网络对机械振动信号进行分类并加以预测 *使用一维卷积神经网络训练振动信号进行二分类 2020年7月16日,一学期没等到开学,然而又放假了。 总览CSDN中大多数卷积神经网络都是对二维图片进行分类的,...

    基于一维卷积神经网络对机械振动信号进行分类并加以预测

    *使用一维卷积神经网络训练振动信号进行二分类
    2020年7月16日,一学期没等到开学,然而又放假了。
    总览CSDN中大多数卷积神经网络都是对二维图片进行分类的,而图片也都是常见的猫狗分类,minst手写数字分类。一维卷积神经网络的使用非常少见,有也是IDMB情感分类,和鸢尾花分类的。
    作者研究生就读于河北一所双飞,全国排名270多,哈哈哈,不吹不黑。
    在网上翻来翻去找不到一篇可以利用的代码去研究我的机械故障诊断,后来在无奈下到某宝搜寻到一段代码,可以利用。这篇代码是改装鸢尾花分类的,直观性较强,对于本人天资愚钝的人来说入手方便。不多说直接上代码:

    import numpy as np
    import pandas as pd
    from sklearn.preprocessing import LabelEncoder
    from sklearn.preprocessing import StandardScaler
    from sklearn.model_selection import StratifiedShuffleSplit
    from keras.models import Sequential
    from keras.layers import Dense, Activation, Flatten, Convolution1D, Dropout,MaxPooling1D,BatchNormalization
    from keras.optimizers import SGD
    from keras.utils import np_utils
    from keras.models import load_model
    
    
    train = pd.read_csv('C:/Users/pc/Desktop/100train.csv')#导入训练集
    test = pd.read_csv('C:/Users/pc/Desktop/100test.csv')#导入测试集
    
    #这里是代码的精髓之处,编辑数据集中的标签,直接使用即可
    def encode(train, test):
        label_encoder = LabelEncoder().fit(train.species)
        labels = label_encoder.transform(train.species)
        classes = list(label_encoder.classes_)
    
        train = train.drop(['species', 'id'], axis=1)
        test = test.drop('id', axis=1)
    
        return train, labels, test, classes
    
    train, labels, test, classes = encode(train, test)
    
    scaled_train=train.values
    # SSS将每个数据集中的30%用作测试
    sss = StratifiedShuffleSplit(test_size=0.3, random_state=23)
    for train_index, valid_index in sss.split(scaled_train, labels):
        X_train, X_valid = scaled_train[train_index], scaled_train[valid_index]
        y_train, y_valid = labels[train_index], labels[valid_index]
        
    
    nb_features = 64    
    nb_class = len(classes)
    
    # reshape train data这里的128强调一点,64*2=128,如果数据量大,可以改变nb_feature的大小,同时在这里将128改成nb_feature的2倍,这里为什么这样,将在代码下面详细说明
    X_train_r = np.zeros((len(X_train), nb_features, 3))
    X_train_r[:, :, 0] = X_train[:, :nb_features]
    X_train_r[:, :, 1] = X_train[:, nb_features:128]
    X_train_r[:, :, 2] = X_train[:, 128:]
    print(X_train_r)
    # reshape validation data
    X_valid_r = np.zeros((len(X_valid), nb_features, 3))
    X_valid_r[:, :, 0] = X_valid[:, :nb_features]
    X_valid_r[:, :, 1] = X_valid[:, nb_features:128]
    X_valid_r[:, :, 2] = X_valid[:, 128:]
    
    model = Sequential()
    model.add(Convolution1D(nb_filter=16, filter_length=64,strides=1, input_shape=(nb_features, 3),padding='same'))
    model.add(Activation('tanh'))#在对振动信号,尤其是在对加速度计测得的振动信号时使用tanh是个不错的选择
    model.add(MaxPooling1D(2,strides=2,padding='same'))
    model.add(BatchNormalization(axis=-1, momentum=0.99, epsilon=0.001, center=True, scale=True, beta_initializer='zeros', gamma_initializer='ones', moving_mean_initializer='zeros', moving_variance_initializer='ones', beta_regularizer=None, gamma_regularizer=None, beta_constraint=None, gamma_constraint=None))
    model.add(Convolution1D(32,3,padding='same'))
    model.add(Activation('tanh'))
    model.add(MaxPooling1D(2,strides=2,padding='same'))
    model.add(BatchNormalization(axis=-1, momentum=0.99, epsilon=0.001, center=True, scale=True, beta_initializer='zeros', gamma_initializer='ones', moving_mean_initializer='zeros', moving_variance_initializer='ones', beta_regularizer=None, gamma_regularizer=None, beta_constraint=None, gamma_constraint=None))
    model.add(Flatten())
    model.add(Dropout(0.3))
    model.add(Dense(100, activation='tanh'))
    model.add(Dense(10, activation='tanh'))
    model.add(Dense(nb_class))
    model.add(Activation('softmax'))
    model.summary()
    
    y_train = np_utils.to_categorical(y_train, nb_class)#这里是将数据集中的标签做成独热码,直接黏贴就好了
    y_valid = np_utils.to_categorical(y_valid, nb_class)
    
    sgd = SGD(lr=0.01, nesterov=True, decay=1e-6, momentum=0.9)
    model.compile(loss='categorical_crossentropy',optimizer=sgd,metrics=['accuracy'])
    
    nb_epoch = 150
    
    model.fit(X_train_r, y_train, nb_epoch=nb_epoch, validation_data=(X_valid_r, y_valid), batch_size=32)
    
    model.save('fei100_model.h5')#将训练好的模型保存,不想保存的话可以在代码前加上#
    

    前十行没什么可说的,导入乱七八糟的函数,日常不管用不用的到瞎鸡导入,不会影响训练。
    这里说明为什么上面将长度为192的代码分成三个长度为64的在重整成一个三维矩阵加载进第一个卷积层:
    在鸢尾花分类的时候是有三大个明显特征的,这里用长、宽、高代替,因为原本是什么,本人记不清楚了,懒得去查,也不重要了。那么问题来了,这是在训练振动信号不用将192长的信号再分成三段了,于是本人将代码进行改变,将原本reshape部分删除,将第一个卷积层的输入改成1维,中间过程不堪入目,终于两天后我放弃了,总是维度有问题,就是无法将(175,192)的数据输入到(1,192)的卷积层中,然后又将(175,192)的信号曾了个维度还是不行,在此希望成功的小伙伴在下面评论一下,或者把代码发本人邮箱983401858@qq.com哈哈哈哈。
    关于振动信号采用激活函数tanh是因为,本人尝试了relu,和sigmod但发现,效果并没有tanh好,为什么不好,同样好在哪里,就不一一赘述了。

    下面,用训练好的模型去预测新收集到的振动信号,当然了,并没有真的做实验去获得新数据,是从原有数据中摘取出一部分。预测用的代码如下:

    import pandas as pd
    import numpy as np
    from sklearn.preprocessing import StandardScaler
    from keras.models import load_model,Sequential
    from keras.layers import Dense, Activation, Flatten, Convolution1D, Dropout,MaxPooling1D,BatchNormalization
    c = pd.read_csv('C:/Users/pc/Desktop/10000.csv')
    a=np.array(c)
    b=a.reshape(-1,64,3)
    model=Sequential()
    model = load_model("fei100_model.h5")
    predict=model.predict(b)
    

    呐,这就基本上完成了。
    本人简单的贴一下预测结果

        0              1
    0 0.99957   	0.000430316
    1 0.00109235	0.998908
    2 0.999585	    0.000414541
    3 0.0143072  	0.985693
    4 0.999522	    0.000478374
    5 0.999482   	0.000517729
    6 0.00236826	0.997632
    7 0.154483  	0.845517
    8 0.999583  	0.000417115
    9 0.999579  	0.000420685
    10 0.0249035	0.975097
    11 0.999566 	0.000434191
    12 0.00106062	0.998939
    13 0.999545 	0.000454852
    14 0.999595	    0.000404937
    15 0.63731	    0.36269
    16 0.00356141	0.996439
    17 0.00621646	0.993783
    18 0.999571 	0.000429145
    19 0.99954	    0.00045966
    
    

    其中0代表信号中的bad,1代表信号中的good
    数据在没测试前的标签如下图
    这是CSV表格
    选择的是2-21行,这样就是20个样本进行验证。可以看出预测的和原本的不太一致,预测过程中将第一行直接转移到了最后一行,奇奇怪怪令人不解,其中还有个预测的概率为0.6多。这样就在研究我的课题时变相的迈了一小步。

    细心的朋友可能早就发现,本人将代码里的归一化,标准化删除了,哈哈哈,卖个乖,本人的研究中发现了一种标准化方法,还在测试阶段,不一定理想。所以将数据直接用matlab归一化和标准化好了。图片中的数据使用的用每个值减去最小值除以最大值得来的。虽然做起来麻烦,但是这样做的好处倒也是有的,那就是在测试的程序中不用再添加训练时的归一化标准化程序。往往在训练的程序中进行归一化处理,再到预测程序中进行归一化,往往得到一些奇奇怪怪的预测结果。
    数据集的连接:
    https://pan.baidu.com/s/18rkiU9gROfSMQhZ5nDzEsg
    提取码sbun
    永久有效
    第一次写博客分享研究生一年来,做出的丁点成果。希望看过这篇帖子的同志在下面评论,共同学习,共同进步。我导师带研究生在3届,然而研三师兄半年没见到就毕业了。研二师兄做老师的另外一个课题。老师赴美学习被堵到了国外。这学上的稀里糊涂,难受的丫批。
    有问题评论区指出,共同讨论,本人虚心受教

    展开全文
  • 目的:针对传统机器学习算法对于流量分类的瓶颈问题,提出基于一维卷积神经网络模型的应用程序流量分类算法。 数据集:ICSX VPN-nonVPN 特征:数据预处理工具“USTC-TK2016, 本文选择同文献[12]相同的前784 Byte,...
  • 一维卷积神经网络在处理序列问题的作用在计算机视觉中我们经常使用卷积神经网络,由于其能够自动提取图像特征,并且可以高效的处理数据。对于序列处理问题,我们可以将序列看成一维空间,也就是我们前面说的数据维度...
  • 维卷积神经网络,可以用来做一维的数据分析,以家用电器的识别分类作为背景。使用excel画出的简单的图形如下,横坐标为用电器开启后的秒数,纵坐标为某一秒的有功功率,由上至下分别为空调(Air Conditioner),...
  • 【keras】一维卷积神经网络做回归

    千次阅读 多人点赞 2020-06-20 13:51:50
    【keras】一维卷积神经网络分类 在这篇博客当中我将利用一个稍加修改的数据集来完成线性回归任务。相比较以往的线性回归处理方式,我认为使用神经网络实现线性回归要简单和准确得多。 数据集大小仍然是247*900,...
  • 结果应该是这样对应1.1-1.3OK,cut the crap.、计算机视觉(Computer Vision,CV)概述,1.1LeNet、AlexNet到...在课程开始时,从吴老师的精神头能看出,卷积神经网络学起来肯定很过瘾.Andrew Ng计算机视觉图像分类的...
  • 点击上方“AI与计算机视觉”,选择加"星标"或...对于文本分类和时间序列预测等简单任务,小型的一维卷积神经网络可以代替RNN,而且速度更快。这种一维卷积层可以识别序列中的局部模式。因为对每个序列段执行相同的...
  • 2019-2020历经一年时间做的关于声学垃圾分类的研究: 背景 随着人口、城市化和经济的快速增长,城市固体垃圾的数量急剧增加。据统计,全世界每5分钟将产生20000吨... (图片来源于网络) 在我国,垃圾分类已...
  • @[人工小将(基于2维卷积神经网络的心电图分类)] 基于2维卷积神经网络的心电图分类 在这里给大家分享篇关于用深度学习进行心电图识别的论文,原文地址https://arxiv.org/abs/1804.06812,我是转载的由人工小将翻译...
  • 相比较以往的线性回归处理方式,我认为使用神经网络实现线性回归要简单和准确得多。数据集大小仍然是247*900,不同的是数据集的第247位变成了湿度特征的真实湿度值。不同于分类算法得到的决策面,回归算法得...
  • 为了进一步提高点云图像船舶分类方法的分类准确率,提出了种基于三维卷积神经网络(3D CNN)的点云图像船舶分类方法。首先采用密度网格方法将点云图像转为体素网格图像,将体素网格图像作为3D CNN的输入对象;接着通过...
  • 针对传统计算机辅助检测系统中肺结节检测存在大量假阳性的问题,提出种基于三维卷积神经网络的肺结节识别方法。首先,将传统二维卷积神经网络扩展为三维卷积神经网络,充分挖掘肺结节的三维特征,增强特征的表达能力;...
  • 本节将利用TensorFlow框架实现卷积神经网络邮件分类。1, 怎样给文字编码?这是我们遇到的第个问题,它不像图像那样H*W*C 在经过一定的reshape就可以了,文字的编码比较复杂一点。需要经过个embedding layer,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 407
精华内容 162
关键字:

一维卷积神经网络分类