《TensorFlow深度学习算法原理与编程实战》

dense：全连接层
相当于添加一个层，即初学的add_layer()函数

tf.layers.dense(
inputs,
units,
activation=None,
use_bias=True,
kernel_initializer=None,
bias_initializer=tf.zeros_initializer(),
kernel_regularizer=None,
bias_regularizer=None,
activity_regularizer=None,
kernel_constraint=None,
bias_constraint=None,
trainable=True,
name=None,
reuse=None
)

inputs:该层的输入。
units: 输出的大小（维数），整数或long。
activation: 使用什么激活函数（神经网络的非线性层），默认为None，不使用激活函数。
use_bias: 使用bias为True（默认使用），不用bias改成False即可。
kernel_initializer:权重矩阵的初始化函数。 如果为None（默认值），则使用tf.get_variable使用的默认初始化程序初始化权重。
bias_initializer:bias的初始化函数。
kernel_regularizer：权重矩阵的正则函数。
bias_regularizer：bias的的正则函数。
activity_regularizer:输出的的正则函数。
kernel_constraint:由优化器更新后应用于内核的可选投影函数（例如，用于实现层权重的范数约束或值约束）。 该函数必须将未投影的变量作为输入，并且必须返回投影变量（必须具有相同的形状）。 在进行异步分布式培训时，使用约束是不安全的。
bias_constraint:由优化器更新后应用于偏差的可选投影函数。
trainable:Boolean，如果为True，还将变量添加到图集collectionGraphKeys.TRAINABLE_VARIABLES（参见tf.Variable）。
name:名字
reuse:Boolean，是否以同一名称重用前一层的权重。

先，代码引用自https://github.com/wiseodd/generative-models

感谢这位网友的代码支持。
每个月总有30天不想看论文，所以直接看源码或许是一个好办法。因为有些时候它的改动就那么一点点。而论文却要用晦涩难懂的语言证明上十几页。
上边这个链接中给出了很多GAN和VAE以及各种变体的源码，并且写得清晰易懂，再次感谢这位网友的贡献。
ConditionalGAN顾名思义是条件GAN，就是给GAN增加一个条件。具体是怎么回事呢？看代码：
这段代码使用mnist数据集，来生成手写数字。以下代码可以直接正确运行。

 

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.gridspec as gridspec
import os

mnist = input_data.read_data_sets('../../MNIST_data', one_hot=True)
mb_size = 64
Z_dim = 100
X_dim = mnist.train.images.shape[1]
y_dim = mnist.train.labels.shape[1]
h_dim = 128

def xavier_init(size):
in_dim = size[0]
xavier_stddev = 1. / tf.sqrt(in_dim / 2.)
return tf.random_normal(shape=size, stddev=xavier_stddev)

""" Discriminator Net model """
X = tf.placeholder(tf.float32, shape=[None, 784])
y = tf.placeholder(tf.float32, shape=[None, y_dim])
D_W1 = tf.Variable(xavier_init([X_dim + y_dim, h_dim]))
D_b1 = tf.Variable(tf.zeros(shape=[h_dim]))
D_W2 = tf.Variable(xavier_init([h_dim, 1]))
D_b2 = tf.Variable(tf.zeros(shape=[1]))
theta_D = [D_W1, D_W2, D_b1, D_b2]

以上与普通的GAN没有区别，从下边开始可以看到discriminator除了输入原来的x，还输入了一个y。这个y就是我们所说的condition。接下来的generator也一样，多了一个y。

def discriminator(x, y):
inputs = tf.concat(axis=1, values=[x, y])
D_h1 = tf.nn.relu(tf.matmul(inputs, D_W1) + D_b1)
D_logit = tf.matmul(D_h1, D_W2) + D_b2
D_prob = tf.nn.sigmoid(D_logit)
return D_prob, D_logit

""" Generator Net model """
Z = tf.placeholder(tf.float32, shape=[None, Z_dim])
G_W1 = tf.Variable(xavier_init([Z_dim + y_dim, h_dim]))
G_b1 = tf.Variable(tf.zeros(shape=[h_dim]))
G_W2 = tf.Variable(xavier_init([h_dim, X_dim]))
G_b2 = tf.Variable(tf.zeros(shape=[X_dim]))
theta_G = [G_W1, G_W2, G_b1, G_b2]

def generator(z, y):
inputs = tf.concat(axis=1, values=[z, y])
G_h1 = tf.nn.relu(tf.matmul(inputs, G_W1) + G_b1)
G_log_prob = tf.matmul(G_h1, G_W2) + G_b2
G_prob = tf.nn.sigmoid(G_log_prob)
return G_prob

def sample_Z(m, n):
return np.random.uniform(-1., 1., size=[m, n])

def plot(samples):
fig = plt.figure(figsize=(4, 4))
gs = gridspec.GridSpec(4, 4)
gs.update(wspace=0.05, hspace=0.05)
for i, sample in enumerate(samples):
ax = plt.subplot(gs[i])
plt.axis('off')
ax.set_xticklabels([])
ax.set_yticklabels([])
ax.set_aspect('equal')
plt.imshow(sample.reshape(28, 28), cmap='Greys_r')
return fig

G_sample = generator(Z, y)
D_real, D_logit_real = discriminator(X, y)
D_fake, D_logit_fake = discriminator(G_sample, y)
可以看出来这边的discriminator和generator都是多输入了一个条件y。

D_loss_real = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=D_logit_real, labels=tf.ones_like(D_logit_real)))
D_loss_fake = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=D_logit_fake, labels=tf.zeros_like(D_logit_fake)))
D_loss = D_loss_real + D_loss_fake
G_loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=D_logit_fake, labels=tf.ones_like(D_logit_fake)))
D_solver = tf.train.AdamOptimizer().minimize(D_loss, var_list=theta_D)
G_solver = tf.train.AdamOptimizer().minimize(G_loss, var_list=theta_G)

loss还是没有变化。

sess = tf.Session()
sess.run(tf.global_variables_initializer())
if not os.path.exists('out/'):
os.makedirs('out/')
i = 0
for it in range(1000000):
if it % 1000 == 0:
n_sample = 16
Z_sample = sample_Z(n_sample, Z_dim)
y_sample = np.zeros(shape=[n_sample, y_dim])
y_sample[:, 7] = 1
samples = sess.run(G_sample, feed_dict={Z: Z_sample, y:y_sample})
fig = plot(samples)
plt.savefig('out/{}.png'.format(str(i).zfill(3)), bbox_inches='tight')
i += 1
plt.close(fig)
X_mb, y_mb = mnist.train.next_batch(mb_size)
Z_sample = sample_Z(mb_size, Z_dim)
_, D_loss_curr = sess.run([D_solver, D_loss], feed_dict={X: X_mb, Z: Z_sample, y:y_mb})
_, G_loss_curr = sess.run([G_solver, G_loss], feed_dict={Z: Z_sample, y:y_mb})
在训练中，输入的y是输入的x所一一对应的真实标签。

在生成的过程中，我们想生成什么就输入对应的标签。

例如以上代码中我们输入的是7的标签，也就是one-hot形式的label中第7位位1，其他位为0。

if it % 1000 == 0:
print('Iter: {}'.format(it))
print('D loss: {:.4}'. format(D_loss_curr))
print('G_loss: {:.4}'.format(G_loss_curr))
print()

到这里就结束了，这么一点代码就可以生成“我想要的（也就是附加了条件的）”逼真的手写数字，是不是很简单呢？

功能：2D 卷积层
结构：

conv2d(inputs, filters, kernel_size,
strides=(1, 1),
padding='valid',
data_format='channels_last',
dilation_rate=(1, 1),
activation=None,
use_bias=True,
kernel_initializer=None,
bias_initializer=<tensorflow.python.ops.init_ops.Zeros object at 0x000002596A1FD898>,
kernel_regularizer=None,
bias_regularizer=None,
activity_regularizer=None,
kernel_constraint=None,
bias_constraint=None,
trainable=True,
name=None,
reuse=None)
参数：
inputs：Tensor 输入
filters：整数，表示输出空间的维数（即卷积过滤器的数量）
kernel_size：一个整数，或者包含了两个整数的元组/队列，表示卷积窗的高和宽。如果是一个整数，则宽高相等。
strides：一个整数，或者包含了两个整数的元组/队列，表示卷积的纵向和横向的步长。如果是一个整数，则横纵步长相等。另外， strides 不等于1 和 dilation_rate 不等于1 这两种情况不能同时存在。
padding："valid" 或者 "same"（不区分大小写）。"valid" 表示不够卷积核大小的块就丢弃，"same"表示不够卷积核大小的块就补0。 "valid" 的输出形状为"valid" 的输出形状为其中， 为输入的 size（高或宽）， 为 filter 的 size， 为 strides 的大小， 为向上取整。
data_format：channels_last 或者 channels_first，表示输入维度的排序。

dilation_rate：一个整数，或者包含了两个整数的元组/队列，表示使用扩张卷积时的扩张率。如果是一个整数，则所有方向的扩张率相等。另外， strides 不等于1 和 dilation_rate 不等于1 这两种情况不能同时存在。

activation：激活函数。如果是None则为线性函数。
use_bias：Boolean类型，表示是否使用偏差向量。
kernel_initializer：卷积核的初始化。
bias_initializer：偏差向量的初始化。如果是None，则使用默认的初始值。
kernel_regularizer：卷积核的正则项
bias_regularizer：偏差向量的正则项
activity_regularizer：输出的正则函数
kernel_constraint：映射函数，当核被Optimizer更新后应用到核上。Optimizer 用来实现对权重矩阵的范数约束或者值约束。映射函数必须将未被影射的变量作为输入，且一定输出映射后的变量（有相同的大小）。做异步的分布式训练时，使用约束可能是不安全的。
bias_constraint：映射函数，当偏差向量被Optimizer更新后应用到偏差向量上。
trainable：Boolean类型。
name：字符串，层的名字。
reuse：Boolean类型，表示是否可以重复使用具有相同名字的前一层的权重。
返回值：
输出 Tensor
异常抛出：
ValueError：if eager execution is enabled.

作用：从一个集合中取出变量

tf.get_collection(
key,
scope=None
)
该函数可以用来获取key集合中的所有元素，返回一个列表。列表的顺序依变量放入集合中的先后而定。scope为可选参数，表示的是名称空间（名称域），如果指定，就返回名称域中所有放入‘key’的变量的列表，不指定则返回所有变量。
例子

variables = tf.get_collection(tf.GraphKeys.VARIABLES)
for i in variables:
print(i)
 

功能：2D反卷积
定义：

tf.layers.conv2d_transpose(
inputs,
filters,
kernel_size,
strides=(1, 1),
padding='valid',
data_format='channels_last',
activation=None,
use_bias=True,
kernel_initializer=None,
bias_initializer=tf.zeros_initializer(),
kernel_regularizer=None,
bias_regularizer=None,
activity_regularizer=None,
kernel_constraint=None,
bias_constraint=None,
trainable=True,
name=None,
reuse=None
)
参数：

inputs：输入张量.
filters：整数,输出空间的维数(即卷积中的滤波器数).
kernel_size：一个元组或2个正整数的列表,指定过滤器的空间维度；可以是单个整数,以指定所有空间维度的相同值.
strides：一个元组或2个正整数的列表,指定卷积的步幅；可以是单个整数,以指定所有空间维度的相同值.
padding：一个"valid"或"same"(不区分大小写).
data_format：一个字符串,一个channels_last(默认)或channels_first；输入中维度的排序；channels_last对应于具有形状(batch, height, width, channels)的输入侧,而channels_first对应于具有形状(batch, channels, height, width)的输入侧.
activation：激活功能,将其设置None为保持线性激活.
use_bias：布尔值,表示该层是否使用偏差.
kernel_initializer：卷积内核的初始化程序.
bias_initializer：偏置向量的初始化器；如果为None,将使用默认初始值设定项.
kernel_regularizer：卷积内核的可选正则化程序.
bias_regularizer：偏置矢量的可选正则化程序.
activity_regularizer：输出的可选正则化函数.
kernel_constraint：由一个Optimizer更新后应用于内核的可选投影函数(例如,用于实现层权重的范数约束或值约束),该函数必须将未投影的变量作为输入,并且必须返回投影变量(必须具有相同的形状).在进行异步分布式培训时,使用约束是不安全的.
bias_constraint：由一个Optimizer更新后应用于偏差的可选投影函数.
trainable：布尔值,如果为True,还将变量添加到图产品集合GraphKeys.TRAINABLE_VARIABLES中.
name：字符串,图层的名称.
reuse：布尔值,是否以同一名称重用前一层的权重.

返回：
输出张量.
可能引发的异常：

ValueError：如果启用了eager执行.

功能：层的批量标准化
定义：

tf.layers.batch_normalization(
inputs,
axis=-1,
momentum=0.99,
epsilon=0.001,
center=True,
scale=True,
beta_initializer=tf.zeros_initializer(),
gamma_initializer=tf.ones_initializer(),
moving_mean_initializer=tf.zeros_initializer(),
moving_variance_initializer=tf.ones_initializer(),
beta_regularizer=None,
gamma_regularizer=None,
beta_constraint=None,
gamma_constraint=None,
training=False,
trainable=True,
name=None,
reuse=None,
renorm=False,
renorm_clipping=None,
renorm_momentum=0.99,
fused=None,
virtual_batch_size=None,
adjustment=None
)
参数：

inputs：张量输入.
axis：一个int,应该是规范化的轴(通常是特征轴)；例如,在使用data_format="channels_first"的Convolution2D图层之后,在BatchNormalization中设置axis=1为.
momentum：移动平均线的动量.
epsilon：小浮点数添加到方差以避免除以零.
center：如果为True,则添加beta到规范化张量的偏移量；如果为False,则忽略beta.
scale：如果为True,则乘以gamma；如果为False,则不使用gamma.当下一层是线性的(例如,nn.relu)时,这可以被禁用,因为缩放可以由下一层完成.
beta_initializer：beta权重的初始化程序.
gamma_initializer：gamma权重的初始化程序.
moving_mean_initializer：移动平均值的初始化程序.
moving_variance_initializer：移动方差的初始化程序.
beta_regularizer：β权量的可选正规化器.
gamma_regularizer：gamma权重的可选正规化器.
beta_constraint：由Optimizer更新后应用于beta权重的可选投影函数(例如,用于实现层权重的范数约束或值约束).该函数必须将未投影的变量作为输入,并且必须返回投影变量(必须具有相同的形状).在进行异步分布式培训时,使用约束是不安全的.
gamma_constraint：由Optimizer更新后应用于gamma权量的可选投影功能.
training：可以是Python布尔值或TensorFlow布尔标量张量(例如,占位符)；表示是否在训练模式下返回输出(使用当前批次的统计数据进行规范化)或在推理模式下(使用移动统计数据规范化)；注意：确保正确设置此参数,否则您的训练/推理将无法正常工作.
trainable：Boolean,如果为True,也会将变量添加到图集合GraphKeys.TRAINABLE_VARIABLES中(请参阅tf.Variable).
name：String,图层的名称.
reuse：Boolean,是否以同一名称重用前一层的权重.
renorm：是否使用批量重整化(https://arxiv.org/abs/1702.03275).这会在培训期间增加额外的变量 对于此参数的任一值,推断都是相同的.
renorm_clipping：一个字典,可以将键'rmax','rmin','dmax'映射到用于剪辑重新校正的Tensors标量.校正(r, d)被用作corrected_value = normalized_value * r + d,以r限幅为[RMIN,RMAX],和d为[-dmax,DMAX]；丢失的rmax,rmin,dmax分别设定为inf,0,inf.
renorm_momentum：动量被用于更新移动平均值和标准偏差,使用renorm；不同于momentum,这会影响训练,既不会太小(会增加噪音)也不会太大(这会产生过时的估计)；请注意,momentum仍然应用于获取推理的均值和方差.
fused：如果为None或者True,则使用更快、更融合的实现；如果为False,请使用系统推荐的实现.
virtual_batch_size：一个int,默认情况下,virtual_batch_size是None,这表示在整个批次中执行批量规范化；如果virtual_batch_size不是None,则执行“Ghost Batch Normalization”,创建虚拟子批次,每个子批次分别进行规范化(具有共享的gamma,beta和移动统计数据)；必须在执行期间划分实际批量大小.
adjustment：一个函数,它包含输入张量(动态)形状的Tensor,并返回一对(scale, bias)以应用于规范化值(在gamma和β之前),仅在训练期间.例如,如果axis == - 1,adjustment = lambda shape: ( tf.random_uniform(shape[-1:], 0.93, 1.07), tf.random_uniform(shape[-1:], -0.1, 0.1))则将规范化值向上或向下缩放7％,然后将结果移动到最多0.1(对每个特征进行独立缩放和偏移,但在所有示例中共享),最后应用gamma或beta；如果为None,不应用调整；如果指定了virtual_batch_size,则无法指定.

返回：
输出张量.
可能引发的异常：

ValueError：如果启用了急切(eager)执行.

tf.convert_to_tensor()
功能：
将python的数据类型转换成TensorFlow可用的tensor数据类型。

它接受张量对象、数字数组、Python列表和Python标量。
函数形式：

tf.convert_to_tensor(
value,
dtype=None,
name=None,
preferred_dtype=None
)
参数：
value：类型具有注册张量转换函数的对象。
dtype：返回张量的可选元素类型。如果缺少，则从值的类型推断类型。
name：创建新张量时使用的可选名称。
preferred_dtype：返回张量的可选元素类型，当dtype为None时使用。在某些情况下，调用者在转换为张量时可能没有考虑到dtype，因此dtype_hint可以用作软首选项。如果不能转换为dtype_hint，则此参数没有效果。

公式：
min max V(D,G) = Ex~pdata(x)[log D(x)] + Ez~pz(z)[log(1 - D(G(z)))]

  G      D  

TensorFlow中和RNN相关的API主要位于两个package:

tf.nn.rnn_cell(主要定义RNN的常见的几种细胞cell Dropout操作)、

tf.nn(RNN相关的计算执行操作)

# rnn api
# tf.nn.rnn_cell. 下面放了很多类型的cell
# tf.nn. 辅助的rnn的计算工具
# RNN的中的细胞Cell（BasicRNNCell RNNCell BasicLSTMCell LSTMCell GRUCell MultiRNNCell）
# tf.nn.rnn_cell.BasicRNNCell()
# tf.nn.rnn_cell.RNNCell()
#
# tf.nn.rnn_cell.BasicLSTMCell() LSTM
# tf.nn.rnn_cell.LSTMCell()
#
# tf.nn.rnn_cell.GRUCell() GRU
#
# tf.nn.rnn_cell.MultiRNNCell() 多层RNN
#
# tf.nn.rnn_cell.DropoutWrapper()
#
# tf.nn.dynamic_rnn() 动态RNN
# tf.nn.bidirectional_dynamic_rnn() 动态双向RNN
 

矩阵各个对应元素相乘, 这个时候要求两个矩阵必须同样大小。
代码：

import tensorflow as tf
a = tf.constant([[1, 3, 5],
[7, 9, 11]])
b = tf.constant([[2, 4, 6],
[8, 10, 12]])
c = tf.constant([[2, 4],
[6, 8],
[10, 12]])
# 矩阵乘法
e = tf.matmul(a, c)
# 矩阵点乘
f = tf.multiply(a, b)
g = a * b
with tf.Session() as sess:
e_val, f_val, g_val = sess.run(fetches=[e, f, g])
print("e=", e_val)
print("f=", f_val)
print("g=", g_val)
结果：

e= [[ 70 88]
[178 232]]
f= [[ 2 12 30]
[ 56 90 132]]
g= [[ 2 12 30]
[ 56 90 132]]
 

水平合并: np.hstack()

垂直合并: np.vstack()
代码： 

import numpy as np
a = np.array([[1, 2, 3],
[4, 5, 6]])
b = np.array([[11, 12, 13],
[14, 15, 16]])
# 水平合并（horizontal 水平的）
c = np.hstack([a, b])
# 垂直合并 vertical 垂直的
d = np.vstack([a, b])
print("a=", a)
print("b=", b)
print("c=", c)
print("d=", d)
结果：

a= [[1 2 3]
[4 5 6]]
b= [[11 12 13]
[14 15 16]]
c= [[ 1 2 3 11 12 13]
[ 4 5 6 14 15 16]]
d= [[ 1 2 3]
[ 4 5 6]
[11 12 13]
[14 15 16]]
 

对于某个事件，有n种可能性，每一种可能性都有一个概率p(xi)
这样就可以计算出某一种可能性的信息量。举一个例子，假设你拿出了你的电脑，按下开关，会有三种可能性，下表列出了每一种可能的概率及其对应的信息量



序号
事件
概率p
信息量I




A
电脑正常开机
0.7
-log(p(A))=0.36


B
电脑无法开机
0.2
-log(p(B))=1.61


C
电脑爆炸了
0.1
-log(p(C))=2.30



注：文中的对数均为自然对数
 
我们现在有了信息量的定义，而熵用来表示所有信息量的期望，即：
H(X)=−∑i=1np(xi)log(p(xi))
 
其中n代表所有的n种可能性，所以上面的问题结果就是
H(X)===−[p(A)log(p(A))+p(B)log(p(B))+p(C))log(p(C))]0.7×0.36+0.2×1.61+0.1×2.300.804
 
然而有一类比较特殊的问题，比如投掷硬币只有两种可能，字朝上或花朝上。买彩票只有两种可能，中奖或不中奖。我们称之为0-1分布问题（二项分布的特例），对于这类问题，熵的计算方法可以简化为如下算式：
H(X)==−∑i=1np(xi)log(p(xi))−p(x)log(p(x))−(1−p(x))log(1−p(x))
 

假设我们听到了两件事，分别如下：

事件A：巴西队进入了2018世界杯决赛圈。

事件B：中国队进入了2018世界杯决赛圈。

仅凭直觉来说，显而易见事件B的信息量比事件A的信息量要大。究其原因，是因为事件A发生的概率很大，事件B发生的概率很小。所以当越不可能的事件发生了，我们获取到的信息量就越大。越可能发生的事件发生了，我们获取到的信息量就越小。那么信息量应该和事件发生的概率有关。
假设X
是一个离散型随机变量，其取值集合为χ,概率分布函数p(x)=Pr(X=x),x∈χ,则定义事件X=x0
的信息量为：
I(x0)=−log(p(x0))
由于是概率所以p(x0)的取值范围是[0,1],绘制为图形如下：




可见该函数符合我们对信息量的直觉

Xt：n维向量，t时刻的输入

Ht：时刻t隐神经元对于线性转换值

St：时刻t的隐藏状态

Ot：时刻t的输出

U：输入层到隐藏层之间的权重

W：隐藏层之间的权重，是网络的记忆控制者，负责调度记忆。（当前样本与上一个样本隐藏层之间的权重）

V：隐藏层到输出层之间的权重

第一步：导入数据

第二步：设置超参并定义学习率调整策略

第三步：开始构建模型 设置输入数据的占位符

第四步：构建VGG Net网络（直接将网络结构翻译成为这个代码）

第五步：构建模型的损失函数

第六步：构建梯度下降的优化方法（一般用Adam 动量GD）

第七步：计算模型正确率

第八步：会话中执行阶段（模型的训练与迭代）

卷积层特征图矩阵尺寸 = （[前层矩阵尺寸] + 2 × [填充像素] - [窗口尺寸] + [步长]）/ [步长]
 

数据输入层：Input Layer

功能：对输入的数据进行预处理

预处理方式：去均值、归一化、PCA/白化


卷积计算层：CONV Layer

功能：进行滑动局部感知，按每个通道、每个过滤器进行卷积。

参数：窗口大小、滑动步长、过滤器（N*(W+B)）、深度（通道）


ReLU激励层：ReLU Incentive Layer

功能：对卷积层的输出结果做一次非线性映射（激活）

常用非线性映射函数：Sigmoid、Tanh、ReLU、Leaky ReLU、ELU、Maxout


池化层：Pooling Layer

功能：通过逐步减小表特征的空间尺寸来减小参数量和网络中的计算。

策略：最大池化、平均池化


全连接层：FC Layer

功能：在尾部用于输出


备注：Batch Normalization Layer

功能：对神经元的输出进行一下修正

方法
类型
说明




cv2.resize()
变换
调整图像尺寸


cv2.pyrDown()
变换
高斯金字塔向上缩小单层采样


cv2.pyrUp()
变换
高斯金字塔向下放大单层采样


cv2.buildOpticalFlowPyramid()
变换
高斯金字塔多层次采样


cv2.getAffineTransform()
变换
计算仿射映射矩阵


cv2.getRotationMatrix2D()
变换
计算2D旋转的仿射矩阵


cv2.warpAffine()
变换
密集仿射变幻

数据采集

数据清洗

特征工程

建模

测试（loss）

上线

判断
相等：tf.equal()

小于等于：tf.less_equal()

条件赋值：tf.where()

取最大值：tf.maximum()
数学
加法：tf.add()

减法：tf.subtract()

平方：tf.square()

正态分布随机数：tf.random_normal()

截断正态分布随机数：tf.truncated_normal()

生成具有均匀分布的张量的初始化器：tf.random_uniform_initializer()

计算张量 x、y 对应元素差平方：tf.squared_difference()

张量赋值：tf.assign()
赋值运算
创建所有元素都为1的张量：tf.ones()

将tensor对象放入同一个集合：tf.add_to_collection()

将list中的数值相加：tf.add_n()
类型
数据类型转换：tf.cast()

将数据类型转换成可用的tensor类型:tf.convert_to_tensor()
控制
控制依赖：tf.control_dependencies

什么都不做：tf.no_op()
矩阵
矩阵常量：tf.constant()

矩阵乘法：tf.matmul()

矩阵点乘：tf.multply()

连接矩阵：tf.concat()

展平操作：tf.layers.flatten()

张量切割：tf.split()
统计
聚合均值：tf.reduce_mean()

求指定维度上的均值：tf.reduce_sum()

按维度计算最大值的下标：tf.argmax()
构图
创建变量层管理器：tf.variable_scope()

创建占位符号：tf.placeholder()
初始化
均匀分布初始化：tf.uniform_unit_scaling_initializer
训练
普通梯度下降优化：tf.train.AdamOptimizer()

梯度下降优化：tf.train.GradientDescentOptimizer()

Adadelta算法梯度下降优化：tf.train.AdadeltaOptimizer()

分类训练：tf.nn.softmax()

分类训练：tf.nn.softmax_cross_entropy_with_logits()

全连接层处理：tf.layers.dense()

Dropout：tf.layers.dropout()

测量离散分类任务中的概率误差：tf.nn.sparse_softmax_cross_entropy_with_logits

返回所有需要训练的变量：tf.trainable_variables()

梯度裁剪：tf.clip_by_global_norm()

梯度：tf.gradients()

定义超参：tf.contrib.training.HParams()

创建RMSProp算法优化器：tf.train.RMSPropOptimizer()

层的批量标准化：tf.layers.batch_normalization()

Relu激活函数：tf.nn.relu()

2D卷积：tf.layers.conv2d()

2D反卷积：tf.layers.conv2d_transpose()

从集合中取出变量：tf.get_collection()
CNN
计算张量的2-D卷积：tf.nn.conv2d()

添加偏值项：tf.nn.bias_add()

最大池化：tf.nn.max_pool()
RNN
选取一个张量里面索引对应的元素：tf.nn.embedding_lookup()

LSTM细胞：tf.nn.rnn_cell.BasicLSTMCell()

LSTM细胞：tf.nn.rnn_cell.LSTMCell()

GRU细胞：tf.nn.rnn_cell.GRUCell()

DropoutWrappert：tf.nn.rnn_cell.DropoutWrapper()

RNNCell合并：tf.nn.rnn_cell.MultiRNNCell()

创建RNNCell指定的递归神经网络：tf.nn.dynamic_rnn()
文件目录
文件读取：tf.io.read_file()

文件或目录是否存在：tf.gfile.Exists()

创建目录：tf.gfile.MakeDirs()
图像
通用图像文件解码：tf.image.decode_image()

JPG图像文件解码：tf.image.decode_jpeg()

PNG图像文件解码：tf.image.decode_png()

图像尺寸调整：tf.image.resize()

图像剪切：tf.image.resize_with_crop_or_pad()

图像等比例裁剪：tf.image.central_crop()

图像填充：tf.image.pad_to_bounding_box()

图像指定位置裁剪：tf.image.crop_to_bounding_box()

图像90度旋转：tf.image.rot90()

图像左右翻转：tf.image.flip_left_right()

图像上下翻转：tf.image.flip_up_down()

图像转置：tf.image.transpose()

图像数值类型转换：tf.image.convert_image_dtype()

将像从RGB转换为HSV：tf.image.rgb_to_hsv()

将像从HSV转换为RGB：tf.image.hsv_to_rgb()

将像从RGB转换为GRAY灰度：tf.image.rgb_to_grayscale()

调整图像亮度：tf.image.adjust_brightness()

调整图像色调：tf.image.adjust_hue()

调整图像颜色饱和度：tf.image.adjust_saturation()

调整图像对比度：tf.image.adjust_contrast()

调整图像Gamma系数：tf.image.adjust_gamma()

图像归一化：tf.image.per_image_standardization()

绘制图表了解一个列中值的分布

import pandas as pd
import matplotlib.pyplot as plt
california_housing_dataframe = pd.read_csv("https://download.mlcc.google.cn/mledu-datasets/california_housing_train.csv", sep=",")
california_housing_dataframe.hist('median_house_value')
plt.show()
结果
 

显示 DataFrame 的前几个记录

california_housing_dataframe.head(8)

结果：

   longitude  latitude  ...  median_income  median_house_value

0    -114.31     34.19  ...         1.4936             66900.0

1    -114.47     34.40  ...         1.8200             80100.0

2    -114.56     33.69  ...         1.6509             85700.0

3    -114.57     33.64  ...         3.1917             73400.0

4    -114.57     33.57  ...         1.9250             65500.0

5    -114.58     33.63  ...         3.3438             74000.0

6    -114.58     33.61  ...         2.6768             82400.0

7    -114.59     34.83  ...         1.7083             48500.0
[8 rows x 9 columns]

显示关于 DataFrame 的统计信息。
california_housing_dataframe.describe()
结果：

          longitude      latitude  ...  median_income  median_house_value

count  17000.000000  17000.000000  ...   17000.000000        17000.000000

mean    -119.562108     35.625225  ...       3.883578       207300.912353

std        2.005166      2.137340  ...       1.908157       115983.764387

min     -124.350000     32.540000  ...       0.499900        14999.000000

25%     -121.790000     33.930000  ...       2.566375       119400.000000

50%     -118.490000     34.250000  ...       3.544600       180400.000000

75%     -118.000000     37.720000  ...       4.767000       265000.000000

max     -114.310000     41.950000  ...      15.000100       500001.000000
[8 rows x 9 columns]

将 CSV 数据导入 pandas 库的 DataFrame
california_housing_dataframe = pd.read_csv("https://download.mlcc.google.cn/mledu-datasets/california_housing_train.csv", sep=",")

Series，它是单一列。DataFrame 中包含一个或多个 Series，每个 Series 均有一个名称。
创建 Series 的一种方法是构建 Series 对象。例如：
pd.Series(['San Francisco', 'San Jose', 'Sacramento'])

DataFrame，您可以将它想象成一个关系型数据表格，其中包含多个行和已命名的列。
您可以将映射 string 列名称的 dict 传递到它们各自的 Series，从而创建DataFrame对象。如果 Series 在长度上不一致，系统会用特殊的 NA/NaN 值填充缺失的值。例如：

 

city_names = pd.Series(['San Francisco', 'San Jose', 'Sacramento'])

population = pd.Series([852469, 1015785, 485199])
pd.DataFrame({ 'City name': city_names, 'Population': population })

pandas 是一种列存数据分析 API。它是用于处理和分析输入数据的强大工具，很多机器学习框架都支持将 pandas 数据结构作为输入。 虽然全方位介绍 pandas API 会占据很长篇幅，但它的核心概念非常简单，我们会在下文中进行说明。有关更完整的参考，请访问 pandas 文档网站，其中包含丰富的文档和教程资源。

学习率（Learning Rate）就相当与对输入所做的一个微小变化，定义每次参数更新的幅度。

顾名思义，梯度下降法的计算过程就是沿梯度下降的方向求解极小值（也可以沿梯度上升方向求解极大值）。

法国数学家，阿德里安-馬里·勒讓德（1752－1833，这个头像有点抽象）提出让总的误差的平方最小的y 就是真值，这是基于，如果误差是随机的，应该围绕真值上下波动。

伯努利分布（英语：Bernoulli distribution，又名两点分布或者0-1分布，是一个离散型概率分布，为纪念瑞士科学家雅各布·伯努利而命名。)若伯努利试验成功，则伯努利随机变量取值为1。若伯努利试验失败，则伯努利随机变量取值为0。

softmax逻辑回归模型是logistic回归模型在多分类问题上的推广，在多分类问题中，类标签y可以取两个以上的值。 Softmax回归模型对于诸如MNIST手写数字分类等问题是很有用的，该问题的目的是辨识10个不同的单个数字。

sigmoid函数也叫Logistic函数，用于隐层神经元输出，取值范围为(0,1)，它可以将一个实数映射到(0,1)的区间，可以用来做二分类。在特征相差比较复杂或是相差不是特别大时效果比较好。Sigmoid作为激活函数有以下优缺点：

优点：平滑、易于求导。

缺点：激活函数计算量大，反向传播求误差梯度时，求导涉及除法；反向传播时，很容易就会出现梯度消失的情况，从而无法完成深层网络的训练。

将每个神经元的输出通过一个非线性函数，那么整个神经网络的模型也就不再是线性的了。这个非线性的函数我们通常会称为“激活函数 Activation Functiion”。

损失函数或成本函数是指一种将一个事件（在一个样本空间中的一个元素）映射到一个表达与其事件相关的经济成本或机会成本的实数上的一种函数，借此直观表示的一些"成本"与事件的关联。

反向传播（英语：Backpropagation，缩写为BP）是“误差反向传播”的简称，是一种与最优化方法（如梯度下降法）结合使用的，用来训练人工神经网络的常见方法。该方法对网络中所有权重计算损失函数的梯度。这个梯度会反馈给最优化方法，用来更新权值以最小化损失函数。
反向传播要求有对每个输入值想得到的已知输出，来计算损失函数梯度。因此，它通常被认为是一种监督式学习方法，虽然它也用在一些无监督网络（如自动编码器）中。它是多层前馈网络的Delta规则的推广，可以用链式法则对每层迭代计算梯度。反向传播要求人工神经元（或“节点”）的激励函数可微。

特征向量（Feature Vector）是用于描述实体的所有数字的组合。

深度前馈网络（deep feedforward network），也叫作前馈神经网络（feedforward neural network）或者多层感知机（multilayer perceptron，MLP）。对深度前馈网络的理解，从感知机的角度可能更易。感知机又被成为最简单的神经网络，顾名思义，多层感知机就是在感知机的基础上设计添加了更多层。

zeros(shape,dtype,name)    #产生全0的数组
#tf.zeros([2,3],int32) => [[0,0,0],[0,0,0]]
ones(shape,dtype,name)    #产生全1的数组
#tf.ones([2,3],int32) => [[1,1,1],[1,1,1]]
fill(dims,value,name)    #产生一个值为给定数字的数组
#tf.fill([2,3],4) => [[4,4,4],[4,4,4]]
constant(value,dtype,shape,name,verify_shape)    #产生一个给定值的数组
#tf.constant([1,2,3]) => [1,2,3]

#正态分布
random_normal(shape,mean,stddev,dtype,send,name)
参数：形状、平均值、标准差、数值类型、随机种子、名称
#正态分布，但如果随机出来的值偏离平均值超过2个标准差，那么这个数将被重新随机
truncated_normal(shape,mean,stddev,dtype,send,name)   
参数：形状、平均值、标准差、数值类型、随机种子、名称
#平均分布
random_uniform(shape,minval,maxval,dtype,send,name)   
参数：形状、最小值、最大值、数值类型、随机种子、名称
#Gamma分布
random_gamma(shape,alpha,bate,dtype,send,name)   
参数：形状、形状类型 alplha、尺度参数 bate、数值类型、随机种子、名称

整数型：
tf.int8、tf.int16、tf.int32、tf.int64、uint8
实数型：
tf.float32、tf.float64
布尔型：
tf.bool
复数型：
tf.complex64、tf.complex128

由于张量加法和矩阵乘法均对运算数施加了限制条件，TensorFlow 编程者需要频繁改变张量的形状。
您可以使用 tf.reshape 方法改变张量的形状。
例如，您可以将 8x2 张量变形为 2x8 张量或 4x4 张量：

在线性代数中，当两个矩阵相乘时，第一个矩阵的列数必须等于第二个矩阵的行数。
tf.matmul(x, y)

TensorFlow 支持广播（一种借鉴自 NumPy 的概念）。利用广播，元素级运算中的较小数组会增大到与较大数组具有相同的形状。

可以先创建变量，然后再如下所示地分配一个值（注意：您始终需要指定一个默认值）：
y = tf.Variable([0]) y = y.assign([5])

创建变量：
y = tf.Variable([5])

要定义常量，请使用 tf.constant 指令，并传入它的值。例如：
x = tf.constant([5.2])

TensorFlow 图（也称为计算图或数据流图）是一种图数据结构。很多 TensorFlow 程序由单个图构成，但是 TensorFlow 程序可以选择创建多个图。图的节点是指令；图的边是张量。张量流经图，在每个节点由一个指令操控。一个指令的输出张量通常会变成后续指令的输入张量。TensorFlow 会实现延迟执行模型，意味着系统仅会根据相关节点的需求在需要时计算节点。

TensorFlow 指令会创建、销毁和操控张量。典型 TensorFlow 程序中的大多数代码行都是指令。

矩阵是二维数组（二阶张量）。例如，[[3.1, 8.2, 5.9][4.3, -2.7, 6.5]]

矢量是一维数组（一阶张量）。例如，[2, 3, 5, 7, 11] 或 [5]

标量是零维数组（零阶张量）。例如，'Howdy' 或 5

TensorFlow 的名称源自张量，张量是任意维度的数组。借助 TensorFlow，您可以操控具有大量维度的张量。

pandas 是一种列存数据分析 API。它是用于处理和分析输入数据的强大工具，很多机器学习框架都支持将 pandas 数据结构作为输入。

人工神经网络（英语：Artificial Neural Network，ANN），简称神经网络（Neural Network，NN）或类神经网络，在机器学习和认知科学领域，是一种模仿生物神经网络（动物的中枢神经系统，特别是大脑）的结构和功能的数学模型或计算模型，用于对函数进行估计或近似。神经网络由大量的人工神经元联结进行计算。大多数情况下人工神经网络能在外界信息的基础上改变内部结构，是一种自适应系统，通俗的讲就是具备学习功能。现代神经网络是一种非线性统计性数据建模工神经网络通常是通过一个基于数学统计学类型的学习方法（Learning Method）得以优化，所以也是数学统计学方法的一种实际应用，通过统计学的标准数学方法我们能够得到大量的可以用函数来表达的局部结构空间，另一方面在人工智能学的人工感知领域，我们通过数学统计学的应用可以来做人工感知方面的决定问题（也就是说通过统计学的方法，人工神经网络能够类似人一样具有简单的决定能力和简单的判断能力），这种方法比起正式的逻辑学推理演算更具有优势。

深度学习（英语：deep learning）是机器学习的分支，是一种以人工神经网络为架构，对数据进行表征学习的算法。
深度学习是机器学习中一种基于对数据进行表征学习的算法。观测值（例如一幅图像）可以使用多种方式来表示，如每个像素强度值的向量，或者更抽象地表示成一系列边、特定形状的区域等。而使用某些特定的表示方法更容易从实例中学习任务（例如，人脸识别或面部表情识别）。深度学习的好处是用非监督式或半监督式的特征学习和分层特征提取高效算法来替代手工获取特征。

无监督学习（英语：Unsupervised learning）是机器学习的一种方法，没有给定事先标记过的训练示例，自动对输入的数据进行分类或分群。无监督学习的主要运用包含：分群(Cluster Analysis)、关系规则(Association Rule)、维度缩减(Dimensionality Reduce)。它是监督式学习和强化学习等策略之外的一种选择。
一个常见的无监督学习是数据聚类。在人工神经网络中，生成对抗网络（GAN）、自组织映射（SOM）和适应性共振理论（ART）则是最常用的非监督式学习。

监督式学习（英语：Supervised learning），是机器学习的一种方法，可以由训练资料中学到或建立一个模式（函数 / learning model），并依此模式推测新的实例。训练资料是由输入物件（通常是向量）和预期输出所组成。函数的输出可以是一个连续的值（称为回归分析），或是预测一个分类标签（称作分类）。

机器学习是人工智能的一个分支。人工智能的研究历史有着一条从以“推理”为重点，到以“知识”为重点，再到以“学习”为重点的自然、清晰的脉络。显然，机器学习是实现人工智能的一个途径，即以机器学习为手段解决人工智能中的问题。机器学习在近30多年已发展为一门多领域交叉学科，涉及概率论、统计学、逼近论、凸分析、计算复杂性理论等多门学科。机器学习理论主要是设计和分析一些让计算机可以自动“学习”的算法。机器学习算法是一类从数据中自动分析获得规律，并利用规律对未知数据进行预测的算法。因为学习算法中涉及了大量的统计学理论，机器学习与推断统计学联系尤为密切，也被称为统计学习理论。算法设计方面，机器学习理论关注可以实现的，行之有效的学习算法。很多推论问题属于无程序可循难度，所以部分的机器学习研究是开发容易处理的近似算法。