精华内容
下载资源
问答
  • autoEncoder01 有两个一维CNN自动编码器示例,可以根据您的压缩需求在输入和输出中对其进行重新配置
  • 上文是二维CNN的C语言实现,我参考上文,照葫芦画瓢实现了一维CNN的前项传播,因嵌入式需求去掉了原文中的malloc函数,取而代之的是申请两个静态数组,input,output, input和output来回挪腾完成模型的前向运算,...

    本文参考github

    上文是二维CNN的C语言实现,我参考上文,照葫芦画瓢实现了一维CNN的前项传播,因嵌入式需求去掉了原文中的malloc函数,取而代之的是申请两个静态数组,input,output, input和output来回挪腾完成模型的前向运算,避免了动态的频繁申请和释放空间。静态数组的大小必须能容下前向运算过程中最大的shape的输入或输出。

    //卷积模块
    int conv(const double* weight, double* input, double* out, int input_size, int in_channels, int out_channels,
    	int kernel_size, int stride, int pad, int activation) 
    {
    	// data preprocess: padding and flatten
    
    	int out_size = (input_size + 2 * pad - kernel_size) / stride + 1;
    
    	int pad_size = input_size + 2 * pad;
    	
    	if (pad != 0) {
    		int index, channel, a = 0;
    		for (channel = 0; channel < in_channels; channel++) {
    			for (index = 0; index < pad_size; index++) {
    				a++;
    				out[channel*pad_size + index] = get_point(input, input_size, channel, pad, index);
    			}
    		}
    	}
    	else {
    		out = input;
    	}
    	memcpy(input, out, pad_size*out_channels * sizeof(double));
    	memset(out, 0, pad_size*out_channels * sizeof(double));
    	int index, in_channel, out_channel, kernel_index, out_index = 0;
    	for (out_channel = 0; out_channel < out_channels;out_channel++) {
    		for (out_index = 0; out_index < out_size; out_index++) {
    			for (in_channel = 0; in_channel < in_channels;in_channel++) {
    				for (kernel_index = 0; kernel_index < kernel_size; kernel_index++) {
    					out[out_channel*out_size + out_index] += weight[out_channel*in_channels*kernel_size + in_channel*kernel_size + kernel_index] * input[in_channel*pad_size + out_index + kernel_index];
    				}
    			}
    			if (activation == 1) {
    			// 激活函数可以自己写,我这里用的是relu
    				out[out_channel*out_size + out_index] = out[out_channel*out_size + out_index] > 0 ? out[out_channel*out_size + out_index] : 0;
    			}
    			else {
    				NULL;
    			}
    		}
    	}
    	memcpy(input, out, pad_size*out_channels * sizeof(double));
    	memset(out, 0, pad_size*out_channels * sizeof(double));
    	return 1;
    }
    // get_point 作用是协助完成pad
    double get_point(double* input, int input_size, int channel, int pad, int index) {
    	index -= pad;
    	if (index < 0 || index >= input_size) return 0;
    	return input[input_size*channel + index];
    }
    // 池化模块
    int maxpool(double* input, double* out, int in_size, int in_channels, int pool_size, int stride) {
    	int out_size, out_channels;
    	out_size = (in_size - pool_size) / stride + 1;
    	out_channels = in_channels;
    	
    	int index, out_channel, pool_index, out_index = 0;
    	
    
    	for (out_channel = 0; out_channel < out_channels; out_channel++) {
    		for (out_index = 0; out_index < out_size; out_index++) {
    			double max = 0.0;
    			for (pool_index = 0; pool_index < pool_size; pool_index++) {
    				index = stride * out_index + pool_index;
    				
    				if (input[out_channel*in_size + index] > max) {
    					max = input[out_channel*in_size + index];
    				}
    			}
    			out[out_channel*out_size + out_index] = max;
    		}
    	}
    	memcpy(input, out, out_size*out_channels * sizeof(double));
    	memset(out, 0, out_size*out_channels * sizeof(double));
    	return 1;
    }
    // 平均池化模块, 如果设置in_size和pool_size 一样,并且stride=1,平均池化就变成了全局平均池化
    int average_pool(double* input, double* out, int in_size, int in_channels, int pool_size, int stride) {
    	int out_size, out_channels;
    	out_size = (in_size - pool_size) / stride + 1;
    	out_channels = in_channels;
    	int index, out_channel, pool_index, out_index = 0;
    
    
    	for (out_channel = 0; out_channel < out_channels; out_channel++) {
    		for (out_index = 0; out_index < out_size; out_index++) {
    			double sum = 0.0;
    			int num = 0;
    			for (pool_index = 0; pool_index < pool_size; pool_index++) {
    				index = stride * out_index + pool_index;
    				sum += input[out_channel*in_size + index];
    				num++;
    			}
    			double mean = sum / num;
    			out[out_channel*out_size + out_index] = mean;
    		}
    	}
    	memcpy(input, out, out_size*out_channels * sizeof(double));
    	memset(out, 0, out_size*out_channels * sizeof(double));
    	return 1;
    }
    // 全连接模块
    int full_connection(const double* weight, double* input, double* out, int in_size, int out_size, int activation) {
    	//double* out = (double*)calloc(out_size, sizeof(double));
    	int index, out_index;
    
    	for (out_index = 0; out_index < out_size; out_index++) {
    		out[out_index] = 0.0;
    		for (index = 0; index < in_size; index++) {
    			out[out_index] = out[out_index] + input[index] * weight[out_index*in_size + index];
    			//printf("%f, %d\n", out[out_index], index);
    		}
    		//out[out_index] = out[out_index] > 0 ? out[out_index] : 0;
    	}
    	memcpy(input, out, out_size * sizeof(double));
    	memset(out, 0, out_size * sizeof(double));
    	return 1;
    }
    
    
    展开全文
  • 一维CNN+MLP

    千次阅读 2018-08-09 18:23:50
    利用Sequential模型构造个二层CNN+MLP的多分类任务。任务描述,有个有向网络,现在需要对网络中的节点进行分类。这里节点的类别就是节点本身,对同个节点进行多次随机游走得到不同的随机游走序列表示。通过...

    利用Sequential模型构造一个二层CNN+MLP的多分类任务。任务描述,有一个有向网络,现在需要对网络中的节点进行分类。这里节点的类别就是节点本身,对同一个节点进行多次随机游走得到不同的随机游走序列表示。通过构造的深度学习模型能正确分辨出属于同一节点的不同游走序列。

    1.数据加载+构建网络

    网络构建,读取一个邻接表文件构建有向图。

    class DiGraphs(object):
        def __init__(self, data_path):
            self.data_path = data_path
    
        def getDiGraph(self):
            di_graph = nx.DiGraph()
            temp_list = np.loadtxt(self.data_path)
            di_graph.add_edges_from(temp_list)
            return di_graph

    随即游走序列产生,给定一个网络和种子节点,设定好需要产生序列的长度,得到一个节点组成的有序序列。

    class NodeSequence(object):
        def __init__(self, graph_net, source_node, sequence_len):
            self.graph_net = graph_net
            self.source_node = source_node
            self.sequence_len = sequence_len
            self.node_sequence = []
    
        def getSequence(self):
            current_node = self.source_node
            for i in range(self.sequence_len):
                self.node_sequence.append(current_node)
                neibor_list = list(self.graph_net.neighbors(current_node))
                if 0 == len(neibor_list):
                    current_node = self.source_node
                else:
                    rand_num = np.random.random()
                    current_node = neibor_list[int(rand_num * len(neibor_list))]
            return np.array(self.node_sequence)

    构建神经网络模型双层CNN+MLP。

    import GraphNet
    from keras.models import Sequential
    from keras.layers import Dense, Activation, Convolution2D, Flatten, MaxPooling2D, Dropout
    from keras import optimizers
    import RandomWalk
    import numpy as np
    from keras.utils.np_utils import to_categorical
    
    path = r'data/email-Eu-core.txt'
    directed_graph = GraphNet.DiGraphs(path).getDiGraph()
    label_num = len(directed_graph.nodes())
    data = []
    label = []
    for i in range(label_num):
        for j in range(100):
            label.append(i)
            data.append(RandomWalk.NodeSequence(directed_graph, i, 50).getSequence())
    data = np.array(data).reshape(-1, 50)
    label = to_categorical(label, num_classes=label_num)
    data = data.reshape(-1, 50, 1, 1)
    # input_shape = Input(shape=(100, 20, 1))
    # filter = 10
    model = Sequential()
    model.add(Convolution2D(
        filters=256,
        kernel_size=(5, 1),
        input_shape=(50, 1, 1),
        border_mode='same',
    ))
    model.add(Dropout(0.1))
    model.add(Activation('relu'))
    model.add(MaxPooling2D(
        pool_size=(2, 1)
    ))
    model.add(Convolution2D(
        filters=256,
        kernel_size=(3, 1),
        border_mode='same',
    ))
    model.add(Dropout(0.1))
    
    model.add(Activation('tanh'))
    model.add(MaxPooling2D(
        pool_size=(2, 1)
    ))
    model.add(Flatten())
    model.add(Dense(label_num))
    model.add(Activation('softmax'))
    print(model.summary())
    sgd = optimizers.SGD(lr=0.03, decay=1e-6, momentum=0.9, nesterov=True)
    model.compile(loss='categorical_crossentropy', optimizer='sgd', metrics=['accuracy'])
    model.fit(data, label, epochs=200)

    注:这里在本次实验过程进行简单的总结。在搭建属于自己的CNN的时候出现了一下小小的“不愉快”,过程不是那么顺利,主要式源于自己的keras中一维CNN搭建的不熟悉以及其中相关参数的不理解。首先,一维CNN相关设置,filters这个参数表示有多少种卷积核,kernel_size表示的卷积核大小设置,input_shape表示的输入的形状。

    2.模型保存和加载

    将训练出来的模型进行保存

    with open('mode_jason50.json', 'w') as jason_file:
        jason_file.write(model.to_json())
    model.save_weights('model_weight50')

    注:这里保存模型的方式有两种。1.model.save()方法进行保存,这样式将模型的结构和参数都一起保存,加载的时候也是一起加载的;2.将模型结构和参数权重分开保存,这样做的好处是能够在加载模型之后对模型的每一层进行控制,控制每一层参数的权重是否更新。这里,选择的就是第二种保存方式

    加载模型

    from keras.models import model_from_json, load_model
    from keras.layers import Dense, Activation, Convolution2D, Flatten, MaxPooling2D, Input
    import dataProcing
    import RandomWalk
    import GraphNet
    import numpy as np
    from keras.utils.np_utils import to_categorical
    from keras import optimizers
    
    #
    # model = load_model('model/ClassifyBySelfModel200')
    jason_file = open('model/mode_jason50.json', 'r')
    load_model_jason = jason_file.read()
    jason_file.close()
    model = model_from_json(load_model_jason)
    model.load_weights('model/model_weight50')

    对加载的模型进行控制,控制加载模型的两层CNN中参数不进行新一轮训练中的参数更新,对原来的MLP层删除,加载新的MLP层进行新的分类

    model.pop()
    model.pop()
    print(model.summary())
    model.layers[0].trainable = False
    model.layers[4].trainable = False
    print(model.summary())
    model.add(Dense(18, name='classify'))
    model.add(Activation('softmax', name='softmax'))
    print(model.summary())
    
    path = r'data/email-Eu-core.txt'
    directed_graph = GraphNet.DiGraphs(path).getDiGraph()
    train_data = []
    train_label_R = []
    train_node, test_node, train_label, test_label = dataProcing.DataGeneration(
        'data/email-Eu-core-department-labels.txt').getTrainTestData()
    index = 0
    for i in train_node:
        for j in range(10):
            train_data.append(RandomWalk.NodeSequence(directed_graph, i, 50).getSequence())
            train_label_R.append(train_label[index])
        index += 1
    train_data = np.array(train_data).reshape(-1, 50)
    train_label_R = to_categorical(train_label_R, num_classes=18)
    train_data = train_data.reshape(-1, 50, 1, 1)
    sgd = optimizers.SGD(lr=0.03, decay=1e-6, momentum=0.9, nesterov=True)
    model.compile(loss='categorical_crossentropy', optimizer='sgd', metrics=['accuracy'])
    model.fit(train_data, train_label_R, epochs=200)
    index = 0
    test_data = []
    test_label_R = []
    for i in test_node:
        for j in range(1):
            test_data.append(RandomWalk.NodeSequence(directed_graph, i, 50).getSequence())
            test_label_R.append(test_label[index])
        index += 1
    test_data = np.array(test_data).reshape(-1, 50)
    test_label_R = to_categorical(test_label_R, num_classes=18)
    test_data = test_data.reshape(-1, 50, 1, 1)
    loss, accuracy = model.evaluate(test_data, test_label_R)
    print('test_loss:', loss)
    print('test_accuracy:', accuracy)
    with open('mode_jason_Fin50.json', 'w') as jason_file:
        jason_file.write(model.to_json())
    model.save_weights('model_weight_Fin50')
    # model.save('ClassifyBySelfModel200')
    f = open('result_Fin50.txt', 'w')
    f.write('test_loss:' + str(loss) + '\n')
    f.write('test_accuracy:' + str(accuracy) + '\n')
    f.close()

     

    展开全文
  • 第二天起来查看资料,还真有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)
    
    展开全文
  • 针对碳纤维复合材料(CFRP)的缺陷类型自动判别,提出一种超声一维卷积神经网络(U-1DCNN),结合贝叶斯优化方法进行超参数优选,通过自动提取超声A-Scan信号特征,实现分层、气孔、无缺陷三种类型自动区分。首先采集超声A-...
  • 最近在修改一篇论文,审稿人要求添加CNN的相关实验,由于本人没有使用过python,只能苦逼的进行matlab的CNN一维数据分类试验。CNN对于图像处理的代码很多,但对于一维数据分类的很少。可以说用MATLAB做这个仿真的...

    最近在修改一篇论文,审稿人要求添加CNN的相关实验,由于本人没有使用过python,只能苦逼的进行matlab的CNN一维数据分类试验。CNN对于图像处理的代码很多,但对于一维数据分类的很少。可以说用MATLAB做这个仿真的资源几乎没有。同时,也是因为以前几乎没有涉及CNN的仿真,这次也算是从同重新学一遍。终于皇天不负有心人,仿真成功了。

    本仿真的代码可以用于模式识别分类(一维数据的:故障诊断,基于传感器的人体行为识别和鸢尾花数据集分类等等)。废话不多说直接上代码:(MATLAB上一定要安装它的deep工具箱)

    %% By_nanj2021.1.14

    clear

    clc

    X=xlsread('xunliannew.xlsx');

    Xtrain1 = X(:,2:end);

    for i=1:1:3000

    for j=1:1:72

    Xtrain(1,j,1,i)=Xtrain1(i,j); % 输入数据维度转化

    end

    end

    ytrain=X(:,1);

    ytrain=categorical(ytrain); % 函数包要求标签类型是categorical

    layers = [ ...

    imageInputLayer([1 72 1])%%2D-CNN

    convolution2dLayer([1,6],4)

    reluLayer

    maxPooling2dLayer([1 6],'Stride',6)

    convolution2dLayer([1,6],4)

    reluLayer

    maxPooling2dLayer([1 6],'Stride',6)

    fullyConnectedLayer(6)

    softmaxLayer

    classificationLayer];

    options = trainingOptions('adam', ...

    'ExecutionEnvironment','cpu', ...

    'MaxEpochs',100,...

    'MiniBatchSize',27, ...

    'GradientThreshold',1, ...

    'Verbose',false, ...

    'Plots','training-progress');

    net = trainNetwork(Xtrain,ytrain,layers,options); % 网络训练

    XX=xlsread('ceshinew.xlsx');

    Xtest1=XX(:,2:end);

    for ii=1:1:1200

    for jj=1:1:72

    Xtest(1,jj,1,ii)=Xtest1(ii,jj); % 输入数据维度转化

    end

    end

    ytest1=XX(:,1);

    ytest=categorical(ytest1); %函数包要求标签类型是categorical

    YPred = classify(net,Xtest); %网络测试

    YPred1 =double(YPred); %转化为可显示的标签

    accuracy = sum(YPred == ytest)/numel(ytest)

    实验结果:

    accuracy =

    0.9733

    e2a603ed6c890409f1522f13aa26fd40.png

    需要数据的朋友可以联系:2458681194@qq.com

    展开全文
  • 我有个由不同长度的时间序列组成的数据集。例如,考虑一下这个ts1 = np.random.rand(230, 4)ts2 = np.random.rand(12309, 4)我有200个数组列表形式的序列^{pr2}$如果良好,这些时间序列的标签为1,否则为0。因此我...
  • cnn卷积神经手写数字识别Handwriting Recognition also termed as HTR(Handwritten Text Recognition) is a machine learning method that aims at giving the machines an ability to read human handwriting from ...
  • python深度学习--一维cnn处理序列

    千次阅读 2019-03-20 16:37:55
    要想结合卷积神经网络的速度与轻量以及RNN的顺序敏感性,一种方法是在RNN前面使用一维CNN作预处理。对于那些非常长,以至于RNN无法处理的序列(比如包含上千个时间步的序列),这种方法尤其有用。 ''' #卷积神经网络...
  • 技术文档主体内容:可以认为是页面最想表达的内容总和...屏:用户滑动屏幕至主体内容展现结束之前,在页面任意位置停留时看到的所有内容,称为屏。移动端适配:为了使PC页面能够在移动端正常展现的手段,保证用...
  • CNN卷积神经网络Matlab实现例程,使用了matlabR2019a自带的深度学习工具箱,一维数据分类,二维cnn
  • 一维CNN涵盖了一定范围,例如 用于自然语言处理(NLP)。 尽管我们可能会遇到其他机器学习问题,但很少有文章提供有关如何构造一维CNN的解释性演练。 本文试图弥补这一差距。何时应用一维CNN?CNN可以很好地识别数据...
  • 结合 CNN 和 RNN 来处理长序列一维CNN在处理顺序敏感问题的弊端一维卷积再处理序列文本的时候,它对时间序列的敏感度不是很强。因为这里通过上面的温度预测的模型来测试。 数据的准备参考前面的文章:深度学习笔记26_...
  • Just wondering whether anybody has done this? I have a dataset that is one dimensional (not sure whether it's the right word choice ... Unlike the usual CNN inputs which are images (so 2D), my da...
  • 一维卷积神经网络(1D-CNN一维卷积常用在序列模型、自然语言处理领域; 假设输入数据维度为8,filter维度为5; 不加padding时,输出维度为4,如果filter的数量为16,那么输出数据的shape就是; 二维卷积...
  • data / sentiment_analysis该目录包含用于构建一维CNN模型和测试解释方法的培训和测试数据 models:此目录包含用于情感分析和回答问题的预训练的1D-CNN模型。 tokenizers:此目录包含用于各种数据集的已保存的...
  • 一维CNN涵盖了一定范围,例如 用于自然语言处理(NLP)。 尽管我们可能会遇到其他机器学习问题,但很少有文章提供有关如何构造一维CNN的解释性演练。 本文试图弥补这一差距。何时应用一维CNN?CNN可以很好地识别...
  • 基于二维CNN的西褚大学轴承故障诊断

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

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

空空如也

空空如也

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

一维cnn