十二、在 Raspberry Pi 上开发 TensorFlow 应用

根据 Wikipedia 的说法，“ Raspberry Pi 是 Raspberry Pi 基金会在英国开发的一系列小型单板计算机，旨在促进学校和发展中国家的基础计算机科学教学。” Raspberry Pi 的官方网站将其描述为“一种小型且价格合理的计算机，可以用来学习编程。” 如果您以前从未听说过或使用过 Raspberry Pi，请访问其网站，然后您很快就会爱上这个很棒的小东西。几乎没有什么功能-实际上，TensorFlow 的开发人员从 2016 年中期开始在早期版本的 Raspberry Pi 上提供了 TensorFlow，因此我们可以在微型计算机上运行复杂的 TensorFlow 模型，您只需花费 35 美元即可购买到。这可能超出了“基础计算机科学的教学”或“学习编程”的范围，但另一方面，如果我们考虑过去几年中移动设备的所有飞速发展，那么看到如何在越来越小的设备中实现越来越多的功能，我们就不会感到惊讶。

在本章中，我们将进入 Raspberry Pi 的有趣世界，Raspberry Pi 是 TensorFlow 正式支持的最小设备。我们将首先介绍如何获取和设置新的 Raspberry Pi 3B 板，包括本章中使用的所有必要配件，以使其能够看，听和说。然后，我们将介绍如何使用 GoPiGo 机器人基础套件，将 Raspberry Pi 板变成一个可以移动的机器人。之后，我们将提供最简单的工作步骤，以便在 Raspberry Pi 上设置 TensorFlow 1.6 并构建其示例 Raspberry Pi 应用。我们还将讨论如何集成图像分类，这是我们在第 2 章，“通过迁移学习对图像进行分类”时使用的模型，并通过文字转语音功能使机器人告诉我们它可以识别的内容，以及如何集成音频识别，这是我们在第 5 章，“了解简单语音命令”中使用的模型以及 GoPiGo API，可让您使用语音命令来控制机器人的运动。

最后，我们将向您展示如何使用 TensorFlow 和 OpenAI Gym，这是一个用于开发和比较强化学习算法的 Python 工具包，如何在模拟环境中实现强大的强化学习算法，以使我们的机器人能够在真实环境中移动和平衡身体。

在 Google I/O 2016 中，有一个名为“如何使用 Cloud Vision 和 Speech API 构建智能的 RasPi Bot”的会话（您可以在 YouTube 上观看视频）。它使用 Google 的 Cloud API 执行图像分类以及语音识别和合成。在本章中，我们将了解如何在设备上离线实现演示中的任务以及增强学习，从而展示 TensorFlow 在 Raspberry Pi 上的强大功能。

总而言之，我们将在本章中涵盖以下主题，以构建一个可以移动，看到，聆听，说话和学习的机器人：

设置 Raspberry Pi 并使其移动
在 Raspberry Pi 上设置 TensorFlow
图像识别和文字转语音
音频识别和机器人运动
在 Raspberry Pi 上进行强化学习

设置 Raspberry Pi 并使其移动

小型单板 Raspberry Pi 计算机系列包括 Raspberry Pi 3B+，3B，2B，1B+，1A+，0 和 0W（有关详细信息，请参见这里）。我们将在此处使用 Pi 3B 主板，您可以从前面的链接或在 Amazon 上以 35 美元的价格购买。我们在主板上使用并测试过的配件及其价格如下：

CanaKit 5V 2.5A Raspberry Pi 电源约 10 美元，可在开发期间使用。
Kinobo - 大约 4 美元的可以记录您的语音命令的 USB 2.0 微型麦克风。
USHONK USB 微型扬声器约合 12 美元，可以播放合成声音。
Arducam 5 Megapixels 1080p 传感器 OV5647 微型相机约合 14 美元，以支持图像分类。
16GB MicroSD 和适配器，价格约为 10 美元，用于存储 Raspbian（Raspberry Pi 的官方操作系统）的安装文件，并用作安装后的硬盘驱动器。
一个 USB 磁盘，例如 SanDisk 32GB USB Drive，售价 9 美元，将用作交换分区（有关详细信息，请参阅下一节）因此我们可以手动构建 TensorFlow 库，这是构建和运行 TensorFlow C++ 代码所必需的。
售价 110 美元的 GoPiGo 机器人基础套件或官方网站，将 Raspberry Pi 板变成可以移动的机器人。

您还需要 HDMI 电缆将 Raspberry Pi 板连接到计算机显示器，USB 键盘和 USB 鼠标。总共要花 200 美元，包括 110 美元的 GoPiGo，来构建一个可以移动，看，听，说的 Raspberry Pi 机器人。尽管与功能强大的 Raspberry Pi 计算机相比，GoPiGo 套件似乎有点昂贵，但是如果没有它，那么一动不动的 Raspberry Pi 可能会失去很多吸引力。

有一个较旧的博客，“如何用 100 美元和 TensorFlow 构建“可视”的机器人”，由 Lukas Biewald 于 2016 年 9 月撰写，内容涵盖了如何使用 TensorFlow 和 Raspberry Pi 3 以及一些其他部件来构建能够说话和说话的机器人。这很有趣。我们这里介绍的内容除了提供语音命令识别和强化学习外，还提供了更详细的步骤来设置带有 GoPiGo 的 Raspberry Pi 3，GoPiGo（易于使用且受 Google 推荐的工具包，可将 Pi 变成机器人）以及更新版本的 TensorFlow 1.6。

现在，让我们首先看看如何设置 Raspbian，Raspberry Pi 开发板的操作系统。

设置 Raspberry Pi

最简单的方法是遵循 Raspbian 软件安装指南，总而言之，这是一个简单的三步过程：

为 Windows 或 Mac 下载并安装 SD 格式化程序。
使用 SD 格式化程序格式化 MicroSD 卡。
在这个页面上下载 Raspbian 的官方简易安装程序 New Out Of Box Software（NOOBS）的离线 ZIP 版本，将其解压缩，然后将提取的NOOBS文件夹中的所有文件拖放到格式化的 MicroSD 卡中。

现在弹出 MicroSD 卡并将其插入 Raspberry Pi 板上。将显示器的 HDMI 电缆以及 USB 键盘和鼠标连接到开发板上。用电源为开发板供电，然后按照屏幕上的步骤完成 Raspbian 的安装，包括设置 Wifi 网络。整个安装过程不到一个小时即可完成。完成后，您可以打开一个终端并输入ifconfig来查找电路板的 IP 地址，然后从您的计算中使用ssh pi@<board_ip_address>来访问它，正如我们稍后将要看到的，这确实很方便并且需要在移动中测试控制 Raspberry Pi 机器人 -- 当移动时，您不想或不能将键盘，鼠标和显示器与板子一起使用。

但是默认情况下未启用 SSH，因此，当您首次尝试 SSH 到 Pi 板上时，会出现“SSH 连接被拒绝”错误。启用它的最快方法是运行以下两个命令：

sudo systemctl enable ssh
sudo systemctl start ssh

之后，您可以使用pi登录的默认密码ssh进行登录。当然，您可以使用passwd命令将默认密码更改为新密码。

现在我们已经安装了 Raspbian，让我们将 USB 迷你麦克风，USB 迷你扬声器和迷你相机插入 Pi 板上。 USB 麦克风和扬声器均可即插即用。插入它们后，您可以使用aplay -l命令找出支持的音频播放设备：

aplay -l
**** List of PLAYBACK Hardware Devices ****
card 0: Device_1 [USB2.0 Device], device 0: USB Audio [USB Audio]
 Subdevices: 1/1
 Subdevice #0: subdevice #0
card 2: ALSA [bcm2835 ALSA], device 0: bcm2835 ALSA [bcm2835 ALSA]
 Subdevices: 8/8
 Subdevice #0: subdevice #0
 Subdevice #1: subdevice #1
 Subdevice #2: subdevice #2
 Subdevice #3: subdevice #3
 Subdevice #4: subdevice #4
 Subdevice #5: subdevice #5
 Subdevice #6: subdevice #6
 Subdevice #7: subdevice #7
card 2: ALSA [bcm2835 ALSA], device 1: bcm2835 ALSA [bcm2835 IEC958/HDMI]
 Subdevices: 1/1
 Subdevice #0: subdevice #0

Pi 板上还有一个音频插孔，可用于在开发过程中获得音频输出。但是 USB 扬声器肯定更方便。

要查找支持的记录设备，请使用arecord -l命令：

arecord -l
**** List of CAPTURE Hardware Devices ****
card 1: Device [USB PnP Sound Device], device 0: USB Audio [USB Audio]
 Subdevices: 1/1
 Subdevice #0: subdevice #0

现在，您可以使用以下命令测试音频记录：

arecord -D plughw:1,0 -d 3 test.wav

-D指定音频输入设备，这意味着它是具有卡 1，设备 0 的即插即用设备，如arecord -l命令的输出所示。 -d以秒为单位指定记录的持续时间。

要在 USB 扬声器上播放录制的音频，首先需要在主目录中创建一个名为 .asoundrc的文件，其内容如下：

pcm.!default {
       type plug
       slave {
            pcm "hw:0,0"
       }
}

ctl.!default {
       type hw
       card 0
}

请注意，"hw:0,0"与aplay -l为 USB 扬声器设备返回的卡 0，设备 0 信息匹配。现在，您可以使用aplay test.wav命令在扬声器上测试录制的音频播放。

有时，Pi 板重新启动后，系统会自动更改 USB 扬声器的卡号，并且在运行aplay test.wav时您听不到声音。在这种情况下，您可以再次运行aplay -l来找到为 USB 扬声器设置的新卡号，并相应地更新~/.asoundrc文件。

如果要调节扬声器的音量，请使用amixer set PCM -- 100%命令，其中 100% 将音量设置为最大。

要加载相机的驱动程序，请运行sudo modprobe bcm2835-v4l2命令。之后，要验证是否已检测到摄像机，请运行vcgencmd get_camera命令，该命令应返回supported=1 detected=1 。要在每次主板启动时加载摄像机驱动程序（这是我们需要的），请运行sudo vi /etc/modules并在/etc/modules的末尾添加一行 bcm2835-v4l2（或者您可以运行sudo bash -c "echo 'bcm2835-v4l2' >> /etc/modules"）。当我们运行 TensorFlow 图像分类示例时，我们将在后面的部分中测试相机。

这就是为我们的任务设置 Raspberry Pi 的全部内容。现在，让我们看看如何使其移动。

使树莓派移动

GoPiGo 是一个流行的工具包，可将您的 Raspberry Pi 板变成移动的机器人。购买并收到我们之前提到的 GoPiGo 机器人基础套件后，请按照这里将其与您的 Pi 板组装在一起。根据您是同时观看 March March Madness 还是 NBA 季后赛比赛，这大约需要一两个小时。

完成后，您的 Raspberry Pi 机器人以及我们之前列出的所有附件应如下所示：

图 12.1：具有 GoPiGo 套件和相机，USB 扬声器和 USB 麦克风的 Raspberry Pi 机器人

现在，使用 Raspberry Pi 电源打开 Pi 机器人，并在启动后使用ssh pi@<your_pi_board_ip>连接到它。要安装 GoPiGo Python 库，以便我们可以使用 GoPiGo 的 Python API 控制机器人，请运行以下命令，它将执行一个 shell 脚本，该脚本创建一个新的/home/pi/Dexter目录并在其中安装所有库和固件文件：

sudo sh -c "curl -kL dexterindustries.com/update_gopigo3 | bash"

您还应该转到~/Dexter目录并运行以下命令来更新 GoPiGo 板的固件：

bash GoPiGo3/Firmware/gopigo3_flash_firmware.sh

现在运行sudo reboot重新启动板，以使更改生效。 Pi 板重新启动后，您可以从 iPython 测试 GoPiGo 和 Raspberry Pi 的运动，可以使用sudo pip install ipython进行安装。

要测试基本的 GoPiGo Python API，请先运行 iPython，然后逐行输入以下代码：

当 GoPiGo Raspberry Pi 机器人开始移动时，请确保将其放在安全的表面上。在最终测试期间，应使用 GoPiGo 电池组为机器人供电，使其可以自由移动。但是在开发和初始测试中，除非您使用充电电池，否则绝对应该使用电源适配器来节省电池。如果将机器人放在桌子上，请务必小心，因为如果发出命令导致机器人动作不佳，机器人可能会跌落。

import easygopigo3 as easy
gpg3_obj = easy.EasyGoPiGo3() 

gpg3_obj.drive_cm(5)
gpg3_obj.drive_cm(-5) 
gpg3_obj.turn_degrees(30)
gpg3_obj.turn_degrees(-30)
gpg3_obj.stop()

drive_cm根据其参数值是正值还是负值来向前或向后移动机器人。 turn_degrees顺时针或逆时针旋转机器人，取决于其参数值是正值还是负值。因此，前面的示例代码将机器人向前移动 5 厘米，然后向后移动 5 厘米，顺时针旋转 30 度，然后逆时针旋转 30 度。默认情况下，这些调用是阻塞调用，因此直到机器人完成移动后它们才返回。要进行非阻塞调用，请添加False参数，如下所示：

gpg3_obj.drive_cm(5, False)
gpg3_obj.turn_degrees(30, False)

您还可以使用forward，backward和许多其他 API 调用来控制机器人的运动，但是在本章中，我们仅使用drive_cm和turn_degrees。

我们现在准备使用 TensorFlow 向机器人添加更多智能。

在 Raspberry Pi 上设置 TensorFlow

要在 Python 中使用 TensorFlow，就像我们稍后在“音频识别”和“强化学习”部分中所做的那样，我们可以在 TensorFlow Jenkins 持续集成站点上为 Pi 安装每晚 TensorFlow 1.6 版本：

sudo pip install http://ci.tensorflow.org/view/Nightly/job/nightly-pi/lastSuccessfulBuild/artifact/output-artifacts/tensorflow-1.6.0-cp27-none-any.whl

此方法更为常见，并在一个不错的博客条目中描述，《为 Raspberry Pi 交叉编译 TensorFlow》，作者是 Pete Warden。

一种更复杂的方法是使用makefile，这在您需要构建和使用 TensorFlow 库时是必需的。 TensorFlow 官方 makefile 文档的 Raspberry Pi 部分包含构建 TensorFlow 库的详细步骤，但是它可能不适用于每个版本的 TensorFlow。此处的步骤与 TensorFlow 的早期版本（0.10）完美配合，但是在 TensorFlow 1.6 中会导致许多“未定义对google::protobuf的引用”错误。

TensorFlow 1.6 版本已经测试了以下步骤，可从下载 https://github.com/tensorflow/tensorflow/releases/tag/v1.6.0 ; 您当然可以在 TensorFlow 发行页面中尝试使用较新的版本，或者通过git clone https://github.com/tensorflow/tensorflow克隆最新的 TensorFlow 源，并修复所有可能的问题。

在cd之后到 TensorFlow 源根目录，然后运行以下命令：

tensorflow/contrib/makefile/download_dependencies.sh
sudo apt-get install -y autoconf automake libtool gcc-4.8 g++-4.8
cd tensorflow/contrib/makefile/downloads/protobuf/
./autogen.sh
./configure
make CXX=g++-4.8
sudo make install
sudo ldconfig # refresh shared library cache
cd ../../../../..
export HOST_NSYNC_LIB=`tensorflow/contrib/makefile/compile_nsync.sh`
export TARGET_NSYNC_LIB="$HOST_NSYNC_LIB"

确保您运行的是make CXX=g++-4.8，而不是运行在正式 TensorFlow Makefile 文档中的make，因为 Protobuf 必须使用与用于构建以下 TensorFlow 的版本相同的gcc版本来编译库，以修复那些“未定义对google::protobuf的引用”错误。现在尝试使用以下命令构建 TensorFlow 库：

make -f tensorflow/contrib/makefile/Makefile HOST_OS=PI TARGET=PI \
 OPTFLAGS="-Os -mfpu=neon-vfpv4 -funsafe-math-optimizations -ftree-vectorize" CXX=g++-4.8

经过几个小时的构建，您可能会收到诸如“虚拟内存耗尽：无法分配内存”之类的错误，否则 Pi 板将由于内存不足而冻结。要解决此问题，我们需要设置一个交换，因为没有交换，当应用用尽内存时，由于内核崩溃，该应用将被杀死。设置交换的方法有两种：交换文件和交换分区。 Raspbian 在 SD 卡上使用默认的 100MB 交换文件，如下所示，使用free命令：

pi@raspberrypi:~/tensorflow-1.6.0 $ free -h
total used free shared buff/cache available
Mem: 927M 45M 843M 660K 38M 838M
Swap: 99M 74M 25M

要将交换文件大小提高到 1GB，请通过 sudo vi /etc/dphys-swapfile修改 /etc/dphys-swapfile文件，将CONF_SWAPSIZE=100更改为CONF_SWAPSIZE=1024，然后重新启动交换文件服务：

sudo /etc/init.d/dphys-swapfile stop 
sudo /etc/init.d/dphys-swapfile start

此后，free -h将显示交换总量为 1.0GB。

交换分区是在单独的 USB 磁盘上创建的，因此首选交换分区，因为交换分区不会碎片化，但 SD 卡上的交换文件很容易碎片化，从而导致访问速度变慢。要设置交换分区，请将没有所需数据的 USB 闪存盘插入 Pi 板上，然后运行sudo blkid，您将看到类似以下内容：

/dev/sda1: LABEL="EFI" UUID="67E3-17ED" TYPE="vfat" PARTLABEL="EFI System Partition" PARTUUID="622fddad-da3c-4a09-b6b3-11233a2ca1f6"
/dev/sda2: UUID="E67F-6EAB" TYPE="vfat" PARTLABEL="NO NAME" PARTUUID="a045107a-9e7f-47c7-9a4b-7400d8d40f8c"

/dev/sda2是我们将用作交换分区的分区。现在卸载并将其格式化为交换分区：

sudo umount /dev/sda2
sudo mkswap /dev/sda2
mkswap: /dev/sda2: warning: wiping old swap signature.
Setting up swapspace version 1, size = 29.5 GiB (31671701504 bytes)
no label, UUID=23443cde-9483-4ed7-b151-0e6899eba9de

您将在mkswap命令中看到一个 UUID 输出。运行sudo vi /etc/fstab，将以下行添加到具有 UUID 值的fstab文件中：

UUID=<UUID value> none swap sw,pri=5 0 0

保存并退出 fstab 文件，然后运行sudo swapon -a。现在，如果再次运行free -h，将会看到“交换总数”接近 USB 存储设备的大小。我们绝对不需要所有大小的交换空间—实际上，具有 1GB 内存的 Raspberry Pi 3 板的建议最大交换大小为 2GB，但是我们将其保留原样，因为我们只是想成功地构建内存。 TensorFlow 库。

更改任一交换设置后，我们可以重新运行make命令：

make -f tensorflow/contrib/makefile/Makefile HOST_OS=PI TARGET=PI \
 OPTFLAGS="-Os -mfpu=neon-vfpv4 -funsafe-math-optimizations -ftree-vectorize" CXX=g++-4.8

完成此操作后，TensorFlow 库将以tensorflow/contrib/makefile/gen/lib/libtensorflow-core.a的形式生成，如果您已经阅读了我们手动构建 TensorFlow 库的前几章，则应该看起来很熟悉。现在，我们可以使用该库构建图像分类示例。

图像识别和文字转语音

在tensorflow/contrib/pi_examples: label_image和相机中有两个 TensorFlow Raspberry Pi 示例应用。我们将修改相机示例应用，以将文本集成到语音中，以便该应用在四处走动时可以说出其识别出的图像。在构建和测试这两个应用之前，我们需要安装一些库并下载预构建的 TensorFlow Inception 模型文件：

sudo apt-get install -y libjpeg-dev
sudo apt-get install libv4l-dev

curl https://storage.googleapis.com/download.tensorflow.org/models/inception_dec_2015_stripped.zip -o /tmp/inception_dec_2015_stripped.zip

cd ~/tensorflow-1.6.0
unzip /tmp/inception_dec_2015_stripped.zip -d tensorflow/contrib/pi_examples/label_image/data/

要构建label_image和相机应用，请运行：

make -f tensorflow/contrib/pi_examples/label_image/Makefile
make -f tensorflow/contrib/pi_examples/camera/Makefile

构建应用时，您可能会遇到以下错误：

./tensorflow/core/platform/default/mutex.h:25:22: fatal error: nsync_cv.h: No such file or directory
 #include "nsync_cv.h"
 ^
 compilation terminated.

要解决此问题，请运行sudo cp tensorflow/contrib/makefile/downloads/nsync/public/nsync*.h /usr/include。

然后编辑tensorflow/contrib/pi_examples/label_image/Makefile或 tensorflow/contrib/pi_examples/camera/Makefile文件，添加以下库，并在再次运行make命令之前包含路径：

-L$(DOWNLOADSDIR)/nsync/builds/default.linux.c++11 \

-lnsync \

要测试运行这两个应用，请直接运行这些应用：

tensorflow/contrib/pi_examples/label_image/gen/bin/label_image
tensorflow/contrib/pi_examples/camera/gen/bin/camera

看看 C++ 源代码tensorflow/contrib/pi_examples/label_image/label_image.cc和tensorflow/contrib/pi_examples/camera/camera.cc，您会看到它们使用与前几章中的 iOS 应用类似的 C++ 代码来加载模型图文件，准备输入张量，运行模型，并获得输出张量。

默认情况下，摄像机示例还使用label_image/data文件夹中解压缩的预构建 Inception 模型。但是对于您自己的特定图像分类任务，提供通过迁移学习重新训练的模型。您可以像第 2 章，“通过迁移学习对图像进行分类”一样，在运行两个示例应用时使用--graph参数。

通常，语音是 Raspberry Pi 机器人与我们互动的主要 UI。理想情况下，我们应该运行 TensorFlow 支持的自然声音文本到语音（TTS）模型，例如 WaveNet 或 Tacotron，但运行和部署不在本章范围之内。这样的模型。事实证明，我们可以使用称为 CMU Flite 的简单得多的 TTS 库，它提供了相当不错的 TTS，并且只需一个简单的命令即可安装它：sudo apt-get install flite。如果要安装最新版本的 Flite 以期希望获得更好的 TTS 质量，只需从链接下载最新的 Flite 源并进行构建。

要使用我们的 USB 扬声器测试 Flite，请使用-t参数运行 flite，然后使用双引号引起来的文本字符串，例如 flite -t "i recommend the ATM machine"。如果您不喜欢默认语音，则可以通过运行 flite -lv找到其他受支持的语音，它们应返回 Voices available: kal awb_time kal16 awb rms slt 。然后，您可以指定用于 TTS 的语音： flite -voice rms -t "i recommend the ATM machine"。

要使相机应用说出识别出的对象，这是当 Raspberry Pi 机器人四处移动时所期望的行为，可以使用以下简单的pipe命令：

tensorflow/contrib/pi_examples/camera/gen/bin/camera | xargs -n 1 flite -t

您可能会听到太多声音。要微调图像分类的 TTS 结果，还可以在使用make -f tensorflow/contrib/pi_examples/camera/Makefile重建示例之前，修改camera.cc文件并将以下代码添加到PrintTopLabels函数中：

std::string cmd = "flite -voice rms -t \"";
cmd.append(labels[label_index]);
cmd.append("\"");
system(cmd.c_str());

现在，我们已经完成了“如何使用 Cloud Vision 和 Speech API 来构建智能 RasPi Bot 演示”的图像分类和语音合成任务，而不使用任何 Cloud API。使用我们在第 5 章，“了解简单语音命令”中使用的相同模型，在 Raspberry Pi 上进行音频识别。

音频识别和机器人运动

要使用 TensorFlow 教程中的预训练音频识别模型或我们之前描述的重新训练模型，我们将重用来自这个页面的 Python 脚本listen.py，并在识别四个基本音频命令后添加 GoPiGo API 调用以控制机器人的运动："left", "right", "go", "stop"。预训练模型支持的其他六个命令-"yes", "no", "up", "down", "on", "off"，在我们的示例中不太适用，如果需要，您可以使用第 5 章， “了解简单语音命令”中所示的重新训练模型，以支持针对特定任务的其他语音命令。

要运行脚本，请先从这里下载预训练的音频识别模型，然后将其解压缩到/tmp，或者对我们在第 5 章“了解简单语音命令”中使用的模型使用scp到 Pi 板的/tmp目录，然后运行：

python listen.py --graph /tmp/conv_actions_frozen.pb --labels /tmp/conv_actions_labels.txt -I plughw:1,0

或者您可以运行：

python listen.py --graph /tmp/speech_commands_graph.pb --labels /tmp/conv_actions_labels.txt -I plughw:1,0

请注意，plughw value 1,0应该与您的 USB 麦克风的卡号和设备号匹配，可以使用我们之前显示的arecord -l命令找到。

listen.py脚本还支持许多其他参数。例如，我们可以使用--detection_threshold 0.5代替默认的检测阈值 0.8。

现在，让我们快速了解listen.py的工作原理，然后再添加 GoPiGo API 调用以使机器人移动。 listen.py使用 Python 的subprocess模块及其Popen类产生带有适当参数的运行arecord命令的新过程。 Popen类具有stdout属性，该属性指定arecord执行的命令的标准输出文件句柄，可用于读取记录的音频字节。

加载训练后的模型图的 Python 代码如下：

with tf.gfile.FastGFile(filename, 'rb') as f:
  graph_def = tf.GraphDef()
  graph_def.ParseFromString(f.read())
  tf.import_graph_def(graph_def, name='')

使用tf.Session()创建 TensorFlow 会话，并在加载图并创建会话之后，将记录的音频缓冲区以及采样率作为输入数据发送到 TensorFlow 会话的run方法，该方法返回识别的预测：

run(softmax_tensor, {
 self.input_samples_name_: input_data,
 self.input_rate_name_: self.sample_rate_
 })

在这里，将softmax_tensor定义为 TensorFlow 图的get_tensor_by_name(self.output_name_)，将output_name_，input_samples_name_和input_rate_name_分别定义为labels_softmax，decoded_sample_data:0和decoded_sample_data:1，我们在第 5 章，“了解简单语音命令”中的 iOS 和 Android 应用中使用过它。

在之前的章节中，我们主要使用 Python 训练和测试 TensorFlow 模型，然后再使用本机 TensorFlow C++ 库的 Java 接口代码在使用 C++ 或 Android 的 iOS 中运行模型。在 Raspberry Pi 上，您可以选择直接使用 TensorFlow Python API 或 C++ API 在 Pi 上运行 TensorFlow 模型，尽管通常仍会在功能更强大的电脑上训练模型。有关完整的 TensorFlow Python API 文档，请参见这里。

要使用 GoPiGo Python API 使机器人根据您的语音命令移动，请首先在listen.py中添加以下两行：

import easygopigo3 as gpg

gpg3_obj = gpg.EasyGoPiGo3()

然后将以下代码添加到def add_data方法的末尾：

if current_top_score > self.detection_threshold_ and time_since_last_top > self.suppression_ms_:
  self.previous_top_label_ = current_top_label
  self.previous_top_label_time_ = current_time_ms
  is_new_command = True
  logger.info(current_top_label)

  if current_top_label=="go":
    gpg3_obj.drive_cm(10, False)
  elif current_top_label=="left":
    gpg3_obj.turn_degrees(-30, False)
  elif current_top_label=="right":
    gpg3_obj.turn_degrees(30, False)
  elif current_top_label=="stop":
    gpg3_obj.stop()

现在将您的 Raspberry Pi 机器人放在地面上，从计算机上用ssh连接到它，然后运行以下脚本：

python listen.py --graph /tmp/conv_actions_frozen.pb --labels /tmp/conv_actions_labels.txt -I plughw:1,0 --detection_threshold 0.5

您将看到以下输出：

INFO:audio:started recording
INFO:audio:_silence_
INFO:audio:_silence_

然后，您可以说左，右，停止，前进和停止，以查看命令被识别并且机器人相应地移动：

INFO:audio:left
INFO:audio:_silence_
INFO:audio:_silence_
INFO:audio:right
INFO:audio:_silence_
INFO:audio:stop
INFO:audio:_silence_
INFO:audio:go
INFO:audio:stop

您可以在单独的终端中运行相机应用，因此，当机器人根据您的语音命令走动时，它会识别出所看到的新图像并说出结果。这就是构建一个基本的 Raspberry Pi 机器人所需的全部内容，该机器人可以听，动，看和说-Google I/O 2016 演示所做的事情，却不使用任何 Cloud API。它远不是一个能听懂自然人的语音，进行有趣的对话或执行有用且不重要的任务的幻想机器人。但是，借助预训练，再训练或其他强大的 TensorFlow 模型，并使用各种传感器，您当然可以为我们构建的 Pi 机器人增加越来越多的智能和物理动力。

在下一节中，您将看到如何在 Pi 上运行经过预训练和再训练的 TensorFlow 模型，我们将向您展示如何向使用 TensorFlow 构建和训练的机器人添加强大的强化学习模型。毕竟，强化学习的反复试验方式及其与环境交互以获取最大回报的本质，使得强化学习成为机器人非常合适的机器学习方法。

在 Raspberry Pi 上进行强化学习

OpenAI Gym是一个开源 Python 工具包，提供了许多模拟环境来帮助您开发，比较和训练强化学习算法，因此您无需购买所有传感器并在实际环境中训练您的机器人，这在时间和金钱上都是昂贵的。在本部分中，我们将向您展示如何在 TenAI 健身房的称为 CartPole。

要安装 OpenAI Gym，请运行以下命令：

git clone https://github.com/openai/gym.git
cd gym
sudo pip install -e .

您可以通过运行pip list来验证是否已安装 TensorFlow 1.6 和 Gym（“在 Raspberry Pi 上设置 TensorFlow”的最后部分介绍了如何安装 TensorFlow 1.6）：

pi@raspberrypi:~ $ pip list
gym (0.10.4, /home/pi/gym)
tensorflow (1.6.0)

或者您可以启动 iPython，然后导入 TensorFlow 和 Gym：

pi@raspberrypi:~ $ ipython
Python 2.7.9 (default, Sep 17 2016, 20:26:04) 
IPython 5.5.0 -- An enhanced Interactive Python.

In [1]: import tensorflow as tf

In [2]: import gym

In [3]: tf.__version__
Out[3]: '1.6.0'

In [4]: gym.__version__
Out[4]: '0.10.4'

现在，我们都准备使用 TensorFlow 和 Gym 来构建一些有趣的在 Raspberry Pi 上运行的强化学习模型。

了解 CartPole 模拟环境

CartPole 是一种可用于训练机器人以保持平衡的环境-如果它携带某些东西并希望在移动时保持其放置状态。由于本章的范围，我们将仅构建在模拟 CartPole 环境中工作的模型，但是可以肯定地将模型以及模型的构建和训练方式应用于类似于 CartPole 的实际物理环境。

在 CartPole 环境中，将杆连接到推车，该推车沿轨道水平移动。您可以对购物车执行 1（向右加速）或 0（向左加速）操作。杆子开始直立，目的是防止其跌落。杆保持直立的每个时间步长都奖励 1。当极点与垂直方向的夹角超过 15 度，或者手推车从中心移出 2.4 个单位以上时，剧集就会结束。

现在让我们使用 CartPole 环境。首先，创建一个新环境并找出智能体可以在该环境中采取的措施：

env = gym.make("CartPole-v0")
env.action_space
# Discrete(2)
env.action_space.sample()
# 0 or 1

每个观察（状态）都由关于购物车的四个值组成：其水平位置，速度，极角和角速度：

obs=env.reset()
obs
# array([ 0.04052535, 0.00829587, -0.03525301, -0.00400378])

环境中的每个步骤（动作）将导致新的观察，动作的奖励，剧集是否完成（如果是，则您无法采取任何进一步的步骤）以及一些其他信息：

obs, reward, done, info = env.step(1)

obs
# array([ 0.04069127, 0.2039052 , -0.03533309, -0.30759772])

记住动作（或步骤）1 表示向右移动，0 表示向左移动。要查看当您继续向右移动购物车时剧集可以持续多长时间，请运行：

while not done:
    obs, reward, done, info = env.step(1)
    print(obs)

#[ 0.08048328 0.98696604 -0.09655727 -1.54009127]
#[ 0.1002226 1.18310769 -0.12735909 -1.86127705]
#[ 0.12388476 1.37937549 -0.16458463 -2.19063676]
#[ 0.15147227 1.5756628 -0.20839737 -2.52925864]
#[ 0.18298552 1.77178219 -0.25898254 -2.87789912]

现在，让我们手动执行从头到尾的一系列操作，并打印出观测值的第一个值（水平位置）和第三个值（极点与垂直方向的度数），因为这两个值确定一个剧集是否为完成。

首先，重置环境并正确加速购物车几次：

import numpy as np

obs=env.reset()
obs[0], obs[2]*360/np.pi
# (0.008710582898326602, 1.4858315848689436)

obs, reward, done, info = env.step(1)
obs[0], obs[2]*360/np.pi
# (0.009525842685697472, 1.5936049816642313)

obs, reward, done, info = env.step(1)
obs[0], obs[2]*360/np.pi
# (0.014239775393474322, 1.040038643681757)

obs, reward, done, info = env.step(1)
obs[0], obs[2]*360/np.pi
# (0.0228521194217381, -0.17418034908781568)

您会看到，推车向右移动时，其位置值会越来越大，杆的垂直度会越来越小，最后一步显示的是负度，这意味着杆位于中心的左侧。所有这一切都是有道理的，在您心目中，您最喜欢的狗用杆子推着推车的画面有些生动。现在，更改动作以使购物车向左（0）加速几次：

obs, reward, done, info = env.step(0)
obs[0], obs[2]*360/np.pi
# (0.03536432554326476, -2.0525933052704954)

obs, reward, done, info = env.step(0)
obs[0], obs[2]*360/np.pi
# (0.04397450935915654, -3.261322987287562)

obs, reward, done, info = env.step(0)
obs[0], obs[2]*360/np.pi
# (0.04868738508385764, -3.812330822419413)

obs, reward, done, info = env.step(0)
obs[0], obs[2]*360/np.pi
# (0.04950617929263011, -3.7134404042580687)

obs, reward, done, info = env.step(0)
obs[0], obs[2]*360/np.pi
# (0.04643238384389254, -2.968245724428785)

obs, reward, done, info = env.step(0)
obs[0], obs[2]*360/np.pi
# (0.039465670006712444, -1.5760901885345346)

首先，您可能会惊讶于 0 动作导致位置（obs[0]）连续变大几次，但请记住，手推车以一定速度运动，并且一个或多个动作将手推车移至另一个方向不会立即降低位置值。但是，如果您继续将购物车向左移动，如前两个步骤所示，您会看到购物车的位置开始变小（向左）。现在继续执行 0 动作，您会看到位置越来越小，负值表示推车进入中心的左侧，而杆的角度越来越大：

obs, reward, done, info = env.step(0)
obs[0], obs[2]*360/np.pi
# (0.028603948219811447, 0.46789197320636305)

obs, reward, done, info = env.step(0)
obs[0], obs[2]*360/np.pi
# (0.013843572459953138, 3.1726728882727504)

obs, reward, done, info = env.step(0)
obs[0], obs[2]*360/np.pi
# (-0.00482029774222077, 6.551160678086707)

obs, reward, done, info = env.step(0)
obs[0], obs[2]*360/np.pi
# (-0.02739315127299434, 10.619948631208114)

如我们前面所述，定义 CartPole 环境的方式是剧集“当极距与垂直方向成 15 度以上时结束”，因此让我们再做一些动作并打印出done值，时间：

obs, reward, done, info = env.step(0)
obs[0], obs[2]*360/np.pi, done
# (-0.053880356973985064, 15.39896478042983, False)

obs, reward, done, info = env.step(0)
obs[0], obs[2]*360/np.pi, done
# (-0.08428612474261402, 20.9109976051126, False)

obs, reward, done, info = env.step(0)
obs[0], obs[2]*360/np.pi, done
# (-0.11861214326416822, 27.181070460526062, True)

obs, reward, done, info = env.step(0)
# WARN: You are calling 'step()' even though this environment has already returned done = True. You should always call 'reset()' once you receive 'done = True' -- any further steps are undefined behavior.

环境决定何时将done返回True时会有一些延迟-尽管前两个步骤已经返回了大于 15 度的度数（当极点与垂直线成 15 度以上时，剧集结束了），您仍然可以对环境执行 0 操作。第三步将done返回为True，并且环境中的另一步骤（最后一步）将导致警告，因为环境已经完成了该剧集。

对于 CartPole 环境，每个step调用返回的reward值始终为 1，信息始终为{}。这就是关于 CartPole 模拟环境的全部知识。现在我们了解了 CartPole 的工作原理，让我们看看可以在每种状态（观察）下制定什么样的策略，我们可以让该策略告诉我们要采取的操作（步骤），以便我们可以保持杆直立。换句话说，就是尽可能长的时间，这样我们才能最大化我们的回报。请记住，强化学习中的一项策略只是一个函数，该函数以智能体所处的状态为输入，并输出智能体接下来应采取的行动，以实现值最大化或长期回报。

从基本的直观策略开始

显然，每次都执行相同的动作（全 0 或 1s）不会使杆保持太直的状态。为了进行基线比较，请运行以下代码，以查看在每个剧集中应用相同操作时在 1,000 个剧集中获得的平均奖励：

# single_minded_policy.py

import gym
import numpy as np

env = gym.make("CartPole-v0")
total_rewards = []
for _ in range(1000):
  rewards = 0
  obs = env.reset()
  action = env.action_space.sample()
  while True:
    obs, reward, done, info = env.step(action) 
    rewards += reward
    if done:
      break
  total_rewards.append(rewards)

print(np.mean(total_rewards))
# 9.36

因此，所有 1,000 集的平均奖励约为 10。请注意， env.action_space.sample()对 0 或 1 动作进行采样，与随机输出 0 或 1 相同。您可以通过求值np.sum([env.action_space.sample() for _ in range(10000)])，应该接近 5,000。

要查看其他策略如何更好地工作，让我们使用一个简单直观的策略，当极数度数为正（在垂直方向的右侧）时执行 1 动作（向右移动购物车），然后执行 0（将购物车向右移动）当极数度数为负时（在垂直方向的左侧）。这项策略是有道理的，因为我们可能会采取尽可能长时间保持平衡的措施：

# simple_policy.py

import gym
import numpy as np

env = gym.make("CartPole-v0")

total_rewards = []
for _ in range(1000):
  rewards = 0
  obs = env.reset()
  while True:
    action = 1 if obs[2] > 0 else 0
    obs, reward, done, info = env.step(action) 
    rewards += reward
    if done:
       break
  total_rewards.append(rewards)

print(np.mean(total_rewards))
# 42.19

现在，每 1,000 集的平均奖励为 42，与 9.36 相比有很大提高。

现在让我们看看我们是否可以制定出更好，更复杂的策略。回想一下，策略只是从状态到操作的映射或函数。在过去的几年中，我们在神经网络的兴起中了解到的一件事是，如果不清楚如何定义复杂的函数（例如强化学习中的策略），请考虑一下神经网络，毕竟这是通用函数近似器（有关详细信息，请参见神经网络可以计算任何函数的可视化证明，Michael Nelson）。

在上一章中我们介绍了 AlphaGo 和 AlphaZero，Jim Fleming 撰写了一篇有趣的博客文章，标题为“在 AlphaGo 之前的 TD-Gammon”，这是第一个强化学习应用，它使用神经网络作为评估函数来训练自己，以击败五子棋冠军。博客条目和 Sutton 和 Barto 的《强化学习：入门》一书都对 TD-Gammon 进行了深入的描述。如果您想了解有关使用神经网络作为强大的通用函数的更多信息，还可以使用 Google 搜索“时差学习和 TD-Gammon”的原始论文。

使用神经网络建立更好的策略

首先，让我们看看如何使用简单的完全连接的（密集）神经网络构建随机策略，该网络将观察中的 4 个值作为输入，使用 4 个神经元的隐藏层，并输出 0 动作的概率，基于，智能体可以采样 0 到 1 之间的下一个动作：

# nn_random_policy.py

import tensorflow as tf
import numpy as np
import gym

env = gym.make("CartPole-v0") 

num_inputs = env.observation_space.shape[0]
inputs = tf.placeholder(tf.float32, shape=[None, num_inputs])
hidden = tf.layers.dense(inputs, 4, activation=tf.nn.relu)
outputs = tf.layers.dense(hidden, 1, activation=tf.nn.sigmoid)
action = tf.multinomial(tf.log(tf.concat([outputs, 1-outputs], 1)), 1)

with tf.Session() as sess:
  sess.run(tf.global_variables_initializer())

  total_rewards = []
  for _ in range(1000):
    rewards = 0
    obs = env.reset()
    while True:
      a = sess.run(action, feed_dict={inputs: obs.reshape(1, num_inputs)})
      obs, reward, done, info = env.step(a[0][0]) 
      rewards += reward
      if done:
        break
    total_rewards.append(rewards)

print(np.mean(total_rewards))

请注意，我们使用 tf.multinomial 函数根据动作 0 和 1 的概率分布，分别定义为outputs和1-outputs（两个概率之和为 1）对动作进行采样。总奖励的平均值约为 20 左右，比一心一意的策略好，但比上一节中的简单直观的策略差。这是一个神经网络，它在没有任何训练的情况下生成随机策略。

为了训练网络，我们使用tf.nn.sigmoid_cross_entropy_with_logits定义了网络输出与所需y_target作用之间的损失函数，该损失函数是使用前面小节中的基本简单策略定义的，因此我们希望该神经网络策略能够实现与基本的非神经网络策略大致相同的奖励：

# nn_simple_policy.py

import tensorflow as tf
import numpy as np
import gym

env = gym.make("CartPole-v0")

num_inputs = env.observation_space.shape[0]
inputs = tf.placeholder(tf.float32, shape=[None, num_inputs])
y = tf.placeholder(tf.float32, shape=[None, 1])
hidden = tf.layers.dense(inputs, 4, activation=tf.nn.relu)
logits = tf.layers.dense(hidden, 1)
outputs = tf.nn.sigmoid(logits)
action = tf.multinomial(tf.log(tf.concat([outputs, 1-outputs], 1)), 1)

cross_entropy = tf.nn.sigmoid_cross_entropy_with_logits(labels=y, logits=logits)
optimizer = tf.train.AdamOptimizer(0.01)
training_op = optimizer.minimize(cross_entropy)

with tf.Session() as sess:
  sess.run(tf.global_variables_initializer())

  for _ in range(1000):
    obs = env.reset()

    while True:
      y_target = np.array([[1\. if obs[2] < 0 else 0.]])
      a, _ = sess.run([action, training_op], feed_dict={inputs: obs.reshape(1, num_inputs), y: y_target})
      obs, reward, done, info = env.step(a[0][0])
      if done:
        break
  print("training done")

我们将outputs定义为logits净输出的sigmoid函数，即动作概率 0，然后使用tf.multinomial采样动作。请注意，我们使用标准的tf.train.AdamOptimizer及其minimize方法来训练网络。要测试并查看该策略的表现，请运行以下代码：

  total_rewards = []
  for _ in range(1000):
    rewards = 0
    obs = env.reset()

    while True:
      y_target = np.array([1\. if obs[2] < 0 else 0.])
      a = sess.run(action, feed_dict={inputs: obs.reshape(1, num_inputs)})
      obs, reward, done, info = env.step(a[0][0])
      rewards += reward
      if done:
        break
    total_rewards.append(rewards)

  print(np.mean(total_rewards))

总奖励的平均值约为 40 左右，这与使用无神经网络的简单策略的收益大致相同，这正是我们在训练阶段将y: y_target专门用于简单策略时的期望值，以训练网络。

现在，我们都准备探索如何在此基础上实现策略梯度方法，以使我们的神经网络表现更好，获得的奖励要大几倍。

策略梯度的基本思想是，为了训练神经工作以生成更好的策略，当所有智能体从环境中知道的都是从任何给定状态采取行动时所能获得的奖励（这意味着我们不能使用监督学习进行训练），我们可以采用两种新机制：

折扣奖励：每个动作的值都需要考虑其未来动作的奖励。例如，一个动作获得立即奖励 1，但是在两个动作（步骤）之后结束剧集的长期奖励应该比获得立即奖励 1 但在 10 个步骤之后结束剧集的动作具有较少的长期奖励。动作的折现奖励的典型公式是其立即奖励加上其每个未来奖励的倍数和由未来步骤提供动力的折现率的总和。因此，如果一个动作序列在剧集结束前有 1、1、1、1、1 个奖励，则第一个动作的折扣奖励为1+(1*discount_rate)+(1*discount_rate**2)+(1*discount_rate**3)+(1*discount_rate**4)。
测试运行当前策略，查看哪些操作导致较高的折扣奖励，然后使用折扣奖励更新当前策略的梯度（权重损失），以使具有较高折扣奖励的操作在网络更新后，下次被选中的可能性更高。重复这样的测试运行并多次更新该过程，以训练神经网络以获得更好的策略。

有关更详细的讨论和策略梯度的演练，请参阅 Andrej Karpathy 的博客条目，《深度强化学习：来自像素的乒乓》。现在，让我们看看如何为 TensorFlow 中的 CartPole 问题实现策略梯度。

首先，导入 tensorflow，numpy 和 gym，并定义一个用于计算标准化和折价奖励的助手方法：

import tensorflow as tf
import numpy as np
import gym

def normalized_discounted_rewards(rewards):
    dr = np.zeros(len(rewards))
    dr[-1] = rewards[-1]
    for n in range(2, len(rewards)+1):
        dr[-n] = rewards[-n] + dr[-n+1] * discount_rate
    return (dr - dr.mean()) / dr.std()

例如，如果discount_rate为 0.95，则奖励列表[1,1,1]中第一个动作的折扣奖励为1 + 1 * 0.95 + 1 * 0.95 ** 2 = 2.8525，并且第二和最后一个折扣奖励是 1.95 和 1；奖励列表[1,1,1,1,1]中第一个动作的折扣奖励为1 + 1 * 0.95 + 1 * 0.95 ** 2 + 1 * 0.95 ** 3 + 1 * 0.95 ** 4 = 4.5244，其余动作为 3.7099、2.8525、1.95 和 1 。 [1,1,1]和[1,1,1,1,1]的归一化折扣奖励为[1.2141, 0.0209, -1.2350]和[1.3777, 0.7242, 0.0362, -0.6879, -1.4502]。每个规范化的折扣清单按降序排列，这意味着动作持续的时间越长（在剧集结束之前），其奖励就越大。

接下来，创建 CartPole 体育馆环境，定义learning_rate和discount_rate超参数，并像以前一样使用四个输入神经元，四个隐藏神经元和一个输出神经元构建网络：

env = gym.make("CartPole-v0")

learning_rate = 0.05
discount_rate = 0.95

num_inputs = env.observation_space.shape[0]
inputs = tf.placeholder(tf.float32, shape=[None, num_inputs])
hidden = tf.layers.dense(inputs, 4, activation=tf.nn.relu) 
logits = tf.layers.dense(hidden, 1)
outputs = tf.nn.sigmoid(logits) 
action = tf.multinomial(tf.log(tf.concat([outputs, 1-outputs], 1)), 1)

prob_action_0 = tf.to_float(1-action)
cross_entropy = tf.nn.sigmoid_cross_entropy_with_logits(logits=logits, labels=prob_action_0)
optimizer = tf.train.AdamOptimizer(learning_rate)

请注意，此处不再像以前的简单神经网络策略示例那样使用minimize函数，因为我们需要手动微调梯度以考虑每个动作的折价奖励。这就要求我们首先使用compute_gradients方法，然后以所需的方式更新梯度，最后调用apply_gradients方法（我们大多数时候应该使用的minimize方法实际上是在幕后调用compute_gradients和apply_gradients）。

因此，让我们现在为网络参数（权重和偏差）计算交叉熵损失的梯度，并设置梯度占位符，稍后将使用考虑了计算梯度和动作折现奖励的值来填充它，动作在测试运行期间使用当前策略选取：

gvs = optimizer.compute_gradients(cross_entropy)
gvs = [(g, v) for g, v in gvs if g != None]
gs = [g for g, _ in gvs]

gps = []
gvs_feed = []
for g, v in gvs:
    gp = tf.placeholder(tf.float32, shape=g.get_shape())
    gps.append(gp)
    gvs_feed.append((gp, v))
training_op = optimizer.apply_gradients(gvs_feed)

从optimizer.compute_gradients(cross_entropy)返回的gvs是一个元组列表，每个元组都由（可训练变量的cross_entropy的）梯度和可训练变量组成。例如，如果您在整个程序运行后查看gvs，您将看到类似以下内容：

[(<tf.Tensor 'gradients/dense/MatMul_grad/tuple/control_dependency_1:0' shape=(4, 4) dtype=float32>,
 <tf.Variable 'dense/kernel:0' shape=(4, 4) dtype=float32_ref>),
 (<tf.Tensor 'gradients/dense/BiasAdd_grad/tuple/control_dependency_1:0' shape=(4,) dtype=float32>,
 <tf.Variable 'dense/bias:0' shape=(4,) dtype=float32_ref>),
 (<tf.Tensor 'gradients/dense_2/MatMul_grad/tuple/control_dependency_1:0' shape=(4, 1) dtype=float32>,
 <tf.Variable 'dense_1/kernel:0' shape=(4, 1) dtype=float32_ref>),
 (<tf.Tensor 'gradients/dense_2/BiasAdd_grad/tuple/control_dependency_1:0' shape=(1,) dtype=float32>,
 <tf.Variable 'dense_1/bias:0' shape=(1,) dtype=float32_ref>)]

请注意，kernel只是权重的另一个名称，(4, 4)，(4, )，(4, 1)和(1, )是权重的形状和对第一个（输入到隐藏）和第二层（隐藏到输出）。如果您从 iPython 多次运行脚本，则tf对象的默认图将包含先前运行的可训练变量，因此，除非调用tf.reset_default_graph()，否则需要使用gvs = [(g, v) for g, v in gvs if g != None]删除那些过时的训练变量，将返回 None 梯度（有关computer_gradients的更多信息，请参见这里）。

现在，玩一些游戏并保存奖励和梯度值：

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())

    for _ in range(1000):
        rewards, grads = [], []
        obs = env.reset()
        # using current policy to test play a game
        while True:
            a, gs_val = sess.run([action, gs], feed_dict={inputs: 
                                   obs.reshape(1, num_inputs)})
            obs, reward, done, info = env.step(a[0][0])
            rewards.append(reward)
            grads.append(gs_val)
            if done:
                break

在测试游戏之后，使用折价奖励更新梯度并训练网络（请记住training_op被定义为optimizer.apply_gradients(gvs_feed)）：

        # update gradients and do the training 
        nd_rewards = normalized_discounted_rewards(rewards)
        gp_val = {}
        for i, gp in enumerate(gps):
            gp_val[gp] = np.mean([grads[k][i] * reward for k, reward in 
                             enumerate(nd_rewards)], axis=0)
        sess.run(training_op, feed_dict=gp_val)

最终，经过 1000 次迭代的测试和更新，我们可以测试经过训练的模型：

    total_rewards = []

    for _ in range(100):
      rewards = 0
      obs = env.reset()

      while True:
        a = sess.run(action, feed_dict={inputs: obs.reshape(1, 
                                           num_inputs)})
        obs, reward, done, info = env.step(a[0][0])
        rewards += reward
        if done:
          break
      total_rewards.append(rewards)

    print(np.mean(total_rewards))

请注意，我们现在使用经过训练的策略网络和sess.run以当前观察为输入来执行下一步操作。总奖励的输出平均值约为 200，这与我们是否使用神经网络的简单直观策略相比有很大改进。

您也可以在使用tf.train.Saver进行训练后保存训练后的模型，就像我们在前几章中曾经做过的多次：

  saver = tf.train.Saver()
  saver.save(sess, "./nnpg.ckpt")

然后，您可以使用以下命令在单独的测试程序中重新加载它：

with tf.Session() as sess:
  saver.restore(sess, "./nnpg.ckpt")

之前的所有策略实现都在 Raspberry Pi 上运行，甚至使用 TensorFlow 训练强化学习策略梯度模型的模型实现也需要大约 15 分钟才能完成。这是我们涵盖的每项策略，在 Pi 上运行后返回的总奖励：

pi@raspberrypi:~/mobiletf/ch12 $ python single_minded_policy.py 
9.362

pi@raspberrypi:~/mobiletf/ch12 $ python simple_policy.py 
42.535

pi@raspberrypi:~/mobiletf/ch12 $ python nn_random_policy.py 
21.182

pi@raspberrypi:~/mobiletf/ch12 $ python nn_simple_policy.py 
41.852

pi@raspberrypi:~/mobiletf/ch12 $ python nn_pg.py 
199.116

现在，您已经拥有了一个强大的基于神经网络的策略模型，可以帮助您的机器人保持平衡，并在模拟环境中进行了全面测试，在将模拟环境的 API 返回值替换为真实环境数据后，您可以将其部署在真实的物理环境中，当然，但是用于构建和训练神经网络强化学习模型的代码当然可以轻松地重用。

总结

在本章中，我们首先详细介绍了使用所有必需的附件和操作系统以及将 Raspberry Pi 板变成移动机器人的 GoPiGo 工具包来设置 Raspberry Pi 的详细步骤。然后，我们介绍了如何在 Raspberry Pi 上安装 TensorFlow 并构建 TensorFlow 库，以及如何将 TTS 与图像分类集成以及如何使用 GoPiGO API 进行音频命令识别，从而使 Raspberry Pi 机器人可以移动，看到，听到和说出所有内容，而无需使用 Cloud API。最后，我们介绍了用于强化学习的 OpenAI Gym 工具包，并向您展示了如何使用 TensorFlow 构建和训练功能强大的强化学习神经网络模型，以使您的机器人在模拟环境中保持平衡。

最后的话

因此，该说再见了。在本书中，我们从三个经过预训练的 TensorFlow 模型开始，这些模型分别是图像分类，对象检测和神经样式迁移，并详细讨论了如何重新训练模型并在 iOS 和 Android 应用中使用它们。然后，我们介绍了使用 Python 构建的 TensorFlow 教程中的三个有趣的模型（音频识别，图像字幕和快速绘制），并展示了如何在移动设备上重新训练和运行这些模型。

之后，我们从零开始开发了用于预测 TensorFlow 和 Keras 中的股价的 RNN 模型，两个用于数字识别和像素转换的 GAN 模型以及一个用于 Connect4 的类似于 AlphaZero 的模型，以及使用所有这些 TensorFlow 模型的完整 iOS 和 Android 应用。然后，我们介绍了如何将 TensorFlow Lite 以及 Apple 的 Core ML 与标准机器学习模型和转换后的 TensorFlow 模型一起使用，展示了它们的潜力和局限性。最后，我们探索了如何使用 TensorFlow 构建 Raspberry Pi 机器人，该机器人可以使用强大的强化学习算法来移动，观看，聆听，讲话和学习。

我们还展示了同时使用 TensorFlow Pod 和手动构建的 TensorFlow 库的 Objective-C 和 Swift iOS 应用，以及使用即用型 TensorFlow 库和手动构建库的 Android 应用，以修复您在移动设备上部署和运行 TensorFlow 模型时可能遇到的各种问题。

我们已经介绍了很多，但是还有很多要讲的。 TensorFlow 的新版本已经快速发布。已经构建并实现了采用最新研究论文的新 TensorFlow 模型。本书的主要目的是向您展示使用各种智能 TensorFlow 模型的足够的 iOS 和 Android 应用，以及所有实用的故障排除和调试技巧，以便您可以在移动设备上为你的下一个杀手级移动 AI 应用快速部署和运行自己喜欢的 TensorFlow 模型。

如果您想使用 TensorFlow 或 Keras 构建自己的出色模型，实现最令您兴奋的算法和网络，则需要在本书结束后继续学习，因为我们没有详细介绍如何做到这一点，但希望我们能激发您足够的动力来开始这一旅程，并从书中获得保证，一旦您构建并训练了模型，便知道如何快速，随时随地在移动设备上部署和运行它们。

关于走哪条路和要解决哪些 AI 任务，Ian Goodfellow 在接受 Andrew Ng 采访时的建议可能是最好的：“问问自己，下一步做什么是最好的，选取哪条路是最适合的：强化学习，无监督学习或生成对抗网络”。无论如何，这将是一条充满兴奋的绝妙之路，当然还要有艰苦的工作，而您从本书中学到的技能就像您的智能手机一样，随时可以为您服务，并准备好将使您的甜蜜而聪明的小设备变得更加甜蜜和智能。

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

12.md

12.md

十二、在 Raspberry Pi 上开发 TensorFlow 应用

设置 Raspberry Pi 并使其移动

设置 Raspberry Pi

使树莓派移动

在 Raspberry Pi 上设置 TensorFlow

图像识别和文字转语音

音频识别和机器人运动

在 Raspberry Pi 上进行强化学习

了解 CartPole 模拟环境

从基本的直观策略开始

使用神经网络建立更好的策略

总结

最后的话

Files

12.md

Latest commit

History

12.md

File metadata and controls

十二、在 Raspberry Pi 上开发 TensorFlow 应用

设置 Raspberry Pi 并使其移动

设置 Raspberry Pi

使树莓派移动

在 Raspberry Pi 上设置 TensorFlow

图像识别和文字转语音

音频识别和机器人运动

在 Raspberry Pi 上进行强化学习

了解 CartPole 模拟环境

从基本的直观策略开始

使用神经网络建立更好的策略

总结

最后的话