`元素，并将其添加到数据中。 训练完成后，该路由返回一个 HTML 片段，该片段会生成一个表，该表具有`do_training`方法返回的评估指标，如以下代码所示：
```py
[[SimpleClassificationDNN]]
@route(do_training="*")
@captureOutput
def do_training_screen(self):
self.classifier, self.eval_results = \
do_training(
self.train_x, self.train_y, self.test_x, self.test_y, self.num_classes
)
return """
Training completed successfully
| Metric |
Value |
{%for key,value in this.eval_results.items()%}
| {{key}} |
{{value}} |
{%endfor%}
"""
```
### 注意
[您可以在此处找到代码文件](https://github.com/DTAIEB/Thoughtful-Data-Science/blob/master/chapter%206/sampleCode6.py)。
以下屏幕快照显示了成功创建模型后的结果，并包括分类模型的评估指标表，其准确率为 87%：
最终屏幕显示成功训练的结果
使用`crimes`数据集作为参数运行此 PixieApp ，如以下代码所示：
```py
app = SimpleClassificationDNN()
app.run(crimes)
```
成功训练模型后，您可以通过调用`app.classifier`变量上的`predict`方法来访问它以对新数据进行分类。 与`train`和`evaluate`方法类似，`predict`也采用`input_fn`来构造输入特征。
### 注意
[**注意**：此处提供有关`predict`方法的更多详细信息](https://www.tensorflow.org/api_docs/python/tf/estimator/DNNClassifier#predict)。
该示例应用通过使用高级估计器 API 为熟悉 TensorFlow 框架提供了一个很好的起点。
### 注意
[**注意**：可在此处找到此示例应用的完整笔记本](https://github.com/DTAIEB/Thoughtful-Data-Science/blob/master/chapter%206/TensorFlow%20classification.ipynb)。
在下一节中，我们将开始使用低级 TensorFlow API（包括张量，图和会话）来构建图像识别示例应用。
# 图像识别示例应用
在涉及构建开放式应用的时，您首先需要定义包含足够的 **MVP**（**最低可行产品**）版本的要求。 使其实用且对用户有价值的功能。 在为实现制定技术决策时，确保尽快获得可行的端到端实现而又不花费太多时间是非常重要的标准。 这个想法是您希望从小处着手，以便快速迭代并改善您的应用。
对于我们的图像识别示例应用的 MVP，我们将使用以下要求：
* 不要从头开始构建模型； 相反，请重用已公开的预训练的通用**卷积神经网络**（ [**CNN**](https://en.wikipedia.org/wiki/Convolutional_neural_network)）模型之一，例如 MobileNet。 [我们以后总是可以使用传递学习](https://en.wikipedia.org/wiki/Transfer_learning)使用自定义训练图像来重新训练这些模型。
* 对于 MVP，虽然我们只关注得分而不是训练，但我们仍然应该使用户感兴趣。 因此，让我们构建一个 PixieApp，该应用允许用户输入网页的 URL 并显示从该页面抓取的所有图像，包括由我们的模型推断出的分类输出。
* 由于我们正在学习深度学习神经网络和 TensorFlow，因此如果可以在 Jupyter 笔记本中直接显示 [TensorBoard Graph Visualization](https://www.tensorflow.org/programmers_guide/graph_viz) 会很棒，而不会强迫用户使用其他工具。 这将提供更好的用户体验并增加他们对应用的参与度。
### 注意
[**注意**：本节中应用的实现改编自教程](https://codelabs.developers.google.com/codelabs/tensorflow-for-poets)。
## 第 1 部分——加载预训练的 MobileNet 模型
### 注意
[**注意**：您可以下载完整的笔记本，以按照此处的讨论进行操作](https://github.com/DTAIEB/Thoughtful-Data-Science/blob/master/chapter%206/Tensorflow%20VR%20Part%201.ipynb)。
在使用 CNN 的中，有很多公开可用的图像分类模型，这些模型已经在大型图像数据库（例如 [ImageNet](http://www.image-net.org) 上进行了预训练。 ImageNet 已发起了多个公共挑战，例如 **ImageNet 大规模视觉识别挑战**（**ILSVRC**）或 Kaggle 上的 [*ImageNet 对象本地化挑战*](https://www.kaggle.com/c/imagenet-object-localization-challenge)，结果非常有趣。
这些挑战已经产生了多个模型，例如 ResNet，Inception，SqueezeNet，VGGNet 或 Xception，每个模型都使用不同的神经网络架构。 遍历所有这些架构都超出了本书的范围，但是即使您还不是机器学习专家（我绝对不是），我还是鼓励您在线阅读它们。 我为该示例应用选择的模型是 MobileNet，因为它小巧，快速且非常准确。 它提供了用于 1,000 个图像类别的图像分类模型，对于该示例应用已经足够了。
为了确保代码的稳定性，[我在 GitHub 存储库中复制了该模型](https://github.com/DTAIEB/Thoughtful-Data-Science/tree/master/chapter%206/Visual%20Recognition/mobilenet_v1_0.50_224)。
在此目录中，您可以找到以下文件：
* `frozen_graph.pb`：TensorFlow 图的序列化二进制版本
* `labels.txt`：一个文本文件，其中包含对 1,000 个图像类别及其索引的描述
* `quantized_graph.pb`：模型图的压缩形式，使用 8 位定点表示
加载模型包括构建`tf.graph`对象和相关标签。 由于将来可能要加载多个模型，因此我们首先定义一个字典，该字典提供有关模型的元数据：
```py
models = {
"mobilenet": {
"base_url":"https://github.com/DTAIEB/Thoughtful-Data-Science/raw/master/chapter%206/Visual%20Recognition/mobilenet_v1_0.50_224",
"model_file_url": "frozen_graph.pb",
"label_file": "labels.txt",
"output_layer": "MobilenetV1/Predictions/Softmax"
}
}
```
### 注意
[您可以在这里找到文件](https://github.com/DTAIEB/Thoughtful-Data-Science/blob/master/chapter%206/sampleCode7.py)。
前面的`models`字典中的中的每个键都代表特定模型的元数据：
* `base_url`：指向文件存储的 URL
* `model_file_url`：假定相对于`base_url`的模型文件的名称
* `label_file`：假定相对于`base_url`的标签名称
* `output_layer`：为每个类别提供最终评分的输出层的名称
我们实现了`get_model_attribute`帮助方法，以方便读取`model`元数据，这在整个应用中将非常有用：
```py
# helper method for reading attributes from the model metadata
def get_model_attribute(model, key, default_value = None):
if key not in model:
if default_value is None:
raise Exception("Require model attribute {} not found".format(key))
return default_value
return model[key]
```
### 注意
[您可以在此处找到代码文件](https://github.com/DTAIEB/Thoughtful-Data-Science/blob/master/chapter%206/sampleCode8.py)。
要加载图，我们下载二进制文件，使用`ParseFromString`方法将其加载到`tf.GraphDef`对象中，然后使用图作为当前内容管理器来调用`tf.import_graph_def`方法：
```py
import tensorflow as tf
import requests
# Helper method for resolving url relative to the selected model
def get_url(model, path):
return model["base_url"] + "/" + path
# Download the serialized model and create a TensorFlow graph
def load_graph(model):
graph = tf.Graph()
graph_def = tf.GraphDef()
graph_def.ParseFromString(
requests.get( get_url( model, model["model_file_url"] ) ).content
)
with graph.as_default():
tf.import_graph_def(graph_def)
return graph
```
### 注意
[您可以在此处找到代码文件](https://github.com/DTAIEB/Thoughtful-Data-Science/blob/master/chapter%206/sampleCode9.py)。
加载标签的方法返回一个 JSON 对象或一个数组（我们将在后面看到两者）。 以下代码使用 Python 列表推导来迭代`requests.get`调用返回的行。 然后，它使用`as_json`标志来适当地格式化数据：
```py
# Load the labels
def load_labels(model, as_json = False):
labels = [line.rstrip() \
for line in requests.get(get_url(model, model["label_file"]) ).text.split("\n") if line != ""]
if as_json:
return [{"index": item.split(":")[0],"label":item.split(":")[1]} for item in labels]
return labels
```
### 注意
[您可以在此处找到代码文件](https://github.com/DTAIEB/Thoughtful-Data-Science/blob/master/chapter%206/sampleCode10.py)。
下一步是调用模型对图像进行分类。 为了使其更简单并且可能更有价值，我们要求用户提供指向包含要分类图像的 HTML 页面的 URL。 我们将使用 BeautifulSoup4 库来帮助解析页面。 要安装 BeautifulSoup4，只需运行以下命令：
```py
!pip install beautifulsoup4
```
### 注意
**注意**：与往常一样，安装完成后，不要忘记重新启动内核。
下面的`get_image_urls`方法将 URL 作为输入，下载 HTML，实例化 BeautifulSoup 解析器，并提取以任何`
![]()
`元素和`background-image`样式找到的所有图像。 BeautifulSoup 具有一个非常优雅且易于使用的 API，用于解析 HTML。 在这里，我们仅使用`find_all`方法查找所有`
![]()
`元素，然后使用`select`方法选择所有具有内联样式的元素。 读者会很快注意到还有许多其他方法可以使用我们没有发现的 HTML 来创建图像，例如，声明为 CSS 类的图像。 与往常一样，如果您有兴趣和时间来改进它，我强烈欢迎 GitHub 存储库中的请求请求（有关如何创建请求请求的说明，[请参见此处](https://help.github.com/articles/creating-a-pull-request)）。
`get_image_urls`的代码如下所示：
```py
from bs4 import BeautifulSoup as BS
import re
# return an array of all the images scraped from an html page
def get_image_urls(url):
# Instantiate a BeautifulSoup parser
soup = BS(requests.get(url).text, "html.parser")
# Local helper method for extracting url
def extract_url(val):
m = re.match(r"url\((.*)\)", val)
val = m.group(1) if m is not None else val
return "http:" + val if val.startswith("//") else val
# List comprehension that look for
![]()
elements and backgroud-image styles
return [extract_url(imgtag['src']) for imgtag in soup.find_all('img')] + [ \
extract_url(val.strip()) for key,val in \
[tuple(selector.split(":")) for elt in soup.select("[style]") \
for selector in elt["style"].strip(" ;").split(";")] \
if key.strip().lower()=='background-image' \
]
```
### 注意
[您可以在此处找到代码文件](https://github.com/DTAIEB/Thoughtful-Data-Science/blob/master/chapter%206/sampleCode11.py)。
对于发现的每个图像，我们还需要一个辅助函数来下载将作为输入传递到模型进行分类的图像。
以下`download_image`方法将图像下载到一个临时文件中：
```py
import tempfile
def download_image(url):
response = requests.get(url, stream=True)
if response.status_code == 200:
with tempfile.NamedTemporaryFile(delete=False) as f:
for chunk in response.iter_content(2048):
f.write(chunk)
return f.name
else:
raise Exception("Unable to download image: {}".format(response.status_code))
```
### 注意
[您可以在此处找到代码文件](https://github.com/DTAIEB/Thoughtful-Data-Science/blob/master/chapter%206/sampleCode12.py)。
给定图像的本地路径，我们现在需要通过从`tf.image`包（即`.png`文件的`decode_png`）调用正确的解码方法，将其解码为张量。
### 注意
**注**：在数学中，张量是向量的概括，向量由方向和大小定义，以支持更高的维度。 向量是 1 阶张量，类似地，标量是 0 阶张量。直观地，我们可以将 2 阶张量视为一个二维数组，其值定义为两个向量相乘的结果。 在 TensorFlow 中，张量是 N 维数组。
在图像读取器张量上进行了一些转换（广播到右边的小数表示，调整大小和规格化）之后，我们在规格化张量上调用`tf.Session.run`以使执行之前定义的步骤，如以下代码所示：
```py
# decode a given image into a tensor
def read_tensor_from_image_file(model, file_name):
file_reader = tf.read_file(file_name, "file_reader")
if file_name.endswith(".png"):
image_reader = tf.image.decode_png(file_reader, channels = 3,name='png_reader')
elif file_name.endswith(".gif"):
image_reader = tf.squeeze(tf.image.decode_gif(file_reader,name='gif_reader'))
elif file_name.endswith(".bmp"):
image_reader = tf.image.decode_bmp(file_reader, name='bmp_reader')
else:
image_reader = tf.image.decode_jpeg(file_reader, channels = 3, name='jpeg_reader')
float_caster = tf.cast(image_reader, tf.float32)
dims_expander = tf.expand_dims(float_caster, 0);
# Read some info from the model metadata, providing default values
input_height = get_model_attribute(model, "input_height", 224)
input_width = get_model_attribute(model, "input_width", 224)
input_mean = get_model_attribute(model, "input_mean", 0)
input_std = get_model_attribute(model, "input_std", 255)
resized = tf.image.resize_bilinear(dims_expander, [input_height, input_width])
normalized = tf.divide(tf.subtract(resized, [input_mean]), [input_std])
sess = tf.Session()
result = sess.run(normalized)
return result
```
### 注意
[您可以在此处找到代码文件](https://github.com/DTAIEB/Thoughtful-Data-Science/blob/master/chapter%206/sampleCode13.py)。
一切准备就绪后，我们现在就可以实现`score_image`方法，该方法将`tf.graph`，模型元数据和图像的 URL 作为输入参数，并根据其置信度返回前五个候选类别分数，包括其标签：
```py
import numpy as np
# classify an image given its url
def score_image(graph, model, url):
# Get the input and output layer from the model
input_layer = get_model_attribute(model, "input_layer", "input")
output_layer = get_model_attribute(model, "output_layer")
# Download the image and build a tensor from its data
t = read_tensor_from_image_file(model, download_image(url))
# Retrieve the tensors corresponding to the input and output layers
input_tensor = graph.get_tensor_by_name("import/" + input_layer + ":0");
output_tensor = graph.get_tensor_by_name("import/" + output_layer + ":0");
with tf.Session(graph=graph) as sess:
results = sess.run(output_tensor, {input_tensor: t})
results = np.squeeze(results)
# select the top 5 candidate and match them to the labels
top_k = results.argsort()[-5:][::-1]
labels = load_labels(model)
return [(labels[i].split(":")[1], results[i]) for i in top_k]
```
### 注意
[您可以在此处找到代码文件](https://github.com/DTAIEB/Thoughtful-Data-Science/blob/master/chapter%206/sampleCode14.py)。
现在，我们可以使用以下步骤测试代码：
1. 选择`mobilenet`模型并加载相应的图
2. 获取从 Flickr 网站抓取的图像 URL 的列表
3. 为每个图像 URL 调用`score_image`方法并打印结果
代码如下所示：
```py
model = models['mobilenet']
graph = load_graph(model)
image_urls = get_image_urls("https://www.flickr.com/search/?text=cats")
for url in image_urls:
results = score_image(graph, model, url)
print("Result for {}: \n\t{}".format(url, results))
```
### 注意
[您可以在此处找到代码文件](https://github.com/DTAIEB/Thoughtful-Data-Science/blob/master/chapter%206/sampleCode15.py)。
结果非常准确（除了第一张图像是空白图像），如以下屏幕截图所示：
在 Flickr 页面上找到与猫有关的图像的分类
我们的图像识别示例应用的第 1 部分现已完成； [您可以在以下位置找到完整的笔记本](https://github.com/DTAIEB/Thoughtful-Data-Science/blob/master/chapter%206/Tensorflow%20VR%20Part%201.ipynb)。
在下一部分中，我们将通过使用 PixieApp 构建用户界面来构建更加用户友好的体验。
## 第 2 部分——为我们的图像识别示例应用创建 PixieApp
### 注意
[**注意**：您可以下载完整的笔记本，以按照此处的讨论进行操作](https://github.com/DTAIEB/Thoughtful-Data-Science/blob/master/chapter%206/Tensorflow%20VR%20Part%202.ipynb)。
提醒一下，PixieApp 的`setup`方法（如果已定义）是在应用开始运行之前执行的。 我们使用选择模型并初始化图：
```py
from pixiedust.display.app import *
@PixieApp
class ScoreImageApp():
def setup(self):
self.model = models["mobilenet"]
self.graph = load_graph( self.model )
...
```
### 注意
[您可以在此处找到代码文件](https://github.com/DTAIEB/Thoughtful-Data-Science/blob/master/chapter%206/sampleCode16.py)。
在 PixieApp 的主屏幕中，我们使用输入框让用户输入网页的 URL，如以下代码片段所示：
```py
[[ScoreImageApp]]
@route()
def main_screen(self):
return """
"""
```
### 注意
[您可以在此处找到代码文件](https://github.com/DTAIEB/Thoughtful-Data-Science/blob/master/chapter%206/sampleCode17.py)。
为了方便起见，我们使用默认值`https://www.flickr.com/search/?text=cats`初始化输入文本。
我们已经可以使用以下代码运行代码以测试主屏幕：
```py
app = ScoreImageApp()
app.run()
```
主屏幕如下所示：
图像识别 PixieApp 的主屏幕
### 注意
**注意**：这对测试很有用，但是我们要记住，`do_process_url`路由尚未实现，因此，单击**前进**按钮将退回到再次使用默认路由。
现在让我们实现`do_process_url`路由，该路由在用户单击**前进**按钮时触发。 该路由首先调用`get_image_urls`方法以获取图像 URL 列表。 然后，使用 Jinja2，我们构建一个 HTML 片段来显示所有图像。 对于每个图像，我们异步调用运行模型并显示结果的`do_score_url`路由。
以下代码显示了`do_process_url`路由的实现：
```py
[[ScoreImageApp]]
@route(image_url="*")
@templateArgs
def do_process_url(self, image_url):
image_urls = get_image_urls(image_url)
return """
{%for url in image_urls%}
{%endfor%}
"""
```
### 注意
[您可以在此处找到代码文件](https://github.com/DTAIEB/Thoughtful-Data-Science/blob/master/chapter%206/sampleCode18.py)。
注意`@templateArgs`装饰器的使用，它允许 Jinja2 片段引用本地`image_urls`变量。
最后，在`do_score_url`路由中，我们调用`score_image`并将结果显示为列表：
```py
[[ScoreImageApp]]
@route(score_url="*")
@templateArgs
def do_score_url(self, score_url):
results = score_image(self.graph, self.model, score_url)
return """
{%for label, confidence in results%}
- {{label}}: {{confidence}}
{%endfor%}
"""
```
### 注意
[您可以在此处找到代码文件](https://github.com/DTAIEB/Thoughtful-Data-Science/blob/master/chapter%206/sampleCode19.py)。
以下屏幕截图显示了包含猫图像的 Flickr 页面的结果：
猫的图像分类结果
### 注意
[提醒一下，您可以在以下位置找到完整的笔记本](https://github.com/DTAIEB/Thoughtful-Data-Science/blob/master/chapter%206/Tensorflow%20VR%20Part%202.ipynb)。
我们的 MVP 应用即将完成。 在下一节中，我们将在笔记本中直接集成 TensorBoard 图可视化。
## 第 3 部分——集成 TensorBoard 图可视化
### 注意
[**注意**：本节中描述的部分代码改编自位于此处的`deepdream`笔记本](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/examples/tutorials/deepdream/deepdream.ipynb)。
[您可以在此处下载完整的笔记本以遵循本节的讨论](https://github.com/DTAIEB/Thoughtful-Data-Science/blob/master/chapter%206/Tensorflow%20VR%20Part%203.ipynb)。
TensorFlow 带有非常强大的可视化套件，可帮助您调试和优化应用的性能。 [请花一点时间在这里探索 TensorBoard 功能](https://www.tensorflow.org/programmers_guide/summaries_and_tensorboard)。
这里的一个问题是，配置 TensorBoard 服务器以使其与笔记本电脑一起使用可能会很困难，尤其是如果您的笔记本电脑托管在云中，并且您几乎无法访问基础操作系统。 在这种情况下，配置和启动 TensorBoard 服务器可能证明是不可能的任务。 在本节中，我们将说明如何通过将模型图可视化直接集成到您的笔记本电脑中（零配置）来解决此问题。 为了提供更好的用户体验，我们想将 TensorBoard 可视化添加到我们的 PixieApp 中。 为此，我们将主布局更改为选项卡布局，然后将 TensorBoard 可视化效果分配给自己的选项卡。 方便地，PixieDust 提供了一个名为`TemplateTabbedApp`的基本 PixieApp，用于构建选项卡式布局。 使用`TemplateTabbedApp`作为基类时，我们需要按以下方式配置`setup`方法中的选项卡：
```py
[[ImageRecoApp]]
from pixiedust.apps.template import TemplateTabbedApp
@PixieApp
class ImageRecoApp(TemplateTabbedApp):
def setup(self):
self.apps = [
{"title": "Score", "app_class": "ScoreImageApp"},
{"title": "Model", "app_class": "TensorGraphApp"},
{"title": "Labels", "app_class": "LabelsApp"}
]
self.model = models["mobilenet"]
self.graph = self.load_graph(self.model)
app = ImageRecoApp()
app.run()
```
### 注意
[您可以在此处找到代码文件](https://github.com/DTAIEB/Thoughtful-Data-Science/blob/master/chapter%206/sampleCode20.py)。
应该注意的是，在前面的代码中，我们尚未将`LabelsApp`子 PixieApp 添加到选项卡列表中，即使尚未实现。 因此，按预期，如果按原样运行代码，则`Labels`选项卡将失败。
`self.apps`包含定义选项卡的对象数组：
* `title`：标签标题
* `app_class`：选择选项卡时运行的 PixieApp
在`ImageRecoApp`中，我们配置了与三个子 PixieApps 相关的三个选项卡：我们已经在第 2 部分“为我们的图像识别示例应用创建一个 PixieApp”中创建的`ScoreImageApp`，会显示模型图，`LabelsApp`会显示模型中使用的所有标签类别的表格。
结果显示在以下屏幕截图中：
选项卡式布局，其中包括得分，模型和标签
使用`TemplateTabbedApp`超类的另一个好处是，分别定义了子 PixieApps，这使代码更易于维护和重用。
首先让我们看一下`TensorGraphApp` PixieApp。 它的主要路由返回一个 HTML 片段，该片段将`tf-graph-basic.build.html`从`https://tensorboard.appspot.com,`加载到 IFrame 中，并使用 JavaScript 加载监听器应用通过`tf.Graph.as_graph_def`方法计算的序列化图定义。 为确保图定义保持合理的大小，并避免浏览器客户端上不必要的性能下降，我们调用`strip_consts`方法来移除具有大尺寸的恒定值的张量。
`TensorGraphApp`的代码如下所示：
```py
@PixieApp
class TensorGraphApp():
"""Visualize TensorFlow graph."""
def setup(self):
self.graph = self.parent_pixieapp.graph
@route()
@templateArgs
def main_screen(self):
strip_def = self.strip_consts(self.graph.as_graph_def())
code = """
""".format(data=repr(str(strip_def)), id='graph'+ self.getPrefix()).replace('"', '"')
return """
"""
def strip_consts(self, graph_def, max_const_size=32):
"""Strip large constant values from graph_def."""
strip_def = tf.GraphDef()
for n0 in graph_def.node:
n = strip_def.node.add()
n.MergeFrom(n0)
if n.op == 'Const':
tensor = n.attr['value'].tensor
size = len(tensor.tensor_content)
if size > max_const_size:
tensor.tensor_content = "
".format(size).encode("UTF-8")
return strip_def
```
### 注意
[您可以在此处找到代码文件](https://github.com/DTAIEB/Thoughtful-Data-Science/blob/master/chapter%206/sampleCode21.py)。
**注意**：子级 PixieApps 可以通过`self.parent_pixieapp`变量访问其父级 PixieApp。
以下屏幕快照显示了`TensorGraphApp`子 PixieApp 的结果屏幕。 它为选定的模型提供了 TensorFlow 图的交互式可视化，允许用户浏览不同的节点并深入研究模型。 但是，重要的是要注意，可视化完全在浏览器中运行，而没有 TensorBoard 服务器。 因此，整个 TensorBoard 中可用的某些功能（例如运行时统计信息）被禁用。
显示 MobileNet V1 的模型图
在`LabelsApp` PixieApp 中，我们简单地将标签加载为 JSON 格式，并使用`handlerId=tableView`选项在 PixieDust 表中显示它：
```py
[[LabelsApp]]
@PixieApp
class LabelsApp():
def setup(self):
self.labels = self.parent_pixieapp.load_labels(
self.parent_pixieapp.model, as_json=True
)
@route()
def main_screen(self):
return """
{
"table_noschema": "true",
"handlerId": "tableView",
"rowCount": "10000"
}
"""
```
### 注意
[您可以在此处找到代码文件](https://github.com/DTAIEB/Thoughtful-Data-Science/blob/master/chapter%206/sampleCode22.py)。
**注意**：我们通过将`table_noschema`设置为`true`将表配置为不显示架构，但是为了方便起见，我们保留了搜索栏。
结果显示在以下屏幕截图中：
可搜索的表中的模型类别
我们的 MVP 图像识别示例应用现已完成； [您可以在此处找到完整的笔记本](https://github.com/DTAIEB/Thoughtful-Data-Science/blob/master/chapter%206/Tensorflow%20VR%20Part%203.ipynb)。
在下一个部分，我们将通过允许用户使用自定义图像重新训练模型来改进应用。
## 第 4 部分——使用自定义训练数据重新训练模型
### 注意
[**注意**：您可以下载完整的笔记本，以按照此处的讨论进行操作](https://github.com/DTAIEB/Thoughtful-Data-Science/blob/master/chapter%206/Tensorflow%20VR%20Part%204.ipynb)。
本节中的代码相当广泛，一些与该主题不直接相关的帮助器函数将被省略。 但是，与往常一样，请参阅 GitHub 上完整的笔记本以获取有关代码的更多信息。
在本节中，我们希望使用自定义训练数据对 MobileNet 模型进行再训练，并使用它来对在常规模型上得分较低的图像进行分类。
### 注意
[**注意**：本节中的代码改编自《将 TensorFlow 用于作诗》教程](https://github.com/googlecodelabs/tensorflow-for-poets-2/blob/master/scripts/retrain.py)。
在大多数情况下，获得高质量的训练数据可能是最艰巨且耗时的任务之一。 在我们的示例中，我们要训练的每个类都需要大量的图像。 为了简单和可重复性，我们使用 ImageNet 数据库方便地提供用于获取 URL 和相关标签的 API。 我们还将下载的文件限制为`.jpg`文件。 当然，如有需要，随时获取您自己的训练数据。
我们首先下载了 2011 年秋季版本中所有图像 URL 的列表，[可在此处下载](http://image-net.org/imagenet_data/urls/imagenet_fall11_urls.tgz)，然后将文件解压缩到您选择的本地目录（例如，我选择`/Users/dtaieb/Downloads/fall11_urls.txt`）。我们还需要下载[上所有`synsets`的 WordNet ID 和单词之间的映射，网址为 http://image-net.org/archive/ words.txt](http://image-net.org/archive/words.txt) ，我们将使用它来查找包含我们需要下载的 URL 的 WordNet ID。
以下代码将两个文件分别加载到 Pandas `DataFrame`中：
```py
import pandas
wnid_to_urls = pandas.read_csv('/Users/dtaieb/Downloads/fall11_urls.txt',
sep='\t', names=["wnid", "url"],
header=0, error_bad_lines=False,
warn_bad_lines=False, encoding="ISO-8859-1")
wnid_to_urls['wnid'] = wnid_to_urls['wnid'].apply(lambda x: x.split("_")[0])
wnid_to_urls = wnid_to_urls.dropna()
wnid_to_words = pandas.read_csv('/Users/dtaieb/Downloads/words.txt',
sep='\t', names=["wnid", "description"],
header=0, error_bad_lines=False,
warn_bad_lines=False, encoding="ISO-8859-1")
wnid_to_words = wnid_to_words.dropna()
```
### 注意
[您可以在此处找到代码文件](https://github.com/DTAIEB/Thoughtful-Data-Science/blob/master/chapter%206/sampleCode23.py)。
注意，我们需要清除`wnid_to_urls`数据集中的`wnid`列，因为它包含与类别中图像索引相对应的后缀。
然后，我们可以定义方法`get_url_for_keywords`，该方法返回一个字典，其中包含作为关键字的类别和作为值的 URL 数组：
```py
def get_url_for_keywords(keywords):
results = {}
for keyword in keywords:
df = wnid_to_words.loc[wnid_to_words['description'] == keyword]
row_list = df['wnid'].values.tolist()
descriptions = df['description'].values.tolist()
if len(row_list) > 0:
results[descriptions[0]] = \
wnid_to_urls.loc[wnid_to_urls['wnid'] == \
row_list[0]]["url"].values.tolist()
return results
```
### 注意
[您可以在此处找到代码文件](https://github.com/DTAIEB/Thoughtful-Data-Science/blob/master/chapter%206/sampleCode24.py)。
通过使用 PixieDust `display`，我们可以轻松浏览一下数据分布。 与往常一样，随时可以自己进行更多探索：
按类别分配图像
我们现在可以构建代码，该代码将下载与我们选择的类别列表相对应的图像。 在本例中，我们选择了水果：`["apple", "orange", "pear", "banana"]`。 图像将被下载到 PixieDust 主目录的子目录中（使用`pixiedust.utils`包中的 PixieDust `Environment`助手类），从而将图像数量限制为`500`以提高速度：
### 注意
**注意**：以下代码使用笔记本中先前定义的方法和导入。 在尝试运行以下代码之前，请确保运行相应的单元格。
```py
from pixiedust.utils.environment import Environment
root_dir = ensure_dir_exists(os.path.join(Environment.pixiedustHome, "imageRecoApp")
image_dir = root_dir
image_dict = get_url_for_keywords(["apple", "orange", "pear", "banana"])
with open(os.path.join(image_dir, "retrained_label.txt"), "w") as f_label:
for key in image_dict:
f_label.write(key + "\n")
path = ensure_dir_exists(os.path.join(image_dir, key))
count = 0
for url in image_dict[key]:
download_image_into_dir(url, path)
count += 1
if count > 500:
break;
```
### 注意
[您可以在此处找到代码文件](https://github.com/DTAIEB/Thoughtful-Data-Science/blob/master/chapter%206/sampleCode25.py)。
代码的下一部分使用以下步骤处理训练集中的每个图像：
### 注意
**注意**：如前所述，该代码相当广泛，并且省略了一部分； 这里仅说明重要部分。 请不要尝试按原样运行以下代码，并且请参阅完整的笔记本以获取完整的实现。
1. 使用以下代码对`.jpeg`文件进行解码：
```py
def add_jpeg_decoding(model):
input_height = get_model_attribute(model,
"input_height")
input_width = get_model_attribute(model, "input_width")
input_depth = get_model_attribute(model, "input_depth")
input_mean = get_model_attribute(model, "input_mean",
0)
input_std = get_model_attribute(model, "input_std",
255)
jpeg_data = tf.placeholder(tf.string,
name='DecodeJPGInput')
decoded_image = tf.image.decode_jpeg(jpeg_data,
channels=input_depth)
decoded_image_as_float = tf.cast(decoded_image,
dtype=tf.float32)
decoded_image_4d = tf.expand_dims(
decoded_image_as_float,
0)
resize_shape = tf.stack([input_height, input_width])
resize_shape_as_int = tf.cast(resize_shape,
dtype=tf.int32)
resized_image = tf.image.resize_bilinear(
decoded_image_4d,
resize_shape_as_int)
offset_image = tf.subtract(resized_image, input_mean)
mul_image = tf.multiply(offset_image, 1.0 / input_std)
return jpeg_data, mul_image
```
### 注意
[您可以在此处找到代码文件](https://github.com/DTAIEB/Thoughtful-Data-Science/blob/master/chapter%206/sampleCode26.py)。
2. 创建瓶颈值（适当地缓存它们），以通过调整大小和缩放比例来标准化图像。 这是通过以下代码完成的：
```py
def run_bottleneck_on_image(sess, image_data,
image_data_tensor,decoded_image_tensor,
resized_input_tensor,bottleneck_tensor):
# First decode the JPEG image, resize it, and rescale the pixel values.
resized_input_values = sess.run(decoded_image_tensor,
{image_data_tensor: image_data})
# Then run it through the recognition network.
bottleneck_values = sess.run(
bottleneck_tensor,
{resized_input_tensor: resized_input_values})
bottleneck_values = np.squeeze(bottleneck_values)
return bottleneck_values
```
### 注意
[您可以在此处找到代码文件](https://github.com/DTAIEB/Thoughtful-Data-Science/blob/master/chapter%206/sampleCode27.py)。
3. 在公共名称空间下，使用`add_final_training_ops`方法添加最终的训练操作，以便在可视化图时更易于操作。 训练步骤如下：
1. 使用`tf.truncated_normal` API 生成随机权重：
```py
initial_value = tf.truncated_normal(
[bottleneck_tensor_size, class_count],
stddev=0.001)
layer_weights = tf.Variable(
initial_value, name='final_weights')
```
2. 添加偏置，并初始化为零：
```py
layer_biases = tf.Variable(tf.zeros([class_count]),
name='final_biases')
```
3. 计算加权和：
```py
logits = tf.matmul(bottleneck_input, layer_weights) +
layer_biases
```
4. 添加`cross_entropy`成本函数：
```py
cross_entropy =
tf.nn.softmax_cross_entropy_with_logits(
labels=ground_truth_input, logits=logits)
with tf.name_scope('total'):
cross_entropy_mean = tf.reduce_mean(
cross_entropy)
```
]
5. 最小化成本函数：
```py
optimizer = tf.train.GradientDescentOptimizer(
learning_rate)
train_step = optimizer.minimize(cross_entropy_mean)
```
为了可视化重新训练的图，我们首先需要更新`TensorGraphApp` PixieApp，以让用户选择要可视化的模型：通用 MobileNet 或自定义。 这是通过在主路径中添加`
{%endfor%}