Keras - Python深度学习（第一部分）
Keras - Python深度学习（第二部分）
执行时报错：could not create cudnn handle: CUDNN_STATUS_ALLOC_FAILED
解决方式：GPU占用问题导致的，keras框架（Tensorflow backend） 设置GPU按需分配：
import tensorflow as tf
from keras import backend as K
config = tf.ConfigProto()
config.gpu_options.allow_growth=True
sess = tf.Session(config=config)
K.set_session(sess)
基础知识
1.张量 包含 向量、标量、矩阵。
2.向量：一维张量（1D 张量），只有一个轴。
标量：0维张量（0D 张量），一个 float32 或 float64 的数字就是一个标量张量（或标量数组），即标量张量/零维张量/0D 张量，有0个轴。
矩阵：行*列的二维数组，即二维张量（2D 张量），只有两个轴。第一个轴上的元素叫作行（row），第二个轴上的元素叫作列（column）。
3.x.ndim：ndim 属性来查看一个 Numpy 张量的轴的个数。
轴：张量轴的个数也叫作阶（rank），张量的阶数即轴的个数。比如 5D 张量 又可以叫做 5阶张量。
维度：第一种表示向量中沿着某个轴上的元素个数，比如 5D 向量 表示只有一个的轴上有5个元素，即指这唯一一个的轴有 5个维度。
第二种表示张量中轴的个数，比如 5D 张量(5阶张量) 表示有5个轴，沿着每个轴可能有任意个维度，即每个轴可以有任意个元素，张量沿每个轴的维度大小即元素个数。
4.3D 张量：将多个矩阵(2D 张量)组合成一个新的数组，即得到一个 3D 张量，相当于把多个二维数组组合成一个三维数组。
4D 张量：将多个 3D 张量组合成一个数组，即得到一个 4D 张量，相当于把多个三维数组组合成一个四维数组。
更高维张量：以此类推，将多个 “N”D张量组合成一个数组，即得到一个 “N+1”D张量。
深度学习处理的一般是 0D 到 4D 的张量，但处理视频数据时可能会遇到 5D 张量。
5D 向量和 5D 张量 概念不相同。5D 向量只有一个轴，沿着轴有 5 个维度，即唯一一个的轴上有5个元素。
而 5D 张量有 5 个轴，沿着每个轴可能有任意个维度。
5.张量的三个属性
1.轴的个数（阶数）：也叫张量的 ndim，例如 3D 张量有 3 个轴，矩阵有 2 个轴。
2.形状：表示为一个整数元组，表示张量中沿每个轴的维度大小（元素个数）。例如向量的形状只包含一个元素，表示为(5,)；而标量的形状为空，表示为()；
矩阵表示为(3, 5)；3D 张量表示为(3, 3, 5)。
3.数据类型：也叫dtype，张量的类型可以是 float32、uint8、float64 等。在极少数情况下，你可能会遇到字符（char）张量。
注意，Numpy（以及大多数其他库）中不存在字符串张量，因为张量存储在预先分配的连续内存段中，而字符串的长度是可变的，无法用这种方式存储。
6.图像张量的形状有两种约定
通道在后（channels-last）的约定（在 TensorFlow 中使用）和通道在前（channels-first）的约定（在 Theano 中使用）。
Google 的 TensorFlow 机器学习框架将颜色深度轴放在最后：(samples, height, width, color_depth)。
与此相反，Theano将图像深度轴放在批量轴之后：(samples, color_depth, height, width)。
如果采用 Theano 约定，前面的两个例子将变成 (128, 1, 256, 256) 和 (128, 3, 256, 256)。
Keras 框架同时支持这两种格式。
7.点积运算
点积运算，也叫张量积（tensor product，不要与逐元素的乘积弄混），是最常见也最有用的张量运算。
与逐元素的运算不同，它将输入张量的元素合并在一起。在 Numpy、Keras、Theano 和 TensorFlow 中，都是用 * 实现逐元素乘积。
TensorFlow 中的点积使用了不同的语法，但在 Numpy 和 Keras 中，都是用标准的 dot 运算符来实现点积。
import numpy as np
z = np.dot(x, y)
数学符号中的点（.）表示点积运算。
z=x.y
注意，如果两个张量中有一个的 ndim 大于 1，那么 dot 运算就不再是对称的，也就是说，dot(x, y) 不等于 dot(y, x)。
当然，点积可以推广到具有任意个轴的张量。最常见的应用可能就是两个矩阵之间的点积。
对于两个矩阵 x 和 y，当且仅当 x.shape[1] == y.shape[0] 时，你才可以对它们做点积（dot(x, y)）。
得到的结果是一个形状为 (x.shape[0], y.shape[1]) 的矩阵，其元素为 x的行与 y 的列之间的点积。
其简单实现如下。
标签向量化的有两种方法：one-hot编码、整数张量
架构选择、损失函数、激活函数
1.对于分类、回归、序列预测等常见问题，你可以遵循一些简单的指导原则来选择正确的损失函数。
2.对于二分类问题，你可以使用二元交叉熵（binary crossentropy）损失函数；
3.对于多分类问题，可以用分类交叉熵（categorical crossentropy）损失函数；
4.对于回归问题，可以用均方误差（mean-squared error）损失函数；
model.add(layers.Dense(1)) 最后一个 Dense 层没有使用激活函数，这对于回归问题是很常见的。
网络的最后一层只有一个单元，没有激活，是一个线性层。这是标量回归（标量回归是预测单一连续值的回归）的典型设置。
添加激活函数将会限制输出范围。例如，如果向最后一层添加 sigmoid 激活函数，网络只能学会预测 0~1 范围内的值。
这里最后一层是纯线性的，所以网络可以学会预测任意范围内的值。
5.model.compile(optimizer='rmsprop', loss='mse', metrics=['mae'])
model.compile(optimizer=RMSprop(), loss='mae')
编译网络时用的mse 损失函数，即均方误差（MSE，mean squared error），预测值与目标值之差的平方。这是回归问题常用的损失函数。
在训练过程中还监控一个新指标：平均绝对误差（MAE，mean absolute error）。它是预测值与目标值之差的绝对值。
比如，如果这个问题的 MAE 等于 0.5，真实目标是房屋价格的中位数，单位是千美元，那么就表示你预测的房价与实际价格平均相差 500 美元。
6.平均绝对误差（MAE）：mae = np.mean(np.abs(preds - targets))
比如现在计算得出的 MAE值 为 0.29。因为输入数据已经被标准化成了均值为 0、标准差为 1的数据，
所以无法直接对这个MAE值进行解释，因此它需要把MAE值转化成“和输入数据同样标准的”值，即MAE值 0.29 乘以 源数据的std值，
这个过程叫做反标准化，便能转换得出真正的平均绝对误差值。
注意：此处的MAE值之所以能乘以源数据的std值便能得出真正的平均绝对误差值是有要求的，首先要求 preds - targets都是同种类型的值。
比如preds是预测的温度值，targets是真实的温度值，而“MAE值所乘以的”std标准值也同样为根据温度值所求出来的std标准值。
数据标椎化：
mean = train_data.mean(axis=0)
train_data -= mean
std = train_data.std(axis=0)
train_data /= std
比如上述的数据标椎化中的求std标准值，std(axis=0)代表求一行中每列特征值的对应的std标准值，比如第i列的为温度值，
那么“MAE值所乘以的”std标准值也必须为std[i]才能得出真正的平均绝对误差值。
7.对于序列学习问题，可以用联结主义时序分类（CTC，connectionist temporal classification）损失函数，等等。
8.只有在面对真正全新的研究问题时，你才需要自主开发目标函数。
>>> x = np.array([[1.0, 2.0, 3.0, 4.0, 5.0],[6.0, 7.0, 8.0, 9.0, 10.0],[11.0, 12.0, 13.0, 14.0, 15.0]])
>>> m = x.mean(axis=0) #mean(axis=0) 求每列的平均值
>>> m
array([ 6., 7., 8., 9., 10.])
>>> x -= m
>>> x
array([[-5., -5., -5., -5., -5.],
[ 0., 0., 0., 0., 0.],
[ 5., 5., 5., 5., 5.]])
>>> std = x.std(axis=0) #std(axis=0) 求每列的标准差
>>> std
array([4.0824829, 4.0824829, 4.0824829, 4.0824829, 4.0824829])
>>> x /= std
>>> x
array([[-1.22474487, -1.22474487, -1.22474487, -1.22474487, -1.22474487],
[ 0. , 0. , 0. , 0. , 0. ],
[ 1.22474487, 1.22474487, 1.22474487, 1.22474487, 1.22474487]])
>>> a = np.array([[1, 2], [3, 4]])
>>> b = np.array([[5, 6]])
>>> np.concatenate((a, b), axis=0)
array([[1, 2],
[3, 4],
[5, 6]])
>>> np.concatenate((a, b.T), axis=1)
array([[1, 2, 5],
[3, 4, 6]])
>>> np.concatenate((a, b), axis=None)
array([1, 2, 3, 4, 5, 6])
1.fit 中的 verbose 表示日志显示
verbose = 0 为不在标准输出流输出日志信息
verbose = 1 为输出进度条记录
verbose = 2 为每个epoch输出一行记录
注意：默认为 1
2.evaluate 中的 verbose
verbose = 0 为不在标准输出流输出日志信息
verbose = 1 为输出进度条记录
注意：只能取 0 和 1；默认为 1
numpy.random.randint(low, high=None, size=None, dtype='l')
1.函数的作用是，返回一个随机整型数，范围从低（包括）到高（不包括），即[low, high)。
如果没有写参数high的值，则返回[0,low)的值。
2.参数如下：
1.low: int
生成的数值最低要大于等于low。
（hign = None时，生成的数值要在[0, low)区间内）
2.high: int (可选)
如果使用这个值，则生成的数值在[low, high)区间。
3.size: int or tuple of ints(可选)
输出随机数的尺寸，比如size = (m * n* k)则输出同规模即m * n* k个随机数。默认是None的，仅仅返回满足要求的单一随机数。
4.dtype: dtype(可选)：
想要输出的格式。如int64、int等等
3.例子
>>> import numpy as np
>>> np.random.randint(0, high=2, size=(2,3))
array([[1, 1, 0],
[0, 1, 1]])
>>> np.random.randint(0, high=2, size=(2,3))
array([[0, 0, 1],
[0, 0, 1]])
>>> np.random.randint(0, high=2, size=(2,3))
array([[1, 1, 1],
[1, 0, 0]])
>>> np.random.randint(2, size=10)
array([1, 0, 0, 0, 1, 1, 0, 0, 1, 0])
>>> np.random.randint(1, size=10)
array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
>>> np.random.randint(5, size=(2, 4))
array([[4, 0, 2, 1],
[3, 2, 2, 0]])
>>>np.random.randint(2, high=10, size=(2,3))
array([[6, 8, 7],
[2, 5, 2]])
1.使用random.randint(0, high=2, size=layer_output.shape)
第三个参数size=layer_output.shape 表示创建一个形状同样为(batch_size, features)的矩阵。
batch_size表示批量大小/样本数，features表示特征列数量。
第一个和第二个参数 表示取值范围为[0,2)，即矩阵中的元素有一半几率为0或为1。
2.方案一
训练时：layer_output *= np.random.randint(0, high=2, size=layer_output.shape)
输出矩阵中大约会有一半的元素被重置为0
测试时：layer_output *= 0.5
输出矩阵中所有的值都乘以0.5，即值等于除以2，即值减一半
3.方案二
训练时：layer_output *= np.random.randint(0, high=2, size=layer_output.shape)
输出矩阵中大约会有一半的元素被重置为0
layer_output /= 0.5
输出矩阵中所有的值都除以0.5，等于非0的值乘以2
测试时：矩阵保持不变
