《python深度学习》keras书籍读书笔记

keras学习过程问题记录：

书籍：

1.“models.Sequential（）”中Sequential函数作用：

Sequential模型字面上的翻译是顺序模型，感觉是简单的线性模型，但实际上Sequential模型可以构建非常复杂的神经网络，包括全连接神经网络、卷积神经网络(CNN)、循环神经网络(RNN)等等。Sequential更准确的理解应该为堆叠，通过堆叠许多不同的层，构建出深度神经网络。 所以这个是构建一个顺序模型网络。

2.models.Sequential（）.compile()方法中各个参数的作用：

*在训练模型之前，我们需要配置学习过程，这是通过compile方法完成的，他接收三个参数：
优化器 optimizer：它可以是现有优化器的字符串标识符，如 rmsprop 或 adagrad，也可以是 Optimizer 类的实例。详见：optimizers。
损失函数 loss：模型试图最小化的目标函数。它可以是现有损失函数的字符串标识符，如 categorical_crossentropy 或 mse，也可以是一个目标函数。详见：losses。
评估标准 metrics：对于任何分类问题，你都希望将其设置为 metrics = [‘accuracy’]。评估标准可以是现有的标准的字符串标识符，也可以是自定义的评估标准函数。

3.np.random.shuffle(data)

重新排序返回一个随机序列作用。
举例：

x = np.arange(10)
print(x)
np.random.shuffle(x)
print(x)

输出：

[0 1 2 3 4 5 6 7 8 9]
[2 1 8 4 3 5 0 9 7 6]

4.列表运算

1.append() 向列表尾部追加一个新元素，列表只占一个索引位，在原有列表上增加
2.extend() 向列表尾部追加一个列表，将列表中的每个元素都追加进来，在原有列表上增加
3.+ 直接用+号看上去与用extend()一样的效果，但是实际上是生成了一个新的列表存这两个列表的和，只能用在两个列表相加上
4.+= 效果与extend()一样，向原列表追加一个新元素，在原有列表上增加

5.keras模型新增卷积层layers.Conv2D()中的参数

例如：

model.add(layers.Conv2D(32,(3,3),activation='relu',input_shape=(28,28,1)))

其中卷积层滤波器的大小是3*3，数量32个，使用激活函数为relu，输入的向量为(28,28,1)，这个一般为第一层。后几层通常为：

model.add(layers.Conv2D(64,(3,3),activation='relu'))

6.keras中的layers.Flatten()

代码：
model.add(layers.Flatten())
一般用于卷积神经网络全链接层前的预处理,下面是例子：

7.keras中的keras.utils.to_categorical方法

to_categorical(y, num_classes=None, dtype=‘float32’)

将整型标签转为onehot。y为int数组，num_classes为标签类别总数，大于max(y)（标签从0开始的）。

8.model.fit() ,model.compile(),model.evaluate参数详解与作用

fit()用于使用给定输入训练模型.
predict()用于实际预测.它为输入样本生成输出预测.
evaluate()用于评估已经训练过的模型.返回损失值&模型的度量值.

9.os.mkdir()和os.path.join()

os.mkdir() 方法用于以数字权限模式创建目录。

os.path.join()函数：连接两个或更多的路径名组件
1.如果各组件名首字母不包含’/’，则函数会自动加上
2.如果有一个组件是一个绝对路径，则在它之前的所有组件均会被舍弃
3.如果最后一个组件为空，则生成的路径以一个’/’分隔符结尾

import os

Path1 = 'home'
Path2 = 'develop'
Path3 = 'code'

Path10 = Path1 + Path2 + Path3
Path20 = os.path.join(Path1,Path2,Path3)
print ('Path10 = ',Path10)
print ('Path20 = ',Path20)

输出：

Path10 = homedevelopcode
Path20 = home\develop\code

10.fnames=[‘cat.{}.jpg’.format(i) for i in range(1000)]

fnames=['cat.{}.jpg'.format(i) for i in range(1000)]

fnames是一个列表，其中存的元素是cat.0.jpg…cat.999.jpg

11.函数shutil.copyfile（file1,file2）

file1为需要复制的源文件的文件路径,file2为目标文件的文件路径+文件名.

12.VGG16模型

一共十六层，13个卷积层和3个全连接层。五个pooling层。第一次经过64个卷积核的两次卷积后，采用一次pooling，第二次经过两次128个卷积核卷积后，再采用pooling，再重复两次三个512个卷积核卷积后，再pooling，最后经过三次全连接。

13.keras中的history类对象

代码：

history=model.fit(train_features,train_labels,epochs=30,batch_size=20,validation_data=(validation_features,validation_labels))

history类对象包含两个属性，分别为epoch和history。
epoch为训练轮数，history字典类型，包含val_loss,val_acc（ val 代表 validation，所以是验证集的acc和loss）,loss,acc四个key值.

14.让图像具有可读性，使曲线变得平滑的smooth_curve（）【页数128】

def smooth_curve(points,factor=0.8):
	smoothed_points=[]
	for point in points:
		if smoothed_points:
			previous=smoothed_points[-1]
			smoothed_points.append(previous*factor+point*(1-factor))
		else:
			smoothed_points.append(point)
	return smoothed_points

15.keras中的函数decode_predictions(preds,top=3)[0]

代码：

preds=model.predict(x)
pred=decode_predictions(preds,top=3)[0]#去的前三个最优可能的类别和概率

其中preds是预测向量，得到的pred是一个列表。列表中的元素是元祖
[(u’n02504458’,u’African_elephant’,0.92546833),(u’n01871265’,u’tushker’,0.070257246),(u’n02504013’,u’Indian_elephant’,0.0042589349)],

16.字典dcit.values()

dict = {'a': 1, 'b': 2, 'b': '3'}

字典的values方法是返回所有的value值。

17.enumerate()函数

>>>seq = ['one', 'two', 'three']
>>> for i, element in enumerate(seq):
...     print i, element
... 

输出

0 one
1 two
2 three

18.Python zip() 函数

zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
实例：

x = [1, 2, 3]

y = [4, 5, 6]

z = [7, 8, 9]

xyz = zip(x, y, z)

print xyz

输出

[(1, 4, 7), (2, 5, 8), (3, 6, 9)]

19.keras中tokenizer的方法介绍

from keras.preprocessing.text import Tokenizer

somestr = ['ha ha gua angry','howa ha gua excited naive']
tokenizer=Tokenizer()#初始化分词器
tokenizer.fit_on_texts(somestr)#学习出文本的字典
word_index=tokenizer.word_index#查看对应的单词和数字的映射关系dict
print(word_index)
sequences=tokenizer.texts_to_sequences(somestr)#通过texts_to_sequences 这个dict可以将每个string的每个词转成数字
print(sequences)

输出

{‘naive’: 6, ‘ha’: 1, ‘excited’: 5, ‘angry’: 3, ‘gua’: 2, ‘howa’: 4}#目测是单词最早出来的顺序
[[1, 1, 2, 3], [4, 1, 2, 5, 6]]

20.keras中pad_sequences()方法作用

keras只能接受相同长度的序列输入，所以得对输入序列进行处理。
语法：

keras.preprocessing.sequence.pad_sequences(sequences, 
	maxlen=None,
	dtype='int32',
	padding='pre',
	truncating='pre', 
	value=0.)

参数说明：
sequences：浮点数或整数构成的两层嵌套列表
maxlen:None或整数，为序列的最大长度。大于这个长度会被截短，小于这个长度填0
datype:返回的numpy arrary的数据类型
padding：‘pre’或‘post’,确定补0的时候，在序列的起始补还是结尾补
truncating：‘pre’或‘post’,确定截断的时候，在序列的起始补还是结尾补
value：浮点数，默认是0，这个值是用来代表填充的数字

这个函数返回的是一个2维张量，长度为maxlen

list_1 = [[2,3,4]]
keras.preprocessing.sequence.pad_sequences(list_1, maxlen=10)
list_1 = [[2,3,4],[3]]

输出

array([[0, 0, 0, 0, 0, 0, 0, 2, 3, 4]], dtype=int32)
array([[0, 0, 0, 0, 0, 0, 0, 2, 3, 4],[0, 0, 0, 0, 0, 0, 0, 0, 0, 3]], dtype=int32)

只对列表中的列表元素处理

21.for line in open(filename)命令理解

按行读取，关于文件读取可查看另一篇博文
python读取文件

22.keras中embedding层

keras.layers.embeddings.Embedding(input_dim, 
								  output_dim, 
								  embeddings_initializer='uniform', 
								  embeddings_regularizer=None, 
								  activity_regularizer=None, 
								  embeddings_constraint=None, 
								  mask_zero=False, 
								  input_length=None)

嵌入层将正整数（下标）转换为具有固定大小的向量

参数：
input_dim：大或等于0的整数，字典长度，即输入数据最大下标+1
output_dim：大于0的整数，代表全连接嵌入的维度
embeddings_initializer: 嵌入矩阵的初始化方法，为预定义初始化方法名的字符串，或用于初始化权重的初始化器。参考initializers
embeddings_regularizer: 嵌入矩阵的正则项，为Regularizer对象
embeddings_constraint: 嵌入矩阵的约束项，为Constraints对象
mask_zero：布尔值，确定是否将输入中的‘0’看作是应该被忽略的‘填充’（padding）值，该参数在使用递归层处理变长输入时有用。设置为True的话，模型中后续的层必须都支持masking，否则会抛出异常。如果该值为True，则下标0在字典中不可用，input_dim应设置为|vocabulary| + 2。
input_length：当输入序列的长度固定时，该值为其长度。如果要在该层后接Flatten层，然后接Dense层，则必须指定该参数，否则Dense层的输出维度无法自动推断。
输入shape
形如（samples，sequence_length）的2D张量
输出shape
形如(samples, sequence_length, output_dim)的3D张量

23.GRU函数

keras.layers.GRU(units, activation='tanh', recurrent_activation='hard_sigmoid', use_bias=True, kernel_initializer='glorot_uniform', recurrent_initializer='orthogonal', bias_initializer='zeros', kernel_regularizer=None, recurrent_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, recurrent_constraint=None, bias_constraint=None, dropout=0.0, recurrent_dropout=0.0, implementation=1, return_sequences=False, return_state=False, go_backwards=False, stateful=False, unroll=False, reset_after=False)

参数说明：
units: 正整数，输出空间的维度。
activation: 要使用的激活函数 (详见 activations)。 默认：双曲正切 (tanh)。 如果传入 None，则不使用激活函数 (即 线性激活：a(x) = x)。
recurrent_activation: 用于循环时间步的激活函数 (详见 activations)。 默认：分段线性近似 sigmoid (hard_sigmoid)。 如果传入 None，则不使用激活函数 (即 线性激活：a(x) = x)。
use_bias: 布尔值，该层是否使用偏置向量。
kernel_initializer: kernel 权值矩阵的初始化器， 用于输入的线性转换 (详见 initializers)。
recurrent_initializer: recurrent_kernel 权值矩阵 的初始化器，用于循环层状态的线性转换 (详见 initializers)。
bias_initializer: 偏置向量的初始化器 (详见initializers).
kernel_regularizer: 运用到 kernel 权值矩阵的正则化函数 (详见 regularizer)。
recurrent_regularizer: 运用到 recurrent_kernel 权值矩阵的正则化函数 (详见 regularizer)。
bias_regularizer: 运用到偏置向量的正则化函数 (详见 regularizer)。
activity_regularizer: 运用到层输出（它的激活值）的正则化函数 (详见 regularizer)。
kernel_constraint: 运用到 kernel 权值矩阵的约束函数 (详见 constraints)。
recurrent_constraint: 运用到 recurrent_kernel 权值矩阵的约束函数 (详见 constraints)。
bias_constraint: 运用到偏置向量的约束函数 (详见 constraints)。
dropout: 在 0 和 1 之间的浮点数。 单元的丢弃比例，用于输入的线性转换。
recurrent_dropout: 在 0 和 1 之间的浮点数。 单元的丢弃比例，用于循环层状态的线性转换。
implementation: 实现模式，1 或 2。 模式 1 将把它的操作结构化为更多的小的点积和加法操作， 而模式 2 将把它们分批到更少，更大的操作中。 这些模式在不同的硬件和不同的应用中具有不同的性能配置文件。
return_sequences: 布尔值。是返回输出序列中的最后一个输出，还是全部序列。
return_state: 布尔值。除了输出之外是否返回最后一个状态。
go_backwards: 布尔值 (默认 False)。 如果为 True，则向后处理输入序列并返回相反的序列。
stateful: 布尔值 (默认 False)。 如果为 True，则批次中索引 i 处的每个样品的最后状态 将用作下一批次中索引 i 样品的初始状态。
unroll: 布尔值 (默认 False)。 如果为 True，则网络将展开，否则将使用符号循环。 展开可以加速 RNN，但它往往会占用更多的内存。 展开只适用于短序列。
reset_after: GRU 公约 (是否在矩阵乘法之前或者之后使用重置门)。 False =「之前」(默认)，Ture =「之后」( CuDNN 兼容)。

24.Dense函数

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)

units: 正整数，输出空间维度。
activation: 激活函数 (详见 activations)。 若不指定，则不使用激活函数 (即，「线性」激活: a(x) = x)。
use_bias: 布尔值，该层是否使用偏置向量。
kernel_initializer: kernel 权值矩阵的初始化器 (详见 initializers)。
bias_initializer: 偏置向量的初始化器 (see initializers).
kernel_regularizer: 运用到 kernel 权值矩阵的正则化函数 (详见 regularizer)。
bias_regularizer: 运用到偏置向的的正则化函数 (详见 regularizer)。
activity_regularizer: 运用到层的输出的正则化函数 (它的 “activation”)。 (详见 regularizer)。
kernel_constraint: 运用到 kernel 权值矩阵的约束函数 (详见 constraints)。
bias_constraint: 运用到偏置向量的约束函数 (详见 constraints)。

25.三个概念epoch，batch，iteration

名词解释：

Epoch就是将所有训练样本训练一次的过程，然而，当一个Epoch的样本（也就是所有的训练样本）数量可能太过庞大（对于计算机而言），就需要把它分成多个小块，也就是就是分成多个Batch 来进行训练。

26.kares中的Conv1D

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)

filters: 整数，输出空间的维度 （即卷积中滤波器的输出数量）。
kernel_size: 一个整数，或者单个整数表示的元组或列表， 指明 1D 卷积窗口的长度。
strides: 一个整数，或者单个整数表示的元组或列表， 指明卷积的步长。 指定任何 stride 值 != 1 与指定 dilation_rate 值 != 1 两者不兼容。
padding: “valid”, “causal” 或 “same” 之一 (大小写敏感) “valid” 表示「不填充」。 “same” 表示填充输入以使输出具有与原始输入相同的长度。 “causal” 表示因果（膨胀）卷积， 例如，output[t] 不依赖于 input[t+1:]， 在模型不应违反时间顺序的时间数据建模时非常有用。 详见 WaveNet: A Generative Model for Raw Audio, section 2.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: 要使用的激活函数 (详见 activations)。 如未指定，则不使用激活函数 (即线性激活： a(x) = x)。
use_bias: 布尔值，该层是否使用偏置向量。
kernel_initializer: kernel 权值矩阵的初始化器 (详见 initializers)。
bias_initializer: 偏置向量的初始化器 (详见 initializers)。
kernel_regularizer: 运用到 kernel 权值矩阵的正则化函数 (详见 regularizer)。
bias_regularizer: 运用到偏置向量的正则化函数 (详见 regularizer)。
activity_regularizer: 运用到层输出（它的激活值）的正则化函数 (详见 regularizer)。
kernel_constraint: 运用到 kernel 权值矩阵的约束函数 (详见 constraints)。
bias_constraint: 运用到偏置向量的约束函数 (详见 constraints)。

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

27.keras中的Conv2D

keras.layers.convolutional.Conv2D(filters,kernel_size,strides(1,1), 
                                  padding='valid',
                                  data_format=None,
                                  dilation_rate=(1,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)

此操作将二维向量进行卷积，当使用该层作为第一层时，应提供input_shape参数。

参数：

filters：卷积核的数目（即输出的维度）。

kernel_size：单个整数或由两个整数构成的list/tuple，卷积核的宽度和长度。如为单
个整数，则表示在各个空间维度的相同长度。

strides：单个整数或由两个整数构成的list/tuple，为卷积的步长。如为单个整数，则
表示在各个空间维度的相同步长。任何不为1的strides均与任何不为1的dilation_rata均
不兼容。

padding：补0策略，为“valid”, “same”。“valid”代表只进行有效的卷积，即对边界数据
不处理。“same”代表保留边界处的卷积结果，通常会导致输出shape与输入shape相
同。

activation：激活函数，为预定义的激活函数名（参考激活函数），或逐元素
（element-wise）的Theano函数。如果不指定该参数，将不会使用任何激活函数（即
使用线性激活函数：a(x)=x）。

dilation_rate：单个整数或由两个个整数构成的list/tuple，指定dilated convolution中的
膨胀比例。任何不为1的dilation_rata均与任何不为1的strides均不兼容。

data_format：字符串，“channels_first”或“channels_last”之一，代表图像的通道维的位
置。该参数是Keras 1.x中的image_dim_ordering，“channels_last”对应原本
的“tf”，“channels_first”对应原本的“th”。以128x128的RGB图像为
例，“channels_first”应将数据组织为（3,128,128），而“channels_last”应将数据组织为
（128,128,3）。该参数的默认值是~/.keras/keras.json中设置的值，若从未设置过，则
为“channels_last”。

use_bias：布尔值，是否使用偏置项。

kernel_initializer：权值初始化方法，为预定义初始化方法名的字符串，或用于初始化
权重的初始化器。

bias_initializer：权值初始化方法，为预定义初始化方法名的字符串，或用于初始化权
重的初始化器。

kernel_regularizer：施加在权重上的正则项，为Regularizer对象。

bias_regularizer：施加在偏置向量上的正则项，为Regularizer对象。

activity_regularizer：施加在输出上的正则项，为Regularizer对象。

kernel_constraints：施加在权重上的约束项，为Constraints对象。

bias_constraints：施加在偏置上的约束项，为Constraints对象。

28.MaxPooling1D和GlobalMaxPooling1D的区别

1.GlobalMaxPooling1D:
在steps维度（也就是第二维）对整个数据求最大值。
比如说输入数据维度是[10, 4, 10]，那么进过全局池化后，输出数据的维度则变成[10, 10]。

2.MaxPooling1D：
也是在steps维度（也就是第二维）求最大值。但是限制每一步的池化的大小。 比如，输入数据维度是[10, 4, 10]，池化层大小pooling_size=2，步长stride=1，那么经过MaxPooling(pooling_size=2, stride=1)后，输出数据维度是[10, 3, 10]。

MaxPooling1D：

keras.layers.MaxPooling1D(pool_size=2, 
						  strides=None, 
						  padding='valid', 
						  data_format='channels_last')

keras.layers.GlobalMaxPooling1D(data_format='channels_last')

data_format: 字符串，channels_last (默认)或 channels_first 之一。 表示输入各维度的顺序。 channels_last 对应输入尺寸为 (batch, steps, features)， channels_first 对应输入尺寸为 (batch, features, steps)。

29.keras中的model.fit()和model.compile()

fit(x=None, 
	y=None, 
	batch_size=None, 
	epochs=1, 
	verbose=1, 
	callbacks=None, 
	validation_split=0.0, 
	validation_data=None, 
	shuffle=True, 
	class_weight=None, 
	sample_weight=None, 
	initial_epoch=0, 
	steps_per_epoch=None, 
	validation_steps=None, 
	validation_freq=1)

x：输入数据。如果模型只有一个输入，那么x的类型是numpy array，如果模型有多个输入，那么x的类型应当为list，list的元素是对应于各个输入的numpy array
y：标签，numpy array
batch_size：整数，指定进行梯度下降时每个batch包含的样本数。训练时一个batch的样本会被计算一次梯度下降，使目标函数优化一步。
epochs：整数，训练终止时的epoch值，训练将在达到该epoch值时停止，当没有设置initial_epoch时，它就是训练的总轮数，否则训练的总轮数为epochs-inital_epoch
verbose：日志显示，0为不在标准输出流输出日志信息，1为输出进度条记录，2为每个epoch输出一行记录
callbacks：list，其中的元素是keras.callbacks.Callback的对象。这个list中的回调函数将会在训练过程中的适当时机被调用，参考回调函数
validation_split：0~1之间的浮点数，用来指定训练集的一定比例数据作为验证集。验证集将不参与训练，并在每个epoch结束后测试的模型的指标，如损失函数、精确度等。注意，validation_split的划分在shuffle之前，因此如果你的数据本身是有序的，需要先手工打乱再指定validation_split，否则可能会出现验证集样本不均匀。
validation_data：形式为（X，y）的tuple，是指定的验证集。此参数将覆盖validation_spilt。
shuffle：布尔值或字符串，一般为布尔值，表示是否在训练过程中随机打乱输入样本的顺序。若为字符串“batch”，则是用来处理HDF5数据的特殊情况，它将在batch内部将数据打乱。
class_weight：字典，将不同的类别映射为不同的权值，该参数用来在训练过程中调整损失函数（只能用于训练）
sample_weight：权值的numpy array，用于在训练时调整损失函数（仅用于训练）。可以传递一个1D的与样本等长的向量用于对样本进行1对1的加权，或者在面对时序数据时，传递一个的形式为（samples，sequence_length）的矩阵来为每个时间步上的样本赋不同的权。这种情况下请确定在编译模型时添加了sample_weight_mode=’temporal’。
initial_epoch: 从该参数指定的epoch开始训练，在继续之前的训练时有用。

fit函数返回一个History的对象，其History.history属性记录了损失函数和其他指标的数值随epoch变化的情况，如果有验证集的话，也包含了验证集的这些指标变化情况

compile(optimizer, 
		loss=None, 
		metrics=None, 
		loss_weights=None, 
		sample_weight_mode=None, 
		weighted_metrics=None, 
		target_tensors=None)

最重要的三个参数是optimizer，loss，metrics
optimizer: 字符串（优化器名）或者优化器实例。
loss: 字符串（目标函数名）或目标函数。 详见 losses。 如果模型具有多个输出，则可以通过传递损失函数的字典或列表，在每个输出上使用不同的损失。 模型将最小化的损失值将是所有单个损失的总和。
metrics: 在训练和测试期间的模型评估标准。 通常你会使用 metrics = [‘accuracy’]。 要为多输出模型的不同输出指定不同的评估标准， 还可以传递一个字典，如 metrics = {‘output_a’：‘accuracy’}。
loss_weights: 可选的指定标量系数（Python 浮点数）的列表或字典， 用以衡量损失函数对不同的模型输出的贡献。 模型将最小化的误差值是由 loss_weights 系数加权的加权总和误差。 如果是列表，那么它应该是与模型输出相对应的 1:1 映射。 如果是张量，那么应该把输出的名称（字符串）映到标量系数。
sample_weight_mode: 如果你需要执行按时间步采样权重（2D 权重），请将其设置为 temporal。 默认为 None，为采样权重（1D）。 如果模型有多个输出，则可以通过传递 mode 的字典或列表，以在每个输出上使用不同的 sample_weight_mode。
weighted_metrics: 在训练和测试期间，由 sample_weight 或 class_weight 评估和加权的度量标准列表。
target_tensors: 默认情况下，Keras 将为模型的目标创建一个占位符，在训练过程中将使用目标数据。 相反，如果你想使用自己的目标张量（反过来说，Keras 在训练期间不会载入这些目标张量的外部 Numpy 数据）， 您可以通过 target_tensors 参数指定它们。 它可以是单个张量（单输出模型），张量列表，或一个映射输出名称到目标张量的字典。
kwargs: 当使用 Theano/CNTK 后端时，这些参数被传入 K.function。 当使用 TensorFlow 后端时，这些参数被传递到 tf.Session.run。

30.为模型选择正确的最后一层激活和损失函数

问题类型	最后一层激活	损失函数
二分类问题	sigmoid	binary_crossentropy
多分类、单标签问题	softmax	categorical_crossentropy
多分类、多标签问题	sigmoid	binary_crossentropy
回归到任意值	无	mse
回归到0~1范围内的值	sigmoid	mse或binary_crossentropy

31.python中的生成器及其yield

32.keras中的concatenate（）函数

语法：

keras.layers.concatenate(inputs, axis=-1)

参数：

返回一个张量，所有输入张量通过axis轴串联起来的输出张量
举例：

concatenated=layers.concatenate([encode_text,encode_question],axis=-1)

形式：
***后续补上

33.keras中的Input（）

keras.Input(shape=%,dtype=%,name=%，batch_shape=%,sparse=%,tensor=%)

参数：
shape：一个尺寸元组（整数），不包含批量大小。例如shape=（32，），表明期望的输入是按批次的32维向量。
batch_shape：一个尺寸元组（整数），包含批量大小。例如==batch_shape=(10)==表明期望的输入是10个32维向量。batch_shape=(None,32) 表明任意批次大小的32位向量。
name：一个可选的层的名称的字符串。在一个模型中应该是唯一的（不可以重用一个名字两次）。如未提供，将自动生成。
dtype: 输入所期望的数据类型，字符串表示 (float32, float64, int32…)
sparse: 一个布尔值，指明需要创建的占位符是否是稀疏的。
tensor: 可选的可封装到 Input 层的现有张量。 如果设定了，那么这个层将不会创建占位符张量。

返回一个张量

34.keras中的预训练模型Xception

keras.applications.Xception(include_top=True, 
							weights='imagenet', 
							input_tensor=None, 
							input_shape=None, 
							pooling=None, 
							classes=1000)

参数
include_top: 是否包括顶层的全连接层。
weights: None 代表随机初始化， ‘imagenet’ 代表加载在 ImageNet 上预训练的权值。
input_tensor: 可选，Keras tensor 作为模型的输入（即 layers.Input() 输出的 tensor）。
input_shape: 可选，输入尺寸元组，仅当 include_top=False 时有效（否则输入形状必须是 (299, 299, 3)，因为预训练模型是以这个大小训练的）。它必须拥有 3 个输入通道，且宽高必须不小于 71。例如 (150, 150, 3) 是一个合法的输入尺寸。
pooling: 可选，当 include_top 为 False 时，该参数指定了特征提取时的池化方式。None 代表不池化，直接输出最后一层卷积层的输出，该输出是一个 4D 张量。
‘avg’ 代表全局平均池化（GlobalAveragePooling2D），相当于在最后一层卷积层后面再加一层全局平均池化层，输出是一个 2D 张量。
‘max’ 代表全局最大池化。
classes: 可选，图片分类的类别数，仅当 include_top 为 True 并且不加载预训练权值时可用。

35.keras中的回调函数

回调函数是一个函数的合集，会在训练的阶段中所使用。你可以使用回调函数来查看训练模型的内在状态和统计。你可以传递一个列表的回调函数（作为 callbacks 关键字参数）到 Sequential 或 Model 类型的 .fit() 方法。在训练时，相应的回调函数的方法就会被在各自的阶段被调用。

接下来介绍三个回调函数：
1.ModelCheckpoint和EarlyStopping回调函数
如果监控的目标指标在设定的轮数内不再改善，可以用EarlyStopping回调函数来中断训练。比如这个回调函数可以在刚刚开始过拟合的时候中断训练，从而避免用最少的轮次重新训练模型。这个回调函数通常与ModelCheckpoint结合使用，后者可以在训练过程中持续不断的保存模型。

import keras
callbacks_list=[
	keras.callbacks.EarlyStopping(//如果不再改善就中断训练
		monitor='acc',//监控模型的验证精度
		patience=1,//如果精度在多余一轮的时间（即两轮内）不再改变，中断训练
	),
	keras.callbacks.ModelCheckpoint(//每轮过后保存当前权重
		filepath='my_model.h5',//目标模型文件的保存路径
		monitor='val_loss',//这两个参数的含义是 如果val_loss没有改善，那么
		save_best_only=True,//不需要再覆盖模型文件。这就是可以始终保存在训练过程
中的最佳模型
	)
]
	
model.compile(optimizer='rmsprop',
			  loss='binary_crossentropy'
			  metrics=['acc'])
model.fit(x,y,epochs=10,batch_size=32,callback=callbacks_list,validation_data=(x_val,y_val))//由于回调函数要监控验证损失和验证精度，所以在调用fit时需要传入validation（验证数据）

2.ReduceLROnPlateau回调函数
如果验证损失不再改善，你可以使用这个回调函数来降低学习率。在训练过程中如果出现损失平台，那么增大或者减小学习率都是跳出局部最小值的有效策略。

callback_list=[
	keras.callback.ReduceLROnPlateau(
		monitor='val_loss' //监控模型的验证损失
		factor=0.1   //触发时将学习率除以10，就是乘以factor
		patience=10 //如果验证损失在10轮内没有改善，那么就触发这个回调函数
		)
]
model.fit(x,y,epochs=10,batch_size=32,callback=callbacks_list,validation_data=(x_val,y_val))

3.编写自己的回调函数
实现方式是创建keras.callbacks.Callback类的子类。然后实现下面的方法，分别在训练过程中的不同时间点被调用。

on_epoch_begin//在每轮开始时被调用
on_epoch_end//在每轮结束时被调用

on_batch_begin//在处理每个批量之前被调用
on_batch_end//在处理每个批量之后被调用

on_train_begin//在训练开始时被调用
on_train_end//在训练结束时被调用

这些方法被调用时都有一个logs参数，这个参数是一个字典，里面包含前一个批量、前一个轮次或前一次训练的信息，即训练指标和验证指标。此外，回调函数还可以访问下列属性：
*self.model:调用回调函数的模型实例
*self.validation_data:传入fit作为验证数据的值

下面为示例：

import keras
import numpy as np

class ActivationLogger(keras.callbacks.Callback):
	def set_model(self,model):
		self.model=model//在训练之前由父模型调用，告诉回调函数哪个模型在调用它
		layers_outputs=[layers.output for layer in model.layers]
		self.activations_model=keras.models.Model(model.input,layer_output)
	def on_epoch_end(self,epoch,logs=None):
		if self.validation_data is None:
			raise RuntimeError('Requires validation_data.')
		validation_sample=self.validation_data[0][0:1]//获取验证数据的第一个输入样本
		activations=self.activations_model.predict(validation_sample)
		f=open('activations_at_epoch_'+str(epoch)+'.npz','w')//最后三行将数据保存到硬盘中
		np.savez(f,activations)
		f.close()