UC伯克利造出会「轻功」的机器人,飞檐走壁,一条腿跳遍天下 2019-05-22

选自Berkeley News

作者:Kara Manke

机器之心编译

参与:路、shooting

Salto 机器人由 UC 伯克利的研究者首创于 2016 年,这只跳跃机器人还没有一只脚大,但它可以跳到自己的三倍高度。而现在研究者使用了大量新技术武装它,使它可以像蹦蹦跷一样跳跃,像一条灵活的狗狗那样越过障碍。Salto 甚至可以在遥控器的控制下在户外「散步」。

体格不如一只脚的 Salto 机器人看起来像《星球大战》中缩小版的帝国步行机。但是千万不要被它的「娇小体格」骗了,这只小机器人可以跳得超高,高度可达它自身高度的三倍。

2016 年的 Salto 机器人单腿伸直站立后约为 30 厘米高,单次起跳的最高高度达 1 米。由于还不能在三维环境中实现自我稳定,当时这款机器人仅能连续起跳两次。而最近更新后的新版 Salto 机器人可实现原地多次弹跳(如图所示,弹跳次数可达到 100 次),单次起跳的高度可达 1.2 米。

2016 年,UC 伯克利的研究者首次展示了单腿机器人 Salto 的「高空飞行」能力,它可以轻松弹离墙面玩跑酷(一种极限运动)。现在,Salto 又有了新技能,可以像蹦蹦跷一样原地弹跳,还可以像灵活的狗狗一样越过障碍物,它甚至可以在遥控器的控制下在校园内散步。

研究者希望 Salto 能够推动小型敏捷机器人的发展,这类机器人可以在碎石路上跳跃行走,支援搜救行动。研究者将在 ICRA 2019 大会上展示 Salto 机器人的新技能。

「小型机器人可以做很多事,比如去大型机器人或人类无法活动的地方。假设在灾难发生时,人类可能被困在碎石碎砖里面,这时候它们就可以用于寻找受灾的人,且不会对救援者造成危险,甚至会比没有辅助工具的救援者更快。」UC 伯克利机器人学博士生 Justin Yim 表示,「我们希望 Salto 不仅体型小,还能够跳得很高、很快,这样它们就可以在困难的环境中也能行走自如了。」

Yim 和 UC 伯克利电气工程和计算机科学教授 Ronald Fearing 合作进行该项目。Ronald Fearing 所在的仿生微系统实验室(Biomimetic Millisystems Lab)致力于探索如何利用动物运动机制创建更加灵活的机器人。

该实验室因构建受昆虫启发的机器人而闻名,这款机器人可以安全地爬过棘手的平面,这些平面要么太光滑,要么太粗糙,总之不适合有足机器人穿行。Salto(「saltatorial locomotion on terrain obstacles」的缩写)表示「在地面障碍物上跳跃移动」,在设计这款机器人的过程中,Fearing 希望它能够以跳跃的方式移动。

UC 伯克利机器人学博士生 Justin Yim 领导了 Salto 项目,通过复杂的控制软件为 Salto 编程,从而让它掌握复杂的动作。

Salto 有一条强大的腿,这条腿是根据婴猴(又名塞内加尔丛猴)来建模的。婴猴这种小型树居灵长类动物的肌肉和肌腱储存了很多能量,起跳之前,夜猴会蹲伏,将力量上传到伸展的肌腱中。这样,较之单使用肌肉力量,这种机制能让加速度提升 15 倍多。而 Salto 机器人在机器人电机和腿部之间有天然乳胶,从而成功模仿这种生物机制。将一系列快速跳跃联系起来,Salto 也可以穿过复杂的地形(比如废墟),而这些地形只有通过跳跃或飞行的方式才有可能穿过。

「与先积聚力量再跳起的蚂蚱或蟋蟀不同,我们想找的是可以一直『跳跳跳跳跳』的机制。」Fearing 表示,「这样我们的机器人就可以从一个地方跳到另一个地方,然后在我们可能无法停留的地方短暂着陆。」

三年前,Salto 的设计团队展示了 Salto 如何跳跃,然后通过在墙壁上借力立即跳得更高,这使它成为世界上在垂直跳跃方面最灵活的机器人。之后,Yim 领导设计了复杂的控制系统,让 Salto 掌握更加复杂的任务,比如在一个地方弹起、穿过有障碍物的路径,以及跟踪一个移动的目标。

Yim 还使用新技术武装 Salto,使之能够「感受」自己的身体,告诉它正在指向的角度以及腿部的弯曲。在还没有这些能力的时候,Salto 是在伯克利工程建筑的一个房间里训练的:运动捕捉摄像头会追踪它的角度和位置并将数据传输回计算机,计算机迅速处理数据并反馈给 Salto,告诉它如何调整角度进行下一次跳跃。

现在 Salto 能够感知它自己的身体和动作,也可以自己进行这些计算。这样 Yim 可以把它带出去,用操纵杆和无线电控制器告诉它该去哪里。

「动作捕捉非常有利于机器人在受控环境中准确地跳跃,它给了我们大量非常好的数据。但问题是,我们没办法带它出去,在其它地方随便跳跃,因为安装动作捕捉摄像头需要很长时间。」Yim 说道,「我们真的很希望把这个机器人带出来,让它到处『跳跳』。为此,我们需要 Salto 能够计算它在哪儿、在做什么,而这就靠它身体上的那台计算机。」

Salto 现在可以在伯克利的校园里「散步」,它成功地在人行道、砖瓦地和草地上移动。用来实现 Salto 这项能力的数学模型还可以泛化到其它类型机器人的运动控制中,Yim 表示。

他还表示,「通过理解这些力作用于 Salto 的方式,及其质量和大小,我们可以将这些理解延伸到其它系统上,从而据此构建其它机器人,比如体型更大或者更小的,形状不同或重量不同的。」

未来,Fearing 希望继续探索跳跃型机器人的更多可能性。

「Salto 是我们走向弹跳型机器人的第一步,」Fearing 表示,「我们可以拓展 Salto 的能力,比如让它抓住树枝来着陆和起跳。Salto 是从一个非常简单的机制开始的,它只有一条腿。它为更复杂的机器人提供了基础,这些机器人可以具有更高的动态性,而且能做大量弹跳。」

原文地址:https://news.berkeley.edu/2019/05/21/with-a-hop-a-skip-and-a-jump-high-flying-robot-masters-obstacles-with-ease/



本文为机器之心编译,转载请联系本公众号获得授权

✄————————————————

加入机器之心(全职记者 / 实习生):hr@jiqizhixin.com

投稿或寻求报道:content@jiqizhixin.com

广告 & 商务合作:bd@jiqizhixin.com


    已同步到看一看

    发送中

    图灵奖得主Yoshua Bengio等大牛授课,字节跳动2019夏令营免费报名 2019-05-23

    日前,面向全球高校学生的第二届字节跳动夏令营已正式开放报名,夏令营从算法、工程、产品三大赛道招收成员,参与为期一周的「封闭式课程+实践性项目」培训。本次活动食宿全包,路费全免,更有现金大奖和字节跳动实习 offer 可拿,感兴趣的读者请点击阅读原文参与报名。

    字节跳动 Byte Camp 是字节跳动公司于 2018 年起举办的一年两度的训练营活动,该活动旨在提高顶尖高校在校学生在计算机领域的专业度,完善从基础环境搭建到技术产品应用的全流程能力,实现能力跃迁。

    去年,字节跳动 Byte Camp 夏、冬两季活动影响非凡。字节跳动「头号玩家」AI 夏令营邀请到周志华、马毅、朱军、Alexander J. Smola、贾扬清等大牛亲自授课,有 25 位营员获得字节跳动的工作机会;为国际大学生程序设计竞赛 (ICPC) 参赛队伍提供培训的冬令营,50 支队伍中有 22 支进入 ICPC World Final 2019。最终 12 支摘牌队伍中,有 5 支参加过字节跳动冬令营,包括最终获得 ICPC World Final 2019 冠军和亚军的两支队伍。

     

    如今,字节跳动 2019 Byte Camp 夏令营已正式开放报名。今年的夏令营将于 2019 年 8 月 24 日至 30 日在北京举行,本次夏令营以「封闭式课程+实践性项目」为主,营员不仅能与顶尖竞赛选手、工业界牛人、学术界专家深入交流,还能接触海量真实数据场景动手实践。

    算法、工程、产品三大赛道并驾齐驱

    本届夏令营在首届基础上进行了升级,在算法赛道之外,增设了工程和产品两个新赛道。

    其中,算法方面,字节跳动算法团队专家们将会现场教学,与学员们一起学习高并发、高可用、低延时大规模推荐系统、存储系统和计算模型的设计与实现。除此之外,夏令营还邀请了来自清华大学、北京大学、南京大学、华盛顿大学的学界权威专家教授亲临授课,他们在数学、算法等方面功底深厚。

    工程方面,字节跳动研发团队作为国内规模最大的研发团队之一,覆盖前后端开发、iOS 与安卓工程、多媒体开发、游戏开发、测试工程等全栈技术岗位。研发团队的技术专家和科学家,也会通过深入浅出的理论讲解与实战经验分享,为营员指点迷津。

    产品方面,目前字节跳动的产品覆盖全球 150 多个国家和地区、75 个语种。字节跳动的中台系统支持产品增长、留存和变现,各产品线保持高频的发版频次,产品团队有充分的创新尝试空间。本次产品赛道上,字节跳动产品团队为营员打造了「ByteDance 产品创造营」,从市场调研、需求分析、原型设计到技术实现,完成一段「理论+实战」的产品创造过程。

    重量级嘉宾:图灵奖得主加持


    针对算法、工程、产品三大赛道,此届夏令营有针对性的邀请了国内外多位大牛授课,外部嘉宾包括 2018 年图灵奖得主 Yoshua Bengio、艾伦人工智能研究所 CEO Oren Etzioni、中科寒武纪科技 CEO 陈天石等。

     


    该活动也得到了字节跳动内部技术大咖的全力支持,内部嘉宾包括字节跳动技术副总裁杨震原、字节跳动人工智能实验室主任马维英、字节跳动人工智能实验室总监李航等。

    报名方式

    目前,夏令营已经向全球高校的本科生、硕士生和博士生(非 2019 年应届毕业生)开放报名。

    5 月 31 日前,满足条件的高校生可在官网(点击阅读原文)报名,通过笔试和面试后即可入营,不需要缴纳任何培训费用。

    训练营后期将对营员进行评估,算法、工程和产品每个赛道评选出一、二、三等奖各一名,分别发放两万元、一万元、五千元奖金。同时,表现优异者将有机会赢得进入字节跳动实习的「直通券」。

     

    点击「阅读原文」,报名参加第二届字节跳动夏令营

      阅读原文

      已同步到看一看

      发送中

      每个开发者都应该了解的一些C++特性 2019-05-23

      选自Medium

      作者:M Chowdhury

      机器之心编译

      参与:韩放、shooting

      C++ 是一种强大的编程语言,但也因为其复杂性一直让用户望而却步。后来,C++ 决定做出改变,然后发展至今,成了编程社区最受欢迎的语言之一。C++ 有一些新特性非常好用,本文对此进行了介绍,比如 auto、lambda、constexpr、tuple、智能指针等。

      作为一门编程语言,C++已经进化了很多。

      当然,这些改变不是一夜之间发生的。曾几何时,C++缺乏活力,导致人们不太喜欢这门语言。

      但是,当 C++标准委员会决定加快转变时,情况就不同了。

      自 2011 年以来,C++已经成为一种不断发展的动态语言,而这正是很多人所期许的。

      不要误以为是这门语言变得简单了,实际并没有。它仍然是被广泛使用的最难编程语言之一。但是相比于之前的版本,确实对用户更加友好了。

      今天,我们深入发掘一下每位开发者都应该了解的新特性(这些新特性从 C++11 时开始出现,距今已有八年历史了)。注意,本文略过了一些高级特性,可能会在以后的内容中详细探讨。

      auto 概念

      当 C++11 第一次引入 auto,一切都变得更简单了。

      auto 的概念是让 c++编译器在编译时自动推断数据的类型,而不是每次都要求你手动声明类型。如果你的数据类型是 map>> 这样的,事情会变得非常方便。

      看一下第五行。没有 initializer 时你不能声明某些东西,这不难理解。像第五行这样,编译器是无法推断数据类型的。

      最初,auto 的使用是非常受限的。在之后的版本中,auto 变得更加强大!

      第 7 和第 8 行中,我使用了花括号初始化。这个特性也是 C++11 中新加入的。

      记住,当使用 auto 时,必须确保你的编译器可以通过某种方式推断数据类型。

      现在问题来了,如果我写  auto a = {1, 2, 3}  会发生什么?会有编译错误吗?这是向量吗?

      实际上,C++11 引入了 std::initializer_list,如果声明为 auto,那么初始化列表会被认为是这种轻量级容器。

      最后,就像前面提到的,当你使用复杂的数据类型时,编译器推断数据类型会非常有用。

      不要忘记查看第 25 行!表达式 auto [v1,v2] = itr.second 是 C++17 的新特性。这被称为结构化绑定。在之前的版本中,每个变量必须要分别进行提取,然而结构化绑定会使这个过程方便很多。

      另外,如果你想通过引用获取数据,只需要添加一个像 auto &[v1,v2] = itr.second 这样的符号,非常简洁。

      lambda 表达式

      C++11 引入了 lambda 表达式,该表达式和 JavaScript 中的匿名函数非常相似。它们是没有命名的函数对象,并且基于一些简洁的语法在不同的作用域捕获变量,它们还可以分配给变量。

      当你想在代码中快速实现一些小功能但并不想为此单独编写整个函数时,lambda 非常有用。另一种非常普遍的应用是将其作为比较函数。

      上面的例子中有很多细节。

      首先,要注意到列表初始化为你节省了多少代码。然后是通用的 begin() 和 end(),它们同样也是 C++11 中新添加的。然后是作为数据比较器的 lambda 函数。lambda 函数的参数被声明为 auto,这是 c++14 中新增的。在此之前,是不可以用 auto 作为函数参数的。

      这里使用方括号[]作为 lambda 表达式的开始。它定义了 lambda 函数的作用域,即它对局部变量和对象有多少权限。

      下面是一些现代 c++中的相关定义:

      • []代表空。因此你不可以在 lambda 表达式中使用任何外部作用域的局部变量。只可以使用参数。

      • [=]代表可通过值获取作用域内的局部对象(局部变量和参数),即你只可以使用但不可修改。

      • [&]代表可通过引用获取作用域内的局部对象(局部变量和参数),即你可以像下面例子中一样修改它。

      • [this]代表可通过值获取 this 指针。

      • [a,&b;]代表通过值获取对象 a, 通过引用获取对象 b。

      因此,如果你想在 lambda 函数中将数据转换成其他形式,你可以像下面这段代码一样,利用作用域来使用 lambda。

      在上面的例子中,如果你在 lambda 表达式中使用 [factor] 取值的方式获取了局部变量,你就不能在第五行中修改 factor,因为你没有权利这样做。不要滥用你的权限!

      最后,注意这里 var 是引用。这保证了在 lambda 函数内的任何改变都会真正改变 vector。

      if 或 switch 语句里的初始状态

      当我了解了 c++17 的这个特性之后我非常喜欢。

      显然,现在你可以在 if/switch 语句块内初始化变量并且进行条件检查了。这对保持代码的紧凑和简洁是非常有帮助的。通常形式如下:

      if( init-statement(x); condition(x)) {
          // do some stuff here
      else {
          // else has the scope of x
          // do some other stuff
      }

      编译时执行 constexpr

      constexpr 非常酷!

      假设你有一些表达式要计算,并且它的值一旦初始化就不会改变。你可以预先计算该值并且作为宏来使用。或者像 C++11 中提供的,你可以使用 constexpr。

      编程人员倾向于尽可能减少程序的运行时间。因此如果某些操作可以让编译器来做,就可以减轻运行时的负担,从而提高时间效率。

      上面的代码是 constexpr 的一个常见例子。

      由于我们声明 fibonacci 计算函数为 constexpr,编译器会在编译时预先计算 fib(20) 的值。所以编译结束后,它可以把 const long long bigval = fib(20) 替换为 const long long bigval = 2432902008176640000;

      需要注意的是,传递的参数是 const 值。这是声明为 constexpr 的函数非常重要的一点,传递的参数同样要是 constexpr 或者 const。否则,该函数会像普通函数一样执行,即不会在编译时预先计算。

      变量也同样可以是 constexpr。这种情况下,你应该可以猜到,这些变量同样也是编译时计算的。否则,会出现编译错误。

      有趣的是,在之后的 c++17 中,又引入了 constexpr-if 和 constexpr-lambda。

      tuple

      和 pair 非常相似,tuple 是一组各种数据类型的固定大小值的集合。

      有时候,使用 std::array会比使用 tuple 更加方便。array 和普通 C 类型的 array 非常相似,但具有 C++标准库的一些特性。这种数据结构是 C++11 中新增的。

      类模版参数推断

      名字有点长。从 c++17 开始,参数推断也适用于标准类模版。此前,该特性只支持函数模版。

      因此,

      std::pair<std::stringint> user = {"M"25}; // previous
      std::pair user = {"M"25}; // C++17

      类型推断是隐式完成的。这对 tuple 来说变得更加方便。

      // previous
      std::tuple<std::stringstd::stringint> user ("M""Chy"25);
      // deduction in action! 
      std::tuple user2("M""Chy"25);

      如果你不熟悉 C++模版,那么上述特性可能对你来说不是很好理解。

      智能指针

      指针也可能并不好用。

      由于 C++给编程人员提供了很大的自由度,有时这种自由可能反而会成为绊脚石。在多数情况下,都是指针在起反面作用。

      幸运的是,C++11 引入了智能指针,它比之前的原始指针更加方便,可以通过适当地指针释放帮助开发者避免内存泄漏,同时也提供了额外的安全机制。

      一开始我想在这篇文章中详细探讨一下智能指针,但显然重要的细节非常多,值得单开一篇来写,因此近期应该会出一篇相关文章。

      原文地址:https://medium.freecodecamp.org/some-awesome-modern-c-features-that-every-developer-should-know-5e3bf6f79a3c


      本文为机器之心编译,转载请联系本公众号获得授权

      ✄————————————————

      加入机器之心(全职记者 / 实习生):hr@jiqizhixin.com

      投稿或寻求报道:content@jiqizhixin.com

      广告 & 商务合作:bd@jiqizhixin.com


        已同步到看一看

        发送中

        蒙娜丽莎.gif:三星新研究用一张图像合成动图,无需3D建模 2019-05-23

        机器之心报道

        参与:思源、张倩、杜伟

        蒙娜丽莎开口说话你见过吗?这位神秘的画中人也能做出各种 gif 表情?来自三星莫斯科 AI 中心和 Skolkovo 科学技术研究所的研究人员创建了一个模型,利用这个模型可以从一张图像中生成人物头像的动图,而且是开口说话的动图。而且,这一模型没有采用 3D 建模等传统方法。

        开口说话的蒙娜丽莎好像看着没那么高冷。


        除了蒙娜丽莎,研究人员还生成了风情万种的玛丽莲·梦露。


        他们生成的名人头部动画包括玛丽莲·梦露、爱因斯坦、蒙娜丽莎以及 Wu Tang Clan 的 RZA 等。

        近年来出现了很多利用 AI 模拟人脸的研究。2018 年,华盛顿大学的研究人员分享了他们创建的 ObamaNet,它是一种基于 Pix2Pix 的唇语口型模型,以美国前总统奥巴马的视频进行训练。去年秋天,加州大学伯克利分校的研究人员开发出一个模型,使用 YouTube 视频来训练 AI 数据集,生成的人物可以做跳舞或后空翻等杂技动作。

        为了创建个性化模型,上面这些研究需要在大量个人数据上进行训练。但是,在许多实际场景中,我们需要从个人的少量甚至是一张图像中学习。因此在这项研究中,三星和 Skolkovo 研究所的研究人员只用少量甚至一张图像或画作就合成了人物开口说话状态的头部动画。

        研究人员利用了 Few-shot learning 等技术,主要合成头部图像和面部 landmark,可应用于电子游戏、视频会议或者三星 Galaxy S10 上现在可用的数字替身(digital avatar)。这种虚拟现实项目的数字替身技术可用于创建 deepfake 图像和视频。

        Few-shot 学习意味着该模型在仅使用几幅甚至一幅图像的情况下模拟人脸。研究人员使用 VoxCeleb2 视频数据集进行元训练(meta trainning)。在元学习过程中,系统创建了三种神经网络:将帧映射到向量的嵌入器网络、在合成视频中映射面部特征点的生成器网络以及评估生成图像真实性和姿态的判别器网络。

        联合三种网络,该系统能在大型视频数据集上执行长时间的元学习过程。待元学习收敛后,就能构建 few-shot 或 one-shot 的神经头像特写模型。该模型将未见过的目标任务视为对抗学习问题,这样就能利用已学习的高质量生成器与判别器。

        论文作者表示:「至关重要的一点是,尽管需要调整数千万参数,该系统能够因人而异地初始化生成器和判别器参数,因此训练可以在仅借助几幅图像的情况下快速完成。这种方法能够快速学习新面孔甚至是人物肖像画和个性化的头像特写模型。」

        该论文已被 2019 CVPR 会议接收,本届会议将于六月份在加利福尼亚州的长滩举行。

        论文:Few-Shot Adversarial Learning of Realistic Neural Talking Head Models


        论文地址:https://arxiv.org/abs/1905.08233

        新颖的对抗学习架构

        在这项研究中,研究者提出了一种新系统,可以只使用少量图像(即 Few shot learning)和有限的训练时间,构建「头像特写」模型。实际上,研究者的模型可以基于单张图像(one-shot learning)生成合理的结果,而且在添加少量新样本后,模型能生成保真度更高的个性化图像。

        与很多同类工作相同,研究者的模型使用卷积神经网络构建头像特性,它通过一个序列的卷积运算直接合成视频帧,而不是通过变形(warping)。研究者模型创建的头像特写可以实现大量不同的姿态,其性能显著高于基于变形(warping-based)的系统。

        通过在头像特写语料库上的大量预训练(meta-learning),模型能获得 few-shot 学习的能力。当然这需要语料库足够大,且头部特写视频对应不同的说话者与面孔。在元学习过程中,研究者的系统模拟了 few-shot 学习任务,并学习将面部 landmark 位置转换到逼真的个性化照片。在 few-shot 学习中,他们只需要提供转换目标的少量训练图像就可以。

        随后,转换目标的少量图像可视为一个新的对抗学习问题,其高复杂度的生成器与判别器都通过元学习完成了预训练。新的对抗问题最终会完成收敛,即在少量训练迭代后能生成真实和个性化的图像。

        元学习架构

        下图 2 展示了研究者方法中的元学习阶段,简单而言它需要训练三个子网络。注意,若我们有 M 个视频序列,那么 x_i(t) 表示第 i 个视频的第 t 帧。

        • 第一个子网络 embedder E:它会输入视频帧 x_i(s) 以及对应的 landmark 图像 y_i(s),该网络会将输入映射到 N 维向量 e hat_i(s) 中。

        • 第二个子网络 generator G:它会输入新的 landmark 图像 y_i(t),且 embedder 看不到其对应的视频帧;该网络还会输入 embedder 输出的 e hat_i,并希望能输出合成的新视频帧 x hat_i(t)。

        • 第三个子网络 discriminator D:它会输入视频帧 x_i(t)、对应的 landmark 图像 y_i(t),以及训练序列的索引 i。该网络希望判断视频帧 x_i(t) 到底是不是第 i 个视频中的内容,以及它到底匹不匹配对应的 landmark 图像 y_i(t)。

        图 2:元学习架构的整体结构,主要包含嵌入器(embedder)、生成器和判别器三大模块。

        嵌入器网络希望将头像特写图像与对应的人脸 landmark 映射到嵌入向量,该向量包含独立于人脸姿态的信息。生成器网络通过一系列卷积层将输入的人脸 landmark 映射到输出帧中,其生成结果会通过嵌入向量以及自适应实例归一化进行调整。在元学习中,研究者将相同视频一组视频帧传递到嵌入器,并对嵌入向量求均值以便预测生成器的自适应参数。

        随后,研究者将不同帧的 landmark 输入到生成器中,并对比标注图像和生成图像之间的差别。模型的整体优化目标包括感知和对抗两种损失函数,后者通过条件映射判别器实现。

        此外,元学习的三大子网络在原论文中都有具体的表达式,读者可具体查阅原论文 3.2 章。

        Few-shot 学习过程

        一旦元学习完成收敛,那么系统就能学习到如何合成新目标的头像特写序列,即使元学习中不曾见过这个人。当然,除了要提供新目标的一些图像样本,我们还需要提供新目标的 landmark,合成过程是以这些目标 landmark 为条件的。

        很自然地,我们可以使用元学习收敛后的嵌入器(embedder),用来估计新头像特写序列的嵌入向量:

        一种比较直观的想法是使用上面的嵌入向量,以及预训练的生成器生成新的视频帧与对应 landmark 图像。理论上这样也能生成真实的图像,但真实性并不是太强。为此,研究者还需要一个精调过程以生成更完美的图像,即 few-shot 学习过程。

        精调过程可视为前面元学习过程的简化版,它只在单个视频序列和较少的帧上完成训练。精调过程主要包含判别器与生成器两个模块,这里嵌入器是不需要调整的。

        其中生成器还是根据 landmark 合成视频帧,只不过对应具体人物的生成器参数 ψ’会和原来一般人物参数ψ共同优化,以学习生成目标人物的某些特征。判别器和元学习阶段也差不多,只不过会增加一个新参数以学习更好地预测真实度分数。

        实验

        研究者在定性和定量评估实验中用到了两个数据集:VoxCeleb1 和 VoxCeleb2。后者的视频数量大约是前者的 10 倍。VoxCeleb1 用于与基线和控制变量研究作对比,VoxCeleb2 用于展示本文中所提方法的全部潜力。实验结果如下表所示:

        如表 1 所示,基线模型在两个相似度度量标准上始终优于三星的方法。三星研究人员认为,这是方法本身所固有的:X2Face 在优化期间使用 L_2 损失函数,因此 SSIM 得分较高。另一方面,Pix2pixHD 只最大化了感知度量,没有 identity preservation 损失,导致 FID 最小化,但从 CSIM 一栏中可以看出,Pix2pixHD 的 identity 不匹配更大。

        此外,这些度量标准和人类的感知并没有特别紧密的关联,因为这些方法都会产生恐怖谷伪影(uncanny valley artifact),这从图 3 和用户研究结果中可以看出。另一方面,余弦相似度与视觉质量有更好的相关性,但仍然倾向于模糊、不太真实的图像,这也可以通过表 1 与图 3 中的结果对比来看出。

        图 3:在 VoxCeleb1 数据集上的结果。对于每一种对比方法,研究者在一个元训练或预训练期间未见过的人物视频上执行 one-shot 和 few-shot 学习。他们将训练的帧数设为 T(最左边的数字)。Source 列显示了训练帧之一。

        接下来,研究者扩展了可用的数据,开始在视频数目更多的 VoxCeleb2 上训练模型。他们训练了两种模型:FF(前馈)和 FT。前者训练 150 个 epoch,没有嵌入匹配损失 LMCH,因此用的时候不进行微调。后者训练 75 个 epoch,但有 LMCH,支持微调。

        他们对这两种模型都进行了评估,因为它们可以在 few-shot 学习速度和结果质量之间进行权衡。与在 VoxCeleb1 上训练的小型模型相比,二者都得到了很高的分数。值得注意的是,FT 模型在 T=32 的设定下达到了用户研究准确率的下界,即 0.33,这是一个完美的分数。两种模型的结果如图 4 所示:

        图 4:三星最好的模型在 VoxCeleb2 数据集上的结果。

        最后,研究者展示了模型在照片或画像上的结果。为此,研究者评估了在 one-shot 设定下训练的模型,任务姿态来自 VoxCeleb2 数据集的测试视频。他们使用 CSIM 度量给这些视频排序,并在原始图像和生成图像之间进行计算。这使得研究者可以发现拥有相似标志几何特征的人脸,并将它们由静态变为动态。结果见图 5 和图 1.

        图 5:使静止的照片栩栩如生。

        本文为机器之心报道,转载请联系本公众号获得授权

        ✄————————————————

        加入机器之心(全职记者 / 实习生):hr@jiqizhixin.com

        投稿或寻求报道:content@jiqizhixin.com

        广告 & 商务合作:bd@jiqizhixin.com


          已同步到看一看

          发送中

          ICRA 2019最佳论文公布:斯坦福大学李飞飞组获奖 2019-05-23

          机器之心报道

          参与:路、shooting

          机器人领域顶级会议 ICRA 2019 正在加拿大蒙特利尔举行(当地时间 5 月 20 日-24 日),刚刚大会公布了最佳论文奖项,来自斯坦福大学李飞飞组的研究《Making Sense of Vision and Touch: Self-Supervised Learning of Multimodal Representations for Contact-Rich Tasks》获得了最佳论文。


          图源:https://twitter.com/animesh_garg/status/1131263955622604801

          ICRA 最佳论文奖项设立于 1993 年,旨在表彰最优秀的论文。据了解,今年一共有三篇论文入围最佳论文奖项:

          • 论文 1:Making Sense of Vision and Touch: Self-Supervised Learning of Multimodal Representations for Contact-Rich Tasks

          • 作者:Michelle A. Lee, Yuke Zhu, Krishnan Srinivasan, Parth Shah, Silvio Savarese, Li Fei-Fei, Animesh Garg, Jeannette Bohg(斯坦福大学)

          • 论文链接:https://arxiv.org/abs/1810.10191

          • 论文 2:Deep Visuo-Tactile Learning: Estimation of Tactile Properties from Images

          • 作者:Kuniyuki Takahashi, Jethro Tan(Preferred Networks 公司)

          • 论文链接:https://arxiv.org/abs/1803.03435


          • 论文 3:Variational End-to-End Navigation and Localization

          • 作者:Alexander Amini, Guy Rosman, Sertac Karaman, Daniela Rus(MIT、丰田研究院)

          • 论文链接:https://arxiv.org/abs/1811.10119

          ICRA 最佳论文

          其中,斯坦福大学 Michelle A. Lee、Yuke Zhu、李飞飞等人的论文《Making Sense of Vision and Touch: Self-Supervised Learning of Multimodal Representations for Contact-Rich Tasks》荣获最佳论文奖项。


          摘要:在非结构化环境中执行需要大量接触的操纵任务通常需要触觉和视觉反馈。但是,手动设计机器人控制器使其结合具备不同特征的模态并不容易。尽管深度强化学习在学习高维输入的控制策略时获得了很大成功,但由于样本复杂度,这些算法通常很难在真实机器人上面部署。

          该研究使用自监督学习感知输入的紧凑、多模态表征,然后使用这些表征提升策略学习的样本效率。研究者在植入任务上评估了该方法,结果表明该方法对于外部扰动具备稳健性,同时可以泛化至不同的几何、配置和间隙(clearances)。研究者展示了在模拟环境中和真实机器人上的结果。

          该研究提出的多模态表征学习模型架构如下图所示:

          图 2:利用自监督进行多模态表征学习的神经网络架构。该网络使用来自三个不同传感器的数据作为模型输入:RGB 图像、力矩传感器在 32ms 窗口上读取的力矩数据、末端执行器的位置和速度。该模型将这些数据编码并融合为多模态表征,基于这些多模态数据可学习用控制器执行需要大量接触的操纵。这一表征学习网络是通过自监督端到端训练得到的。

          控制器设计

          下图展示了该研究的控制器架构,该架构可分为三部分:轨迹生成、阻抗控制和操作空间控制。


          实验

          下图展示了该模型在模拟环境中的训练。图 a 展示了 TRPO 智能体的训练曲线:

          图 4:模拟植入任务:对基于不同感知模态数据训练得到的表征进行模型简化测试。研究者将使用结合了视觉、触觉和本体感觉的多模态表征训练得到的完整模型和未使用这些感知训练的基线模型进行了对比。b 图展示了使用不同反馈模态的部分任务完成率,其中视觉和触觉模态在接触丰富的任务中发挥不可或缺的作用。

          下图展示了在真实环境中的模型评估。

          图 5:a)在真实机器人实验及其间隙上使用 3D 打印 peg。b)定性预测:研究者对来自其表征模型的光流预测示例进行可视化。

          下图展示了在真实机器人上对该模型的评估,同时展示了该模型在不同任务设置上的泛化效果。


          最佳论文入围论文简介

          另外两篇入围最佳论文的研究分别是来自日本 Preferred Networks 公司的《Deep Visuo-Tactile Learning: Estimation of Tactile Properties from Images》,以及来自 MIT 和丰田研究院的《Variational End-to-End Navigation and Localization》。

          论文:Deep Visuo-Tactile Learning: Estimation of Tactile Properties from Images

          摘要:基于视觉估计触觉特性(如光滑或粗糙)对与环境进行高效互动非常重要。这些触觉特性可以帮助我们决定下一步动作及其执行方式。例如,当我们发现牵引力不足时可以降低驾驶速度,或者如果某物看起来很光滑我们可以抓得更紧一些。

          研究者认为这种能力也会帮助机器人增强对环境的理解,从而面对具体环境时选择恰当的行为。因此他们提出了一种模型,仅基于视觉感知估计触觉特性。该方法扩展了编码器-解码器网络,其中潜变量是视觉和触觉特征。

          与之前的研究不同,该方法不需要手动标注,仅需要 RGB 图像及对应的触觉感知数据。所有数据都是通过安装在 Sawyer 机器人末端执行器上的网络摄像头和 uSkin 触觉感知器收集的,涉及 25 种不同材料的表面。研究者展示了该模型可以通过评估特征空间,泛化至未包含在训练数据中的材料,这表明该模型学会了将图像和重要的触觉特性关联起来。

          该研究提出的网络架构图示。

          论文:Variational End-to-End Navigation and Localization


          摘要:深度学习彻底变革了直接从原始感知数据学习「端到端」自动车辆控制的能力。虽然最近在处理导航指令形式的扩展方面取得了一些进步,但这些研究还无法捕捉机器人所有可能动作的完整分布,也无法推断出机器人在环境中的定位。

          在本文中,研究者扩展了能够理解地图的端到端驾驶网络。他们定义了一个新的变分网络,该网络能够根据环境的原始相机数据和更高级路线图进行学习,以预测可能的控制指令的完整概率分布,以及能够在地图内指定路线上导航的确定性控制指令。

          此外,受人类驾驶员可以进行粗略定位的启发,研究者根据地图和观察到的视觉道路拓扑之间的对应关系,制定了如何使用其模型来定位机器人的方案。研究者在真实驾驶数据上评估了该算法,并推断了在不同类型的丰富驾驶场景下推断的转向命令的稳健性。另外,他们还在一组新的道路和交叉路口上评估了其定位算法,并展示了该模型在没有任何 GPS 先验的情况下也具备粗略定位的能力。

          模型架构。

          ICRA 其他奖项

          除了最佳论文,ICRA 大会还设置了最佳学生论文,以及自动化、认知机器人、人机交互等分支的最佳论文。

          其中获得最佳学生论文提名的研究有:

          • 论文 1:Closing the Sim-to-Real Loop: Adapting Simulation Randomization with Real World Experience

          • 作者:Yevgen Chebotar, Ankur Handa, Viktor Makoviichuk, Miles Macklin, Jan Isaac, Nathan Ratliff, Dieter Fox(英伟达、南加州大学、哥本哈根大学、华盛顿大学)

          • 论文链接:https://arxiv.org/abs/1810.05687


          • 论文 2:Online Multilayered Motion Planning with Dynamic Constraints for Autonomous Underwater Vehicles

          • 作者:Eduard Vidal Garcia, Mark Moll, Narcis Palomeras, Juan David Hernández, Marc Carreras, Lydia Kavraki(西班牙赫罗纳大学水下机器人实验室、美国莱斯大学 Kavraki 实验室)

          • 论文链接:http://www.kavrakilab.org/publications/vidal2019online-multilayered-motion-planning.pdf


          • 论文 3:Drift-free Roll and Pitch Estimation for High-acceleration Hopping

          • 作者:Justin K. Yim, Eric K. Wang, Ronald Fearing(加州大学伯克利分校)

          • 论文链接:https://people.eecs.berkeley.edu/~ronf/PAPERS/jyim-icra2019.pdf

          值得一提的是,机器之心昨天报道了其中一项研究,详见:UC 伯克利造出会「轻功」的机器人,飞檐走壁,一条腿跳遍天下

          其他机器人学分支领域的最佳论文提名名单参见:https://www.icra2019.org/program/awards。

          本文为机器之心报道,转载请联系本公众号获得授权

          ✄————————————————

          加入机器之心(全职记者 / 实习生):hr@jiqizhixin.com

          投稿或寻求报道:content@jiqizhixin.com

          广告 & 商务合作:bd@jiqizhixin.com


            已同步到看一看

            发送中

            INTERFACE # 13 从算法到工程,解读阿里巴巴大规模图表征学习框架 2019-04-05

            图神经网络是当前机器学习领域最前沿的研究方向之一。不久之前,阿里巴巴开源大规模分布式图表征学习框架 Euler,可支持数十亿点、数百亿边的大规模异构图表征学习,也内置了大量高效的图神经网络算法。

            为了方便读者们进一步了解图神经网络在工业界的应用,本期 INTERFACE 邀请到了两位阿里巴巴专家,从算法到工程,为大家做精彩的分享。

            主题:Euler:大规模图神经网络推高人工智能的天花板

            演讲摘要:在过去几年,深度学习技术在工业界被广泛应用并产生了巨大的技术红利,业界也在积极思考和探索如何进一步拓展人工智能的边界。图神经网络将端到端学习与归纳推理相结合,有望解决深度学习无法处理的关系推理、可解释性等一系列问题。对结构知识的表达、计算和组合泛化是实现具备 human-likeAI 的关键,图神经网络有希望在这些方面形成突破,使得机器能力进一步提升。

            Euler 是阿里巴巴开源的大规模分布式图表征学习框架,可支持数十亿点、数百亿边的大规模异构图表征学习,并内置了大量的高效图神经网络算法。本次分享将为大家剖析 Euler 的系统架构与实现,详解如何支撑大规模图神经网络的计算,以及不同类型图神经网络算法的实现与加速。同时我们也会分享 Euler 在阿里巴巴商业场景

            下的应用案例及算法创新,以及我们对于图神经网络未来发展的思考。

            演讲人:

            张迪,阿里巴巴资深技术专家,阿里妈妈大数据与机器学习工程架构负责人

            林伟,阿里巴巴高级算法专家,搜索直通车匹配算法与智能创意工作负责人

            活动流程

            • 13:30-14:00,签到

            • 14:00-14:40,阿里巴巴资深技术专家张迪分享

            • 14:40-15:20,阿里巴巴高级算法专家林伟分享

            • 15:20-16:00,QA 及自由交流

            • 时间:4/13 周六下午 13:30-16:00

            • 地点:北京市海淀区中关村大街 32 号新中发一楼场馆会议中心

            扫描下方二维码,添加「机器之心小助手 3」

            备注:”Interface 活动”小助手邀请进群

            第一时间获取活动相关信息,以及与其他小伙伴互动交流

            活动直播链接将于活动当天在群里发出

            点击「阅读原文」参与报名。

              阅读原文

              发送中

              用免费TPU训练Keras模型,速度还能提高20倍! 2019-04-05

              选自KDnuggets

              作者:Chengwei Zhang

              机器之心编译

              参与:高璇、路

              本文介绍了如何利用 Google Colab 上的免费 Cloud TPU 资源更快地训练 Keras 模型。

              很长一段时间以来,我在单个 GTX 1070 显卡上训练模型,其单精度大约为 8.18 TFlops。后来谷歌在 Colab 上启用了免费的 Tesla K80 GPU,配备 12GB 内存,且速度稍有增加,为 8.73 TFlops。最近,Colab 的运行时类型选择器中出现了 Cloud TPU 选项,其浮点计算能力为 180 TFlops。

              本文将介绍如何在 Colab 上使用 TPU 训练已有的 Keras 模型,其训练速度是在 GTX 1070 上训练速度的 20 倍。

              我们首先构建一个易于理解但训练过程比较复杂的 Keras 模型,以便「预热」Cloud TPU。在 IMDB 情感分类任务上训练 LSTM 模型是个不错的选择,因为 LSTM 的计算成本比密集和卷积等层高。

              流程如下所示:

              • 构建一个 Keras 模型,可使静态输入 batch_size 在函数式 API 中进行训练。

              • 将 Keras 模型转换为 TPU 模型。

              • 使用静态 batch_size * 8 训练 TPU 模型,并将权重保存到文件。

              • 构建结构相同但输入批大小可变的 Keras 模型,用于执行推理。

              • 加载模型权重。

              • 使用推理模型进行预测。

              读者阅读本文时,可以使用 Colab Jupyter notebook Keras_LSTM_TPU.ipynb(https://colab.research.google.com/drive/1QZf1WeX3EQqBLeFeT4utFKBqq-ogG1FN)进行试验。

              首先,按照下图的说明在 Colab 运行时选项中选择激活 TPU。

              激活 TPU

              静态输入 Batch Size

              在 CPU 和 GPU 上运行的输入管道大多没有静态形状的要求,而在 XLA/TPU 环境中,则对静态形状和 batch size 有要求。

              Could TPU 包含 8 个可作为独立处理单元运行的 TPU 核心。只有八个核心全部工作,TPU 才算被充分利用。为通过向量化充分提高训练速度,我们可以选择比在单个 GPU 上训练相同模型时更大的 batch size。最开始最好设定总 batch size 为 1024(每个核心 128 个)。

              如果你要训练的 batch size 过大,可以慢慢减小 batch size,直到它适合 TPU 内存,只需确保总的 batch size 为 64 的倍数即可(每个核心的 batch size 大小应为 8 的倍数)。

              使用较大的 batch size 进行训练也同样有价值:通常可以稳定地提高优化器的学习率,以实现更快的收敛。(参考论文:https://arxiv.org/pdf/1706.02677.pdf)

              在 Keras 中,要定义静态 batch size,我们需使用其函数式 API,然后为 Input 层指定 batch_size 参数。请注意,模型在一个带有 batch_size 参数的函数中构建,这样方便我们再回来为 CPU 或 GPU 上的推理运行创建另一个模型,该模型采用可变的输入 batch size。

              import tensorflow as tf
              from tensorflow.python.keras.layers import Input, LSTM, Bidirectional, Dense, Embedding


              def make_model(batch_size=None):
                  source = Input(shape=(maxlen,), batch_size=batch_size,
                                 dtype=tf.int32, name='Input')
                  embedding = Embedding(input_dim=max_features,
                                        output_dim=128, name='Embedding')(source)
                  lstm = LSTM(32, name='LSTM')(embedding)
                  predicted_var = Dense(1, activation='sigmoid', name='Output')(lstm)
                  model = tf.keras.Model(inputs=[source], outputs=[predicted_var])
                  model.compile(
                      optimizer=tf.train.RMSPropOptimizer(learning_rate=0.01),
                      loss='binary_crossentropy',
                      metrics=['acc'])
                  return model


              training_model = make_model(batch_size=128)

              此外,使用 tf.train.Optimizer,而不是标准的 Keras 优化器,因为 Keras 优化器对 TPU 而言还处于试验阶段。

              将 Keras 模型转换为 TPU 模型

              tf.contrib.tpu.keras_to_tpu_model 函数将 tf.keras 模型转换为同等的 TPU 模型。

              import os
              import tensorflow as tf
              # This address identifies the TPU we'll use when configuring TensorFlow.
              TPU_WORKER = 'grpc://' + os.environ['COLAB_TPU_ADDR']
              tf.logging.set_verbosity(tf.logging.INFO)

              tpu_model = tf.contrib.tpu.keras_to_tpu_model(
                  training_model,
                  strategy=tf.contrib.tpu.TPUDistributionStrategy(
                      tf.contrib.cluster_resolver.TPUClusterResolver(TPU_WORKER)))

              然后使用标准的 Keras 方法来训练、保存权重并评估模型。请注意,batch_size 设置为模型输入 batch_size 的八倍,这是为了使输入样本在 8 个 TPU 核心上均匀分布并运行。

              history = tpu_model.fit(x_train, y_train,
                                      epochs=20,
                                      batch_size=128 * 8,
                                      validation_split=0.2)
              tpu_model.save_weights('./tpu_model.h5', overwrite=True)
              tpu_model.evaluate(x_test, y_test, batch_size=128 * 8)

              我设置了一个实验,比较在 Windows PC 上使用单个 GTX1070 和在 Colab 上运行 TPU 的训练速度,结果如下。

              GPU 和 TPU 都将输入 batch size 设为 128,

              • GPU:每个 epoch 需要 179 秒。20 个 epoch 后验证准确率达到 76.9%,总计 3600 秒。

              • TPU:每个 epoch 需要 5 秒,第一个 epoch 除外(需 49 秒)。20 个 epoch 后验证准确率达到 95.2%,总计 150 秒。

              20 个 epoch 后,TPU 上训练模型的验证准确率高于 GPU,这可能是由于在 GPU 上一次训练 8 个 batch,每个 batch 都有 128 个样本。

              在 CPU 上执行推理

              一旦我们获得模型权重,就可以像往常一样加载它,并在 CPU 或 GPU 等其他设备上执行预测。我们还希望推理模型接受灵活的输入 batch size,这可以使用之前的 make_model() 函数来实现。

              inferencing_model = make_model(batch_size=None)
              inferencing_model.load_weights('./tpu_model.h5')
              inferencing_model.summary()

              可以看到推理模型现在采用了可变的输入样本。

              _________________________________________________________________
              Layer (type) Output Shape Param #
              =================================================================

              Input (InputLayer) (None, 500) 0
              _________________________________________________________________
              Embedding (Embedding) (None, 500, 128) 1280000
              _________________________________________________________________
              LSTM (LSTM) (None, 32) 20608
              _________________________________________________________________
              Output (Dense) (None, 1) 33
              =================================================================

              然后,你可以使用标准 fit()、evaluate() 函数与推理模型。

              结论

              本快速教程介绍了如何利用 Google Colab 上的免费 Cloud TPU 资源更快地训练 Keras 模型。

              原文链接:https://www.kdnuggets.com/2019/03/train-keras-model-20x-faster-tpu-free.html

              本文为机器之心编译,转载请联系本公众号获得授权

              ✄————————————————

              加入机器之心(全职记者 / 实习生):hr@jiqizhixin.com

              投稿或寻求报道:content@jiqizhixin.com

              广告 & 商务合作:bd@jiqizhixin.com

                发送中

                2019年,TensorFlow被拉下马了吗? 2019-04-05

                选自TowardsDataScience

                作者:Jeff Hale

                机器之心编译

                参与:杜伟、李泽南

                AI领域里技术的发展总是很快,深度学习框架这样的工具流行的趋势也时刻处于变化之中。最近一段时间里,TensorFlow放出了2.0版(Alpha),推出了诸多新功能,也让入门的门槛有所降低。不过这些改变并没有减慢PyTorch追赶的步伐。

                本文中,作者通过GitHub、Medium文章、arXiv论文和领英等维度评估了不同神经网络框架的最新发展趋势。

                2018年9月,作者曾就需求、使用和受欢迎程度三方面比较了所有主要的深度学习框架,其中TensorFlow是无可争议的重量级冠军,PyTorch是赢得大量口碑的后起之秀。

                过去的六个月,领先的深度学习框架又有什么变化呢?

                为回答这一问题,作者不仅查看了Indeed、Monster、LinkedIn和SimplyHired上的职位列表数量,而且评估了谷歌搜索量、GitHub动态、Medium和ArXiv文章以及Quora主题关注者的变化。总的说来,这些资源全面描述了需求、使用和兴趣三方面的增长。

                集成和更新

                从工具本身来说,近来TensorFlow和PyTorch框架都出现了几项重大发展。

                2018年10月,PyTorch v1.0预发布,同时fastai v1.0发布。二者的发布是标志框架成熟的重大里程碑。

                2019年3月4日,TensorFlow 2.0 alpha版发布,增加了一些新功能,改善了用户体验。TensorFlow 2.0 alpha版更紧密地集成了Keras,作为其高阶API。

                方法论

                Keras和fastai与TensorFlow和PyTorch紧密集成在一起,因而本文在比较时将二者包含在内。Keras和fastai还为评估TensorFlow和PyTorch提供了可以参考的评估范围。

                作者在本文中不会探究其他深度学习框架。作者希望收到反馈,证明Caffe、Theano、MXNet、CNTK、PaddlePaddle、DeepLearning4J或Chainer值得讨论。虽然这些深度学习框架各有其优点,但就其增长轨迹而言,似乎不太可能接近TensorFlow或PyTorch。这些框架也未能与TensorFlow或PyTorch紧密耦合。

                搜索日期为2019年3月20日-21日。源数据在谷歌表格中。

                让我们看一下各类深度学习框架的结果吧!

                在线职位列表变化

                为了确认哪种深度学习库在当今求职市场中受欢迎,作者搜索了Indeed、LinkedIn、Monster和SimplyHired中的职位列表。

                作者首先搜索术语「机器学习」,其后为框架/库名。所以,作者以「机器学习 TensorFlow」评估TensorFlow。基于历史比较的原因,作者采用了这种评估方法。不包含「机器学习」的搜索没有产生明显不同的结果。搜索区域是美国。

                作者从2019年3月的职位列表数量中减去六个月前的数量,结果如下:

                TensorFlow的职位列表增长略高于PyTorch。Keras的职位列表也出现了增长——约是TensorFlow增长的一半。FastAI依然没有出现在任何职位列表中。

                需要注意的是,除了LinkedIn,PyTorch在所有求职网站上的增加职位列表数量都超过了TensorFlow。还需要注意的是,就绝对项而言,TensorFlow出现在职位列表中的数量几乎是PyTorch或Keras三倍。

                平均谷歌搜索活动的变化

                最大搜索引擎中的网页搜索是衡量受欢迎程度的一个标准。作者查看了过去一年里Google Trends的搜索历史。作者还搜索了全世界对「机器学习」和「人工智能」分类的兴趣。谷歌没有给出绝对搜索数量,但提供了相对数据。

                作者将过去六个月与在之前六个月的搜索兴趣平均分进行比较。

                在过去六个月,TensorFlow的相对搜索数量减少,而PyTorch的相对搜索数量增加。

                下图来自谷歌,直接显示了过去一年的搜索兴趣。

                TensorFlow显示为蓝色,Keras黄色,PyTorch红色,fastAI绿色。

                新Medium文章

                Medium是数据科学文章和教程的流行阵地。作者希望读者可以喜欢!😃

                过去六个月里,作者使用Medium.com的谷歌站点搜索,结果发现TensorFlow和Keras发表的文章数量相当,而PyTorch相对较少。

                作为高阶API,Keras和fastAI非常受深度学习新从业人员的欢迎。Medium中有很多教程介绍了这些框架的使用方式。

                最新arXiv文章

                作为最流行的预印版论文发布平台,大多数学术类深度学习文章在arXiv上发表。作者根据过去六个月的谷歌站点搜索结果来搜索提及每种框架的最新文章。

                TensorFlow有接近3000篇文章,在这方面占有很大优势,大多数最新AI论文使用的是TensorFlow框架(说好的学界爱用PyTorch呢?)。

                最新GitHub动态

                GitHub上的最新动态是框架受欢迎程度的另一指标。作者在下图列出了star、fork、watcher和contributor的数量。

                在每种类别中,TensorFlow上的GitHub动态最多。但是,PyTorch在watcher和contributor的增长方面与TensorFlow相当接近。此外,Fastai上也有大量的新增contributor。

                毫无疑问,Keras的一些贡献者会在TensorFlow库中工作。值得注意的是,TensorFlow和Keras都是由谷歌人牵头的开源产品。

                Quora新关注者

                作者将新的Quora主题关注者添加进参考标准中——这是一个以前没有数据的新分类。

                过去六月里,TensorFlow增加了最多的新话题关注者。PyTorch和Keras相差甚多。

                作者在添加所有数据后将其合并成一个指标。

                增长分数过程

                作者创建了增长评分机制:

                1. 所有特征的数值范围为0-1。

                2. 汇总了「线上职位列表」和「GitHub动态」子分类。

                3.基于下列百分比的加权分类。

                4.可理解性乘以加权分数100。

                5.将每个框架的类别分数汇总为单个增长分数。

                工作列表占总分数的三分之一多,这是比例最高的一部分:钱说了算。这种多权重方法平衡了不同类别。相比2018年的统计,这次统计未包含KDNuggets的使用调查(因为还未出现新数据),以及书籍的出版(过去六个月相应新书数量不多)。

                结果

                这里是表格形式的变化。

                相应的Google表格:https://docs.google.com/spreadsheets/d/1Q9rQkfi8ubKM8aX33In0Ki6ldUCfJhGqiH9ir6boexw/edit?usp=sharing

                这里是类别和最终分数。

                这是最终的增长分数。

                TensorFlow是需求量最大,也是增长最快的框架,这个趋势近期不会有任何变化。PyTorch的增长速度也很快,在职业需求列表中的快速增长证明了这种需求。在过去的六个月里,Keras也有了很大发展。最后,fastai的起点最低,不过因为它最年轻,所以仍然值得期待。

                TensorFlow和PyTorch都是值得学习的框架。

                学习建议

                如果你希望学习TensorFlow,我们建议你可以从Keras学起。相应的课程则是Chollet的Deep Learning with Python和Dan Becker的DataCamp course on Keras。TensorFlow 2.0使用tf.keras,将Keras作为其高阶API。Chollet有一篇TensorFlow 2.0的快速入门。

                如果你想要学习PyTorch,我们建议你从fast.ai的MOOC课程《Practical Deep Learning for Coders v3》入手。在这里你将学习到深度学习基础、fastai和PyTorch的基础。

                TensorFlow和PyTorch的未来方向会是什么?

                未来的方向

                我们一直能够听到“PyTorch比TensorFlow更好用”的说法。的确,PyTorch更加Python一些,也有更为统一的API,它拥有原生的ONNX模型导出机制,可用于加速推理。而且,PyTorch和Numpy有着很多共同之处,这让人们的学习成本降低不少。

                但是,TensorFlow 在2.0版中大力改进了用户体验,正如谷歌首席智能决策工程师Cassie Kozyrkov所说的。TensorFlow现在已拥有更加直接的API、完全集成的Keras和Eager Execution选项了。这些变化,以及TensorFlow的用户基础可以让这个框架在未来继续流行下去。

                TensorFlow最近宣布了另一个激动人心的计划:Swift版TensorFlow的开发。Swift是一种原先由苹果推动的编程语言。在执行和开发速度方面,Swift比Python有很多优势。Fast.ai将在MOOC进阶课程中使用Swift for TensorFlow。这种语言可能不会在未来一两年内迎来黄金时间,但这种发展对于目前的深度学习框架非常有益。

                语言和框架之间的融合正在发生。

                另一个即将影响深度学习框架的是量子计算。实用型量子计算机有机会在几年后出现,而谷歌、IBM、微软和其他公司正在探索量子计算与深度学习的融合。框架需要适应这些新技术。

                结语

                在统计之后,我们可以看到TensorFlow和PyTorch都是增长强劲的神经网络框架。它们都有高阶API——tf.keras和fastai——它们降低了进入深度学习的门槛。除此之外,我们还看到了未来的一些发展方向。

                若希望获取文章中的数据,以及Jupyter Notebook,请移步Kaggle Kernel:https://www.kaggle.com/discdiver/2019-deep-learning-framework-growth-scores 

                原文链接:
                https://towardsdatascience.com/which-deep-learning-framework-is-growing-fastest-3f77f14aa318



                本文为机器之心编译,转载请联系本公众号获得授权

                ✄————————————————

                加入机器之心(全职记者 / 实习生):hr@jiqizhixin.com

                投稿或寻求报道:content@jiqizhixin.com

                广告 & 商务合作:bd@jiqizhixin.com

                  发送中

                  重磅 | GAN之父Ian Goodfellow加盟苹果 2019-04-05

                  机器之心报道

                  机器之心编辑部

                  据 CNBC 报道,生成对抗网络(GAN)的创造者,前谷歌大脑著名科学家 Ian Goodfellow 刚刚正式宣布加盟苹果。他将在苹果公司领导一个「机器学习特殊项目组」。

                  虽然苹果此前已经缩小了自动驾驶汽车研究的规模,但 Ian Goodfellow 等人的加盟似乎意味着这家公司在人工智能军备竞赛中的投入不减反增。

                  目前,Ian Goodfellow 的 LinkedIn 账户已经更新了最近的跳槽活动:

                  「我在苹果公司领导一个机器学习特殊任务群组。」Goodfellow 写道。

                  在回归谷歌之前,Ian Goodfellow 在另一家著名人工智能研究机构 OpenAI 工作。后者是一个人工智能研究联盟,最初由埃隆·马斯克(Elon Musk)和其他科技名人出资创建。Ian Goodfellow 是生成对抗网络(GAN)之父,他的著作在 AI 领域广为引用。

                  Goodfellow 是谷歌在过去的 12 个月里被苹果挖走的第二位 AI 人才,是后者加强其 AI 战略的结果。前谷歌 AI 主管 John Giannandrea 也加入了苹果,担任苹果的机器学习和人工智能战略高级副总裁,监管所有人工智能和机器学习开发,包括 Core ML 和 Siri 技术。Giannandrea 和 Goodfellow 以前在谷歌一起工作,Goodfellow 似乎是 Giannandrea 出任苹果高管后精挑细选的人

                  Goodfellow 最突出的贡献是其在 2014 年提出了生成对抗网络(GAN)。GAN 包含两种神经网络:创造新数据实例的生成器和区分由生成器从真实数据中创建假数据的判别器。这两种神经网络通过越来越逼真的假数据来挑战彼此,优化自己的策略,直至生成数据与真实数据难以区分。

                  过去五年,GAN 在图像生成领域取得了重大突破,现在可以生成动物、风景以及人脸等高度逼真的合成图像。例如可以合成人脸的网站 thispersondoesnotexist.com 。但是,GAN 的成功也打开了潘多拉的魔盒,引发了诸多伦理问题和潜在危险。例如,有人利用 GAN 开发「deepfake」人脸交换技术,制作「换脸」明星色情片,同时也有人担忧 GAN 用于生成假新闻以操控公众舆论等。

                  苹果显然正处于团队建设模式。该公司最近聘请了特斯拉前工程副总裁 Michael Schwekutsch 担任另一个「特别项目组」的高级工程总监,为自动驾驶研发加码。

                  Ian GoodFellow 简介

                  Ian Goodfellow 是机器学习领域备受关注的年轻学者之一,本科与硕士就读于斯坦福大学,师从吴恩达,博士阶段则跟随蒙特利尔大学的著名学者 Yoshua Bengio 研究机器学习。他最引人注目的成就是在 2014 年 6 月提出了生成对抗网络(GAN)。这一技术近年来已成为机器学习界最火热的讨论话题,特别是近年来,与 GAN 有关的论文不断涌现。GAN 已成为众多学者的研究方向。

                  Ian GoodFellow 论文引用量逐年飙升,来源:Google Scholar

                  Ian Goodfellow 影响作者图,包括 Bengio、Hinton、LeCun 等巨头,来源:Semantic Scholar

                  在 2016 年,Ian Goodfellow、Yoshua Bengio、Aaron Courville 等人推出了著名的人工智能基础书《Deep Learning》,该书已被列为机器学习领域内的必读内容。

                  《Deep Learning》中文版链接:https://github.com/exacity/deeplearningbook-chinese


                  机器之心 Ian GoodFellow & Yoshua Bengio 联合签名版《Deep Learning》

                  由于在人工智能领域的激烈竞争,目前在 FAANG 工作的顶级 AI 人才可以获得六位数到七位数美元的薪资。Ian Goodfellow 在加盟苹果后会带来哪些新的技术突破?或许我们很快就会看到了。 

                  扩展阅读:

                    发送中

                    比无所不能的DIP更强大的图像恢复方法:DeepRED 2019-04-06

                    选自arXiv

                    者:Gary Mataev、Michael Elad、Peyman Milanfar

                    参与:高璇、Chita

                    此前,深度图像先验(DIP)被证明可以在不用学习的情况下解决图像去噪、去水印、超分辨率问题。但这一方法与最先进的替代方法相比,效果并不理想。本文基于 DIP 和去噪正则化(RED)概念,提出了 DeepRED 方法。它将两者结合,获得了非常有效的结果。

                    成像中的逆问题(inverse problem)是基于给定的损坏程度 y 对未知图像 x 的恢复。由于逆问题往往是病态(ill-posed)的,因此恢复过程成功的关键是正则化的选择。作为稳定逆向退化的图像先验,正则化将结果导向更合理的图像。

                    Ulyanov[13,14] 等人最近的工作为逆问题与深度学习的融合做出了特殊贡献。本文提出了深度图像先验(DIP)方法,这是一种在逆问题中处理正则化任务的新策略。与大多数早期的方法不同,DIP 建议使用深度网络本身作为逆问题的正则化工具,而不是采用监督的方法。

                    更具体点来说,DIP 移除了显式正则化,取而代之的是假设未知图像 x 是来自学习到的网络的生成图。当 DIP 与损坏图像的网络参数相匹配时,就可以根据要处理的图像进行调整。研究人员对这项研究的极大兴趣是源于一个绝妙的想法,即隐式地使用网络的架构来获得恢复图像 x 的正则化效果。

                    虽然 DIP 已经被证明十分有效,并在去噪、去水印、图像修复、超分辨率等多个成像逆问题中获得成功,但它的效果远没有达到当前最佳水平。因此研究人员提出通过返回显式正则化为 DIP 提供额外提升的想法,以便丰富隐式正则化,从而更好地恢复图像。

                    那应该从如此多的正则化方法中选择哪种呢?有趣的是,《Image restoration using total variation regularized deep image prior》中最近提出了对额外正则化的需求,它使用 Total-Variation 改善了修复结果。

                    在本文中,研究人员建议引入最近的去噪正规化概念 (RED)[17],并将它与 DIP 融合。RED 的特别吸引力在于它优于其它许多正则化方案,并且依赖现有的去噪算法来定义正则化项。本研究的一个特殊挑战是找到训练新的复合目标 DIP + RED 的方法,同时避免去噪函数的显式求导。

                    这些都是通过使用交替方向乘子法 (ADMM)[18] 实现的,它有一个额外的优势:相对于所采用的停止规则,它有一个稳定的恢复。这个方案被称为 DeepRED,经过图像去噪、单张图像超分辨率和图像去模糊方面的测试,RED 显示出明显优势。结果表明,无论是相对于 [17] 中的自然 RED 或 DIP 本身,所有结果都得到了显著改善。事实上,尽管 DeepRED 是一种无监督的方法,但它更接近于逆问题的监督求解器。

                    论文 :DeepRED: Deep Image Prior Powered by RED



                    论文链接:https://arxiv.org/abs/1903.10176

                    多年来,研究人员使用各种策略、工具和理论对成像中的逆问题进行了广泛研究。最近,这一领域受到了深度学习技术的巨大影响。Ulyanov 等人的深度图像先验(DIP)研究就是其中之一。DIP 为逆问题的正则化提供了一种新方法。尽管 DIP 已被证明是有效的,但与最先进的替代方法相比,它的效果并不理想。


                    在这项工作中,研究人员的目标是通过添加一个显式先验来增强 DIP,这丰富了整体正则化效果,从而可以更好地恢复图像。更具体地说,研究人员建议引入去噪正则化(RED)的概念,它利用现有的降噪器来正则化逆问题。本文的研究展示了如何将两者(DeepRED)合并到高效的恢复过程中,同时避免区分所选的降噪器,并产生非常有效的结果,这在几个已测试的逆问题中得到了证明。

                    DeepRED 方案

                    将 DIP 和 RED 合并,目标函数变为:

                    注意,要避免使用 x,并定义关于未知数 Θ的整体优化。这需要求解: 

                    虽然这看起来很简单,但实际上行不通。因为在 T 上反向传播需要对去噪函数 f(·) 求导。对于大多数降噪器来说,这是一项必须避免的艰巨任务。如上所述,在适当条件下,RED 可以避免这种直接求导,研究人员想利用的也是它这个特性。

                    解决这一问题的方法是采用交替方向乘子法 [18]。从等式 (4) 开始,利用增广拉格朗日乘子法 (AL) 将约束项转化为惩罚项。

                    在这个表达式中,u 代表等式约束集合的拉格朗日乘子向量,而µ是被选择的自由参数。

                    ADMM 算法相当于此表达式中三个未知数——Θ、x 和 u 的顺序更新。

                    算法 1 总结了应用此整体算法处理 DeepRED 目标最小化的步骤。

                    实验结果

                    本文在一系列实验中测试了提出的 DeepRED 方案。下面考虑了三种应用:图像去噪和单张图像超分辨率(SISR)以及图像去模糊。

                    图 2 显示了从这些实验中获得的两个可视化视觉结果,以说明获得的图像恢复效果。

                    超分辨率结果。上两行:花朵 (Set14),比例因子 4。下两行:斑马 (Set14),比例因子 4。

                    研究人员分别测试了 4 和 8 的比例因子,并将结果与 DIP [13] 和 RED [17] 在两个数据集上进行了比较。表 2 和表 3 对结果进行了总结。可以看出,RED+DIP 的效果始终优于单独使用 DIP 或 RED。

                    表 2:Set5 的超分辨率结果。

                    表 3:Set14 的超分辨率结果。

                    研究人员将 DeepRED 与 DIP、RED 和 NCSR Deblur 在 4 幅彩色图像上进行了比较。结果如表 5 所示。此外,图 4、图 5 和图 6 给出了该实验的三组结果,结果表明 RED 正则化效果优势明显。

                    表 5:图像去模糊结果

                    图五和图六分别是鹦鹉和树叶的图像去模糊结果比较。

                    本文为机器之心编译,转载请联系本公众号获得授权

                    ✄————————————————

                    加入机器之心(全职记者 / 实习生):hr@jiqizhixin.com

                    投稿或寻求报道:content@jiqizhixin.com

                    广告 & 商务合作:bd@jiqizhixin.com

                      发送中

                      谷歌软件工程师分享编程经验:有效的流程很关键 2019-04-06

                      选自blog.usejournal

                      者:Steve Merritt

                      参与:Panda

                      编写程序时,正确合适的工作流程能够确保高效地完成工作目标。近日,谷歌软件工程师 Steve Merritt 在博客上分享了自己的工作流程,机器之心进行了编译介绍,希望能为读者的编程之路带来一些帮助和启发。

                      我将在这篇文章中带你了解我从头至尾解决编程问题的策略。我既在谷歌的日常工作中使用这一策略,也在和各种水平的编程人员(训练营、大学生和实习生等)合作时使用它(帮助他们学习和成长)。应用这一结构化的流程能尽可能地缩减令人沮丧的调试过程,在更少的时间里得到更清晰更正确的代码。

                      一步步介绍

                      我将使用一个示例练习题来进行说明。

                      问题:「给定两个字符串 sourceString 和 searchString,返回 searchString 出现在 sourceString 中的第一个索引。如果 searchString 未在 sourceString 中出现,则返回 -1。」

                      第一步:画出来

                      直接从写代码开始实际上是一个荒谬又懒惰的思路。在写一篇文章之前,你首先会搞清楚你的假设和证据,以确保你的论证是合理的。如果你不这样做,后面当你发现你写的内容整体无法合适地组合起来时,你又要重新开始,这会浪费很多时间。写代码也是这样,甚至可能更糟,就像把洗发水揉进眼睛里那么糟。

                      通常而言,一个问题的解决方案并不是浅显直观的,即使可能乍看起来很简单。在纸上琢磨一下能让你找到解决方案并验证该方案在一些不同场景中的效果。所有这些工作都应在写下任何一行代码之前完成。

                      所以先不要写代码。甚至不要去想代码。后面你会有足够的时间去添加分号和括号。现在你只需要搞清楚你作为一台人体计算机,会如何解决这个问题。

                      画图。使用箭头。在小方框里填写数字。只要能让你可视化这个问题,就去做吧。你的目标是解决问题,你能用纸张和铅笔尽情发挥,而不受限于键盘。

                      首先找一些简单的输入。比如,假设你的函数是「取一个字符串」:「abc」。搞清楚正确的结果是什么。然后去想「如何」解决这个问题以及所涉及到的步骤。

                      我们假设我们的字符串有以下值:

                      sourceString: "abcdyesefgh"
                      searchString: "yes"

                      我的想法就会像下面这样展开:

                      好吧,我看到 sourceString 包含 searchString。但我是怎么看出来的?嗯,我首先从 sourceString 的开头开始阅读,检查每 3 个字符构成的片段是否与词「yes」匹配,直到结束。比如,我看了 abc、bcd、cdy 等组合。当我看到索引 4 时,我找到了 yes,所以我确定找到了匹配并且是从索引 4 开始。

                      当我们写下我们的算法时,我们需要确保我们表达了一切并能够处理所有可能的情况。当我们确实能找到匹配时,返回正确答案当然很好,但我们也需要在没有匹配时也能返回正确答案。

                      我们再以另一对字符串为例:

                      sourceString: "abcdyefg"
                      searchString: "yes"

                      这里,我们同样首先从 sourceString 的开头开始阅读,检查每 3 个字符构成的片段是否与词「yes」匹配,直到结束。当我们看到索引 4 时,找到了「yef」,差点就匹配了,但却并没有完全匹配,因为第三个字符不同。所以我们继续检查,直到字符串末尾,最后确定其中没有匹配,因此返回 -1。

                      我们已经确定了解决这个问题的一系列步骤(在编程领域,我们称之为「算法」),我们也已经尝试了一些不同场景,每一次都得到了正确的结果。现在,我们已经很相信我们的算法有效了,现在是时候形式化这个算法了,这就是下一个步骤。

                      第二步:写成普通话

                      我们想想在第一步确定的算法,然后用平实易懂的语言把它写出来。这能使这些步骤显得具体,让我们在写代码时能够回顾参考。

                      1. 从字符串开头开始检查

                      2. 检查每 3 个字符构成的片段(具体字符数量视 searchString 而定)

                      3. 如果其中有任何片段等于 searchString,就返回当前索引

                      4. 如果直到该字符串结束也没找到任何匹配,就返回 -1

                      看起来不错哟!

                      第三步:写伪代码

                      伪代码并不是真正的代码,但却模仿了代码的结构。下面是我为上面的算法写的伪代码:

                      for each index in sourceString,
                          there are N characters in searchString
                          let N chars from index onward be called POSSIBLE_MATCH
                          if POSSIBLE_MATCH is equal to searchString, return index
                      at the end, if we haven't found a match yet, return -1.

                      我还可以让伪代码更接近代码一点,比如这样写:

                      for each index in sourceString,
                          N = searchString.length
                          POSSIBLE_MATCH = sourceString[index to index+N]
                          if POSSIBLE_MATCH === searchString:
                              return index
                      return -1

                      伪代码与代码的接近程度完全由你决定,随着时间的推移,你会发现最适合自己的风格!

                      第四步:将你能做到的部分翻译成代码

                      注:对于更简单的问题,这个步骤可以与上一步一起完成。

                      这是整个流程中我们第一次必须考虑句法、函数参数和语言规则。你也许没法写出所有一切,但没有关系,把你知道的部分写出来!

                      function findFirstMatch(searchString, sourceString{
                          let length = searchString.length;
                          for (let index = 0; index         let possibleMatch = <the LENGTH chars starting at index i>
                              if (possibleMatch === searchString) {
                                  return index;
                              }
                          }
                          return -1;
                      }

                      注意,我在这段代码中留了一些空白。这是故意的!我不确定 JavaScript 中切分字符串的句法是什么,所以我要在下一步查一下。

                      第五步:不要猜测

                      我看到代码新人常会犯一个错误:在互联网上找一些写着「可能有效」的东西,然后不加测试地将其插入到自己的程序中。你的程序中你不理解的片段越多,你就越不可能最后得到正确的解决方案。

                      每增加一个你不确定的东西,你的程序可能出错的方式都会翻一倍。对某事不确定?没有问题——如果你的代码无效,那么这里可能就是问题所在。

                      附注:你的程序可能出错的方式遵循梅森序列:a(n) = (2^n) — 1

                      首先测试你的新代码。在网上找东西是可以的,但你在将其插入你的程序之前应该在另一个单独的小空间里测试一下它,以确保其工作方式和你所想的一样。

                      在前一步中,我并不确定在 JavaScript 中该如何选择一个字符串的特定部分。所以我谷歌了一下:

                      https://www.google.com/search?q=how+to+select+part+of+a+string+in+javascript

                      第一个结果来自 w3schools,有点旧了,但通常比较可靠。

                      https://www.w3schools.com/jsref/jsref_substr.asp

                      基于这个结果,我猜想我应该使用

                      substr(index, searchString.length) 

                      来提取 sourceString 中的各部分。但这只是一个假设,仅此而已。所以,我首先创建了一个小例子来测试其行为。

                      >> let testStr = "abcdefghi"
                      >> let subStr = testStr.substr(34);  // simple, easy usage
                      >> console.log(subStr);
                      "defg"
                      >> subStr = testStr.substr(85);   // ask for more chars than exist
                      "i"

                      现在,我已经确定这个函数的效果了。所以当我将其插入到我的程序中时,我知道如果我的程序没有效果,那么原因不会是我加入的这段新代码。

                      有了这样的保证,我就可以完成程序的最后一部分了。

                      function findFirstMatch(searchString, sourceString{
                          let length = searchString.length;
                          for (let index = 0; index         let possibleMatch = (
                                  sourceString.substr(index, length));
                              if (possibleMatch === searchString) {
                                  return index;
                              }
                          }
                          return -1;
                      }

                      总结

                      如果你读到了这里,我现在只想说:试试这种策略。回到你上周因为受挫而搁置一旁的编程问题。我保证你能立马看到效果。祝你好运,编程快乐!

                      原文链接:https://blog.usejournal.com/how-a-googler-solves-coding-problems-ec5d59e73ec5

                      本文为机器之心编译,转载请联系本公众号获得授权

                      ✄————————————————

                      加入机器之心(全职记者 / 实习生):hr@jiqizhixin.com

                      投稿或寻求报道:content@jiqizhixin.com

                      广告 & 商务合作:bd@jiqizhixin.com

                        发送中

                        最好用的文字与公式编辑器,这套数学笔记神器送给你 2019-04-06

                        机器之心报道

                        机器之心编辑部

                        作为一个高大上的文字工作者,写写划划,抄抄数学表达式是必不可少的。今天小编介绍学习中必不可少的两大神器:最好用的 Markdown 编辑器 Typora,最好用的数学神器 Mathpix Snip,不接受反驳。它们珠联璧合简直能上天~

                        在我们学习生活中,经常需要记很多笔记,或者发发个人博客网站,那么工具就必不可少了。一般情况下,我们都钟爱使用贼简单、贼优美的 Markdown 标记语言,它的学习曲线并不陡峭,且基本上能 Cover 绝大多数使用场景。

                        Markdown 语法简洁明了,小白看几眼就能知道个大概。但是我们总不能一直以标记语言的形式看文章啊,因此也就需要 Typora 编辑器了,键入标记语言,编辑器将自动渲染为视图页面。总之用 Markdown 记下学习生活,才是程序猿必不可少的。

                        对于 ML 领域的程序猿,Markdown 的一个缺点是不能用 LaTex 数学表达式,但 Typora 能完美解决这个问题,它可以直接展示 LaTex 数学表达式。既然要写 ML 数学表达式,那么神器 Mathpix Snip 就必不可少了,它可以将表达式截图转化为 LaTex 代码。小编用它「抄了」这么多公式,基本上语法没有错误,而且还很「规矩」。

                        在这一篇文章中,我们将重点介绍这两大神器,至少在老编们的心中,它们是无敌的。如果你有更好的配置,欢迎留言推荐。

                        最好的 Markdown 编辑器 Typora

                        其实优秀的 Markdown 编辑器有很多,例如微软开源的 Madoko 在线 IDE、Cmd Markdown 等等。但是 Typora 简洁的界面和实时预览效果非常优美,而且甚至我们都不需要了解 Markdown 语法就能完成文档。Typora 比较适合轻量级的日常使用,它的特点就是入门简单。

                        • Typora:https://typora.io/

                        有了 Typora,语法自动补全、Markdown 与 Word 或 PDF 等的导入与导出、字数统计等各种功能也就都有了。如下所示为 Typora 中的数学公式特点:



                        Typora 还支持各种主题、各种功能,还没搭上 Markdown 高速列车的小伙伴们,推荐使用 Typora。

                        数学公式神器 Mathpix Snip

                        前面我们可以使用 Typora 完成各种文章与笔记,那么我们该怎样写得更高效呢?这里可能需要花些时间的就是嵌入数学公式。其实用 LaTex 表达式写数学公式还是挺麻烦的,至少一般人做不到手写速度。但是我们有 Mathpix Snip 啊,只要截个图,公式会自动转化为 LaTex 表达式,我们只需要简单地修改修改就行了。

                        Mathpix Snip 的设计初衷是帮助人们在通过手机或电脑输入数学公式时节省时间。为此,Mathpix 研发了一款免费 APP——Snip 来自动化这一繁琐过程。


                        • Mathpix Snip:https://mathpix.com/

                        Mathpix 怎么用?

                        以下是官网展示的操作步骤,其演示了各个操作系统配合使用的快捷键以及详细步骤。实际上,我们就只需要截个图:



                        以下是小编在 Windows 系统上安装该工具后,系统给出的操作步骤提示:

                        然后,小编亲手操作了一波:

                        打开 Mathpix 后,它会在后台运行。当遇到想编辑的图片公式时,只要按快捷键 Ctrl+Alt+M 即可对图片截图:



                        如上,截图选中了红框里的公式之后,很快就出现了转化效果。注意上面绿色的方框表示转换代码的置信度,只要截图正确,基本上它都是 OK 的。

                        最后 copy 想要的结果,再粘贴到 Typora 编辑器中就大功告成啦!有没有超简单?!

                        万能的 API

                        为了方便使用,该公司还研发了一个 API(MathpixOCR),可以帮助开发者将 Mathpix 的功能集成到自己的应用程序。

                        你向 MathpixOCR 发送一张图片,它就会告诉你其中的数学公式。就这么简单。该 API 会返回 LaTex 以及图片元数据,你可以在你的应用中使用它。

                        如下展示了如何简单调用 API 处理单张图像:

                        #!/usr/bin/env python
                        import sys
                        import base64
                        import requests
                        import json

                        # 将文件路径放在此处
                        file_path = 'limit.jpg'
                        image_uri = "data:image/jpg;base64," + base64.b64encode(open(file_path, "rb").read())
                        r = requests.post("https://api.mathpix.com/v3/latex",
                            data=json.dumps({'url': image_uri}),
                            essay-headers={"app_id""trial""app_key""34f1a4cea0eaca8540c95908b4dc84ab",
                                    "Content-type""application/json"})
                        print json.dumps(json.loads(r.text), indent=4, sort_keys=True)

                        curl -X POST https://api.mathpix.com/v3/latex \
                            -H 'app_id: trial' \
                            -H 'app_key: 34f1a4cea0eaca8540c95908b4dc84ab' \
                            -H 'Content-Type: application/json' \
                            --data '{ "url": "data:image/jpeg;base64,'$(base64 -i limit.jpg)'" }'

                        API 返回的 JSON 结构如下所示:

                        {
                            "detection_list": [],
                            "detection_map": {
                                "contains_chart"0,
                                "contains_diagram"0,
                                "contains_geometry"0,
                                "contains_graph"0,
                                "contains_table"0,
                                "is_inverted"0,
                                "is_not_math"0,
                                "is_printed"0
                            },
                            "error""",
                            "latex""\\lim _ { x \\rightarrow 3} ( \\frac { x ^ { 2} + 9} { x - 3} )",
                            "latex_confidence"0.86757309488734,
                            "position": {
                                "height"273,
                                "top_left_x"57,
                                "top_left_y"14,
                                "width"605
                            }
                        }

                        他们用了都说好



                        该工具的官网还调侃了爱因斯坦、牛顿和图灵,模仿三人对 Mathpix Snip 进行评价:

                        如果我早一点知道 Mathpix Snip,也许我会有足够的时间来计算大统一理论——爱因斯坦
                        Mathpix 可以帮我在新作《自然哲学的数学原理》中轻松使用数学公式。现在我有更多的时间站在苹果树下等着苹果砸了——牛顿
                        Mathpix 的 AI 绝对可以通过这个图灵测试!——图灵

                        本文为机器之心报道,转载请联系本公众号获得授权

                        ✄————————————————

                        加入机器之心(全职记者 / 实习生):hr@jiqizhixin.com

                        投稿或寻求报道:content@jiqizhixin.com

                        广告 & 商务合作:bd@jiqizhixin.com

                          发送中

                          解密:OpenAI和DeepMind都用的Transformer是如何工作的 2019-04-07

                          选自towardsdatascience

                          者:Giuliano Giacaglia

                          机器之心编译

                          参与:Geek AI、张倩

                          Transformer 是一种越来越流行的神经网络架构。最近,OpenAI 将 Transformer 用到了他们的语言模型中, DeepMind 也将其用到了他们为击败顶级职业玩家所设计的 AlphaStar 程序中。本文将详解这一架构的工作原理。


                          Transformer 是为解决序列转换或神经机器翻译问题而设计的架构,该任务将一个输入序列转化为一个输出序列。 语音识别、文本转语音等问题都属于这类任务。


                          序列转换。绿色方框代表输入,蓝色矩形代表模型,紫色方框代表输出。

                          对于执行序列转换任务的模型来说,它们需要某种记忆能力。例如,让我们将下面的句子翻译成另一种语言:

                          “The Transformers” are a Japanese [[hardcore punk]] band. The band was formed in 1968, during the height of Japanese music history”

                          在本例中,第二句中的「band」一词指的是第一句中介绍的「The Transformers」乐队。当你在第二句中读到这支乐队时,你知道它指的是「The Transformers」乐队。这对翻译任务可能非常重要。此外,还有很多这样的例子,某句中的某个单词指的是前面句子中的单词。


                          注意力机制


                          为了解决这些问题,研究人员创造了一种将注意力分配到特定单词上的技术。

                          在翻译一个句子时,我们会特别注意正在翻译的单词。当转写录音时,我们会仔细聆听正在努力记下来的片段。如果让我描述一下我所在的房间,我会一边说一边环顾我所描述的物体的四周。

                          神经网络可以使用注意力机制实现相同的行为,将注意力集中在给出了信息的部分上。例如,一个循环神经网络(RNN)可以处理另一个 RNN 的输出。在每一个时间步上,它都会关注另一个 RNN 的输出的不同位置。

                          为了解决这些问题,神经网络使用了一种名为「注意力机制」的技术。对 RNN 来说,每个单词都有一个对应的隐藏状态,并且被一直传递给解码阶段,而不只是将整个句子编码在一个隐藏状态中。然后,在 RNN 的每一步中都会利用这些隐藏状态进行解码。下面的动图显示了完整的工作流程:


                          绿色显示的步骤被称为编码阶段,而紫色显示的步骤则是解码阶段。

                          这样做的理由是,在一个句子中的每个单词都可能有相关的信息。因此,为了让解码更加精确,模型需要使用注意力机制考虑输入的每一个单词。

                          为了在序列转换任务中将注意力机制引入到 RNN 中,我们将编码和解码分为两个主要步骤。一个步骤用绿色表示,另一个步骤用紫色表示。绿色的步骤被称为编码阶段,紫色的步骤被称为解码阶段。



                          绿色的步骤负责根据从输入中创建隐藏状态。我们没有像在使用注意力之前那样仅仅向解码器传递一个隐藏状态,而是将句子中每个单词生成的隐藏状态都传递给解码阶段。每一个隐藏状态都会在解码阶段被利用,从而找到神经网络应该施加注意力的地方。

                          例如,当把句子「Je suis étudiant」翻译成英文时,就需要解码步骤在翻译时关注不同的单词。


                          这个动图显示了将句子「Je suis étudiant」翻译成英文时,每个隐藏状态被赋予权重的过程。颜色越深,单词的权重就越大。

                          又或者,当你把句子「L’accord sur la zone économique européenne a été signé en août 1992.」从法文翻译成英文时,每个输入被赋予注意力的程度如下图所示:



                          将句子「L’accord sur la zone économique européenne a été signé en août 1992.」翻译成英文。

                          但是使用了注意力机制的 RNN 仍然不能解决一些我们讨论过的问题。例如,并行地处理输入(单词)是不可能的,对于大型的文本语料库来说,这增加了翻译文本要花费的时间。

                          卷积神经网络


                          卷积神经网络对解决这些问题有所帮助。通过卷积神经网络,我们可以:

                          • 轻松做到并行化处理(在每一层中)

                          • 利用局部的依赖

                          • 位置之间的距离是对数函数


                          一些最流行的用于序列转换任务的神经网络架构(如 Wavenet 和 Bytenet)都是基于卷积神经网络的。


                          Wavenet 模型是一种卷积神经网络(CNN)。


                          卷积神经网络能够并行工作的原因是,输入的每个单词都可以被同时处理,而且并不一定需要依赖于之前有待翻译的单词。不仅如此,CNN 的时间复杂度是 log(N)阶的,这是从输出到输入生成的树的高度的大小(如上面的动图所示)。这要比 RNN 的输出到输入之间 N 阶的距离要短得多。

                          但问题是,卷积神经网络并不一定能够帮助我们解决翻译句子时的依赖关系的问题。这也就是「Transformer」模型被创造出来的原因,它是卷积神经网络和注意力机制的结合。


                          Transformer

                          为了解决并行计算的问题,Transformer 试着同时使用卷积神经网络和注意力模型。注意力模型提升了模型将一个序列转换为另一个序列的速度。

                          接下来,让我们看看 Transformer 是如何工作的吧。Transformer 是一类使用注意力机制加速运算的模型。更确切地说,Transformer 使用的是「自注意力机制」。



                          Transformer 的示意图。

                          在内部, Transformer 具有与前面的模型类似的架构。但是 Transformer 是由 6 个编码器和 6 个解码器组成的。


                          每个编码器互相之间都是类似的。所有的编码器都有相同的架构。解码器也都具有相同的特性,即解码器互相之间也很类似。每个编码器由一个「自注意力层」和一个「前馈神经网络」组成。


                          编码器的输入首先会流经一个「自注意力」层。它会帮编码器在对特定的单词进行编码时关注输入句子中其它的单词。解码器也有这两层,但解码器中的自注意力层和前馈神经网络层之间还有一个注意力层,该层会帮助解码器关注输入的句子中相关的部分。



                          自注意力机制


                          注:这一节摘选自 Jay Allamar 的博文(http://jalammar.github.io/illustrated-transformer/)。

                          首先让我们来看看各种向量/张量,以及它们如何在这些组件之间流动,将一个训练过的模型的输入转化成输出。与一般的自然语言处理应用程序一样,我们首先将使用一个嵌入算法将每个输入的单词转换为向量形式。


                          词嵌入示意图

                          每个单词都被嵌入到了一个 512 维的向量中。在本文中,我们将这些向量表示为上图中这样的简单的方框。


                          词嵌入过程仅仅发生在最底部的编码器中。所有的编码器所共有的抽象输入形式是,他们会接受一个 512 维的向量的列表。

                          在底部的编码器中,这种输入是词嵌入,而在其他的编码器中,输入则是紧接着的下一层编码器的输出。在对我们输入序列中的单词进行嵌入后,每个向量都会流经编码器的两层。



                          编码器内部结构示意图

                          这里将开始介绍 Transformer 的一个关键属性:每个位置的单词都会沿着各自的路径流经编码器。在自注意力层中,这些路径之间有相互依赖关系。然而在前馈层中则没有这样的依赖关系,因此可以在流经前馈层时并行处理各种路径。

                          接下来,我们使用一个更短的句子作为例子,看看每个子层中发生了什么。

                          自注意力


                          首先,让我们来看看如何使用向量计算自注意力,然后进一步看看这是如何使用矩阵来实现的。


                          找出一个句子中各单词之间的关系,为其赋予正确的注意力。

                          计算自注意力的第一步是根据每个编码器的输入向量(在本例中,是每个单词的嵌入)创建三个向量。因此,对于每个单词,我们会创建一个查询向量、一个键向量和一个值向量。这些向量是通过将嵌入乘以我们在训练过程中训练出的三个矩阵得到的。

                          请注意,这些新向量的维度比嵌入向量小。其维数为 64,而嵌入和编码器的输入/输出向量的维度为 512。这三个向量不必更短小,这种架构选择可以使多头注意力的计算过程(大部分)保持不变。


                          将 x1 与权值矩阵 WQ 相乘得到与该单词相关的「查询向量」 q1。我们最终为输入句子中的每个单词创建了一个「查询」、「键」和「值」的投影。

                          什么是「查询向量」、「键向量」和「值向量」?

                          这三个向量是对注意力进行计算和思考时非常有用的抽象概念。阅读下面关于注意力计算方法的有关内容,你就会对这些向量的作用有一个很好的认识。

                          计算自注意力的第二步是计算出(某个单词的查询向量与其它单词的键向量相乘)的得分。假设我们正在计算本例中第一个单词「Thinking」的自注意力。我们需要计算出输入句子中每一个单词对于「Thinking」的打分。在我们对某个特定位置上的单词进行编码时,该得分决定了我们应该对输入句子中其它的部分施以多少关注。

                          该得分是通过将查询向量分别和我们正在打分的单词的键向量做点乘得到的。所以,假设我们正在计算位置 #1 的自注意力,第一个得分就是 q1 和 k1 的点积。第二个分数就是 q1 和 k2 的点积。


                          第三步和第四步是将第二步得到的得分除以 8(文中使用的键向量的维度(64)的平方根。这会让我们得到更稳定的梯度。这里也可以除以其它的值,但本文给出的是默认情况),然后将做除法的结果传递给 softmax 运算。Softmax 会将这些分数进行归一化,使它们都为正值,而且加起来等于 1。


                          这个 softmax 处理后的得分决定了每个单词在这个位置上被「表达」的程度。显然,该位置上本身存在的单词会得到最高的 softmax 值,但是有时关注与当前编码单词相关的另一个单词是很有用的。

                          第五步是将每个值向量与 softmax 得分相乘(为对其求和做准备)。这里的直观理解是,将我们想要关注的单词的值维持在较高水平,并且忽略那些不相关的单词(例如,通过将它们的值与 0.001 这样极小的数字相乘)。

                          第六步是对加权值后的值向量求和。该步骤将生成当前编码位置上(第一个单词)的自注意力层的输出。

                          这就是自注意力机制计算过程得到的结果。我们可以将最终得到的向量传递给前馈神经网络。然而,在实际的实现中,为了加快处理速度,这种计算是以矩阵的形式进行的。


                          多头注意力

                          基本上,Transformer 就是这样工作的。但还有一些小的细节可以让它们工作地更好。例如,Transformer 使用了多头注意力机制的概念,而不是仅仅在一个维度上让单词彼此关注。

                          多头注意力机制背后的想法是,每当你翻译一个单词时,你可能会基于你所问的问题的类型对每个单词赋予不同的注意力。下图对这种想法的意义进行了说明。例如,当你翻译句子「I kicked the ball」(我踢了球)时,你可能会问「是谁踢了?」而根据答案的不同 ,将该单词翻译成另一种语言的结果可能会有所变化。或者你也可能会问其它的问题,例如「做了什么?」等等。



                          位置编码

                          Transformer 中另一个重要的步骤就是在对每个单词进行编码的时候加入了位置编码。对每个单词的编码之间都是相互关联的,因为每个单词的位置与其翻译结果相关。


                          原文链接:https://towardsdatascience.com/transformers-141e32e69591


                          本文为机器之心编译,转载请联系本公众号获得授权

                          ✄————————————————

                          加入机器之心(全职记者 / 实习生):hr@jiqizhixin.com

                          投稿或寻求报道:content@jiqizhixin.com

                          广告 & 商务合作:bd@jiqizhixin.com

                            发送中

                            那些一键抠图的软件是怎么做到的?这些语义分割方法了解一下 2019-04-07

                            选自Medium

                            者:Bharath Raj

                            机器之心编译

                            参与:Geek AI、张倩

                            分类问题是为整个图像分配一个标签,而语义分割则是将从属于同一类的对象看成一个整体,为图像中的每一个像素点分配一个标签。本文对一些经典语义分割方法和基于深度学习的语义分割方法进行了讨论,此外还讨论了常见的选择和应用损失函数的方法。



                            语义分割。


                            经典方法

                            在深度学习时代到来之前,大量的图像处理技术被用来将图像分割成一些感兴趣的区域(ROI)。下面列出了一些常用的方法。

                            灰度分割

                            这是最简单的语义分割形式,它包括将一个区硬编码的规则或某个区域必须满足的特定的标签属性赋予这个区域。可以根据像素的属性(如灰度值)来构建这样的规则。「分裂-合并」算法就是一种用到了灰度分割技术的方法。该算法递归地将图像划分成若干子区域,直到可以为划分出的子区域分配一个标签,然后通过合并将相邻的带有相同标签的子区域融合起来。

                            该方法存在的问题是,规则必须是硬编码的。此外,仅使用灰度信息来表示复杂的类(比如人)是极其困难的。因此,需要特征提取和优化技术来恰当地学习这些复杂类所需的表征形式。

                            条件随机场

                            不妨考虑通过训练模型为每个像素分配一个类来分割图像。如果我们的模型不完美,我们可能会得到自然界中可能不存在的带有噪声的分割结果(如图中所示,狗像素与猫像素混合在一起)。


                            带有狗标签的像素和带有猫标签的像素混合的结果(图 c)。图 d 显示了一个更加符合真实情况的分割结果。

                            可以通过考虑像素之间的先验关系来避免这些问题,如果目标是连续的,那么相邻的邻像素往往具有相同的标签。使用条件随机场(CRF)对这样的关系进行建模。

                            CRF 是一种用于结构化预测的统计建模方法。与离散分类器不同,CRF 在进行预测之前可以考虑相邻的上下文环境,比如像素之间的关系。这使得它成为语义分割的理想候选建模方案。本节将探讨把 CRF 用于语义分割的方法。

                            图像中的每一个像素都与一组有限的可能状态相关联。在我们的例子中,目标标签是一组可能的状态。将一个状态(或标签 u)分配给单个像素(x)的成本被称为一元成本。为了对像素之间的关系建模,我们还考虑了将一对标签(u,v)分配给一对像素(x,y)的代价,这被称为成对代价。我们可以考虑相邻的像素对(网格 CRF)或者考虑图像中的所有像素对(密集 CRF)。


                            密集 CRF vs 网格 CRF

                            所有像素的一元成本和成对成本之和被称为 CRF 的能量(或成本/损失)。通过最小化能量,可以得到一个好的分割输出结果。


                            深度学习方法


                            深度学习极大地简化了进行语义分割的工作流程,并且得到了非常好的分割结果。在本节中,我们将讨论用于训练这些深度学习方法的流行的模型架构和损失函数。

                            1. 模型架构

                            全卷积网络(FCN)是最简单、最流行的用于语义分割的架构之一。在论文「
                            FCN for Semantic Segmentation」中,作者使用 FCN 首先通过一系列卷积操作将输入图片下采样至一个较小的尺寸(同时得到更多的通道)。这组卷积操作通常被称为编码器(encoder)。然后通过双线性插值或者一系列转置卷积对编码后的输出进行上采样。这组转置卷积通常被称为解码器(decoder)。


                            FCN 中的下采样和上采样过程。

                            尽管这个基础的架构很有效,但是它也有一些缺点。其中一个缺点就是由于转置卷积(或称反卷积)操作的输出不均匀重叠而导致棋盘状伪影的存在。


                            棋盘状伪影的形成过程。

                            另一个缺点是,由于编码过程中损失了一部分信息,导致边界的分辨率很低。

                            研究人员提出了一些解决方案来提高基础 FCN 模型的性能。下面是一些被证明行之有效的流行的解决方案:

                            U-Net

                            U-Net 是对简单的 FCN 模型架构的一种升级方案。它具有从卷积块的输出到相应的同一级的转置卷积块的输入之间的跳跃连接。


                            U-Net

                            这种跳跃连接让梯度可以更好地流动,并提供了来自多个尺度的图像大小的信息。来自更大尺度(较上层)的信息可以帮助模型更好地分类。来自更小尺度(较底层)的信息可以帮助模型更好地进行分割。

                            Tiramisu 模型

                            Tiramisu 模型类似于 U-Net,而不同的是,它使用 Dense 块进行卷积和转置卷积(正如 DenseNet 的论文中所做的那样)。一个 Dense 块由若干层卷积组成,其中所有较早的层的特征图会被用作所有后续层的输入。生成的网络具有极高的参数效率,可以更好地利用较早的层的特征。


                            Tiramisu 网络

                            这种方法的缺点是,由于几个机器学习框架中的连接操作的性质,它的内存效率不是很高(需要大型 GPU 才能运行)。

                            多尺度方法

                            一些深度学习模型显式地引入了整合来自多个尺度的信息的方法。例如,金字塔场景解析网络(PSPNet)使用四种不同尺寸的卷积核和步长来执行池化操作(最大池化或平均池化),从而输出卷积神经网络(如 ResNet)的特征图。然后,它使用双线性插值对所有池化输出和卷积神经网络的输出特征图的尺寸进行上采样,并在相应的通道上将它们连接起来。最后对这个连接的输出进行卷积操作从而生成预测结果。


                            PSPNet

                            Atrous  卷积(膨胀卷积)是一种可以在不增加大量参数的情况下,结合多尺度的特征的高效的方法。通过调节膨胀率(dilated rate),同一个卷积核的权值可以在空间中拓展地更远。这使其能够学习更多的全局上下文。


                            级联的 Atrous 卷积。

                            DeepLabv3 网络的论文使用了不同膨胀率的Atrous 卷积捕获来自多个尺度的信息,从而避免了显著的图像尺寸损失。他们通过级联的方式(如上图所示)和以并行的 Atrous 空间金字塔池化的方式(如下图所示)对 Atrous 卷积进行了实验。


                            并行的 Atrous 卷积。

                            CNN-CRF 的混合方法

                            一些方法使用卷积神经网络作为特征提取器,然后将特征作为一元成本(势)输入给密集 CRF(Dense CRF)。由于CRF具有对像素间关系建模的能力,这种 CNN-CRF 的混合方法得到了很好的分割结果。


                            使用 CNN  和 CRF 相结合的方法。

                            某些方法将 CRF 包含在了神经网络中,正如「CRF-as-RNN」(https://www.robots.ox.ac.uk/~szheng/papers/CRFasRNN.pdf)一文中所描述的,其中密集 CRF被建模为一个循环神经网络。这种端到端的训练如上图所示。

                            2. 损失函数

                            和一般的分类器不同,语义分割必须选择不同的损失函数。下面是一些常用的语义分割损失函数。

                            通过交叉熵实现的像素级 softmax用于语义分割的标签尺寸与原始图像相同。标签可以用one-hot编码的形式表示,如下图所示:


                            语义分割的独热编码形式

                            由于标签以方便的one-hot编码的形式存在,它可以直接被用作计算交叉熵的参考标准(目标)。然而,在应用交叉熵之前,必须对预测的输出在像素级上应用 softmax,因为每个像素可能属于我们的任何一种目标类。

                            焦点损失(Focal Loss)

                            《Focal Loss for Dense Object Detection》一文中介绍的焦点损失是对标准的交叉熵损失的一种改进,用于类别极度不平衡的情况。

                            让我们看看如下图所示的标准交叉熵损失方程(蓝色)。即使在我们的模型对像素的类的置信度很高的情况下(比如 80%),它也存在一定的损失值(这里大约是 0.3)。另一方面,当模型对一个类的置信度很高时,焦点损失(紫色,gamma=2)不会对模型造成如此大的影响(即置信度为 80% 的情况下损失接近于 0)。


                            标准的交叉熵损失(蓝色曲线)vs 带有 gamma 变量的焦点损失

                            让我们用一个直观的例子来探究一下为什么这很重要。假设我们有一个 10000 像素的图像,像素只有两个类:背景类(one-hot编码形式下表示为 0)和目标类(one-hot编码形式下表示为 1)。假设图像的 97% 是背景,3% 是目标。现在,假设我们的模型以 80% 的置信度确定某像素是背景,但只有 30% 的置信度确定某像素是目标类。

                            使用交叉熵时,背景像素损失等于 (10000 的 97%)*0.3 = 2850,目标像素损失等于(10000 的3%)* 1.2 = 360 。显然,由于置信度更高的类造成的损失占主导地位,模型学习目标类的动机非常低。相比之下,对于焦点损失,由于背景像素的损失等于(10000 的 97%)* 0,即0。这让模型可以更好地学习目标类。

                            Dice 损失

                            Dice 损失是另一种流行的损失函数,用于类极度不平衡的语义分割问题。Dice 损失在《V-Net: Fully Convolutional Neural Networks for Volumetric Medical Image Segmentation 》一文中被提出,它被用于计算预测出的类和真实类之间的重叠。Dice 系数(D)如下所示:

                            Dice 系数

                            我们的目标是最大化预测类和真实参考标准之间的重叠部分(即最大化 Dice 系数)。因此,我们通常将(1-D)最小化来实现相同的目标(由于大多数机器学习程序库只提供最小化损失函数的操作)。


                            Dice 系数的求导过程

                            虽然 Dice 损失对类不平衡的样本很有效,但计算其导数的公式(如上所示)在分母中有平方项。当这些值很小时,我们就可以得到很大的梯度,导致训练不稳定。


                            应用场景


                            语义分割技术被用于了各种各样的真实生活场景下的应用。下面是语义分割的一些重要的用例。

                            自动驾驶

                            语义分割用于识别车道、车辆、人和其他感兴趣的物体。其结果可用于智能决策,以正确引导车辆。


                            用于自动驾驶汽车的语义分割。

                            自动驾驶汽车的限制之一是:语义分割模型必须是实时运行的。解决上述问题的一个方法是将 GPU 与车辆进行本地集成。为了提高上述解决方案的性能,可以使用更轻量级(参数更少)的神经网络,或实现适用于边缘计算的技术。

                            医学影像分割

                            语义分割技术也被用于在医学扫描影像中识别显著性元素。该方法对识别图像中的异常(如肿瘤)十分有效。提升算法的准确率并解决低召回率的问题对于这种应用十分重要。


                            医学扫描影像的分割

                            我们还可以将一些不那么关键的操作自动化处理,比如根据语义分割后的 3D 扫描影像估计器官的体积。

                            场景理解

                            语义分割通常是更复杂任务的基础,如场景理解和可视化问答(VQA)。场景理解算法的输出通常是一个场景图或一段字幕。


                            场景理解的工作示意图。

                            时尚产业

                            语义分割在时尚产业中被用来从图像中提取出服装对象,为零售商店提供类似的建议。更先进的算法可以在图像中「重新设计」特定的衣服。


                            语义分割被用来作为根据输入文本重新为某人设计衣服的一个中间步骤。

                            卫星(或航拍)图像处理

                            语义分割还被用于从卫星图像中识别土地类型。典型的用例包括对水体进行分割以提供准确的地图信息。其他高级用例包括绘制道路图、确定作物类型、确定免费停车位等等。


                            卫星/航拍图像的语义分割结果。


                            结语


                            深度学习技术极大地提升并简化了语义分割算法,为语义分割在现实生活中更广泛的应用铺平了道路。由于研究社区不断努力地提高这些算法的准确性和实时性能,本文中列举出的概念可能并不详尽。话虽如此,本文介绍了这些算法的一些流行的变体和他们在现实生活中的一些应用。


                            原文链接:https://medium.com/beyondminds/a-simple-guide-to-semantic-segmentation-effcf83e7e54?sk=3d1a5a32a19d611fbd81028cfd4f23fd


                            本文为机器之心编译,转载请联系本公众号获得授权

                            ✄————————————————

                            加入机器之心(全职记者 / 实习生):hr@jiqizhixin.com

                            投稿或寻求报道:content@jiqizhixin.com

                            广告 & 商务合作:bd@jiqizhixin.com

                              发送中

                              SysML 2019论文解读:视频分析系统的提升 2019-04-07

                              机器之心原创

                              者:Andy Xiong
                              参与:Hao Wang、Panda

                              SysML 2019 已于 3 月 31 日-4 月 2 日在斯坦福成功举办,本文将解读两篇在高效视频分析方面的研究。

                              系统与机器学习会议(SysML)是一个非常新的会议(始于 2018 年),针对的是系统与机器学习的交叉领域。该会议的目标是引出这些领域之间的新联系,包括确定学习系统的最佳实践和设计原理,以及为实际机器学习工作流程开发全新的学习方法和理论。

                              前言

                              随着视频摄像头的日益普及,视频分析也吸引到了很多研究关注。因为目标检测语义分割等大多数计算机视觉任务都需要密集的计算,所以有必要设计出在软件开发和硬件实现方面都高效的系统。下面介绍两篇遵循这些思想解决视频分析问题的论文。

                               

                              第一篇论文提出了 Filter-Forward,这是一种新的边缘计算到云计算(edge-to-cloud)系统,能通过安装仅回传相关视频帧的轻量级边缘滤波器让基于数据中心的应用有能力处理数千个摄像头的内容。第二篇论文提出了 FixyNN,其包含一个用于生成通用的 CNN 特征的固定权重的特征提取器,还有一个用于处理特定数据集的 CNN 的典型的可编程 CNN 加速器。

                               

                              声明:本文的所有图片和公式都来自于原论文。

                               

                              • 论文1:Scaling Video Analytics on Constrained Edge Nodes

                              • 地址:http://www.sysml.cc/doc/2019/197.pdf

                               

                              引言

                               

                              为了有效实现交通流量监控和行人检测等应用,需要解决两个问题:视频流是广角的且相关数据稀少,而数据中心需要高分辨率视频流来进一步处理。在这篇论文中,研究者设计了一个名为 FilterForward(FF)的系统,能为广域视频处理提供边缘计算和基于数据中心的方法的双重优势。FilterForward 引入了快速且表现力强的每应用(比如「向我发送包含狗的序列」)「微分类器」(MC)来识别与数据中心应用最相关的视频序列(过滤)并仅将匹配的事件传输给数据中心以便进一步分析(转发)。

                               

                              FilterForward 架构


                              大多数边缘计算到云计算的视频分析系统都面临着三个关键挑战:带宽限制、检测现实视频中的微妙细节、支持许多并发应用。为了解决这些难题,FilterForward 为应用提供了将工作划分成边缘和云两部分的灵活性,即在边缘利用高质量的数据为云提供相关的视频序列。图 1 给出了 FilterForward 的整体架构。FilterForward 的两个主要组件是特征提取器和微分类器。

                               

                              特征提取器的输入是实时的相机帧,并使用深度神经网络(DNN)提取一些常见的特征。每应用微分类器共享特征提取器,以在计算有限的边缘节点上同时检测数十个事件(就像语义滤波器)。微分类器是轻量级的二元分类神经网络,其以基础 DNN 提取的特征图为输入,输出一个帧与一个特定应用相关的概率。FilterForward 能通过并行地评估许多微分类器来扩展到许多独立的应用(比如找到狗或找到自行车)。

                               

                              为了以不同方式解决广角监控视频的难题,研究者在这篇论文中提出了三种定制的微分类器架构:全帧目标检测器(Full-frame Object Detector)、局部化二元分类器(Localized Binary Classifier)以及窗口化的局部化二元分类器(Windowed, Localized Binary Classifer);如图 2 所示。一方面,这些设计可以操作来自各种基础 DNN 层的激活,以关注它们各自任务的适当特征;另一方面,还可以选择裁剪掉帧中不相关的区域。

                               

                              全帧目标检测器微分类器的建模方法跟随了 SSD 和 Faster R-CNN 等滑动窗口式目标检测器,其在卷积层特征图的每个位置都应用一个小型的二元分类 DNN,然后将检测结果聚合起来得到全局预测。

                               

                              局部化二元分类器微分类器包含两个单独的卷积层和一个全连接层,可以处理空间上裁剪的特征图,比如检测局部化区域内的突出目标(即,比如缩放到原始帧的一个区域)。

                               

                              窗口化的局部化二元分类器微分类器是对局部化二元分类器微分类器的扩展,是为了通过指定 W 帧的时间窗口来集成临近的时间背景信息,从而提升每帧的准确度。

                               

                              评估

                               

                              FilterForward 系统的主要目标是在实现高过滤准确度的同时限制带宽用量并可扩展到多个应用。研究表明,FilterForward 能够通过在微分类器之间共享计算而在商用硬件上实现较高帧率,同时还能在两个事件检测任务上维持较高的事件级准确度。研究者在两个真实世界的相机流数据集上进行了评估,结果表明 FilterForward 在高难度的视频内容上能够提升计算效率和事件检测准确度,同时还能显著降低网络带宽的使用。


                               数据集

                               

                              为了在真实世界的监控任务上评估所提出的 FilterForward 系统,研究者收集了两组真实世界视频。第一个数据集的视频来自怀俄明州杰克逊霍尔的一个交通摄像头(Jackson 数据集)。第二个数据集是来自一个城市街道的两段三小时长的视频(Roadway 数据集)。图 3 给出了这些数据的细节。

                               

                              以事件为中心的指标:事件 F1 分数

                               

                              大多数分类指标都以每帧为基础,而 FilterForward 则是以事件为中心的。研究者针对跨越多帧的事件采用了来自近期研究工作的一个修改版的召回(recall)指标。对于事件 i,所得到的 EventRecall_i 指标衡量的是两个成功度度量:

                               

                              • Existence_i 奖励的是至少检测到一个事件的一帧

                              • Overlap_i 奖励的是检测到一个事件的更大比例的帧

                              其中 R_i 和 P_i 分别是基本真值和预测的事件范围。EventRecall 是 Existence 和 Overlap 的线性组合。作者选择了 α = 0.9 和 β = 0.1 的配置,说明更看重检测到每个事件的单帧。

                               

                              与此同时,研究者还将标准的精度(预测的帧占真正例中的比例)与修改过的 EventRecall 定义结合起来计算了一个事件 F1 分数——精度和召回的调和平均值,并在整个评估阶段使用了这一指标。

                               

                              节省广域带宽

                              FilterForward 的主要目标是节省边缘计算到云计算的带宽。图 4 展示了在 Roadway 数据集上两种微分类器架构(全帧二元分类器和局部化二元分类器)的带宽用量和事件 F1 分数,并对比了压缩整个数据流的方法。对于这两种微分类器,相比于高质量地将整个视频流发送回数据中心,FilterForward 可将网络带宽降低接近一个数量级。

                               

                              端到端的性能可扩展性

                              为了评估性能可扩展性以及展示微分类器的低边际成本,作者对比了三种微分类器与另外两种过滤技术:直接运行一个完全 DNN(MobileNet)的多个实例以及训练专门的像素级分类器。图 5 展示了 FilterForward 的三种微分类器架构以及多 DNN 和 NoScope 式离散分类器(DC)的过滤吞吐量。离散分类器比通用型分类 DNN 速度更快,但成本比微分类器更高。

                               

                              结果表明,当分类器的数量较低时(大约少于 4),离散分类器有更高的吞吐量,因为此时基础 DNN 的成本在 FilterForward 占主导。一旦 FilterForward 运行的微分类器数量大约 4,其计算共享的设计就能达到成本摊销的突破点。而运行多个 DNN 一直都更加低效,并且在超过 35 个实例后就会耗尽内存。


                              为了进一步理解 FilterForward 的吞吐量可扩展性,研究者还衡量了基础 DNN 和微分类器在每帧上所用的时间。图 6 展示了三种新提出的微分类器架构的细分结果。在查询较少时,基础 DNN 的执行时间占主要,这在意料之中。但即使增加数十个并发的微分类器,总的执行时间也只会适量增长。在最坏的情况下,基础 DNN 的 CPU 时间基本等于 20 个微分类器的时间。

                              微分类器的成本和准确度

                              图 7 展示了微分类器和离散分类器在两个真实世界数据集上的准确度(使用事件 F1 分数)和计算成本(以乘法-加法的数量衡量)。实验结果表明,微分类器的边际成本比离散分类器低得多,并且还能实现更高的准确度。

                               

                              总结

                              这篇论文解决的问题是:基于数据中心的应用需要高保真的视频序列,而每个相机又只有有限的带宽。通过设计一种混合式边缘计算到云计算的 FilterForward 系统,微分类器可以在真实世界计算机视觉任务上实现更高准确度的同时降低计算成本。作者相信 FilterForward 的混合式边缘计算到云计算设计能够为迅猛发展的智能摄像头部署提供重要的构建模块。


                              但是,FilterForward 的原型版本还存在一些局限性。首先,每个微分类器仅使用了单层的特征图。而某些分割任务需要来自多层的多个尺度的特征,这还没有得到解决。其次,对每个应用而言,找到选择哪一层作为每个分类器的输入对结果非常重要。而在这篇论文中,作者只是基于两个简单的启发而人工选择了一层,这方面还有改进空间。最后,和大多数边缘计算系统一样,FilterForward 可能存在中断时间更长以及数据可能丢失或损坏的风险。

                               

                              • 论文2:FixyNN-Efficient Hardware for Mobile Computer Vision via Transfer Learning

                              • 地址:http://www.sysml.cc/doc/2019/69.pdf

                              引言


                              目标检测/跟踪和语义分割等实时计算机视觉(CV)任务是人脸跟踪和人体分割等移动计算应用的关键使能技术。但是,实时计算机视觉应用日益增长的准确度需求与移动设备的功率限制之间存在一道能量效率的鸿沟。为了填平这道能效鸿沟,目前有两大主要研究趋势:MobileNet 等更高效的卷积神经网络(CNN)架构以及专用硬件加速器。

                               

                              这篇论文设计的 FixyNN 是这两个趋势的融合,采用了硬件与 CNN 的联合设计方法来实现基于移动设备的 CV 应用的 CNN 推断。FixyNN(如图 1 所示)将 CNN 分成了两部分。第一部分是为多个不同的任务或数据集生成常见的低层面 CNN 特征。第二个部分提供特定于任务的 CNN 后端。然后,其前端层被实现成一种经过深度优化的固定权重的特征提取器(FFE)硬件加速器,后端部分则因为特定于具体任务,需要在典型的可编程 CNN 硬件加速器上实现。


                              固定权重特征提取器的硬件设计


                              在这篇论文中,FixyNN 结合了两个专用硬件加速器:一个深度优化的固定权重特征提取器(FFE)和一个更传统的可编程 CNN 加速器。在硬件中固定权重方面有五项主要的优化:固定的移位加法缩放器、零开销权重剪枝、经过优化的中间精度、零 DRAM 带宽、最小激活存储。固定全并行的、全流水线式的 FFE 加速器中卷积(CONV)层的权重能为 FFE 实现很多激进的硬件优化,使其在吞吐量和能效方面优于传统的可编程加速器。FFE 的硬件设计可以描述为以下三个层级:

                               

                              1.完全并行式固定权重* CNN *数据路径:*如图 2 所示,每个卷积层的计算都可实现为扁平的、全并行的、经过剪枝的固定权重算术逻辑层级。替代乘法器的固定缩放器是由综合工具(synthesis tool)生成的,而权重的嵌入方式则与 Verilog 硬件描述语言(HDL)完全一样。在卷积层之后的是批归一化、ReLU 和量化算子。

                               

                              2.全流水线式 CNN 缓冲:传统的可编程 CNN 加速器通常是通过将卷积转换成通用矩阵乘法(GEMM)来以串行方式计算 CNN;相对而言,FFE 是使用全流水线式的 CONV 层实现本地卷积。图 3 给出了一个核大小为 3×3 的简单卷积层的全流水线式排布概况。这个缓冲功能是使用一个 SRAM 行缓冲器(line buffer)实现的,其中逐行存储了每一层的激活,直到达到所需的张量大小。在 SRAM 行缓冲器之后是一个基于触发器(flip-flop)的移位寄存器,可使得卷积窗口在特征图上有效地移动,而无需重新读取数据。


                              3.DeepFreeze 工具流程:研究者开发了一个名为 DeepFreeze 的开源工具来帮助实现可能带有数百万个硬编码的权重的 FFE 加速器。给定一个标准机器学习软件框架(比如 TensorFlow)导出的模型,DeepFreeze 工具流程能够为一组特定的层生成 Verilog HDL 代码等固定的 CNN 硬件加速器设计,如图 4 所示。

                               

                              实验结果


                              为了评估 FixyNN,研究者执行了硬件建模与迁移学习实验。硬件建模部分是比较 FixyNN 与当前最佳的硬件加速器设计的硬件性能。另一方面,为了展示固定特征提取器方法的泛化能力,研究者设计了两组包含一系列任务的实验,其分别使用了 MobileNetV1-0.25 和 MobileNetV1-1.0 来执行。MobileNetV1 首先在 ImageNet 数据集上进行了训练,然后在迁移到其它视觉任务。

                              硬件

                               FixyNN 包含两个硬件组件:FFE 和可编程的 CNN 加速器。其中 FFE 使用 DeepFreeze 工具流程生成。可编程加速器基于在英伟达深度学习加速器(NVDLA)上发表的结果,这是一种当前最佳的开源的神经网络加速器,使用了 Verilog RTL 进行硬件实现,使用了 TLM SystemC 仿真模型进行软件开发、系统集成和测试。表 1 给出了硬件资源六种标称配置的已发表的 NVDLA 性能结果。


                              首先,研究者比较了 FFE 和可编程 NVDLA 加速器在 MobileNet-0.25 的 13 层中每一层上的吞吐量(TOPS)和能效(TOPS/W),如图 5 所示。很明显,FFE 在所有方面都优于 NVDLA,在 TOPS 和 TOPS/W 上分别实现了 8.3 和 68.5 倍的提升。

                               

                              但是,FFE 所需的硅面积实际上会对层的数量带来限制。图 6 给出了在使用不同大小的 MobileNet 网络时,FFE 的面积随固定层的数量的变化情况。因此 FixyNN 的关键点是平衡 FFE 和可编程加速器之间的层分布,从而在给定硅面积约束的条件下最大化能效和泛化能力。


                              在演示了固定特征提取器在单个个体层上的优势之后,研究者又展示了实际的 FixyNN 系统。类似地,其基线是一个没有固定层的完全可编程 NVDLA 加速器,其代表了当前最佳。


                              在吞吐量方面(图 7a),在预算面积小时,基线 NVDLA 的表现优于 FixyNN,因为此时 FFE 严重受制于可编程 NVDLA 的瓶颈。但是在预算面积更大时,FixyNN 可以固定更多层,在吞吐量上获得更大增益。而在能效方面(图 7b),由于数据复用和其它分摊的增加,基线 NVDLA 一开始能很好地随面积扩展,但随着在利用内存带宽方面的限制出现,增益会出现饱和(甚至回落)。由于 FFE 能效出色,当从 NVDLA 向 FFE 转移的负载增多时,能效也会随之提升。

                               

                              表 2 展示了在不同的设计条件下,图 7 的设计空间中的帕累托最优 FixyNN 配置。



                              此外,这篇论文还调查了在面积预算为 2-3 mm²(有 11 个固定层和 NVDLA 配置 C)时能效最优的配置。图 8 给出了 FFE 和可编程 NVDLA 之间的功率、性能和面积(PPA)细分结果。图中表明固定的数据路径占据了较大部分的面积和网络中较多的运算,但却仅占消耗能量和延迟的一小部分。



                              模型准确度


                              表 3 给出了在 MobileNet-0.25 上使用 FFE 的第一组迁移学习实验结果。MobileNet-0.25 首先在 ImageNet 上经过训练,然后再迁移到六个不同的视觉任务(CIFAR100、CIFAR10、SVHN、 Flwr、Airc 和 GTSR)。该网络中有更高的比例是固定的,也使用了更大的 FFE。第一行有 0 个固定层的结果是基线结果。

                               

                              表 4 给出了 MobileNet-1.0 的迁移学习准确度,它也首先在 ImageNet 上进行了训练,然后再迁移到 CIFAR-100。可以观察到其迁移学习准确度损失有类似的趋势。整体而言,这里的准确度比上面的更高,因为 MobileNet-1.0 模型本身能力更强。固定网络的前 11 个卷积层并使用自适应批归一化(BN)只让准确度下降了 1.6%。

                               


                              总结


                              由于基于深度学习的模型计算量很大,传统的移动系统芯片(SoC)无法达到流畅运行深度学习模型所需要的性能。而目前市面上已有的硬件加速方案主要有(1)GPU:计算效率高,但功耗太大,价格昂贵;(2)FPGA:功耗低,但单颗性能低、导致总体性价比低,另外从业人员少,大规模开发难度高;(3)ASIC:效率能耗比,但不可更改任务,从而增大了普及难度。

                               

                              这篇论文提出的 FixyNN 是一种更紧密整合计算机系统和机器学习的解决方案。通过将 DNN 分成两部分,一部分使用高度定制的硬件来提取 CNN 特征,另一部分是可编程的,使用迁移学习泛化到不同的计算机视觉任务,FixyNN 有能力实现能效的最优平衡。实验评估表明,FixyNN 硬件可以实现比 iso-area 可编程加速器更好的能效。

                              SysML 2019提前看:神经网络安全性

                              本文作者为机器之心特邀技术分析师 Andy Xiong,他热爱人工智能和计算神经科学领域,乐观相信深度强化学习能帮助人类更接近实现通用人工智能。目前从事计算机视觉、图形学相关工作,欢迎交流。

                              本文为机器之心原创,转载请联系本公众号获得授权

                              ✄————————————————

                              加入机器之心(全职记者 / 实习生):hr@jiqizhixin.com

                              投稿或寻求报道:content@jiqizhixin.com

                              广告 & 商务合作:bd@jiqizhixin.com

                                发送中

                                浅显易懂!「高中数学」读懂梯度下降的数学原理 2019-04-07

                                选自towardsdatascience

                                者:Parul Pandey

                                机器之心编译

                                参与:Panda

                                梯度下降是最常用的机器学习优化算法之一,Towards Data Science 近日发布了一篇文章,浅显易懂地解释了梯度下降的原理和工作过程。

                                 

                                「过早优化是罪恶之源。」

                                ——计算机科学家和数学家 Donald Ervin Knuth

                                 

                                敏捷(agile)是软件开发过程中的一个广为人知的术语。其背后的基本思想很简单:快速构建出来→发布它→获得反馈→基于反馈进行修改→重复这一过程。这种做法的目标是让产品亲近用户,并让用户通过反馈引导你,以实现错误最少的可能最优的产品。另外,改进的步骤也需要很小,并且也应该让用户能持续地参与进来。在某种程度上讲,敏捷软件开发过程涉及到快速迭代。而梯度下降的基本过程也差不多就是如此——尽快从一个解开始,尽可能频繁地测量和迭代。

                                 

                                目标

                                 

                                梯度下降算法是一个迭代过程,能让我们得到一个函数的最小值(这里先不提一些额外的注意事项)。下面的公式将整个梯度下降算法汇总成为了一行:

                                 


                                但我们是怎么得到这个公式的?实际上很简单,而且仅包含一些高中数学知识(小编:海外高中数学?捂脸)。我们希望能通过这篇文章在线性回归模型的背景中理解和再现这一公式。

                                 

                                一个机器学习模型

                                 

                                设有一些在一个 2D 空间中的数据点。假设这些数据与一组学生的身高和体重有关。我们希望预测这些量之间的某种关系,以使我们可以预测未来某个新学生的体重。这本质上是监督式机器学习技术的一个简单案例。

                                 

                                现在,让我们在空间中画一条任意的线,并使其穿过某些数据点。那么这条线的方程即为 Y = mX + b,其中 m 是斜率,b 是这条线在 Y 轴上的截距。

                                 

                                预测

                                 

                                给定一组已知的输入和它们对应的输出。机器学习模型会尝试基于这些数据预测新输入的输出结果。

                                 

                                机器学习过程

                                 

                                误差(Error)即为两个预测结果之间的差异。

                                 


                                与其相关的概念是成本函数或损失函数。

                                 

                                成本函数

                                 

                                成本函数/损失函数评估的是我们的机器学习算法的性能表现。损失函数计算的是单个训练样本的误差,成本函数则是损失函数在整个训练集上的平均。因此,我会交替地使用这两个术语。

                                 

                                基本上而言,成本函数能告诉我们在给定了 m 和 b 的值时模型在预测方面的表现「有多好」。

                                 

                                比如说,如果数据集中共有 N 个点,而对于所有这 N 个数据点,我们希望最小化其误差。因此成本函数就将是总平方误差,即:

                                 

                                N 个数据点的成本函数

                                 

                                为什么我们要用平方差而不直接使用绝对差呢?因为平方差能让我们更轻松地推导出一条回归线。实际上,为了找到那条线,我们需要计算成本函数的一阶导数,而计算绝对值的倒数比计算平方值的导数要难得多。

                                 

                                最小化成本函数 

                                任何机器学习算法的目标都是最小化成本函数。

                                 

                                这是因为实际值和预测值之间的误差越低,就说明算法在学习上的表现就越好。因为我们希望得到最低的误差值,所以我们希望这些m 和 b 值所得到的误差尽可能最小。

                                 

                                我们究竟如何最小化任意函数?

                                 

                                仔细观察,我们的成本函数是 Y=X² 的形式。在笛卡尔坐标系中,这是一个抛物线方程,可以画成下图形式:

                                 

                                抛物线

                                 

                                要最小化上述函数,我们需要找到能得到最低 Y值的 X 值,即红点位置。因为这是一张2D 图,所以定位其最小值很容易,但在更高维度上情况却非如此。在这些情况下,我们需要设计一个能定位最小值的算法,这个算法就是梯度下降。

                                 

                                梯度下降

                                 

                                梯度下降是最常用的优化算法之一,也是目前最常用的优化神经网络的方式。这是一种用于寻找函数最小值的迭代式优化算法。

                                 

                                直观理解

                                 

                                假设你正沿着下面的图行走,而且目前正位于绿点位置。你的目标是到达最小值,即红点位置;但在你的位置处,你无法看到最小值在哪里。

                                 


                                可能的动作会是这样:

                                 

                                • 你可能向上或向下

                                • 如果你决定了要走的方向,为了到达目的地,你可能跨一大步,也可能走一小步。

                                 

                                本质上讲,为了到达最小值,你应该知道两件事:走哪条路和步子迈多大。

                                 

                                梯度下降算法可使用导数帮助我们有效且高效地做这些决定。导数是源自微积分的一个术语,可作为图在特定点的斜率而进行计算。所以,如果我们有能力计算这条切线,我们可能就能够算出为到达最小值所应选择的方向。我们将在后文更详细地介绍这一点。

                                 

                                最小值

                                 

                                在上图中,我们可以在绿点画一条切线,我们知道,如果我们向上移动,我们就将远离最小值或者反过来。另外,这条切线也能让我们了解斜率的陡峭程度。

                                 

                                蓝点处的斜率没有绿点处陡,这意味着从蓝点到达最小值所需的步幅比在绿点处要小得多。

                                 

                                成本函数的数学解释

                                 

                                现在,让我们将上面介绍的一切写成数学公式。在等式 y = mX+b 中,m 和 b 是其参数。在训练过程中,它们的值会进行较小的变化。我们将这个小变化表示成δ。参数的值将分别以m=m-δm和 b=b-δb 的方式更新。这里我们的目标是找到y=mx+b 中能使误差最小的 m 和 b 值,即最小化成本函数的值。

                                 

                                重写成本函数:

                                 

                                其思想是,通过计算函数的导数和斜率,我们可以找到该函数的导数/斜率。

                                 

                                学习率

                                 

                                到达最小值或底部的步幅大小被称为学习率。更大的步幅/更高的学习率可以覆盖更大区域,但却有越过最小值的风险。另一方面,更小的步幅/更低的学习率到达最低点需要消耗大量时间。

                                 

                                下面的图片展示了学习率的概念。在第三张图中,我们用最少的步骤到达了最小值。这是这一问题的最佳学习率。


                                可以看到,当学习率过低时,需要很多步骤才能收敛。而当学习率过高时,梯度下降将无法到达最小值,如下图所示。

                                 

                                 

                                不同学习率的实验结果可参考:https://developers.google.com/machine-learning/crash-course/fitter/graph。

                                 

                                导数

                                 

                                机器学习在优化问题中使用导数。梯度下降等优化算法使用导数来实际决定是增大还是减小权重,以增大或减小目标函数。

                                 

                                如果我们可以计算出一个函数的导数,我们就会知道要继续的方向就是最小化该函数的方向。我们主要是处理两个来自微积分的概念:

                                 

                                幂规则

                                 

                                幂规则计算的是提升成幂的变量的导数。

                                 

                                链式法则

                                 

                                链式法则用于计算复合函数的导数。链式法则可以使用莱布尼兹符号表示如下:

                                 

                                如果变量 z 依赖于变量 y,而变量 y 又依赖于变量 x,则 y 和 z 是因变量,而且 z 也通过中间变量依赖于 x。这被称为链式法则,用数学式可写成:

                                 

                                让我们通过一个例子来理解:

                                 

                                将幂规则和链式法则用于导数,我们可以计算成本函数相对于 m 和 b 的变化方式。这涉及到偏导数的概念,即如果一个函数有两个变量,则寻找该函数相对于一个变量的偏导数的方法是将另一个变量视为常量。用例子解释会更清楚:

                                 

                                计算梯度下降

                                 

                                现在我们将这些微积分规则应用于我们原来的等式,并找到成本函数相对于 m 和 b 的导数。重访成本函数:


                                为了简单,让我们摆脱其中的求和符号。这个求和部分很重要,尤其是涉及到随机梯度下降(SGD)与批梯度下降的概念时。在批梯度下降的过程中,我们一次性检查所有训练样本的误差;而在 SGD 过程中,我们每次检查每个误差。但是,为了简单起见,我们假设我们每次检查每个误差。

                                 

                                 

                                现在,我们来计算与 m 和 b 相关的误差的梯度:

                                 

                                将这些值放回成本函数,并将其与学习率相乘:



                                现在,这个等式中的 2 并不是那么重要,因为它只是表示我们的学习率有两倍或一半那么大。所以我们直接丢掉它。因此,最终这整篇文章都浓缩成了两个表示梯度下降的简单等式。

                                 

                                m¹,b¹ = 下个位置参数;m⁰,b⁰ = 当前位置参数。

                                 

                                因此,为了求解梯度,我们使用新的 m 和 b 值迭代我们的数据点并计算偏导数。这个新梯度能指出成本函数在当前位置的斜率以及我们应该移动的方向,以便更新我们的参数。我们的更新的大小受学习率控制。

                                 

                                总结

                                 

                                这篇文章的目的是展示梯度下降的概念。我们使用了梯度下降作为线性回归的优化策略。通过绘制最佳拟合线来测量学生身高和体重之间的关系。但是,需要重点指出,这个线性回归示例是为了演示简单而选择的,梯度下降也可用于其它机器学习技术。


                                原文链接:https://towardsdatascience.com/understanding-the-mathematics-behind-gradient-descent-dde5dc9be06e


                                本文为机器之心编译,转载请联系本公众号获得授权

                                ✄————————————————

                                加入机器之心(全职记者 / 实习生):hr@jiqizhixin.com

                                投稿或寻求报道:content@jiqizhixin.com

                                广告 & 商务合作:bd@jiqizhixin.com

                                  发送中

                                  INTERFACE # 13 这周六,线下学习图神经网络 2019-04-08

                                  图神经网络是当前机器学习领域最前沿的研究方向之一。不久之前,阿里巴巴开源大规模分布式图表征学习框架 Euler,可支持数十亿点、数百亿边的大规模异构图表征学习,也内置了大量高效的图神经网络算法。为了方便读者们进一步了解图神经网络在工业界的应用,本期 INTERFACE 邀请到了两位阿里巴巴专家,从算法到工程,为大家做精彩的分享。

                                  主题:Euler:大规模图神经网络推高人工智能的天花板

                                  演讲摘要:在过去几年,深度学习技术在工业界被广泛应用并产生了巨大的技术红利,业界也在积极思考和探索如何进一步拓展人工智能的边界。图神经网络将端到端学习与归纳推理相结合,有望解决深度学习无法处理的关系推理、可解释性等一系列问题。对结构知识的表达、计算和组合泛化是实现具备 human-likeAI 的关键,图神经网络有希望在这些方面形成突破,使得机器能力进一步提升。

                                  Euler (https://github.com/alibaba/euler) 是阿里巴巴开源的大规模分布式图表征学习框架,可支持数十亿点、数百亿边的大规模异构图表征学习,并内置了大量的高效图神经网络算法。本次分享将为大家剖析 Euler 的系统架构与实现,详解如何支撑大规模图神经网络的计算,以及不同类型图神经网络算法的实现与加速。同时我们也会分享 Euler 在阿里巴巴商业场景下的应用案例及算法创新,以及我们对于图神经网络未来发展的思考。

                                  演讲人:

                                  张迪,阿里巴巴资深技术专家,阿里妈妈大数据与机器学习工程架构负责人

                                  林伟,阿里巴巴高级算法专家,搜索直通车匹配算法与智能创意工作负责人

                                  活动流程

                                  13:30-14:00,签到

                                  14:00-14:40,阿里巴巴资深技术专家张迪分享

                                  14:40-15:20,阿里巴巴高级算法专家林伟分享

                                  15:20-16:00,QA 及自由交流

                                  时间:4/13 周六下午 13:30-16:00

                                  地点:北京市海淀区中关村大街 32 号新中发一楼场馆会议中心

                                  扫描下方二维码,添加「机器之心小助手 3」

                                  备注:”Interface 活动”小助手邀请进群

                                  第一时间获取活动相关信息,以及与其他小伙伴互动交流

                                  活动直播链接将于活动当天在群里发出 

                                  点击「阅读原文」参与报名。

                                    阅读原文

                                    发送中

                                    一文读懂Python装饰器,这是一个会打扮的装饰器 2019-04-08

                                    选自pouannes.github.io

                                    作者:Pierre Ouannes
                                    机器之心编译

                                    参与:路、思源

                                    Python 是一种对新手很友好的语言。但是,它也有很多较难掌握的高级功能,比如装饰器(decorator)。很多初学者一直不理解装饰器及其工作原理,在这篇文章中,我们将介绍装饰器的来龙去脉。


                                    在 Python 中,函数是一种非常灵活的结构,我们可以把它赋值给变量、当作参数传递给另一个函数,或者当成某个函数的输出。装饰器本质上也是一种函数,它可以让其它函数在不经过修改的情况下增加一些功能。

                                    这也就是「装饰」的意义,这种「装饰」本身代表着一种功能,如果用它修饰不同的函数,那么也就是为这些函数增加这种功能。

                                    一般而言,我们可以使用装饰器提供的 @ 语法糖(Syntactic Sugar)来修饰其它函数或对象。如下所示我们用 @dec 装饰器修饰函数 func ():

                                    @dec
                                    def func():
                                      pass

                                    理解装饰器的最好方式是了解装饰器解决什么问题,本文将从具体问题出发一步步引出装饰器,并展示它的优雅与强大。

                                    设置问题

                                    为了解装饰器的目的,接下来我们来看一个简单的示例。假如你有一个简单的加法函数 dec.py,第二个参数的默认值为 10:


                                    # dec.py

                                    def add(x, y=10):
                                      return x + y

                                    我们来更认真地看一下这个加法函数:

                                    >>> add(1020)
                                    30
                                    >>> add
                                    0x7fce0da2fe18
                                    >
                                    >>> add.__name__
                                    'add'
                                    >>> add.__module__
                                    '__main__'
                                    >>> add.__defaults__ # default value of the `add` function
                                    (10,)
                                    >>> add.__code__.co_varnames # the variable names of the `add` function
                                    ('x''y')

                                    我们无需理解这些都是什么,只需要记住 Python 中的每个函数都是对象,它们有各种属性和方法。你还可以通过 inspect 模块查看 add() 函数的源代码:

                                    >>> from inspect import getsource
                                    >>> print(getsource(add))

                                    def add(x, y=10):
                                      return x + y

                                    现在你以某种方式使用该加法函数,比如你使用一些操作来测试该函数:

                                    # dec.py
                                    from time import time

                                    def add(x, y=10):
                                      return x + y

                                    print('add(10)',         add(10))
                                    print('add(20, 30)',     add(2030))
                                    print('add("a", "b")',   add("a""b"))
                                    Output: i

                                    add(1020
                                    add(203050
                                    add("a""b") ab

                                    假如你想了解每个操作的时间,可以调用 time 模块:

                                    # dec.py
                                    from time import time


                                    def add(xy=10):
                                      return x + y

                                    before = time()
                                    print('add(10)',         add(10))
                                    after = time()
                                    print('time taken: ', after - before)
                                    before = time()
                                    print('add(20, 30)',     add(2030))
                                    after = time()
                                    print('time taken: ', after - before)
                                    before = time()
                                    print('add("a", "b")',   add("a""b"))
                                    after = time()
                                    print('time taken: ', after - before)
                                    Output:

                                    add(1020
                                    time taken:  6.699562072753906e-05
                                    add(203050
                                    time taken:  6.9141387939453125e-06
                                    add("a""b") ab
                                    time taken:  6.9141387939453125e-06

                                    现在,你作为一个编程人员是不是有些手痒,毕竟我们不喜欢总是复制粘贴相同的代码。现在的代码可读性不强,如果你想改变什么,你就得修改所有出现的地方,Python 肯定有更好的方式。

                                    我们可以按照如下做法,直接在 add 函数中捕捉运行时间:

                                    # dec.py
                                    from time import time

                                    def add(x, y=10):
                                      before = time()
                                      rv = x + y
                                      after = time()
                                      print('time taken: ', after - before)
                                      return rv

                                    print('add(10)',         add(10))
                                    print('add(20, 30)',     add(2030))
                                    print('add("a", "b")',   add("a""b"))

                                    这种方法肯定比前一种要好。但是如果你还有另一个函数,那么这似乎就不方便了。当我们有多个函数时:

                                    # dec.py
                                    from time import time

                                    def add(x, y=10):
                                      before = time()
                                      rv = x + y
                                      after = time()
                                      print('time taken: ', after - before)
                                      return rv

                                    def sub(x, y=10):
                                      return x - y

                                    print('add(10)', add(10))
                                    print('add(20, 30)', add(2030))
                                    print('add("a", "b")', add("a""b"))
                                    print('sub(10)', sub(10))
                                    print('sub(20, 30)', sub(2030))

                                    因为 add 和 sub 都是函数,我们可以利用这一点写一个 timer 函数。我们希望 timer 能计算一个函数的运算时间:

                                    def timer(func, x, y=10):
                                      before = time()
                                      rv = func(x, y)
                                      after = time()
                                      print('time taken: ', after - before)
                                      return rv

                                    这很不错,不过我们必须使用 timer 函数包装不同的函数,如下所示:

                                    print('add(10)', timer(add,10)))

                                    现在默认值还是 10 吗?未必。那么如何做得更好呢?

                                    这里有一个主意:创建一个新的 timer 函数,并包装其他函数,然后返回包装后的函数:

                                    def timer(func):
                                      def f(x, y=10):
                                        before = time()
                                        rv = func(x, y)
                                        after = time()
                                        print('time taken: ', after - before)
                                        return rv
                                      return f

                                    现在,你只需用 timer 包装一下 add 和 sub 函数 :

                                    add = timer(add)

                                    这样就可以了!以下是完整代码:

                                    # dec.py
                                    from time import time
                                    def timer(func):
                                      def f(x, y=10):
                                        before = time()
                                        rv = func(x, y)
                                        after = time()
                                        print('time taken: ', after - before)
                                        return rv
                                      return f

                                    def add(x, y=10):
                                      return x + y
                                    add = timer(add)


                                    def sub(x, y=10):
                                      return x - y
                                    sub = timer(sub)

                                    print('add(10)',         add(10))
                                    print('add(20, 30)',     add(2030))
                                    print('add("a", "b")',   add("a""b"))
                                    print('sub(10)',         sub(10))
                                    print('sub(20, 30)',     sub(2030))
                                    Output:

                                    time taken:  0.0
                                    add(1020
                                    time taken:  9.5367431640625e-07
                                    add(203050
                                    time taken:  0.0
                                    add("a""b") ab
                                    time taken:  9.5367431640625e-07
                                    sub(100
                                    time taken:  9.5367431640625e-07
                                    sub(2030-10


                                    我们来总结一下这个过程:我们有一个函数(比如 add 函数),然后用一个动作(比如计时)包装该函数。包装的结果是一个新函数,能实现某些新功能。

                                    当然了,默认值还有点问题,稍后我们会解决它。

                                    装饰器

                                    现在,上面的解决方案以及非常接近装饰器的思想了,使用常见行为包装某个具体的函数,这种模式就是装饰器在做的事。使用装饰器后的代码是:

                                    def add(x, y=10):
                                      return x + y
                                    add = timer(add)
                                    You write:

                                    @timer
                                    def add(x, y=10):
                                      return x + y

                                    它们的作用是一样的,这就是 Python 装饰器的作用。它实现的作用类似于 add = timer(add),只不过装饰器把句法放在函数上面,且句法更加简单:@timer。

                                    # dec.py
                                    from time import time
                                    def timer(func):
                                      def f(x, y=10):
                                        before = time()
                                        rv = func(x, y)
                                        after = time()
                                        print('time taken: ', after - before)
                                        return rv
                                      return f

                                    @timer
                                    def add(x, y=10):
                                      return x + y

                                    @timer
                                    def sub(x, y=10):
                                      return x - y

                                    print('add(10)',         add(10))
                                    print('add(20, 30)',     add(2030))
                                    print('add("a", "b")',   add("a""b"))
                                    print('sub(10)',         sub(10))
                                    print('sub(20, 30)',     sub(2030))

                                    参数和关键字参数

                                    现在,还有一个小问题没有解决。在 timer 函数中,我们将参数 x 和 y 写死了,即指定 y 的默认值为 10。有一种方法可以传输该函数的参数和关键字参数,即 *args 和 **kwargs。参数是函数的标准参数(在本例中 x 为参数),关键字参数是已具备默认值的参数(本例中是 y=10)。代码如下:

                                    # dec.py
                                    from time import time
                                    def timer(func):
                                      def f(*args, **kwargs):
                                        before = time()
                                        rv = func(*args, **kwargs)
                                        after = time()
                                        print('time taken: ', after - before)
                                        return rv
                                      return f

                                    @timer
                                    def add(x, y=10):
                                      return x + y

                                    @timer
                                    def sub(x, y=10):
                                      return x - y

                                    print('add(10)',         add(10))
                                    print('add(20, 30)',     add(2030))
                                    print('add("a", "b")',   add("a""b"))
                                    print('sub(10)',         sub(10))
                                    print('sub(20, 30)',     sub(2030))

                                    现在,该 timer 函数可以处理任意函数、任意参数和任意默认值设置了,因为它仅仅将这些参数传输到函数中。

                                    高阶装饰器

                                    你们可能会疑惑:如果我们可以用一个函数包装另一个函数来添加有用的行为,那么我们可以再进一步吗?我们用一个函数包装另一个函数,再被另一个函数包装吗?

                                    可以!事实上,函数的深度可以随你的意。例如,你想写一个装饰器来执行某个函数 n 次。如下所示:

                                    def ntimes(n):
                                      def inner(f):
                                        def wrapper(*args, **kwargs):
                                          for _ in range(n):
                                            rv = f(*args, **kwargs)
                                          return rv
                                        return wrapper
                                      return inner

                                    然后你可以使用上述函数包装另一个函数,例如前文中的 add 函数:

                                    @ntimes(3)
                                    def add(x, y):
                                      print(x + y)
                                      return x + y

                                    输出的语句表明该代码确实执行了 3 次。

                                    原文地址:https://pouannes.github.io/blog/decorators/



                                    本文为机器之心编译,转载请联系本公众号获得授权

                                    ✄————————————————

                                    加入机器之心(全职记者 / 实习生):hr@jiqizhixin.com

                                    投稿或寻求报道:content@jiqizhixin.com

                                    广告 & 商务合作:bd@jiqizhixin.com

                                      发送中

                                      随机连接神经网络性能超过人工设计!何恺明等人发布新研究 2019-04-08

                                      选自arxiv

                                      者:Saining Xie、Alexander Kirillov、Ross Girshick、Kaiming He

                                      机器之心编译

                                      随机连接的神经网络性能居然比人工设计的网络(ResNet、ShuffleNet等)还要好?最近,FAIR何恺明等人提交了一篇论文,其模型性能让人觉得有点不可思议。


                                      在该研究中,来自 FAIR 的研究人员谢赛宁、Alexander Kirillov 、Ross Girshick 与何恺明通过随机神经网络连接的方式探索了比此前神经架构搜索更为广泛的连接形式,并实现了很好的效果。

                                      今天我们所说的深度学习是从认知科学的连接主义方法发展而来的,这一范式反映了一种假设,即计算网络如何连接对构建智能机器至关重要。与这一观点相互呼应,计算机视觉领域的最新模型也由链式连接转向更加精细的连接方式,如 ResNet、DenseNet,由于其连接方式更加精细,这些模型在很大程度上是有效的。

                                      神经架构搜索(NAS)的出现推动了这一趋势的发展,已经成为联合搜索连接方式和操作的有前景的研究方向。在聚焦搜索的同时,NAS 方法隐式地依赖于一种叫做网络生成器(network generator)的重要(但很大程度上被忽视的)组件。

                                      NAS 网络生成器定义了一系列可能的连接方式,网络根据可学习的概率分布从网络生成器中进行采样。然而,和 ResNet 和 DenseNet 中的连接方式一样,NAS 网络生成器是手工设计的,支持的连接方式空间被限制在所有可能图的一个小小的子集中。从这一角度出发,我们会问:如果我们放松这一限制并设计新的网络生成器会怎么样?

                                      谢赛宁、何恺明等研究者通过从随机网络生成器中采样的随机连接神经网络来探索这个问题,生成器中的生成结果由人类设计的随机过程定义。为了减少研究者的偏好对生成器造成的影响,他们使用了图论中三组经典的随机图模型:Erdos-Renyi(ER)、Barabasi-Albert(BA)和 Watts-Strogatz(WS)模型。为了定义完整的网络,研究者将随机图转换成有向无环图(DAG),并应用了一个从节点到其功能角色(如同一类型的卷积)的简单映射。

                                      结果出人意料:这些随机生成器的几个变体在 ImageNet 上产生了准确率颇具竞争力的网络。使用 WS 模型的最佳生成器生成的多个网络性能优于或可媲美全手工设计的同类网络或通过各种神经架构搜索方法找到的网络。

                                      研究者还观察到,同一生成器生成的不同随机网络的准确率方差较低,但不同生成器生成的网络准确率差距可能较大。这些观察结果表明,网络生成器的设计非常重要。

                                      研究者注意到,这些随机连接网络并非「prior free」,即使他们是随机的。实际上,许多强先验(strong prior)被隐式地设计到生成器中,包括选择特定的规则和分布来控制连接或不连接某些节点的概率。每个随机图模型都具有一定的概率行为,使得采样的图可能具有某些属性(例如,WS 是高度聚集的)。生成器的设计最终决定了网络上的概率分布,因此这些网络往往具有某些特性。生成器的设计是先验的基础,因此不应被忽视。

                                      在本文中,研究者探索了与 NAS 随机搜索当前研究 [23, 41] 不同的方向。那些研究表明,随机搜索在「NAS 搜索空间」(即该研究所说的「NAS 网络生成器」)中颇具竞争力。

                                      他们的研究结果表明,NAS 生成器设计所产生的先验往往可以生成好的模型,这与本研究的观察结果相似。与之前的工作相比,本文研究者的工作超越了现有 NAS 生成器的设计,探索了不同的随机生成器设计。

                                      最后,本研究表明,从设计单个网络到设计网络生成器的过渡是可能实现的,类似于从设计特征到设计学习特征的网络的过渡。研究者建议设计新的网络生成器,生成用于搜索的新模型集合,而不是聚焦于使用固定生成器进行搜索。

                                      (NAS 等中)网络生成器设计的重要性还表明,机器学习还没有实现自动化(参见 AutoML [20])——即基本的人类设计和先验从网络工程转向了网络生成器工程。

                                      随机连接神经网络

                                      对 NAS 的分析表明,该网络生成器是手动设计的,且根据人类知识对先验进行编码。网络生成器的设计很可能起着很大的作用,这样的话,当前的方法还无法达到「AutoML」,而且仍需要大量的人力。

                                      为了研究网络生成器设计的重要性,只对同一 NAS 生成器比较不同的(复杂或随机的)优化器是不够的;有必要研究与 NAS 生成器非常不同的新的网络生成器。

                                      为此,研究者开始利用随机连接神经网络。即,他们将定义网络生成器,该生成器生成带有随机图的网络,服从于不同的人类特定先验。为了最小化人类偏见(本文研究者对先验的偏见),研究者在研究中使用了三种经典的随机图模型。其生成随机连接网络的方法包含以下概念:

                                      边缘操作。假设图是有向的,研究者定义边缘是数据流,即有向边缘将数据(张量)从一个节点发送到另一个节点。

                                      节点操作。有向图中的节点可能有一些输入边缘和一些输出边缘。

                                      图 2. 随机图节点设计。这是一个节点(蓝色),有三个输入端和 4 个输出端,通过可学习的正权重 w_0、w_1、w_2 的加权来完成聚合。转换器是 ReLU-convolution-BN 三元组,可简单视作卷积。转换后的数据作为 4 份副本发送出去。

                                      图 3. 在随机图形生成器上的比较:ER、BA 和 WS 在小计算量条件下的结果。每个指标代表在 P、M 或(K、P)参数设置下的生成器的结果(x 轴)。纵轴为 ImageNet Top-1 准确率,5 个随机网络生成的结果显示为标准均值(std)。在最右侧,WS(K、P=0)没有随机性。

                                      图 4. ER、BA 和 WS 生成随机图像的可视化。每个图表代表由指定生成器采样的一个随机图形实例。生成器即为图 3 中的配置。每个计算图的节点数为 N=32。红色/蓝色节点代表输入/输出节点,在一些情况下,会加入额外的唯一输入/输出节点(未显示)。

                                      论文:Exploring Randomly Wired Neural Networks for Image Recognition


                                      论文地址:https://arxiv.org/abs/1904.01569

                                      摘要:用于图像识别的神经网络已经通过人工设计,从简单的链状模型发展到具有复杂路径的结构。ResNet 和 DenseNet 的成功很大程度上归功于它们的创新性线路设计。近日,神经架构搜索(NAS)的研究正在拓展连接和操作方式的联合优化,然而其可能的布线空间仍然受到约束——它们在搜索中仍受到手动设计的驱动。

                                      在本论文中,我们通过随机神经网络连接的方式探索了更为广泛的连接形式。首先,我们定义了一个随机网络生成器的概念,它封装了整个网络的生成过程。这一封装提供了 NAS 和随机连接网络的统一视图。然后,我们使用三个经典随机图模型为网络生成随机连接图。结果令人惊讶:这些随机生成的网络变体在 ImageNet 图像识别基准测试中有着非常具有竞争力的准确率。这些结果表明,相比于小搜索空间,专注于设计更好的网络生成器或许可以带来更大的技术突破。

                                      图 1. 由经典的 Watts_Strogatz(WS)生成的随机连接神经网络模型:在和 ResNet-50 使用相近算力的条件下,这三个随机生成的网络在 ImageNet 上实现了(从左至右)79.1%、79.1%、79.0% 的分类准确率,ResNet 的准确率为 77.1%。

                                      PyTorch 实现

                                      FAIR 提出的这些随机连接神经网络看起来十分魔性,论文一经提交就引起了人们的广泛关注,很快就有了实现——来自 MINDsLab 的 Park Seung Won 试图在 PyTorch 上实现它,并重现研究中的一些结果:

                                      实现地址:https://github.com/seungwonpark/RandWireNN 



                                      本文为机器之心编译,转载请联系本公众号获得授权

                                      ✄————————————————

                                      加入机器之心(全职记者 / 实习生):hr@jiqizhixin.com

                                      投稿或寻求报道:content@jiqizhixin.com

                                      广告 & 商务合作:bd@jiqizhixin.com

                                        发送中

                                        数学还能这么学?高中要有这个网站我早就及格了 2019-04-08

                                        机器之心报道

                                        机器之心编辑部

                                        高中数学经常考不及格的我发现了一个有趣的可视化数学学习网站!恨不能回到十年前(emmm… 一不小心暴露年龄了……

                                        之前我们介绍过全交互的线性代数书可视化的统计概率入门书,今天我们就来看一看「这本有趣的基础数学书」:Mathigon。Mathigon 提供交互式学习方式、个性化学习服务和故事化的教学内容,试图改变原本枯燥的数学学习方式,为数学学习过程注入活力,保护和提升学习者的好奇心、创造力和想象力。

                                        该网站的创始人 Philipp Legner 曾在剑桥大学学习数学,在伦敦大学学院教育研究院学习数学教育,曾供职于谷歌、彭博、沃尔夫勒姆研究公司和高盛。此外,他还为 MoMath 和 Imaginary 等教育组织提供咨询。

                                        该网站的顾问委员会成员包括:MoMath CEO Cindy Lawrence、沃尔夫勒姆研究公司欧洲分部联合创始人和 CEO Conrad Wolfram、Global Math Week 创始人 James Tanton、Android 公司创始人 Rich Miner,以及《Fermat』s Last Theorem》、《The Code Book》等畅销书的作者 Simon Singh。

                                        网站地址:https://mathigon.org/

                                        课程

                                        Mathigon 网站涵盖大量课程,目前包括基础(Foundations)、Intermediate(中级)、Advanced(高级)和 Recreational(娱乐)四个模块,其中基础课程适用于 6-8 年级学生,中级和高级适合高中生。

                                        基础课程

                                        基础课程包括:数字和算术、方程和函数、几何学、概率和统计。

                                        「数字和算术」这部分内容中,目前只有「Divisibility and Prime」(整除和素数)是开放的,其它内容正在设计当中。

                                        小编点进去发现,该主题下又分为了好几节:从约数和倍数、整除规则、素数、素数分布、最小公倍数、最大公约数到最后的现实应用,内容丰富详尽、应有尽有。

                                        每节内容中都包含彩色插图,有些图片还是互动式的,以「最大约倍数」为例:

                                        现实应用的讲解看起来也很有趣:

                                        看完这些,小编酸了。如果以前学数学的时候这么好玩,小编的数学成绩肯定会好看多了!

                                        中级课程

                                        中级课程包括几何、代数、概率和离散数学三大类。其中几何内容基本已经完备,都可以点进去学习:


                                        代数课程目前只有序列和模式、二次方程是开放的,其余尚在准备阶段:

                                        概率和离散数学中,有一半内容已经筹备完毕:

                                        高级课程

                                        高级课程分为五部分:数学语言,代数与分析,几何学、三角学和矩阵,微积分,概率和统计。

                                        数学语言部分皆已开放:



                                        代数分析都还在筹备中:



                                        第三部分中只有分形是开放的,其它内容尚在准备中:



                                        微积分与概率统计部分都还在路上:

                                        娱乐

                                        这部分主要包括一些好玩的活动,如「数学在日常生活中的应用」、「折纸中的数学」、「爱丽丝漫游数学仙境」、「寻宝游戏」,寓教于乐,帮助学习者在游戏中学习数学。


                                        OH MY GOD! 兔子洞中惊现数学题……

                                        此外,该网站还计划为教师提供服务,所有资源均可免费使用。

                                        教学特点

                                        互动式的学习方式

                                        该网站的创新内容格式使数学变得极具互动性。学生在每一步都要积极参与,探索和发现新思想。

                                        这种学习方式与视频教学和课本教学不同,学生不仅仅消化信息,他们还参与解决问题、推理,因此变得更具创造力。

                                        个性化的学习服务

                                        该网站提供虚拟个人教师来引导学生学习新的主题,并给予实时提示和鼓励。这种导师-学生的比例几乎是 1:1 的。

                                        随着对学生的了解加深,该网站的算法会无缝调整和个性化学习内容,使每个学生都能掌握课程内容。

                                        故事化的教学内容

                                        每门课程都有各种彩色插图、谜语、动画和真实应用。迷人的叙事方式让教学内容变得更易理解和记忆。

                                        通过这种教学方式,你会发现数学不仅仅是抽象的方程和程序,它还非常美丽和实用。

                                        话不多说,小编要去学习了~


                                        本文为机器之心报道,转载请联系本公众号获得授权

                                        ✄————————————————

                                        加入机器之心(全职记者 / 实习生):hr@jiqizhixin.com

                                        投稿或寻求报道:content@jiqizhixin.com

                                        广告 & 商务合作:bd@jiqizhixin.com

                                        文章已于修改

                                          发送中