keras编程学习

Keras 是一个用 Python 编写的高级神经网络 API，它能够以 TensorFlow, CNTK, 或者 Theano 作为后端运行。

1.模型构造

Keras 的核心数据结构是 model，一种组织网络层的方式。最简单的模型是 Sequential 顺序模型，它由多个网络层线性堆叠。对于更复杂的结构，你应该使用 Keras 函数式 API，它允许构建任意的神经网络图。
Keras的模型构造十分简单，可以通过add来堆叠模型

from keras.models import Sequential
model = Sequential()
#可以通过add来堆叠模型
from keras.layers import Dense
model.add(Dense(units=64, activation='relu', input_dim=100))
model.add(Dense(units=10, activation='softmax'))

2.卷积层

深度学习中的卷积神经网络（Convolutional Neural Network，CNN）是一种广泛应用于图像、语音、文本等领域的神经网络模型。在CNN中，卷积层是最基本的层之一，用于提取输入数据的特征。在Keras中，Conv1D和Conv2D是两种常用的卷积层，其区别如下：
1.输入数据的维度
Conv1D和Conv2D的主要区别在于输入数据的维度不同。Conv1D用于处理一维的序列数据，例如时间序列数据或文本数据。而Conv2D用于处理二维的图像数据，例如灰度图像、彩色图像等。

2.卷积核的维度
卷积核是卷积层的核心组件，它负责对输入数据进行卷积操作，提取特征。在Conv1D中，卷积核是一维的，它的长度可以是任意值。在Conv2D中，卷积核是二维的，它的大小通常是一个正方形或矩形，例如3x3或5x5。

3.卷积操作的过程
卷积操作是卷积神经网络中最重要的操作之一。在Conv1D中，卷积操作在一个维度上进行，例如时间维度或文本中的词向量维度。在Conv2D中，卷积操作在两个维度上进行，例如图像的宽度和高度。

4.模型结构的设计
在设计模型结构时，需要根据数据的特点来选择合适的卷积层。对于一维序列数据，例如时间序列数据和文本数据，可以使用Conv1D来提取特征。而对于二维图像数据，可以使用Conv2D来提取特征。

5.应用场景的不同
Conv1D和Conv2D的应用场景不同。Conv1D主要应用于文本分类、情感分析、音频识别等领域。Conv2D主要应用于图像分类、目标检测、图像生成等领域。

综上所述，Conv1D和Conv2D在输入数据的维度、卷积核的维度、卷积操作的过程、模型结构的设计和应用场景等方面存在差异。在实际应用中，需要根据数据的特点来选择合适的卷积层，以提高模型的性能和效率。

2.1Conv1D

keras.layers.Conv1D(filters, kernel_size, strides=1, padding='valid', data_format='channels_last', dilation_rate=1, activation=None, use_bias=True, kernel_initializer='glorot_uniform', bias_initializer='zeros', kernel_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, bias_constraint=None)

1D 卷积层 (例如时序卷积)。
该层创建了一个卷积核，该卷积核以 单个空间（或时间）维上的层输入进行卷积， 以生成输出张量。 如果 use_bias 为 True， 则会创建一个偏置向量并将其添加到输出中。 最后，如果 activation 不是 None，它也会应用于输出。

当使用该层作为模型第一层时，需要提供 input_shape 参数（整数元组或 None），例如， (10, 128) 表示 10 个 128 维的向量组成的向量序列， (None, 128) 表示 128 维的向量组成的变长序列。

参数

• filters: 整数，输出空间的维度 （即卷积中滤波器的输出数量）。
• kernel_size: 一个整数，或者单个整数表示的元组或列表， 指明 1D 卷积窗口的长度。
• strides: 一个整数，或者单个整数表示的元组或列表， 指明卷积的步长。 指定任何 stride 值 != 1 与指定 dilation_rate 值 != 1 两者不兼容。
• padding: “valid”, “causal” 或 “same” 之一 (大小写敏感) “valid” 表示「不填充」。 “same” 表示填充输入以使输出具有与原始输入相同的长度。 “causal” 表示因果（膨胀）卷积， 例如，output[t] 不依赖于 input[t+1:]， 在模型不应违反时间顺序的时间数据建模时非常有用。
• data_format: 字符串, “channels_last” (默认) 或 “channels_first” 之一。输入的各个维度顺序。 “channels_last” 对应输入尺寸为 (batch, steps, channels) (Keras 中时序数据的默认格式) 而 “channels_first” 对应输入尺寸为 (batch, channels, steps)。
• dilation_rate: 一个整数，或者单个整数表示的元组或列表，指定用于膨胀卷积的膨胀率。 当前，指定任何 dilation_rate 值 != 1 与指定 stride 值 != 1 两者不兼容。
• activation: 要使用的激活函数。 如未指定，则不使用激活函数 (即线性激活： a(x) = x)。
• use_bias: 布尔值，该层是否使用偏置向量。
• kernel_initializer: kernel 权值矩阵的初始化器 。
• bias_initializer: 偏置向量的初始化器 。
• kernel_regularizer: 运用到 kernel 权值矩阵的正则化函数。
• bias_regularizer: 运用到偏置向量的正则化函数。
• activity_regularizer: 运用到层输出（它的激活值）的正则化函数 。
• kernel_constraint: 运用到 kernel 权值矩阵的约束函数。
• bias_constraint: 运用到偏置向量的约束函数。

3.Flatten

keras.layers.Flatten层的作用是将一个多维向量展开成为一维向量，可以理解为展开成一行向量，例若输入向量的大小为（None, 1, 10, 64）），则其展开后的向量大小为（None,640）。

#使用示例
>>> model = tf.keras.Sequential()
>>> model.add(tf.keras.layers.Conv2D(64, 3, 3, input_shape=(3, 32, 32)))
>>> model.output_shape
(None, 1, 10, 64)
 
 
>>> model.add(Flatten())
>>> model.output_shape
(None, 640)

4.全连接层

keras.layers.Dense层为全连接层，用以输出预测结果或预测概率。
Dense参数介绍

tf.keras.layers.Dense(
    units,
    activation=None,
    use_bias=True,
    kernel_initializer='glorot_uniform',
    bias_initializer='zeros',
    kernel_regularizer=None,
    bias_regularizer=None,
    activity_regularizer=None,
    kernel_constraint=None,
    bias_constraint=None,
    **kwargs
)

5.模型编译

model.compile()方法用于在配置训练方法时，告知训练时用的优化器、损失函数和准确率评测标准

model.compile(optimizer = 优化器，
 
                        loss = 损失函数，
 
                        metrics = ["准确率”])

6.模型训练

model.fit(x=x_train, y=y_train, epochs=500, shuffle=True, batch_size=2)

7.模型评估

model.evaluate 和 model.predict均是用来使用训练好的模型model来对预测数据进行测试，不同的是model.evaluate（）输入数据和标签，输出的是损失值和正确率；model.predict （）输入的是测试数据，输出的是测试结果(各标签的置信度，置信度最大的标签为该数据的标签)。

# model.predict和model.evaluate比较
 
loss,accuracy = model.evaluate(X_test,Y_test) 
 
y_pred = model.predict(X_test,batch_size = 1)

8.Keras卷积神经编程要点

数据预处理

import pandas as pd

from sklearn.preprocessing import StandardScaler

from sklearn.preprocessing import OneHotEncoder

加载数据

data = pd.read_csv('data.csv')

提取自变量和应变量

X = data.iloc[:, :-1].values

Y = data.iloc[:, -1].values

标准化处理

scaler = StandardScaler()

X = scaler.fit_transform(X)

OneHot编码

encoder = OneHotEncoder()

Y = encoder.fit_transform(Y.reshape(-1, 1)).toarray()

划分数据集

from sklearn.model_selection import train_test_split

X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.2, random_state=0)

建立卷积神经网络模型

from keras.models import Sequential

from keras.layers import Conv1D, MaxPooling1D, Flatten, Dense

model = Sequential()

添加卷积层

model.add(Conv1D(filters=64, kernel_size=3, activation='relu', input_shape=(3, 1)))

添加池化层

model.add(MaxPooling1D(pool_size=2))

添加全连接层

model.add(Flatten())

model.add(Dense(units=64, activation='relu'))

添加输出层

model.add(Dense(units=3, activation='softmax'))

编译模型

model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

训练模型

model.fit(X_train.reshape(-1, 3, 1), Y_train, batch_size=32, epochs=50, verbose=1)

评估模型

score = model.evaluate(X_test.reshape(-1, 3, 1), Y_test, verbose=0)

print('Test loss:', score[0])

print('Test accuracy:', score[1])

模型优化

调整神经网络的层数、神经元个数、激活函数等超参数

model = Sequential()

model.add(Conv1D(filters=64, kernel_size=3, activation='relu', input_shape=(3, 1)))

model.add(Conv1D(filters=64, kernel_size=3, activation='relu'))

model.add(MaxPooling1D(pool_size=2))

model.add(Flatten())

model.add(Dense(units=128, activation='relu'))

model.add(Dense(units=64, activation='relu'))

model.add(Dense(units=3, activation='softmax'))

调整优化器、学习率、批大小等训练参数

from keras.optimizers import Adam

model.compile(optimizer=Adam(lr=0.001), loss='categorical_crossentropy', metrics=['accuracy'])

model.fit(X_train.reshape(-1, 3, 1), Y_train, batch_size=64, epochs=100, verbose=1)

输入新的自变量，输出对应的应变量

import numpy as np

X_new = np.array([[3, 30, 5]])

X_new = scaler.transform(X_new)

Y_pred = model.predict(X_new.reshape(-1, 3, 1))

print(Y_pred)