机器学习之杂乱笔记

https://tensorflow.google.cn/tutorials/representation/word2vec

暂时我们使用 vanilla 定义，将“上下文”定义为目标字词左侧和右侧的字词窗口

通过噪声对比训练进行扩展

神经概率语言模型一直以来都使用最大似然率 (ML) 原则进行训练，以最大限度地提高使用 softmax 函数根据之前的字词（表示“历史”字词）正确预测出下一个字词（表示“目标”字词）的概率

在大多数情况下，这对于小型数据集来说是很有用的。但是，skip-gram 将每个上下文-目标对视为一个新的观察对象，当我们使用大型数据集时，skip-gram 似乎能发挥更好的效果。在本教程接下来的部分，我们将重点介绍 skip-gram 模型。

Word2vec 是一种计算效率特别高的预测模型，用于学习原始文本中的字词嵌入。它分为两种类型：连续词袋模型 (CBOW) 和 Skip-Gram 模型

基于计数的方法会计算在大型文本语料库中，一些字词与临近字词共同出现的频率统计数据，然后将这些计数统计数据向下映射到每个字词的小型密集向量。预测模型会根据学到的小型密集嵌入向量（被视为模型的参数），直接尝试预测临近的字词。

向量空间模型 (VSM) 在连续向量空间中表示（嵌入）字词，其中语义相似的字词会映射到附近的点（“在彼此附近嵌入”）。VSM 在 NLP 方面有着悠久而丰富的历史，但所有方法均以某种方式依赖于分布假设，这种假设指明在相同上下文中显示的字词语义相同。利用该原则的不同方法可分为两类：基于计数的方法（例如潜在语义分析）以及预测方法（例如神经概率语言模型）。

图像和音频处理系统采用的是庞大的高维度数据集，对于图像数据来说，此类数据集会编码为单个原始像素强度的向量，对于音频数据来说，则编码为功率谱密度系数

tf.global_variables_initializer().run()

sess = tf.InteractiveSession()

获得以下数据集

([the, brown], quick), ([quick, fox], brown), ([brown, jumped], fox), ...

其中包含多组 (context, target) 对。回想一下，skip-gram 会调换上下文和目标，并尝试根据其目标字词预测每个上下文字词。因此，任务变成根据“quick”预测“the”和“brown”、根据“brown”预测“quick”和“fox”，等等。这样一来，我们的数据集就变成了

(quick, the), (quick, brown), (brown, quick), (brown, fox), ...

对于 word2vec 中的特征学习，我们不需要完整的概率模型。CBOW 和 skip-gram 模型会使用二元分类目标（逻辑回归）进行训练，以在相同上下文中区分实际目标字词

embeddings = tf.Variable(tf.random_uniform([vocabulary_size, embedding_size], -1.0, 1.0))

噪声对比估计损失是基于逻辑回归模型进行定义的。为此，我们需要为词汇表中的每个字词定义权重和偏差（也称为 output weights，与 input embeddings 相对）。我们先进行定义。

nce_weights = tf.Variable( tf.truncated_normal([vocabulary_size, embedding_size], stddev=1.0 / math.sqrt(embedding_size))) nce_biases = tf.Variable(tf.zeros([vocabulary_size]))

skip-gram 模型有两个输入。一个是表示源上下文字词的整数批次，另一个是表示目标字词的整数批次。

评估嵌入的一种简单方法是直接使用它们预测语法和语义关系（如 king is to queen as father is to ?）。这种方法称为类比推理

如果使用one-hot的方式来表示词语，那么词汇之间的余弦相似度总是零

跳字模型就是用一个词去预测它文本序列周围的词，例如：”the“，”man“，”hit“，”his“，”son“。比如时间窗口大小为2，则可以用”hit“中心词来预测”the“，”man“，”his“，”son“这些窗口小于2的背景词的最大概率

用softmax表达给定任意一个中心词wc生成背景词wo的概率。vc代表中心词在索引中第c个坐标，uo代表背景词在索引中第o个坐标。

wt为t处中心词，我们要预测t+j范围内的背景词。这个公式就是说给定每时刻的中心词，生成该处背景词的最大联合概率。！是条件概率下的联合概率最值问题。损失函数使用该联合概率的均值的负数值

连续词袋模型就是用文本序列周围的词来预测中心词，例如，给定文本序列”the“，”man“，”hit“，”his“，”son“，连续词袋模型关心的是给定”the“，”man“，”his“，”son“一起生成中心词”hit“的概率。

假设窗口大小为m，我们就有2m个背景词，中心词索引为c，该公式就对2m个背景词求平均，用这个平均值来做CBOW的向量，依然用softmax

机器学习之杂乱笔记

每个词都可有两个向量表达，既可以是背景词，也可以是中心词

梯度计算中计算开销都特别大，因为计算梯度时都需要最小字典大小的复杂度O(|v|)。word2vec解决这个问题采用了两个近似训练法，一个叫做负采样，一个叫做层序softmax。

负采样，词典V大小之所以会在目标函数中出现，是因为中心词wc生成背景词wo的概率P(wo|wc)使用了softmax，而softmax是考虑了背景词可能是词典中的任意一词，并体现在softmax的分母上。

中心词wc与任意一个背景词wo同时出现在训练数据时间窗口概率为D=1

中心词wc和第K个噪声词wk不同时出现在该训练数据窗口(噪声词wk按噪声词分布P(w)随机生成)。就是假设我有一个噪声词是词典中任何一个词，但是该窗口中，没有同时与中心词被观察到。则该公式就是上一个公式与噪声词没有在这个窗口观察到的概率的联合概率

层序softmax

https://blog.csdn.net/u013378306/article/details/64920924

任何采样算法都应该保证频次越高的样本越容易被采样出来。基本的思路是对于长度为1的线段，根据词语的词频将其公平地分配给每个词语

机器学习之杂乱笔记

https://blog.csdn.net/rxt2012kc/article/details/71123052

词对和“短语”

作者指出了像“Boston Globe”（“波士顿环球报”，一种报纸）这样的单词对，在作为单独的“Boston”和“Globe”来进行看待的时候有着非常不同的含义。所以在将它作为一整个“Boston Globe”来说是非常有意义的，不论它出现在文中哪里，都将一整个当成一个单词来看待，并且有它自己的词向量。减到了3百万个单词

这个工具从训练文章中计算出每两个单词组合同时出现的次数，并且在一个公式中使用这些计算出来的次数来决定哪些单词的组合能够转换成短语。这个公式是设计出来将多个经常一起出现的单词组合变成短语的。并且它还能够完成一些频率不高单词组成短语

高频词汇的二次采样

训练一个神经网络意味着使用一个训练样本就要稍微调整一下所有的神经网络权重，这样才能够确保预测训练样本更加精确。换句话说，每个训练样本都会改变神经网络中的权重。负采样通过使每一个训练样本仅仅改变一小部分的权重而不是所有权重，从而解决这个问题

使用负采样，我们通过随机选择一个较少数目（比如说5个）的“负”样本来更新对应的权重。(在这个条件下，“负”单词就是我们希望神经网络输出为0的神经元对应的单词）。并且我们仍然为我们的“正”单词更新对应的权重（也就是当前样本下”quick”对应的神经元）。

我们模型的输出层有大约300 x 10,000维度的权重矩阵。所以我们只需要更新正确的输出单词”quick”的权重，加上额外的5个其他应该输出为0的单词的权重。也就是总共6个输出神经元，和总共1800个的权重值。这些总共仅仅是输出层中3百万个权重中的0.06%。在隐藏层中，只更新了输入单词对应的权重（不论你是否使用了复采样）

使用频率的3/4次方显然是根据经验来的；在他们的文章中，他们说到这个公式比其他函数的表现更为优秀。你可以通过在谷歌中输入: plot y = x^(3/4) and y = x并且调整焦距为x = [0, 1]范围。当我们增加数值一点点的时候它的图像有一点小弯曲

skip-gram模型可以构造一个监督学习任务，把上下文映射到目标词上，以学习一个实用的词嵌入，但是他的缺点是softmax计算起来很慢。本节将会介绍了一个经过优化的学习问题叫做 负采样，其能够做到和 skip-gram 相似的功能但是使用起来更加高效。

正样本 的生成是采样得到一个上下文词和一个目标词。其中先在句中随机均匀的选取一个单词作为上下文词。然后在其左右两边一定词距内随机选择一个单词作为目标词。并且将标签设置为1.

负样本 的生成是使用和正样本一样的上下文词，然后从字典中随机选取一个单词构成一个组合。并且将标签设置为0. 其中同一 上下文词 生成 K个负样本

正负样本 的区别仅取决于单词对的来源，即使 of 也在 orange 的设定词距之内，但是作为随机从字典中选取的单词， of - orange 单词对仍然被标记为负样本

论文作者推荐，小数据集的话 K 被设置为5-20，而对于较大的数据集， K 被设置为2-5.即数据集越小 K 值被设定的越大

机器学习之杂乱笔记

损失函数 定义为给定 样本单词对 的情况下， $y = 1$

$y = 1$

词嵌入是一种把词从高维稀疏向量映射到了相对低维的实数向量上的表达方式。
Skip-Gram和CBOW的作用是构造神经网络的训练数据。
目前设计的网络结构实际上是由DNN+softmax()组成。
计算词嵌入向量实际上就是在计算隐藏层的权矩阵。
对于单位矩阵的每一维(行)与实矩阵相乘，可以简化为查找元素1的位置索引从而快速完成计算。

https://www.cnblogs.com/wkang/p/9611257.html

https://www.cnblogs.com/wkang/p/9978364.html

在讨论词嵌入之前，先要理解词向量的表达形式，注意，这里的词向量不是指Word2Vec。关于词向量的表达，现阶段采用的主要有One hot representation和Distributed representation两种表现形式。

Distributed representation在One hot representation的基础上考虑到词与词之间的联系，例如词义、词性等信息。每一个维度元素不再是0或1，而是连续的实数，表示不同的程度

Distributed representation 又包含了以下三种处理方式：

基于矩阵的分布表示。，矩阵中的一行，就成为了对应词的表示，这种表示描述了该词的上下文的分布。由于分布假说认为上下文相似的词，其语义也相似，因此在这种表示下，两个词的语义相似度可以直接转化为两个向量的空间距离。

基于聚类的分布表示。

基于神经网络的分布表示。现在常说的Distributed representation主要是基于神经网络的分布式表示的

词嵌入，我们可以理解为是对词的一种分布式表达方式，并且是从高维稀疏向量映射到了相对低维的实数向量上

计算效率。采用One hot representation的每个词的向量长度是由词汇表的数量决定，如果词汇表数量很大，那么每个词的长度会很长，同时，由于向量元素只有一个元素为1，其余元素为0，所以，每个词的向量表达也会非常稀疏。而对于海量的词语来讲，计算效率是需要考虑的。

词关系。和One hot representation相比，Distributed representation能够表达词与词之间的关系。

数量。对于把词语作为模型输入的任务，对于相似的词语，可以通过较少样本完成目标任务的训练，而这是One hot representation所无法企及的优势。

Bag of words model又称为词袋模型

例如以下两个句子：

John likes to watch movies. Mary likes movies too.
John also likes to watch football games.

基于以上两个句子，可以建构词袋表：[ "John", "likes", "to", "watch", "movies", "also", "football", "games", "Mary", "too" ]

由于词袋表的长度为10，所以每个句子的数字向量表示长度也为10。下面是每个句子的向量表示形式：

[1, 2, 1, 1, 2, 0, 0, 0, 1, 1]
[1, 1, 1, 1, 0, 1, 1, 1, 0, 0]

N-Gram model

机器学习之杂乱笔记

同样地，马尔可夫假设可以推广到：系统下一时刻的状态仅由当前0个、1个、2个...n个状态决定。这就是N-gram model的N的意思：对下一时刻的状态设置当前状态的个数。下面分别给出了unigram（一元模型）和bigram（二元模型）的第t + 1个单词的发生概率

Word2Vec Model

Word2Vec模型实际上分为了两个部分，第一部分为训练数据集的构造，第二部分是通过模型获取词嵌入向量，即word embedding

Word2Vec的整个建模过程实际上与自编码器（auto-encoder）的思想很相似，即先基于训练数据构建一个神经网络，当这个模型训练好以后，并不会用这个训练好的模型处理新任务，而真正需要的是这个模型通过训练数据所更新到的参数

关于word embedding的发展，由于考虑上下文关系，所以模型的输入和输出分别是词汇表中的词组成，进而产生出了两种词模型方法：Skip-Gram和CBOW。同时，在隐藏层-输出层，也从softmax（）方法演化到了分层softmax和negative sample方法。

机器学习之杂乱笔记

霍夫曼树是不是计算词嵌入向量的最优解？假设我们的训练样本里的中心词w是一个很生僻的词，那么就得在霍夫曼树中一直往下寻找路径。能不能不用搞这么复杂的一颗霍夫曼树，将模型变的更加简单呢？Negative Sampling就是这么一种求解word2vec模型的方法，它摒弃了霍夫曼树，采用了Negative Sampling（负采样）的方法来求解

噪声对比估计(NCE)的核心思想是通过logistic回归将一个多分类问题转化为一个二分类问题，同时保留学习到的词向量的质量。在NCE中，词向量不再是通过从中心词中预测上下文单词来学习，相反通过学习如何从（target, random word from vocabulary）对中区分出真实的（target, context）对从而完成词向量的计算。换句话说，如果一个模型能够从随机噪声中分辨出实际的目标词对和上下文词对，那么好的词向量就会被学习

而Negative Sampling是基于噪声对比估计(类似于生成对抗性网络)的一种方法

即一个好的模型应该通过逻辑回归来区分假信号和真实信号。同时Negative Sampling背后的思想类似于随机梯度下降：不是每次都改变所有的权重，考虑到我们所拥有的成千上万的观测数据，我们只使用了其中的K个，并且显著地提高了计算效率

对于训练数据集，我们使用的是具有噪声分布的数据集。之所以使用这种噪声分布数据集，是为了区分真实数据和我们试图解决的假数据。具体来说，对于每个正样本(即 true target/context pair)，我们从噪声分布中随机抽取k个负样本，并feed进模型

由于采用了随机采样，所以需要假定一个概率分布。在词汇表中每个单词概率由下式决定，其中幂为3/4。之所取3/4是因为可以减弱由于不同频次差异过大造成的单词采样差异的影响，使得小频次的单词也有一定被采样的概率。f(w)是词汇表中单词w出现的频率：

使用 prefetch 转换可将提供方和使用方的工作重叠。我们特别建议将 prefetch(n)（其中 n 是单步训练使用的元素数/批次数）添加到输入流水线的末尾，以便将在 CPU 上执行的转换与在加速器上执行的训练重叠。
通过设置 num_parallel_calls 参数并行处理 map 转换。建议您将其值设为可用 CPU 核心的数量。
如果您使用 batch 转换将预处理元素组合到一个批次中，建议您使用 map_and_batch 混合转换；特别是在您使用的批次较大时。
如果您要处理远程存储的数据并/或需要反序列化，建议您使用 parallel_interleave 转换来重叠从不同文件读取（和反序列化）数据的操作。
向量化传递给 map 转换的低开销用户定义函数，以分摊与调度和执行相应函数相关的开销。
如果内存可以容纳您的数据，请使用 cache 转换在第一个周期中将数据缓存在内存中，以便后续周期可以避免与读取、解析和转换该数据相关的开销。
如果预处理操作会增加数据大小，建议您首先应用 interleave、prefetch 和 shuffle（如果可以）以减少内存使用量。
建议您在应用 repeat 转换之前先应用 shuffle 转换，最好使用 shuffle_and_repeat 混合转换。
如果执行以上示例的机器有 4 个核心，则设置 num_parallel_calls=4 会更高效
由于输入元素彼此独立，因此可以跨多个 CPU 核心并行执行预处理。为实现这一点，map 转换提供了 num_parallel_calls 参数来指定并行处理级别
准备批次数据时，可能需要预处理输入元素。为此，tf.data API 提供了 tf.data.Dataset.map 转换
tf.data API 通过 tf.data.Dataset.prefetch 转换提供了一种软件流水线机制
流水线将训练步骤的预处理和模型执行过程重叠到一起。当加速器正在执行第 N 个训练步时，CPU 正在准备第 N+1 步的数据。这样做不仅可以最大限度地缩短训练的单步用时（而不是总用时），而且可以缩短提取和转换数据所需的时间
使用 tf.estimator.Estimator API 时，前两个阶段（提取和转换）是在 input_fn（传递给 tf.estimator.Estimator.train）中捕获的
TensorFlow 训练输入流水线视为 ETL 流程：

提取：从永久性存储（可以是 HDD 或 SSD 等本地存储或 GCS 或 HDFS 等远程存储）读取数据。
转换：使用 CPU 核心解析数据并对其执行预处理操作，例如图像解压缩、数据增强转换（例如随机裁剪、翻转和颜色失真）、重排和批处理。
加载：将转换后的数据加载到执行机器学习模型的加速器设备（例如，GPU 或 TPU）上。
NHWC 是 TensorFlow 的默认值，NCHW 是使用 cuDNN 在 NVIDIA GPU 上训练时使用的最佳格式
这些配置是使用 tf.ConfigProto 进行设置的，并传递给 tf.Session（在 config 属性中）
在 CPU 和移动设备上，如果 GPU 不支持 tf.contrib.cudnn_rnn，那么最快且最节省内存的选项是 tf.contrib.rnn.LSTMBlockFusedCell
如果您需要一次运行 RNN 的一步（使用递归政策的强化学习中可能会出现这种情况），则应该将 tf.contrib.rnn.LSTMBlockCell 与您自己的环境交互循环（在 tf.while_loop 构造内部）结合使用
在 NVIDIA GPU 上，除非您想要实现不受支持的层归一化，否则应始终首选使用 tf.contrib.cudnn_rnn。它通常比 tf.contrib.rnn.BasicLSTMCell 和 tf.contrib.rnn.LSTMBlockCell 快至少一个数量级
feed_dict 提供数据可实现高度灵活性，但 feed_dict 通常无法提供可扩缩的解决方案。请尽量将 feed_dict 用于简单样本，避免全部应用
对于较小的数据集 (200MB-1GB)，最好的方法通常是将整个数据集加载到内存中
读取大量小文件会显著影响 I/O 性能。实现最大 I/O 吞吐量的一种方法是将输入数据预处理为更大（约 100MB）的 TFRecord 文件
tf.data API 在设计时考虑了灵活性、易用性和性能。要使用 tf.data API 并最大限度地提高其性能，请参阅数据输入流水线指南

t-SNE：一种非线性不确定性算法（T 分布式随机邻点嵌入），它会尝试保留数据中的局部邻点，通常以扭曲全局结构为代价。您可以选择是计算二维还是三维投影。

PCA：一种线性确定性算法（主成分分析），它尝试用尽可能少的维度捕获尽可能多的数据可变性。PCA 会突出数据中的大规模结构，但可能会扭曲本地邻点。Embedding Projector 会计算前 10 个主成分，您可以从中选择两三个进行查看。
为了将这些字词 ID 映射到向量，我们需要创建嵌入变量并使用 tf.nn.embedding_lookup 函数
机器学习的很多重要输入（例如文本的字词）没有自然的向量表示。嵌入函数是将此类离散输入对象转换为有用连续向量的标准和有效方法
嵌入是从离散对象（例如字词）到实数向量的映射
http://projector.tensorflow.org
TensorFlow 中训练嵌入，此外还说明了如何使用 TensorBoard Embedding Projector 查看嵌入（真实示例）。前两部分适合机器学习或 TensorFlow 新手，而 Embedding Projector 指南适合各个层次的用户。
https://tensorflow.google.cn/guide/autograph
@autograph.convert()
def fizzbuzz(i, n):
while i < n:
 msg = ''
 if i % 3 == 0:
 msg += 'Fizz'
 if i % 5 == 0:
 msg += 'Buzz'
 if msg == '':
 msg = tf.as_string(i)
 print(msg)
 i += 1
return i

with tf.Graph().as_default():
final_i = fizzbuzz(tf.constant(10), tf.constant(16))
# The result works like a regular op: takes tensors in, returns tensors.
# You can inspect the graph using tf.get_default_graph().as_graph_def()
with tf.Session() as sess:
    sess.run(final_i)
如果您不需要轻松访问原始 Python 函数，请使用 convert 修饰符：
# Continue in a loop
def sum_even(items):
s = 0
for c in items:
    if c % 2 > 0:
      continue
    s += c
return s

print('Eager result: %d' % sum_even(tf.constant([10,12,15,20])))

tf_sum_even = autograph.to_graph(sum_even)

with tf.Graph().as_default(), tf.Session() as sess:
print('Graph result: %d\n\n' % sess.run(tf_sum_even(tf.constant([10,12,15,20]))))
AutoGraph 支持常见的 Python 语句（例如 while、for、if、break 和 return），并且支持嵌套。将此函数与以下代码块中显示的复杂图版本相比较：

您可以考虑改为每 n 步运行一次合并的总结 op。
要将此汇总数据写入磁盘，请将汇总 protobuf 传递给 tf.summary.FileWriter
因此可以使用 tf.summary.merge_all 将这些操作合并为一个操作，从而生成所有汇总数据
为了生成总结信息，我们需要运行所有这些总结节点
或许您还希望显示特定层中激活函数的分布情况，或者显示梯度或权重的分布情况。为了收集这些数据，您可以分别向梯度输出和存储权重的变量附加 tf.summary.histogram 操作
为了收集这些数据，您可以分别向输出学习速率和损失的节点附加 tf.summary.scalar
首先，创建您想从中收集总结数据的 TensorFlow 图，然后再选择您想在哪个节点标注总结指令
TensorBoard 通过读取 TensorFlow 的事件文件来运行。TensorFlow 的事件文件包含运行 TensorFlow 时生成的总结数据

机器学习之杂乱笔记

tf.keras.layers.Lambda(collatz, input_shape=(1,), output_shape=())
对于无状态函数（如下面所示的 collatz），将其添加到 keras 模型中的最简单方法是使用 tf.keras.layers.Lambda 将其封装为层
在图中使用 Python print 函数
如果您不需要轻松访问原始 Python 函数，请使用 convert 修饰符
AutoGraph 支持常见的 Python 语句（例如 while、for、if、break 和 return），并且支持嵌套
tf_square_if_positive = autograph.to_graph(square_if_positive)
转换为使用图构建过程的函数
自动转换 Python 控制流
为了进行演示，我们将启用 Eager Execution，但 AutoGraph 在 Eager Execution 和 Graph Execution 环境中都适用
from tensorflow.contrib import autograph
AutoGraph 可帮助您使用普通 Python 编写复杂的图代码。AutoGraph 会在后台自动将您的代码转换为等效的 TensorFlow 图代码。AutoGraph 已经支持大部分 Python 语言，而且覆盖范围在不断扩大。如需所支持 Python 语言功能的列表，请参阅 Autograph 功能和限制。

您可以使用 TensorFlow Serving Model Server 二进制文件轻松加载和提供 SavedModel
在 TensorFlow Serving 中加载和提供 SavedModel
tf.saved_model.loader.load(sess, [tag_constants.TRAINING], export_dir)
加载 Python 版 SavedModel
如果需要将资源保存并写入或复制到磁盘，则可以在首次添加 MetaGraphDef 时提供这些资源
tf.saved_model.builder.SavedModelBuilder 类提供了保存多个 MetaGraphDef 的功能
通过 TensorFlow Serving 进行加载，并支持 Predict API。要访问 classify API、regress API 或 multi-inference API，请使用手动 SavedModel builder API 或 tf.estimator.Estimator。
能够通过 TensorFlow Serving 进行加载
创建 SavedModel 的最简单方法是使用 tf.saved_model.simple_save 函数
简单保存
TensorFlow 提供了多种与 SavedModel 交互的方式，包括 tf.saved_model API、tf.estimator.Estimator 和命令行界面
保存和恢复模型
chkp.print_tensors_in_checkpoint_file("/tmp/model.ckpt", tensor_name='v1', all_tensors=False)
chkp.print_tensors_in_checkpoint_file("/tmp/model.ckpt", tensor_name='', all_tensors=True)
print_tensors_in_checkpoint_file
如果您在会话开始时仅恢复一部分模型变量，则必须为其他变量运行初始化操作。详情请参阅 tf.variables_initializer
saver = tf.train.Saver({"v2": v2})
有时候，仅保存或恢复模型使用的变量子集也会很有裨益。例如，您可能已经训练了一个五层的神经网络，现在您想要训练一个六层的新模型，并重用该五层的现有权重。您可以使用 Saver 只恢复这前五层的权重
在检查点文件中明确指定变量名称的这种做法有时会非常有用。例如，您可能已经使用名为"weights"的变量训练了一个模型，而您想要将该变量的值恢复到名为"params"的变量中。
如果您没有向 tf.train.Saver() 传递任何参数，则 Saver 会处理图中的所有变量
tf.train.Saver.save 方法以将变量保存到检查点文件中
保存和恢复变量
训练 Estimator 模型之后，您可能需要使用该模型创建服务来接收请求并返回结果。您可以在本机运行此类服务，或在云端部署该服务。
搭配 Estimator 使用 SavedModel

conda install -c conda-forge jupyter_contrib_nbextensions
Define an input pipeline
keras_estimator = tf.keras.estimator.model_to_estimator
strategy = tf.contrib.distribute.MirroredStrategy()
config = tf.estimator.RunConfig(train_distribute=strategy)
Multiple GPUs
tf.keras.estimator.model_to_estimator
converting the model
Estimators
Distribution
model subclassing and building custom layers
Eager execution
tf.keras.models.load_model
model.save('my_model.h5')
Entire model
model.to_yaml()
tf.keras.models.model_from_json(json_string)
json.loads(json_string)
json_string = model.to_json()
Configuration only
model.load_weights
HDF5
model.save_weights
Save and restore
tf.keras.callbacks.Callback
TensorBoard
EarlyStopping
LearningRateScheduler
ModelCheckpoint
callback
from_config
get_config
compute_output_shape
call
build
tf.keras.layers.Layer
Custom layers
tf.keras.Mode
Model subclassing
tf.keras.Model
inputs
functional API
Build advanced models
Evaluate and predict
labels
validation_data
tf.data.Dataset.from_tensor_slices
Input NumPy
Input tf.data datasets
tf.keras.Model.fit
Input NumPy data
metrics
optimizer
compile
kernel_regularizer and bias_regularizer
kernel_initializer and bias_initializer
Configure the layers
Build a simple model
Sequential model
Estimators
eager execution
tf.keras
tf.keras
tf_data
Estimators
eager execution
tf.keras
pip install jupyter_contrib_nbextensions
 分割数据集
keras models have a builtin training loop (using the `fit` method)
w = tf.Variable([[1.0]])
with tf.GradientTape() as tape:
loss = w * w

grad = tape.gradient(loss, w)
print(grad) # => tf.Tensor([[ 2.]], shape=(1, 1), dtype=float32)
Since different operations can occur during each call, all forward-pass operations get recorded to a "tape". To compute the gradient, play the tape backwards and then discard. A particular tf.GradientTape can only compute one gradient; subsequent calls throw a runtime error.
tf.GradientTape is an opt-in feature to provide maximal performance when not tracing
tf.keras.layers.Layer
write your own layers or
use a layer provided in the `tf.keras.layers`
tf.convert_to_tensor为显然式转换
tf.convert_to_tensor(max_num)
tf.squeeze(input, squeeze_dims=None, name=None)

Removes dimensions of size 1 from the shape of a tensor.
从tensor中删除所有大小是1的维度
expand_dims(t, 0)
# 't' is a tensor of shape [2]
shape(expand_dims(t, 0)) ==> [1, 2]
shape(expand_dims(t, 1)) ==> [2, 1]
shape(expand_dims(t, -1)) ==> [2, 1]

# 't2' is a tensor of shape [2, 3, 5]
shape(expand_dims(t2, 0)) ==> [1, 2, 3, 5]
shape(expand_dims(t2, 2)) ==> [2, 3, 1, 5]
shape(expand_dims(t2, 3)) ==> [2, 3, 5, 1]
TensorFlow中，想要维度增加一维，可以使用tf.expand_dims(input, dim, name=None)函数。当然，我们常用tf.reshape(input, shape=[])也可以达到相同效果，但是有些时候在构建图的过程中，placeholder没有被feed具体的值，这时就会包下面的错误：TypeError: Expected binary or unicode string, got 1
在这种情况下，我们就可以考虑使用expand_dims来将维度加1
tf.expand_dims
jupyter contrib nbextension install --user --skip-running-check
pip install https://github.com/ipython-contrib/jupyter_contrib_nbextensions/tarball/master

jupyter_contrib_nbextensions
Estimator 的数据集
Estimator 要求 input_fn 不接受任何参数。为了不受此限制约束，我们使用 lambda 来获取参数并提供所需的接口。
train_path, test_path = iris_data.maybe_download()

# All the inputs are numeric
feature_columns = [
tf.feature_column.numeric_column(name)
for name in iris_data.CSV_COLUMN_NAMES[:-1]]

# Build the estimator
est = tf.estimator.LinearClassifier(feature_columns,
                                    n_classes=3)
# Train the estimator
batch_size = 100
est.train(
    steps=1000,
    input_fn=lambda : iris_data.csv_input_fn(train_path, batch_size))

ds = ds.map(_parse_line)
print(ds)

数据集提供很多用于在通过管道将数据传送到模型的过程中处理数据的方法。最常用的方法是 map，它会对 Dataset 的每个元素应用转换
为了生成必要的 (features, label) 对，我们必须解析数据集中的每一行。以下 _parse_line 函数会调用 tf.decode_csv，以将一行解析为特征和标签两个部分。由于 Estimator 需要将特征表示为字典，因此我们依靠 Python 的内置 dict 和 zip 函数来构建此字典。特征名称是该字典的键。然后，我们调用字典的 pop 方法以从特征字典中移除标签字段：

# Metadata describing the text columns
COLUMNS = ['SepalLength', 'SepalWidth',
           'PetalLength', 'PetalWidth',
           'label']
FIELD_DEFAULTS = [[0.0], [0.0], [0.0], [0.0], [0]]
def _parse_line(line):
    # Decode the line into its fields
    fields = tf.decode_csv(line, FIELD_DEFAULTS)

# Pack the result into a dictionary
features = dict(zip(COLUMNS,fields))

# Separate the label from the features
label = features.pop('label')

return features, label
iris_data.parse_line 函数会使用 tf.decode_csv 函数和一些简单的 Python 代码来完成此任务
调用 skip 方法来跳过文件的第一行，此行包含标题，而非样本：

ds = tf.data.TextLineDataset(train_path).skip(1)

iris_data.csv_input_fn 函数包含使用 Dataset 解析 csv 文件的备用实现
csv_input_fn
train_path, test_path = iris_data.maybe_download()

# seaborn这个绘图包很漂亮
dataset.tail()
 升维

机器学习之杂乱笔记

Additionally, SavedModels or stored GraphDefs will be backwards compatible. SavedModels saved with 1.x will continue to load and execute in 2.x
conversion tool
Compatibility and Continuity
Removal of queue runners in favor of tf.data.
Removal of graph collections.
Changes to how variables are treated.
Moving and renaming of API symbols.
Differences between TensorFlow 1.x and 2.0
Along with these capabilities, TensorFlow provides eager execution for easy prototyping & debugging, Distribution Strategy API and AutoGraph to train at scale
TensorFlow 2.0 brings several new additions that allow researchers and advanced users to experiment, using rich extensions like Ragged Tensors, TensorFlow Probability, Tensor2Tensor
And for even more flexibility and control, the low-level TensorFlow API is always available and working in conjunction with the higher level abstractions for fully customizable logic
Custom Training Logic: Fine-grained control on gradient computations with tf.GradientTape and tf.custom_gradient.
Keras Functional API and Model Subclassing API:
Powerful experimentation for research
TensorFlow.js:
TensorFlow Lite:
TensorFlow Serving:
Robust model deployment in production on any platform
Export to SavedModel.
Use Distribution Strategies for distributed training.
Run and debug with eager execution, then use tf.function for the benefits of graphs
Build, train and validate your model with tf.keras, or use Premade Estimators
Load your data using tf.data
Easy model building

本站文章如无特殊说明，均为本站原创，如若转载，请注明出处：机器学习之杂乱笔记 - Python技术站

机器学习之杂乱笔记

N-Gram model

Word2Vec Model

相关文章