TensorFlow中的优化算法

API

class AdadeltaOptimizer：实现Adadelta算法的优化器。

class AdagradDAOptimizer：用于稀疏线性模型的Adagrad Dual Averaging算法。

class AdagradOptimizer：实现Adagrad算法的优化器。

class AdamOptimizer：实现Adam算法的优化器。

class BytesList

class Checkpoint：组检查可检查对象，保存和恢复它们。

class CheckpointSaverHook：每N步或秒保存检查点。

class CheckpointSaverListener：在检查点保存之前或之后执行操作的侦听器的接口。

class ChiefSessionCreator：为一个酋长创建一个tf.Session。

class ClusterDef

class ClusterSpec：将群集表示为一组“任务”，组织为“作业”。

class Coordinator：线程协调员。

class Example

class ExponentialMovingAverage：通过使用指数衰减维持变量的移动平均值。

class Feature

class FeatureList

class FeatureLists

class Features

class FeedFnHook：运行feed_fn并相应地设置feed_dict。

class FinalOpsHook：一个Tensors在会话结束时评估的钩子。

class FloatList

class FtrlOptimizer：实现FTRL算法的优化器。

class GlobalStepWaiterHook：延迟执行直到全局步骤到达wait_until_step。

class GradientDescentOptimizer：优化器，实现梯度下降算法。

class Int64List

class JobDef

class LoggingTensorHook：每N个本地步骤，每N秒或结束打印给定的张量。

class LooperThread：重复运行代码的线程，可选择在计时器上运行。

class MomentumOptimizer：实现Momentum算法的优化器。

class MonitoredSession：类似会话的对象，用于处理初始化，恢复和挂钩。

class NanLossDuringTrainingError

class NanTensorHook：如果损失是NaN，监控损失张量并停止训练。

class Optimizer：优化器的基类。

class ProfilerHook：每N步或秒捕获CPU / GPU分析信息。

class ProximalAdagradOptimizer：优化器，实现Proximal Adagrad算法。

class ProximalGradientDescentOptimizer：优化器，实现近端梯度下降算法。

class QueueRunner：保存队列的入队操作列表，每个队列都在一个线程中运行。

class RMSPropOptimizer：实现RMSProp算法的优化器。

class Saver：保存和恢复变量。

class SaverDef

class Scaffold：用于创建或收集训练模型通常所需的部分的结构。

class SecondOrStepTimer：定时器每N秒触发一次或每N步触发一次。

class SequenceExample

class Server：进程内TensorFlow服务器，用于分布式培训。

class ServerDef

class SessionCreator：tf.Session的工厂。

class SessionManager：从检查点恢复并创建会话的培训助手。

class SessionRunArgs：表示要添加到Session.run()调用的参数。

class SessionRunContext：提供有关session.run()正在进行的呼叫的信息。

class SessionRunHook：挂钩以扩展对MonitoredSession.run（）的调用。

class SessionRunValues：包含结果Session.run()。

class SingularMonitoredSession：类似会话的对象，用于处理初始化，恢复和挂钩。

class StepCounterHook：钩子计算每秒的步数。

class StopAtStepHook：钩子请求在指定的步骤停止。

class SummarySaverHook：每N步保存摘要。

class Supervisor：检查点建模和计算摘要的培训助手。

class SyncReplicasOptimizer：要同步的类，聚合渐变并将它们传递给优化器。

class VocabInfo：热门启动的词汇信息。

class WorkerSessionCreator：为worker创建一个tf.Session。

功能

MonitoredTrainingSession(...)：创建一个MonitoredSession培训。

NewCheckpointReader(...)

add_queue_runner(...)：QueueRunner在图表中添加一个集合。（废弃）

assert_global_step(...)：Asserts global_step_tensor是一个标量int Variable或Tensor。

basic_train_loop(...)：训练模型的基本循环。

batch(...)：创建批量的张量tensors。（废弃）

batch_join(...)：运行张量列表以填充队列以创建批量示例。（废弃）

checkpoint_exists(...)：检查V1或V2检查点是否存在指定的前缀。

confusion_matrix(...)：从预测和标签计算混淆矩阵。

cosine_decay(...)：将余弦衰减应用于学习率。

cosine_decay_restarts(...)：应用余弦衰减并重新启动学习率。

create_global_step(...)：在图形中创建全局步长张量。

do_quantize_training_on_graphdef(...)：正在开发一种通用的量化方案tf.contrib.quantize。（废弃）

exponential_decay(...)：将指数衰减应用于学习率。

export_meta_graph(...)：返回MetaGraphDef原型。可选择将其写入filename。

generate_checkpoint_state_proto(...)：生成检查点状态原型。

get_checkpoint_mtimes(...)：返回检查点的mtimes（修改时间戳）。

get_checkpoint_state(...)：从“检查点”文件返回CheckpointState proto。

get_global_step(...)：获得全局步长张量。

get_or_create_global_step(...)：返回并创建（如果需要）全局步长张量。

global_step(...)：帮助全球迈出的小帮手。

import_meta_graph(...)：重新创建保存在MetaGraphDefproto中的Graph 。

init_from_checkpoint(...)：使用从给定检查点加载的张量初始化当前变量。

input_producer(...)：将输出input_tensor管道的行输出到队列。（废弃）

inverse_time_decay(...)：将反时限衰减应用于初始学习速率。

latest_checkpoint(...)：查找最新保存的检查点文件的文件名。

limit_epochs(...)：返回张量num_epochs时间然后引发OutOfRange错误。（废弃）

linear_cosine_decay(...)：将线性余弦衰减应用于学习速率。

list_variables(...)：返回检查点中所有变量的列表。

load_checkpoint(...)：CheckpointReader找到的检查点的返回值ckpt_dir_or_file。

load_variable(...)：返回检查点中给定变量的张量值。

match_filenames_once(...)：保存匹配模式的文件列表，因此只计算一次。

maybe_batch(...)：有条件地创建基于的批量张量keep_input。（废弃）

maybe_batch_join(...)：运行张量列表以有条件地填充队列以创建批次。（废弃）

maybe_shuffle_batch(...)：通过随机改组条件排列的张量来创建批次。（废弃）

maybe_shuffle_batch_join(...)：通过随机改组条件排列的张量来创建批次。（废弃）

natural_exp_decay(...)：将自然指数衰减应用于初始学习率。

noisy_linear_cosine_decay(...)：将嘈杂的线性余弦衰减应用于学习速率。

piecewise_constant(...)：来自边界和间隔值的分段常数。

polynomial_decay(...)：将多项式衰减应用于学习速率。

range_input_producer(...)：生成队列中从0到限制1的整数。（废弃）

remove_checkpoint(...)：删除给定的检查点checkpoint_prefix。

replica_device_setter(...)：返回a device function以在为副本构建Graph时使用。

sdca_fprint(...)：计算输入字符串的指纹。

sdca_optimizer(...)：分布式版本的随机双坐标上升（SDCA）优化器

sdca_shrink_l1(...)：对参数应用L1正则化收缩步骤。

shuffle_batch(...)：通过随机填充张量创建批次。（废弃）

shuffle_batch_join(...)：通过随机填充张量创建批次。（废弃）

slice_input_producer(...)：产生每一个切片Tensor在tensor_list。（废弃）

start_queue_runners(...)：启动图中收集的所有队列运行程序。（废弃）

string_input_producer(...)：将字符串（例如文件名）输出到输入管道的队列。（废弃）

summary_iterator(...)：用于Event从事件文件中读取协议缓冲区的迭代器。

update_checkpoint_state(...)：更新“检查点”文件的内容。

warm_start(...)：使用给定的设置暖启动模型。

write_graph(...)：将图形原型写入文件。

Stochastic Gradient Descent（SGD）

最基础的方法就是GD了，将整个数据集放入模型中，不断的迭代得到模型的参数，当然这样的方法计算资源占用的比较大，那么有没有什么好的解决方法呢？就是把整个数据集分成小批(mini-batch)，然后再进行上述操作这就是SGD了，这种方法虽然不能反应整体的数据情况，不过能够很大程度上加快了模型的训练速度，并且也不会丢失太多的准确率
参数的迭代公式
w:=w−α∗dww:=w−α∗dw

Momentum

传统的GD可能会让学习过程十分的曲折，这里我们引入了惯性这一分量，在朝着最优点移动的过程中由于惯性走的弯路会变少
m=β∗m−α∗dwm=β∗m−α∗dw
w:=w−mw:=w−m

AdaGrad

这个方法主要是在学习率上面动手脚，每个参数的更新都会有不同的学习率
s=s+dw2s=s+dw2
w:=w−α∗dw/s√w:=w−α∗dw/s

RMSProp

AdaGrad收敛速度快，但不一定是全局最优，为了解决这一点，加入了Momentum部分
s=β∗s+(1−β)dw2s=β∗s+(1−β)dw2
w:=w−α∗dw/s√w:=w−α∗dw/s

Adam

adam是目前比较好的方法，它融合了Momentum和RMSProp方法

 

# https://www.cnblogs.com/wxshi/p/8645634.html
import tensorflow as tf
import matplotlib.pyplot as plt
import numpy as np


def reset_graph(seed=42):
    tf.reset_default_graph()
    tf.set_random_seed(seed)
    np.random.seed(seed)


reset_graph()
plt.figure(1, figsize=(10, 8))
x = np.linspace(-1, 1, 100)[:, np.newaxis]  # <==>x=x.reshape(100,1)
noise = np.random.normal(0, 0.1, size=x.shape)
y = np.power(x, 2) + x + noise  # y=x^2 + x+噪音
plt.scatter(x, y)
plt.show()
learning_rate = 0.01
batch_size = 10  # mini-batch的大小


class Network(object):
    def __init__(self, func, **kwarg):
        self.x = tf.placeholder(tf.float32, [None, 1])
        self.y = tf.placeholder(tf.float32, [None, 1])
        hidden = tf.layers.dense(self.x, 20, tf.nn.relu)
        output = tf.layers.dense(hidden, 1)
        self.loss = tf.losses.mean_squared_error(self.y, output)
        self.train = func(learning_rate, **kwarg).minimize(self.loss)


SGD = Network(tf.train.GradientDescentOptimizer)
Momentum = Network(tf.train.MomentumOptimizer, momentum=0.5)
AdaGrad = Network(tf.train.AdagradOptimizer)
RMSprop = Network(tf.train.RMSPropOptimizer)
Adam = Network(tf.train.AdamOptimizer)
networks = [SGD, Momentum, AdaGrad, RMSprop, Adam]
record_loss = [[], [], [], [], []]  # 踩的坑不能使用[[]]*5
plt.figure(2, figsize=(10, 8))
with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    for stp in range(200):
        index = np.random.randint(0, x.shape[0], batch_size)  # 模拟batch
        batch_x = x[index]
        batch_y = y[index]
        for net, loss in zip(networks, record_loss):
            _, l = sess.run([net.train, net.loss], feed_dict={net.x: batch_x, net.y: batch_y})
            loss.append(l)  # 保存每一batch的loss
labels = ['SGD', 'Momentum', 'AdaGrad', 'RMSprop', 'Adam']
for i, loss in enumerate(record_loss):
    plt.plot(loss, label=labels[i])
plt.legend(loc="best")
plt.xlabel("steps")
plt.ylabel("loss")
plt.show()