最近在修改一篇论文，审稿人要求添加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
需要数据的朋友可以联系：2458681194@qq.com

利用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后能够被很好的分类或者分割开来，现在我们以一维信号为例，探索卷积和非线性是如何把不同灰度和尺寸的物体分离开来。
以下信号包括一个长度为15和一个长度为5的有效信号，
现在我们设计一个由卷积和非线性构成的滤波器把这两个信号分离开来
其中，边缘提取和两个扩散卷积的卷积核如下所示
这样，CNN就很好的分离出了长度为5的信号。原信号与分离信号做减法（shortcut connection？）就不再有长度为5的信号了，事实上，cnn总是优先提取长度更短的信号。
另外这里面最重要的一点，卷积能让一个信号往周围扩散（因为卷积核有大小），并在扩散的过程中控制其大小 （结合非线性函数和bias）。而当两个响应扩散到一起时，便能够产生一个更大响应（只有一个卷积模板里面出现两个以上的极大响应，才有可能聚合成更大的响应），这时选择合适的阈值，就能提取这个更大响应。如果一个信号由三个分离的极大响应描述（比如说人脸的边缘响应同时也包含了五官的极大响应），我们也完全可以使得最先聚合的极大信号不通过阈值（阈值这个参数是加权和非线性学习出来的），这样三个极大响应会变成两个极大响应，然后会随着扩散的进行变成一个极大响应，这一个极大响应也就描述了这个信号，而这个扩散的过程也能很好被记忆住，这个扩散中产生的各种极大响应描述了整体与部分之间的关系，并且这个方法是鲁棒的，允许信号极大响应之间的间隔有一个合理范围。又因为卷积是可逆的，所以任何一个被逆转回去，从原信号里减去，减少干扰，这个机制非常类似于跨层连接，另外，相减的操作也可以用1x1卷积或者常数卷积实现，因为它们可以让原信号通过。
灰度更好分离，灰度代表着信号强度，直接使用阈值函数就能分离出来，如果两个信号只有强度区别，用阈值函数作用其上，就能直接把两个信号分离开。
为了更好的说明这个问题，设计一个一维信号的分类网络
这里用一组滤波器模拟了卷积神经网络的一个通道，实际上cnn里面有很多通道，分别用来记住不同的灰度分布和形状分布。并且这里滤波器都是手工设计的，但是cnn里面都是学出来的，另外，用不用阈值函数的阈值本身也是可以学出来的，因为cnn里的卷积都会加权相加，只要学一个很大的权值，就能让阈值函数产生不同的响应，也是可以学习的，这里的信号分布也是非常精确的。
但是，我们知道，cnn能够处理的信号分布也是有界的，两个能被完美区别的物体不是纹理就是形状，二者之一一定区分度非常大。
另外，设计这个滤波器组的作用，也是为了论证卷积的重要作用只有两个，边缘响应极大值化，聚合远距离的两个或者多个极大响应为更大响应（使用和物体形状相近分布的卷积，只有和滤波器形状最相近的pattern才有可能在滤波器中心产生极大响应），这些在cnn可视化里面都有例证。另外，响应扩散也可以用小卷积核慢慢扩散（这个还会继续讨论）。。。
这里再详细解释一样，以人脸为例（假设已经完全得到了边缘响应）。卷积能把来自不同方向的边缘响应聚合起来，如果每层特征值都有界，那如果有人脸的边缘响应，卷积核只要和人脸的边缘分布一模一样，这样非零的部分全部对齐，这个时候卷积中心的响应是非常大的，然后过一个阈值函数，就只剩这样一个响应了（但这样做必定泛化性能不好，模板偏离几个像素可能响应就有很大的变化，所以一般使用小卷积核叠加）
未完待续。。。
我在另一篇文章里面试图说明cnn的本质是泛函拟合，事实上它只是其中一种泛函拟合。这篇文章我想说的是cnn的本质是可以适应数据的级联滤波器。

这篇文章通用性不强，没有解释cnn的通用性，请辩证的阅读本文
长久以来，卷积神经网络在语音图像信号的处理中取得了巨大的作用。大多数使用过卷积神经网络的人都知道，卷积神经网络能很好的建模很多物体，一些无法用常用分布描述的物体经过cnn后能够被很好的分类或者分割开来，现在我们以一维信号为例，探索卷积和非线性是如何把不同灰度和尺寸的物体分离开来。
以下信号包括一个长度为15和一个长度为5的有效信号，
现在我们设计一个由卷积和非线性构成的滤波器把这两个信号分离开来
其中，边缘提取和两个扩散卷积的卷积核如下所示
这样，CNN就很好的分离出了长度为5的信号。原信号与分离信号做减法（shortcut connection？）就不再有长度为5的信号了，事实上，cnn总是优先提取长度更短的信号。
另外这里面最重要的一点，卷积能让一个信号往周围扩散（因为卷积核有大小），并在扩散的过程中控制其大小 （结合非线性函数和bias）。而当两个响应扩散到一起时，便能够产生一个更大响应（只有一个卷积模板里面出现两个以上的极大响应，才有可能聚合成更大的响应），这时选择合适的阈值，就能提取这个更大响应。如果一个信号由三个分离的极大响应描述（比如说人脸的边缘响应同时也包含了五官的极大响应），我们也完全可以使得最先聚合的极大信号不通过阈值（阈值这个参数是加权和非线性学习出来的），这样三个极大响应会变成两个极大响应，然后会随着扩散的进行变成一个极大响应，这一个极大响应也就描述了这个信号，而这个扩散的过程也能很好被记忆住，这个扩散中产生的各种极大响应描述了整体与部分之间的关系，并且这个方法是鲁棒的，允许信号极大响应之间的间隔有一个合理范围。又因为卷积是可逆的，所以任何一个被逆转回去，从原信号里减去，减少干扰，这个机制非常类似于跨层连接，另外，相减的操作也可以用1x1卷积或者常数卷积实现，因为它们可以让原信号通过。
灰度更好分离，灰度代表着信号强度，直接使用阈值函数就能分离出来，如果两个信号只有强度区别，用阈值函数作用其上，就能直接把两个信号分离开。
为了更好的说明这个问题，设计一个一维信号的分类网络
这里用一组滤波器模拟了卷积神经网络的一个通道，实际上cnn里面有很多通道，分别用来记住不同的灰度分布和形状分布。并且这里滤波器都是手工设计的，但是cnn里面都是学出来的，另外，用不用阈值函数的阈值本身也是可以学出来的，因为cnn里的卷积都会加权相加，只要学一个很大的权值，就能让阈值函数产生不同的响应，也是可以学习的，这里的信号分布也是非常精确的。
但是，我们知道，cnn能够处理的信号分布也是有界的，两个能被完美区别的物体不是纹理就是形状，二者之一一定区分度非常大。
另外，设计这个滤波器组的作用，也是为了论证卷积的重要作用只有两个，边缘响应极大值化，聚合远距离的两个或者多个极大响应为更大响应（使用和物体形状相近分布的卷积，只有和滤波器形状最相近的pattern才有可能在滤波器中心产生极大响应），这些在cnn可视化里面都有例证。另外，响应扩散也可以用小卷积核慢慢扩散（这个还会继续讨论）。。。
这里再详细解释一样，以人脸为例（假设已经完全得到了边缘响应）。卷积能把来自不同方向的边缘响应聚合起来，如果每层特征值都有界，那如果有人脸的边缘响应，卷积核只要和人脸的边缘分布一模一样，这样非零的部分全部对齐，这个时候卷积中心的响应是非常大的，然后过一个阈值函数，就只剩这样一个响应了（但这样做必定泛化性能不好，模板偏离几个像素可能响应就有很大的变化，所以一般使用小卷积核叠加）
未完待续。。。
我在另一篇文章里面试图说明cnn的本质是泛函拟合，事实上它只是其中一种泛函拟合。这篇文章我想说的是cnn的本质是可以适应数据的级联滤波器。