近日，老板突发奇想想让我用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)

刚刚接触到深度学习，前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】一维卷积神经网络做回归
 
比起其他科普的博客，我这篇文章更像是在学习如何利用工具做深度学习。
 
希望大家多多支持，不足之处互相交流(●ˇ∀ˇ●)！
 
 

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）、文档分类和拼写校正。
 '''
 
 
 
 
 
 

使用一维数据构造简单卷积神经网络
 
觉得有用的话,欢迎一起讨论相互学习~
 
 
神经网络对于一维数据非常重要，时序数据集、信号处理数据集和一些文本嵌入数据集都是一维数据，会频繁的使用到神经网络。我们在此利用一组一维数据构造卷积层-最大池化层-全连接层的卷积神经网络。希望给大家使用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机器学习实战指南