keras学习笔记

keras

实例

一、Regressor 回归

import numpy as np

# seed()用于指定随机数生成时所用算法开始时的整数值（*）
np.random.seed(1337)
from keras.models import Sequential
from keras.layers import Dense
import matplotlib.pyplot as plt


# np.linspace(start, stop, num) 在指定的间隔内返回均匀间隔的数字
X = np.linspace(-1, 1, 200)

# np.random.shuffle(X)是对列表X中的所有元素随机打乱顺序
np.random.shuffle(X)

# np.random.normal(loc, scale, size)
# loc: 分布的均值  scale: 分布的标准差  size: 输出值的维度,整数或者整数组成的元组
Y = 0.5 * X + 2 + np.random.normal(0, 0.05, 200)

# plt.scatter()绘制散点图, x和y是散点的坐标
plt.scatter(X, Y)
plt.show()

X_train, Y_train = X[:160], Y[:160]
X_test, Y_test = X[160:], Y[160:]

# Sequential序贯模型，线性模型
# 通过add()方法将各层添加到模型中
model = Sequential()
# 全连接层(2D层): Dense, units=输出尺寸, input_dim=输入尺寸
model.add(Dense(units=1, input_dim=1))

# 对网络的学习过程进行配置
model.compile(loss='mse', optimizer='sgd')

print("Training ----------")
for step in range(301):
    
    # model.train_on_batch()在训练集数据的一批数据上进行训练, 返回值为标量训练损失
    cost = model.train_on_batch(X_train, Y_train)
    if step % 100 == 0:
        print('train cost: ', cost)

print("Test -----------")

# model.evaluate()在测试模型下返回模型的误差值, batch_size: 评估的样本数
cost = model.evaluate(X_test, Y_test, batch_size=40)
print("test cost: ", cost)

# model.layers[]: 查看第几层
# layers[0]为之前定义的Dence()层,生成的数据有weight和biases两个
# layer.get_weights(): 返回该层权重
W, b = model.layers[0].get_weights()
print("Weights=", W, 'nbiases=', b)

# model_predicr(): 为输入样本生成输出预测
Y_pred = model.predict(X_test)
plt.scatter(X_test, Y_test)

# 绘制折线图
plt.plot(X_test, Y_pred)
plt.show()

二、Classifier 分类

import numpy as np

# seed()用于指定随机数生成时所用算法开始时的整数值（*）
np.random.seed(1337)
from keras.datasets import mnist
from keras.utils import np_utils
from keras.models import Sequential
from keras.layers import Dense, Activation

# 务必使用tensorflow.keras.optimizers, 否则会报错
from tensorflow.keras.optimizers import RMSprop
# from keras.optimizers import RMSprop

# 下载mnist数据集并处理下载下来的四个文件
(X_train, y_train), (X_test, y_test) = mnist.load_data()

# 进行特征标准化, 为了方便各指标之间的可比性
# arr = reshape(m,-1) 即改变arr维度为m行d列, -1表示列数自动计算(d = a * b / m)(arr.shape ==> (a ,b))
X_train = X_train.reshape(X_train.shape[0], -1) / 255
X_test = X_test.reshape(X_test.shape[0], -1) / 255

# np_utils.to_categorical() 在多分类问题中将类别变量的输出标签转化为数值变量
y_train = np_utils.to_categorical(y_train, num_classes=10)
y_test = np_utils.to_categorical(y_test, num_classes=10)


# Sequential() 序贯模型 线性模型, 可以通过将层的列表传给Sequential的构造函数来创建一个Sequential模型
# Dense(输出尺寸, 输入尺寸) 第一个全连接层有输入尺寸, 后面的全连接层不用输入尺寸
# Activation 激活函数, 对输入进行非线性变换, 使其能够学习和执行更复杂的任务
model = Sequential([
    Dense(32, input_dim=784),
    Activation('relu'),
    Dense(10),
    Activation('softmax')
])

# 使用RMSprop优化器来更新数据
# ls: 学习率  rho: RMSprop梯度平方的移动均值衰减率  epsilon: 模糊因子  decay: 每次参数更新后学习率的衰减值
rmsprop = RMSprop(lr=0.001, rho=0.9, epsilon=1e-08, decay=0.0)

# model.compile(): 对网络的学习过程进行配置
# optimizer: 优化器(可以是自己定义的, 也可以是默认的优化器)  loss: 损失函数  metrics: 在训练和测试期间的模型评估标准, 可为多输出模型的不同输出指定不同的评估标准
model.compile(
    optimizer=rmsprop,
    loss='categorical_crossentropy',
    metrics=['accuracy']
)

print("nTraining--------")

# model.fit(): 以给定数量的轮次训练模型
# X_train: 训练数据的数组  y_train: 目标数据的数组  epochs: 训练模型迭代轮次, 一个轮次是在整个X_train和y_train上的一轮迭代  batch_size: 每次梯度更新的样本数, 若未指定默认32
model.fit(X_train, y_train, epochs=2, batch_size=32)

print("nTesting--------")

# model.evaluate(): 在测试模型下返回模型的误差值和评估标准值
loss, accuracy = model.evaluate(X_test, y_test)

print("test loss: ", loss)
print("test accuracy: ", accuracy)

三、CNN卷积神经网络

import numpy as np

# seed()用于指定随机数生成时所用算法开始时的整数值(*)
np.random.seed(1337)
from keras.datasets import mnist
from keras.utils import np_utils
from keras.models import Sequential
from keras.layers import Dense, Activation, Convolution2D, MaxPooling2D, Flatten

# 务必使用tensorflow.keras.optimizers, 否则会报错
from tensorflow.keras.optimizers import Adam


# 下载mnist数据集并处理下载下来的四个文件
(X_train, y_train), (X_test, y_test) = mnist.load_data()


# reshape(sample的个数, chanel的个数, 长, 宽) (*)
X_train = X_train.reshape(-1, 1, 28, 28)
X_test = X_test.reshape(-1, 1, 28, 28)

# np_utils.to_categorical(): 在多分类问题中将类别变量的输出标签转换为数值变量
y_train = np_utils.to_categorical(y_train, num_classes=10)
y_test = np_utils.to_categorical(y_test, num_classes=10)


# Sequential(): 序贯模型 线性模型
# 通过add()方法将各层添加到模型中
model = Sequential()


# filters: 卷积核的数目(即输出的维度)  kernel_size: 卷积核的宽度和长度  padding: 补0策略, 为"valid", "same"; valid: 代表只进行有效的卷积,对边界数据不处理;same:代表保留边界处的卷积结果，通常会导致输出shape与输入shape相同  input_shape(颜色通道数, 长, 宽)
model.add(Convolution2D(		# 卷积层
    filters=32,     
    kernel_size=(5, 5),
    padding='same',
    input_shape=(1, 28, 28)
))
model.add(Activation('relu'))		# 激活函数


# pool_size: 池化核尺寸  stride: 池化窗口移动步长  padding: 填充(valid: 边缘不填充 same: 边缘0填充)
model.add(MaxPooling2D(		# 池化层
    pool_size=(2, 2),
    strides=(2, 2),
    padding='same',
))


# 64: feature  5:长  5:宽 
model.add(Convolution2D(64, 5, 5, padding='same'))		# 卷积层
model.add(Activation('relu'))		# 激活函数
model.add(MaxPooling2D(pool_size=(2, 2), padding='same'))		# 池化层


# Flatten(): 将多维的输入一维化, 常用在从卷积层到全连接层的过渡
model.add(Flatten())

# 1024: Dense层生成出的像素
model.add(Dense(1024))		# 全连接层
model.add(Activation('relu'))		# 激活函数

model.add(Dense(10))		# 全连接层

# softmax通常用于分类
model.add(Activation('softmax'))		# 激活函数


# Adam优化器 ls: 学习率
adam = Adam(lr=1e-4)

# model.compile(): 对网络的学习过程进行配置
# optimizer: 优化器  loss: 损失函数  metrics: 在训练和测试期间的模型评估标准, 可为多输出模型的不同输出指定不同的评估标准
model.compile(optimizer=adam,
              loss='categorical_crossentropy',
              metrics=['accuracy'])

print("Training----------")

# model.fit(): 以给定数量的轮次训练模型
# X_train: 训练数据的数组  y_train: 目标数据的数组  epochs: 训练模型迭代次数, 一个轮次是在整个X_train和y_train上的一轮迭代  batch_size: 每次梯度更新的样本数, 若未指定则默认32
model.fit(X_train, y_train, epochs=1, batch_size=32)

print("Testing----------")

# model.evaluate(): 在测试模型下返回模型的误差值和评估标准值
loss, accuracy = model.evaluate(X_test, y_test)

print("ntest loss: ", loss)
print("ntest accuracy: ", accuracy)

四、使用RNN循环神经网络进行分类

import numpy as np

# seed()用于指定随机数生成时所用算法开始时的整数值(*)
np.random.seed(1337)
from keras.datasets import mnist
from keras.utils import np_utils

# 序列化, 分别读取每行的像素, 再进行总结
from keras.models import Sequential
from keras.layers import SimpleRNN, Activation, Dense

# 务必使用tensorflow.keras.optimizers 否则会报错
from tensorflow.keras.optimizers import Adam

# 时间点, 读取多少行
TIME_STEPS = 28

# 每一行读取多少像素
INPUT_SIZE = 28

# 每一批训练多少图片
BATCH_SIZE = 50
BATCH_INDEX = 0
OUTPUT_SIZE = 10

# RNN中放多少hidden unit
CELL_SIZE = 50

# 学习率
LR = 0.0008


# 下载mnist数据集并处理下载下来的四个文件
(X_train, y_train), (X_test, y_test) = mnist.load_data()


# 进行特征标准化, 方便各特征之间的比较
# X_train.reshape(simple, time_steps, input_size)
X_train = X_train.reshape(-1, 28, 28) / 255
X_test = X_test.reshape(-1, 28, 28) / 255

# np_utils.to_categorical(): 在多分类问题中将类别变量的输出标签转化为数值变量
y_train = np_utils.to_categorical(y_train, num_classes=10)
y_test = np_utils.to_categorical(y_test, num_classes=10)


# Sequential() 序贯模型 线性模型
# 通过add()方法将各层添加到模型中
model = Sequential()

# batch_input_shape = (图片数, 时间点, input)  units: 输出给后面一层
model.add(SimpleRNN(
    batch_input_shape=(BATCH_SIZE, TIME_STEPS, INPUT_SIZE),
    units=CELL_SIZE
))

# 全连接层
model.add(Dense(OUTPUT_SIZE))

# 激励函数 SimpleRNN默认激励函数为tanh
model.add(Activation('softmax'))


# Adam优化器
adam = Adam(LR)

# model.compile(): 对网络的学习过程进行配置
# optimizer: 优化器  loss: 损失函数  metrics: 在训练和测试期间的模型评估标准, 可为多输出模型的不同输出指定不同的评估标准
model.compile(optimizer=adam,
              loss="categorical_crossentropy",
              metrics=['accuracy'])

for step in range(4001):
    
    # 一批一批截取
    X_batch = X_train[BATCH_INDEX: BATCH_SIZE + BATCH_INDEX, :, :]
    Y_batch = y_train[BATCH_INDEX: BATCH_SIZE + BATCH_INDEX, :]
    
    # model.train_on_batch(): 在训练集数据的一批数据上进行训练, 返回值为标量训练损失
    cost = model.train_on_batch(X_batch, Y_batch)

    
    # 累加
    BATCH_INDEX += BATCH_SIZE
    
    # 累加后大于总个数, 就循环上去从零开始
    BATCH_INDEX = 0 if BATCH_INDEX >= X_train.shape[0] else BATCH_INDEX

    if step % 500 == 0:
        
        # model.evaluate(): 在测试模式下返回模型的误差值和评估标准值
        # X_test: 测试数据数组  y_test: 目标数据数组  batch_size: 每次评估样本数, 若未指定默认32  verbose: 0或1, 日志显示模式, 0 = 安静模式, 1 = 进度条
        cost, accuracy = model.evaluate(X_test, y_test, batch_size=y_test.shape[0], verbose=False)
        print("test cost: ", cost, "test accuracy: ", accuracy)

五、使用循环神经网络RNN预测回归问题

import numpy as np

# seed()用于指定随机数生成时所用算法开始时的整数值(*)
np.random.seed(1337)
import matplotlib.pyplot as plt
from keras.models import Sequential
from keras.layers import LSTM, TimeDistributed, Dense
from tensorflow.keras.optimizers import Adam

BATCH_START = 0
TIME_STEPS = 20    # 一个batch取20步
BATCH_SIZE = 50	   # 一次训练所抓取的数据样本量
INPUT_SIZE = 1    # 一个时间点上有1个数据
OUTPUT_SIZE = 1     # 用input_size预测出的output_size也为1
CELL_SIZE = 20    # 隐藏层状态变量的维度
LR = 0.001    # 学习率

def get_batch():
    global BATCH_START, TIME_STEPS

    xs = np.arange(BATCH_START, BATCH_START + TIME_STEPS * BATCH_SIZE).reshape((BATCH_SIZE, TIME_STEPS)) / (10 * np.pi)
    seq = np.sin(xs)
    res = np.cos(xs)
    BATCH_START += TIME_STEPS
    return [seq[:, :, np.newaxis], res[:, :, np.newaxis], xs]



# Sequential(): 序贯模型 线性模型
# 通过add()方法将各层添加到模型中
model = Sequential()



# batch_input_size=(图片数, 时间点, input)    units=output_size
# return_sequences: 在输出序列中, 返回单个hidden state 的值还是返回全部 time step 的 hidden state的值, False返回单个, True返回全部, 默认False。(对于每个时间点都输出output, 或在最后一个时间点输出output)
# stateful: batch和batch是否有联系
model.add(LSTM(
    batch_input_size=(BATCH_SIZE, TIME_STEPS, INPUT_SIZE),
    units=CELL_SIZE,
    return_sequences=True,
    stateful=True,
))


# TimeDistributed(Dense()): 对每一个output都连到全连接层, 对每一个时间点进行全连接计算
model.add(TimeDistributed(Dense(OUTPUT_SIZE)))


# Adam优化器
adam = Adam(LR)

# model.compile(): 对网络的学习过程进行配置
# optimizer: 优化器  loss: 损失函数
model.compile(optimizer=adam,
              loss='mse')

print("Training----------")
for step in range(501):
    X_batch, Y_batch, xs = get_batch()
    
    # model.train_on_batch(): 在训练集数据的一批数据上进行训练, 返回值为标量损失值
    cost = model.train_on_batch(X_batch, Y_batch)
    
    # model.predict(): 为输入样本生成输出预测
    pred = model.predict(X_batch, BATCH_SIZE)
    plt.plot(xs[0, :], Y_batch[0].flatten(), 'r', xs[0, :], pred.flatten()[:TIME_STEPS], 'b--')
    
    # plt.ylim(): 设定y坐标轴的范围
    plt.ylim((-1.2, 1.2))
    plt.draw()
    plt.pause(0.5)
    if step % 10 == 0:
        print('train cost:  ', cost)

六、Autoencoder自编码(非监督学习)

import numpy as np

# seed(): 用于指定随机数生成时所用算法开始时的整数值(*)
np.random.seed(1337)
from keras.datasets import mnist
from keras.models import Model
from keras.layers import Dense, Input
import matplotlib.pyplot as plt


# 下载mnist数据集并处理下载下来的四个文件
(x_train, _), (x_test, y_test) = mnist.load_data()


# arr.astype(): 转换数组的数据类型
x_train = x_train.astype('float32') / 255. - 0.5
x_test = x_test.astype('float32') / 255. - 0.5

# 进行特征标准化, 方便各指标之间的可比性
# arr.reshape(m, -1): 即改变arr维度为m行d列, -1表示列数自动计算(d = a * b / m)(arr.shape ==> (a, b))
x_train = x_train.reshape((x_train.shape[0], -1))
x_test = x_test.reshape((x_test.shape[0], -1))
print(x_train.shape)
print(x_test.shape)


# 最终将784压缩到encoding_dim, 表示缩小的范围
encoding_dim = 2

input_img = Input(shape=(784,))


# 用4层全连接层进行压缩
# Dense(output_size, 激活函数)(输入)
encoded = Dense(128, activation='relu')(input_img)
encoded = Dense(64, activation='relu')(encoded)
encoded = Dense(10, activation='relu')(encoded)
encoder_output = Dense(encoding_dim)(encoded)


# 对应encoded进行解压
decoded = Dense(10, activation='relu')(encoder_output)
decoded = Dense(64, activation='relu')(decoded)
decoded = Dense(128, activation='relu')(decoded)

# input的值的范围在 -0.5 到 0.5, 使用tanh激活函数可使解压缩出来的值在 -1 到 1 的范围, 以达到对用的效果
decoded = Dense(784, activation='tanh')(decoded)

autoencoder = Model(inputs=input_img, outputs=decoded)


# 此处的encoder是autoencoder的压缩部分
encoder = Model(inputs=input_img, outputs=encoder_output)


# model.compile(): 用于配置训练模型
# optimizer: 优化器  loss: 损失函数
autoencoder.compile(optimizer='adam', loss='mse')


# model.fit(): 以给定数量的轮次训练模型
# epochs: 训练模型迭代轮次, 一个轮次是在整个x, y上的一轮迭代  batch_size: 每次梯度更新的样本数, 若未指定则默认32  shuffle: 是否在每次迭代之前混洗数据, 对每一个batch内部的数据进行混洗
autoencoder.fit(x_train, x_train,    # 对 x_train 压缩解压再对比 x_train, 故两处都为 x_train
                epochs=20,
                batch_size=256,
                shuffle=True)


# model.predict(): 为输入样本生成输出预测
encoded_img = encoder.predict(x_test)

# plt.scatter(): 绘制散点图
# c: 色彩或颜色序列
plt.scatter(encoded_img[:, 0], encoded_img[:, 1], c=y_test)
plt.show()

七、模型 的保存和提取

from keras.models import load_model
model.save('my_model.h5')
model.load_model('my_model.h5')

model.save_weights('my_model_weights.h5')
model.save_weights('my_model_weights.h5')

from keras.models import model_from_json
json_string = model.to_json()
model = model_from_json(json_string)

实例(回归模型(一))

import numpy as np
np.random.seed(1337)
from keras.models import Sequential
from keras.layers import Dense
from keras.models import load_model

X = np.linspace(-1, 1, 200)
np.random.shuffle(X)
Y = 0.5 * X + 2 + np.random.normal(0, 0.05, 200)

X_train, Y_train = X[:160], Y[:160]
X_test, Y_test = X[160:], Y[160:]

model = Sequential()
model.add(Dense(units=1, input_dim=1))

model.compile(loss='mse', optimizer='sgd')

for step in range(301):
    cost = model.train_on_batch(X_train, Y_train)

print('test before save: ', model.predict(X_test[0: 2]))
model.save('my_model.h5')
del model

model = load_model('my_model.h5')
print('test after load: ', model.predict(X_test[0: 2]))

八、在CIFAR10小型数据集上训练一个卷积神经网络

# from __future__ import print_function: 把下一个新版本的特性导入到当前版本
from __future__ import print_function
import keras
import tensorflow
from keras.datasets import cifar10
from keras.preprocessing.image import ImageDataGenerator
from keras.models import Sequential
from keras.layers import Dense, Dropout, Activation, Flatten
from keras.layers import Conv2D, MaxPooling2D
import os

batch_size = 32
num_classes = 10
epochs = 100

# data_augmentation: 数据增强
data_augmentation = True
num_predictions = 20

# os.path.join(): 连接路径名组件  os.getcwd(): 返回当前进程的工作目录
save_dir = os.path.join(os.getcwd(), 'saved_models')
model_name = 'keras_cifar10_trained_model.h5'

# 数据，切分为训练和测试集。
(x_train, y_train), (x_test, y_test) = cifar10.load_data()
print('x_train shape:', x_train.shape)
print(x_train.shape[0], 'train samples')
print(x_test.shape[0], 'test samples')

# 将类向量转换为二进制类矩阵。
# keras.utils.np_utils.to_categorical(): 在多分类问题中将类别变量的输出标签转化为数值变量
y_train = keras.utils.np_utils.to_categorical(y_train, num_classes)
y_test = keras.utils.np_utils.to_categorical(y_test, num_classes)


# Sequential(): 序贯模型 线性模型
# 通过add()方法将各层添加到模型中
model = Sequential()

# Conv2D(filter, kernel_size, padding, input_shape): 二维卷积层
# filter: 输出空间的维度  kernel_size: 卷积核尺寸, 2D卷积窗口的宽度和高度
# padding: 是否对边界进行填充, same(即使通过 kernel_size 缩小了维度但四周会填充0), valid(存储不为0的有效信息)  input_shape: 输入
model.add(Conv2D(32, (3, 3), padding='same',
                 input_shape=x_train.shape[1:]))
model.add(Activation('relu'))    # 激活函数
model.add(Conv2D(32, (3, 3)))    # 二维卷积层
model.add(Activation('relu'))    # 激活函数

# 池化层(在卷积神经网络中常常会在相邻的卷积层中加入池化层, 池化层可以有效缩小参数矩阵的尺寸, 从而减少参数数量, 所以加入池化层可以加快计算速度防止过拟合)
# pool_size: 指定池窗口的大小
model.add(MaxPooling2D(pool_size=(2, 2)))

# Dropout(): 正则化(在每轮权重更新时随机选择一定比例的节点抛弃, 有效防止过拟合)
model.add(Dropout(0.25))


# Conv2D(filter, kernel_size, padding, input_shape): 二维卷积层
# filter: 输出空间的维度  kernel_size: 卷积核尺寸, 2D卷积窗口的宽度和高度
# padding: 是否对边界进行填充, same(即使通过 kernel_size 缩小了维度但四周会填充0), valid(存储不为0的有效信息)
model.add(Conv2D(64, (3, 3), padding='same'))
model.add(Activation('relu'))    # 激活函数
model.add(Conv2D(64, (3, 3)))    # 二维卷积层
model.add(Activation('relu'))    # 激活函数

# 池化层(在卷积神经网络中常常会在相邻的卷积层中加入池化层, 池化层可以有效缩小参数矩阵的尺寸, 从而减少参数数量, 所以加入池化层可以加快计算速度防止过拟合)
model.add(MaxPooling2D(pool_size=(2, 2)))

# Dropout(): 正则化(在每轮权重更新时随机选择一定比例的节点抛弃, 有效防止过拟合)
model.add(Dropout(0.25))


# Flatten(): 用于将输入层的数据压成一维的数据
model.add(Flatten())

# 全连接层  Dense(output_size)
model.add(Dense(512))
model.add(Activation('relu'))    # 激活函数

# Dropout(): 正则化(在每轮权重更新时随机选择一定比例的节点抛弃, 有效防止过拟合)
model.add(Dropout(0.5))

# 全连接层  Dropout(output_size)
model.add(Dense(num_classes))
model.add(Activation('softmax'))    # 激活函数

# 初始化 RMSprop 优化器。
# 使用RMSprop优化器来更新数据
# learning_rate: 学习率  decay: 每次参数更新后学习率的衰减值
opt = tensorflow.keras.optimizers.RMSprop(learning_rate=0.0001, decay=1e-6)

# 利用 RMSprop 来训练模型。
# model.compile(): 对网络的学习过程进行配置
# loss: 损失函数  optimizer: 优化器  metrics: 在训练和测试期间的模型评估标准, 可为多输出模型的不同输出指定不同的评估标准
model.compile(loss='categorical_crossentropy',
              optimizer=opt,
              metrics=['accuracy'])


# arr.astype(): 转换数组的数据类型
x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
x_train /= 255
x_test /= 255

if not data_augmentation:
    print('Not using data augmentation.')
    
    # model.fit(): 以给定数量的轮次训练模型
    # x_train: 训练数据的数组  y_train: 目标数据的数组  batch_size: 每次梯度更新的样本数  epochs: 训练模型的迭代次数, 一个轮次是在整个x_train, y_train上的一轮迭代
    # validation_data: 用来评估损失, 以及在每轮结束时的任何模型度量指标, 模型将不会在这个数据上进行训练  shuffle: 是否在每轮迭代之前混洗数据, 对一个batch内部的数据进行混洗
    model.fit(x_train, y_train,
              batch_size=batch_size,
              epochs=epochs,
              validation_data=(x_test, y_test),
              shuffle=True)
else:
    print('Using real-time data augmentation.')
    
    # 这一步将进行数据处理和实时数据增益。data augmentation:
    # ImageDataGenerator()是keras.preprocessing.image模块中的图片生成器, 同时可以在 batch 中对数据进行增强, 扩充数据集大小, 增强模型的泛化能力 
    datagen = ImageDataGenerator(
        featurewise_center=False,  # 将整个数据集的均值设为0(对输入的图片每个通道减去每个通道对应均值)
        samplewise_center=False,  # 将每个样本的均值设为0(每张图片减去样本均值, 使得每个样本均值为0)
        featurewise_std_normalization=False,  # 将输入除以整个数据集的标准差
        samplewise_std_normalization=False,  # 将输入除以其标准差
        zca_whitening=False,  # 运用 ZCA 白化(去除样本之间的相关性)
        zca_epsilon=1e-06,  # ZCA 白化的 epsilon值(默认1e-6)
        rotation_range=0,  # 随机旋转图像范围 (角度, 0 to 180)
        # 随机水平移动图像 (总宽度的百分比)
        width_shift_range=0.1,
        # 随机垂直移动图像 (总高度的百分比)
        height_shift_range=0.1,
        shear_range=0.,  # 设置随机裁剪范围
        zoom_range=0.,  # 设置随机放大范围
        channel_shift_range=0.,  # 设置随机通道切换的范围
        # 设置填充输入边界之外的点的模式(constant, nearest, reflect)
        fill_mode='nearest',
        cval=0.,  # 在 fill_mode = "constant" 时使用的值
        horizontal_flip=True,  # 随机水平翻转图像
        vertical_flip=False,  # 随机垂直翻转图像
        # 设置缩放因子 (在其他转换之前使用)
        rescale=None,
        # 设置将应用于每一个输入的函数
        preprocessing_function=None,
        # 图像数据格式，"channels_first" 或 "channels_last" 之一
        data_format=None,
        # 保留用于验证的图像比例（严格在0和1之间）(多少数据用于验证集)
        validation_split=0.0)

    # 计算特征标准化所需的计算量
    # (如果应用 ZCA 白化，则为 std，mean和主成分).
    # datagen.fit(x_train): 将图片生成器 datagen 用于数据x_train
    datagen.fit(x_train)

    
    # model.fit_generator(): 使用生成器逐批生成的数据, 按批次训练模型
    # 利用由 datagen.flow() 生成的批来训练模型
    # datagen.flow(x_train, y_train, batch_size): 按 batch_size 大小从 x, y 生成增强数据
    # epochs: 训练模型的迭代总轮数, 一个 epoch 是对所提供的整个数据的一轮迭代
    # validation_data: (inputs, targets) 用来在每个epoch后或者每几个epoch验证一次验证集,用来及时发现过拟合或超参数设置等问题
    # workers: 使用的最大进程数量, 如果使用基于进程的多线程, 若为指定默认为1, 若为0将在主线程上执行生成器
    model.fit_generator(datagen.flow(x_train, y_train,
                                     batch_size=batch_size),
                        epochs=epochs,
                        validation_data=(x_test, y_test),
                        workers=4)

# 保存模型和权重
# os.path.isdir(path): 判断某一路径是否为目录
if not os.path.isdir(save_dir):
    
    # os.makedirs(): 用于递归创建目录
    os.makedirs(save_dir)
    
# os.path.join(): 连接路径名组件
model_path = os.path.join(save_dir, model_name)
model.save(model_path)
print('Saved trained model at %s ' % model_path)

# 评估训练模型
# model.evaluate(): 在测试模式下返回模型的误差值和评估标准值
# x_test: 测试数据的数组  y_test: 目标数据的数组  verbose: 日志显示模式 0=安静模式 1=进度条
scores = model.evaluate(x_test, y_test, verbose=1)
print('Test loss:', scores[0])
print('Test accuracy:', scores[1])

模型

一、 基于LSTM的序列分类

from keras.models import Sequential
from keras.layers import Dense, Dropout
from keras.layers import Embedding
from keras.layers import LSTM

max_features = 1024


# Sequential(): 序贯模型 线性模型
# 通过add()将各层添加到模型中
model = Sequential()

# Embedding(input_dim, output_dim): 降维
# input_dim: 词汇表大小  output_dim: 稠密嵌入矩阵的维度(词语向量的维度)
model.add(Embedding(max_features, output_dim=256))

# LSTM(输入句子的长度)
model.add(LSTM(128))

# Dropout(): 正则化(在每轮权重更新时随机选择一定比例的节点抛弃, 有效防止过拟合)
model.add(Dropout(0.5))

# 全连接层
# Dense(output_size, activition)
model.add(Dense(1, activation='sigmoid'))


# model.compile(): 对网络学习的过程进行配置
# loss: 损失函数  optimizer: 优化器  metrics: 在训练和测试期间的模型评估标准, 可为多输出模型的不同输出指定不同的评估标准
model.compile(loss='binary_crossentropy',
              optimizer='rmsprop',
              metrics=['accuracy'])


# model.fit(): 以给定数量的轮次训练模型
# x_train: 训练数据的数组  y_train: 目标数据的数组  batch_size: 每次梯度更新的样本数  epochs: 训练模型的迭代次数, 一个轮次是在整个x_train, y_train上的一轮迭代 
model.fit(x_train, y_train, batch_size=16, epochs=10)

# model.evaluate(): 在测试模型下返回模型的误差值和评估标准值
# x_test: 测试数据的数组  y_test: 目标数据的数组  batch_size: 每次评估的样本数, 若未指定则默认32
score = model.evaluate(x_test, y_test, batch_size=16)

二、 基于多层感知器(MLP)的softmax多分类

import keras
from keras.models import Sequential
from keras.layers import Dense, Dropout, Activation
from keras.optimizers import SGD

# 生成虚拟数据
import numpy as np

# np.random.random((1000, 20)): 代表1000个浮点数, 从0到20中随机
x_train = np.random.random((1000, 20))

# keras.utils.np_utils.to_categorical(): 在多分类问题中将类别变量的输出标签转化为数值变量
# np.random.randint(low, high=None, size): 返回一个随机整型数, 范围从低(包括)到高(不包括)  size: 输出随机数的尺寸
y_train = keras.utils.np_utils.to_categorical(np.random.randint(10, size=(1000, 1)), num_classes=10)

# np.random.random((100, 20)): 代表100个浮点数, 从0到20中随机
x_test = np.random.random((100, 20))

# keras.utils.np_utils.to_categorical(): 在多分类问题中将类别变量的输出标签转化为数值变量
# np.random.randint(low, high=None, size): 返回一个随机整型数, 范围从低(包括)到高(不包括)  size: 输出随机数的尺寸
y_test = keras.utils.np_utils.to_categorical(np.random.randint(10, size=(100, 1)), num_classes=10)


# Sequential(): 序贯模型 线性模型
# 通过add()将各层添加到模型中
model = Sequential()
# Dense(64) 是一个具有 64 个隐藏神经元的全连接层。
# 在第一层必须指定所期望的输入数据尺寸：
# 在这里，是一个 20 维的向量。
model.add(Dense(64, activation='relu', input_dim=20))

# Dropout(): 正则化(在每轮权重更新时随机选择一定比例的节点抛弃, 有效防止过拟合)
model.add(Dropout(0.5))

# 全连接层
# Dense(output_dim, activation)
model.add(Dense(64, activation='relu'))

# Dropout(): 正则化(在每轮权重更新时随机选择一定比例的节点抛弃, 有效防止过拟合)
model.add(Dropout(0.5))

# 全连接层
# Dense(output_dim, activation)
model.add(Dense(10, activation='softmax'))

# SGD优化器
# lr: 学习率  decay: 每次更新后的学习率衰减值  momentum: 动量参数  nesterov: 确定是否使用Nesterov动量
sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)

# model.compile(): 对网络的学习过程进行配置
# loss: 损失函数  optimizer: 激励函数  metrics: 在训练和测试期间的模型评估标准, 可为多输出模型的不同输出指定不同的评估标准
model.compile(loss='categorical_crossentropy',
              optimizer=sgd,
              metrics=['accuracy'])


# model.fit(): 以给定数量的轮次训练模型
# x_train: 训练数据的数组  y_train: 目标数据的数组  epochs: 训练模型迭代次数  batch_size: 每次梯度更新的样本数
model.fit(x_train, y_train,
          epochs=20,
          batch_size=128)

# model.evaluate(): 在测试模式下返回模型的误差值和评估标准值
# x_test: 测试数据的数组  y_test: 目标数据的数组  batch_size: 每次评估的样本数, 若未设置则默认为32
score = model.evaluate(x_test, y_test, batch_size=128)

三、 基于多层感知器的二分类

import numpy as np
from keras.models import Sequential
from keras.layers import Dense, Dropout

# 生成虚拟数据
# np.random.random((1000, 20)): 代表1000个浮点数, 从0到20之间随机
# np.random.randint(low, high=None, size): 返回一个随机整型数, 范围从低(包括)到高(不包括)  size: 输出随机数的尺寸
x_train = np.random.random((1000, 20))
y_train = np.random.randint(2, size=(1000, 1))
x_test = np.random.random((100, 20))
y_test = np.random.randint(2, size=(100, 1))


# Sequential(): 序贯模型 线性模型
# 通过add()将各层添加到模型中
model = Sequential()

# 全连接层
# Dense(output_dim, input_dim, activation)
model.add(Dense(64, input_dim=20, activation='relu'))

# Dropout(): 正则化(在每轮权重更新时随机选择一定比例的节点抛弃, 有效防止过拟合)
model.add(Dropout(0.5))

# 全连接层
# Dense(output_size, activation)
model.add(Dense(64, activation='relu'))

# Dropout(): 正则化(在每轮权重更新时随机选择一定比例的节点抛弃, 有效防止过拟合)
model.add(Dropout(0.5))

# 全连接层
# Dense(output_size, activation)
model.add(Dense(1, activation='sigmoid'))


# model.comple(): 对网络的学习过程进行配置
# loss: 损失函数  optimizer: 激励函数  metrics: 在训练和测试期间的模型评估标准, 可为多输出模型的不同输出指定不同的评估标准
model.compile(loss='binary_crossentropy',
              optimizer='rmsprop',
              metrics=['accuracy'])


# model.fit(): 以给定数量的轮次训练模型
# x_train: 训练数据的数组  y_train: 目标数据的数组  epochs: 训练模型的迭代轮次  batch_size: 每次梯度更新的样本数, 若未指定则默认为32
model.fit(x_train, y_train,
          epochs=20,
          batch_size=128)

# model.evaluate(): 在测试模式下返回模型的误差值和评估标准值
# x_test: 测试数据的数组  y_test: 目标数据的数组  batch_size: 每次评估的样本数, 若未指定则默认32
score = model.evaluate(x_test, y_test, batch_size=128)

最后

以上就是大意星月为你收集整理的keras学习笔记的全部内容，希望文章能够帮你解决keras学习笔记所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。