在树莓 Pi 3 模型 B+上安装 OpenCV 3.4.3
我之前写了一个分步指南，展示如何让 OpenCV 3.4.1 在一个 Raspberry Pi 3 B 上运行。从那时起，我已经完成了一些安装，所以这里有一个新的、简化的过程来获得 OpenCV 3.4.1(最新版本！)在您的 Raspberry Pi 3 B plus 上运行。
为什么是 3.4.1？它提供了一个改进的 DNN 模块和许多其他改进和错误修复。总的来说，自从 OpenCV 3.4.0 以来，已经集成了大约 250 个补丁，关闭了 200 多个问题。
警告:编译 OpenCV 是一项 CPU 密集型任务——所有 4 个内核都将因 1 个内核而达到极限…两个小时。为了避免过热，确保你的树莓派有散热器和风扇(或者在旁边放一个强大的外部风扇)。不，它不会因过热而死亡，但它会抑制其 CPU 性能，潜在地将构建时间从 2 小时增加到 6 小时，您可能不希望这样。
这是新的流程:
第一步:确保你的操作系统是最新的。(<5 分钟)
当前 OS 版本为Raspbian Stretch(2018 年 4 月)。您可以从 SD 进行全新安装(遵循此处列出的说明)，或者升级您现有的版本。
要升级，请在您最喜欢的编辑器中打开(以 sudo 身份)文件 /etc/apt/sources.list 和*/etc/apt/sources . list . d/raspi . list*，并将当前发行版名称(如“jessie”)的所有出现处更改为“stretch”。然后，打开终端并运行更新:
sudo apt-get update
sudo apt-get -y dist-upgrade
如果您已经在运行 Stretch，只需在继续之前更新所有软件包:
sudo apt-get update
sudo apt-get upgrade
第二步:配置 SSH 和实用程序(<2 分钟)
确保 SSH 已启用。也更改默认密码！
我在 Linux 上最喜欢的一些实用程序是 screen (如果您的终端会话丢失，保持进程运行)和 htop (性能监控)——这些可能已经预装了:
sudo apt-get install screen
sudo apt-get install htop
第三步:放弃 Wolfram 和 Libreoffice，释放 1GB+(2 分钟)
您的计算机视觉系统不太可能需要这两个软件包，因此:
sudo apt-get purge wolfram-engine
sudo apt-get purge libreoffice*
sudo apt-get clean
sudo apt-get autoremove
第四步:安装依赖关系(<10 分钟)
sudo apt-get install build-essential cmake pkg-config sudo apt-get install libjpeg-dev libtiff5-dev libjasper-dev libpng12-dev sudo apt-get install libavcodec-dev libavformat-dev libswscale-dev libv4l-dev sudo apt-get install libxvidcore-dev libx264-dev sudo apt-get install libgtk2.0-dev libgtk-3-dev sudo apt-get install libatlas-base-dev gfortran
第五步:安装 Python 3(<2 分钟)
为了在 Open CV 中启用 Python 绑定，我们需要这样做:
在 OpenCV 中，所有算法都是用 C++实现的。但是这些算法可以在不同的语言中使用，如 Python、Java 等。这是由绑定生成器实现的。这些生成器在 C++和 Python 之间架起了一座桥梁，使用户能够从 Python 中调用 C++函数。要全面了解后台发生的事情，需要对 Python/C API 有很好的了解。关于将 C++函数扩展到 Python 的一个简单例子可以在官方 Python 文档中找到[1]。因此，通过手动编写包装函数将 OpenCV 中的所有函数扩展到 Python 是一项耗时的任务。所以 OpenCV 以一种更智能的方式来做这件事。OpenCV 使用位于 modules/python/src2 中的一些 Python 脚本从 C++头文件自动生成这些包装函数
sudo apt-get install python3-dev
第六步:安装 pip 3(<2 分钟)
sudo apt-get install python3-pip
第七步:获取最新的(3.4.3) OpenCV 源代码 ( < 5min)
我使用的是 OpenCV 的 3.4.3 版本。你可以查看官方网站(或 Github)的版本部分，看看当前的版本是什么。如果您想要的版本不同，请相应地更新下面的命令和路径。
下载并解压 OpenCV 3.4.3 及其实验模块(存储在 opencv_contrib 库):
wget -O opencv.zip [https://github.com/opencv/opencv/archive/3.4.3.zip](https://github.com/opencv/opencv/archive/3.4.3.zip) wget -O opencv_contrib.zip [https://github.com/opencv/opencv_contrib/archive/3.4.3.zip](https://github.com/opencv/opencv_contrib/archive/3.4.3.zip) unzip opencv.zip unzip opencv_contrib.zip
步骤 8:安装 Numpy，Scipy(❤️ 分钟)
sudo pip3 install numpy scipy
第九步:编译 OpenCV(<10 分钟)
注意:这一步需要很长时间。在我的设备上花了将近 2 个小时。此外，如果没有适当的冷却，您的覆盆子酱会过热。
同样，我使用的是 OpenCV 的 3.4.3 版本。如果不是，请相应地更新您的路径:
cd ~/opencv-3.4.3/
mkdir build
cd build cmake -D CMAKE_BUILD_TYPE=RELEASE \
-D CMAKE_INSTALL_PREFIX=/usr/local \
-D INSTALL_PYTHON_EXAMPLES=ON \
-D OPENCV_EXTRA_MODULES_PATH=~/opencv_contrib-3.4.3/modules \
-D BUILD_EXAMPLES=ON ..
请确保 cmake 完成时没有错误。
第十步:构建 OpenCV(90-120 分钟)
如果您使用全部四个 CPU 核心，这将运行得更快:
make -j4
一旦 OpenCV 构建成功，继续安装:
sudo make install
sudo ldconfig
sudo apt-get update
…然后重新启动系统，您就可以开始了！
sudo reboot
步骤 11:测试你的 OpenCV 安装(<1 分钟)
$ python3 Python 3.5.3 (default, September 5 2018, 14:11:04)
[GCC 6.3.0 20170124] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import cv2
>>> cv2.__version__
'3.4.3'
>>>
欢迎评论和建议！
原载于 2018 年 9 月 5 日www.alatortsev.com。
在树莓 Pi 3 B 上安装 OpenCV
我用的是 B 版本，在亚马逊购买，规格如下:
- 1.2GHz 64 位四核 ARMv8 CPU，1 GB 内存
- 802.11n 无线局域网，10/100Mbps 局域网速度
- 蓝牙 4.1，蓝牙低能耗
- 4 个 USB 端口、40 个 GPIO 引脚、全 HDMI 端口、组合 3.5 毫米音频插孔和复合视频
- 相机接口(CSI)、显示器接口(DSI)、Micro SD 卡插槽(现在是推拉式而不是推推式)、VideoCore IV 3D 图形核心
现在有一个的更新版本(“b+”)，它应该以同样的方式工作，但一些步骤(如编译 OpenCV，在我的设备上花了近 2 个小时)应该更快。
此外，正如所料，编译 OpenCV 使无风扇 CPU 过热 30 分钟——所以我不得不在它旁边放置一个强大的风扇，直到我收到一个有适当冷却的案例。
第一步:确保你有最新版本的操作系统
当前 OS 版本为Raspbian Stretch(2018 年 4 月)。您可以从 SD 进行全新安装(遵循此处列出的说明)，或者升级您现有的版本。
要升级，请在您最喜欢的编辑器中打开(以 sudo 身份)文件 /etc/apt/sources.list 和*/etc/apt/sources . list . d/raspi . list*，并将当前发行版名称(如“jessie”)的所有出现处更改为“stretch”。然后，打开终端并运行更新:
sudo apt-get update
sudo apt-get -y dist-upgrade
步骤 2:配置 SSH 和实用程序
确保 SSH 已启用。也更改默认密码！
我在 Linux 上最喜欢的一些实用程序是 screen (如果你的终端会话丢失，保持进程运行)和 htop (性能监控)——这些可能已经预装了:
sudo apt-get install screen
sudo apt-get install htop
第三步:放弃 Wolfram 和 Libreoffice，释放 1GB+
您的计算机视觉系统不太可能需要这两个软件包，因此:
sudo apt-get purge wolfram-engine
sudo apt-get purge libreoffice*
sudo apt-get clean sudo apt-get autoremove
第四步:安装依赖关系
sudo apt-get install build-essential cmake pkg-config sudo apt-get install libjpeg-dev libtiff5-dev libjasper-dev libpng12-dev sudo apt-get install libavcodec-dev libavformat-dev libswscale-dev libv4l-dev sudo apt-get install libxvidcore-dev libx264-dev sudo apt-get install libgtk2.0-dev libgtk-3-dev sudo apt-get install libatlas-base-dev gfortran
第五步:安装 Python 2.7 & 3
为了在 Open CV 中启用 Python 绑定，我们需要这样做:
在 OpenCV 中，所有算法都是用 C++实现的。但是这些算法可以在不同的语言中使用，如 Python、Java 等。这是由绑定生成器实现的。这些生成器在 C++和 Python 之间架起了一座桥梁，使用户能够从 Python 中调用 C++函数。要全面了解后台发生的事情，需要对 Python/C API 有很好的了解。关于将 C++函数扩展到 Python 的一个简单例子可以在官方 Python 文档中找到[1]。因此，通过手动编写包装函数将 OpenCV 中的所有函数扩展到 Python 是一项耗时的任务。所以 OpenCV 以一种更智能的方式来做这件事。OpenCV 使用位于 modules/python/src2 中的一些 Python 脚本从 C++头文件自动生成这些包装函数
sudo apt-get install python2.7-dev
sudo apt-get install python3-dev
第六步:获取最新的 OpenCV 源代码
我使用的是 OpenCV 的 3.4.1 版本。你可以查看官方网站(或者 Github)的版本部分，看看当前的版本是什么。如果您想要的版本不同，请相应地更新下面的命令和路径。
下载并解压 OpenCV 3.4.1 及其实验模块(存储在 opencv_contrib 库):
wget -O opencv.zip [https://github.com/opencv/opencv/archive/3.4.1.zip](https://github.com/opencv/opencv/archive/3.4.1.zip) wget -O opencv_contrib.zip [https://github.com/opencv/opencv_contrib/archive/3.4.1.zip](https://github.com/opencv/opencv_contrib/archive/3.4.1.zip) unzip opencv.zip unzip opencv_contrib.zip
第七步:安装 pip 和 virtualenv
这些是管理 Python 包的最底层工具。
首先获取 pip:
wget -O get-pip.py [https://bootstrap.pypa.io/get-pip.py](https://bootstrap.pypa.io/get-pip.py)
sudo python get-pip.py
sudo python3 get-pip.py
来源:https://pip.pypa.io/en/stable/installing/
然后，安装虚拟环境:
sudo pip install virtualenv virtualenvwrapper
修改你的 ~/。配置文件包括以下行:
导出 WORKONHOME=$HOME/。virtualenvs 导出 VIRTUALENVWRAPPERPYTHON =/usr/bin/python 3
source/usr/local/bin/virtualenvwrapper . sh
这是我的文件的样子:
# ~/.profile: executed by the command interpreter for login shells. # This file is not read by bash(1), if ~/.bash_profile or ~/.bash_login # exists.
# see /usr/share/doc/bash/examples/startup-files for examples.
# the files are located in the bash-doc package. # the default umask is set in /etc/profile; for setting the umask
# for ssh logins, install and configure the libpam-umask package. #umask 022 # if running bash
if [ -n "$BASH_VERSION" ]; then
# include .bashrc if it exists
if [ -f "$HOME/.bashrc" ]; then
. "$HOME/.bashrc"
fi
fi # set PATH so it includes user's private bin if it exists
if [ -d "$HOME/bin" ] ; then
PATH="$HOME/bin:$PATH"
fi # virtualenv and virtualenvwrapper settings
export WORKON_HOME=$HOME/.virtualenvs export VIRTUALENVWRAPPER_PYTHON=/usr/bin/python3 source /usr/local/bin/virtualenvwrapper.sh
…激活更改:
source ~/.profile
第八步:创建一个虚拟环境
mkvirtualenv cv -p python3
…或者，如果您想使用 Python 2.7 而不是 Python 3:
mkvirtualenv cv -p python2
以下是使用 virtualenvwarapper 的基本命令:
mkvirtualenv virtualenv_name # create virtualenv workon virtualenv_name # activate/switch to a virtualenv deactivate virtualenv_name # deactivate virtualenv
在我们的例子中，我们可以激活一个名为“cv”的 virtualenv:
pi@raspberrypi:~ $ workon cv
(cv) pi@raspberrypi:~ $
第九步:安装 Numpy，Scipy
现在您已经进入了虚拟环境(如终端窗口中的“(cv)”前缀所示)，让我们安装一些用于数据分析的附加包— numpy 和 scipy :
sudo pip install numpy scipy
第十步:最后，安装 OpenCV
注意:这将需要很长、很长、很长的时间。在我的设备上花了将近 2 个小时。此外，如果没有适当的冷却，您的覆盆子酱会过热。
同样，我使用的是 OpenCV 的 3.4.1 版本。如果不是，请相应地更新您的路径:
cd ~/opencv-3.4.1/ mkdir build cd build cmake -D CMAKE_BUILD_TYPE=RELEASE \ -D CMAKE_INSTALL_PREFIX=/usr/local \ -D INSTALL_PYTHON_EXAMPLES=ON \ -D OPENCV_EXTRA_MODULES_PATH=~/opencv_contrib-3.4.1/modules \ -D BUILD_EXAMPLES=ON ..
请确保 cmake 完成时没有错误。
现在，给自己拿杯啤酒，准备最后一步——编译。为了加快速度，暂时增加您的 /etc/dphys-swapfile 中的交换文件大小，将 CONF _ 交换大小从 100 改为 1024:
# set size to absolute value, leaving empty (default) then uses computed value
# you most likely don't want this, unless you have an special disk situation
#CONF_SWAPSIZE=100
CONF_SWAPSIZE=1024
要避免重新启动以使这些更改生效，只需重新启动交换服务:
sudo /etc/init.d/dphys-swapfile restart
这里有一个关于如何用包编译 OpenCV 的详细指南:
https://github.com/opencv/opencv_contrib
我所做的(使用所有 4 个 CPU 内核):
make -j4
OpenCV 编译成功后，继续安装:
sudo make install
sudo ldconfig
sudo apt-get update
…然后重新启动系统，您就可以开始了！
还有一件事:
测试安装:
$ python3
Python 3.5.3 (default, Jan 19 2017, 14:11:04) [GCC 6.3.0 20170124] on linux Type "help", "copyright", "credits" or "license" for more information.
>>> import cv2
>>> cv2.__version__ '3.4.1'
>>>
如果出现错误(ImportError:没有名为“cv2”的模块)，则库的命名可能不正确:
(cv) pi@raspberrypi:$ ls -l /usr/local/lib/python3.5/site-packages/ total 4500 -rw-r--r-- 1 root staff 4604912 Apr 27 14:41 cv2.cpython-35m-arm-linux-gnueabihf.so
通过将库文件重命名为“cv2.so”来修复它:
cd /usr/local/lib/python3.5/site-packages/ sudo mv cv2.cpython-35m-arm-linux-gnueabihf.so cv2.so
原载于 2018 年 4 月 27 日www.alatortsev.com。
在 OSX 上安装 XGBoost
我们本周的项目是研究一个古老的卡格尔竞赛(https://www.kaggle.com/c/predict-west-nile-virus)。XGBoost 在过去的 kaggle 比赛中被许多获胜者使用，所以我们非常希望它能提高我们的成绩。虽然这并没有提高我们的成绩，但我确实在这个过程中学到了很多。
我找到的下载 XGBoost for Mac 的最好的文章是通过 IBM 网站(讽刺的是，不是？).甚至这篇文章也有很多地方需要进行故障诊断，所以我想介绍一下我遇到错误的地方，但这绝对是一个好的起点。如果 IBM 的文章对您有用，就不需要继续读下去了，但是如果没有，我希望我能回答您的一些问题。
[## 在 Mac OSX 上安装 XGBoost(最好保密的是优化)
OSX 比 Windows 好得多，不是吗？这是一个普遍的智慧，当我…
www.ibm.com](https://www.ibm.com/developerworks/community/blogs/jfp/entry/Installing_XGBoost_on_Mac_OSX?lang=en)
- 在你的终端上，如果你还没有安装家酿软件的话。“/usr/bin/ruby-e " $(curl-fsSLhttps://raw . githubusercontent . com/home brew/install/master/install)” “如果在这一步遇到错误，请参考本网站"https://computers . tuts plus . com/tutorials/home brew-demystified-OS-xs-ultimate-package-manager-MAC-44884”。
- 同样在终端中，您应该“brew install gcc—without-multi lib”，without multilib 应该有助于解决我们稍后可能会遇到的多线程错误。这可能需要一些时间，但是如果这不起作用，请尝试“sudo apt-get install gcc
sudo apt-get install g++” - cd 到你想放目录的任何地方，我简单地把我的放在我的根目录，但是确保这不是在另一个目录里！(我们不需要任何怀孕的回复)
- 使用这一行“git clone-recursivehttps://github.com/dmlc/xgboost”将存储库克隆到您希望您的目录所在的任何位置
- cd 放到名为 xgboost 的新目录中
- 打开 make/config.mk。如果您的计算机已正确格式化，只需键入“打开 make/config.mk”就可以了。如果没有，您可以使用 GUI 在您喜欢的文本编辑器或其他命令中打开它。取消对这两行代码的注释:“export CC = gcc
export CXX = g++”。根据您安装的 gcc 版本，您可能需要将它们更改为“export CC = gcc-6
export CXX = g+±6”。请确保保存此内容，然后继续下一步。 - cd 进入 xgboost(如果您还没有在那里)，然后“cp make/config.mk。
make -j4 - 最后一步:“CD python-package；sudo python setup.py 安装
要检查这是否成功，您可以打开一个 jupyter 笔记本或者在您的终端中键入“pip freeze ”,并确保 xgboost 有一个版本。如果你想在 jupyter 笔记本中使用它，你应该打开一个新的终端窗口，并启动一个新的内核。你可以通过“import xgboost”来检查这个过程是否成功，只要它不抛出错误，你就可以使用它。
如果这些步骤不起作用，请尝试“brew install gcc5”，然后将步骤 6 更改为“export CC = gcc-5
export CXX = g+±5”
如果最后一步不起作用，就用这三个代替:“sudo。/build . sh
CD python-package
sudo/home/username/anaconda/bin/python setup . py install "
令人沮丧的答案是，如果这不起作用，卸载并再次尝试稍微改变步骤，并尝试准确地遵循 IBM 的文章。
[## pip 安装失败问题#463 dmlc/xgboost
xgboost -可扩展、可移植和分布式梯度增强(GBDT、GBRT 或 GBM)库，用于 Python、R、Java、Scala…
github.com](https://github.com/dmlc/xgboost/issues/463#issuecomment-147365960)
实例嵌入:没有建议的分段
在这篇文章中，我将回顾实例分割领域的 3 篇论文。它们不同于主流的基于提议的基于 fast-RCNN 的方法，如 Mask-RCNN 或 MaskLab 和最新的 PANet ，在多个数据集上实现了最先进的结果( CityScapes 、 COCO 、 MVD )。参见此处的 Mask-RCNN 教程。
在基于提议的实例分段架构中有三个基本缺陷。首先，两个对象可能共享同一个边界框，或者非常相似的框。在这种情况下，遮罩头部无法判断要在盒子中选取哪个对象。对于其边界框中填充率较低的线状对象(如自行车和椅子)，这是一个严重的问题。其次，架构中没有任何东西阻止两个实例共享一个像素。第三，实例的数量受限于网络处理的提案数量(通常为数百)。
architecture for Mask-RCNN, https://www.slideshare.net/IldooKim/deep-object-detectors-1-20166
此外，该架构非常复杂，很难调整和“调试”。在目标检测中，这个问题的前兆，已经成功地使用了更简单的单级架构，例如 RetinaNet 。
使用实例嵌入，每个对象都被分配一个 n 维空间中的“颜色”。网络处理图像并产生与输入图像相同大小的密集输出。网络输出中的每个像素是嵌入空间中的一个点。属于同一对象的像素在嵌入空间中是靠近的，而属于不同对象的像素在嵌入空间中是远离的。解析图像嵌入空间涉及某种聚类算法。
论文 1:具有区别损失函数的语义实例分割
伯特·德·布拉班德雷，戴维·内文，吕克·范古尔https://arxiv.org/abs/1708.02551
https://github.com/DavyNeven/fastSceneUnderstanding
visualizing the contrastive loss.
**损失。**本文使用由三部分组成的对比损失函数:
(1)拉力。惩罚相同实例的所有元素与其平均值的距离。也就是说，获取一个实例的所有像素并计算它们的平均值。拉力会将同一实例的所有像素嵌入吸引到同一点。简而言之，减少每个实例嵌入的差异。
(2)一个推力。取所有的中心点(在嵌入空间中，而不是空间中心)并将它们推得更远。
(3)正规化。中心不应该离原点太远。
α和β的值为 1，γ设置为 0.001。两个增量都是拉力和推力的阈值。
解析。在获得语义分割图(汽车、狗、计算机……)之后，我们将每个类别掩码细分为实例。这是通过在语义掩码中选取一个随机未分配的点，并迭代应用均值漂移算法来找到实例的均值点来实现的。
均值的第一个假设是最初选取的随机像素的嵌入。然后，围绕该点(在嵌入空间中)扩展一组点，然后再次计算它们的平均值，并且重复该过程，直到平均值的变化不显著。根据我的经验，算法收敛不超过 10 次迭代。大多数时候 3-4 次迭代就足够了。
用于在嵌入空间中扩展实例遮罩的半径与拉取阈值相同。理论上，如果测试误差为 0，并且中心之间的最小距离至少是方差分量的拉阈值的两倍，则我们可以使用这些阈值来解析图像。距离不大于拉动阈值的所有点应属于同一个实例。因为测试误差几乎从不为 0，所以使用均值漂移算法来寻找嵌入的高密度部分的中心。
a nice visualization of this tracking process in a two dimensional embedding space where the mode of the set, the peak of the density, is finally found.
错误来源
这些结果显示了 Cityscapes 数据集上大多数错误的来源。如果语义分段没有被断定，而是使用了基础事实，则 AP50 结果从 40.2 跳到 58.5。如果也使用实际的中心，而不是使用均值漂移来估计，则得分几乎增加了 20 分，达到 77.8 分。使用面板(参见仪表板)在 COCO 上不进行预训练的当前技术水平结果是 57.1。与使用语义分段基本原理相同。我们了解到嵌入本身可能非常好。
嵌入示例
下面是一个由一个训练有素的网络嵌入生成的实例。它用于解决目前正在 Kaggle 上运行的数据科学碗 2018 提出的问题。目的是在医学图像中找到细胞核。
左上角的图像是原始图像。中上部图像是语义分割(这里只有两类，背景和前景)。其余的图像是 64 个嵌入空间的前 7 个通道。从嵌入可以明显看出，网络学习了在空间上区分细胞核的通道。对角线或水平编码的例子。一些编码从图像中心的距离。但是，在实例内部，颜色是同质的。这让我们对网络如何学习分割实例有了一些了解。
论文 2:通过深度度量学习的语义实例分割
阿里雷扎·法蒂，兹比格涅夫·沃伊纳，维韦克·拉特霍德，王鹏，玄武铉，塞尔吉奥·瓜达拉马，凯文·p·墨菲
【https://arxiv.org/abs/1703.10277
Network architecture proposed in Semantic Instance Segmentation via Deep Metric Learning
本文的主要贡献是为每个像素学习种子分数。分数告诉我们该像素是否是扩展遮罩的良好候选。在之前的论文中，种子是随机选择的，然后使用均值漂移算法来细化中心。这里只做了一次扩展。
seedeness score per pixel. taken as the maximum over all classes and bandwidths.
该论文提出为每个像素学习几个可能种子。我们为每个半径(在嵌入空间中)和类学习一个种子。因此，如果我们有 C 类，我们学习 T 带宽(半径),我们有 CxT 种子“建议”每像素。对于每个像素，只考虑得分最高的建议。
**嵌入损失。**本文对像素对的嵌入进行惩罚。我们考虑具有相同实例的对和来自不同实例的对。
a logistic distance function in embedding space
本文使用一种改进的逻辑函数，将嵌入空间中的欧氏距离变换到[0，1]域。嵌入空间中接近的对将被函数赋予接近 1 的值，而距离远的对将接近 0。
自然地，logloss 被用作损失函数。实例大小可能会有所不同，因此，为了减轻这种不平衡问题，根据实例的大小对它们进行加权。
logloss over logistic distance between pairs of pixels
**落英。**对于每个像素，模型学习几个种子性分数。带宽(嵌入空间的半径)和类别的每个组合得一分。由于种子分数接近但不同于语义分割，因此每次评估嵌入时都要确定每一个的基础事实。围绕像素的嵌入扩展掩码，并且如果具有基本事实实例的 IoU 超过某个阈值，则该像素被认为是该实例的类的种子。这个损失将会惩罚这个职业的低种子分数。
seediness loss
每批图像中只有 10 个左右的种子被评估，随机挑选。学习几个这样的模型，一个用于一个带宽。带宽越宽，物体越大。在某种程度上，获得最高分数的带宽是模型传达其对实例大小的估计的方式(相对于嵌入空间中的距离)。
**训练程序。**本文使用在 COCO 数据集上预处理的 ResNet-101 主干。训练从没有分类/种子预测开始，即λ=0，并且随着嵌入更加稳定而进展到 0.2。
以不同的比例(0.25，0.5，1，2)评估主链，并将连接的结果输入种子和包埋头。
解析。这个过程非常简单，因为种子学会了。提出了一种为图像选择最佳种子集的方法。它一方面优化了高种子分数，另一方面优化了嵌入空间的多样性。
迭代地选择种子，每个新的种子被选择为在嵌入空间中远离先前选择的种子。选择的第一个种子是图像中种子性得分最高的像素。第二个将是一方面具有高种子性分数，另一方面在嵌入空间中不接近的种子。使用参数α来控制这两个要求之间的平衡。α是一个需要调整的参数，该参数的测试范围在 0.1 到 0.6 之间。与 NMS 不同，嵌入空间的多样性受到鼓励，而不是空间多样性。
some results from Semantic Instance Segmentation via Deep Metric Learning
论文 3:用于实例分组的递归像素嵌入
舒孔，查尔斯·福尔克斯
https://arxiv.org/abs/1712.08273
https://github . com/aimerykong/Recurrent-Pixel-Embedding-for-Instance-Grouping
本文提出在 n-球面上进行嵌入，并使用余弦距离来测量像素的邻近性。然而，本文的主要贡献是基于高斯模糊均值漂移(GBMS)算法的改进版本的递归分组模型。
GBMS 是一种迭代算法，类似于第一篇论文中用于查找实例中心的简单均值漂移算法。在这个版本中，所有的像素都被认为是潜在的种子。所有像素在每次迭代时都相对于它们周围的密度进行更新。朝着一个“重心”移动，好像图像的嵌入空间是一个产生行星的星云。点与点之间的距离越远，它们之间的相互影响就越小。从下面的算法可以清楚地看出，距离是由高斯的带宽控制的，这是它的标准偏差。
对于 GBMS 来说，有三次收敛保证，所以在应用几次变换后，我们最终应该得到非常密集的，几乎像点一样的簇。想了解更多关于 GBMS 的信息，请看这里。
为了将该算法结合到网络中，已经使用矩阵上的运算来表示该算法。
简单地应用上述算法是没有意义的，因为嵌入是在球体上，并且它们的接近度是使用余弦变换来测量的。描述所有点之间距离的相似性矩阵使用以下变换来计算:
测量球体上的距离，而不是使用 L2 规范。此外，在应用 GBMS 步骤后，需要对生成的嵌入进行归一化，以便它们位于单位球面上。
**训练。**使用成对像素损失，类似于之前的论文，对不同对所需的距离设置阈值(alpha)。使用范围为[0，1]而不是[-1，-1]的校准余弦距离来评估每一对。
calibrated cosine distance
损失通过递归分组模型的每个应用反向传播。应用的后期阶段只会出现非常困难的情况。例如，作者将这一特性与在 fast-RCNN 训练中使用的硬负挖掘进行了比较。
loss used in Recurrent Pixel Embedding for Instance Grouping
作者在论文中使用 0.5 作为α值。请注意，实例的大小用于重新平衡大小实例之间的损失。
**解析。**在分组模块的几次应用之后，簇应该非常密集，随机选取值应该产生足够好的种子。
出于实际目的，在 GBMS 步骤中仅使用一些像素是有意义的，因为计算相似性矩阵可能被证明是极其昂贵的。所取的像素数量是速度/精度的折衷考虑。
其他方法
实例嵌入不是基于建议的网络的唯一替代方案。以下是一些使用其他方法解决实例分割问题的论文
-
【https://arxiv.org/abs/1605.09410】端到端实例分割与递归关注
-
深分水岭变换为例分割
https://arxiv.org/abs/1611.08303 -
关联嵌入:用于联合检测和分组的端到端学习
http://ttic . uchicago . edu/~ mmaire/papers/pdf/affinity _ CNN _ cvpr 2016 . pdf -
序贯分组网络实例分割
https://www . cs . Toronto . edu/~ urta sun/publications/Liu _ et al _ iccv 17 . pdf
摘要
与基于建议书的解决方案相比，这些论文的结果没有竞争力。我们已经回顾了 3 篇论文，它们对丢失和解析提出了不同的解决方法。
(1) 使用区别损失函数的语义实例分割
使用了非成对损失函数。使用图像中的所有像素产生丰富得多的渐变。
(2) 通过深度度量学习的语义实例分割
引入了种子模型，帮助我们分类并同时挑选最佳种子，优化速度。
(3) 循环像素嵌入例如分组
GBMS，均值偏移的一种变体，在训练和解析中被用于网络内部。产生非常密集的集群。
这些方法可能被结合和改进以产生更好的结果。它们比基于提议的方法更简单，可能更快，同时避免了本文介绍中提到的基本缺陷。
**联系人:**me@barvinograd.com
**幻灯片:**https://goo.gl/iTC9aS
results from “Semantic Instance Segmentation with a Discriminative Loss Function” on the CityScapes dataset
实例分割:自动细胞核检测。
实例分割成为医学图像处理的热门话题并非偶然。
识别细胞核是大多数分析的起点，因为人体的 30 万亿个细胞中，大多数都含有一个充满 DNA 的细胞核，DNA 是为每个细胞编程的遗传密码。识别细胞核使研究人员能够识别样本中的每个细胞，通过测量细胞对各种处理的反应，研究人员可以了解潜在的生物过程。
每年的数据科学杯比赛都会提出有趣的挑战，以获得洞察力、现有解决方案的增强和对问题的新观点，从而对医学发展产生前所未有的影响。
今年数据科学杯的任务是创建一个模型，可以识别各种条件下的一系列原子核。换句话说，这是一个实例分割任务，以检测不同类型的扫描细胞核。班级数量— 1。主持人提供了地面真相图片和面具。所有关于数据和指标的信息都可以在竞赛页面上找到。
下面我想简要描述两种最流行的解决这类竞争的策略和一些准确性增强实验。
屏蔽 RCNN
想到实例分割首先想到的是，当然是 Mask RCNN。
因此，一个基本的方法是使用掩模 RCNN 框架进行对象实例分割，它开箱即用，效果很好。之所以做出这样的选择，是因为模型给出了相当不错的现成结果，而且两阶段 RCNN 比一阶段解决方案更好。RCNN 有助于过滤 RPN 的错误结果。
但是，当然“相当好”并不是我们竞争所需要的，并且很难实现模型的进一步增强。
尽管如此，还是做了一些实验和修改来提高模型的准确性
- 对模型进行大量的扩充
- 不同类型的内部模型集合，例如具有不同尺寸参数的不同掩模头，以处理重叠情况，或者具有多个区域建议网络和多个 RCNN 的多个掩模头
- 当然适当的外部数据
- 不同的主干网 ResNet-50、SEResnext-50、ResNet-101
- TTA 扩增
- 具有进一步 NMS 系综的基于 IOU 的聚类结果
- 使用后处理改进掩模边界
- 伪标记
- 在后处理阶段扩张然后腐蚀掩膜
一些合奏技巧看起来像
其中来自不同阶段的结果可以用 NMS 和联合集来集合。
改进:
- resnet 152 主干，用于提高精确度和处理复杂图像
- 显著更多的增强来提高泛化能力
带分水岭后处理的 UNet
另一种解决问题的方法是使用带有 ResNet 编码器的编码器-解码器 Unet 风格架构。模型的掩模检测超过了 MaskRcnn 检测部分的结果。剩下未解决的问题是分离粘在一起的细胞核。
第一个想法是使用形态学后处理(基于标记的分水岭)来分离掩模。
在这里可以找到一个很好的分水岭工作原理的解释——分水岭变换。
基本上，它看起来像:
- 预测两个通道，一个是二元掩模，另一个是原子核的质心。
- 使用预测质心作为分水岭函数中的标记。
另一个想法是通过预测从最近的边界像素指向的中间单位矢量场，使用深分水岭变换来预测分水岭能量水平(被不同偏移侵蚀的掩模)。能级图与像素和最近边界之间的距离有关。它可以通过使用相同的 Unet 模型来完成，而不需要训练新的模型，只需在多个通道中输入。
可以用来改进 pipeline 的改进与 Mask Rcnn 的相同。至于后处理-腐蚀操作分离掩模是有益的。还使用了来自多个检查站和 TTA 的集合结果。更深的编码器和更大数量的增强。
结果:
最终想法
Mask Rcnn 是最适合此类问题的模型，并且易于使用。整个比赛表明，Unet 风格的建筑更轻，更灵活，最重要的是，它显示了核心探测任务的艺术成果。
链接
- 第一名解-https://www . ka ggle . com/c/data-science-bowl-2018/discussion/54741
- 比赛页面-https://www.kaggle.com/c/data-science-bowl-2018
- 竞赛中的文档化 DWT 解决方案和许多其他有用信息-https://spark-in.me/post/playing-with-dwt-and-ds-bowl-2018
- https://github.com/matterport/Mask_RCNN
- 马斯克 cnn 论文-https://arxiv.org/abs/1703.06870
- TernausNet - Unet 用于实例分割【https://github.com/ternaus/TernausNet T2
- Unet 论文-【https://arxiv.org/abs/1505.04597
- 分水岭变换-http://cmm.ensmp.fr/~beucher/wtshed.html
- 深分水岭变换-https://arxiv.org/pdf/1611.08303.pdf
- 用于图像识别的深度残差学习-https://arxiv.org/pdf/1512.03385.pdf
即时可视化什么是不同的
这是一篇关于我们期待已久的 VLDB 2016 论文 的简短博文，标题为“SeeDB:支持可视化分析的高效数据驱动可视化建议”，这是我们 SeeDB 系统上继 2013 愿景论文 和 2014 演示论文 之后的巅峰之作。合著者: 玛纳斯·瓦尔塔克 ，这位首席博士生完成了大部分工作。论文上的合著者包括绝世的 山姆·马登 和才华横溢的 阿尔基斯·多佐蒂斯 。
A Tired Data Scientist
数据可视化通常是数据科学家探索新数据集的第一道“攻击线”。作为他们探索的一部分，数据科学家一个接一个地重复生成可视化，并检查每一个，以找到那些显示有趣或不寻常行为的可视化。根据数据集有多少属性，这种 基于试错的探索可能需要很长时间 。
示例时间！假设一名数据科学家对研究“悬浮滑板”产品感兴趣，该产品最近表现不佳。他们想将悬浮滑板与一直热销的产品“融合先生”相提并论。那么他们会怎么做呢？嗯，他们会生成一些可视化效果，并检查这些可视化效果对于悬浮滑板和 Fusion 先生是否不同。这样的可视化之一可能是各州的销售分布——也许悬浮滑板的分布与 Fusion 先生非常不同。另一个可视化可能是广告随着时间的推移——可能悬浮滑板的广告保持不变，而 Fusion 先生的广告随着时间的推移而增加。这两个都是“有趣”的可视化，突出了两个数据子集之间的差异——悬浮滑板数据和 Mr 融合数据。
目标和挑战
SeeDB 的目标是 自动搜索有趣的可视化 。我们现在描述用户使用 SeeDB 浏览数据集的体验。
SeeDB Frontend
用户选择他们想要比较的两个数据子集(窗格 A)，并立即获得推荐的可视化(窗格 D)，显示这两个数据子集在哪些可视化上最不同。可选地，用户也可以明确地选择他们想要创建可视化的属性(窗格 B)，然后接收生成的可视化(窗格 C)。
那么 SeeDB 是如何做到这一点的呢？构建 SeeDB 有两个挑战(即从窗格 A 到窗格 D):
- 我们如何判断 某件事是否有趣？
- 我们如何遍历候选可视化的大空间来找到那些感兴趣的？
挑战 1:评估兴趣度
对于 1，我们使用分布差异作为效用度量。有许多方法可以评估分布差异，包括 K-L 散度、运土机距离(我们的特定选择)和欧几里德距离；关于评估这些指标的更多信息，请稍后讨论。
挑战 2:提高性能
对于 2，我们发现有两个主要原因导致我们浪费时间探索这个可视化的空间:
- 我们对数据进行重复处理，以生成和评估每个候选可视化。
- 我们在低效的可视化上浪费了大量时间。
对于 1，我们开发了许多基于共享的优化*，对于 2，我们开发了许多基于剪枝的优化*。**
Architecture Diagram
这些优化以中间件层的形式实现，位于可视化客户端界面和常规关系数据库之间，如我们的架构图所示。
这种共享+修剪的组合允许我们将合理的大型数据集 上的可视化推荐从几十分钟缩短到几秒钟。
用户反应
除了全面的性能评估之外，我们还进行了一项用户研究，以了解用户对可视化建议的总体反应，以及对基于我们的效用指标的可视化建议，特别是的反应。总的来说，从定量的角度来看，SeeDB 在帮助视觉数据探索方面非常有效。从定性的角度来看，以下是一些有说服力的引用:
".。。快速确定相关的相关性”
".。。帮我【分析】。。。快速创建新数据集”
".。。为数据集提出一组初始查询的绝佳工具”
".。。潜在的负面影响可能是，它让我变得懒惰，所以我不会过多地考虑我真正可以学习或感兴趣的东西。”
因此，尽管 SeeDB 在帮助勘探方面很棒，但也有一个警告，即这种帮助可能会让分析师产生一种错误的自满感——然而，我们认为这种收益非常值得冒险。
当前工作
SeeDB 在 2015 年初被接受出版，因此我们已经转向其他项目。一个这样的项目是一个成熟的“毫不费力”的视觉探索引擎， ZenVisage ，推广了 SeeDB 的工作；我们还有一篇关于可视化推荐系统的远景论文正在审阅中。
承认
一个疲惫的数据科学家的形象来自 https://outkasty.wordpress.com/的。非常感谢美国国家科学基金会、英特尔和国家卫生研究院对这项工作的资助。
Python 中的整数编程
We’ll use integer programming to make optimal decisions. Photo from Unsplash
整数规划(IP)问题是优化问题，其中所有变量都被约束为整数。知识产权问题是如何最好地分配资源的有用的数学模型。假设您正在为一位政治候选人组织一场营销活动，您正在决定向哪些选民发送营销材料。你可以给每个选民发一张醒目的传单、一本解释你议程的详细小册子，或者一张保险杠贴纸(或者三者结合)。如果你有办法根据人们收到的营销材料来衡量他们投票给你的候选人的可能性，你会如何决定发送哪些材料，同时注意不要超出你的供应量？
传统的优化算法假设变量可以采用浮点值，但在我们的情况下，给某人送半个保险杠贴纸或四分之三的小册子是不合理的。我们将使用一个名为 cvxpy 的特殊 python 包来解决我们的问题，这样解决方案才有意义。
我将向您展示如何使用 cvxpy 来解决政治候选人问题，但是我将首先从一个称为背包问题的简单问题开始，向您展示 cvxpy 语法是如何工作的。
背包问题
让我们假设你要去远足，你正在计划你可以带哪些物品。每个物体都有重量，单位是磅 w_i，会给你 u_i 单位的效用。你想把它们都带走，但是你的背包只能装 P 磅。假设你要么拿一个对象，要么不拿。你的目标是在不超过包的重量限制的情况下最大化你的效用。
cvxpy 问题有三个部分:
- **创建变量:**我们将用一个由 1 和 0 组成的向量来表示我们的选择。1 表示我们选择了那个对象，0 表示我们把它留在了家里。我们用 cvxpy 构造了一个只能取 1 和 0 的变量。布尔对象。
- **指定约束:**我们只需要确保我们的对象的总和不超过重量限制 p。我们可以使用选择向量和权重向量的点积来计算我们的对象的总重量。请注意，cvxpy 重载了*运算符来执行矩阵乘法。
- **公式化目标函数:**我们想要找到最大化我们效用的选择。任何给定选择的效用是选择向量和效用向量的点积。
Complete cvxpy code for the Knapsack problem
一旦我们有了一个成本函数和约束，我们就把它们传递给一个 cvxpy 问题对象。在这种情况下，我们已经告诉 cvxpy，我们试图用 cvxpy.Maximize 最大化效用。之后，我们可以通过查看选择向量的值属性来检查它的最优值。
print(selection.value)matrix([[1.],
[1.],
[1.],
[1.],
[0.],
[1.],
[0.],
[0.],
[0.],
[0.]])
我们选择了前四项和第六项。这是有道理的，因为这些有很高的实用重量比，而不会太重。
营销问题
现在我们已经介绍了基本的 cvxpy 语法，我们可以为我们的政治候选人解决营销优化问题。比方说，我们有一个模型，它接受一个选民的属性，并预测他们为我们发送给他们的营销材料的每个组合投票给我们的候选人的概率。我在这里使用了假数据，但让我们假设模型输出以下概率:
print(test_probs[0:5])array([[0.0001, 0.0001, 0.3 , 0.0001, 0.2 , 0.0001, 0.2 , 0.3 ],
[0.1 , 0.1 , 0.1 , 0.2 , 0.2 , 0.2 , 0.1 , 0.0001],
[0.1 , 0.0001, 0.2 , 0.0001, 0.1 , 0.2 , 0.0001, 0.4 ],
[0.3 , 0.0001, 0.0001, 0.2 , 0.1 , 0.2 , 0.2 , 0.0001],
[0.2 , 0.3 , 0.1 , 0.0001, 0.2 , 0.1 , 0.1 , 0.0001]])
每个成分有八个总概率，因为我们可以发送给个人的材料总共有八种组合。以下是每个 1 x 8 向量的条目所代表的内容:
【1 张传单，1 张小册子，1 张保险杠贴纸，传单和小册子，传单和保险杠贴纸，小册子和保险杠贴纸，三个都有，无】。
例如，如果第一个选民收到传单或小册子，他有 0.0001 的概率投票给我们的候选人，但如果我们给他寄去保险杠贴纸，他有 0.3 的概率投票给我们的候选人。
在我们进入 cvxpy 代码之前，我们将通过取负对数把这些概率转化为成本。这使得数学结果更好，它有一个很好的解释:如果概率接近 1，负对数将接近 0。这意味着向选民发送特定组合的材料几乎没有成本，因为我们确信这将引导他们投票给我们的候选人。如果概率接近于 0，反之亦然。
#clipping so that we don't take log of 0 or 1
test_probs = np.clip(test_probs, 0.0001, 0.9999)#turning into costs
model_costs = -np.log10(test_probs)
最后，假设我们不能发送超过 150 份传单、80 份小册子和 25 张保险杠贴纸。
supply = np.atleast_2d([150, 80, 25])
现在我们已经完成了所有的设置，我们可以开始有趣的部分了:
- **创建变量:**我们将使用 cvxpy。因为我们在这里只能做二进制选择。我们将指定它必须与我们的概率矩阵形状相同:
selection = cvxpy.Bool(*test_probs.shape)
2.**指定约束:**我们的选择变量将只告诉我们为每个组成部分做了 8 个选择中的哪一个，但它不会告诉我们决定给他们发送多少个材料。我们需要一种方法将我们的 1 x 8 选择向量转换成 1 x 3 向量。我们可以通过将选择向量乘以以下矩阵来实现:
TRANSFORMER = np.array([[1,0,0],
[0,1,0],
[0,0,1],
[1,1,0],
[1,0,1],
[0,1,1],
[1,1,1],
[0,0,0]])
如果这一部分有一点混乱，请解出下面的例子:
print(np.dot(np.array([0,0,0,1,0,0,0,0]), TRANSFORMER))array([1, 1, 0])
我们的决策向量的第四个条目表示向选民发送传单和小册子，乘以 TRANSFORMER 告诉我们的就是这一点！所以我们会告诉 cvxpy，我们的选择矩阵乘以 transformer 不能超过我们的电源:
supply_constraint = cvxpy.sum_entries(selection * TRANSFORMER, axis=0) <= supply
我用 cvxpy.sum_entries 对这些行求和，以合计我们发送给所有委托人的材料总数。
我们还需要确保每个成分只做一次选择，否则求解器可以通过不向任何人发送任何东西来实现零成本。
# We must make our choice per constituent
# remember that the last column is for "no materials"feasibility_constraint = cvxpy.sum_entries(selection, axis=1) == 1constraints = [supply_constraint, feasibility_constraint]
3.**公式化目标函数:**我们任务的总成本将是我们为每个组成部分所发生的成本的总和。我们将使用 cvxpy.mul_elemwise 函数将我们的选择矩阵乘以我们的成本矩阵，这将为每个成分选择成本，cvxpy.sum_elemwise 函数将通过将各个成本相加来计算总成本。
cost = cvxpy.sum_entries(cvxpy.mul_elemwise(model_costs, selection))
最后一步是创建 cvxpy。问题并解决它。
# Solving the problemproblem = cvxpy.Problem(cvxpy.Minimize(cost), constraints=constraints)problem.solve(solver=cvxpy.GLPK_MI)
就是这样！下面是我们期末作业的快照。我们决定不给第一个选民寄任何材料。这是有道理的，因为无论我们给他们寄去保险杠贴纸还是什么都不寄，他们投票给我们候选人的概率都是 0.3。
事实证明，最佳作业耗尽了我们的小册子和保险杠贴纸，但只用了总共 150 张传单中的 83 张。我们应该告诉我们的候选人，她的传单没有她想象的那么有说服力。
print(hard_assignments.value[0:5])matrix([[0., 0., 0., 0., 0., 0., 0., 1.],
[0., 0., 0., 1., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 1.],
[1., 0., 0., 0., 0., 0., 0., 0.],
[1., 0., 0., 0., 0., 0., 0., 0.]])print(np.dot(hard_assignments.value, TRANSFORMER).sum(axis=0))matrix([[83., 80., 25.]])
以下是打包在一起的所有代码:
结束语
我希望您喜欢学习整数编程问题以及如何用 Python 解决这些问题。信不信由你，我们已经涵盖了你解决自己的优化问题所需的大约 80%的 cvxpy 知识。我鼓励你阅读官方的文档来了解剩下的 20%。CVXPY 能解决的不仅仅是 IP 问题，看看他们的教程页面，看看 cvxpy 还能解决什么问题。
要安装 cvxpy，请遵循他们网站上的说明。我还会安装 cvxopt 来确保 cvxpy 附带的所有解算器都能在你的机器上工作
我们已经指定 cvxpy 应该在求解方法中使用 GLPK _ 米求解器。这是一个专门为 IP 问题设计的求解器。在你解决你自己的问题之前，参考这个表来看看哪个预先打包的 cvpxy 解算器最适合你的问题。
快乐优化！
将 TensorFlow 分布式图像服务与 TensorFlow 对象检测 API 集成
通过网络为您的 TensorFlow 对象检测模型服务
这款笔记本是使用 TensorFlow-Serving 的 RESTful API 服务基于图像的深度学习模型的续集。请务必阅读该文章，以了解 TensorFlow 服务和 TensorFlow 分布式图像服务(Tendies)库的基础知识。强烈推荐克隆Tendies 库来跟随本教程，因为我将关注重要的代码摘录而不是整个文件。如果你想在笔记本上查看这篇文章，点击这里。
在这里，我们将扩展基本 Tendies 类的功能，以集成一个更快的 R-CNN 深度神经网络，它使用 TensorFlow 对象检测 API 。这将允许我们为符合 REST 的远程推理提供更快的 R-CNN，就像上一篇文章中的 CycleGAN 一样。
CycleGAN 相当简单，因为它接受图像并输出图像；然而，更快的 R-CNN 接受一个图像并输出张量的字典。此外，对象检测 API 迫使我们从 pipeline.config 构建我们的模型，并且重新定义推理函数，使得服务更快的 R-CNN 成为更困难的任务。整合新模型和趋势的步骤如下:
- 在 LayerInjector 中定义预处理和后处理功能。
- 在 ServerBuilder 中创建或导入模型推理函数。
- 创建或导入客户端。
虽然我将使用更快的 R-CNN 进行演示，但是这些步骤对于任何任意模型都是相同的，所以请按照您的特定用例随意操作。
分层注射
每个预处理函数必须将图像位串、图像大小和args(其中args 可用于表示任意数量的自定义位置参数)作为参数，然后将模型输入作为张量返回。相反，每个后处理函数必须将模型输出和*args 作为参数，然后返回输出节点名称列表以及输出是否应该作为图像传输。这些输出将在导出模型时在 ServerBuilder 中使用。
首先，我们将定义我们的预处理函数，它将把图像位串转换成适合推理的 uint8 张量。
import tensorflow as tf
def bitstring_to_uint8_tensor(self, input_bytes, image_size, *args):
input_bytes = tf.reshape(input_bytes, [])# Transforms bitstring to uint8 tensor
input_tensor = tf.image.decode_png(input_bytes, channels=3)# Ensures tensor has correct shape
input_tensor = tf.reshape(input_tensor, [image_size, image_size, 3])# Expands the single tensor into a batch of 1
input_tensor = tf.expand_dims(input_tensor, 0)
return input_tensor
符合对象检测 API 的模型返回有用张量的字典，比如 num_detections、detection _ boxes 等等。在我们的后处理函数中，我们将遍历这些张量并给它们分配名称，这样我们就可以在 ServerBuilder 中提取它们。我们还必须考虑检测类张量的 1-索引。最后，我们返回一个输出节点名称列表，并将 output_as_image 设置为 False，因为我们将通过 JSON 将输出张量(不是可视化的图像)发送回客户机。
def object_detection_dict_to_tensor_dict(self, object_detection_tensor_dict, *args):
# Sets output to a non-image
OUTPUT_AS_IMAGE = False
# Class labels are 1-indexed
LABEL_ID_OFFSET = 1 # Assigns names to tensors and adds them to output list
output_node_names = []
for name, tensor in object_detection_tensor_dict.items():
if name == "detection_classes":
tensor += LABEL_ID_OFFSET
tensor = tf.identity(tensor, name)
output_node_names.append(name) # Returns output list and image boolean
return output_node_names, OUTPUT_AS_IMAGE
如果您遵循您自己的模型，可以随意使用*args 来接受您需要的任意多个参数进行处理。Tendies 对张量的形状和类型相当挑剔，所以要确保你的预处理器的输出和后处理器的输入分别等价于你的模型的输入和输出。
推理功能
接下来，我们必须从 pipeline.config 构建更快的 R-CNN，并定义我们的推理函数。其代码在 example_usage()下的 ServerBuilder.py 中，这是我们的模型导出的地方。通过将配置文件读入对象检测 API model_builder，我们可以实例化一个更快的 R-CNN，而无需实际查看模型代码。接下来的几个单元格被认为在 example_usage()的范围内。
from object_detection.protos import pipeline_pb2
from object_detection.builders import model_builder
from google.protobuf import text_format# Builds object detection model from config file
pipeline_config = pipeline_pb2.TrainEvalPipelineConfig()
with tf.gfile.GFile(config_file_path, 'r') as config:
text_format.Merge(config.read(), pipeline_config)detection_model = model_builder.build(pipeline_config.model, is_training=False)
由于 export_graph 期望单个推理函数，但是对象检测 API 有自己的前后处理要做，所以我们必须自己将它们组合起来。这是使用闭包的好地方，因为当我们传递推理函数时，我们希望保留实例化更快的 R-CNN 的范围。闭包是最好的。
# Creates inference function, encapsulating object detection requirements
def object_detection_inference(input_tensors):
# Converts uint8 inputs to float tensors
inputs = tf.to_float(input_tensors) # Object detection preprocessing
preprocessed_inputs, true_image_shapes = detection_model.preprocess(inputs)
# Object detection inference
output_tensors = detection_model.predict(preprocessed_inputs, true_image_shapes)
# Object detection postprocessing
postprocessed_tensors = detection_model.postprocess(output_tensors, true_image_shapes)
return postprocessed_tensors
最后，我们将实例化一个 ServerBuilder 和 LayerInjector，然后导出模型。注意，我们将推理函数、预处理器和后处理器传递给 export_graph()。
# Instantiates a ServerBuilder
server_builder = ServerBuilder()# Instantiates a LayerInjector
layer_injector = LayerInjector()# Exports model
print("Exporting model to ProtoBuf...")
output_node_names, output_as_image = server_builder.export_graph(
object_detection_inference,
layer_injector.bitstring_to_uint8_tensor,
layer_injector.object_detection_dict_to_tensor_dict,
FLAGS.model_name,
FLAGS.model_version,
FLAGS.checkpoint_dir,
FLAGS.protobuf_dir,
FLAGS.image_size)
print("Wrapping ProtoBuf in SavedModel...")
server_builder.build_saved_model(output_node_names,
output_as_image,
FLAGS.model_name,
FLAGS.model_version,
FLAGS.protobuf_dir,
FLAGS.serve_dir)
print("Exported successfully!")
客户
创建定制趋势客户端的最佳方式是从客户端继承，这为远程推理提供了一个框架。在这样的子类中，只需创建 visualize()和相关的 helper 函数，然后调用 client.inference()开始评估过程。
我们将需要几个这样的帮助函数；第一个函数与我们的预处理函数几乎完全相同，只是没有添加批处理。
def bitstring_to_uint8_tensor(self, input_bytes):
input_bytes = tf.reshape(input_bytes, []) # Transforms bitstring to uint8 tensor
input_tensor = tf.image.decode_jpeg(input_bytes, channels=3) # Ensures tensor has correct shape
input_tensor = tf.reshape(input_tensor, [self.image_size, self.image_size, 3])
return input_tensor
我们的第二个助手函数将用于从提供的标签映射中的对象检测 API 创建我们的类别索引字典；这个更快的 R-CNN 的具体实现只有一个类，所以很简单:
from object_detection.utils import label_map_util
def get_category_index(self):
# Loads label map
label_map = label_map_util.load_labelmap(self.label_path)
# Builds category index from label map
categories = label_map_util.convert_label_map_to_categories(label_map, max_num_classes=1, use_display_name=True)
category_index = label_map_util.create_category_index(categories)
return category_index
借助我们的助手，我们的可视化功能还不算太差。我们将解码 JSON 数据并将其转换为边界框，然后在对象检测 API visualization_utils 的帮助下将它们覆盖在输入图像上。请注意，我们将输入图像转换为张量，因此我们必须。在可视化之前对其进行 eval()。
from object_detection.utils import visualization_utils
def visualize(self, input_image, response, i):
# Processes response for visualization
detection_boxes = response["detection_boxes"]
detection_classes = response["detection_classes"]
detection_scores = response["detection_scores"]
image = self.bitstring_to_uint8_tensor(input_image)
with tf.Session() as sess:
image = image.eval() # Overlays bounding boxes and labels on image
visualization_utils.visualize_boxes_and_labels_on_image_array(
image,
np.asarray(detection_boxes, dtype=np.float32),
np.asarray(detection_classes, dtype=np.uint8),
scores=np.asarray(detection_scores, dtype=np.float32),
category_index=self.get_category_index(),
instance_masks=None,
use_normalized_coordinates=True,
line_thickness=2) # Saves image
output_file = self.output_dir + "/images/" + self.output_filename + str(i) + self.output_extension
visualization_utils.save_image_array_as_png(image, output_file)
使用服务器
既然我们已经完成了集成更快的 R-CNN 和 Tendies，让我们运行服务器。首先，我们必须导出我们的模型:
python serverbuilder.py --checkpoint_dir $(path) --image_size 512
截至 2018 年 7 月，Python 3 不支持 TensorFlow 服务，但有人提出了解决方案。安装 Python 3 TensorFlow 服务 API，包括:
pip install tensorflow-serving-api-python3
现在，我们可以用下面的命令从 bash 运行这个 TensorFlow 模型服务器:
tensorflow_model_server --rest_api_port=8501 --model_name=saved_model --model_base_path=$(path)
其中$(path)是服务器目录的路径。在我的例子中，它是/mnt/c/Users/Tyler/Desktop/tendies/full _ functional/serve。
最后，我们可以通过在输入图像的文件夹上调用我们的客户端来运行远程推理:
python objectdetectionclient.py
结论
感谢跟随本教程；希望对你有帮助！这个笔记本是用我的 TensorFlow 分布式图像服务库构建的，你可以在这里下载。更多关于我的博文和信息，请访问我的网站。
计算机器中的智能:探索、方法和未来
智能科学与工程整体发展的必要性
Photo by Alexandre Debiève on Unsplash
出于某种原因，我们倾向于让我们的生活变得更好。科学和工程分别努力理解事物和建造它们，互相帮助进行下一次迭代。经过多次反复之后，我们变得更加明智，对我们的生活和我们自己的内心有了更多的控制，最终使我们变得更加文明。下一个迭代是智能的科学和工程。
智力的这个问题，无论是智力的科学还是工程，都被 认为是 所有科学中最大的问题，可能是科学和工程本身的最后一次迭代。如果要解决智能问题，机器智能是必要的或迫在眉睫的。
智能机器，如果成为可能，可能是许多问题的答案。制造甚至设计的完全自动化，个人辅助和护理，增强的人类智能，以及科学发现本身。这是未来的路。我们甚至不知道这是否可能。但是，这正是激起人类好奇心的原因。
在这里，我们看到了在计算机器中对智能的追求，以及几种构建智能机器的独立方法。我们推断出智力问题的严格跨学科性质和该领域研究者的明显利益不一致。一直以来，我们呼吁智能科学和工程的整体发展，这可以帮助我们克服如此多的障碍，为通往智能机器的道路提供一个清晰的视野。
1.探索
将智能设计到机器中的想法可以追溯到数学家、第一个计算机程序员阿达·洛芙莱斯，他说“除了思考，机器可以做任何事情”。在一定程度上反对这种反对意见和其他意见，关于机器智能的最重要的早期工作是艾伦·图灵(Alan Turing)的开创性论文《计算机器与智能》(Computing Machinery and Intelligence)，他在论文中还谈到我们应该如何阐述“机器会思考吗？”这个问题。我们可以推断，他把“思考”的问题简化为对人类对话的模仿，这可能涉及推理、解决问题、常识和对世界的理解。他预言，大约 50 年后，我们将拥有一台相当大的思维机器，但 70 年后的今天，我们仍然没有一台我们都认为智能的机器。
对激动人心的冒险的乐观
后来，人工智能领域在达特茅斯的夏季研究项目中崭露头角，参与者有约翰·麦卡锡、马文·明斯基、克劳德·香农等。整个领域都非常乐观，他们的项目将逻辑、常识、一般问题解决能力整合到一台机器中，我们现在意识到这是一个遥不可及的目标。
马文·明斯基在他的论文“迈向人工智能的步骤”(出版， pdf )中，带着我们不再敢拥有的对人工智能的断言和希望，总结如下——(这篇论文是计算智能科学的一个伟大而简单的例子)。
启发式编程的问题——让计算机解决真正困难的问题——分为五个主要领域:搜索、模式识别、学习、规划和归纳。在适当的地方，讨论由文献的广泛引用和一些迄今为止最成功的启发式(解决问题)程序的描述来支持。
研究者们想出了不同的模型，主要是通过对事物及其变化的符号解释，这些模型只能达到探索他们所追求的问题的重要性的程度，但没有一个成功。然后，基于商业规则的专家系统出现了，但并没有给科学发现带来飞跃。即便如此，由于问题的艰巨性和整体性，还是有太多的方法是合理的。直到问题的严重性使人气馁之后，不可挽回的损失才发生。
连接主义(与符号方法相反，具有对象的分布式表示和从数据中进行统计学习的能力——例如，神经网络)方法开始发挥作用了。然后，大多数研究人员停止了智能机器科学的研究，转而专注于他们狭隘智能的小项目。语音识别、对象检测和所有类型的模式识别任务都受益匪浅。这并不是说它没有带来任何好处(许多应用为我们提供了很好的服务)，而是智能机器的科学没有前进一步。
一个被低估的问题
智力的问题总是被低估，也许是因为它的新颖性、艰巨性和整体性。许多研究人员，如图灵、马文·明斯基，大概还有所有从事人工智能工作的人，都预测智能机器会比现在更早出现，但事实上，我们离他们建造智能机器的目标并不遥远。
2.方法
这个问题吸引了许多制造智能机器的方法。在这个领域的开端，象征主义和联结主义的方法。然后，人工智能模型是否需要更多的天赋才能变得智能，直到根据正在解决的狭隘问题寻求混合方法，而不参考智能机器的科学。
从事象征主义和联结主义研究的研究者预见到了建造智能机器的成功，但对另一种方法持怀疑态度。前者的研究者，因为问题的复杂性，如常识和一般问题的解决，而后者的研究者，因为他们的方法具有更好的模式识别能力。参见这个关于智能机器的理论，‘符号主义者对联结主义者’，它谈论将智能设计到机器中，并使辩论成为暂时的，而不是需要关注的主要问题。
“……智能系统需要这两个组成部分，所以符号连接主义的对立不是一个有效的技术问题，而只是当代科学政治中的一个短暂问题。”
现在，竞争的范式是非常不同的类型，比如是否在模型中使用更多的先天机制。先天机制是模型中独立的(先验的)结构，无法从数据中学习。在大多数情况下，它支持并推动学习。举一个熟悉的先天类型的例子，卷积神经网络中的卷积或权重分配可以被视为驱动特定学习的先天机制。
现在，从哲学到语言学，围绕智能机器的天赋有很多讨论，Gary Marcus 和阎乐存之间的这场辩论(视频)题为**‘人工智能需要更多的先天机器吗’**将是相当全面和当代的。
以及是否从神经科学中寻找灵感或者从零开始建造智能机器。强化学习是最终的答案。神经网络是。现在，像计算机视觉，自然语言处理，机器人，生成模型等子领域。，提供了从智能机器科学的困难问题中解脱出来的方法，这是唯一有助于每个子领域在更大的时间范围内向前飞跃的东西。
面对所有科学中最大的问题，我们再次低估了这个问题，但现在，由于缺乏对智能科学整体发展的关注，在深度学习短暂成功的启发下，我们转向了不同的方法或子领域。一门具体的智能科学将会成功地辨别在模糊不清的时代什么是正确的方法，以及什么是正确的方法组合来推进每个子领域。没有智能科学，我们就无法成功地将智能设计成一台机器。
3.今后
智能科学和工程的理论有必要引导相关领域(可能涉及人类智能或人工智能，如计算机科学、神经科学、认知科学、哲学、心理学……)的研究者走上正确的道路，或者至少为不同的研究提供占位符，并能够在下一次迭代中建立这些占位符。
David Marr，一位杰出的视觉研究者，表达了他的观点，即探索物体表征的不同类型的内在结构的研究将对计算机视觉产生影响。从视觉智能的角度查看分类调查的综述- “人工智能-个人观点”
“……Marr 和 Nishihara 的 3D 表示理论断言，深层结构本质上是简笔画的结构，这种表示在图像分析过程中受到操纵……”
以便在下一次迭代中解决不同的认知任务，如推理、常识和问题解决。这来自心灵哲学的方法，即有一个先验的结构来实现无法学习的感知。比起从一个数据集求解到另一个数据集，这是一个更好的研究方法。一个完整的智力理论将鼓励这种研究，并通过这种研究得以实现。
深度学习领域的研究人员表示(在关于模型所需先天的争论中)，他们正在将先验结构(先天)的所有方面整合到模型的架构中**，以便它可以从数据中学习一切**。在科学迭代中，这将成为一个可信的调查，但只有通过讨论他们的调查的重要性和立场，更多地关注这些方面，参考智能科学，而不是仅仅在辩论中为他们辩护。(关于先天的争论如上所述)
我们不能只猜测我们的调查将是解决问题的第一步，甚至不考虑完全了解我们正在解决的问题。我们必须将我们的研究作为原始数据呈现给下一代，这些原始数据将在下一次迭代中被研究。我们必须以超出应用科学范围的更科学的严谨态度来处理智力问题。
该领域目前的调查能力
主要研究在著名的机器学习会议上提出，如 NIPS、ICML、ICLR 等。，是关于神经网络的新结构和算法，神经网络模型的理论理解，改进最优化，正则化等的新方法。，以及一些受神经科学和认知科学启发的实现。
不是出于对智能能力的关注，而是该领域目前的研究实际上对智能机器的科学和工程没有多大贡献。大部分工作都被认为是对机器智能的贡献，说“这是迈向机器智能的第一步，也是必不可少的一步”,而没有考虑它在智能机器完整理论中的作用。如果从任何角度来看，这些研究似乎在智能机器科学中发挥了作用，那么**，我们可以很容易地看到，它只是在几个方面，而不是全面的，这使得即使那些微小的贡献也不具有建设性。**应用机器学习的多功能性和价值可能会随着一些政治和文化影响对该领域产生影响。
我们可以在一定程度上看到智能机器科学的贡献。对于一个简单的衡量标准，让我们看看
- 如何在该领域的调查中利用马文·明斯基提出的智能机器的五个组成部分(搜索、模式识别、学习、规划和归纳，来自上述论文“迈向人工智能的步骤”)、它们的关系以及它们的组合集成。
- 柏拉图、亚里士多德和康德等许多心灵哲学家提出的感知和理解的先验结构(先天结构)如何被证明/集成到为机器感知和理解而设计的神经网络模型中。
- 机器学习社区接受输入(要实现的理论、设计模型的见解、模型的验证等)的频率和认真程度如何。，)从几十年甚至几个世纪以来一直在研究人类智力和大脑的领域，像心灵哲学、数理逻辑、神经生理学、认知科学、心理学、神经科学等等。
显然，这些方法不是主流。也许是因为存在更多有益于智力的途径(通过应用科学)，而这些途径不一定对科学有贡献。这些途径的问题在于，它们很少能成功实现我们让机器变得智能的目标。
对该领域先驱的影响
该领域的大多数研究人员都会同意，人工智能作为一个领域正处于起步阶段。在所有的科学中，一个新兴科学领域的研究者们会专注于他们正在解决的问题的根源。这是智力的问题，根源是心灵哲学、认知和行为科学、心理学、语言学等等。
这一领域的先驱们很清楚这一点。马文·明斯基是人工智能的先驱之一，他深受心理学家西格蒙·弗洛依德和许多在他之前的哲学家的影响。他职业生涯的大部分时间都在研究智能机器的理论。他最重要的工作可能是‘心智社会’，这是一个大脑的计算模型。它建立在计算理论、数理逻辑、神经解剖学、哲学、认知和行为心理学的基础上，以解释智力的不同方面。
约翰·麦卡锡广泛致力于将逻辑集成到机器中，致力于哲学和人工智能的交叉。为了熟悉他从哲学中借用的思想，请参见这篇有见地的论文，‘人工智能的哲学和人工智能的哲学’。
甚至该领域的一些杰出研究者也欣赏人工智能的跨学科性质。Deepmind 的联合创始人戴密斯·哈萨比斯为神经科学启发的人工智能提供了一个案例，支持神经科学的灵感帮助人工智能的例子，并描述了这种方法在机器中设计智能的潜力和必要性。
一位年轻的实地调查员
让我们假设在不久的将来，一些新的领域的调查者想要一台机器来理解世界上的事情，并通过阅读文本输入来推理抽象的想法。然后，他可能不会单独使用人工智能/深度学习的工具成功建立那个模型。他需要从语言学、逻辑学、常识推理、认识论的研究中获得灵感，还需要从神经科学、认知科学等方面了解大脑实际上是如何理解的…,
如果一个人打算从事智能科学和工程方面的工作，他/她必须超越这一新生领域的研究者的工作，看到先驱者本身的影响。如果我们对正在解决的问题不全面，那么我们最终会“重新发明轮子”，或者可能根本解决不了问题。
与智能相关的问题，信息技术的科学和工程，应该是所有人工智能研究的基础，但在目前的情况下，它们最终只是总结整个领域的流行谈话中的一个哲学上的一线希望。
参考
[1]艾伦·m·图灵。计算机械与智能 ( pdf )，Mind 1950。
[2]马文·明斯基。迈向人工智能 ( pdf )，IRE 会议录，1961 年。
[3]马文·明斯基。符号主义者 vs 联结主义者，麻省理工学院人工智能，拓展前沿，帕特里克·h·温斯顿(编。)，第一卷，麻省理工学院出版社，1990 年。
4 大卫·马尔。人工智能——个人观点，AIM 355，1976 年 3 月。
[5]马文·明斯基。心理学会，西蒙&舒斯特公司，纽约，纽约州，美国 1986 年，ISBN:0–671–60740–5
[6]约翰·麦卡锡。人工智能的哲学和哲学的人工智能，斯坦福大学计算机科学系，2006 年。
[7]加里·马库斯。天赋、AlphaZero 和人工智能， arXiv:1801.05667， 2018。
[8]戴密斯·哈萨比斯、达尔山·库马兰、克里斯托弗·萨默菲尔德、马修·博特文尼克。神经科学启发的人工智能，神经元，2017。
这是’ 探知’ 举报的奠基篇。即将发表的文章详细讨论了哲学和语言学中提出的不同的先验结构(先天机器)，以及它们如何在机器感知和语言理解的当代研究中实现。
智能环境:从汽车到国家
物联网正在改变我们周围的世界。我们从电脑、平板电脑和智能手机的普及开始。现在我们可以制造小而低成本的芯片，将它们嵌入电器、灯、门、窗甚至马桶中。让我们看看这项技术将如何在不同的尺度上改变我们的环境。
无人驾驶汽车
研究人员在 20 多年前推出了第一辆自动驾驶汽车，它们包含一套 100 多公斤的计算机。如今，一块 6 英尺大小的智能手机配一对摄像头就可以做同样的工作，价格不到 1000 美元。同样，软件驾驶比普通司机安全得多，尽管在特殊情况下会有一些问题。
MobilEye 是该领域的领先公司之一(最近被英特尔以 150 亿美元收购)。他们为沃尔沃、宝马、奥迪和许多其他公司提供技术。埃隆·马斯克创造的特斯拉将在今年年底实现完全自动化。数十家其他创业公司正在崛起，你可以在网上学习如何开发自动驾驶技术。
智能家居
知道哪些产品丢失或变质的冰箱。咖啡机，等待信号从你的智能手机，你醒了，开始做一杯。了解您的偏好并找到您可能喜欢的节目的电视。这种门可以识别你的指纹或声音，不用任何钥匙就能打开。根据您的需求不断调节的气候控制和照明。监控你健康和饮食的马桶。
你家的每一部分都可以适应创造你喜欢的环境。
自动化商店、诊所和学校
亚马逊将带着他们的新项目 Amazon Go 走向现实世界。一般都是没有排队和结账的店。进来吧，带上你需要的东西，然后出去。周围的智能传感器系统会识别你拿了什么东西。在你离开商店后，它会自动从你的信用卡上扣钱。不再等待，24/7 简单购物。
在医院门口用一滴血诊断成千上万种疾病怎么样？或者，例如，MRI 扫描仪在没有任何服务人员的情况下检测肿瘤并将结果发送给医生？
对于学生，我们可以提供个性化和互动的教育。此外，我们可以自动记录孩子的出勤和进步情况。
适应性城市
每个大城市都有交通基础设施的问题。传感器可以提供关于交通、免费停车场和事故的信息。此外，结合自动驾驶汽车，这个网络将能够大大减少交通堵塞。
旧金山和洛杉矶电灯公司正在升级他们的室外照明。一项技术根据周围人的数量来控制亮度，而第二项技术可以检测并向警察部门报告枪声。结合起来，他们可能会减少犯罪和电费。
超过 100 个城市已经实施了智能垃圾箱，以减少容器数量和降低回收费用。
智能国家
今天可用的自然语言处理工具能够处理数百万个文档。机器人可以处理公共咨询服务。用于识别身份的智能应用程序可以简化投票过程，促进民主。Civiciti 正在开发一种类似的产品。看一看:
同时，人工智能技术可能被用于有问题的项目。中国政府正在开发一个系统，该系统将分析公民的公共和私人信息，并给他们打分。它可以用来作为信用评分，就业，禁止出境，抵制欺诈和许多其他目的。
我认为收集关于公民的数据是有用的，但是这样的项目应该完全透明。
智能物流
【戴上我的公司分析师帽子……】
物流领导者开始利用他们的信息物理系统产生的大量数据。通过人工智能，他们发现了更高的效率、更高的性能、更复杂的网络协调和更准确的需求预测。
物流是一个庞大的行业，已经在全球范围内形成了一个复杂的网络。收入估计为 8 万亿美元，预计到 2024 年将增长到 15.5 万亿美元。与此同时，IDC 预测，到 2020 年，全球人工智能支出将增长至 470 亿美元，相当于 55%的 CAGR。随着人工智能与工业物联网的融合，物流公司现在看到了人工智能的价值。
像供应链的许多部分一样，物流正在经历数字化转型。连接物流价值链会产生更多的数据、更好的互操作性和更强的控制力。现在，它正在被学习系统(深度学习算法的集合)放大，这些系统筛选数据，建立和管理高分辨率模型，微调运营绩效，并预测整个价值链的变化。对于物流运营商来说，这些变化可以实现持续的感知和学习，以及在不断加速的世界中保持敏捷和适应性的能力。
德国物流公司 DHL 认为这是一个 1.9 万亿美元的机会。援引来自能源、安全和技术的压力，他们的物流趋势雷达宣称，“数据驱动和自主供应链的影响为制造、物流、仓储和最后一英里交付方面以前难以想象的优化水平提供了机会，这可能在不到五年的时间内成为现实。”物流正在进入第四次工业革命。
…围绕不同的地理需求，协调他们的动态供应网络。
供给&需求
从库存到交付，该行业一直在持续数字化和自动化。亚马逊现在在其仓库中部署了超过 45，000 台机器人拣货员。学习系统直观地检查新包装，监控货架，为每件商品分配包装，并协调库存从仓库到运输车辆的移动。这种数据、机器人和机器智能的融合已经成为信息物理系统的模板。“我们喜欢将它视为软件、机器学习、计算机算法和人的交响乐，”亚马逊发言人凯利·齐斯曼说。
管理供应和需求可能非常复杂，失误可能意味着错过机会和浪费商品，尤其是易腐商品。Shelf Engine 使用学习系统根据历史需求模式预测订购多少食物。他们帮助零售商 Molly’s 增加了 9%的利润。跨国杂货商 Tesco 通过将天气数据输入其预测分析引擎来预测对天气相关食品(如冰淇淋)的需求，节省了 1.4 亿美元。他们使用这些数据来调整每个商店的库存和订单，围绕不同的地理需求来协调他们的动态供应网络。
从库存到编排
物流公司必须协调大型供应商、合作伙伴、分包商和车辆网络。这些存在于更大的背景下，如地区需求、全球经济、地缘政治和气候。随着学习系统构建更强大的模型并整合来自世界的信息，它们充当网络指挥者的能力正在增强。ClearMetal 利用预测物流来管理集装箱，解决了这一复杂性。为了降低供应和需求之间的风险，他们跟踪集装箱，评估承运人，并整合关于天气、经济和港口条件的第三方信号，用机器学习对所有这些进行建模。
引擎盖下
随着越来越多的组件被连接和感知，越来越多的数据可以输入到学习系统中。罗尔斯·罗伊斯的特伦特·XWB 喷气发动机有数千个传感器，在长途飞行中产生万亿字节的数据。使用微软的 Azure Stream Analytics 和机器智能库，他们可以优化燃油效率并预测维护，从而节省成本并最大限度地减少停机时间。通用运输公司对其机车也采取了同样的做法，同时试图为每天运送 500 万吨货物的美国铁路系统提供仪器。戴姆勒和纳威司达各自在相连的车队中试验了自动驾驶长途卡车——百威英博自动运送了一卡车啤酒(在优步 Otto 无人驾驶设备的帮助下)。百威英博表示，自动卡车运输每年可以在美国节省 5000 万美元。孟买的 ABB 船舶管理展示了许多重工业的路线图。他们正在他们的船上和船之间建立网络，以及连接和自动化操作的服务。这将让他们使用远程控制，然后启动完全自主的系统。ABB 展示了如何利用物理资产获取高分辨率数据，从而为深度分析、预测模型和自我管理奠定基础。
这说明了也许是最有价值的机会:降低能源和水的使用，污染和排放，以及工业化的临近。
含义
在其关于第四次工业革命的工作中，世界经济论坛宣称“我们正站在一场技术革命的边缘，这场革命将从根本上改变我们的生活、工作和人际交往方式。”物流领域的领导者一直在稳步奠定这一基础，现在正在构建学习系统来理解所有数据。初创公司正试图分拆物流，让大型运营商拥有一些灵活性和撤资的机会，同时也威胁到他们的控制权。这推动了更多的竞争和并购。
自动化、预测和协调复杂、动态的生态系统以提高性能和效率的能力将继续吸引 R&D 并保证季度收益。谷歌已经表明，其 DeepMind 学习系统可以将数据中心的能源成本降低 15%。他们不仅在其数据中心部署了这一解决方案，而且现在他们正在与英国国家电网合作，看看相同的解决方案是否可以降低英国能源足迹的总体负荷。这说明了也许是最有价值的机会:降低能源和水的使用，污染和排放，以及工业化的临近。
路障
物流转型面临诸多挑战。人工智能很难，物流是一个庞大而分散的行业，协调着数万家企业。存在相当大的数据和互操作性挑战，但人工智能可以被训练在它们之间进行翻译。该行业厌恶风险，采用速度缓慢，尤其是当网络暴露出安全和漏洞问题时。此外，随着自主系统继续对人类劳动力施加压力，监管反应将会很强烈。在美国，350 万工人驾驶运输车辆。随着物流车队变得自主，劳工危机将会发展，并推动监管机构施加限制。
还有许多挑战有待解决，但人工智能提供的能力太强大了，不容忽视。这是影响所有行业的下一波数字化转型。
智能支付路由
使用多臂 Bandit 算法优化支付性能
Multi-Armed Bandits a.k.a. Slot Machines
如果你有一个电子商务网站，你很可能会花无数的时间来寻找正确的产品组合，内容，按钮，颜色和其他变量，可以提高你的转化率，平均交易价值，最终你的收入。大多数商家止步于支付。
多年来，支付行业让我们相信，在优化结账流程的性能方面，我们几乎无能为力。大多数美国企业只要求能够接受信用卡，从标准的万事达卡和维萨卡，到增加美国运通、 JCB 、 Diners/Discover 或银联。但纵观全球，本地支付方式已经能够捕捉到很大一部分交易，尤其是在线交易。荷兰有 iDeal，德国有 Sofort，法国有 Cart Bancaire，中国有支付宝，日本有 Konbini。全球现在有超过 250 种可供选择的支付方式，这使得商家更难决定他们应该提供什么样的支付方式，更不用说优化了。
The global brand general purpose cards — Visa, UnionPay, Mastercard, JCB, Diners Club/Discover, and American Express — generated 295.65 billion purchase transactions for goods and services in 2017, up 18.0%.
实验
在金融服务行业工作超过 14 年后，我一直使用数据来帮助自己和他人做出更好的决策。通过描述性分析(发生了什么)、诊断性分析(为什么会发生)、预测性分析(可能会发生什么)或规定性分析(采取什么行动)。
作为一名数据科学家，我最喜欢最后阶段，因为那是我进行实验的地方。第一阶段对于弄清楚发生了什么，甚至为什么会发生什么是必要的，但是能够使用数学和算法来预测将要发生的事情，并开发技术来自动化需要采取的行动，这才是真正让我兴奋的。
因此，当我在 2015 年为一家大型全渠道零售商做项目时，他们很难决定使用哪种支付方式组合。在六个月的时间里，我研究了他们的业务、新的和已有的支付方式，以及客户从登陆网站到付款或决定不付款的行为。我创建了实验来测试不同的场景，并进行优化，直到我得到最佳的支付组合。事后看来，实验非常成功，我们将结账转化率(购物者点击支付按钮并实际输入和成功支付交易的转化率)从 91%提高到 95%。额外的收益是额外的 100 万欧元的收入，预计在接下来的 12 个月中会有 400 万欧元的收入。我没有留在公司，而是从处理商户交易的 PSP(他们是项目的发起人)那里得到了一个提议，用我的方法帮助其他更大的商户获得相同类型的结果。
加入一家注重结果而非完美执行的超高增长公司后，我能够在近两年的时间内运行超过 100 种不同的分析和实验，并得出描述性、诊断性、预测性和规范性的分析结果。从计算授权率，提高收单性能，弄清楚支付领域的哪些变量导致被授权的可能性更高。但在所有这些项目中，帮助商家找到最佳支付组合是最突出的。
考虑到这个问题和许多其他问题，运行多个实验是获得答案的唯一途径，我无意中发现了多臂强盗算法。
多臂强盗实验
多臂强盗是一种实验类型，其中:
- 目标是找到最佳或最有利可图的行动
- 随机化分布可以随着实验的进行而更新
“多臂强盗”这个名字描述了一个假设的实验，在这个实验中，你面对几个吃角子老虎机(“单臂强盗”)，它们具有潜在的不同预期支付。你想找到具有最佳支付率的吃角子老虎机，但你也想最大化你的奖金。根本的矛盾在于“利用”过去表现良好的武器和“探索”新的或看似较差的武器，以防它们表现更好。
被谷歌用来运行内容实验，我开始思考支付服务提供商和更具体的收单连接是如何相似的。与大多数人可能认为的不同，PSP 或收购方可能对正在处理的交易的性能有很大影响。根据地区、声誉和数据质量等变量，信用卡交易平均有 80%的几率被批准。他们拒绝的原因可以从资金不足，交易不允许持卡人或广泛覆盖不兑现。通过拥有多个 PSP 或获取连接，多臂 Bandit 实验可以在没有人工干预的情况下产生最佳性能。
盗匪如何运作
本质上，多臂 Bandit 算法从多个变量开始，基于输入产生输出。根据性能，每个变量的流量比例将自动调整。性能优于其他变体的变体将被分配更大部分的流量，而性能不佳的变体将看到流量减少。每次调整都基于一个统计公式，该公式同时使用样本大小和绩效指标，以确保变化是真实的绩效差异，而不仅仅是随机的。根据时间和流量，一个或多个变体将成为赢家，我们将奖励所有流量或决定运行一个新的实验。与传统的 A/B 实验不同，Multi-Armed Bandit 实验是在进行实验的同时获得并利用结果，而不是等到有了结果再决定哪种变化是最好的。
应用于商户支付
与任何算法一样，将它应用于现实生活场景给了我们机会去了解结果是否可以改进。向旅游业中一家拥有多个 PSP 连接的大型商家提出这个想法，我们能够测试这个想法。
第一个实验侧重于授权率，这是支付行业内提供 PSP 性能反馈的一个指标。我们知道，在差异较小的地区，获得具有统计显著性的结果将具有挑战性，因此我们决定将重点放在授权率在 60%至 70%之间的国家和其他 PSP(未连接)上，他们表示能够获得 80%左右的授权率。现有的两个集成扩展为三个。开发了在每个 PSP 连接之间切换所需的逻辑以及跟踪性能的能力。
在我们测试该解决方案时，我们进行了不同的调整，以确保流量仅在结果具有统计学意义时才重新分配。在一个月的时间里，我们处理了超过 10 万笔交易，三个 PSP 的授权率分别为 74%、66%和 59%，其中本地 PSP 的性能最高。
尝试多臂强盗实验的其他场景
除了将交易路由到多个 PSP 之外，当然还有许多其他方式来使用多臂 Bandit 算法。在支付领域，将交易路由到不同的收单机构是次佳选择，但也是测试不同的欺诈保护工具。支付之外的选择是无穷无尽的，从测试你的网站或电子邮件中的内容。每当你想比较两个以上的变量，等到最后再做决定代价太大，多臂土匪实验肯定应该考虑。
感谢阅读；)，如果你喜欢它，请点击下面的掌声按钮，这对我意义重大，也有助于其他人了解这个故事。通过在推特或 Linkedin 上联系让我知道你的想法。或者关注我，阅读我关于数据科学、支付和产品管理的每周帖子。
机器人过程自动化中的智能过程挖掘
智能流程挖掘为什么以及如何改善 RPA 结果
Image source: Envato Elements
了解您的“现状”流程状态
许多组织正在将机器人流程自动化(RPA)作为其数字化转型工作的一个关键方面。RPA 为公司提供了一种“数字工人”战略，这种战略可以对使用最佳实践来规划和执行自动化项目的团队产生显著的可量化影响，这些最佳实践有助于清楚地识别自动化友好的流程，同时避免自动化设计不佳或不完善的流程。评估“原样”状态流程的能力有助于明确设定投资回报预期，确保敏捷的服务交付，或实现改善的客户旅程的好处。
RPA 为更好的服务、更高的过程精度和巨大的成本效益提供了巨大的希望——这无疑是以服务为重点的行业纷纷采用它的原因。
如果您的组织使用手动方法来理解端到端的流程执行，那么您正在进行大量的时间和金钱的前期投资，并且只能获得一小部分。负责执行操作和后台事务的软件会生成大量与流程相关的数据。能够提取这些数据并进行汇总和分析，为您提供了对“现状”流程的切实可行的见解。这一概念听起来简单易行，但对大多数组织来说却是一个巨大的挑战。这有什么难的？一个重要的原因是，当多个系统执行任何流程的不同方面时，几乎不可能使用旧的方法重新创建一个单一的、可用的流程视图。另一个原因是，用于生成关键指标的分析工具及时提供快照，而不是在时间背景下查看流程执行情况。
流程智能为 RPA 增值
而当前的大多数 RPA 计划侧重于在没有人工干预的情况下自动执行涉及结构化数据的大量相对简单的流程。在处理非结构化数据的过程中，以及在人类参与其中的更复杂的环境中，或者在可能需要采用一些认知推理的情况下，越来越多地考虑使用机器人。日益增加的复杂性和复杂性推高了部署成本，进而对 RPA ROI 合理性提出了挑战。在数字工人环境中，访问可操作流程智能的能力与涉及人类工人时一样重要。它允许您:
- 找出你可能没有意识到的冗余过程。
- 确定可以解放数字员工周期的机器人流程优化，从而让效率最高的数字员工变得更有效率。
- 发现低效的人机交互，反之亦然
- 按流程提供有关数字工作者财务影响的可量化数据。
- 从成本、准确性、效率和持续时间方面比较人工劳动和数字劳动。
流程智能平台为您的机器人操作模型实例化相应的风险和合规性框架，该框架定期监控和评估自动化流程性能:
- 为流程治理建立数据驱动的基础，并清晰地记录和自动化风险缓解步骤。
- 创建 RPA 卓越中心，该中心可以捕获流程、将流程导出到剔除的 RPA 流程中，或者根据多个数据标准对流程的感知价值评分进行排名。
- 通过识别流程异常和自动启动补救来扩大 RPA 范围。
- 对数字和人工流程及其交互执行更广泛的生命周期管理。
瞄准正确的 RPA 机会
许多不同的行业使用流程挖掘来自动建模和呈现流程流。类似于最初用于制造环境的数字双胞胎，它基于真实数据，在实际发生时揭示任何业务流程的内部工作方式。详细的过程数字孪生是智能过程挖掘的核心。直观的 BI 风格分析使发现、分析和自动监控接近实时的流程变得更加容易和快速，从而揭示自动化机遇和挑战的真正深度和广度。
以下是智能流程挖掘解决方案可以应对的四个常见 RPA 挑战——改善实施和大规模可持续性:
瞄准自动化潜力最大的流程，同时缩短实现价值的时间
- 提供跨多个业务应用程序的实际流程执行的单一全面的端到端视图，以发现主要的自动化机会以及潜在的副作用。
- 基于显示所有流程变化以及时间和成本影响的实际流程执行数据，轻松识别高价值的自动化候选项目。
- 基于交易数量，实现可量化、数据驱动的投资回报计算；流程步骤的数量；AHT/TAT 流程(持续时间)；每笔交易的成本。
- 消除了费力、昂贵且通常主观的手动流程评估。
智能流程挖掘提供 100%的流程可见性。找到你意想不到的高风险或高成本的模式。
瞄准高价值 RPA 机会
避免中断或执行不良流程的自动化
- 100%的“已执行”流程可见性允许团队识别、分析和纠正流程执行问题，如瓶颈、法规遵从性风险或 RPA 前的错误执行顺序
- 避免或修复会增加 RPA 开发成本并延长价值实现时间的中断流程
- 确定流程执行中可能会扩大 RPA 投资范围和价值的潜在变化
维护受影响流程的 RPA 后可见性
- 确保您的自动化投资在部署后按预期运行
- 监控自动化对上游和下游的影响，确保持续的协议合规性
- 混合模式场景中的自动化流程执行监控(机器人包含人工协助)保障了投资回报承诺
- 轻松指定在正确的时间向正确的人触发实时警报的详细场景或条件。
- 每天自动监控清晰、可量化的实施后成本影响，为未来的自动化计划提供数据支持
在企业规模执行 RPA
- 使用流程智能作为空中交通控制塔，通过近乎实时地监控企业范围的业务流程，建立合规性和风险治理框架
- 从几十个扩展到几百个，甚至几百个到几千个机器人需要大量的命令和控制，以确保自动化在它涉及的每个流程和业务系统中保持同步。
- 使用警报功能实时监控启用 bot 的流程执行情况，以生成自动化补救流程。
构建您自己的过程数字双胞胎
交互式流程模型也称为流程数字双胞胎，它不仅可以 100%地显示 RPA 机器人或 IT 系统执行的任何流程，还可以了解导致意外或不良行为的复杂动态。您可能已经有了大量的 IT 平台投资和各种部门系统，以确保获得关于每个支持事件或分配任务的每条有意义的信息。
智能流程挖掘通过自动发现流程，提供复杂的工具来分析流程行为，帮助您优化生产力、客户满意度和服务质量，从而释放更多价值。然后，近乎实时地监控流程执行，以保持最佳性能。
无论用于存储数据的系统数量有多少，流程智能平台都可以帮助您从端到端改善 RPA 流程的各个方面。将来自任意数量 IT 系统的流程数据转换为可操作的洞察，可以更快、更低成本地做出更准确的自动化决策。智能流程挖掘为做出数据驱动的决策提供了信心，这些决策对服务交付的任何方面都有可持续的影响。简而言之，利用智能流程挖掘技术，您可以确保您的流程在更短的时间内以更低的成本以最高的效率运行。
增加可见性——加速变化
评分者间协议
又名评分者之间的可靠性或一致性
在统计学中，评分者之间的可靠性、评分者之间的一致性或一致性是评分者之间的一致程度。它给出了评委给出的评分中同质性或一致性的程度。
这里涵盖的 Kappas 最适合于**【名义】**数据。这些方法忽略了数据中的自然排序(如果有的话)。如果您要使用这些指标，请确保您了解限制。
科恩的卡帕
这有两个部分:
- 计算观察到的一致
- 偶然计算一致
假设我们正在处理“是”和“否”的答案以及 2 名评定者。以下是收视率:
rater1 = ['yes', 'no', 'yes', 'yes', 'yes', 'yes', 'no', 'yes', 'yes']
rater2 = ['yes', 'no', 'no', 'yes', 'yes', 'yes', 'yes', 'yes', 'yes']
将这些评级转化为混乱矩阵:
Observed agreement = (6 + 1) / 10 = 0.7
Chance agreement = probability of randomly saying yes (P_yes) + probability of randomly saying no (P_no)
P_yes = (6 + 1) / 10 * (6 + 1) / 10 = 0.49
P_no = (1 + 1) / 10 * (1 + 1) / 10 = 0.04
Chance agreement = 0.49 + 0.04 = 0.53
因为观察一致大于偶然一致，我们会得到一个正的 Kappa。
kappa = 1 - (1 - 0.7) / (1 - 0.53) = 0.36
或者直接用sklearn的实现
**from** **sklearn.metrics** **import** cohen_kappa_scorecohen_kappa_score(rater1, rater2)
它返回 0.35714。
卡巴的解释
特殊情况
小于机会协议
rater1 = ['no', 'no', 'no', 'no', 'no', 'yes', 'no', 'no', 'no', 'no']
rater2 = ['yes', 'no', 'no', 'yes', 'yes', 'no', 'yes', 'yes', 'yes', 'yes']
cohen_kappa_score(rater1, rater2)
-0.2121
如果所有的评级都是相同和相反的
这种情况可靠地产生 0 的kappa
rater1 = ['yes'] * 10
rater2 = ['no'] * 10
cohen_kappa_score(rater1, rater2)
0.0
随机评级
对于随机评分，Kappa遵循平均值约为零的正态分布。
随着评级数量的增加，Kappa 值在分布中的可变性更小。
10 random ratings for each rater (random sample of 1,000 inter-rater Kappa calculations)
100 random ratings for each rater (random sample of 1,000 inter-rater Kappa calculations)
您可以在此找到更多详情
请注意，Cohen 的 Kappa 仅适用于对完全相同的项目进行评分的 2 名评分者。
弗莱斯
将 Cohen 的 Kappa 扩展到 2 名以上的评定者。
解释
它可以被解释为表达评价人之间观察到的一致程度超过了所有评价人完全随机进行评价时的预期程度。
评分者可以对不同的项目进行评分，而对于 Cohen，他们需要对完全相同的项目进行评分
Fleiss’kappa 特别允许，尽管有固定数量的评定者(例如，三个)，不同的项目可以由不同的个人进行评定
例如，假设我们有 10 名评定者，每人对 5 个项目进行“是”或“否”评定:
例如，假设我们有 10 名评定者，每人对 5 个项目进行“是”或“否”评定:
例如第一行(P_1):
P_1 = (10 ** 2 + 0 ** 2 - 10) / (10 * 9) = 1
第一列(p_1):
p_1 = 34 / (5 * 10) = 0.68
如果不清楚的话，在这里看一下这个例子。
现在你可以计算 Kappa:
P_bar = (1 / 5) * (1 + 0.64 + 0.8 + 1 + 0.53) = 0.794
P_bar_e = 0.68 ** 2 + 0.32 ** 2 = 0.5648
在这一点上，我们已经得到了我们需要的一切，而kappa的计算就像我们计算科恩的:
kappa = (0.794 - 0.5648) / (1 - 0.5648) = 0.53
你可以在这里找到这篇文章附带的 Jupyter 笔记本。
参考文献
- 【https://www.wikiwand.com/en/Inter-rater_reliability
- https://www.wikiwand.com/en/Fleiss%27_kappa
使用 Jupyter 笔记本的交互式数据科学
在我的视频中，你已经看到我在屏幕上实时运行 Python 代码并显示结果。今天，我想和你分享我是如何做到这一点的，并告诉你如何利用它！
我在屏幕上实时运行 python 代码的方式是使用一个名为 Jupyter 的 Python 包。Jupyter 构建于 IPython 项目之上，允许在浏览器中运行交互式 Python。但远不止如此。从 bash 命令到特殊的“魔法”和插件，Jupyter 极大地增强了 Python 编码体验。
如果你已经在使用 Jupyter，我希望我能改进你的工作流程，并向你展示一些新的技巧。如果您还没有使用 Jupyter，那么让我们开始吧。
安装和启动
安装 Jupyter 最简单的方法是运行pip install jupyter，尽管如果您使用打包的 python 发行版，比如 Anaconda，您可能已经安装了它。确保首先激活您的 Python 环境。让我们开始吧。
在本地运行 Jupyter 时，您将通过浏览器连接到本地运行的 web 服务器，通常是在端口 8888 上。在你的工作目录中运行jupyter notebook来启动你的笔记本。通常 Jupyter 启动后会自动打开，但如果没有，请将你的浏览器指向localhost:8888。
如果您还没有想要打开的笔记本，您可以通过单击“新建”并选择 Python 2 或 3 来创建一个，具体取决于您环境中运行的 Python 版本。Jupyter 非常灵活，实际上可以处理许多语言和文件类型，尽管我们现在只坚持使用 Python。
在 Jupyter 笔记本中运行代码
一旦你有一个新的笔记本在运行，你可以在空的单元格中写一些 python 代码，然后按 ctrl+enter 来运行它。我们可以在这里运行所有典型的 Python 代码，就像您可能用 Python 脚本编写一样。不同的是，我们可以运行它，并立即看到结果！
注意当我们用 ctrl+enter 运行一个单元格时会发生什么。当单元正在运行或排队等待运行时，单元左侧的括号中会显示一个星号，然后在运行完成后会显示一个数字，代表单元在给定会话中的运行顺序，从“1”开始。
代码单元格最后一行的结果将作为该单元格的输出打印出来，但前提是该值没有存储到变量中。例如，如果我导入 tensorflow，然后用一个字符串连接它，输出如下所示，即使我没有使用 print 命令。
当然，我也可以使用 print()。这对于修补和观察事物的行为非常有用。
Shift-Tab
Jupyter 笔记本的另一个奇妙的特性是能够通过按shift-tab显示你正在调用的函数的文档字符串。这允许您使用正确的参数调用函数，而不需要每次都查阅完整的文档。
这个特性也可以和你自己的本地自定义函数一起工作，所以如果你写了好的 docstrings，你会得到回报的！
输出
当您有大量输出时，您可以通过单击输出的左侧面板来减少它占用的空间，这将使它变成一个滚动窗口。如果双击，输出将完全折叠。
更多细胞！
一个细胞是有用的，但实际上我们希望有许多细胞。要添加单元格，请单击工具栏上的“加号”图标。还有一些单元执行命令可以创建新的单元。
如果您按下shift+enter，它将运行当前单元格，然后高亮显示下一个单元格。如果没有新单元，则创建一个新单元。另一方面，如果您想在给定的单元格之后立即创建一个新的单元格，您可以使用alt-enter来执行该单元格，然后在它之后直接插入一个新的单元格。
有人说降价了吗？
也许到目前为止，我遗漏的最大特性是降价支持。我对 Jupyter 笔记本的第一印象是它能够提供一种很好的方式来编写代码和描述我正在编写的代码。markdown 丰富的语义允许研究人员和教育工作者简单明了地交流思想和观点。
也许最重要的是，它允许过去的你告诉未来的你一个给定的代码单元应该做什么，以一种比使用注释块更有表现力的方式！
朱庇特魔术
有时我只想快速检查一下一个培训或评估周期需要多长时间。一个简单的方法来计时你的代码，用%%time 开始一个单元，一旦这个单元完成执行，它将打印出运行这个单元花了多长时间。这不是精确的原子计时，但这是一个很好的方式，可以用最小的努力获得一些可靠的第一印象。
如果要在笔记本中运行命令行命令，最简单的方法就是在命令前面加一个感叹号。这对于一次性命令非常有用。
如果您想运行一组命令，用“%%bash”开始一个单元，使整个单元被解释为一个 bash 脚本。
这个的一个很大的用途是启动张量板。通常，运行 TensorBoard 可能需要启动一个新的终端窗口，并在命令行上运行它，如果您想运行一段时间，我们通常会这么做。但是，如果你只是想旋转它，看一眼，然后关闭它，把它放在 Jupyter 笔记本电池里也不是一个坏主意。
此外，您将永远不会忘记运行它，因为它嵌入到您的笔记本电脑单元的工作流程中！请注意，它将占用您的笔记本。因此，在 Tensorboard 运行时，您将无法运行任何其他内容。要停止它，点击中断内核，星号会消失，你会得到控制流。
这就是我最喜欢的 Jupyter 特性和功能。这当然不是对 Jupyter 特性的全面讨论。我刚刚在这里介绍了一些我最喜欢和最常用的。还有很多很多等着你去探索。
感谢阅读这一集的云人工智能冒险。如果你喜欢这个系列，请为这篇文章鼓掌让我知道。如果你想要更多的机器学习动作，一定要关注媒体上的我或订阅 YouTube 频道以观看未来的剧集。更多剧集即将推出！
附:如果你还在读:这篇文章的 gif 怎么样？他们有帮助吗？分散注意力？俏皮？迷惑？让我知道！
用 D3.js 实现交互式数据可视化
开启数据驱动的可视化之路
本文内容由 昆西·史密斯 供稿，昆西·史密斯是 跳板 在线培训公司营销团队的一员，该公司致力于弥合世界各领域的技能差距。他们开设以行业为重点、由导师指导的课程，如数据科学训练营和网络安全职业跟踪。
Credit: https://d3js.org/
交互式可视化可以给平淡乏味的数据集增添令人印象深刻的魅力。交互数据的主要特征在于它本身作为一个应用程序使用。它允许用户选择特定的数据点，以他们选择的方式将故事可视化。实现这一点的最强大的方法之一是通过 JavaScript ，或者更具体地说，D3.js 框架。
由 Mike Bostock 开发的 D3 (data-driven documents)是一个开源的 JavaScript 库，它利用 SVG、HTML 和 CSS 来创建强大的数据可视化表示，从而赋予数据以生命。让我们看一个由 D3.js 支持的有趣的交互式可视化的例子！
Tech Company IPOs vs. Company Value
在上述示例中，将鼠标悬停在特定数据点上会弹出一个弹出窗口，显示关于该特定数据的更多信息。图表本身可以进一步动画化，创建一个令人兴奋的用户数据视图。请看它在 这里的 。
在 2400 次科技、互联网和电信的首次公开募股之后发生了什么
archive.nytimes.com](https://archive.nytimes.com/www.nytimes.com/interactive/2012/05/17/business/dealbook/how-the-facebook-offering-compares.html)
D3 . js 的主要特性
- 它使用预先存在的约定: D3.js 使用 web 标准，比如前面提到的 SVG、HTML 和 CSS。就其本身而言，这一特殊特征可能并不显著。然而，这允许跨平台的脚本的容易实现，而不需要除了浏览器之外的其他技术或插件。它还允许数据可视化与其他脚本和 JS 框架统一应用，如 Angular.js、Ember.js 或 React.js。换句话说，它可以顺利地放入您的网站中，而不会干扰其余的代码。最好的部分:D3 是轻量级的。它适用于任何网络标准，因此速度很快，不管你的数据集有多大。
- 数据驱动: D3 完全由数据驱动，通过输入静态数据或从远程服务器获取数据。这可以通过多种格式实现，从数组和对象到 CSV、JSON 和 XML 等等。通过这个专门的工具，可以很容易地创建不同类型的图表。D3 大量使用数据驱动元素也增强了您的数据，允许动态生成不同的元素和图表样式，无论是表格、图形还是任何其他类型的元素分组。
- **它是动态的:**凭借其灵活性，D3 可以成为一个非常强大的工具，因为它为几乎所有的功能提供了最大的动态属性。然后，您输入到脚本中的数据可以很容易地形成特定数据集可视化所需的样式和属性类型。
点击这个咖啡风味转盘上的任何地方，它就会以一种流畅、动态的动作缩放。查看 这里 。
咖啡味道的形象化。
www.jasondavies.com](https://www.jasondavies.com/coffee-wheel/)
如果您真的想深入了解技术细节，这是一个使用[d3.layout.partition](http://github.com/mbostock/d3/wiki/Partition-Layout)布局从分层数据生成可缩放旭日树的例子。旭日树是一种特殊的放射状空间填充可视化，类似于冰柱树。
总而言之，D3 允许用户创建基本上任何类型的可视化，纯粹基于数据，而不是来自个人对数据的理解。无论是表格还是饼图、图形还是条形图，D3 都通过简化数据可视化过程来避免人为错误，同时为用户提供了进行调整和控制可视化功能的所有机会。
不仅如此，D3 通过像**duration()**、**delay()**和**ease()**这样的功能为交互和动画提供了足够的空间，这些功能允许用户制作数据动画，就像在你的网站上添加视频一样——除了在 D3 的情况下，它被简化并直接在你的网站上实现。这些动画也很快，对用户交互反应灵敏，使它们更有吸引力。
如何入门？
D3.js 实现起来非常简单，只要你已经掌握了一些 JavaScript 的基础知识。这里有一个简化的分步指南，帮助您开始交互式数据之旅。
步骤 1:设置
D3 的第一步是建立 D3 库，它作为 D3 代码的信息和指令的存储库。它构成了数据可视化的基础，所以把这一步做好很重要。
有两种方法可以做到这一点:
- **将 D3 库引入您的项目文件夹:**由于 D3 是开源的，源代码可以在 D3 网站上下载。你要做的就是解压下载的文件夹，寻找
**d3.min.js**，直接复制到你项目的根文件夹。然后，使用**<script src =…>**将**d3.min.js**文件包含在 HTML 页面中。有了这个，你的 HTML 网页现在可以访问 D3 库中的代码和 DOM 元素。 - 介绍来自内容交付网络(CDN)的 D3 库: CDN 是一个由不同服务器组成的网络，这些服务器托管根据用户的地理位置交付给他们的文件。使用 CDN，您甚至不需要源代码(就像使用第一种方法一样)。只需使用
**<script src=…>**包含 CDN URL
第二步:DOM 元素
有了开源代码库，就可以根据样式和操作其他 DOM 元素来设置网页本身了。使用**d3.select** (css-selector)或**d3.selectAll** (css-selector)获取 DOM 元素的引用是很重要的。之后，应用众所周知的 HTML 和 CSS 约定，并且可以相应地实现这些元素。
DOM 元素也可以由一系列方法操作，比如**text(“content”)**或**remove()**。这些与现有的约定非常相似，因此从编码的角度来看很容易使用。您可以使用不同的脚本以类似的方式添加动画和其他功能，这些脚本可以在官方网站的 API 参考中找到。
开发这段代码的关键点在于“链语法”，如果您使用过 JQuery，可能会对它很熟悉。D3 的链接技术是通过使用句点将方法放在一起实现的。这样，第一个方法的输出作为输入传递给下一个方法，从而简化了代码。
Standard Candlestick Chart for Stock Prices
凭借其数据驱动的焦点，D3 可以轻松创建烛台图，如this。
绘制股票数据的一个微妙之处是市场只在工作日开放:如果你…
beta.observablehq.com](https://beta.observablehq.com/@mbostock/d3-candlestick-chart)
第三步:加载您的数据
下一步是加载数据集并将它们绑定到 DOM 元素。D3 可以处理不同类型的文件，本地的和外部的。数据的上传类似于 HTML 和 CSS 的传统数据加载，通过**.csv**文件的**d3.csv()**、**.json**文件的**d3.json()**等方法。
第四步:可视化数据
数据成功加载到 D3 后，用户可以创建数据可视化最重要的部分:可视化本身。
这可以以 SVG 的形式出现，它允许您的图表显示不同的形状，从线条到圆形到椭圆形，并允许您完全控制以实现数据的理想可视化。本质上，SVG 值的操作与 DOM 元素的操作非常相似。
通过采取这些步骤，用户可以轻松地创建图像和形状，帮助构建完整的图表和图形。然而，这实际上并没有形成真正的数据可视化。相反，需要通过 D3 对几何图形和样式进行操作，以获得想要的结果。这也包括从图表的刻度到它的轴到图表的动画。
然而，一旦掌握了 D3.js 技术，从移动饼图到响应条形图，制作任何东西都很容易。
US Trade Deficit
上图显示了一段时间以来美国的贸易逆差。第一次打开时，图表会根据时间线从 2001 年移动到 2013 年。单击时间线的任何部分都会导致图表相应移动，显示特定时间段的贸易逆差。仔细看看这里的。
美国在贸易逆差下运作，这意味着美国从国外购买的商品多于其销售的商品。这个…
www.brightpointinc.com](http://www.brightpointinc.com/united-states-trade-deficit/)
简单地说
总的来说，D3.js 是一个极其强大和通用的工具。
它包含大量的功能，让数据科学家(有经验的&新)完全控制图表或图形的外观和感觉，使其成为任何希望掌握数据可视化的人最有影响力的工具之一。*
查看昆西·史密斯在全球最大的职业社区 LinkedIn 上的个人资料。昆西有 9 份工作列在他们的…
www.linkedin.com](https://www.linkedin.com/in/qlsmith/)
如果你对我的文章或数据科学有任何反馈、评论或有趣的见解要分享，请随时通过我的 LinkedIn 社交媒体频道联系我。
[## Dipanjan Sarkar -数据科学家-英特尔公司| LinkedIn
查看 Dipanjan Sarkar 在世界最大的职业社区 LinkedIn 上的个人资料。Dipanjan 有 6 份工作列在…
www.linkedin.com](https://www.linkedin.com/in/dipanzan/)**
交互式机器学习:让 Python 再次“活跃”
当使用交互式小工具时，笔记本变得活跃起来。用户可以可视化和控制数据和模型的变化。学习变成了一种身临其境的、有趣的体验。
你已经用 Jupyter 编写了代码，Jupyter 是一个无处不在的笔记本平台，用于用几乎所有主流编程语言编写和测试很酷的想法。你喜欢它，你经常使用它。
但是你想要更多的控制，你想要通过简单的点击鼠标来改变变量，而不是通过编写 for 循环。你该怎么办？您可以使用 IPython 小部件。请继续阅读…
什么是 Python Widget？
Project Jupyter 诞生于 2014 年的 IPython 项目，并迅速发展到支持跨所有主要编程语言的交互式数据科学和科学计算。毫无疑问，它对数据科学家如何快速测试和原型化他/她的想法并向同行和开源社区展示工作产生了最大程度的影响。
然而，当用户可以交互地控制模型的参数并(几乎)实时地看到效果时，学习和实验数据就变得真正身临其境了。Jupyter 中大多数常见的渲染都是静态的。不过有一个很大的努力，引入了名为 ipywidgets 的元素，在 Jupyter 笔记本上渲染出有趣的交互控件。
小部件是多事件的 python 对象，在浏览器中有一个表示，通常是像滑块、文本框等控件。，通过前端(HTML/Javascript)呈现通道。
在之前的一篇文章中，我使用基本的小部件控件演示了一个简单的曲线拟合练习。请阅读那篇文章，了解关于安装这个小部件包的说明。在本文中，这在交互式机器学习技术领域得到了进一步的扩展。
交互式线性回归
我们使用交互控制元素演示单变量的简单线性回归。注意，该思想可以容易地扩展到复杂的多变量、非线性、基于核的回归。然而，为了简化可视化，我们在这个演示中坚持使用单变量的情况。
我的 Github 库 中有锅炉板块代码 。我们分两个阶段展示交互性。首先，我们将数据生成过程显示为输入变量和相关噪声统计属性的函数。这是一个视频，展示了用户使用简单的滑动条控件动态生成和绘制非线性函数的过程。
这里，生成函数(又名“地面真相”)是四次多项式，噪声来自高斯分布。接下来，我们使用 scikit-learn 的 多项式特征生成 和 流水线方法 编写一个线性回归函数。此处 给出了这样一个机器学习流水线过程的详细 **分步指南。**在这里，我们将整个功能封装在另一个交互式控件中，以便能够动态地改变线性模型的各种参数。
我们为以下超参数引入交互控制。
- 模型复杂性(多项式的次数)
- 规则化类型— 套索或山脊
- 测试集的大小(测试中使用的总样本数据的一部分)
以下视频显示了用户与线性回归模型的交互。请注意，测试和训练分数也是如何随着模型复杂性的变化而动态更新，以显示过度拟合或欠拟合的趋势。可以返回到数据生成控制，增加或减少噪声幅度，以查看其对拟合质量和偏差/方差权衡的影响。
摘要
我们简要介绍了一个 Jupyter 笔记本，它具有嵌入式交互控制对象，允许用户/程序员动态地处理数据集的生成和建模。当前演示允许用户引入噪声，改变模型复杂性，并检查正则化的影响，所有这些都在运行中，并立即看到最终的模型和预测。但整个想法在笔记本中以一步一步的方式进行了解释，这应该有助于感兴趣的读者试验这些小部件，并提出生动、交互式的机器学习或统计建模项目。
如果您有任何问题或想法要分享，请通过tirthajyoti【AT】Gmail[DOT]com联系作者。你可以查看作者的 GitHub 资源库 中其他有趣的 Python、R 或 MATLAB 代码片段和机器学习资源。此外，如果你像我一样对机器学习/数据科学/半导体充满热情，请随时在 LinkedIn 上添加我或在 Twitter 上关注我。
交互式(自然)语言学习
设置和模型/算法核心
设置
游戏中的两个玩家:人类和电脑。
游戏:通过固定数量的关卡进行。
对于人机之间的每一个层次:在 Y 中，人类和计算机都有一个起始状态 s ，但在 Y 中，只有人类知道目标状态 t 。
- 人类给计算机说话 x
- 计算机在 Z 中构造动作 z 的排序列表，然后对于给定当前状态 s 的 z 中的每个子，它计算排序后的后继状态 yi 并返回给人类。
- 然后，人类根据他/她的发言 x 选择后继状态易(如果 i ==1，则计算机是正确的)
- 状态更新为 s = yi
- 如果 s==t，则该级别结束
玩家进入下一关
模型和算法核心
语义分析
逻辑形式(动作)上的对数线性模型 z 给定话语 x
其中φ(x，z) ∈ R^d 是特征向量，θ ∈ R^d 是要学习的参数向量。
特征
n-grams(包括跳格)在逻辑形式方面与树-gram 连接
- 话语方:(’ stack red on orange ‘)、一元语法(’ stack ‘、∑、∑)、二元语法(’ red ‘、’ on ‘、∑)、三元语法(’ red ‘、’ on ‘、’ orange ‘)和跳过三元语法(’ stack ‘、∑、’ on ')。
- 逻辑形式方面:特性对应于逻辑形式中的谓词及其参数。
- 特性对应于逻辑形式中的谓词及其参数。
生成/解析
在生成逻辑形式中使用波束搜索:对于每个大小 n = 1，.。。，8，通过根据语法规则组合较小大小的逻辑形式，构造一组大小为 n 的逻辑形式(正好有 n 个谓词)。
对于每个 n，保留 100 个逻辑形式 z 具有最高得分θ^Tφ(x，z)。
但是， Z 不保证包含获得观察状态 y 的逻辑形式。所以在训练中使用一个课程，这样在初级阶段只需要简单的动作，给人类一个机会，在移动到更大的复合动作之前，先教计算机一些基本的术语，比如颜色
学问
使用 AdaGrad 和以下损失函数进行单一梯度更新:
建模语用学
通过对上述语义解析模型的初步体验，他们发现它能够很好地学习，但缺乏人类学习者所具有的推理能力。
想法
把语言游戏当成说话者(人)和听话者(计算机)之间的合作游戏。
形式上，让 S(x | z)是说话者的策略，L(z | x)是听话者的策略。说话者考虑字面语义分析模型 pθ (z | x)以及话语上的先验 p(x ),而听者考虑说话者 S(x | z)和先验 p(z ):
然后，计算机将使用 L(z | x)而不是 pθ对候选人进行排名
务实的倾听者将说话者塑造成一个合作的代理人，他以一种的方式最大限度地成功交际。
在线学习
使用了两种近似技巧:
- 近似所有话语 x 上的难以处理的和，我们仅使用看到的例子来计算归一化常数
- 为了避免使用每个新示例存储的当前参数再次解析所有以前的示例
关于在线学习算法的详细解释，请参考论文中的语用在线学习。
相关研究
- 透过互动学习让程式语言自然化。(2017).来自同一组
- 项目链接在这里。
- 一个视频链接
- 本文从一种核心编程语言开始，允许用户通过定义替代的、更自然的语法和越来越复杂的概念来逐渐“适应”核心语言。
- 高迪尔，乔恩和伊戈尔·莫达奇。"情境和目标驱动的语言学习模式."更正 abs/1610.03585 (2016 年):n. pag。
- 本文提出了一种通用的情境语言学习范式，旨在产生能够与人类有效合作的健壮的语言主体。这种对话模式是建立在语言理解的功利主义定义之上的。功利主义的定义是由最近强化学习方法的成功所激发的。在强化学习环境中，代理最大化现实世界任务的成功度量，而不需要直接监督语言行为。
- 李，纪伟等，《在对话互动中学习》更正 abs/1612.04936 (2016 年):n. pag。代码
- 本文通过设计一个模拟器和一组电影领域的综合任务来探索(一般)学习，这些任务允许学习者和教师之间进行互动。
- 他们认为一个好的对话代理应该有能力通过回答问题和提问与用户互动，重要的是从两种互动中学习。
参考
- 王，司大一等:“在互动中学习语言游戏”更正 abs/1606.02447 (2016): n. pag。
- shrdurn web 演示、日历应用演示
- shrd 返回代码，数据，并在 CodaLab 上进行实验，shrd 返回客户端代码
- 王，四大一等，“通过交互学习自然化程序设计语言”(2017).
- 高捷、乔恩和伊戈尔·莫尔达奇。"情境和目标驱动的语言学习模式."更正 abs/1610.03585 (2016 年):n. pag。
- 李，纪伟等.“在对话互动中学习”更正 abs/1612.04936 (2016 年):n. pag。
使用 Tableau 的交互式简历
Static version of my Tableau Resume
对于 2018 年春季学期，我参加了由教授 Rahul Basole 讲授的 MGT CS 8803 数据可视化原理和应用课程，在那里我了解了#datavisualization (#dataviz)的方方面面。
几个课程目标是:-
- 了解人类感知和认知能力，以设计有效的数据可视化。
- 根据最终用户的目标和目的，评论不同的可视化技术
- 了解如何使用商业和开源软件工具设计和实现数据可视化。
作为作业的一部分，我们被要求将专业简历转换成数据可视化。因此，在这里我开始思考如何用素描来完成它，这对于其他人来说可能更容易，但对我来说要复杂得多。有时，灵活性会成为障碍。
Tableau 作为一种数据可视化工具，在演示文稿、仪表盘、统计(定量和定性分析)中经常使用。但是在我看来，把它用于交互式简历是一种严重利用不足的应用。做完这个练习后，如果有人问我你更喜欢哪份简历，我会左右为难。不是因为我做了这两项，而是因为可视化有效地将观点传达给了用户(在这种情况下是读者)。
数据
这种可视化的数据既不容易在网上获得，简历也不能以其原始形式使用。Tableau 足够健壮，可以接受来自各种数据源(JSON、PDF、MySQL、Excel 等)的数据，但它需要大量的数据管理才能使其可用。对于这个任务，我专注于使用数据来揭示我的技能和项目贡献。虽然我的 LinkedIn 和 Github 个人资料上有这些内容，但 Tableau 不一定能马上导入和使用这些内容(至少我还没有找到一种方法来导入网站链接并即时使用这些信息)。
形象化
1.项目捐款
目的是更好地可视化 Github 的贡献。我使用了简单的文本表格，但是以 Github 的方式。不同于通常在一个轴上分配时间，在另一个轴上分配数量特征，我在两个轴上都使用了时间(日期)。工作日在行，季度为列。Github 将其进一步细化到每月，给出全年的概况。由于空间的限制，我不得不满足于四分之一。人们可以看到我对 Github 的贡献并与 Tableau 进行比较。
2。技能时间表
我希望它是一个垂直的时间线(像传统的简历)，但 Tableau 不允许垂直的时间线(到目前为止)。我将技能时间线显示为多年来技能水平总和的趋势。颜色显示技能的细节。该视图根据技能进行筛选，保留 10 个成员中的 9 个。组织和工作等附加信息已被编码为标签。
Tableau 仪表板
Tableau 上的仪表板帮助用户将不同的工作表缝合在一起。它有助于统一所有数据，并利用链接特性来触发跨多个工作表的交互。此外，Tableau Public 允许用户在他们的平台上发布他们的 Tableau 仪表盘，以便轻松分享他们的工作。这是一个非常方便的工具，可以让你的可视化快速启动和运行。
用 Jupyter 窗口小部件实现决策树的交互式可视化
Photo by Aaron Burden on Unsplash
决策树是广泛用于分类和回归任务的监督模型。在本文中，我们将讨论决策树分类器，以及如何动态地可视化它们。这些分类器在训练数据上建立一系列简单的 if/else 规则，通过它们来预测目标值。决策树很容易解释，因为它们的结构和我们可视化建模树的能力。
使用 sk learnexport _ graphviz函数，我们可以在 Jupyter 笔记本中显示该树。在这个演示中，我们将使用 sklearn 葡萄酒数据集。
from sklearn.tree import DecisionTreeClassifier, export_graphviz
from sklearn import tree
from sklearn.datasets import load_wine
from IPython.display import SVG
from graphviz import Source
from IPython.display import display# load dataset
data = load_wine()
# feature matrix
X = data.data
# target vector
y = data.target
# class labels
labels = data.feature_names
# print dataset description
print(data.DESCR)estimator = DecisionTreeClassifier()
estimator.fit(X, y)
graph = Source(tree.export_graphviz(estimator, out_file=None
, feature_names=labels, class_names=['0', '1', '2']
, filled = True))display(SVG(graph.pipe(format='svg')))
Decision Tree with default parameters
在树形图中，每个节点都包含分割数据的条件(if/else 规则)，以及该节点的一系列其他指标。Gini 指的是 Gini 杂质，节点杂质的度量，即节点内样本的同质程度。当一个节点的所有样本都属于同一个类时，我们说这个节点是纯的。在这种情况下，没有必要进一步分裂，这个节点被称为叶。Samples 是节点中实例的数量，而 value 数组显示每个类中这些实例的分布。在底部，我们可以看到节点的多数类。当 export_graphviz 的 filled 选项设置为 True 时，每个节点根据多数类进行着色。
虽然很容易理解，但决策树往往会通过构建复杂的模型来过度拟合数据。过度拟合的模型很可能不能很好地概括“看不见的”数据。防止过拟合的两种主要方法是预修剪和后修剪。预修剪是指在创建树之前限制树的深度，而后修剪是指在构建树之后移除无信息的节点。
Sklearn 学习决策树分类器只实现预剪枝。预修剪可以通过几个参数来控制，例如树的最大深度、节点保持分裂所需的最小样本数以及叶子所需的最小实例数。下面，我们在相同的数据上绘制一个决策树，这次设置 max_depth = 3。
Decision Tree with max_depth = 3
这个模型没有我们最初训练和绘制的模型那么深入，因此也没有那么复杂。
除了预修剪参数，决策树还有一系列其他参数，我们在构建分类模型时会尝试优化这些参数。我们通常通过查看准确性度量来评估这些参数的效果。为了掌握参数的变化如何影响树的结构，我们可以再次在每个阶段可视化树。我们可以利用Jupyter Widgets(ipywidgets)来构建我们的树的交互式绘图，而不是每次做出改变时都绘制一个树。
Jupyter 小部件是交互式元素，允许我们在笔记本中呈现控件。安装 ipywidgets 有两个选项，通过 pip 和 conda。
和皮普一起
pip install ipywidgets
jupyter nbextension enable --py widgetsnbextension
与康达
conda install -c conda-forge ipywidgets
对于这个应用程序，我们将使用交互功能。首先，我们定义一个训练和绘制决策树的函数。然后，我们将这个函数以及每个感兴趣的参数的一组值传递给交互函数。后者返回一个我们用 display 显示的小部件实例。
from sklearn.tree import DecisionTreeClassifier, export_graphviz
from sklearn import tree
from sklearn.datasets import load_wine
from IPython.display import SVG
from graphviz import Source
from IPython.display import display
from ipywidgets import interactive# load dataset
data = load_wine()# feature matrix
X = data.data# target vector
y = data.target# class labels
labels = data.feature_names
def plot_tree(crit, split, depth, min_split, min_leaf=0.2):estimator = DecisionTreeClassifier(random_state = 0
, criterion = crit
, splitter = split
, max_depth = depth
, min_samples_split=min_split
, min_samples_leaf=min_leaf)
estimator.fit(X, y)graph = Source(tree.export_graphviz(estimator
, out_file=None
, feature_names=labels
, class_names=['0', '1', '2']
, filled = True))
display(SVG(graph.pipe(format='svg')))return estimatorinter=interactive(plot_tree
, crit = ["gini", "entropy"]
, split = ["best", "random"]
, depth=[1,2,3,4]
, min_split=(0.1,1)
, min_leaf=(0.1,0.5))display(inter)
Initial view of widget
在本例中，我们公开了以下参数:
- 标准:节点处分割质量的度量
- 拆分器:每个节点的拆分策略
- max_depth:树的最大深度
- min_samples_split:节点中所需的最小实例数
- min_samples_leaf:一个叶节点所需的最小实例数
最后两个参数可以设置为整数或浮点数。浮动被解释为实例总数的百分比。关于参数的更多细节，你可以阅读 sklearn 类文档。
Widget demonstration
这个交互式小部件允许我们修改树参数，并动态地查看图形变化。通过这种相互作用，我们能够通过揭示每一步产生的变化来掌握每个参数的影响。
虽然这不是模型性能评估或参数调整的工具，但它有几个好处。通过检查深度、节点数量和叶子的纯度，它可以作为评估模型复杂性的一种手段。另一方面，它可以给我们关于数据的有用见解，因为我们可以看到树使用了多少和哪些特性。此外，我们也许能够发现清楚地将我们的样品区分到不同类别的条件。
总之，我发现这种交互式可视化是一种有趣的工具，可以更深入地理解构建决策树的抽象过程，脱离特定的数据集，这将为我们下次为我们的一个项目构建决策树提供一个良好的开端！
Jupyter 笔记本中的交互式可视化
这篇文章并不详尽地介绍了如何直接从 Jupyter 笔记本上创建交互式内容。内容主要是指数据可视化工件，但我们将看到我们可以轻松地扩展到通常的图表之外，为各种场景提供有价值的交互位，从数据探索到动画。
我将从简单介绍数据可视化开始，并更好地定义本文中的交互性的范围和含义。
然后我将提供一个相关工具的快速概述(Plotly 和 ipywidgets)以及一些关于 Jupyter 生态系统的一般性建议。
最后，我将展示一些具体的例子，大部分是指我的个人项目，以及我依靠这些互动片段获得的改进。这最后一部分正是为了在 Jupyter 这样一个令人印象深刻的框架上展示这些工具的能力。这一切都是为了推动你尝试自己的项目，并传播这个词。
介绍
数据可视化是成为一名优秀的数据科学家所需的核心技能之一——或者任何其他与数据相关的角色。它既能让您(或团队中的其他人)更好地理解数据集的本质，又能向外部受众(技术和非技术)传达正确的信息。
当搜索“数据可视化”时，最常见的建议编程库之一是 D3.js，但是一些断言，当你搜索非常个性化/定制化的方法和随之而来的结果时，它是值得深入这样的工具的。如果您的目标是更直接和“标准”的可视化，那么您选择的语言中已经可用的包可能是更好的方法。
对于 Python 生态系统来说，不可避免地从 Matplotlib 的基础块开始，然后可能扩展到更高级别的替代(例如 Seaborn 、 Bokeh )。一个额外的越来越有保障的选择——特别是对于数据科学数字——是使用 Jupyter 笔记本。我相信 Jupyter 崛起背后的主要力量和原因之一是它如何将不同的媒体打包在一个简单的解决方案中:你编码，你写作，你可视化。它不仅能让你在工作时变得流畅愉快，还能极大地简化这类工作的分享，无论是出于教育还是协作目的。
就个人而言，结合 Jupyter 的支持，我发现 Matplotlib+Seaborn 组合非常适合我的可视化需求，甚至比 Pandas 的额外嵌入式绘图功能更好。当需要动画功能时，Matplotlib 1.1 版中的简单动画框架在可用性和结果之间提供了很好的折衷。
但在某一点上，人们觉得需要更多的东西。并不是完全转向新工具，只是在必要时依赖它们。在这方面，我个人认为有两种类型的互动:
- 互动图:关于当前探索的特定点或区域的实时信息，加上高亮/隐藏特定内容的可能性。
- 用于内容交互的窗口小部件:这超越了图形情节，扩展到其他类型的媒体和内容，通常需要一个或多个复杂的 UI 元素来收集外部输入。
对于前者，我现在在使用plottly中找到了极大的满足感。对于后者，我专门搜索了可以轻松嵌入 Jupyter 的解决方案，这样我几乎可以将我的任何笔记本变成交互式仪表盘。为此，我们将研究 ipywidgets。
工具
在讨论之前提到的工具的细节之前，这里有一些我认为值得分享的关于 Python 和 Jupyter 生态系统的个人建议。
第一个建议:使用 Anaconda (一个 Python 发行版等等)。
第二个建议:使用虚拟环境(相当于 Anaconda)。是关于管理多个独立的 Python 环境。
第三个建议:参见 nb_conda_kernels 从你的 Jupyter 笔记本管理多个环境/内核。
第四条建议:用 Jupyter 扩展定制你的 Jupyter 的****
Plotly
Plotly 让创建和分享互动情节变得非常容易。这个库的一个伟大之处在于它为你的图形提供了无缝的网络托管能力。通常情况下，你可以获得一个免费账户，但代价是你托管的一切都将是公开的。但与一些人所说的相反，如果需要的话你绝对可以完全离线使用 Plotly，直接在笔记本上渲染互动情节，并能够将它们导出为(仍然互动的)HTML 文件。
如果这还不够的话，还有两个特征让这个包更有吸引力:plot_mpl和袖扣。
前一种方法执行从纯 matplotlib 图形到交互式 Plotly 图形的直接转换(这种操作还不完美，但正在迅速变得越来越好)。
相反，袖扣是熊猫数据框和图案之间的自动绑定。这种绑定再次保证，只需一次调用，您就可以获得 dataframe 内容的高质量数据可视化，具有自动解析和格式化日期时间值以及推断的色调和列标签管理等优点。
开始使用 Plotly(在一般情况下)就像跑步一样简单
pip install plotly
pip install cufflinks
然后，您必须为您的每台笔记本电脑选择在线或离线绘图。同时记住.iplot()是显示 Jupyter 内部内容的神奇语法。
ipywidgets
ipywidgets 是关于在你的笔记本中易于构建的交互式图形用户界面。这又是一个在灵活性和可用性之间做出巨大妥协的工具。
在安装步骤之后，真正要做的就是发挥创造力，了解如何在项目中最好地利用新功能。这个想法是让小部件作为你的内容的交互界面，例如滑块、复选框、按钮、文本框等。
当您开始使用时，最令人印象深刻的是交互功能，，它根据传递的参数自动生成您的小部件(可能有多个组件)。例如，传递带有布尔值的参数会自动生成相应的复选框；取而代之的是，一个值列表被转换成一个下拉小部件。
所有的机制都非常简单，并且在官方文档中有详细的解释，所以让我们转到展示部分。
显示优点的东西
现在，为了演示到目前为止所解释的内容，加上一点无耻的自我宣传，这里有一个来自个人项目的例子列表。
包含不同的更复杂的项目的事实实际上是为什么我没有简单地为这个条目写一个笔记本，而是选择了一个老式的文章。然而，你可以在我的 Github repo 中找到所有的项目，一些简单到自包含和可复制的笔记本
示例 1: Fitbit 仪表板
这个例子可能会让我的一些量化自拍伙伴特别感兴趣，或者总的来说，对于那些为了探索和获得洞察力而想要轻松显示个人数据的人来说，不需要太多精细的工作(构建一个完整的仪表板应用程序)，但仍然保证拥有灵活性——可能是变化无常的——需求(是的，这意味着编码)。
我的 Fitbit 睡眠数据就是一个例子，其中我在可能的不同粒度级别(例如，一天、工作日、一年)有不同的统计数据要可视化(例如，睡眠效率、睡眠值计数、入睡的第一分钟)。一种选择是使用 Seaborn factorplot 并一次可视化目标统计数据的子集。
Static Seaborn Factorplot for summary stats
这对于简单的情况有效，但是当内容变得更加混乱时，情节就失去了有效性。例如，转到按月显示工作日统计数据，我们可以得到如下结果
Static weekday stat by month
已经有太多的信息了，如果你不像我一样擅长颜色，就不容易找到数据。如果这是一个打印的情节，它肯定不符合良好的沟通和情节指南。转移到 Plotly 为这种情况提供了一个解决方案，可以通过三种方式进行:
- 将 matplotlib 图形直接传递给
iplot_mpl方法 - 使用 Plotly 语法从头开始创建您的绘图
- 使用袖扣，直接从你的熊猫数据框中绘图
在这种情况下，最后一个选项是最直接和最精确的，因为原始数据格式只是将工作日转换为目标 stat 的行、月和列，这里是我按月列出的工作日睡眠效率。
综合所有这些，我最终得到了一个我认为相当不错的睡眠数据仪表板。
Demo of Jupyer as dashboard for Fitbit sleep data
示例 2:营养数据库
您可能希望有一个快速的界面来访问一些结构化的内容。例如，我在研究营养数据时就这么做了。特别是，我转述了美国农业部国家营养数据库。这是一个非常丰富和相对复杂的数据集，但可以很容易地用 Python 和 Pandas 解决。
有人可能会争辩说，这只是数据库范围内的事情，一个合适的 SQL 工具将证明更适合这种情况。这可能是真的，但是我仍然想展示通过 ipywidgets 在 Jupyter 中实现这一点是多么容易，以及对于某些人来说，这最终会成为比单独的数据库系统更好的临时选择，尤其是在数据探索期间。
Interacting with Nutrient Database
在这里，您可以看到我再次简单地依赖于interact函数，传递我的原始 Python 函数(参数化的)，加上将自动映射到小部件的参数:
- food: 空列表，转换为文本框
- *营养素:*数据库中存在的独特营养素的列表，它被转换成一个下拉小部件
示例 3:动画
如前所述，一旦你手头有了好的工具，交互性对于各种场景都是很方便的，动画肯定是其中之一。
一个简单的 intslider(由interact在传递一个(min,max,step)元组时自动生成)，可以极大地帮助探索不同分辨率或复杂性的动画，正如这个模拟康威的生命游戏所示。
Conway’s Game of Life simulation
此外，您可以构建自定义界面来快速浏览您的数据和相关分析结果，就像在这个示例中，我可视化了 CNN 在猫狗数据集上训练的内部图层输出。
CNN Layer Output Heatmap Demo
有许多可视化的框架和工具可用，特别是对于机器学习任务，但有时像上面这样快速而肮脏的解决方案可以节省大量时间，同时提供所有实际需要的信息和功能。
结论
所有展示都是使用所列工具提供的非常基本的功能获得的。例如，考虑所有与 ipywidgets 相关的例子都简单地使用了interact并对生成的小部件进行类型推断。正如官方文档中的很好地解释的那样，通过自定义小部件定义和组合可以获得更多。
通过这个条目，我想准确地传播这个词，并迅速显示这些工具在简单性和定制化方面的巨大价值。同时，我也对关于数据可视化工具的一般反馈感兴趣，特别是关于可能包含更多边缘领域(如 3D 建模和动画)的框架。
作为最后的赠品，我想强烈推荐这个库，它提供了可选的 Jupyter 主题和额外的视觉定制。
使用 Spark 交互式分析 100 GB JSON 数据
你知道有史以来印刷的最重的书是什么吗？让我们通过使用 Python 中的 Spark 探索开放库数据集来找出答案。
本教程的目的是教育，最初由Valentin Dali bard 博士和Raoul-Gabriel Urma 博士:https://Cambridge Spark . com/content/tutorials/interactive-analyze-100 GB-of-JSON-data-with-Spark/index . html
您将初步了解 Spark 中的一些可用操作，以及如何使用这些操作来交互式地探索在 Excel 等简单工具中不方便使用(由于大小和结构)的数据集。您还将看到如何在 Spark 中轻松表达 MapReduce 操作。注意，我们使用 Spark 以一种方便的方式运行一个特别的分析。还有其他方法可以分析这个数据集，比如使用 Impala 。
在本教程中，您将学习:
- 如何开始使用 Spark，
- 如何使用
map、flatMap、filter和reduce模式，以及 - 如何使用
groupByKey和reduceByKey功能。
数据集
开放图书馆是一项旨在为“每本已出版的书创建一个网页”的倡议您可以在终端中使用以下命令下载他们的数据集，该数据集大约有 20GB 的压缩数据。--continue标志让您可以分几次下载数据。
wget --continue [http://openlibrary.org/data/ol_cdump_latest.txt.gz](http://openlibrary.org/data/ol_cdump_latest.txt.gz)
然后，您可以使用以下命令提取数据—您需要大约 100GB 的可用空间:
gunzip -k ol_cdump_latest.txt.gz | cut -f 5 > ol_cdump.json
要使用 EC2 上的数据集，请将其上传到亚马逊 S3。使用以下命令，使用您的 S3 存储段名称，将数据上传到 S3。像前三步一样，这一步需要时间来完成。
aws s3 cp ol_cdump.json s3://my_bucket
或者，如果你想处理更小的数据集以节省时间，你可以从 https://s3-eu-west-1.amazonaws.com/csparkdata/ol_cdump.json 的下载一个数据样本。下面的技术是可行的，但是结果会有所不同。
如果你想在本地分析数据，你可以在你自己的机器上安装 PySpark，忽略 Amazon 的设置，直接跳到数据分析。
启动亚马逊 EMR
如果您想在集群上开始使用 Spark，一个简单的选项是Amazon Elastic MapReduce(EMR)。它为您提供了一个包含几台预配置了 Spark 的机器的集群。如果您需要快速处理存储在 S3 上的大型文件，这将非常有用。
这里有一个 youtube 视频向你展示如何开始:
开始一本齐柏林飞船笔记本
亚马逊 EMR Spark 实例与 Zeppelin 笔记本一起提供:jupyter 笔记本的替代品，直接运行在 Spark 之上。点击亚马逊 EMR 上的 Zeppelin 链接，打开 Zeppelin 笔记本。
Zeppelin 允许在同一个笔记本中使用多种语言。使用单元格顶部的%pyspark来运行 Python 命令。
%pyspark
print("Hello")
或者，您可以执行 shell 指令:
%sh
echo "World !"
导入数据集
第一步是在一个 Spark RDD 中加载数据集:一个抽象数据处理方式的数据结构——在分布式模式下，数据在机器之间分割——并允许您应用不同的数据处理模式，如过滤、映射和简化。要了解更多关于 rdd 以及本教程其余主题的信息，请查看我们的大数据训练营。
您可以读取文件，并使用操作textFile将每一行转换成 RDD 的一个元素。
path = "s3://my_bucket/ol_cdump.json"
raw_data = sc.textFile(path)
请注意，如果您正在使用文件的本地副本，您可以将一个标准文件路径(例如，ol_cdump.json)传递给该函数。
RDD 中的每个元素都是代表一个 json 值的单个字符串。因此，第二步是在 Python 字典中转化这些元素，以便更容易地分析它们。json.loads函数将一个 JSON 值解析成一个 Python 字典。方法.map(f)返回一个新的 RDD，其中f已经应用于原始 RDD 中的每个元素。将两者结合起来解析 RDD 的所有行。
import json
dataset = raw_data.map(json.loads)
dataset.persist()
注意，代码还调用了方法.persist()来缓存内存中的 RDD，以便以后可以直接重用。
RDD 数据集中的每个元素现在都是一个将键映射到值的字典。
探索性数据分析
您可以从找出条目的数量开始:
dataset.count()
这将返回 126，107，177 。还不错，书挺多的！
您可以使用first操作偷偷查看数据，返回第一个元素。或者，take(k)返回第一个k元素的列表
dataset.take(10)
输出相当长。但是你会看到返回的条目包含了number_of_pages、title、weight、isbn_10等书籍属性。
为了理解您所拥有的数据的形状，您可以提取字典中所有可用的不同键。你可能想再次使用map操作，但是你必须使用flatMap来代替。实际上，对于每一个字典，您提取一个键列表，所以map将产生一个键列表的 RDD。使用flatMap，所有的键都被折叠成一个单一的平面 RDD。考虑flatMap的一种方式是，它允许您对每个元素应用一对多的转换，而不是像map那样一对一。
在这个 RDD 键上，您可以使用distinct删除重复的键。最后，使用collect操作将惟一键的 RDD 提取到一个 Python 列表中。
keys = dataset.flatMap(**lambda** d: d.keys()).distinct().collect()
len(keys)
有 504 唯一键！一本书有很多不同的属性。
实际上，并不是所有的 JSON 对象都有相同的属性:经常会缺少属性。例如，数据库可能提到一本书的页数，但不一定提到它的印刷尺寸。这就是你从真实世界的数据中得到的。在开放图书馆数据集中，你会发现很多多样性！为了探索这种多样性，您可以使用groupByKey对每个元素的属性数量进行分组:
groups = dataset.map(**lambda** e: (len(e.keys()), e)).groupByKey()
但是坚持住！这实际上根本不是好的做法！您可以拥有一个最常见的键数，其中包含大量与该键相关联的数据，比如 20GB。在这种情况下，您将创建一个 20GB 的 Python 列表，这会使您的机器崩溃或导致交换。
计算相同结果的更好方法是使用reduceByKey:
count_per_key = (
dataset
.map(**lambda** e: (len(e.keys()), 1))
.reduceByKey(**lambda** x, y: x + y)
.collect()
)
reduceByKey操作将为每个键生成的1相加，最终返回每个属性的计数。Zeppelin 在这里非常有用，因为它让您可以通过其界面直接可视化结果:
print("%table")
**for** e in count_per_key:
print("%d\t%d" % (e[0], e[1]))
告诉我重量
你设法获得了一些关于数据的见解。不如来点更有趣的东西，你可以在高级晚宴上提出来？你很幸运。JSON 的一个属性是每本书的重量。你好奇想知道最重的书是什么吗？让我们希望这至少是一本有趣的书。当您浏览数据集时，您会注意到weight属性有不同的单位:kg、g、盎司、磅等。一切都很乱！你将需要一个函数，可以正常化的重量，所以你可以比较每本书:
**def** sanitizedWeight(weight_str):
w = convertToKilograms(weight_str)
**if** w > 1e6: *#books above 1e6 kg are errors*
**return** 0.0
**else**:
**return** w**def** convertToKilograms(weight_str):
result = weight_str.split()
**if**(len(result)) != 2:
**return** 0
**try**:
number = float(result[0])
**except** ValueError:
**return** 0
**if**(result[1] == 'pounds' or result[1] == 'lb' or result[1] == 'lbs'):
**return** number * 453.592 * 1e-3
**elif**(result[1] == 'ounces' or result[1] == 'oz' or result[1] == 'oz.'):
**return** number * 28.35 * 1e-3
**elif**(result[1] == 'grams' or result[1] == 'gms' or result[1] == 'g'):
**return** number * 1e-3
**elif**(result[1] == 'kilograms' or result[1] == 'kilo' or result[1] == 'kg'):
**return** number
**else**:
**return** 0
注意，仍有少数带有权重属性的书籍被该函数忽略。有些重量的数字和单位之间没有空格，有些是不寻常的大写字母(GM，KGms)，有些是错别字(ounds)，有些是其他奇怪的符号。让我们把重点放在分析数据集上——但是如果您愿意，可以随意改进这个解析器。
要找到最重的书，你只需要迭代数据并减少它，每次选择最重的书。
heaviest_book = (
dataset
.filter(**lambda** e: "weight" in e and "title" in e)
.map(**lambda** e: (e, sanitizedWeight(e["weight"])))
.reduce(**lambda** x, y: x **if** x[1]>y[1] **else** y)
)
那么答案是什么呢？不幸的是，这是一个有点失望，输出是一本书的 200，000 磅(刚刚超过 90 公吨)与扼杀标题！
({… u'weight': u'200000 pounds', …, u'title': u'u fool,stupid', …}, 90718.40000000001)
显然有人在数据库中插入了一个虚拟条目！这有点令人失望。
想象一下书是什么时候出版的怎么样？您可以使用所学的操作生成以下查询:
booksWithDate = (
dataset
.filter(**lambda** e: "publish_date" in e)
.map(**lambda** e: (e["publish_date"], 1))
.reduceByKey(**lambda** x, y: x + y)
.collect()
)**def** is_int(s):
**try**:
t = int(s)
**return** True
**except** ValueError:
**return** FalsebooksWithDate = (
dataset
.filter(**lambda** e: "publish_date" in e)
.filter(**lambda** e: len(e["publish_date"]) >=4)
.filter(**lambda** e: is_int(e["publish_date"][-4:]))
.map(**lambda** e: (int(e["publish_date"][-4:]), 1))
.reduceByKey(**lambda** x, y: x+y)
.collect()
)
同样，在处理真实年份之前，您需要处理和清理数据。您现在可以使用 Zeppelin 中的可视化功能来获得一个不错的分布:
print("%table")
**for** r in d:
print("%d\t%d" % (r[0], r[1]))
如果您对 Spark 和大数据系统更感兴趣，请查看我们即将举办的网络研讨会系列:
在世界各地加入我们，了解数据科学、大数据分析和在以下领域使用的先进技术…
cambridgespark.com](https://cambridgespark.com/webinar)
与此同时，你可以测试你的星火技能，尝试找到这些问题的答案:
- 数据集里哪个作者写的或者合著的书最多？
- 数据集中哪一类书最受欢迎？
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
