智源大会-2023-笔记-三-

智源大会 2023 笔记（三）

AI开源论坛 - P1 - 智源社区 - BV1jo4y1K74N

🎼尊敬的嘉宾、女士们、先生们，大家下午好。非常欢迎大家来到2023北京资源大会AI开源论坛。我是今天的主持人杨轩啊。

我来自lin foundation亚太区呃简单呃讲两句就是呃lin foundation是全球最大的开源呃组织啊非盈利组织呃。

而呃LFAI and data这个是lin foundation下边专职的是人工智能这个领域的这个基金会。同时呢LI and data呢也是呃全球最大的AI领域的呢开源社区。

啊现今呢AI开源呢已经成为人类呃超大规模智力的智力协同的一个最佳的一个组织方式，可以说呢没有开源，就不会有今天AI的这个呃成就。呃，现在呢AI呢已经成为了。😊，这个人类这个开源创新的一个主战场啊。

今天呢我们有幸呢请到了非常多的呃AI领域的专家一起探讨呢呃从这个AI与数据的开源到大到大模型的这一些的机遇与挑战。啊，希我们希望呢这次的这个大会呢能够对待大家的未来的这个发展呢，有呃呃有所帮助啊。

工作上啊或者是呃事业上有所帮助。另外呢我们也希望我在这里也在呼吁一下呢，就是说希望能够有更多的朋友能够加入到AI开源的社区的行列。啊，我们在LI data这边呢，我们有大概440到50个这个开源项目。

这些呢也都欢迎大家来去呃使用参与这些项目。今天呢我们就是有请呢我们今天这个第一位嘉宾，这是呃我们有请LAI andda呃董事会呃主席杜俊平老师为我们带来。主题演讲AI与数据开源挑战以机励有请啊杜老师。

也感谢主办方资援和研院和这个林老师的邀请。那么今天给大家啊介绍一些这个关于AI和数据领域开源的一些挑战和机会。那么借着这个场合呢，我首先介绍一下这个FAN data基金会啊。

那么FANdata data基金会呢是个开源的软件基金会，它是一个非盈利组织。但是它啊托管了在AI和这个数据领域最重要的全球最重要的一些啊开源的项目。那么同时呢在呃我们当前的基金会里面。

大概有全球有50个啊左右的这个member啊，包括像咱们呃国内大家熟悉的一些大企业，甚至包括资源研究机构也在里面。

同时呢我们全全球呢托管了大概有46个啊这样一个关键的这种technical project。啊，也有啊超过啊接近2万名的这种开发者，为我们的这种AI和数据类的这种项目，开验项目在持续的贡献。

那么这个这张图呢能看到FANda作为一个大的这个基金会的社区大的开源社区啊，它的这个开发者的规模，它的呃技术的这种成呃这个飞速的发展。过去的5年呃成长的大概5倍啊，53031%的这个成长。

一方面这个也反映了当前这个在AI这个领域的开发的这个趋势，就是更多的开发者更多的呃开源的这个公呃公司呢投入到这个AI这个领域也涌现到这个开源这个领域。

那么同时呢我们也希望借着这样一个平台能够更好的这个拓展我们的啊这个让技术更好的发展。啊，同时这里面的这些关键的这个project呢，包括一些这个深度学习框架，包括这种onex啊。

这样的一个框架之间的翻译的平台，包括这harwood在这种分布式的这种学习框架，甚至包括啊项目资源也有这个flag AI啊，在这个在这个里面。然后这些top的这种organization呢。

就是大家耳熟能详的。像这个啊亚马逊啊微软啊啊这个meta啊等等。像国内的华为啊、百度啊、阿里啊啊，都在这个我们的这个组织里面，或者是或者是member吧，或者是包括推管了一些关键的项目。

那我们的这个基金会它的运作呢是呃主要是分就是相当于是一个分层治理的架构。那么有governning board呢，就负责这个董事，就整个基金会的一个层面的治理。

那么另外我们有technical呃这种cordation呢，就是type meeting。呃，我们的TAC technicalnicalad，它是专注在啊技术层面的治理。那个包括我们整个。

🎼开源社区这些项目，它的这种life circle从这个sbox到incubate到graate它是一整套的一个啊相当于一个毕业的演进流程。

那么我们 typically认为sbox阶段是项目的一个开源项目，它的总阶段。在这个阶段里呢，更多的我们会关注啊他的这种开发者的生态，更多的这种开源的呃开发者能够加入当中到这个项目当中。

那么到了incub呢就是更多的它是开始拓展自己的用户，就它已经有足够的开发的，有些完整的功能能够适应在一些场景之上。然后再往前走呢，它就是一个graduate的状态，就是它的呃功能比较完善。

它的生态比较丰富，用户也也积累积累的比较丰富，它可以进行一些规模化的落地啊，这就是它整个完整的呃这个开源项目的这种life circlecle。那么回到我们今天的正题啊。

就是我们在呃看看这个当前我们说是属于属于的时代。实际上呃当前我们的时代在不管是工业界还是学术界，大家的认知都是一致的。就是我们认为这是属于AI的技术爆炸的的这个起点时刻啊，就是我们在通样陆续在。

在这个关键时刻走向这个人通用人工智能。那么现在的一个。很多这种bussword就是说啊从前几年的我们mine learning啊，deep learning AI framework是吧？

慢慢的现在更多的大家听到的都是这个呃transformer，然后attention呃AIGCLALA large language model这些啊这些词其实这些都。看到这这两年每隔每隔一年或者两年。

它的这个焦点都不一样。尤其是当这个去年底对吧？这个chGBT出来之后，其实上引爆了一个核弹。呃，快速的走向这个呃。呃，让这个AI的这个生态啊快速的这种啊能够能够蓬勃的发展。那实际上呃业界呢把这些模型。

就现在我们看现在应该是一个模型飞速发展的时代。那么业界把这些模型呢从这个小模型到中模型，中等的模型，大型的模型跟超大的模型啊，每个每个来某某一个模型的，它的能干的事情也看的比较清楚，是吧？

一些小模型呢可以做一些简单的一些阅读理解啊，包括这种debugging的工作是吧？然后中中型到大型的这种模型。啊，类似于GPT3GPT呃3。5之类的呃。

它可以做一些啊这个GR包括GPT4可以做一些这种GRE层次的这种阅读理解，甚至包括一些对于这种类比啊比喻啊。还有一些这个呃包括这个逻辑的推导啊，一些这个生成代码的生成啊，我们的这个。

在这个ghas上的一个 pilot这些啊其实很很。就是很很大程度上其实提高了我们啊在这种啊开发生成这些文档啊，包括这种写代码开发的这个效率。其实未来呢我们看到随着这个我们的这个模型会越来越呃这个发发展。

可能会有些进进进一步的一些。呃，功能会被开发出来啊，包括他有一些初步的一些呃更。更这个更强的一些自我的意识啊，或者更复杂的一些工作，甚至是一些呃一些这个argument他都可以去做啊。

这就是一个我们这个时代的继承，就是它是一个飞速发展的过程。那么实际上去年呃两周前我们看到dybreaks发了一个报告，就是在2023年的这个呃，他认为这个state of data加AI。呃。

有些有趣有有意思的这个呃数据。那比如说。就AIGC这个呃就是拆GPT发布之以来的几个月，这实际上大家用呃用这个API的模式，或者是这种呃模型工具链的这种模式会成为这个主流。

在这之前大家都是啊美公司自己可能训一些，或者是用依赖于一些这个啊开源的开放的一些一些模型。那么在这之后呢，可能直接我们就开始用这个API去访问这些模型。那么这短短的这个半年时间。

从去年底到啊今年的5月份，这半年时间呢，这种直接对于API的这个层次的这种访问量的吧升了1310，也就是13倍。那么同时呢，现在在NLRP的这个领域呢，在整个呃这种。呃，科学计算呃。

在在整个这个呃python的这种data science这个领域啊，它占的这个比例啊已经得到大概大概占到了这个50%左右啊，就非常的popular，也占用大量的这种。啊，这种。

M型 learningning和这个个学计算的这种任务。那么同时呢。嗯，还有一个意思就还有一个有趣的现象，就是企业对于模型的重要性也是越来越呃越来越有更强的认知。那么在过去的一年当中啊。

模型上线的在生产中上线的模型啊，实际上翻了400%啊，甚至包括在这个过程当中，大家的成熟度，使用模型的成熟度也提高了。与以前的一年之前。大概是每5个模型，就是在测试阶段，最后呢变成一个生产模型。

那么现在呢这个比例是3比1，就是每三个啊处于这个测试阶段的模型呢，就啊就有一个进进入生产。实际上这种比例的变化也也意味着我们在AI这个infer或者是整个呃这个行业的应用当中慢慢的走向成熟。

一方面是我们认为这个大模型的生态是发现在发展的是欣欣向荣啊，但是从另外一个层面，我们看到冰山下的部分呢永远是数据。那某种程度而言。啊，模型只是数据的一个一个转化品或者衍生品，它是一个。

呃呃这个模型是数据的，在某一个切面上的一个投影啊，或者是一种折叠，或者是一种压缩。所以一个高高质量的这个数据集呢，实际上是可以啊训练出这个不同的维度的这个多个高价值的模型的。那么作为这个冰山之下的部分。

这个数据的重要性呢，就是大家一直在强调啊，一直在呃在在提。但是始终呢大家都觉得哎这块可能。有很多各种各样的挑战。那么今天我们待会儿也会去啊更多的去讨讨论一下有哪些挑战啊。其第一个就是。呃。

从训从这个模型训练的角度来说，这个数据从来就没有够过啊，这个够体现在一个是质量，一个是数量啊，我们需要更高的质量，然后更多的这个数据等等。啊，不管在整个这个模型的这种产生，诞生，从训练阶段是吧。

到后面的调优阶段的后面的这个推理到啊生成之后的这种prom engineering，其实它都离不开这个不断对它进行这个数据的一个投位。所以就是如果我们说大模型就像一个这个贪吃的贪吃蛇或者一个贪吃的怪兽。

那么就是他一直吃不饱，那始终是啊有更好的这个需要更多的数据和更高质量的数据。那么同时呢很多的企业呢初步初步已经感受到这个模型的power之后呢。

下一步就是说如果能如何能够更好的提升我的这个呃模型的这个能力和质量。也是在呃数据这块层面做很多工作。就是所谓的这个啊datacentric的的工作。那么实际上当前的这些数据呢，来源无非就是三个来源。

那么第一个来源呢就是自己啊去这个呃去收集一些数据，去扒取一些数据。那么第二个呢就是。从第三方去购买是吧，或者是呃获得一些数据。那么第三个呢就是通过public valuable的方式啊。

找一些公开的数据集啊，类似于我们的hing face啊，在在这个之上去获得一些。但是这三个层面上呢，多多少少还都是有一些挑战的哈。第一个从主动收集领域。

其实很多我们发现现在的数据呢呃很多的公司还是在管个公司，它的这个啊私域属于在这个私域之中啊，很难从外部去获得。而且是一种合规合法的这种方式去获得，是是比较难的。那么另外一个层面呃上讲呢就是。呃。

对于这种第三方的呃购买或者交易的这些数据呢，实际上也是有很多挑战。因为啊这个数据的定价格如何定义是吧？然后这个数据啊如何定义它的质量，或者是它的对我的这个外部的公司，外部的企业，它能够真正产生益处。

所以这个所以有很多的这种啊数据交易市场。国内我们也有一些海外的也有一些在云，甚至在一些云服务上啊，云服务场上，包括这种呃这种数据的这种呃production。

或者数据的saras service上都有这样相应的market。但是目前来看的它的交易量和本交易的数量和规模其实还没有完呃，没有达到这个理想的状态和要求。那么第三个呢，实际上是在呃。

这种公寓就是public available的这种数据。那实际上我们现在看到很大量的数据集还是不是一种完全开源的状态，它可能还是在。呃，商用啊或者是方面有很多的限制，就你可能做做研究可以是吧？

但是你不允许相应相应推发，或者是当你训练完了之后，你的这个这个预训量的模型，或者将来的数这个AI的模型的产品啊，不允许有各种各样的限制。

那么实际上这也使得我们的可用的商业可用的这些数据集都是啊很有的限制。我认得这个是一个很重要的挑战。在三种渠道上各有各自的这种挑战需要去去做。那么另外呢，还有就是看到这个数据的这个。呃。

quality还是quity啊，大家会有很多不同的。呃，这个要求和纠结现在基本上达成大家达成一个共识，就是quality over quantity，就是数据的这个质量可能优于它的。

它的这个呃这个quity。因为其实质量呢它决定了这个模型是吧，是否精确，是否是相关，是否啊会不会有一些buers，会不会有一些就就是不公平啊等等。但是 quantity呢它实际上也是有用的。

它包括你大量的数据训练出来的模型的，它会有更强的这种泛化能力啊，包括它有更强的这种robust能力。他不会说呃觉得过于依赖某一部分的这种数据。然后同时呢他看到一些这种。呃。

没有见过的传情况的这种case，他能够很好的这个处理。所以quity和 quality这种呃经常是也是有企业会去纠结的。那么我们认为就未来的方式呢就是。呃，可能在数据在保证数据质量的情况下。

那个我们更更高的更多的获取数据。然后同时用一些，比如说现在当前是用人工的方式去打一些标签，对吧？或者是做一些相应的这种工作，未来可能会更多的自动化的标签，或者有相应的开发出相应的模型啊。

自动的会给我们的这个啊数据啊贴上各种各样的这种标签。那么可以更好的训练我们的。我们的这个模型。然后同同时呢，在这个data set的治理层面，其实有很多啊很多的这种问题。其实原数据的治理呢一直在。

在业界就是一个问题。包括我们看到很多企业内部大的公司内部啊，不同的team，不同团队其实互相之间的因为啊一些沟通的问题，或者是啊部门强的一些问题，其实没有办法啊很好的共享数据。

哪怕这些数据呢对啊在公司内共享是很有价值的。那么第一个难点就就卡在这个数据法源数据的发现，就是我们能不能有一套这个原数据的标准，很好的定义不同的呃不同的这个。呃，这个数据注意集他在做什么事。

那我们其实看到比如说以这个hing为face为例，其实。都同样是文本数据是吧？MDB的这个数据集和这个wiki就是还是有些差别。那么对于。呃，对于我们这个普通大众来说，他的认知还好，还是能够理解。

但是一旦这个是牵扯到企业不同的不同的业务，它的业务逻辑在里面的时候，这个呃互相之间就很难去达成一个一致。所以在这个层面上啊数据级的这种medada是需要一个标准。我觉得在这个领域。

其实FANda基金会可以做的更多。我们可以做更多的啊这种相应的开源的标准的这种工作。那么从另外一个层面，其实从治理的层面。实际上呃当前的很多时候在强调这个data的这个governance。呃。

这种data governance设施包括一些原数据，包括一些数据的呃血缘。但实际上在当前来看，除了数据这块需要治理。

其实在整个呃motion型 learninging某型 learning pipeline上有很多更复杂的东西，包括我们从数据的这个处预处理之后呢，会有特涉及到特征特征工程，对吧？

在后面的model training，啊，包括这个managementserv。到后面现在还有这个pro engineering。所以这里面有很多大量的东西啊。

你有很多从从数据data set到这个feature的映射，从feature到。model映射model到后面的一些prom的一个映射，这个形成了很多这种网站的关系。啊。

但当前现在是没有一个很好的一个治理的产品或者治理的一个框架来去。呃，来去这个完善。那么我们认为这个是市场上这个急需的一些啊一些方向。那么刚才说到的这些挑战呢，其实还有一个很关键的。

就是在于我们看到在呃更多的挑战其实还来自于来自于这个包括我们的数据的全球的这个分布啊，然后多区域多云造成的这个新数据孤岛的问题。我们看到现在很多这种致力于开展国际化业务的公司。

其实面临着呃越来越这个这个严苛的一些数据的监管。那么怎么样去兼顾啊以合规的前提啊，就是兼顾监管的要求。但同时呢从全局的角度，从业务的角度，他需要一个全局的视角。

全局的视图能看到啊这个不同的地域它的这个业务策略和数据驱动的这些策略。其实这里面其实有一个很强的一个gap。那么这样的话，如何统一啊去做这个数呃数据的分析治理、训练推理，就是在呃当前越来越成为各个。

大公司或者是有国际化业务，有这种订购业务的公司，它的一个很大的一个。呃，难点。那么近年来其实像如果我们关注像berkeley啊，他们也提出了这个skycomp一个云联邦的架构。

某种程度上在IS这个层面啊，解决了缓解了这个多云带来的这种复杂性呃和这种性能问题。但是要解决彻底解决这样一个啊多云造成的这种数据割裂数据孤岛的问题。啊，且或者模型的鼓导问题。

其实还需要这个更颠覆性的产品和技术出来。但是虽然这里面讲了很多的问题啊，就是很多挑战。但我觉得这里面其实更意味着更多的机会。那很多这些机会很多这些问题呢就潜就是之前是隐藏在水下。

那么现在随着这一波的啊这个大语模型的这种蓬勃发展呢，实际上我们有更多的可能性。我们的问题更多了。但是同时我们的这个手段，我们的能力，包括我们的这个聚焦的资源也很多了。那么现在有很多聪明的工程师。

包括很多的资源多的快速涌向这个AI这个领域和数据这个领域。我觉得我对未来我们快速这个领域快速的这种发展充满了信心。那么我们现在正在做的这个啊这个我的一个初创的公司呢。

也在以开源的方式来解决AI和这个开源呃和数据开源碰到的各种各样问题。啊，这个用开源的方式解决啊这个AI和领域和数据领域的这些啊最尖端的痛点问题，一直是我的这个啊这个秉持这个我的这个啊理想。

也是我的啊一个公司未来的一个愿景。那么也希望啊更多的小伙伴可以跟啊跟我们一起啊，就是在这个领域探索啊，创造一些伟大的技术，创造伟大的产品。好，谢谢大家。😊，啊，感谢杜老师的精彩分享。

接下来有请智源研究院副院长兼总工程师林永华老师。智源研究院自然语言多模太祖负责人刘广老师呃，带来主题分享。智源open呃flag open大模型技术开源体系，开启大模型时代新linux生态建设啊。

掌声有请。🎼谢谢哈，等会呃这个这个session呃由我还有呃我同事留管，等会呃会把他请上来哈。嗯，那呃首先我还是想借今天的这个机会哈，感谢那个杜俊平老师。

还有感谢lin基金会AI AI data基金会对我们支援大会的支持，以及组织了这么好的一个AI开源的论坛。我看到后面大家都已经这个站站站都站站了哈，包括坐在楼梯上的这个小伙伴们。呃，前面其实还有座位哈。

大家可以这个也可以做那个嗯开源其实是很重不好意，我拿一下那个翻业的。😊，开源很重要，包括在这一次呃智援呃，我们发布大模型其实我们很重要很重要的一个keyword，就是开源啊。

所以为什么说AI开源论坛也是这次呃，其实历届智援大会都是很重要的一个话题。呃，这个这个就不说了哈，今天说了太多了。这个好，我发现那个用用的这个图跟读老师的图一样啊。😊，但的确就是说看到了。

实际上虽然现在从去年下半年到到现在哈很火热的，例如像AIGC文生图，例如像GPT大家其实看到的冰山上的部分。啊，但嗯水面之下大家看到的的不一样哈，从资源来看，这个数据大然是以以很重要一部分。

还有很重要的是它整整个冰山水面下的技术站。那这里头的技术站，包括了各个重要的基础模型，包括语言视觉图文文声图等等。也包括了我们这些数据集以及做数据集很多的重要的工具，还有大模型的评测的方法。

另外还有就是支撑整个大模型，高效训练的AI的系统技术。那这里头也是很多，包括框架的并行优化平台的调度算子优化，甚至AI异构芯片技术啊，这也是为什么我们其实是说AI系统。

就是今天上午们特别也是有一个专门的论坛啊去讨论。😊，那呃对资源本身来说，呃，正因为看到这个水面之下最重要的这个技术站。所以这是我们的定位。就是说我们需要把帮助整个产业科研这个产业。

把这个技术站整一个打造出来。嗯，那这里头就包括我们的一系列的基础大模型啊，从昨天早上我们的整一个这个呃全体会议的时候，呃announce的我们开源出来的几个大的这种包括语言视觉跨模态的大模型啊。

也包括我们自己的数据及工具。呃，AI基础大模型评测，这是等一下下一个session介绍这个由我们杨西杨博士介绍那个flyev啊呃去介绍。然后还有我们的整一个九鼎的智算平台。

那呃首先我我我也想趁今天这个机会啊来说一下为什么我们资源要走大模型开源开放的道路。其实很简单就是说两个原因。第一个是说推动整个社会资源的合理使用，包括数据和算力。其实基础模型。如果我们这个基础模型。

它不是一个行业性，而是一个通用性的话，其实它去构造这个基础模型所使用的东西是很类似的，都是需要我们有一定比例的这个呃互联网数据加高质量的数据，也需要海量的这个算力。所以其实大家是想就是说如果基础模型。

其尤其是通用性的基础模型不没有开源出来，也进一步没有能够是以商用的版本开源出来。那势必找只能够逼的各家企业自己去重复性的去造这个轮子。而这个轮子很高昂，很昂贵。

呃我在昨天的那个呃我们新发布的那个呃天鹰大模型的时候。我第一页就是说为什么我们认为基础大模型就像这个就类比AI中造1个CPU第一个原因就是它贵呀，那贵是贵成什么样？这资源是什么样子。

当时我就我们就至少是小几千万到大几千万这样的一个量级。而另外一个就是说哪怕是金钱不是问题。但算力以及推动算力运载算力背后的能源也是很重要一个问题。要知道。

大家要知道说现在我们实际上付给去租用这个GGPU服务器，哪怕是英伟达这样子的，它在能耗比上面已经算是做的很不错的。其实我们很多很很很重要的一部分钱就是付给了这个电电费啊。

所以没有必要真的没有必要重复大家去造这个轮子，而这个轮子都是通用性的是吧？何不就是有人能够把这个东西开源出来，并且它是商业可用。但当然重要一个是可以保证这个版本可以持续的往前迭代。那第二个很重要的是。

它这个基础大模型。今天它已经不是只是个理解，它是一个能力的生成。并且它是一个认知对外输出价值观对外输出的东西。那因此它对社会可能带来的影响是巨大的那因此我们在训练这些这个基础模型里的时候。

所使用的预训练的数据也是相当的考究啊，那这个可能大家也能留意是说，前阵子这个国家网信办也有一个征求意见搞出来。其实有很大一部分也是在探讨这个数据的安全的问题嗯。

那呃其实支源我们最近哈也对持续的关注check，我们在在今年那个1月份到5月份全球开源的这些通用的通用的语言大模型的统计。那这里头是有一些数字哈，未必完全准确哈这个总数。

国外开源的语言大模型一共有39个，其中可以商用，并且并不是使用copy left的协议的大模型有16个。那为什么这两个东西很重要。因为我们来看科研是一个问题，但现在最重要是怎么推动这个AI产业落地。

产业落地必须我们要符合产业的游戏规则。而产业的游戏规则是说你要用的东西必须是带有可商用的版本。非商用版本其实是对企业未来的发展，它的使用是有ris的那另外一个copy left的协议。

这个因为在座都是对开源可能就已经从事很多年，就知道例如像类似。GPL这种类似的license的话，呃，现在我们也看到有一些模型开源也用了类似这种copy的协议。

那那种这种协议它定义了是说只要在这个模型上面 further的con training的模型，以及它的呃微调的模型都必须开源。

那这个实际上对于很多企业的商业的利益的保护是很很很有弊端的这也是为什么其实咱们看整个开源界，它使用的版本也是越来越多的开源的代码呃，使用像阿帕奇啊MIT啊这种呃BSD这种copy。

就是不是copylic。呃，所以这是一个。那另外咱们回归到看咱们国内开源的发布了发布的大模语言大屏模型有28个开源的数量只有11个。那其中我们同样也是去看它这个开源可商用的版本的模型。

目前只有一个就是ba里的一个小的一个基于b的一个指定微调的对话模型。所以这里头可见是说，为什么这一次致援我们在发布我们的呃这个天鹰大模型的时候，直接很干脆的使用这个可商用的license。

以避免企业的一个呃顾虑。那支援我们这一次开源的整一个就是我们的大模型数。但实际上最重要的是底层的这个基础的大模型。在这里头我就不多花时间。那开源开放，使得我们可以站在前人的基础上去前行哈那因此。

这个呃这是为什么智源刚才说我们打造的是冰山水面以下啊，这些对于咱们构造大模型应用很重要的技术的部分。而我们实际上在今年的2月28号就全面开源啊，发布出来。这里头包括了最核心的fAI大模型算法开源项目。

这里头呃会包含我们智源最新呃发布的呃。天鹰大模型也是放在这个里头去进行发布。这个等会刘广博士会给大家介绍呃哦by the way我要强调这个大模型算法开源项目，我们去年6月份正式第一个开源出来的时候。

就第一时间给lin基金会内到I and data这是因为我们希望是说以这样一个决心来促进呃咱们在中国签呃呃主导。但是全球可以开放使用的这样一种合作的氛围。

那bes这个fI我们还有f data这个主主要是做数据工具的开源。另外还有f这个大模型评测开源项目这个等工和第二个top会讲。还有最后是说下面一个我们对AI系统开源的评测。

那说一下这个AI呃异购它是其实有点对标那个Mf但是Mf的话，它实际上呃主要还是比较tradition的work作为而进入我们大模型时代。实际上我们需要新的一批大模型的来牵动我们易购芯片的发展。呃。

同时我们希望是说在这个呃用来帮助做系统性评测芯片性能评测的时候，不要只有一种一种一种框架。我们也是积极的去跟这些国内的框架合作，呃，使得是说大家对芯片的评测，可以也基于多种的框架结构。

那下面呢我们很高兴也获得了这个呃不同的包括天数天数智星昆仑星，包括华为升腾的等等芯片厂商的支持，陆续的把他们的一些呃呃相应的部分也加到我们这个评测的开源系统里头。那我们希望打造的是说。😊。

帮助我们芯片异购芯片的用户，可以很快拉起一个完整的测试。呃，这个因为等会会讲，我就sip掉。那呃这个是我们那个呃fd dataf data实际上是它是一个呃工具的开源，那包括了数据清洗统计分析等等。

其实这是智源一直在过去3到4年做这个大模型预训练数据的时候积累的工具嗯。然后。哎，等一下，我看这个是不是有点哦，好，不好意思哈，那个我我我我要讲的部分已经呃讲完了。然后在此我邀请那个刘广刘博士。

刘博士是我们呃自然负责这个自然语言处理和呃多模态生层的研究组的负责人。😊，哦，同时他也在，是咱们fAI的负责人。谢谢谢谢林老师的介绍。对。😊，呃，首先就是接在林老师后面演讲是非常有压力的。

然后我觉得是呃给大家呃简单先介绍一下我们flagI做的一些事情。首先我认为坚定的去开源肯定是会推动和降低整个大模型的门槛。我们也希望能够通过开源这种方式。

让更多的小伙伴们一起加入到这个大模型这个行业发展中来。然后呃虽然看到这个曲线，它的star并不是特别多啊，因为还等待大家各位的一些帮帮助，然后投入。呃，但是我们想做的事情是说。

我们希望打造一站式的高效应用灵活的大模型的算法与工具，去解决刚才上一页PPT中讲到的那个些问题。😊，就是呃现在我们训练了qui，然 diusion等等这种大模型。在这个训练的过程中。

我们面临了很多的问题。首先第一个是说，现在有很多开源的加速的呃各种模型并行，数据并行的一些开源框架。但是呢这些框架特别的就是开源技术特别的呃复杂，然后呢，标准不太统一。

在这种情况下去学习和使用某一种开源框架进行大模型的开发是比较困难的。当然如果你坚定的只选择一种，然后坚定的去为这一种框架去排坑是可以的。像我们之前一样去一步一步把这个坑都汤完也是可以的。

但是这个时间周期会比较长。第二个是说各种不同的加速技术，然后去呃他们复杂的交接在一起的时候，组合在一起的时候，会影响到整个系统的稳定性，导致你训练不收敛，或者是导致你训练的效果不达预期。

在这种过程中怎么样去呃解决这种兼容性差的问题。所以说这个是呃技术比。复杂一个点。第二个点是说，现在有很多开业模型，我不呃就是大家可以通过很方便的一些方式得到一些开源模型。但是开业模型它的质量怎么样。

它能达到一个什么效果。其实我们是在真实应用的场景中是很难去去去感知或者去体会到或者评价，得到一个一个比较好的一个结果。我们需要投入大量的时间和工程的呃人员去把这个算算法复现，然后下载下来。

然后去做一些对齐，在我们的那个真实的业务数据中去做一些验证。所以这个成本非常高，花了大量的时间验证了很多我们不用的模型。第三个是说，除了这除此之外，大模型是一个新兴的领域。这个新领域有新的技术。

有新的研究点，有新的问题。那么我们在这么一个复杂的过程中，怎么样去让更多的人去接触和加入到大模型的这个行业中，推动这行业的发展，是我们希望能够做到的事情。所以说在这么一个时间成本。

人力成本和精成本非常高的一个大模型开发的这么一个问题和前景。呃，这个行业中，我们希望通过开源的方式来来来做一些贡献。对我们提出了一个叫flagI的大模型开源的框架架构。

我们的c模型和之前很多呃视觉和多模态的模型都是在这个框架下进行训练推理，然后开源出来。然后呃在这个过程中，我们有很多坑已经蹚过了。所以说大家可以很方便的基于我们踩到我们肩膀上继续前行。

我们这呃之前的话就是用的bM券对变M券进行的技术进行了升级，然后提高了它的训练的稳定性和提提高它的训练效果。同时我们把微调的loura推理加速大文件的处理等等。呃，甚至于国产芯片服务器的一些支持。

我们都做了很做了很多很多工作。近期我们也是准备把F就是的FDP这种技术做个集成做个加入。所以说整个如果需要去做一个大模型的新手的入门，甚至到中级，你要训拟一个中等或者是大规模的一个大模型。

都是已经完全可以满足需求。所以说大家可以去试用，然后然我们也可以在开源设区中空过去讨论，去探索怎么样的一个更好的技术，能够发展，或者是去训练更好的一个大模型。对，呃。

因为因为我们现在还是在一个呃因为我们的人力肯定是有限的，所以说希望能够利用开源的力量，让大家一起来加入到这个开源社区，通过扫码，然后加入我们的群里面。然后我们一起去讨论，一起去交流。

然后能够共同的去推动不只是flag AI，甚至是整个我们中国或者是整个世界开源的一个项目的一个发展。对我要讲的这么多，谢谢各位嗯。😊，好，谢谢谢谢。好呃，感谢啊呃林老师啊，刘广老师的精彩分享啊。

接下来有请啊北京呃智源人工呃智能研究院。😊，技术平台智能测呃智能评测组负责人杨希老师。好呃，杨希老师将会为我们带来这个刚才其实李老师刚才已经讲过了啊，叫flag e well。😊，呃呃。

大模型评测开源项目OK啊，掌声有请。哦。好呃，大家下午好啊，呃，我是呃资源研究院的杨希。然后呢，我今天代表我们资源研究院跟大家分享一下，我们最近发布出来的flag e天秤啊。

大模型的开源呃开源评测体系以及相关的那个呃平台。那首先来说的话呢，大家都知道大模型其实是一个呃一个快速发展的这样的一个领域。早在2021年的时候，其实IDC它就有了已经有了一个呃一个报告。

当时他就预测说呃超大规模的这个大模型的它它的这个发展将会引领一个新的一个潮流。那当时的人们就会觉得它是一个呃会会在产业以及学术界会有非常大的一个发展。

那么所以的话呢就是说在各大企业以及高水平的一些研究机构上面都会在大模型上面去做一些发力和布局。那我们也可以看到，特别是从。啊，拆GPT出来之后，引发了一波一波更更大的一个一个热潮。那那最近的一段时间。

不管是模型的数量，还是说大模型所处的领域，也都会越来的越多，可以说是到了一个百花齐百花齐放的这样的一个呃11一个境地。那。啊，那那那首先来说的话呢。

其实是说技术模型大模型它在LRP领域的话是首先爆发的那但是呢它的这个爆发的话，对于我们评测来说，其实就带来一个非常新的一个挑战。那难点他这个这些难点在于是说首先大模型，特别是大的大大语言模型。

它的潜力其实是很难刻画，很难评价的那也就是说我们的大语言模型它是规模大啊，然后结构复杂，它具有非常大的待开发的潜力。但是呢我们很难捕捉或者是说刻画到它的这个潜力，它具体的一个形式以及上限是什么？

那我们如何能够捕捉到它的一个上限以及它的这个能力，其实对我们评价来说，其实是一个比较大的挑战。就直观上来说，例如说我们有有一个赛车，有一个公交车。那我们用传统的方法来说的话，他们其实是都可以呃达。

到一种完成一个任务，就是说达到我们想要的一个指定的一个地点。但是呢其实这种评价或者是这种任务并不能够体现出F一赛车它的这种速度啊，也不能体现出公交车它的一个载客的这样的一个能力。

所以是说我们要怎么去刻画大模型的这种潜力，或者是它的能力，其实是我们要关注的一个点。啊，第二个点是说，在我们传统的这个评测上的话，其实是以任务为先的那这种的话呢，就是说传统小模型的时代的话呢。

是说我有一个任务。然后我在这任务上有一个好的表现。那我这个模型其实就是呃就会比较好，我就可以去商用，可以去落地。但是大模型的话呢，它其实具备了很多的通用的能力。

那它已经突破了单一的这种任务层面的一个限制。在很多的下游水下游任务的过程中的话呢，它可以完成很多的这种下游任务。因此的话呢就是说从任务的这个维度再去评价的话，其实还是远远不够的。

另外的话就是传统的一些基于任务的这种啊评测方法以及评测的基准，其实在对大模型的这个评价上面其实已经有失效了。那这里边呢有举出来一个例子，这个是啊斯坦福大学，他们对大语言模型提出来的一个hel框架。

在它这个框架里面，它就提出来说，在传统的一些例如summarization这样的一个。任务上来说，传统的ground truth所谓的ground truth就是人写的这种参考答案。

其实从质量上来说已经不如大模型它输出的这种答案。那同样的话，基于这种呃ground truth来做出来的。例如说round two这样的一些指标，它其实也失效了。所以对于大模型来说的话，怎么去评价。

以及它的评价的指标是什么？其实也是一个需要探讨的问题。那第三点的话就是原有的一些，我们可能更关注的是，例如说在准确性上面的这样的一些指标去评价。但是呢大模型的出现，那我们可能要考虑到会更多。

例如说鲁棒性啊，例如说它的一些不确定性。例如说它的一些效率。那那这些的话都会呃影响大模型的它本身的一个呃会对大模型的它的整体的一个发展，提供很好的一些帮助。

那我们也希望能够更全面的一些有指标化的体系去评价大模型。那第四点的话是大家都知道啊，训练一个大模型非常的难。那它的成本算力成本，人力成本都非常的高。那就我们自然而言的话。

为了训练大模型一天的就是一个语言模型，一天的他的一个成本大概是在10万元以上。那如果我们在训练的过程中，不能够及时的看到呃看到模型存在的一些问题，以及模型的发展的一个趋势。

我们就放任模型自动化去让他让他去跑，让他去run。这个的话会造成极大的资源浪费。同时的话是说除了是说算力人力以及经济上面的这些浪费以外的话，它会带来的这种环境的影响也其实也是巨大的。所以的话呢。

在这个过程中的话，就需要评测与训练相结合，希望的是说通过为群这个通过评测，为训练过程能够提提供及时的反馈，去提供及时的监测。那如何去去去把两者去结合起来，其实也是一个比较大的问题。

最后的话呢是说其实大模型目前而言的话，嗯缺少权威的中立的一个评测的榜单。那helme的话呢就是塞坦福大学出来的那个helme榜单，其实给我们呃指了一个比较好的方向。但是它仅仅的话是呃支持英文。

它不支持中文。那在我们中文世界上面的话，其实并不是很友好。那这个榜单的意义在于是说，不管是对于科研团队而言，还是对于企业界的，想要去做大模型相关的一些落地的企业而言的话。

他们在选型上面其实都存在一些问题。因为大模型他想要去评测需要的算力和人力的成本其实是巨大的。对于有有一些团队的话，想要把所有的这些模型都做一遍评测的话，其实呃其实没有没有没有这么多的一个成本。对。

所以因此的话呢我们呃就是基于上面的几几个考虑，我们致援的话呢，在科技部2023的一个重大的项目的一个支持下，我们就要开发了一个flag e啊开源的这样的一个呃评评测的平台。

那我们期望的是说能够在这个平台上覆盖全领域覆盖整体呃整个的呃模型的它的一个生产的一个生命周期。那呃并且的话支持多芯片，特别是国产芯片的一个框架和呃框的芯片和框架。所以呢我们这个目前的话呢。

这个开放平台的话呢，第一期推出来了三大人呃三种呃评测的一个方法。一个是说我们对大语言模型的，它从能力任务指标这个三维的话，我们做了一个整体的一个拆解。另外的话，对于多模态以及文声图上。

我们开发开放了一些相关的一些评测工具。啊，大家有兴趣的话，可以到我们flag e的呃平台或者是工具呃那个呃gitthub上面去看一下。顺便给我们点几颗星。😊，对。

那从呃从刚刚我们提到了说大语言模型的它的整体的一个评测的呃能力来说的话呢，我们其实是呃考虑到在传统的上能力任务指标其实是混在一起的，没有进行个好的拆解。

所以的话呢我们把模型的能力任务呃指标做成了一个三维的一个评价体系。所谓的能力的话呢，其实就是刻画这个语言模型，它的整体的一个能力的边界。它能为我们做什么？它能达到一个什么样的程度。

那另那我们怎么来探测呃，这它的能力在哪呢？那就要用我用到我们的任务。那我们用不同的任务去探测不同的能力。

或者是说在一个能力上用不同的呃任务去探测都是去可都是可以的那我们这样的话就把能力和任务进行了一个拆分。那具体的话要我们如何用呃量化的去刻画它的这个呃在呃的大模型的能力。所以的话呢。

我们又提出来了四大的呃。呃，四大指标。所以这样下来的话，我们一共可以做600多个维度的全面的一个语言模型的一个评测。那到目前为止的话呢。

我们现在是呃整个也是包含了22个主客观的这样的一个评测数据集8万多道的这个题目。当然这些的话可能还并不足够。我们还需要去做进一步的探索。而且我们在做能力评测的这个框架的时候。

我们还特意一定也把安全以及相关的价值观的评测，作为一个非常重要的部分啊放在了里边。但是呢这一部分的研究还是属于一个起步的阶段。我们还需要在这上面有很长的路要走。具体的话，我们是说呃要去怎么评测。

肯定还是离不开数据，离不开任务。那那我们一期发布出来的这些呃一共包含了55项任务啊。中英文分开算的话，特别有中英文的选择问答，中英文的文本分类，还有一个中文的开放问答。那这些数据的话。

其实来源于主要来源于两两个方面，一个是呃开现有的一些开源的一些数据集，一方面是我们致源与像北京大学等等这些共建单位一起合作的共建的共建的数据集。

那这些数据集呢其实就是为了要弥补一些一些我们能力上面评测的一些空白。那对于一些开源的那个数据集的话呢，我们是做了一些做了适应性的调整之后，把它做的统一化的处理之后，才放到我们平台上面去进行的评测。

然后呢，现在的整体的所有的数据集几乎可以包呃可以覆盖我们刚刚建立的那个呃能力。体系的评测。对于评测的方法而言的话呢，我们其实采用了两呃呃采用了两种方式，一种是呃客观评测，一种是主观评测。

那这两种方式的话呢，它各自有各自的一些目标以及它的特点。那从客观上来是客观评测的话，也就是说呃他的这个任务主要是以呃客观的这种任务也就是说有标准答案的这个任务为主。那它的评价方式的话呢。

我们是以一个 context的一种方式。那我们可能给他一些通过pro给他一些fe shot或者是 shot的一些提示，让他去完成相应的任务。那在这个评测过程中的话，我们需要注意的其实是为了保证公平性。

我们对于数据对于算力，都都对于各个模型的话都需要进行统一的处理。那它的整体的一个特点是说他的评测的数据量很大。那快速非常快。那他适合的话是方便对我们的模型进行快速的一。验证。

但是呢它的缺点在于是说它能评测的这个能力其实是有限的啊，它能评测的维度是几是是比较有限的那我们的一个资源来自于是说有丰富的一些现成现有的一些Bnchmark以及一些自动化的一些工具。

可以支撑我们去做快速的客客观评测。那仅有客观评测还不够。我们需要做一些主观性的一些评测，特别是对于这种对话的模型。那所谓的主观评测的话，指的就是没有客观标准，就或者是说就是没有标准答案的这样的一些试题。

那这些试题的一个评价的话，还是要以人为主义呃，这种形式的话就是以这种对话，就shop接 shot的这种形式去进行的一个一个评价。

那我们的评价的话是严格按照呃严格遵循着这种背靠背的这个整体的一个这个标注去去去进行的。而且我们的标注人人员一定是非经过了多轮的呃评测的这种标准的一个培训，大家都对于标准比较的熟悉且对齐。嗯。

但这种主观评测的一个特点是说它的能够评测的数据量其实是有限的啊，然后速度是比较慢。但是呢它的优点就是说它评测的能力的维度会非常的丰富。而且我们可以及时的发现啊，模型的一些特点。那目前的话呢。

我们支源的话已经建立了一个比较非常的有。经验的这样的一个标志团队来支撑我们做人工的评测。那对于回到模型而言的话呢，我们对于模型进行了两种拆呃拆解成了两种。一种是基础模型。我们认为是一个基座的模型。

那对于这种基座的模型的话，不太适合用主观的评测方法去进行评测。所以我们使用的是客观的一个评测方呃评测的方式去去评测。这个里边的话还特意加了一些特呃提示学习的这种评测。也是要看这种大的模型。

它在什么样的程度的时候是可以涌现出in contexttex learning的这种能力的。那对于微调的，也就是大家呃，例如说现在的一些对话的这种模型啊，这种的模型的话呢。

我们是除了用客观的像呃跟呃基础模型一样的评测方法进行评价以外，那我们又加了一些主观的评测。那主观的评测的话也分为大概两种，一种是说呃人工全人工评测啊，全人工评测就是多人评测加加仲裁，得到最终的一个结果。

那或者是人机评测。因为人工评测的这种呃时间周期以及它的这个呃工作量确实是很大的。所以呢我们尝试着使用了GPT4来辅助我们进行一个评测。当然，但是GPT4的结果也一定会和人进行一个呃进行一个对齐嗯。

那在我们呃支援的话，本身是有Q拉的这个模型的。嗯。啊呃智源本身的话是有大模型的一个训练的那在这个训练的过程中的话呢，我们的评测的话是有相关的自动化的评测机制啊，也有一个自适应的评测机制。

那在这个整体的一个自动化评测的机制的过程中的话呢，我们的主客观的话，是完成了整体的一个自动化的一个流水线的这样的一个评测。那我们可以做做到一个全自动的一个衔接。那对于各项的一些效率。

就这种评测的效率也是有逐步的一些提升。我们使用了很多的。比如说推理服务的并行啊，并行化，还有评测的各个阶段以及评测数据不同的一种变行化的一些处理，提高了这个评测的效率。另外的话呢。

我们也做了一些适应性的一些评测。那根据模型的这个类型啊，还有它的这种呃状态啊，选择不同的不同的评测的一个策略，最最终是形成了一个结呃做整合成一个最终的一个评测的结果。

那我们在评测的开始以及结束以及它的整个生命周期，我们如果发现会有一些错误的时候，那我们都会把做写成一个自动化的通告。那相关的这些这些告警的这些机制的话，也会同步给各呃相关的一些同事。

那这样的话极大的提升了我们在训练过程中呃的这样的一个衔接的效率。那也就解决了我们刚刚说大模型呃，就是开头呃这个大船南调头的这样的一个问题。最后的话呢我们现在flag的话目前支持多芯片多框架的一个评测。

也就是说上来的这个模型，我们不局限于是说它一定要是在呃在英伟达的芯片上训练的，也不局限于它一定是要我们其实是要积极的去推动国内的芯片以及框架的相关的一些一些发展。

那目前的话呢从AIAI的这个框架上来的话，我们目目前是支持呃拍和这两种。后边的话我们会继续的去扩充。然后芯片的话呢从平台平台上面现在已经集成了像武纪昆仑新，还有升腾。

就是那个鹏程云脑的那个升腾的集群相关给我们提供了相关的算力，支持我们进行相关的大规模的这种评测。那最后的话呢是说我们现在在对开源的一些小规模的语言上的语言模型上进行了一个评测。那目前的话呢。

我们的Q chat是目前支持中英双语，并且性能最优，并且它的开源是商用协议许可的一个对话的模型。那我们其实是。大家可以看一下，就是说呃我们。呃，我我们整体的一个就是那个数数字的第一列。

就是min的主观加客观的那一列。我我们是已经达到了所有模型当中是最最好的。特别是在中文的中中文的这个客观和主观的领域都是所有的模型当中是最好的。

特别需要提到的一点是我们的b模型只用了不到600B的 token。然后我们的SFT的数据只用了的只用到了14万，和同类同级别同量级的这个模型来比的话，我们使用到的数据是非常少的。

所以是说我们用了很少少相对少量的这种呃优质的数据就可以可以训练出一个呃比其他的那些呃多的多数据训练出来的那些呃那些模型还要好的一些效果。不过当然的话，我们在英语上的话，确实还是有一定的差距。

这个也跟我们使用的数据数据的这个呃这个构成是有。关的我们在我们的整个的500多B不到600B的这个token当中的话，英文占了呃不到一半。所以是说能达到这样的一个水平，也是很很了不起的。呃，目前的话呢。

天鹰模型的话，现在已经在呃已已经在flag AI就刚刚刘广博士推那个介绍的那个项目里边已经集成进去了，欢迎大家去使用去下载。然后我们的开源协议都是最宽松的。那最后的话呢，就是说我们大模型的评测。

刚刚我们也提到了有面临了很多的问题，很多的困难。我们现在虽然有一些初步的探索和初步的成果，但是呢其实还有很长的路要走。那那首先是说我们会要后边的话是说要集成和字眼很多的维度的呃评测的数据以及评测的工具。

那我们要覆盖更多的啊例如说多模态视觉呀，语音啊领呃领域的这种呃大模型的这种评测的能力，我们也需要去进一步去提升。另外的话呢是说从语言模型而言的话呢，其实我们现在的呃评测。

其实仅仅是触碰到了语言模型的很表层的一个部分，并没有呃有很多本质的问题并没有完全的能够去解答。例如什么它是不是具备智能，它是不是有心智，它的它是否有真的是有认知能力，以及它的认知能力到底是什么？

其实这些问题这。一些本质性的问题还没有真正的去刻画和完成。那我们希望在接下来的一个工作中，能够与很多，例如说呃呃例如说社会学，例如伦理学，例如心理学这样的社会学科。那跟我们一起去探讨。

那怎么样的话能够把大模型的这个评测做的更加的全面，更加的科学啊，然后呢这里边这这这边是我们上线的一个那个呃上线的平台，欢迎大家注册那边是我们flag的一个开源的工具，也欢迎大家去去下载。

去去给我们提相关的一和PR啊，期待跟大家有进一步的合作嗯。谢谢。😊，啊，以上就是我的报告，嗯，谢谢大家。😊，好呃，谢谢啊杨希老师的这个精彩分享。呃。

接下来有请hugging face机器学习工程师黄静雅为我们分享主题演讲AI快速增长年，来自hgging face开源社区的新进感，掌声有请。😊，嗯，好，谢谢杨老师的介绍。

今天也非常高兴能够参加呃志愿大会的AI开源论坛。然后有机会为h face开源社区在去年一年做出的一些进展，做一个非常简单且快速的汇报。😊，那首先。介绍一下我自己呃，我叫黄静雅，呃。

我是hugging face的一名machine learning机器学习工程师。然后我在hugging face的主要工作是一些针对硬件方面的呃对开源模型训练和推理部署的优化的工作。

然后同时我也是hin face开源呃模型提速库opim的维护者。呃，首先什么是gging face？我相信在座的大家可能或多或少已经了解hgging face，或者使用过我们的平台我们的工具。

或者是看到过我们对呃机器学习知识传播做出的一些分享。那对于还不太了解什么是gging face的朋友这里简单的做一个关于gging face的介绍。那hgging face呃对于hin face。

我们的理念非常简单，我们的目标就是我们想要民主化好的机器学习。那这就意味着四点。首先第一点就是开源透明是我们的信条。第二点就是我们非常注重呃去开发高质量且非常易用的工具。

来帮助大家更快的去推动机器学习的工作，同时降低机器学习的门槛。那第。三点就是呃我们知道今天的这个机器学习的doomain是一个非常快速发展的一个呃一个doomain。

然后呃所以我们希望通过合作的方式和不同的organization以及社区的贡献者能够快速的迭代我们的工具，使他永远保持在前沿。然后最后的最后也是最重要的一点。

就是呃人工智能的道德标准永远是指导我们整个开源开发过程中的一个很重要的信念。那这就是呃hing face。呃，那接下来就进入今天汇报的正题，那就是在过去的一年当中， face做了些什么。呃。

这是一个非常简化版本的 face的开源生态，在去年的今天与今天的一个对比。我们看到我们在去年的一年当中，我们有了新的合作。呃新的模型。然后新的开源的数据及新的开源工具。

包括我们发现去年的很大程度上AI的浪潮，其实是由一些应用去来掀起去推动的那我们在应用层面上也做出了我们的一些尝试。包括我们也持续在呃机器学习道德伦理风险管控上持续我们一直以来的一些工作。

其中包括参与一些呃机器学习道德伦理标标准的讨论以及制定。那接下来让我们把时间倒回。去年的今天来看一下我们当时的开源工具的一个情况，包括我们的开源库，以及我们的开源平台h face hub。

让我来快速的过一下。首先是我们的transformer呃工具。呃，我想可能利用 face呃这个平台，然后去做开发的朋友很多都是通过它来首先认识到那我们一切故事开端就是从我们的fo开了版本的开始。

然后后面一路我们的贡献者去拓展transformer库，然后形成了我们今天的一个开源社区。那今天在transformer上面已经支持超过100种模型结构，可以让使用者可以快速的训练和使用。呃。

我们 face上面成千计的模型。那同时我们也支持多种的 learning的框架，包orflow以及google的ja。呃，接下来再快速的谈一下我们的taet库和evalu。那数据和模型评估的重要性。

刚才几位老师已经讲了非常多了，也不需要我再强调了这两个库也是希望可助大家更方便的完成数据的获取和准备以及模型的评估工作。那taet库呢就是为了让使用者能够快速的获取以及分享数据集。

而evaluate则是实现了一些模型评估的希望能够建立呃一些模型评估的标准。那当然在呃大语言模型流行的今天，我们知道很多可能evalu里面的me对大语言模型已经不再试用了。那呃我们也做出了一些新的尝试。

比如说后面会提到在space上面有一个 leader我们采用的就是当然指。他的选取是一个非常值得探讨的问题。然后不同的朋友也会有不同的意见。那对于hugging face来说，呃。

我们去做这样的一个leaderboard或者是这种leader board文化。一方面是我们希望去评估这些大语言模型的真实真实的能力。那从另一个角度来讲，今天有那么多的开源模型。

使用者可能更多的是希望我能够快速的去通过某一些指标。哪哪怕它并不全面去对比比较这些模型。那leaderboard可能更多是从这个角度出发，希望给我们社区的开发者一些参考。

那在evaluate的这个问题上面，其实我们内部也在做一些工作，也希望呃能够更好的帮助大家去标准化这个evaluation的问题。然后后面也可能会后面也会开源出来，欢迎大家持续的关注我们。

那上面提到的工具，大家已经可以去利用他们去做完成一个呃machine learning比较完成完整的那个workflow了。那in face作为一个开源社区，呃。

很多朋友们说我们是machine learning界的gi。那确实我们确实也有gging face hub这样的平台。在上面我们的社区成员可以找到超过20万的预训练或者是微调过的模型。

里面也有包括有3万家的开源数据集等等。那inface hub主要有三个模块。呃，一个是模型数据集，还有一个就是spaces，也就是我们的demo。呃，关于模型，我们开源的模型呃，多种多样。

包括了自然源处理computer visionaudio以及一些多模态的模型。同时在垂直领域，我们也有过也有非常多的呃微调过的模型，比如说针对生物医药金融数据等等。

那我们的社区成员可以通过t呃我们的t和以及下游的任务来很快的检索到他们所需要的模型。同时和giub一样，我们呃你也可以在 face上面提交p request，然后不停的更新迭代一些模型。

然后我们也有呃dicussion这样的模块，帮助开发者能够和其他的开发者共同讨论。但与。gi不太相同的是 hub作为 learning的gi它对机器学习做了一些优化定制。

比如说我们可以通过model card模板快速的上传呃你的开源模型的介绍。同时在 hub上面，你也可以快速的上传你的模型评估的。然后并且关联到自己相关的一个demo。

同时呃关于 set的这个呃 hub上面的呃开源也是和model相相似的概念。啊这里就不多讲了。那第三个模块可能大家了解的相对来说会少一点。

那就是spacespaces其实就是希望能够在大家开源了自己的模型和数据集之后，能够快速的做一个demo。首先我要介绍的一下的是我们的gradio开源库。

那gradio的开发团队其实是在2021年的12月份成。为了huin face工程师团队的一员。那通过gradio库只需要仅仅几行代码，我们就可以快速的搭建一个可以交互的demo。

并且在huin face space spaces当中快速的呃展示你的模型或者是数据集。这是一个例子。那我们刚才已经提到了非常完整的相对完整的一套工具了。

那接下来我们的需求可能就会从如何让我们的模型跑起来训练起来到如何会有更高的需求，也就是对速度对吞吐量等等的需求。那我们有两个通过两个不同的库来满足这方面的大家这方面的加速需求。

首先是acelrate accelerateelrate是一个简化分布式训练和推理的库。通过acelrate，其实大家只需要插入几行代码，就可以完成包括数据并行呃，等等的一些feature。

然后同时我们也集成了deep speed实现的。比如说zero redundancy optimize这样的 featureature，以及呃M对呃tenor并行提供的一些 feature。

那另外一个库olopim同样是希望能够达到速度上的优化，但它的实现的角度呃。和acelary不同im为了提高呃训练速度减少推理的响应时间，我们更多的是从硬件的性能出发。

比如说我们和微软的onex runtime团队合作，通过图算融合高效内存管理等方式，在CPU和vidia的GPU上面实现了加速。同时我们也加入了对模型量化的知识。

包括动态的量化静态的量化以及量化感知训练等等。然后我们也还和一些专用的AI芯片厂商合作，让他们的硬件可以无缝的去接入到face的生态系统呃，去克服AI编译器的一些限制，降低这些专用芯片的使用门槛。

那好的，我终于讲完了，就是2022年之前hin face以及已经存在的一些开源工具，以及他们在今天的一些形态。那现在我就来讲一下，在2022年到2023年，我们又出现了哪些新的开源的工具。

以及一些新的模型。😊，呃，在这里我选择了三个时间节点来标记去年的时间线，一个是stable diusion的开源，一个是chatGPT。然后就像刚才杜老师说的，它是呃去年这个AI浪潮的一枚核弹。

然后以及拉ma的开源。那在chatGPT3的时代，其实hggingface发起了一个叫做big science的项目。我们集结了来自全世界60多个国家的reearer，然后去研究大语言模型。

我们利用法国的zz呃超级计算机去，希望去能复现呃GP three。然后我们训练了一个呃17000亿参数的bown模型，并且在2022年的7月把它开源。然后它的license也是可以商用的。呃，很可惜。

我们在当时在evaluate完之后，我们发现他们并没有能达到GPT3的一水准。但是呃它作为一个可商用的大语言模型，它其实为后面的许多工作做了一定的基础。包括今天我们可以看到非常多的高质量的大语言模型。

其实也是以bom and为基座模型去完成的。而在8月份，我们就迎来了一个呃可以说是AIGC的去年浪潮的一个序幕，也就是tabletable diusion模型的开源。

那这个模型其实是基于慕尼黑大学和海德堡大学的学者的laten diusion这样一个工作去完成的那face也开源了一个新的库，用于训练，以及使用这些预训练的扩散模型，包括文声图文声音频。

甚至是文声呃3D的分子结构。呃，这里举一个例子，大家可以看到，比如说用这样的几行代码，然后我们其实就可以调用runway呃ML的stable diffusion的模型节点，然后完成文字到视频的生成。

那接下来在open AI在2022年的11月底则发布了chatGPT它可以说是街棒stabletable diffusion掀起的AIGC浪潮，进一步的推动了大语言模型训练的呃开源。

我们在今年的2月初的时候，然后metta fair也开源了lama模型。transformer library也是第一时间其实就加入了lama模型的结构。

同时 face也发布了LLM的一个leaboard它用的是usI的 language evaluation harness呃，就像我刚才谈到的呃刚刚在讲eval的时候谈到的。

其实我们更多的是希望从某一些角度某一些指标能为使用者提供一些模型的比较的参考。那同时在呃应用层面，我们则做了一个叫做tt作为t g的一个替代品呃，同时在 chat的这个 uI的代码。

其实我们也是开源的这意味着什么呢？就是t它其实背后目前用的是open assist模型。但是大家可以利用chat u的这个代码，然后调用任意的上的呃开源模型快速的搭建一个tboard。

那除了刚才谈到的big science，其实face在今年和service now也是共同合作发起了另外一个呃大语言模型的项目，叫做b code项目。

并且我们在上个月的时候发布了代码的大语言与训练模型star那star其实是利用呃来源于gi的上面的许可数据训练了一个15亿参数，并且支持超过8000个 token上下文 context的一个大语言模型。

在数据集方面，我们同时也开源了用于训练呃b code star的呃数据集，并且还提供了一个叫做op out的工具。呃op out工具是什么呢？

这意味着大家可以在利用这个op out工具检索自己的代码是否在b code的数据集当中。当你不想要你的代码在保持在这个数据集当中的时候，你可以选择就是提交 issue，然后让我们删从。

这个数据集中删除你的代码，并且不再用于下一轮的训练。而就在前天的时候呃，我们是在5月初的时候发布了star code base。然后在前天的时候。

我们在它的基础上利用falcom的呃refin web数据即又微调了我们的star code，发布了star code plus的版本，让star code进一步的提升了呃通用大语言模型的能力。

而且star code plus其实也是呃完全开源可商用的。这里我们也做了一个叫做star chat是一个编程助手。它的阿法版本是基于star codestar code base。

而beta版本则是新一版的star code plus。欢迎大家去测试，用它去写代码，然后并且给我们一些反馈。哦，太好了，我终于讲完了。呃。大家可以看到我刚才以一种非常快的速度过了一遍整个的生态系统。

因为呃主办方跟我说的是让我讲一下新一年的进展。其实新一年做了非常多的工作，我并没有办法在20分钟的时间内很快的去过掉所有我们的工作。然后所以有非常多不详尽的地方。

也希望大家可以到我们的生态系统中去使用这些库，使用这些模型，然后进一步发现更多的一些开源的工具。那在最后的最后，因为今天是一个AI的开源论坛。我更希望可以在最后分享一点，我在做AI开源工作的时候，呃。

产生的一些小小的思考。那第一点就是我觉得AI开源很重要的一点就是需要每个人都可以参与进来。😊，嗯，这是为什么呢？首先从比较小的落脚点出发，想要构建一个非常活跃的一个开源生态。

我们必须要让每一个人能够有参与感互动感。这样可以增加大家对于这个开源工具的粘性，然后让我们的开源工具能够获得更好的发展。因为对于hinface来说，其实我们并不希望说我们的开源工具的发展。

和我们在上面去maintain这个库的工程师的数量是一个线性增长的关系。我们希望可以和通过合作，包括调动呃社区贡献者的力量，然后一起去完成呃这些工具的完善。那从更大一点的角度出发。

就是为什么每个人都应该去参与到这些呃开发工具的这些开源工具的开发。其实我们可以看到，可能去年还没有这个感觉。但今年我们可以明显的感觉到，虽然AI他没有马上把我们带到一个新的时代。

但是他已经开始在我们生活的方方面面去重塑我们的生活了。包括现在呃全世界的很多不同的地区和国家，他们已经开始去制定一些AI监管的规则去限制AI因为这个AI对人类的冲击实在是太大了。

那对于这样一个新世界规则的制定。我们所希望的是其实不仅仅是行业的工作者，其实每一个人都应该参与这个规则的制定。那在开发一切工具的时候，我们的落脚点都是一定要易用易入门。包括大家如果去读过我们的代码的话。

就会发现它非常的简洁，而且以及扩展性非常的强。其实我们希望的就是大家能够很好的去上手，甚至你不需要是这个领域的专业人才，也可以快速的去扩展，增加自己的需求，并且进入了解这个领域。呃，第二点时间不太够。

那我就赶赶赶赶紧讲讲我的第二点思考。那就是我对开源工作的思考。呃，过去年是AI发展非常快速的一年，我们可以看到每天几乎都有新的工作发表。然后每个星期会有非常优秀的大模型发表。

那每个人可能都会觉得非常的应接不暇。包括呃我的很多同事其实也是这样的。我的一个同事叫做nathan，他写了一篇文章叫做behind feels like to work in aI now。

里面就提到了呃学者们现在对快速跟进AI发展，其实也是有非常多压力的。因为有时候有很多噪音会影响到我们的专注力。呃，对于我来说，作为开源工具的开发者，我也会遇到同样的问题。

那我觉得最重要的就是一定要去享受这个过程。因为我觉得。😊，开源最重要的一件事情就是。Have fun。好，谢谢大家。😊，好呃，非常感谢啊黄景雅的精彩分享啊。

这个黄景是刚刚是特意从法国飞过来来支持了我们的大会的，是不是啊，非常感谢对。😊，好嗯，接下来我们有请华为mine book开源生态总监胡小曼呃，带来主题演讲AI大语言模型开源生态发展与大模型平台构建啊。

掌声有请啊，有请小曼。非常多的人，我现在前面可能还看不太到，后面基本上都已经占满了。那今天非常荣幸的跟大家来去分享这个AI大模型开源生态，以及我们做的生大模型平台。在这一块的开源的实践。😊，呃。

我今天分享的主题是呃包括三个方面。第一块是会跟大家分享一下关于AI大模型整个开源的生态。第2块是华为AI大模型的全景的架构。第3块是我们在做生思大模型平台的一个平台技术的架构以及相关的技术的分析。呃。

其实在AI这一块，从1956年的达特毛斯达特毛斯的会议到现在啊恰GPT发展。其实他经历一个非常长的一个时间，他也不是一直都是直线上升，或者是指数级的上升的这么一个趋势。

那么从过去的感知世界到现在的生成创造的世界啊，从我以前做基器学习工程师到现在做生态这一块，会发现它有非常多的一个变化。我们过去的话可能更加偏向于从数据做数据挖掘，做啊数据清洗特征提取。

再到现在的啊这个生成创造世界之后，我们会发现很多啊我们我们传统的可能就已经跟啊之前的训练的方式，就已经发生了一些变化。😊，那么大语言模型它其实是从一个量变到质变的一个过程。

我们其实在恰GPT和更多的实验当中发现。当这个语言模型的规模超过了一定的阈值之后，它产生了一些非常超出我们预期的一个能力。可能大家也都啊体验过，包括AI作画以及GPT等等。

我们现在体验的这个AI它能生成的效果，跟我们过去啊使用AI训练模型生成的效果可能已经完全不一样了。那么增大模型容量呢有几个有效的方式，这个就不太在赘述了，包括增加模型的参数。

增加训练的数据以及增加训练的轮数等等。那么其实从我们看到GTG one啊G two到现在的啊从G oneG two到G我们可以看到它的参数量，其实其实是一个成指数型的发展。

它不是一个说我今天个G发表的参数是1。17亿。我下一次就是2亿或者3亿，而是我G的时候，这个参数量已经到达了15亿G已经到达了1750亿。

所以这个发展的话跟我们以前可能看到的啊加一定的这个数据集扩充数据集，然后再去训练得到的这个模型的参数的这个发展已经完全不一样了。我们可以看到GPT它成功的关键呃，给大家总结了一下。

当然这个可能也只是我们各呃自己叫什么各自己自家的这个看法。首先第一个它一定是需要一个庞大的算力的。那么可以看到他在训练这一块就用了992块的GPU那在训练一次就需要高达40060万美元。

总的训练成本是超过1200万美元的。所以对于现在的整个大模型的生态来看的话，如果不具备相当足够的算力，以及足够的这个人工标注的数据，是很难处是很难去训练得到出这么一个大的大的这个语言模型的。

那从技术的角度来看的话，GBT它的一个非常过人之处是它引入的RHF就是人类反馈的强化学习。我们以往的话通常会啊比如说标注数据，标注数据之后，通过人工啊标注，然后再放到这个模型训练里面去训练。

那么呃在模型上线之后，可能需要通过啊大家去测试，得到这个back case，再把这个back case拿到模型里面再去训练。那么现在GPT他引入了人工反馈的强化学习之后强化比较强化优化了这个数据集。

就能够让它模型的效果更优。所以我们整体可以看到GBT如果想要在国内商业化或者说其他的以各家为代表的这种大模型，想要在国内商业化。其实对于算力，对于集群软硬件都是有一个非常大的一个挑战的。呃。

下面的这几个模型呢，其实可以看到这个模型的它所需要的算力，基本上是超过超过这个1000块的卡。那么在这一块呢，我们会看到，如果想要做一些关于大模型的商业模式的话，我们大概分了三类。

第一块呢是云服务的变现。这个可能大家会比较常见，包括百度云、华为云智能，还有其他的云等等。第2块是业务升级。比如说我把传统的这个搜索的模式啊，比如说像并它结合了这个GPT像百度，它引入了文心一言等等。

啊，再把这个传统的业务进行升级。那第3块是模型和数据的解决方案。因为现在看到的这些大语言模型，它还是更加偏向于一种通用的模型。那么这种通用的模型，你要用到各个不同的行业，尤其是锤类里面。

怎么样让他得到更好的更加精细的运用。所以这一块呢是有很大的想象空间的。那从这个AI的发展到现在呢，我们把这个整个产业链拆解成3块啊，第一块是数据供给，第2块是模型的定制。第3块是这模型产生了之后。

我们怎么样通过这个模型产生的结果来进行内容的分发。所以可以看到，其实整个上下游的各个赛道都是百花齐放的。而且大家都在探索各种各样不同的这个商业模式。从最上游的数据的标注数据的供给数据的生成等等。

已经跟以往都发生了天翻地覆的变化。那么在中游的话，包括内容的设计内容制作的工具啊，以及其他的，甚至你拿着这些内容来去在版权许可的情况下去做周边内容的售卖等等啊，以及下游的这个各个内容的创作及分发的平台。

其实现在在我们生活当中，以及各个app里面都有非常广泛的运用。那大概也梳理了一下整个呃目前我们看到的国内或者说海外做大语言模型相关的一些公司，嗯，这个可能看的不太清楚啊。其实可以看到基础层基础层的话。

基本上都是头部公司再去做。因为你没有这个足够的算力，没有足够的基础设施的这个架构这个人员，包括啊这块技术架构的一些规划，也是很难把这个基础设施做的啊非常好，或者说跟或者说非常有竞争力。

那么在中间的这个啊中间层的话，你看像包括呃各个高校他们做的啊这些大语言的模型以及这种中间型的应用等等。那么在应用层的话，这块其实初创就非常非常多了。不仅仅是包括CV领域NLP领域。

然后语音领域推荐领域等等。其实每一家都会根据啊已有的开源的大语言模型或者是自研的一些大语言模型来去做相关的一些应用。那么到第二部呢第二部分来给大家讲一下这个华为AI的大模型全景的一个架构。

那么在最底层的话是我们的升腾硬件。那么除了这个啊我们常见的升腾的啊那个叫什么那个升腾的这个芯片，我们还有这个升腾的集群来去支撑这个大大规模的这个模型的训练。

那么在中间这一层呢是我们现在负责的这块的AI的框架I框架啊其实大家也都应该非常熟悉在海外的话是有这个google代表的flow然后facebook发这个发布的当拍已经捐赠了，他可能不太属于某一个公司。

那么在基于这个框架之上，我们又开发了一些相应的工具，比如像这个大模型的一些开发套件啊，包括微调组件部署的工具等等。那么在最上面一层的话，我们就做了一个大模型的统一的服务平台。

因为我们会想到我们开发的这么多大模型怎么样去用怎么样让开发者甚至企业甚至不同的行业能够做到非常好的去运用。😊，这是对很多企业或者说对一些头部厂商一个非常痛点的问题。因为训练一个大模型。

实际上是非常耗人力和非常耗金钱的。那么怎么样把这个钱或者说把这个利润收回来。这个RY怎么能够让你训练这个模型是值得的。那么在工具和平台上这块是非常值得花功夫来去做的？那么在升腾这块呢。

我们现在已经发布了包括CVNLP多模态、语音等等各种不同的这个领域的大模型，以及包括呃科学计算这块的大模型。那么刚刚其实提到了很多关于大模型这块，那么大模型你肯定是要用框架去训练。

传统的话一般是用tensorflow或者拍拖会训练的比较多。那么今天为什么要单独去提一下框架这个概念呢？其实很多时候或者说很早以前我们最开始运用的大部分都是开源框架。比如像现在可能已经废弃了的C啊。

包括像后来的car等等，这些我都用过。然后再到后面的tensorflowflow一点几二点几拍拓等等。那么框架的发展一定是随着我们的数据集的发展，算力的规模的发展，同样的去产生能力的进化。

那么在去呃my是2020年3月份开园的。那么从呃2020年到现在差不多有3年半的时间。那么这三年半的时间，我们现在整个份额已经达到了全球的top3国内的top one那么在学术生态的份额的话。

在去年Q4的时候，在pa code就这个是收纳啊基于某个框架去写的这个论文。那么在这个学术的份额这块，去年Q4是超过了teorflow达到了top个第二的这个位置。然后仅次于。

当然今年的话我们在学术这块也会持续的发力。所以整体来看，AI框架它现在发展的话是经历了4个阶段，可能早期是偏向于我们自己工程师啊，简单的去写一写代码去跑下这个demo。然后再他后面的学术科研比较领先。

所以产生了这个拍拖，然后以及拍拖生拍拖的生态持续的快速的发展。到现在的话，如果这个框架它很难或者说没有办法去支持大规模的啊这个模型去训练的话，那么啊。他被抛弃，或者说他的这个生态的这个示威是显而易见的。

那么回到这个刚刚说的啊m是2020年3月份开源的。那么在2020年9月份，我们就发布了1。0的版本。那么在现在的话，我们已经发布了m2。0的融合框架。那么在这个现在的融合框架，我们包含这么几个能力。

第一个是他是三方框架兼容的。因为我们联合起社区开发的一个叫做MS adapt这个工具能够非常方便的去帮助你把拍拓的模型转化成m模型。因为很有可能很多人他并没有接触过这个框架，它要去上手的话。

还有一定的成本。但是你们之前可能训练的模型是拍拓起来训练的。那么这个时候我们可以直接用这个工具，非常方便的先帮你转化，转化了之后，先看一下m到底训练的效果怎么样，是不是足够的啊方便上手等等。

那呃加上这个生腾910的芯片能够快速的去提升你的这个模型的性能的话，就能够可以帮你去啊非常快速的方式去看到m的能力。😊，那么截止到现在呢，我们整个下载量已经达到了480万。

然后在gityAI的开源的项目综合排名是top one，已经服务了5500多家企业。现在已经发布了400多个模型和600多篇的顶会的论文。然后有在整个开源生态这块有1。3万的贡献者。

然后有30多个不同领域的这个C个组，也非常欢迎大家和开发者来去加入。在框架这个层面上呢，我们可以看到呃动静态图的转化，这个能力实际上是非常重要的。如果这个框架它还是只停留在静态图的话。

那么在我们再去做学术科研去实现最新的论文的时候可能会发现不如这个支持动态图的这个拓写的框架好用。但是静态动静态图它之间可能会有一些应用性上啊或者是性能上一些损失。那么在这一块呢。

我们在动静态图的能力上进一步的提升。尤其是在典型的一些网络上，比如说像101这个动态执行的性能提升了33%等等。那么在开发态这块，我们的编程的门槛进一步降低啊。

整个API的完备的幅度呢也大幅的降升降大幅的这个提升。我们新增了400多个接口，然后已经覆盖了90%的拍拓写的技术和数据类的API。并且m是啊能够延伸的去支持大模型的训练推理全流程的技术闭环啊。

在开发和训练这一块，那除了它能够非常高效的去支持分布式的训练，我们也同样提供了两个非常关键的工具。一个是当这个现在已经集成到了生模型平台里面。

大家可以非常方便的去用里面基本上包含了我们现在最主流的一些预训练的这个模型，包括GBT这个bom，还有这个ma等等。然后ion呢是啊现在主流的一些扩散的模型。

大家可以直接去调用这个里面的预训练模型来去再去做学习等等。在微调里面，我们也提供了mad这个微调的工具。但这个微调的工具，它目前能够支持多种的低参的调餐，低参的微调的算法。但在部署这块。

我们还有这个m for light，这个可以帮助你在呃服务端训练完的模型之后，可以非常方便的转化成各种不同终端终端的模型去识别到各种不同的这个硬件上面去。但除了是原生的能够支持大模型以外。

我们还能够去支持科学计算。在科学计算这一块呢，其实我们做了非常多的工作。第一个是包括啊在生物计算这块，比如说像m sp。

这块其实是和昌明实验室以及呃深圳湾实验室以及北大的高琴老师的团队一块联合开发这么一个套件。这个套件其实是主要是用来计算分子蛋白的分子的模拟就是。啊，我慢点说，蛋白质的分子结构模拟啊。

那这个的话比他们原本的做生物，做化学这块领域的人手动的去计算它的效率能够提升10倍。第2块是msport flow啊。第3块是mport elect，分别是针对于电磁仿真和流体力学等等不同的领域。

所以刚刚提到了一些比较主流的啊开发训练部署以及A计算的这些套件啊，除了这些套件的话，我们还有其他的一些套件。比如说像m flow啊，比如说像这个m oCRmV以及LLP等等。这些套件的话。

它是能够集它已经集成了主流的so塔的模型，然后提供了一些非常易用的数据和模型的接口，大家可以直接去使用这个套件，能够达到开箱即用的目的。😊，那这个就是刚刚给大家提到的啊。

我们开发的一个工具叫做MS adapt，它能够支持第三方的框架，能够非常方便的去实现大家做到低成本的迁移。

所以我们和中科院的啊中科院自动化所子动中科院自动化所的王金桥老师团队联合发布了子动泰出的多模态的大模型。去年的时候是发布的1。0的版本，然后在WAIC上获得了最呃世界人工智能最高奖。

那么今年我们又发布的2。0的版本。啊，这个可以提一下。嗯，大家也知道之前的话，前段时间新冠确实还是非常影响大家生活的。

那么这个我们联合鹏程实验室发布的鹏程神农是能够预测下一个可能出现的啊那种类似于新冠的病毒的分子的结构。我觉得这个对于呃对于整个人类社会上来说，都是还是非常有远大的这个意义的。

然后这个也当时呢也入围了啊哥伦贝尔的新冠特别奖。啊，这个就是我刚刚说的啊，联合抗病抗病实验室做了两个非常大的创新场景的应用啊，包括抗体的血液设计以及动态蛋白结构的解析。

那么我们在做了这些啊不同的大模型之后，怎么样去支持行业的客户呢？嗯，我们联合的头部银行去开发了一些支持他们行业领域的数据的这个小型化的模型，包括他们能够啊这些小型化的模型部署在他们行内的话。

可以做包括票据识别OCR通用识别，以及他们去用AI作画这种方式去生成他们想要的金融领域的这种图片，或者说海报，能够去支撑他们行内啊日常的这些去通过啊设计师来去生成的这些海报，极大的去节省他们的人力。

那我们整个生色的生态啊，全年大概有200多场活动，包括我们的首届峰会啊，不同类别的MSE的城市型、校园型等等，也非常欢迎大家来去参与。那么第3块是讲到这个大模型平台，但是我就有3分钟了。

可能不能给大家讲的这个特别的详细嗯。😊，算力我就不用这个重要性我就不用多说了。我重点说一下，我们为什要做这个平台。其实这个平台也是呃我们去年我们前年9月份的时候就构思要做这个平台。

因为当时会发现大模型确实有很多东西都出来了。但是呢很难去得到非常广泛的运用。那么做这个平台的目的呢是一是简化大家的这个应用成本。第二个是能够帮助大家去做更好的部署。

加上你们的行业数据可以做更好的迁易学习。那么这个是在当时陆奇今年的他的演讲里面，我们摘取的两个我觉得比较重要的PPT这个这个这个信息吧。他讲的这个平台这块呢，有4点我觉得是必须必备的。

如果大家要做一个平台的话，第一个是这个平台一定要有非常有效的算力。第二个是大规他能够支持大规模的训练。第3块是他有足足够完备的开发的工具链。第4块是他有非常丰富的开源的模型数据集等等。😊。

那么整个平台它能够提供的功能。第一个一定要完整，它能够做到开箱即用。如果说在你这个平台上还得非常费劲的去使用，你的使用成本还非常高的话，那大家完全没有必要去使用你这个平台。第二个是你的商业模式要清洗。

因为平台确实非常就在大公司里面可能我们还能够呃让这个平台活一段时间。但是如果是初创去做平台的话，实际上是如果没有想清楚商业模式是会很得不偿失的。第三点是要有杀手机的应用程序。

所以依托于啊我们在全国各地大概30多个城市部署的生腾的AI计算中心啊，通过这个AICC的算例，我们做了生死大模型平台。那么在这个平台上，我们现在能够。啊，不仅包括数据的前期准备。

包括模型的预训练下游任务的微调模型的转化部署等等。我们都有相应的工具，能够去支持你们把啊这个数据集上传，或者是我们去做私有化的部署，能够非常方便的去做这个模型的下游任务的应用。

那么刚刚给大家也提到这个form呢其实上一位这个face黄同学也讲到他们有有一个trans那form呢其实也是类似于trans一个类似的工具。那我们在form里面集成了非常多的预训练的啊模型。

那这个模在这个把这个套件呢又放在jupyter里面。那大家直接在jupyter里面去调用form里面的预训练模型。不知道这个大家会不感觉很绕啊。但是直观点来说就是我们把这些工作都做好了。

大家只用直接在这个模型这个平台上去体验就可以非常方便的去使用。😊，那这个。那这个平台上呢，我们现在啊依然也提供了一些其他的应用性的工具，包括AI实验室。

那左下角的这个也要再感再次感谢一下facegra的团队。我们也同样把这个grad的这个工具集成到了我们这个平台上，非常方便的去做这个可视化。

那中间这个AI作画呢是现在我们有一个呃悟空画画的AI作画的开源的大模型。这些都是用户他输入不同的这个提示词之后生成的这个作画。😊，那除了像面向于开发者这一块啊，我们提供了这么多应用性的工具。

面对行业客户，尤其是我们最近和一些头部的金融公司头部的国企头部的一些集团合作的一些项目里面，我们也会发现啊，在有了这些大模型之后，他们很难去做一些落地的应用。那么我们平台可以跟他们去共建垂直行业的专区。

我们可以对他做私有化的部署。同时他们在数据不出网，保持数据安全合规的情况下，也能够去做到啊行业的大模型，部署到他们的内网，去做啊实际的应用，解决他们的生产力的问题。

那么现在我们已经有电力、工业、医疗和人文几个不同的这个行业的专区。后面的话我们也会新增，包括金融、石油等等其他的一些专区来去帮助他们做行业的落地。好，那今天就是我的分享的整体内容。

非常欢迎大家关注我们的公众号，我们会提供最新的技术的资讯以及最新的活动。😊，好，结束。好呃，感谢小曼精彩分享。😊，🎼呃，接下来呢我们有呃有请这个any skill呃m呃，龚俊来给我们带来。

🎼an open array and open source framework for distributed mL啊，原本这个环节分享的这个呃这个ray data的团体经理呢。

这个苏成呢因为因病来不了，希望他能够早日康复了啊好。我来啊再讲一个，早上我在那个AI system已经介绍过瑞啊但是那个ta可能更注重的是在呃呃这个机器学习嗯N to end的那个workflow上啊。

然后这个我想主要介绍一下呃，我们在open source最近的一些啊工作。然后我其实昨天晚上才知道我要cover这个事情。所以如果大家觉得有一点准备不充分的话，啊，敬请原谅啊。

嗯。OK然后。开源项目嘛一开始就是。大家就讨论这个这个gethub store的事情嗯。嗯，我也不知道为什么，刚刚我看hing face的那个那个图上也是拿那个spark和卡夫卡做对比。

然后我们这个图也是用的嗯。spark kafka呃就。从呃到上个月为止吧，到23年5月份为止，我们的那个呃star数量已经超越了卡夫卡现在正在朝着这个park方向接近。嗯。

我们可以说这个community的还是不错。嗯然后也正好是借助这个大模型的这个蜂潮吧。an skill一直的就是说嗯这个model这个呃继续学习的这个模型的呃增长速度应该是远大于这个物理硬件的增长速度。

呃，所以我们一直觉得就是说嗯你要你要从从单机走向那个多机啊，从单机的训练走向这个分布式的训练是一个不可避免的事情。这个也是整个compan的sis，然后嗯最近由于大模型的出现。

这个速度好像愈发愈发加快了。所以所以我们看到它的这个op的这个增长还是不错。然后也很幸运的吧，因为呃因为他们的创始团队还算是比较有啊分量。

所以我们有很多的那个呃open source的 user和partner啊和我们一起呃共同建设这个这个library。然后其中其实呃蚂蚁一直都是从很早的时候就是一个呃非常大的支持者。

然后也给了很多的工作和帮助。嗯我可能待会会嗯 come back to these some of the use cases。OK然后。还是一样的介绍一下这个re的这个呃嗯产生发展的这个历程。嗯。

re其实一开始的时候是在呃博伯克利的一个叫rise lab的嗯一个嗯computer labs。然后我们的两个 founder当年都是做那个家乡学习的呃博士。呃，然后他们做家乡学习的时候，就会发现。

就是说你做家乡学习的时候，其实家乡学习的部分啊倒相对简单，这个算法也并没有那么复杂。然后它的ski也比较小。然后他们就是在不停的写那个呃分布式计算的code嗯。

老是在那边跑那些物理的那个模拟啊什么之类的。啊，老是用那个GRPC去那些啊。呃，从从那个呃远端的机器上去把那个呃training data给他 fetch过来，然后做training。

然后他们就说要不就去写一个framework，然后把这件事情搞得简单一些。嗯，这个就是整个嗯ray这个这个library的开始呃，也是为什么就是说这个。作为一个分布式的这个嗯。呃，框架。

然后他们第一个做的这个library居然是一个家乡学习的 library，这个是很奇怪的一件事情。但是 historicallystoricallytheres a reason behind it。

然后家乡学习这件事情，其实如果你做过话，就会知道他这个啊是出了名的不稳定，然后也很难用啊，你如果做家乡学习的话，这个hyperpre tuning就是第一件要做的事情。

以他们写完了re之后就就接着写了一个这个hyperpri tuning的这个reune library。嗯。然后做完这两个libbra之后。

他们就很很快就意识到就是说呃他们写的其实是一个很通用的这个呃分布式计算的一个框架。呃，可以使用在家庭学习以外的很多地方。呃，所以那个时候就会呃就就an any skill就诞生了。

然后呃an skill就成为了这个呃re背后的这个商商业化的公司。啊，然后在在此之后就再增加了嗯deep learning啊啊呃也补全了那个呃。呃。

inference和那个嗯data ingetion的那些呃那些部分。呃，如果你现在今天去看的话，嗯，其实re这个 ecosystemstem已经是涵盖了啊端到端所有你是嗯。呃。

机器学习需要用到的嗯最最最重要的那些部分，包括呃数据的预处理嗯输入，然后呃深度学习。呃，模型的这个部署呃呃超餐的这个不好意思，有些但是不是很熟啊。呃。

呃超餐的那个调调调调整和那个呃和一些workflow的那个呃呃逻逻辑。呃，这个就是我们其我们想要做到的事情。

就是你如果看那个呃mine learning这个open source的这个cosystem的话，其实呃现在是处于一个百家争鸣的状态啊。

也并没有说哪一家独大或者嗯整个整个整个整个行业consoli到哪个地方。啊，所以嗯我们就想就是说用一个整完整的cos ecosystemstem，使得他们这个呃库和库之间的这个交流会呃结合会会更好一些。

呃， userer用起来的话会更呃流畅一些。呃。然后简单介绍一下这个ra呃设计的思想。嗯，这个其实也是我当年为什么。选择加入这个公司，我觉得嗯他们的设计理念还挺呃。

叫什么ele他们就是把那个呃pyython的那个一些概念，把它映射到那个分布式计算里边。比如说那个pyython的 function，其实你可以把它想象成一个呃一块计算，对吧？

然后你如果把这个functionate一下之后，你这块这个计算就可以被移到其他这个远端的机器上去执行啊，然后想象这个呃microserv或者说你一个deeploy service啊。

其实就是一个actctor的概念，就是这个他把map到那个thon的 class上每一个这个class instance啊mray就会自动帮你deloy成一个啊一个serv。嗯。

然后有了这两个piece之后，他们就再buil了一个sed memoryory space嗯， calledobject store。呃。

这样的话就是handle这个这个嗯嗯分布计算中间的这个嗯通信的问题。呃，然后他还可以顺便就是说去优化呃这些数据的流向，嗯。

帮帮你节省就是不必要的那个数据的传输和那个呃seilization和desilization。嗯，这个其实是整个这个ra thesis，就是这么一点。嗯，它的API其实还是蛮。简单的就是说比如。

比如像现在这里的两个function，嗯，然后你有一个pyython class。然后all you need to do就是你只你只需要加这么几个嗯decorator呃，read到 remove。

然后突然之间他们就变成了一个在源端执行的一个呃一个一个service和一个嗯一个compation。然后你你instead就说你本来你要写很多的那个er play code呃，对吧？

然后现在你都你都直接他们就帮你呃藏在那个pyython的那个呃source code的背后。呃，然后你想要做的事情。

其实就是instead of calling这些呃这个这个这个function直接去call这个 function，你你你做到remmo。然后这个时候啊，你其实是在一个远端机器上执行了这段这段code。

然后你拿回来其实也是一个future，就是说你不会直接把这个数据拿回来。in case如果你下一个competition还是在远端那个机器上的话，那这样你中间就不会incur那时候呃多余的那个呃通讯。

呃。that's the idea其实啊然后我觉得这个还是蛮umele的，呃，也也比较 generic。呃，然后他 handle了一些呃。

就我我们我们kind of我我们一直说这个read这个obion个obstruction嗯感觉是在一个呃right level上，它可它是 generic enough。

但是hide enough of the the pain points。嗯，然后for use case wise嗯就是我你如果看那个 openen source的呃。使用的情况来看的话，呃。

最最常见的一种做法是呃体量相对较大的公司会拿我们的那个开源的部分，在他们的公司内部就搭一个平台。然后这个平台作用就是使得他们公司里边的那个呃数据工程师，或者是他们的机器学习工程师就。

就是他们他们只需要去考虑这个pyython side of things，他们就是只写pyython code，也只跑pyython code。

然后相对的相同的pyython code可以在嗯本地机器上嗯调试，也可以直接就sit给那个呃read cluster，然后就可以被deloy成一个很大的那个comput。

然后这样的用法其实包括spotify cruise Shopify，他们其实都发过那个呃block post啊，如果有兴趣的话，可以读一下。然后更加相对重磅一点的嘛，其实就是嗯open AI因为。嗯。

他们其实那个开发GBT four的时候，其实是在那个readd那个class上开发的嗯。呃，feedback是说这个呃开发的效率会高很多。然后嗯他们的ski也比较吓人。我们经常给他们。

Haack hack things wrong。呃，然后如果你看那个。嗯。benefi wise就是说这一张图是instacar share给我们的。嗯，他们在没有用ray之前。

他们的那个ubernet的那个cluster utilizationil一直都不高。然后因为有了这个ray比较灵活自由的那个啊调度之后，嗯那c最高的时候就啊真正在被人使用的时候是可以到百分之八九十这样。

呃，另外一件比较有意思的这个呃开源。活动最近发生的是呃我们的co team上有一个ber克利的那个博士生。然后他的博博士 thesis其实跟re也很相关。然后他在re上做了一个bench，他就是。呃。

terabyte sword这个好像是他们这种大规模。呃，并行计算的人一个比较重要的那个bench，就是看你可以用多少钱去sort100个teraby的 data。呃，然后用ray来做的话。

我们是第一个。把这个cos的做到1块钱以下啊，每TB的那个呃呃框架。这个还是而且它的code其实是很很简单。

就是说嗯因为ray天生就比较适合做这种嗯这个这个这个控制和运行无数的那个呃小小的那个那个计算的这这件事情。所以。嗯，所以我觉得可以拿来在这里提一下。呃。

然后另外一件比较有意思的事情是呃我们最近做了很多的这个对read data赛做了很多的优化。data赛本来的用处是给那个嗯机器学习做呃做输入有的。

就是data loading和data ingestion。然后我们在调优的时候发现它跟市场上其他的那个嗯solution比还是有一定的优势啊。呃，因为首先它是呃pyython native嘛。

然后它build ray的话，嗯，对这种比较啊大量细索的这个这个工作，它就有一定的嗯天生的优势。然后也是一样的，我们做了一些呃bench。呃，和比如说sage make的那个。

batch influence比它就快了大概有十七八倍。嗯，然后和哪怕和park的那个。呃，调优过的spark cluster比我们都快了大概3倍左右。嗯，究其后面的原因。

其实这个也是一篇嗯就是发布的block post，你们也可以去呃看一下究其原因里边主要的原因就是因为你这个ine learning的时候，这个model都是t在那个thon。然后sk其实是在java。

所以spar在做这件事情的时候，它的数据在thon和java之间不停的在那边seization和ization来来去去啊，外加park对那个呃不同stage的那个fusing。嗯，做的有一点不好。

就是他会很ag的把所有的stage都在一起。这样的话，如果你有一个GPU的t，它是包在那里的话，你的CPU就不能 fully utilize。

但是ra就稍微呃ray在那个ex plan上就稍微呃自自由一点。呃。对，然后另外一个事情就是我们最近呃上个月吧呃上个版本就把这个re data set的那个execution mode变成了那个streaming mode by default。

这样的话就是我们经常发现就是你在帮一些呃大的用户来调的时候，他们的呃data injection经常就会wo啊。

因为这种呃大型的deep learning那个d size基本上你很难凑到说这么这么多多量的那个呃CPU memoryory去去hold it。嗯，所以我们自从把它改成streaming之后。

就解决彻底解决了这个问题啊，ray data会自动的去就是apply back pressure，然后m sure你的这个CPU和GP是pro的情况下，它就尽量的帮你去prefe足够的足够的数据。嗯。

最后讲讲这个geneativeVI的事情嗯。呃，geneary其实瑞嗯参与的也比较早了，大概一两年前就有很多的合作，像那个cohere和。和那个open aI的ta都是发生在去年的那个re上面上了。嗯。

然后more recently就是最近的话嗯在刚刚结束的那个GTC就是Nvidia的那个conference上，我们也有一个talk，就是elpa的那个performance嗯做的其实也很好。

然后alpa整个的那个tion就是它这个大模型的这个呃执行，它是bu在上的。嗯，然后基于这些吧，我们最后最近在最近的那个2。4版本里面也发布了嗯很多的那个呃of the shelf的这个嗯事例。

告诉大家怎么在ra上面跑那些大模型的事情。呃，然后我们take的一个稍微有一点不一样的角度。就是说呃我们在做这些事情的时候，发现这个其实现在。高端的那个嗯GPU卡是很难找得到。

所以嗯我们就就是说利用re的这个特性，所有的事例都是呃让这些大模型跑在呃。多个小的那个note，用小的那个GPU来确一个很大的啊很大的模型。然后有的时候这样做到，反而在成本上也有呃也有优势。啊。

大家如果有兴趣的话，不妨去呃看一看。然后。然后for serving，我们其实也做了一些呃工作来增强它的那个scalability和那个streaming support for这个大模型的那个use case。

呃，然后就在上个礼拜，反正我已经在中国了，然后他们呃在美国团队，他们发布了一个叫aviliary的东西，其实有一点像是炫技的感觉。

就是我们claim说我们有这个reer这个library是可以sve大模型的。然后他们就发了一个。嗯，算是样板吧，就告诉你我们不但可以 serveve一个，我们还可以 serve很多个大模型啊。

你可以一起跑，然后那些东西都是会自动的sscale up，s down的。嗯，根据你的traffic，然后嗯如果你有一个re cluster在呃跑的话，嗯。

你可以试一下这个基本上就可以拿来servve嗯sve open source model了。😊，呃，然后我加了一个ro map的slides啊，其实这个是我今天早上自己加的，我也不知道准确不准确哈嗯。

😊，从从re的角度来说，我们这个cosystem因为比较广，它cover了很多很多不同的事情。嗯，所有的这些东西都在不同的呃tage里边。co的话，他们的最主要的问题还是呃增强这个稳定性。

还有就是大模型的时代，你必须要把这个sability做强。然后data set因为呃相对较心，他们里面有很多那个。呃， performanceformance的 optimization可以做。呃。

也会是接下来的重点。然后Rlab的话有一点奇怪，因为Rla一直都是以呃包罗万象各种各样的这个alrithm就拿起来随手就用。然后我们最近发现其实这个。对呃研究者的支支持不是很好。

就是说因为呃research的同志们，他们使用阿类的方式一般都不是你现在写在里面的，他们都是脑洞大开。嗯，这个这个这个改改的地方都基本上嗯都不是特别的of the shelf。

所以我们的方向是要把搞的modularize一点。这样的话你可以把它的piece pick出来，然后去build你自己的al。呃，servve基本上就是为大模型服务了啊。

因为inference是一个很重要的那个大模型的use case。呃，trink tune的话，其实我们的go是在嗯今年的30，也就9月份之前想要把这个API stabilizebilize下来啊。

因为有些地方感觉还是嗯不是特别舒服。然后最后也是要做个广告，因为为呃。呃，是完整开源的这个项目。其实呃公司也很小，都是靠大家帮衬啊，请大家。Contribute。呃，就是这样。啊，感谢龚俊的精彩分享啊。

接下来我们有请张军啊，百度非讲框架产品负责人开放原子基金会TOC委员来给我们分享产业产业级深度学习开源开放平台非讲及其开源社区。好，有请。😊，🎼一強よ。🎼喂。很荣幸参加智源大会。

参加这个AI开源的这个论坛。呃，到现在这个时间下午3点半，我看大家可能有点困了。其实我跟大家一样，也多少有点困了。那今天呢听了很多关于AI的东西，尤其是很多大模型相关的东西。那我的PP里面也一样。

既有AAI的部分也有开源的部分。但是呢呃考虑到大家现在比较困了，所以我准备多讲点开源的地方，少讲点AI的东西。那因为呢开源就像刚才face的小姐姐分享的一样，开源可以让大家开放，这是开源最重要的部分。

那嗯这今天所有的会听下来，感觉嗯。😊，讲大模型的东西讲的特别特别多。那呃这一切的开始，其实就是从呃open AI呃，当然大家现在可能很多人吐槽他，因为它不够open了。

因为open AI开始把很多东西他都闭原了，不开始开源出来了。那从他们的cheGPT开始。那呃他们出了che的GPT之后呢，那嗯。😊，呃，google做了一个bar的也是一个开也是一个大模型。

当然也没有开源。国内的大模型也是非常非常的火。国内最早那呃做了一个嗯就是百度做的是一个呃大模型的一个产品。因为现在应该有不少人已经拿了他那次账号已经可以开始测试了，叫呃文心一言，可能有不少的的人听说过。

呃呃我今天要分享的部分呢，其实是呃训练出来文心一言的。我们的一个开源的深度学习平台叫分享。呃，当然了那个呃。😊，文心语言出来之后，其实国内很多的公司也在做这些大模型的产品和服务。那阿里有一个叫通一千问。

那有点像是那种你出上联，我出下联的感觉。那你出了一个微心语言，那我的下联就是通一千问听起来还挺对账的，是不是那呃其实在呃深度学习框架和平台这方面呢也一样的是国内一直是做了很多很多的事情。

那可能很多人在知道说是在训练大模型的时候呢，用的是一个呃叫呃叫to很火的一个深度学习框架，包括像face的呃生态里面有非常大量的模型是用的拍to训练出来的那呃国内呃其实也一样。

也有很多现在开源出来深深度学习框架。刚才华为的的小姐姐分享了，叫华为的max4那那其实max pro也有个上联去拍ddle拍ddle。paddleped是国内最早我们开源出来的这个深度学习的框架。那嗯。

首先先跟大家简单汇报一下，其实百度一直在AI的开源啊，尤其甚至在开源领域，我们做了很多很多的事情。那呃从最早我们去contribut一些很有名的一些开源的项目，像像大数据领域的。

那呃到后来我们呃开源了呃深度学习平台ddle。那同时呢我们也是很多呃很知名的这些这些呃开源的基金会的这些成员。呃呃在整个AI开源上面呢。

其实也是有一系列的这些开源的动作的那最下面其实今天是今天我要给大家介绍的是是开源的深度学习平台paddleddle那呃他有一个中中文名字叫飞讲。那呃这在这事上呢。

其实我们有很多基于飞讲做的呃全面通用一些AI的能力，包括视觉呃自然源处理，还有语音技术。这些。其实这当中我们。很早很早就开源了很多的这些模型。

我们的最早的算法库里面大概有600多个是算法都已经开源了出来。当然那当当当然当然因为那时候还没有像现在这个大模型，大家一说好像你搞模型算法都必须得是非常大的模型一样。因为因为在这里顺便呃嗯稍微提一下。

因为大家可能知道如果训大模型的话，其实是需要有很多很多的东西的。首先算力，那一个大的模型是需要有一个大概呃上千张卡的这样一个集群，你才能训得了的那要有数据，这些数据呢可能一些呃互联网上的这些数据。

可能还是比较容易能拿到的。尤其用来训 model。但是SFT阶段，包括后来的RRL呃HF那部分呢也是需要非常多标注的这些数据。那同样还需要很多这个呃很专业的人才算法。

还要很重要的基础设施就是深度学习的这些框架和平台。所以。对需要这么大投入的情况下，其实各家如果把大模型开源出来是有很大的这个顾虑的。包括国外大家可以看到的开源出来的一个模型呢。

那那最大的现在公认的比较好用的就是facebook那个拉ma模型，它是1个65B的模型。那最近呢可能很多有些人知道中东有个土豪，有有一个土豪的机构放出来一个大模型。据说它只有40B。

但是据说呢比那个拉马还要好用。那今天听说是智源也放出来一个一个呃中文领域很牛的一个大模型。那那这样那我是感觉呃智源在做一件非常非常了不起的事情。那呃。

那回过来呃我们看看如果训练大模型的一个深度学习框架和平台到底是什么。其实呢首先是一个开源的开源的项目。那最早我们现在在组织上有90多个开源仓库。那也有很多这通过或者就是跟我们讨论的一些贡献者。

那有两个数据啊呃其实第一个是国内的有一个项目活跃度是是我们在保守。然后第二个其实是我们是也是去年才注意到基金会下面的N他会做一个统计，这上面它有一个榜单是很荣幸上了这个这个榜单。

虽然我们是排名是比较靠后，但是也是很荣幸在那个榜单上世界上很多很知名的开源项目像编程语言开源项目一起在这个榜单上那同时呢大家知道在深度学习框架和平台上其实开源的东西很多。那有的人可能会问说是。😊。

那你这个飞讲到底跟那个拍有什么差异呢？其实我们一直以来有一个很重要的一个价值主张。其实飞讲是一个源于源于产业实践的深度深度学习平台。所以不光有是开源出来，深度学习框架，我们也有很多的产业级的这些模型库。

为了让很多的用户他真正把AI落地的它的应用场景，说我们也有一系列的这个开发套件和工具的组件，这里呢有一个呃大概的一个全景图，那呃从跟刚才其实介绍的也比较类似，从下面的核心的框架。

它上面的工具组件其实都是开源出来的。当然最上面的两个不是开源的。因为那是呃要商业要卖钱的。但是下面这一大大头的东西都是开源出来的嗯。😊，发展的历程呢其实是比较早的。

因为最早呢其实做非讲就是在百度公司内部，为了能够让很多的工程师能够很好的使用一个共性的一个呃平台和一个算法啊，因为最早如果没有这些深度学习框架和平台这样工具的话，那你如果做一个深度学习算法。

要从大科呢开始写起。那你你你你你你你有可能说是我的前项计算写对了。但是我这个就算错了，会很头疼。那所以才有了这些这些这些工具。那百度也是在当时内部建设了，很早是12年就开始建设这样的平台。

那16年的时候开源出来，到现在其实还是一个比较成熟的一些深度学习框架。百度内部几乎所有的业务都在使用非讲。所以这里面也是一个呃百度的文心语言跟其他一些大模型不一样的地方。

百度的文心语言这个大模型呢是用ddle训练出来是我们自己的呃开源的一个深度学习平台。那有哪些呃就是我们自己觉得比较有优势的地方呢。第一个其实还是一个开发便捷的深度学习框架。

如果你用呃ddleddle去呃写一个模型的话，有可能你会觉得代码长得怎么跟那个非常非常像的。甚至有的人开玩笑说是我是不是呃呃port，然后你就可以直接把那代码跑起来呢。

那呃可能对一些简单的模型是可以这么做到的，但是稍微复杂一些可能还是还还是做不太到。因为框架有他自己本身下面那些技术设计的差异会导致你前端的几些接口的交互可能也会有不一样的地方。

第二个呢其实是在呃我们超大规模深度学习模。😊，训练技术我们其实是一直以来比较自豪的。因为其实在呃呃在在今天这个时代有大模型这些技术出来之前呢那。已经在很多地方已经在用大模型解决很多的问题了。

只不过那些模型呢可能跟现在大家今天谈到那些大模型可能还有有些区别。比如说是在呃百度自己的搜索这些业务上其实最早就用的是是大模型。但是他的模型跟现在的呃大家看到这类的可能还比较大的区别。

比如说是我如果用呃百度搜索上的我的模型的conex不用那么长。因为很少有用户说输入一个很长很长的query，你在百度里面搜词的时候，可能你输入十几个字也就差不多了。但现在的这类模型。

它的conex甚至现在可以达到32K这样的长度。那那同样的在搜索领域，我们的那个词表可能会非常非常大大概大大概一两百万的这词表也是有可能的。但是现在的大模型，现在的大的语言模型可能不需要那样大的。

但是但但他们背后的技术有很多是相似的那呃飞讲的是呃通过在百度自己业务实验上。😊，积累了很多的插大规模深度学习的模型训练的技术。第二第三个呢其实是呃在很多很多场景下，它是可以推理的。因为呃一个一个呃模型。

它不光是在云上的服服务器当中可以进行推理。那同样在边缘设备和手机上也要能够推理。那最后一个其实我们是是我们的一个比较大的差异，其实是我们开源了很多的模型库。这些模型的size呢。

可能不像现在动辄说一个模型，你的那个模型大小，你如果没有一个百亿的模型放出来，感觉都不像是大模型，不像在开源模型似的。当然还有很多的模型模模型其实像视觉领域的可能模型。

它其实可能目前真正在产业当中落地使用的时候，它它它那些传统的那些的那些算法，那些算法或者sg的那些算法。那那些模型虽然没有那么大，但是在产业当中使用的时候呢，还是需要这样一个开源的这模型库。

他直接拿来可以用的。那嗯。到底谁在使用飞桨呢？那首先呢百度公司内呢？有基于飞桨的计算集群呢，每个月大概20万个训练的任务。那还有很多推理的服务，飞桨所有的搜索啊推荐啊这些业务都在使用飞桨啊。

这个PPT里面可能忘了加上文心一言也在用飞桨。那同时公司外呢，因为我们一直以来的价值主张是做产业级的深度学习平台。所以很多的这些产业当中，那他可以用深度学习的模型去解决他整个产业当中的实际问题的时候。

他们也会选择用飞桨啊，那这里面有一些具体的例子。比如说是呃中国商飞，我们刚很自豪的自己的大飞机呃，飞行的的那家公司。那他们使用飞桨去做这些呃同像损伤的检测。

那比如说是工商银行用飞桨去做卡证的这个电子的这种识别。呃，接下来的部分呢呃是呃说作为一个开源项目，到底哪些人为飞讲paddleddle做了contribution，尤其是代码上的contriion。

那可能有些人可能会会会觉得说那你是不是就是你们百度的这些工程师在做呢。这当然是很重要的一方面，因为从2016年开源到现在这么长的时间，百度其实一直在这上面为做这个开源的项目有非常非常大投入。

当然这当中最主要的其实研发的投入。我们有专门的研发部门去做飞桨飞讲这个项项目。当然另外一个很重要的呃对paddle做contribut的部分呢是corpoerate contribution。

那呃尤其是飞讲为了能够运行的很多这些硬件上，这些来的硬件公司的很优秀的工程师在con to，那就包括像英伟达英伟达在我们组国的宝岛台湾有专门的工程师在做。😊。

那intel的intel呢呃中当然中间发生过一些变化。那最早是上海的团队，后来呢是波兰的一个团队，就相面中间这部分很可爱的工程师在做pa。当然最近为了更加local的合作呢。

其实是把这部分工作是转到了呃intel上海的的团队。那还有像很多的硬件硬件的公司。像啊像百度自己的昆仑新，还有寒武纪，还有等等很多硬件的公司公司的工程师在为papa做contri。

另外很多很大一部分其实过去这一两年，我们看到呃的。😊，为paddlepaddle做contri很重要的一部分，来自于呃高校的学生和企业的工程师，这些individual contribution的。

他们占的比例也会非常非常大。尤其最近我们观察到他们的比例一直在持续的持续的增长。那呃当然也会有些社区的一些技术交流的活动。我我们一般把它叫做线上的m up。那开会的有一个截图。那呃。😊。

做这样一个ddle这样一个呃开源项目呢，那有些最近呢有这么多社区的个人开发者的参与呢，其实也是看到国内的这些开源的环境越来越好。所以有很多的这些呃工程师他们可以呃贡献到开源里面来，这是一个很重要的部分。

因为大家不太可能说是我们所有的东西都去关注到说是那些大模型领域上去大模型所需要这些基础设施基术软件其实是现在我们非常需要的那如果能给ddle做贡献呢，对很多的社区个人的开发者，他们参与的动力。

我们观察到的是首先是技术上的提升。第二是来自于社区的呃认可。这是我们在做非这样一个开源社区的时候，观察到很重要的部分。那也有很多的社区的个人开发者跟着我们去一起去去成长。

当然那个做ddle这样一个深度学习的呃平台呢，其实呃对于很。社区的个人开发者来说，有一个很大的挑战，他可能自己没有那个呃GPU的这些开发环境。我们也提供了一些线上的GPU的开发环境。嗯。

这是去年的一个呃一个呃社区开发者做的一些项目的一些选集啊。那从比较简单的一些呃一一些呃codeb maintenance的一些工作，到很难的一些变像升级网络编译器的算算开发，都有社区开发者在做。

那整个社区呢其实去年我们做下来是有很多的社区活动。那比如说是呃我们有飞黑客这样一个呃用来做编程挑战的这些活动。那它的呃难度还是比较大的。

然后还有稍微呃轻松一些呃主要是欢迎做一些firs good一手这类开源贡献的一些活动，我们把它叫做快乐开源活动。当然一些社区的这些meet up。嗯，那如果谈到开源呢，呃，其实今天是AI开源的。

尤其是在中国作为1个AI开源的社区，到底跟国外有哪些不一样呢？正好前两天我我我看了一本书，它是讲那个开源的。它里面提到了一个说是如果你作为一个开源社区，最应该避免的事情是什么？最不好的一个工工具是什么？

最不好的一个工具，那上面是说是微信。可能很多人都会这么说。那因为老外呢就说我们所有东西尽量要open，尽量用在me list来讨论。但是呢如果国内做开开源。

没有哪家说不用微信的那这是我们跟国外很大不一样的地方。等于我们有自己的loc的这些特色。那我们做下来呢是觉得做飞展开源社区呢，其实我自己总结了一个词啊，叫国际化的思考本地化的行动。国际化的思考是说。

一个开源项目，你很难说是离开国际上这些优秀的开源项目，你能自己能够独立独立生存的，你不可能忽略了那么多的那些开源的项目。所以就拿pedddleddle来说呢，首先我们要融入到整个开源的生态当中。

所以pedddleddle的 distribution的时候，我们要去兼容这些呃下面的硬件，比如说哭大不同的这个版本，那上面的python的不同的版本。

像python其实如果大家注意到python最近几个版本，他们一直在致力于python本身性能的提升，甚至最近thon有一个计划是要去掉。😊，IL那这些都是很重要的一个工作要不同的OS发行版本。

那要能够跑到很多的AI去。然后呃如果是做inence的话，那型式其他的通也，跟M也要有通。那同在模型上，其实我们也一起做了一些事情在也也有一些模型。

那如果但是呃如果开源这个本身因为社区的参与者都是本地的话，很多本地化比较自己有特色的的事情。那所以在开源社区的运营上，其实我们也有己很多本地化的一些一些不一样的有特色地方。那比如说是包领航团活动。

还产业实践做智动升级的话，很多企业去跟里面的工程师一起去去做的。呃，很很多的AI解决方案上面的一些探讨。那同样的是跟呃一些呃硬件伙伴呢，也是从最开始我们先聚到一起。

然后呢呃先一起做一些呃适配上的优化上的事情，然后再看怎么样去拓展跟硬件公司一起去去去拓拓拓展硬件上的这些生态。这当中就包括开发基于跟pa跟硬件公司一起做一些课程，模型库啊，还有案例这些事情。

我就不展开讲了嗯。对，是呃，这一页是吹牛的啊，我我就不不讲了。那个我们另外一个比较有意思的是那个呃S studio的学习和实训社区。那这上面呢也是有有有有有专门的教学培训，还有开发生态，还有企业的实训。

😊，嗯。对，这是在教育上的我们做的一些事情。因为如果让很多人用到用起来paddlepaddle呢，我们观察的一个很重要的现象是可以先让学校里面同学们先学起来怎么用paddlepaddle。

因为呃大家在学习AI的阶段，如果就已经接触到paddlepaddle，他大概留在后面还能还能会一起一直持续用我们的paddlepaddle。所以我们也也也也相应的也会有一些呃课程和和比赛的一些资源。那。

呃，也有一些书呃，也有一些案例。那。嗯，这是整个吧，就是呃我们从下面是深度学习的平台，然后有维新的大模型。

然后跟企业啊跟技术伙伴一起去做基于非讲非讲非讲的这个呃呃的一个深度学习AI的这个生态嗯那最后这页呢呃这是公司要加的公司的使命。那这页多少还是跟大模型有点关系的。

因为这张图是用呃我们的大模型文心一格画出来的那呃训练出来文心一也维心一维心一格这个呃大模型的呃平台呢是飞讲paddle拍ddle，也是希望通过今天我的这个简单的介绍呢。

能够让大家知道说啊我们有这样一个深度学习的平台拍ddle拍ddle在国内，我们也可以用来做很牛的这些像维心一言这样的大的模型。嗯。我的这部分就到这里，谢谢大家。😊，好啊，感谢张军的这精彩分享啊。

之后下一个我们有请zeice合伙人及呃产品总监郭仁通。😊，带给我们向量数据库，面向AIGC的海量记忆体OK。啊，OK今天看前面的主题主要都是这个聚焦在大模型啊，然后这块呢换一个话题。

希望也是给大家这个调解一下啊，今天主要想跟大家聊一聊这个大模型和向量数据库结合的这一块。那我们Z团队呢其实在全球范围内是最早做限量数据库的一支团队。那在这个限量数据库的这个领域呢。

也是深耕了有超过5年的时间了。那近期呢像AIGC啊拆GBT啊，还有像这个咱们国内很多国产大模型的话呢，都非常的火。那呃也带火了另外一个这个数据库领域，这个新的品类啊，叫做限量数据库。

那今天呢就是想借着咱们大会这个机会呢，和大家聊一聊这个AI大模型和限量数据库这个结合的点位。😊，呃，简单做一下我呃自我介绍啊，我叫郭仁通，然后呢是Zli的合伙人，现在负责整个公司的产公司的产品。

那在呃在此之前呢，我主要是负责技术和研发的工作。😊，呃，在前面呢就包括像这个有有有一些主要的工作啊，包括像呃向量数据库的这个分布式原生的架构设计。呃，还有像这个toy这个项目。

主要是解决非机化数据ETL的这个工具框架这样的一个问题。呃，我自己的这个兴趣领域工作领域呢，主要是在AI和这个数据的呃基础软件这一这一部分。😊，O先给大家做一个background的啊。

就是说讲一讲非结构化数据，然后向量以及向量数据库这么几个概念和他们之间关系。那我们知道说最早的时候呢，这个数据主要是以结构化的这种数值为主。然后呢面向这些数据呢，我们有一个数呃数据库生态啊。

主要是以这个结构化数据C那一套生态为主。那呃再后来呢2000年左右这个文本这个数据都上来了，文本成为这个信息的主要载体。那对应的我们的数据库生态呢，又呃有一套新的内容。

包括比如说这个比较火的像ES啊mongoDB啊，这些都是在这个生态里面。那现在的话呢我们的数据的主要载体呢是以非结构化为主啊，包括我们常见的图像视频音频或者领域内的。

比如说前面这个几位老师讲过的这个呃我的呃生物制药相关的呃化合物结构啊，蛋白质结构啊，还有像比如说自动驾驶领域的点云啊，这些都是属于这个非结构化数据。那对应的话呢，我们要把这些非机构化数据。😊。

应用起来产生价值，那也是需要有一套数据库系统生态的那向量数据库呢就是在这个大的背景下，就是以非计化数据为这个主要的呃数据基础。然后呢是以AI的能力去作为这个数据的这个分析和应用的主要手段。

这样一个大的背景下面的这个数据库生态的一个核心的位置。😊，OK呃，再讲讲技术层面啊，就是说大概这个过程是呃怎么样子呢？我们的非计化数据本身它的这个主要的语义是蕴含在这个数据内部的。

其实很难去以一个比较低的成本，对这些数据直接的做理解分析和这个应用。那做法是我们首先通过这个典型的通过像呃神经网络模型的能力，把这个蕴含在非机化数据内部的这些语义呢，先去提取出来。

然后编码成一个高维的向量。那等于是说我们把这些非计化数据都映射到一个高维的这个向量化的语义空间。然后在这个右边的限量化语语义空间里面去完成对这些数据的呃理解分析查询这样的一些任务。😊，呃。

OK那这个是讲到了非计化数据和向量数据库。那和这个AI大模型有什么关系呢？啊，这里我呃列了一个一个一个问题啊，这是我头一阵子去问的拆GPT这是4。0啊呃，问了一个问题。

就是说拆GPGPT four你你来给我讲讲你自己的这个局限性是什么啊，这第一条就是他讲的很清楚就是说我的能力呢边界完全呃取决于我的训练数据，我见过的东西，我能回答好。见就是没没见到的呢。

这些呢基本上就很难回答。而且很有可能这部分内容是我生成了，但是这部分内容说实在的就是一本正经活说八道。但是这个事呢，我自己又不知道啊，这是他最大一个问题。那对应下来呢。

就是说因为咱们呃国内很多包括北呃这个北美地区呢大家去做数据应用。那这个数据应用的话呢，就有两点非常大的挑战了。一个是我本身我的业务内呢是有很多的这个。😊，或者思域的内容的啊。

这些数据显然是不会出现在这个大模型的训练数据里面。还有一个呢就是说呃我的实时的数据信息，因为大模型本身它去训练的时候，不管是频率还是成本都是比较高的。

很难说把这些实时信息都会去整合到它大模型的这个呃参数里面。本质上来说就是说呃我们去把所有的这个训练数据呢，然后这些呃自然语言的它的信息或者叫做自然语言，它的这个分布呢编码到这个大模型里面，大模型里面去。

但是业务上面来说呢，这些数据呢又很难出现在数据集去造成的这样一个问题。😊，OK那呃像open eye的话呢，他们在很早就意识到这个问题了。就呃一个直接解决方案，就是说大模型搞不了的话，我去做这个外挂啊。

那在今年上半年的时候呢，open eye做了一个非常大的动作，就是结合他的GPT这些模型周边去做一个插件系统。那其中有一部分呢就是这个向量数据库插件。也就是说我通过向量数据库。

然后把所有的这些语义知识性的内容呢，去向量化之后呢，呃给这个通过插件给我的这个大模型呢提供一个知识库的能力。这样呢就解决刚才说呃你垂语也好，或者是实时信息也好。

去呃支撑这个大模型去完成这样任务的一个能力。😊，那我们呃Z这家公司呢是有两套内容啊，在在下面啊就是一个是我们的开源的mususe向量数据库。

这里呢近期应该在get up上面会超越有2万个star这样一个热度。那还有呢就是近期我们呃提供的一套这个呃向量数据库的产品。这这两套开源的和商业化的呃这个能力呢。

在第一批里面已经是被集成到这个open eye的这个插件系统里面去了。😊，OK呃，那从这一点出发的话呢，其实是对于我们现在的这个数据构建的范式呢呃提供了一个新的框架啊，这里我我自己总结就是MVP的框架。

M呢这就指的是这个大语言模型。V的话呢是线量数据库。P的话就prot。那大语模型呢更多的是解决呃这个分析和推理的能力，以及说很重要一点就是呃以这个。😊，自然语言为基础，呃，做这个语言对接的能力。

那限量数据库呢呃就是为这个前面大语言模型提供一个呃long term的meory以及知识库的这样的一个能力。那prompt呢是在结合在两个前两个基础上呢呃完成一个解决一个这个我大语言模型加知识库。

像呃具体的业务适配和对接的能力。😊，OK那这里面其实呃像包括我我观察我观察到就是国内啊，还有北美也好，就是大家其实呃在知识库的构建上面，这一套架构已经有一些落地了。那这里呢有一个思考。

就是呃我们的大模型和这个向量数据库。说白了就是我的这个分析和推理单元，还有我的这个外存，我的记忆体之间的关系的事情。😊，那呃现在我看到就是说不管是全呃呃咱们国内北美或者全球化去做这个大模型的这个竞争。

其实还是在沿着呃一个传统路线。就是说我要去尽可能的把我的这个数据质量做高。然后呢呃训练数据啊，训练数据的质量做高，然后训练数据的规模做大。😊，然后呢，我要找到更好的这个模型结构。

把这些语言的这些分布呢去编码到模型里面，还是这条路。那呃刚才讲到了，就是说这条路其实有很多的局限性。然后另外呃就是我们可以想象一下，就是说其实人的话人脑呢本身的这个参数要比现在大模型要多得多。

但是呃人脑并不会选择，我把全世界的信息都编码编码，然后呢记录这个死记硬背到我的脑子里面。也就是说现在大模型OK能力是很强。

但是我们观察到就是说大量的这些参数都被用在记忆这些这种常识或者是一些这种可以被检索到的信息里面。然后呢呃这些信息其实是可以外推到向量数据库的。也就是说如果我们有一种手段把限量数据库里面。

这些死记硬背的内容，大量死记背死记硬背的内容推到向量数据库这一部分。那我就有更多的参数可以去支撑更强的这个分析和推理能力。😊，ok。😊，呃，另外一点的话呢，就是我等会会讲啊，就是说关于整个端到端的效果。

因为我们现在看，比如说我自己用拆GPOK其实在工作中呢，更多的是一个语言层面的。就比如说我写了一段话，他可以帮我把这些文字写的更好。但是在业务层面的话呢，其实是很难端到端的完成内容。那像国内。

不管是我们知识库还是问答系统或者是什么呃。😊，个人助手等等等等这样的一些应用。其实大家业务上面关心的是更多的是关心我端到端的业务效果啊，那也就是说。

如果我们把这个注意点从只是从这个从只是这个关注这个大模型单一的能力到呃关注三个维度，也就是一个是大模型本身的能力。还有一个就是我的知识库的能力，还有一个就是大模型去应用知识库的能力。

这三个维度去做的话呢，是极有可能在这个业务端到端效果上面超过一个单维度的大模型的能力的。😊，OK呃，这里面是关于我们呃开源和商业化的一些工作啊。因为今天这个时间也比较有限。

我就快速讲一下这里面我们现在典型的呃这个开源项目呢有这么4个啊，就ms的话呢是解决这个呃限量数据库的内核能力。😊，呃，toy的话呢是解决非计化数据的一条的这个框架工具的能力。

像GPT catch呢是解决一个就是线量数据库到这个呃大言模型的一个适配这部分的工作。那阿图呢是解决上面所有的这些生态的一个包括线量数库的一个呃管控的能力。😊，那像呃这个今年的话呢，我们2。

0已经进入了一个呃m2。0呢已经进入一个分定呃非常稳定的一个状态。呃，到今年应该是这个月左右，在gitub上热度，应该会超过2万个star。呃，这里就不展开讲。如果大家去呃这个关心我们项目的话。

可以到我们的这个项目的git upub上面去了解更多的信息。然后呢，另外一个就是toy这个项目是这个解决的是一个的问题啊，就是从最早的非化数据业务那边。然后呢呃ETL，然后再做再进到线量数据库。

然后最后呢把所有的这些大模型啊，向量数据库啊，这些连接到一起。😊，呃，值得一提的是，我们呃今年呢在6月份就会在国内提供这个线上数据库的sas和pass服务。

像在在此之前呢呃比较靠谱一点的这个现上数据服务主要集中在北美。呃，我们会在今年6月份登录像阿里云，然后百度智能云腾讯云，还有这个金山云这样几个主要的云厂商都会去呃，大家可以用到我们的服务。😊，呃。

时间是时间是6月底，然后我们现在呢其实也呃陆续开启了就是呃企业用户的这个申请试用的阶段。所以这一块不管是呃生态合作伙伴，还有就是企业用户的话呢，也可以开始联系我们去呃做这个线下数据库的试用了。😊。

OK呃，现在呃到目前我们重要的一些合作伙伴，包括像英美达呀，还有呃北美这边的这个大的模型的厂商，还有国内的像百度文心言mini maxax，这些都是我们的合作伙伴。那呃云的话呢，刚才讲过。

就是除了北美的AWSGCP以外呢，我们今年也会覆盖呃国内的主要的这个公有云。😊，O。呃，对，这个广告部分说回来，我们再跳回来啊，调到这个。😊，呃。

这个MVP啊就是大模型加向象输加pro engineering这一部分。那这里呢我们在这个呃框架下面做了一个小的项目。这个项目也是为开源的社区做的一个事情啊，这个事大概是理念是什么呢？

就是说现在的每一个开源社区，它的这个知识其实散落在各个地方啊，比如说我有我的文档啊，我做了一个开源项目会有文档会有在scle flow上面大家提的问题或者是我自己的for。

还有就是说像slack或者是企业微信里面大家去交流的问题。😊，等等等等。这些问题。那我对于一个这个项目的成员来说呢，我想去呃了解到这个项目里面的知识。

那这个项目呢就是说把刚才这些各种各样途径的这些内容都为每一项目呢去构建一个知识库。那这样呢每一个呃开源项目的成员，他都可以以对话的形式对这些开源项目，以一种呃。这个问答的方式去获取有史以来所有的知识。

OK。这里举一个例子啊呃这里是问的是GPT four啊，就说唉这个这个ms系统里面TTL是干什么用的？你能不能帮我解释一下啊，这个这个里面就是典型的它出现这个一分钟就胡说八道这个问题。

就说前面一段我们看还是对的对吧？就是这个time to leave这个事呢，前面解释挺好。然后接下来呢他会给一段这个代码告诉你怎么写。但是下面其实大家如果了解ms系统的话，是属于纯发挥的内容啊。

其实按照这个下面去做的话呢，都是错误的啊，但是这个大模型的本身是不知道的。这是GPT four去做。😊，OK然后接下来的话呢，呃我们在这个系统内部其实是拿GPT3。5。

然后呢加上一个结合一个知识库去支撑这样一个任务。那我们可以看到说他对于这个任务实际上呃回答的非常好啊，反过来呢其实证明了我刚才说这个事，就是说呃我拿这个限量数据一个知识库外挂的知识库。

然后去增强一个弱一点的大语言模型。其实面向业务效果来说是可以干得过这个最好的这个比如GPT four的这个大语言模型的。😊，OK这里面这个是这个系统，整个系统架构，我们就不展开讲了。😊，然后呢。

接下来这个实间希望呃跟大家分享另外一个有意思的工作，就是GPTc。😊，就大家用GPT的话呢，会或者其他大语文语言模型会有这么几个问题。就是说呃GPT for非常好。

或者是这些付费的这些大语言模型都非常好。但是它是按token收费的啊，非常贵。😊，然后呢，整个我如果是拿这个东西去上面支撑业务的话呢，呃他throughput其实也跟不上，latency都跟不上。

一个字一个字往外蹦嘛。😊，那不管是成本还是性能来说呢，都是一个比较大的问题。那我们这个项目呢就是解决这个问题。呃，GP开他的思想主要思想是这样，就是说我在这个大元模型上面再加一层。😊。

那一方面呢就是说OK这个图可能看的更清楚一点，就是说我对外用户来了问题，来了问题之后呢，我先去查我的缓存系统。如果缓存系统命中了。然后呢就是缓存系统直接这个结果就出去了。如果缓存系统没有命中。

然后呢再走下面的比较昂贵的大语言模型啊，这个架构呃思路比较简单，跟传统的这个缓存没有任何区别。但这里面还是有些tck。就是说像传统的缓存系统其实呃举个例子，我想是一个KV的那key呢是完全匹配。

我是拿出来是对的。但这里面的话呢呃同样一个问题它可以有不同的说法，或者是相关的话呢，这个问题对应的答案，它不一定是对的。所以这里面我们对于大语言模型返回来之后，缓存系统上面呢。

是要再加一个这个小的模型的啊，在这一部分加上之后呢，等于说是。😊，这个故事变成这样了。我在上游呢用户问了很多问题，然后呢，我把呃高成本的这些拿回来答案积累到缓存层。😊，然后我在缓存层里面呢。

再内置一个开源的或者成本相对低的这个小的模型。那这个时候呢，如果说我在上面的小的模型加上。大语言模型提取之前拿到的知识，这两部分加起来能够支撑这个问题的话。

那我就可以以一个非常低的成本去完成一个大言模型的任务，而且效果是基本是一致的。😊，啊呃。这个可能可能有点绕啊，就。😊，就等于说是大圆模型，我们去呃不停的去问，然后拿到的答案。

这些答案对于上层的这个缓存层的小模型来说，它是一个外挂的知识库。啊，然后我们拿这个知识库再加上一个开源的模型，就可以提供一个成本非常低廉的在缓存层飞提呃提供成本非常低廉的这个问答的能力。😊，OK。呃。

对，时间差不多啊，主要呃分享的就是这些内容。然后这里呢是我们的开源的项目地址，还有公众号。如果大家对于这个我们在做的事情比较感兴趣的话，可以欢迎下来去交流。嗯，好，谢谢。😊，好啊。

感谢郭文通精彩精彩分享啊。下边呢我们有请啊黄世宇。第四范是强化学习科学家open rL lab负责人来给我们分享open rL呃，通用的开源强化学习框架。OK。😊，うん。呃，大家好。

然后感谢这个杜老师的邀请。然后我叫黄世宇，是来自这个第范式的强化学习科学家，然后也是这个open lab的负责人。然后我们这个呃open的话主要就是一个强化学习的研究团队。

然后我们主要就是做这个强化学习研究和一些强化学习技术的开源。然后我们现在团队人数还不大，所以的话也欢迎各位对强化学习感兴趣的同学加入我们。那后我们这个组织的话就是一个是可以去做这个开源。

然后去做这种社区建设。然后对如果对算法感兴趣了，也可以来我们做这里做强化学习算法的研究，然后去发论文。然后我们公司的话也会也有这种强化学习相关的一个业务。

所以的话如果对这个实际业务感兴趣的同学也可以去做这个强化学习的这些业务。然后这个左边这个二维码是我们的这个repo，就是我们这个open这个强化学习框架的repo，然右边是我们这个QQ交流群。

然后欢迎大家能够进群进行交流。然后。嗯。我不懂。嗯。然后今天主要讲三部分，就是第一个是简单介绍一下这个强化学习。还有我们为什么做这个强化学习框架。

然后第二个的话就是去介绍我们这个强化学习框架的这个主要的功能和特点。然后三个的话就是我们这个强化学习框架的呃未来的一些呃工作。呃，首先是对我们这个强化学习，还有我们框架的介绍就。嗯。

首先是什么是强化学习？呃，强化学习可能大家听过很多，然后强化学习是目前是这个既学习三大训练范式当中的呃一个。那么我们做强化学习也是为了最终的目标是为了去实现这个通用人工智能，也就是强人工智能。呃。

为什么我们会觉得这个强化学习是实现这个通用人工智能的一个工具呢？因为在我们的这个现实生活中啊，我们这个其实训练不是监督学习训练的，都是大部分是通过这种反馈，基于奖励反馈的这种训练。比如我们训练一个小狗。

让他去呃这个讲我们这个扔出去的东西，那么一般是如果他捡回来这个东西，我们会给他一个奖励。所以的话包括人我们人这个也是通过我们的金钱，通过我们一些成绩去给我们做一些这种物质啊，金钱上的反馈。

然后让我们去提升自己。所以的话强化学习是一个更加通用的一个学习范式。🎼呃，这是一个例子，就是一个小小的游戏，然后又可以用小学去训练。然后就是我们把这个数字出去，我后这小辉就可以给。🎼把这个数枝减过来。

然后这个后面补这个小狗的时候，算然法是可以通过情况学习训练的。🎼，然后呢，这个强化学习。呃，除了做这种游戏，可能以前大家看看的比较多的是做这个游戏。但强化学习应该还有很多其他实际的用处。啊。

比如说这个机器人。呃，机器人的话就是比如说这是openI他们嗯19年做了一个控制手机械手臂去完成这个魔方的这个呃。求解的这样一个机器人。然后右边的话是一个自动驾驶的模拟器。

然后我们可以用强化学习在自动驾驶模拟器里面去训练我们的自动驾驶算法。Okay。然后另外的话还有强化学习可以用在这个工业设计里面。呃。

比如说这个英伟达和这他们是通过这个就去年用这个强化学习去去训练他们去学习他们芯片的设计。然后还有包括谷科的这个TPU也是用了强化学习去做他们那个placement的这个设计。

然后另外的话还有这个包括这个股票的买入买出，也可以通过强化学去训练。嗯，然后就是回到这个最近大火，包括前面几个top，全是做全是说这language model呀。

所以这个强化学习在这个language model里面也是非常非常重要的一环。嗯，嗯其中一个点啊，就是为什么要用强化学习这个里面的原因很多。我说一个比较简单的一个点。

就是当我们比如说现在GPD4它的那个ken的长度能达到8000。如果我们要去通过监督学习去训练这个大模型的话，我们要准备一个8000的response。

就是800长度的countent的一个response。那如果我们要专家去写这个response，这个需要非常厚非常的多的那个资源的。😊，然后但是我们强化学习只需要啥，只需要reward。

那我们让机器人或者机器呃模型，他给出了这个response过后，我们让人去标个reward就可以了。好与不好就可以了。

这直接把一个需要准备一个8000的token的这个长度的一个数据变成了只用准备一个reward model，或者只用准备一个reward，它大大降低了我们这个训练嗯大模型的这个难度。

提升了我们这个训练的效率和这个标注的效率。嗯。另外的话，强化学习还涉及到多智能体，还有这个对抗强化学习。多智能体的话就是说我们有多个呃智能体相互配合。现在我们前面讲的不管是大语言还是什么的。

它只有一个智能体是吧？训练的时候，也只有一个智能体。但是我们可能在我们社会生活当中，它是有人与有多个智能体相互的交互，然后包括多个智能体的相互竞争的。呃后所有上面这些呃环境可以看到是多种多样的。

然后我们做了一个这个opR的话，就是一个通用的一个强化学习的算法框架，就是它不仅能支持单智能体啊，不仅能还能支持多智能体，还能支持这个soplay。呃。

另外的话我们也是支持这个大语言模型的这个RHF的训练。所以的话我们是一个呃把环境进行了一个抽象的，抽象成一个模拟器的一个这样一个呃强化学习算法框架。然后它能更加的通用。另外的话。

强化学习本身它是有非常非常多的算法。首先按照大类非就有很多的分法呃，单质人体多质人体。然后ofpoli还是呃onpoli是valueue based的，还是还是那个poli的。

还是还有这个model free还是mod base的。你看这个按照大类，它就能分出一堆来。然后如果切分到特别细小的这个算法的话，它更是特别特别多的这个强化学习算法。

所以的话呃我们的话就是说我们的框架就提供一个抽象，就是我们对强化学习算法进行抽象。然后所有的这种小这种算法，其实就是我们其中一种实现而已。然后强化学习的话还涉及到这个分布式与非分布式。一般在学术界的话。

大家用的都是单机多卡或者单机单卡的这样一个训练方式。然后可能在工业界又涉及到要分布式的进行训练。比如说你RHF，你可能必须要上多机多卡进行训练。那多级多卡的话。

就涉及到首先你有一堆actctor去这个在一个集群里面去收集这个root数据，然后收集好了这个数据过后，你要发送到一个呃data server里面去存储你的数据。

然后你有一个就是你的那个训练你lo的一个模块，然后要去这个 server里面去拉取这个呃数据。然后拉取了数据过后进行学习，学习完过后，他再把这个模型又把它分发到集群里面去收集数据。那怎样这这一个路的话。

其实呃是一个比较底层的一个呃数据流的一个实现。但是可能对于上层的算法工程师来说，他并不关心你这个是怎么样的。所以的话我们希望是提供一个呃比较统一的接口，就是说他对呃单机单卡训练和多机分布式的训练。

他都是呃对于算法工作人员来说，他就是调用一个同样的接口。然后我们去提供这样一个底层的能力帮他完成这个分布式。那我们的话去年也是去做了这种分布式的这种东西，然后能让科研人员。

他实现代码过后能够立刻在单机单卡上进行。测试，然后又能切换一个perameter，然后在单机多卡上进行测试，然后又能切换一个perameter，然后到多机多卡进行测试。

这样的话就不需要呃科研人员去改任何的代码。它只要算法设计好了，它就可以从单机到多机的这样一个简单的适配。然后我们的这个framemework是长什么样的？我就是这个左边这个样子。呃。

就是环境肯定是要有的，不管你做MOP还是做什么，首先你要一个环境吧。然后环境我我们肯定需要一个网络。然后就第二行这个就是我们要去初始化一个网络。

第三行就是我们要去初始化一个ag然后ag初始化稿好过后我们就agent点就可以开始训练了。然后训练好了，我们下面就是怎么去测试，就是agent点act，然后输入你的observ。

然后你就可以去输出这个a需要的动作。然后我们所有的这个编程模式都遵循这个这个简单的一个模式。不管你是训NOP还是训训任何多智能体单智能全都是这个样子。然后我们OPR的话就是去统一了就是各种各样的环境。

各种各样的呃算法。不管是呃ofpoli，就是离线的强化学习，也是通过这一套去训练，然后还是单智能体，多智能体se play还是分布式的，还是单机的。我们都是去通过这样一个呃简单的调用接口去实现。然后。

接下来主要是讲一下我们这个open I它的一些呃功能和一些特点。然后open I的话，它是一个python实现的一个强化学习算法框架。然后后面的话主要是基于派取的。嗯，首先是就是我们这个框架的话。

因为作为一个开源框架，我们希望有更多的同学能够来使用我们的框架。所以的话第一个做的就是要足够的简单。嗯，在简单性的方面，我们呃第一个它是就安装这个我们是python的库。

所以的话你很简单的pi store openI就可以装了。啊，然后呢，如果对docker或者KPS使用的比较多的同学也可以直接通过这个拉取这个docker镜像。

我们的我们为大家准备了基于GPU的和没有GPU的镜像。然后另外的话呃用onna康da同学也可以通过conda进行安装。还有还有这个如果大家又不想完全不想装，就想浏览器看一下这个能不能用，就可以。

我们也提供这个google的呃collaboratory这个这个方式，大家可以去试用。然后装装好过后的话，大家就open out，我们提供一个命令行工具。

能够快速的去验证你装好过后能不能run或者runrun的怎么样。然后我们提供了一个colleport的一个例子。然后在大家的这个普通的笔记本上啊，只需要几秒钟，这个就可以训练好。嗯。

然后这是我们这个刚才col的一个例子，就是这这两段不像刚才那个我们是给了伪代码，这个是我们实际调用我们opL训练的一个代码。呃，就很简单，就就make通过我们的make函数。

你就可以去呃得到你的这个vironment，然后在ronment里传入这个你要的vironment训练的就是并行的数量。然后后面就说话经网络和这个agent，然后就可以开始训了。

就是嗯然后其他更加复杂了，可能需要做一些定制化，但是也是遵循了这样一个呃编程的范式，能够让大家非常快速的去呃使用我们的这个框架。然后另外的话，作为一个国产的这个强化学习框架。

我们是提供非常详细的这个中文文档，还有这个呃手把手教学的这个tutuial。嗯，刚才那个是为了给这个呃初级用户。但是如果你说你是个科研人员或者是一个强袭的专业人员。

那我们也给这个专业人员去提供了足够的呃足够的这个定制化的能力。因为我们也是基于我们这个框架去做一些研究。我们也要去不断修改一些代码网络啊什么的。所以的话我们也会去考虑到这方面。呃。

首先就是我们提供了这个配置，就是我们自己训的时候需要不断去调餐啊，还有C的呀这些东西。然后包括我们去LOP的时候，需要加载哈上的模型啊，或者数据啊，我们都可以通过一个压文件去搞定所有这些配置。

然后具体怎么去使嗯，这个使用也很简单啊，只是我们就是我们嗯命令行传入这个压模就可以了。然后大家再可以在文档里面去找到具体的这个使用方式。然后另外的话就是我们可以定制化的去呃输出我们的log的信息。

大家大家不需要去改我们底层的这个这个强学习算法的强学习框架的代码啊，只需要去继承我们一个叫的一个类。然后在类里面去定义好自己需要输出的这些训练的时候的信息。

然后就可以去完成这个呃这个one上的一些log的输出。还有这些同它也会同步输出输输出在你的这个tmin里面。然后我们也可以一键切换到这个tenorboard。如果大家不喜欢用oneDB的话。嗯。

然后的话刚才那个呃瑞同学讲了一下，就是那个呃R为什么大家用的科研空科研人员用的不太多。因为他没有做很好的这个呃抽象和这个模块化的这个设计。后我们的话也是就是做了很好这个抽象模块化的设计。

首先就是re model呃以前的强化学习框架可能没有做太多这块的这个抽象设计。嗯，因为环境里面就自带了reward model。后来我们在做研究的时候，我们做的时候。

发现这个reward model是需要做re需要通过另外一个模型去改的。然后包括我们做OP的时候，这个reward也是通过一个模型生成的。所以的话我们单独把这个re model做了一个抽象化。

后大家只要继承我们的这个re的 model的这个呃积累，然后就可以去实现自己的一个 model，然后去。呃，给出任意的这样一个网络呃，这个reword。然后其他的关于poliice和这个Vdwork。

还有这个agrim，我们也是做了这个抽象和模块化。然后这样就可以这样是对这个科研人员比较友好。因为科研人员主要就是去改这些算法呀，还有这个模型啊这些东西。

另外的话呃还有就是一些强化学习比较高阶的一些使用方式。比如说这个呃dictionaryob，就是我们的强化学习输入不可能不只是向量或者是图片，我们可能是一些混杂的。然后我们也是支持的。嗯。

然后还有这个是创新和并行的环境，就是强化学习训练的时候，我们需要这个大量的并环境并行。但是如果环境一开始就并行的话，它是很难调试的。所以的话我们支持这个并行和创新的一键式的切换。

然后这个切换然后我们也是保证了它这个呃环境的这个随机性是完全一样的。然后我们也是支持多种多样的，就RN和这些transform这些结构。然后我们也是支持这个MP的这种混合精度的训练。

然后还有就是我们在这个做这个roout的时候，收集数据的时候，我们需可能并不需要特别高精度的一个网络去进行数据收集。因为它收集数据的时候，本来就会去主动的去引入一些随机性。

所以说话我们也支持这个半精度的这个呃这个act。嗯，还有就是强化学习，可能呃和language model一样，我们也后面也需要站在别人的肩膀上，利用别人的模型，别人的数据。

所以的话我们也是支持从ha interface上去导入模型和导入这个data set的。然后我们也提供了这个gallery，就是我们不是只是把这个代码啊，这个框架代码给大家。

我们也是提供了这个gaery。然后通过这个gallery大家可以实际的去了解到我们怎么去用这个这个框架。我们这个gaery里面有有单质人体的多智人体的连续动作了，离散动作了。然后还有LOP的例子。

还有图片的例子啊，都是都是大家可以去找得到了。然后通过这些例子，大家可以知道我们这个框架该怎么用。然后我们实际上这个框架也会关注它的这个performance。呃，首先它要够快。然后我们刚才也说了。

我们这个cardpo呃，在普通的笔记本上不需要GPU只只需要几秒钟就可以训出来。然后还有就是对一些ngo model的训练，我们也是有呃17%的这个加速能力。

然后还有话就是我们也是去做了一些实际的一些任务。我们在那个foot的那个这个一个比较难的一个多政题任务上，也是当时也是排第一名。通过我们框架寻出来的。

然后还有是去呃我们在这个language model上这个对比的是和super learning区比。然后最高的话，这个指标能达到就通过RHF区量能达到这个43%的这个性能的提升。

然后未来的话最后讲一下我们未来的工作。就未来的话我们是去面向一个更大scale的一个强化学习训练。一个是更大的模型。我们现在其实我们最大模型我们采用到了那个G。

所以的话我们未来会用更大的上B的模型或者几十的几百B的模型去训练。然后我们现在正在接入的就是的就是说也是我们后面会开源给大家用的就是加上的我们这强化学习框架能够去做非常大一个模型的训HF的训练。

然后还有就是更大的这个cluster。呃，因为啊大模型的训练涉及到这个超大规模的集群，然后我们后面也会去集成这个瑞和这个K8S去在这个大规模的这个集群上进行强学训练。还有这个。

这个更大的这个population的训练，就是我们也是这个库是可以训练多智人体和这个splay的。嗯，多智人体的话。

我们去年的工作就是能在呃首先我们是第一个在这个gogle food全场游戏上这种多智人体呃完成这个训练的工作的团队。然后另二一个。

我们是第一个在50个智人体上完成这个多智人体深度学习强化学习训练的一个团队。然后所以的话我们未来会在更大的一个呃智能体的构数上进行深度强强化学习的训练。然后我们也会去更加去去注重这个开源的建设。

然后包括是把我们讯好的模型的讯号的模型放在hin face上啊，还有我们的代码，我们的demo也会放在同步发生在我们的git hop上。然后还有这个一些实验结果，我们也会通过那个oneDB分享给大家。

然后这是我们的这个呃report啊，然后这是我们是5月份刚开园啊，没有没有多久啊，但是也是已经是成为这个强化学习。呃，这方面前期增长最快的这个一个reple了。嗯，最后谢谢大家。好啊。

感谢黄世宇的精彩分享。呃，刚才我看到就是大家对这个啊非常呃非常受欢迎啊，跟大家这个卖个广告了。就是说呃包括，还有这个迪范事呢都是LI data基金会的最活跃的核心成员啊。

这个的创始人的星爵呢是上一任的 data基金会的这个董事主席呃，这个我们这个呃刚刚讲刚刚跟大家分享的这个迪斯范事呢同样呢也是董事会成员，应该相信不久呢就会呃登陆这个香港股市了。

今年之内大概就会看到登录香港的tchan了。另外呢在LI data呢。其实我们还有这样子非常有潜力的这个开源公司。啊，有好多不少这个呃刚才我看到这下边呢有很多这个在这个投资投资的这个有兴趣的呢。

其实我们以后会有很多这样子的交流的活动啊。😊，这个希望大家来这多参与。好，那下边呢我们就有请徐楠这个呃中科院自动化所副研究员呃，中科文革产业中心副总经理啊，给我们分享呃浅谈大模型及眼进技术的发展应用。

好，有请徐楠。那个下面我就分享一下我们在这个大模型方面的一些工作。那个主要是这三个方面，包括我们对TGPT和未来大模型趋势的一些看法，及最后分享一下我们中控文哥在这个大模型方面的一些探索。

以及我们在开源方面做的一些工作。

那其实所大家都在接触那个chaGPT啊，就是GPT相关的这个大模型给社会啊带来最大的一个变化，就是让这个知识的获取和调用越来越简单成本越来越低。那这个我就不展开了。

那回归整个GPT大模型的这个技术可以看到，其实嗯到GPT4它所用到的所有的一个呃算法以及相关的这些技术啊，其实都是呃过去呃半个世纪以来呃积累的这些技术是一个极大成的一个呃突破。

是一个工程实践的一个里程碑。包括用到的像对抗大模型以及强化学习等等。其实都是其他公司产生。那所以呢chGPT呢就把呃这些技术做了一个大的一个集成。那这张图可能我我又提到这张图，就是今天已经第三次出现了。

那其实对于目前来看，我们对于chGPT的理解啊，还是一个呃黑盒。就是它为什么能做呃各种任务啊，然后它的涌现啊等等，大家都是去猜测嘛。但是它呃虽然是一个黑盒，但是它给我们带来的一些启示。

包括对于这种统一知识的一个表征推理，以及对于世界知识的这种认知和建模，这些问题的探索，给了我们一条路，就是这个大模型的这条道路。那呃整个chtPT它的一个突破啊，其实人工智能的三个要素啊。

就是算法算力和数据。那么呃chatGPT它其实也是在这三个方面呃发挥到了极致。那刚刚也一直提到的它的算法其实是一个技术密集型的工程。那算力就不不说了。在这块的整个训练投入的是相当多的GPU的资源。

以及它在数据方面的这个搜集和相关的这个积累。那未来我们针对这个呃从不管是从企业界还是学术界，我们研究就是接下来在大模型发展的几个趋势。第一个就是信息技术应用和创新生态的一个新的范式。那目前来说呃。

大模型，我们可以看作四个阶段，那每个人基本现在都在使用大模型，不管是从个人企业。那从最早的这个创开始上手。包括后续的我们结合一些pro的构造。运用一些工具。

以及把这些嗯相关的这个固化的工作流打造成一些工具。比如说chatPDF等等，以及最终的形态，结合大模型和相关的这在行业以及领域方面的应用去做一些大模型的生态。比如说这个微软啊。

百度正在做这个第四阶段相关的这个工作。那第二个趋势呢，就是也是大模型本身的演化趋势，就是从最早的chat。

自然语言那个交互到GPT4实现这个dooma态以及近期的用大模型和一些机器做一些人机交互的那当然未来我们甚至可以猜测，当然我我比较乐观啊，可能猜测未来GPT4呃。

未来的GTX甚至可能会真的产生一些情感或者交互意识等等，甚至可能通过这种广义的这种图灵测试。所以其实它的这个呃进化速度也是越来越快越来越智能。那最后第三个趋势呢，就是呃从企业或者从应用这个角度来看。

那未来还有另外一个趋势，就是大模型它是面向这种更加呃领垂直领域，或者说是往更加轻量化小模型这个方面也是一个发展的个趋势。这里目最近呢也有很多在领域以及青量化有很多开源的这个工具。那目前不据不完全统计啊。

当然这个是4月份陆奇博士的这个统计啊，就是目前国内啊已经有数十家那个大模型的这个机构和包括公司主要企业界啊学术界都有那也有上千家依托于大模型去构建自己的应用和以大模型生成的这些公司啊。

那么呃其实国内外现大模型，其实是一个呃井喷式爆发的一个趋势。那么呃我们中科文哥为什么还要去继续去做一个呃专属的大模型，或者说面向企业的一个大品呢，其实我们也呃包括发布的这些通用的基础大模型。

那我们想去做一个什么呢？呃做为一个面向领域的垂直的一个呃大模型。另外呢就是我们要去探索能够让用户可用的安全的，能够本地化部署的一个大模型。所以。那就是我们自己推出了我们的个呃雅逸的一个大模型。

那我们重点就是去面向领域，然后提供一些安全可靠的一个大模型以及相关的工具链。那我们这个大模型呢在6月3号正式的这个推出。

当时呃这一周刚刚到现在一周的时间也是受到这个央视啊、新华网、环球、凤凰等多家媒体的这个报道。呃，说明我们在这个领域探索这条路上得到了这个主流媒体的这个关注和认可。

那么呃雅印模型目前我们主要聚焦的就是领域深耕领域。那么提提供了包括呃领域知识问答复杂场景信息抽取等五大的核心能力。那提供了上百种领域的这种特色的技能。

那呃第一个其实就是大家经常考虑的就是大模型在呃回答问题过程中，它的一些幻觉的问题。那解决幻觉问题最大的一个呃方式或者工具就是通过互联网去做一些呃相当于是一个呃实时的这个数据的这个接入。

那么我们举个最简单的例子啊。那个智源也是在这个中关村论坛一系列的这个系列，那我们就问一下这个呃今年中关村论坛的一个主题。那通过搜索引擎，就可以精准的找到。那今年是开放合作。那共享未来。

那开放一直是整个中关村系列，包括我们今天这次论坛的一个呃主旨。那么接下来那我们真的面到一些呃领域，比如说我们在做呃新闻媒体方面，那我们可能借助大模型不是去问他一些通用的知识。那我们可能真的就关心呃。

比如说这两天高考也刚刚结束啊，那我们就问询问通过。雅意去询问高考的热点信息，那他就会呃排列了这个根据互联网的结果，找到了这个十篇高考相关的热点新闻。当然我们还做了很多工作。

包括呃针对某个新某个热点去询问他的摘要，询问他相关的这个呃网民以及不同媒体客户对于这些事件的一些观点。这这我就不再不再展开了。那第二阶段其实是我们在这块做的一个重要的一个探索，就是呃领域的知识问答。

那其实大模型刚才提到了，就是嗯他在目前已经开源的这些都是通用方面的这个基础的能力。那真正把它运用到领域运用到实际的业务生产线上。那接下来需要怎么做呢？就是我们也在这块做了很多这个插件和能力的这个训练。

那呃第一个方面就是我们在金融金融领域的一个探索。那比如说我们在财经投研方面，我们很关心企业的一些风险原因风控这些。那我们就是把我们的模型和一个非常高质量的一个领域知识库进行了一个深度的一个对接。

这是我们的合作伙伴财联社。那目前是国内财经领域的一个呃非常top的一个机构，他们的一个高质量的金融问答的一个相关的知识融合在雅翼模型的交互中。那我问他相关的硅谷银行啊。

去年今年3月份硅谷银行倒闭相关的它的倒闭的原因产生的影响，都可以通过雅翼模型进行一个精准的回答。那第二个呃领域知识问答就是刚才其实向量数据库的那位呃老师也介绍了。

就是关于这种离线的长文本怎么和预训练模型进行一个呃融合。那我们其实在做的就是长文本的问答。那这一块呢就是面更多的就是面向那种私域数据的客户企业政府他们有很多内部的数据。比有比如说银行比如说内部的呃政府。

他们的数据是第一没有在互联网出现。2、也不可能通过呃open eye的接口，通过互联网进行一个传递。那么这个时候呢就需要大模型具备它阅读它内部文档的一个能力，怎么实现这些能力呢，这里呢我们做了很多插件。

包括相量数据库ES搜索排序等等。结合我们的雅印模型，比如说这个是我们基于两篇的这个呃一个是。那个人AIGC的一个白皮书200多页，还有一个关于腾讯研究院关于数字人的1个呃PPPT的1个PDF的文档。

那我们就可以根据雅力大模型进行一个交互。然后一次就可以阅读上百页的PP当然这个演示系统只是支持部分。那后台其实可以实现百万级的这种文档的这个接入。那整个回答都是在几秒以内就可以进行一个回答。呃。

接下来就是真的我们把模大模型运用到我们实际的这个具体的场景和我们工作流上，它带来的一些工作带来的一些抽取。那呃我们第一个就是面向这个复杂场景的信息抽取。这里我举一个例子就行。

这是我们面向每舆情安全领域的一个应用。那我们每天互联网有很多新闻的报道。那我们作为一个呃舆情分析师，作为一个安全人员。那我们可能关注的是这些新闻，它的一些呃关键信息的这些要素来方便我做下一步的重点分析。

那这个就是针对。嗯，针对一个美国的一个枪击事件，他我们通过亚翼进行抽取它发生的这个事件的地点，事件的详情，人员的伤亡事故的原因的一个总结性的一个概述。那然后就是精准的抽取了它相关的这些信息。

当然我们肯不止这一个呃要素抽取。还有更多的能力和大模型进行持续跟他交互，就可以在呃十0分钟的时间就可以写出一份非常完整的舆情报告，涵盖上百篇新闻文稿的一个集合。

当然都是通过模型和这个互联网搜索引擎与我们的知识库多次的一个交互完成。这是我们在领域上的一个探索。接下来就是在多语言方面的一个，我们知道是模大模型在本身就具备天然的这种多语言的这个能力。

因为在预训练的阶段，他也使用了很多多语言的这个数据。那我们继续在领域上的探索，就是因为可能不关心的是呃翻译传统的翻译的能力。那可能真的是嗯我们的呃我们的一个合作，就是我们的一个客户。

他在嗯他每天都要看全球的各种新闻数据。那么那大模型本来就在这个多语言能力上就有很多这个鲜艳的这个优势。那我们可能是嗯这是一篇俄文的报道啊，报道的是那样呃。那个北京举办的这个世界环境日的一个相关的新闻。

那可能就是需要快速的总结这种多语言新闻。它的这个概述事件发生的原因，以及产生的结果影响等等。都是通过我们在这个多语言训练之后，在这个视力方面做了一些解析。

它也精准的找到了这个事件的这个概要等等一系列信息都可以支撑我们舆情分析师在这个海外媒体使用过程中的一个多语言的这个场景。那另外就是我们针对这个嗯金融客户，他们对于企业对于舆情负面这些方面的这个嗯影响。

那经常企业他很关注自己的产品，在互联网这些媒体报道这种满意度。那我们的模型在这块的应用，主要是针对去直接抽取他关心的这些呃相关的新闻，对于他的产品的这个介绍，还有他的是否满意。

从情感情感原因以及意见方面的一些抽取。这个是我们在直接抽取，然后并按照着jason的格式直接送到他的业务线上进行一个抽取的一个任务。那。接下来就是在这个多模态内容生产。

因为本身大模型它的这个生成能力是它天然的这个优势啊。那我我们在这一块的这个重点的优化和训练，更多的是面向企业直接产生生产力的这块的一个一个方面的探索。那这是我们在金融方面的一个一个问题。

就是嗯每天会那各家互联网各家公司啊都会有在他的平台和一些公开的这个渠道上发布自己的这个快报。那作为一个财经投研的客户，或者说用户它需要快速的消化这信息，并生成一份快报。那这个就是呃我们上线以后啊。

就是直接应用在各大的这个企业企业平台上生成这种持续不断的这种业绩报告啊。然后那个呃股股价的报告等等，都是可以通过我们的雅翼模型进行一个快速生成。过去这个过程可能需要呃10分钟半个小。

现在只需要呃部署上线之后，几秒就可以快速生成这个报告。那当然这个诗歌创作这些都是正常的这个能力，这个我就不展开了，包括去调用一些AI绘画的插件，包把刚才那个诗歌做一些绘画啊。

以及我们把整个呃雅翼模型作为一个智能问答对话的大脑，以及各种AI类插件的一个大脑。我们和虚智能的这个虚拟人进行一个实时的交互的互动，都是通过我们的雅翼模型，那进行一个呃交互和体验。

那接下来呃这是我们在雅意模新的一些能力。那其实呃提到了这个今今天的这个论坛的主题，就是AI的开源嘛。那我们也是希望能够呃在这块做一些贡献啊。

这这个是今年那个5月份科技部最新发布的这个中国人工智能大模型的地图研究报告。它显示了就是目前啊其实已经有国内超过一半的这个大模型都是实现了这个开源。

但是这其中有那个主要的开源的主力还是来自于高校和科研机构。那目前中国大模型开源影响力前十有8家来自于这个高校和机构啊比较代表性的像GM复旦大学的这个mo斯等。那目前国那企业在这块呢就是影响力。

那还算还需要持续不断增加影响力。那目前前十的里有两家大模型，一个是百度的这个文心，还有贝壳的belly。那呃中科文哥作为那个一家科技企业，那我们也是呃坚持这个开源开放的情怀。

也愿意为这个社区在大模型这条路上贡献我们的这个经验和数据。所以呢就是呃我们也在那个把我们刚才展示的这个雅意的这个大模型进行了这个全面的开源。包括我们的代码模型，以及在面向领域。

包括金融媒体安全运行等等这些领域的这些高质量的数据进行了这个开源。那我们希望通过我们把大模型的开源这个路。那为这个中文预训模型的社区贡献我们自己的一份力量。那呃针对我们本次开。

当然我们发布会6月3号已经实现了开源。那当然已经放到get和那个face上了。我们整次开源的是我们的70亿参数的这个版本啊啊。

它也是在这个也是我们也是基于一个预训练模型的这个权重通过在这个百万级的这种领域任务上微调得到的那当然在这个呃迭代的过程中。

我们也有数百名用户的这个持续不断的这个测试内测也是持续增加了它的这个呃忠实性和这个安全性。包括我们也把我们面向这些嗯媒体啊，金融啊，舆情等等这些数据也进行了全面的这个开源。那7月份呢，我们。

同时会进一步增加模型的这个呃是那个到这个150亿这个规模。那继续强化它在这个多轮对话逻辑推理方面的能力，并增多增加更多的这种插件和这个多么态这些能力。然后到7月底呢。

我们也相关的这些公开我们在雅印模型整个训练过程中，详细的这个基术报告，以及我们相关的评测的数据以及相应的这个评测工具。那当然未来我们还继续会探索个通用的这种基础的模型。当刚才那个也是那个林林院也提到了。

就是呃智源的这个基础模型。其实我们还是希望在基础模型能力上面去通过大规模的资金的训练。那以及选用更加安全可靠的这种中文的这种数据来去做这个呃一个基座的这个能力。

那这是我们模型在这个呃评测的我们自己搜集的一些。当然不是很全面。当然主要是为了做一些领域和基础能力的一个评测的数据。那我们也是邀请了多位领域专家在这块作为我们那个人工评测啊当然在这个呃对比的几个模型。

包括主流的这些来自于企业的T啊文心言通益星火以及一些开源的这些像GMmo等等。那结果在这个领域方面，我们确实因为我们主要还是面向领域去做垂直训练嘛，取得了一些呃不错的性能。当然在基础能力层面呃。

目前我们也算是呃刚刚开始啊在68个模型里边，目前我们的雅翼排在第六位。当然这只是当然雅翼的只是一个初期的模型啊，就是我们在这个面向领域大模型的构建过程中。

也刚刚开始我们也希望通过雅翼的开源就是在未来进一步。提升它的性能，共建这个雅翼以及大模型中文社区的一个生态。那最后介绍一下我们公司。那呃中科文哥。

那是一家那个来自于中科院自动化所的一家企业的呃那个人工智能和大数据的一个企业。那我们核心团队其实都是来自于自动化所。那我们呃成立至今5年的时间，主要就面向这个社会计算，做一些媒体安全舆情方面的一些领域。

那目前我们是在全国已经有6家分公司，总共是有超接近800人的一个规模。那最后还是想就是说这是我们这个相关的这个扫码，都可以直接获取我们这个雅艺的这个模型。然后也是希望就是刚好借助这次大会。

也是宣传一下我们的一些工作。那大家未来有有兴趣，或者说是呃呃对于我们这个都可以多多多参与或给我们提一些意见。我们也希望通过他的开源，在这个面向领域这一条度上啊继续走下去。好的。好呃。

感谢啊徐南先生的精彩分享。那现在呢我们就到了今天的这个压轴环节啊，圆桌讨论AI与data开源的趋势与展望。那我们首先呢有请今天的这个主持人李晨啊，那李晨李晨呢是ze开发者关系及市场运营负责人啊。

交给你啊，李晨。😊，谢谢杨先总，谢谢。😊，呃，大家好呃，今天非常荣幸啊，然后嗯能够。😊，🎼在这边跟大家以一个圆周来结束我们最后的AI和开源的这个分论坛啊。啊，今天整体的议题也是非常精彩分层啊。

然后到现在为止都留了非常多的同学在这边，非常感谢大家的一个热情啊。😊，🎼好，给我们工作人员几分钟的时间，咱们布置一下场地啊。🎼，今天的这几几位嘉宾呢也是我们开源技术圈。

还有AI大数据圈的一些呃专家和老师们。啊，今天我们也准备了非常多的跟我们热门话题相关的一些话题，帮助大家更好的去了解我们处于的这个时代。OK了。🎼好，那有请这几位老师吧。首先邀请我们胡俊平老师。

孟伟老师。🎼布林老师。🎼菲谢老师。🎼还有杨轩总。🎼呃哦，他那个。🎼没有对应的，那大家随便做吧。😊，🎼对对对对。🎼都是老朋友，大家随便做吧啊。😊，🎼O这个很很尖峰的对话，其实。

🎼很难聚齐这这几位大咖同时在一个台上去做啊。那简单的开个场吧。其实今年啊今年早些时候随着GT横空出世啊，让全世界的目光再度聚焦到我们的人工智能的一个领域。呃，李开复更是提出了，这是1个AI2。

0的一个概念。整个技术圈创业圈和投资圈迅速达成了共识，并快快速的进行了一个布局。我相信2023势必是一个AI全面开启商业化的一个大年。今天在座的各位嘉宾都是开源技术圈的一个老兵。

也是我们大数据和AI领域的专家。因此今天非常荣幸，请大家坐在一起交流。在这个历史性的节点，我们一起探讨一些大家关心的问题。那么先请大家给我们现场的观众朋友做一个自介绍。从从您开始。😊，好，大家好。

我刚才呃给过一个演讲，关于AI数据方面的开源。所以我是大概在十呃有十几年在数据和AI领域的啊这个研发开源和业务的经验。然后我现在在A这个领域在创业做一个初创公司。

那么我也同时在F基金会是去年和今年的这个啊，我在这个我是很早之前的项目的comitM啊等等等等吧。开源这个圈子数据这个的AI这个圈子大概耕耘了年。谢谢九斌总。哎，好的。大家好嗯。呃，我叫孟伟。

我是来自那个中兴通讯。呃，我本人除了在那个中兴通讯负责那个呃开源工作以外，也同时在那个LFAI andda呃，也董事会里面担任一些职务，呃，同时呢在2018年F data成立的时候，呃。

当时叫deper learning啊，也是当时呃我们几家那个包括几家中国公司，也是那个在呃帮助这个linux基金会成立了这样的一个基金基金会。呃，所以呢也是能够非常荣幸在这里跟大家分享一些观点。嗯。

大家好，我是赵菲菲。呃，我是中科院自动化所的副研员，也是中科文科的创始合伙人。呃，我们这个团队呢一直是在科学院体系做做大数据呃，做人工智能这个方向的。然后成立的公司中科文科以后呢，刚才我同事也介绍到了。

我们主要是专注于做领域的啊这个中模型。我们不要大模型啊，7B啊、15B啊，20B。对，就这样的呃，然后呢也很高兴能够在这里跟大家分享我们的一些呃就是观点吧。好，谢谢大家。😊，大家好，我是杜林啊。

贝赛科技的创始人和CEO啊，贝赛科技啊起源于呃数据标注行业啊，但是我们在呃5年前就开始了我们的产品化和开源的历程啊。

我们这个发起了我们这个我们面向整个多模态的全球首个的开源的训练数据平台X string one啊，并且在今年把它捐献给了lininux基金会。同时贝赛科技也是linux基金会的成员之一啊。

很开心今天在这里和大家有机会交流。呃，大家好，我是杨轩啊，我来自linndaC金会啊，亚台区呃，我主要负责的是呃。这个其中我主要的一个负责领域呢就是在人工智能这个领域呢的社区的生态的发展。啊。

包括了这个L data这个社区了，也包括了我们马上要开始这个推动的这个基金会的这个社区的中国区的社区的建设。呃，我们希望通过我们在这个中国这个社区的这个开源社区的这个呃推动开源社区发展的这个方向努力啊。

希望让中国的这个更多的这个AI的公司，能够呃走出走向全世界影响全世界啊啊，我我为这个L data个小再卖一个小广告。 data呢本身呢他现在是全球最大的一个开源的AI的生态。

在我们而中国区我们中国区的会员呢是在在里边有很大的这个话语权，我们有一半的这个董事会成员呢都是我们的包括我们的主席了都。我们的这个中国区的这个会员。

所以呃呃实际上我们现在是一个呃站在一个非常有利的一个位置啊，呃不仅是说能够让我们中国区的这个项目，中国区的这个公司走向全世界。同样呢我们能够把全世界的整个开元社区生态的这些专业人才专家呢。

整个这个开源社区呢能够为我们中国的项目服务。所以我们也我也通过专加活动，我也非常希望这呼吁大家来加入我们OK好。好，那我再打个广告。呃，我是Zence的呃市场运营和生态的负责人啊。

刚才我们的郭仁通博士也讲了一下我们做的一个产品，非常感谢大家的热情啊。现在郭仁通博士还在外边被困住的对，非常感谢大家对限量数据库的一个支持啊。如果大家有什么想了解的，也可以来跟我一起去探讨啊。

那我们快速开始。今天因为今天的整个圆著的话题还是离不开我们现在最流行的这个大模型和我们的数据啊，这2块可能因为很多专家都在提，在这个时代算力算法和数据是最关键的几个要素啊。那我们先来谈谈。

因为现在大模型之争是非常的火爆，也是愈演愈烈啊。呃，有业界观点认为开源大模型才是未来。那各位老师和专家怎么看待目前的一个整体的一个竞争的一个格局。而开源又会在其中起到什么样的重要的推动作用呢。

那我们先从从俊明总开始。😊，好的，我先抛个砖吧。因为现在确实我感觉像这个大家不管是在美国还是中国是吧？大家在这个进入了一个大量模型的时代，所以基本上。每个公司不管有没有必要，大家都为了修肌肉。

或者是真的有看到了这样的机会，都会啊去练自己的大模型。那我觉得这个是个好事是吧？因为从这个open AI从chHBT这里，我们看到模型给我们实际的这种呃环境，我们的业务，我们的应用。

包括日常的生活都带来了极大的一种便利性。那么所以这个需求市场都是真实存在的，也是科技革命的一个一个一个引爆点。所以呃所以我们看到现在即便它现在是一个啊春秋战国时期，对吧？那种感觉。

但是仍然大家觉得很有价值。但是我们认更更加认为就是开源一定是一个未来。因为大模型更某种程度更像是啊早年的操作系统。就最早的时候你可能写一个应用，那么就直接跑了。

但是这个应用之间呢很难有这些被共享被复用的东西是吧？那那到后面为什么会有操作系统，就是它有一个common的组件。那么这个common的组件能够更好的去支持我们的这种各种应用。

那同时呢这个操作系统早前它可能是必远的是吧？然后慢慢的他也会走向开源原因就是在开源的这个世界里面大家可以更好的协同起来，可以更好的去支持啊上面的应用层中间层，刚刚我们也看到它会分这个模型层是吧？

中间层上面的应用层。啊，一个开放的生态，显然是更有利于这个生态的发展。但是实际上我们从另外一个角度也看到模型开源它有它的困难的地方。那它困难的地方，相对于传统的这种开源在于它比较难协同协作。

我比如说你如果是一个一个一个代码的这种开源你的。代码质量高还是低啊，一个有经验的程序员他他是可以看出来的是吧？我可以判断你的外面的这些代码到底可到底是好还是坏。但是我一个比如说一个确好的一个模型。

一个高质量数据集。那在这个新的数据外部的这种数据集的这种呃fin tuning之下，它到底是变好还是变化。其实这个是不确定的啊。

这个很多时候呃这种开源的这种匿名性或者公开性开放性跟他模型本身它的一个对数据的要求，对这种呃算力的要求的这个壁垒，其实它有点冲突或者矛盾的点。所以我觉得这个业界现在没有看到说每个模型社区非常非常活跃？

大家都基本上都是比如说拉ma从拉ma的角度是给他改过来，拿过来啊，然后衍生一个什么其他的模型，而没有看到说这个某一个某一个社区这个拉ma他可以比开开源出来之后，其他的组织进来之后。

让他在原有的主干上去迭代像我们传统的这种开源的这种方式。我觉得这种可能逐步的我们要去解决它，这样的话可能充分的释放开源的在模型这个事情上面的潜力啊，这是一些个人观点。OK孟老师哎，好的。

刚才那个杜老师抛了砖，我这边再隐个喻啊。那个是这样，就我这么理解的，就是首先这个刚才主持人那个观点就是说开元大模型是未来。我觉得这个我是赞同的。首先那个我先摆明自己的观点。

然后那个从那个就是大模型这一块来看的话，就是我们又看到历史惊人的相似的一幕就是什么呢？就是碧园的老大哥是吧？在那边吃肉。是满汉全席。这个时候哎老二老三带着一帮老四不干了，就把这个我我们来做开源。

把这桌子给掀了。我觉得这个是一个非常那个很多这个历史上有相似的这一幕啊，就是很多人会说就是说那个嗯拉ma这一块开源之后啊，不管拉嘛还是辣妈还是羊驼啊，这开源之后，这个。

就是大家认为这个这个这个这个大模型的这个安卓的时代到来了。安卓时代到来了。但是我我是这么认为，就是其实现在那个因为大模型这一块还是有一些有一些问题的嘛，就是有开源这一块，有些问题啊。

比如说那个拉ma这一块呢，他其实不管是羊驼还是羊驼的子子孙孙，他们其实其实它的商用商用性，其实不是非常强，就是很很多很多时候就是我们把这个拉ma拿过来之后，我们是不可以去商用的。那个这存在一个问题。

就是就是就是什么呢？就是说我我们这个技术多先进，但是对它这个商用其实没有帮助。我觉得这个是一个非常大的一个问题。就比如说我我我一个那个二维码，扫二维码去那个付款是吧？这其实是一个非常简单简单的一个东西。

但是它商用性非常强。我觉得这个这个从商商用性的角度来讲，嗯，我觉得这个呃拉ma这一块虽然是好用是吧？嗯，嗯拉ma这这个好用到一个程度，就是说我我用拉ma非常爽，一直用一直爽，但是就是不能拿拿拿出去商用。

所以这个会存在一个问题。那么现在能商用的一些开那个开源的大模型，比如说什么什么刀利啊这些，但是它的那个可用性就用的爽的程度又不如那个就是就是羊头这一块。

所以所以我觉得呢这个因为也是大模型这个一个初始的阶段吧，所以我觉得呃从开源的角度来讲，我们只要继续给他一点时间，我相信这个开源在未来的这个。呃整个一个技术的一个生态发展里面。

肯定会有一个非常一个呃美好的一个未来好。菲菲嗯，好，嗯，就是像像前两位我们的老师说的，这个也是阡魔大战的这么一个时代哈。嗯，因为从我们看来呢，就我一一家之言啊。

我觉得现在大模型大概分成呃就是基础型的叫通用型大模型。然后另一呢就是另一种呢叫领域型的这个大模型。大家现在开源的很多的一大部分都还是说这个通用型的这个模型啊，我我因为开源这块在通用型的模型之上。

我认为它是非常非常好的。就像之前咱们的很多老师讲的。第一，因为大模型的这个算它是一个算力密集型啊啊这个这个数据密集型或者说人工密集型的这么一个大的投入的这么一个呃这样的一个工作。

所以如果我们通用型的大模型能够开源，能够让别人能够让我们的生态伙伴，或者我们的很多厂商能够站在巨人的肩膀上再去做进一步的领域的这个模型的工作，我觉得这个是未来的一个很好的一个方向。

那说到领域大模型的这个开源呢，我觉得可。😊，可能会遇到很多很多的这个问题啊，包括你这个领域里面的你喂养它的数据啊，包括喂养的这个模型的这个情况。我觉得其实这这个问题未来可能还没走到啊。

可能还大家在领域大模型开源这块，可能呃有一些比如说医疗的等等，刚有所尝试。包括我们中科文哥发布的雅医模型也是在啊媒宣就媒体宣传，在舆情，在社会治理啊等等方面做了一些尝试，但是呢真的深入的应用。

我们觉得还有很长的路要走。包括在开源这虽然我们也开源了。啊，但是也希望大家多关注吧，多提意见。嗯，好，谢谢大家。😊，哎，杜总。呃，分享呃三个呃我个人对于这个整个大模型开源的一些粗浅的认知吧。

就是第一我觉得呃就是现在的这些闭源的大模型，其实也是起源一些开源的技术啊，所以说在未来我是相信这个依然会有两个很大的阵营，就是闭源阵营和开源阵营，并且开源阵营会随着它的这个开放啊。

和更多的这些贡献者的加入啊，而变得这个生态非常的丰富啊呃第二个呃认知就是我觉得这个整个的开源和闭源的这个演进方向。

极有可能会变成这个闭源的会面向更多的这to C的领域啊啊这个因为它可以有比较呃直观的这些通用的解决方案或者是大模型，对于C的这些体验非常的友好啊这些呃这些开源的这些呃模型。

基于一些呃历史场景的这些数据的 tune啊，包括这个这个这个一些呃面向to B的一些垂直应用啊，可能会有更多的这种繁荣的机会啊。第三。嗯我觉得啊最终其实现在目前更多的这个开源可能还是一些底座的开源。

或者是这个训练方法的一些开源啊，或者训练工具链的一些开源。但其实我认为最终整个大模型生态真正核心的开源啊，只有走到数据层面的开源。我想才能是整个从模型层面的真正的开源。

就是最终其实大家觉得就是训练方法也好，或者算法也好，都是一些基础的东西。但更核心的其实是这些数据啊。呃，我我就做一个简单的我自己的一个预测。O呃，首先呢刚刚我们大家都呃都都在讨论了。

就是说为什么开源对吧？这个我觉得开源是一个已经是一个呃呃现在是讲就是一个通用应该是一个就是开发者的一个创新的一个模式啊我觉得呢这个大家都在讲大模型。

我觉得呢其实我觉得就是是属于一个呃我自己认为是一个初始阶段的啊，就是说他打开了一个门，打开了一扇窗户，打开一个领域，但是呢通用型的这个大这个模型呢，它注定它解决不了太多的这个生产的实际的环境的问题。

对吧？就像是我自己我很喜欢用这个但是我只能把它当成一个秘书来用对吧？但是呢就像今天刚才那个呃国通来分分享的一样，对吧？他可以睁着眼睛说瞎话，因为没有那个数据。

所以我个人认为啊未来的大模型应该说每一个企业不不是个led应该说每一个企业他可以都有。😊，自己大模型，他其实基于自己的企业，基于自己的服务，基于自己产品，他建大模型呢是用来服务自己的客户。

他可以大极大的降低自己的运营成本。所以我觉得数据呢都不是问题。现在问题是什么？是工具，开源的工具，可信的工具能够让你呃呃能够让你去产生。😊，可信的结果的一个工具，包括了平台。

为什么我们说呃呃投资者这么青睐涌向那些开源工具的厂商AI工具厂商，因为未来的大模型一定是以企业为单位的这个是我的预测啊，这是我的认为的。所以这个这个一定是有一个极大的蓝海在等着。

等着我们所有开源厂商再再去再去一起来共建的。OK好，谢谢。OK呃，为了解决大模型幻觉，可以用大模型加向量数据库的方式。来解决大模型的幻觉，或者说你私有领域知识。

包括知识增强的这些领域啊啊又又打了波广告啊，很舒服啊。接在杨总后边说话很舒服。OK其实刚才杜总包括很多嘉宾也提到过数据的问题啊，那我们就必须在聊聊数据。

大家知道数据对于大模型目前的训练是非常非常重要的啊，而其他的开源的大模型，或者说其他的像这种infr这一层的工具啊，或者说未来的这些生态项目更加是需要建立在这个开放的数据集之上的啊。

那么大家认为数据的开源对人工智能发展有哪些重要的意义？然后又会在后边大模型发展过程当中催生出哪些机遇和挑战呢。😊，睇住边度。对，这块呃其实我刚早前第一个分享就在讲这个数据对于呃这个AI和模型的重要性。

这某种程度而言，呃，数据是呃应该是低性的是吧？相反是这个模型是在呃数据的一个一个投影在一个屏切面上的投影。然后你可以你有高质量数据能产生很多的模型。但是反之不成立的。当然你可以说你足够的模型往前回推啊。

你可能能把全量数据能够推导出来，但是这会很难很很难受，很辛苦。所以数据的重要性显然不言而喻。但是呢从另外一个层面上，数据呢去共享或者开源也是一个很大的难点。因为现在很多的数据呢隐私数据敏感数据。

它是人类活动的一个一个投影，或者是人类的业务或者企业它的业务的一个投影。所以这个时候大家都天然对这部分就是很很有很强的这种保护性。所以我觉得更多的是未来我们看看怎么样探索一个呃就是说现在的私域数据。

公益数据中间有没有一个呃有一个灰度的空间。那这个灰度的空间呢，就是绝对敏感的。你比如还在思域里面是吧？然后完全开放的，就是呃现在的这种开放开源的或者开放的数据集。

那么其中还有一部分是可以比如说可以被交换，可以被啊这个租用对吧？这样的模式可以去呃去推广的。我就认为这个可能是未来呃拓展啊，从拓展数据可用性上的一个一个一个可能性和尝试，这是一个。第二个。

从另外一个层面上通，本身从开源的角度来说，就哪怕我们现在能用到的这些开源的数据集或者开放的。其实本质上它是个开放的数据集。因为很多时候它不能商用啊，或者是什么各种各样的许可证条款。前段时间呃。

一直反正一直以来都有各种各样的数据集的问题。从最早的那google的imagenet开始是吧？就不能大家都有很多的这种商用条款的限制。那我认为从某种程度而言，就是我们要在这个数据在开放数据这里面去探索。

就是为什么就是它的商用的边界在什么地方。因为这个如果不能用于商用，只能用于科研啊呃实际上很多的这种呃我们的这种技术的突破是吧？尤其是这种技术突破之后的呃应用都会产生产生一定的问题。

那么反反过反过来我们会去想，哎，为什么这些数据啊，不能开源啊，开源到底有哪些风险，仅仅只是商业上的风险吗？还是这里面会有这个伦理上的风险。反过来我们要去反思，不是说大家因为稳妥啊，所以我不能商用是吧？

但是实际上呃这种不能商用的一个早期的一个简单的选择，其实会影响后面很多的这个事情啊。对我我能想到的这大概是这些点吧嗯。王老师。嗯，刚才杜老师说的其实还是蛮详细的啊，就是我这边嗯简单的补充一下。

就是数据要素的流通这一块，其实呃不必多说了。现在国家各个层面都已经在鼓励这个数据要素流通这样的一些一些工作。那么其实就数据要素的流通过程中，不管是内部还是外部，其实涉及到的问题啊。

其实跟我们的那个开放源码，包括开放模型都不一样。嗯，就是因为它涉及到不仅仅是说他这个风险程度也不一样。它不仅仅是涉及到我把我把我的代码开放出去，那什么都O了是吧？它里面我选个许可证。

不管是奇还是选一个那么这个数据这一块，那我把它开出去之后，那我一个贡献者和使用者拿这个数据去用，那其实这个里面还是还是有非常大的一个风险的。我们都知道前段时间那个某个那个社交公司是吧？被欧洲罚了。

7个亿到了呃欧元啊 euro其实很多公司在这方面其实还是蛮蛮注重这个这个数据这个就是共享啊，或者是说流通这方面的一些一些事情呢。所以呢就是说就像我们买房子哈，是呃也是一个非常有风险的事情。

我们很少有人是买一个房子，我自己跟房东就直接跑到房产公司那个去那个那个那个房产局去去去成交去了。一般都会去找一个一个专业的一个中间的一个机构去去去那个去去去成交这个这个房产。那么我们这个整整个数据流通。

不管它是是开源的数据还是必缘的。那我们是不是未来也会也要有这样的一个有第三方能够承担起这样的一个规避风险的这样的一个职能啊，这是我的一个思考。嗯，好，嗯。

我也是非常非常赞同刚才这位老师说的这个呃数据的开源，其实面临的问题不像代码开源或者框架开源一样那么简单。这里面嗯就是涉及到的问题有很多嗯。

因为像现在说政府也是在做这种数据的大数大各地方的大数据教育中心啊，教育所呀去去做这方面的工作，实际上里面涉及到像数据的确权，你的质量的管控审核是否合规，咱们的数据安全法里面。

未来是不是把大模型的这个数据也会放到那个立法里面，这些都是未来要待解决的问题。嗯，所以嗯可以把伴随着这个的解决，我觉得可能这个问题会会有所解决。

未来也有可能啊咱们大数那个大模型数据的这个交易放到教育所里面，我觉得也是一种啊方式啊，这是例所以啊从前面的各位老师这个总结。我觉得啊未来的私有化的这个专属大模型还是挺大的一个方向的。啊。

因为很多数据的问题解决不了。他必须但是又想做。😊，比如说企业或者政府内部，他需要大模型的助力，他需要啊去啊让自己转型升级啊，提高效率，降本增效。那怎么样？那只能说哎做一个私有化的大模型嗯。好，谢谢。😊。

对，其实我我觉得从数据的角度来看，我觉得可能最后这个行业会划分成两种阵营的数据吧，就是一种还是一种公域可以获取的这些数据，或者是一些偏开放性的一些呃数据啊。

这一部分的数据可以通过这种开源数据级的方式或者是一些第三方这种啊平台的一些方式啊，或者政府来去促成的一些方式去实现他的一种交易或者交换啊，我认为这是这一类。

然后另外一类呢呃可能更关心到这些企业内部的一些核心的业务数据啊，或者涉及到一些真正的这些个人用户的隐私数据。这部分的数据啊，我是持着比较保守的态度。我觉得可能很长的一段时间。

他都很难做到这种真正的交易或者是交流啊，这这其实是呃确实是这个对于企业来讲或者对于这些数据的真正的这些pricy的 ownerer来说，这是他们非常在意的东西啊，这是他们的核心的价值。

我就没有什么补充了，我觉得任何的这这这种数据开源的讨论呢，我觉得都可以放到呃在开源社区为我们创的阳光下一起来讨论的。我觉得是这样子。嗯，对，其实我本来还准备了下一个问题。但是我觉得在大家聊的过程当中。

把这块已经聊的很全面。确实数据对于一个企业来讲的话是非常非常重要的一环呢。你让企业的私有数据去开源这件事情就变得更加困难重重了。无论是从信息安全啊，包括提到的伦理的方面，道德方面。

这些可能都会产生非常大家的问题。那我们也希望有更多的借助于开源社区的这种公开共享的这种方式，大家更多的去探讨一个边界感啊，然后找到一个更合理的方式建立一定的规则和标准，甚至是立法啊。因为伴随着大模型。

我们对数据确权和隐私，肯定会更加的关注啊，从而想办法去激励或者鼓励大家把这个东西能拿出来，然后贡献给我们的社会，让更多的人去受益。这个跟我们开源的无论是代码还是框架这块的理念是不谋而合的啊。

但是在这个过程当中呢，我们现在其实是有解决方法。就比如说在私域数据把数据放到。数据库里边是不是这个方式我觉得还是OK的。就可能在这个过程当中，我们需要一个这样的一个方式，中间方式去过渡啊。

帮助我们去找到最终的一条非常好的一个道路啊。😊，OK那嗯我们在聊开源的项目，聊到最后都要去聊到一个商业化的一个话题啊。在这个过程当中，最容易引起争议的其实就是开源许可证啊。

这个是我们经常会有一些热点事件啊，在这块也是最容易翻车的一件事情啊。其实呃刚才有专家提到过那个。😊，f的那个那个新的那个项目啊，他在h face上面，然后去开源了，然后也也号号称是史上最强的大模型。

它参数虽然没有拉ma那么大，但是说性能效果都比他要好很多。然后他开源了，这是一个很振奋人心的消息啊，但是呢他有一个事情让他骂上了热搜啊，就是说他模改了啊2。0，你要仔细读呢。😊，他又遵循了他又没遵循。

在你商业化的时候，他又给你加了一些小tricks在里边啊，小心思在里边啊，所以他迅速的就被骂上了热搜。然后说他这个不是纯纯的开源精神，违背了开源精神，甚至是亵渎了阿巴奇基金会。

然后亵渎了阿巴奇基金会多年的一个品牌啊，也造成了非常大的一个争议啊，那面对着许可证，这样子在开源圈经常翻车的这样一个重灾区。那各位专家站在这个大模型的这个时间点是怎么看待这件事情的。

然后对未来的我们做开源大模型这块的呃同道中人有哪些建议呢？哎，杜老师。😊，好的，其实还是回到那个问题，就是模型的开源和数据的开源跟传统代码开源还是不太一样的。那么代码的开源我们。

传统上可能会更加开放是吧？包括我的各项权利都是比较简单的。你你有没有权利去再分发，有没有权利去再啊修改是吧？还包括你的这个其他的一些权利相对是比较比较简单。但是像模型像。尤其数据数据集是吧。

你能不能够呃这个数据被篡改之后还能不能再分发？其实他有的时候不是不是一个简单的是呃一个个人行为或者一个商业行为。他后面其实有各种各样的影响的，他会给他的这个原创者或者原来的贡献者其实带来很多的这种风险。

所以也不能简单的说这些加上了许可证，加上限制的这些条款，他初衷一定是坏的，我觉得可能也不一定。首先他比至少比没有开放出来的这些模型也好或者数据级也好会更加的开放？是觉得这首先是一个要肯定他好的一面。

那第二点呢，他就是在这个领域呢，确实他也做了一些一定程度的创新，也比如说他他说他他有个约定是吧？当你当你的收入在多少多少之前，你是免费差不多。但是到了某一个商业的结算点的时候。

好像要跟他要有一些利益的分成。我觉得这个也是蛮有意思的一个一个一个想法吧。因为这个事情呃不是坏事，因为呃好像他们最后又改回来了，我看那个最新的进展，好像又改回到这个比较纯粹的2。0。呃。

但是我觉得在这个呃开源和商业化，尤其在模型和数据这种新情况，新问题之上，我觉得呃有效的就适当的这样的探索。这个探索在于一个是探索大家的这个商业的边界。

一个是探索大家心理上对于开源的这个道德或者伦理的这种边界到底在什么地方。我认为都是一个比较有意思一有意思的话题。我觉得大家也别就一就是一下一棍子打死或者一棍子拍下去。因为在完全开放和完全封闭之间。

其实还是有一些灰度的地带。而且灰度地带还是也是有价值的嗯。好，这是我的观点，谢谢。好，下面我说一下我对这件事的一个看法，就是嗯前段时间也是这个事情闹得沸沸扬扬。

其实网上其实在开源圈子里面嗯骂的人还是非常多。这个因为因为从我的了解，就是因为我我也做开源出身嘛，就是。嗯。

就是很多这个开源人的这个脑子里面都有一种就是乌托邦啊那种那种理想主义的这样的一个一个一个理念在这边。但是我尝试从另外一个角度去想这个问题。嗯，就是我我们在想，就是说企这个企业为什么要开源。

就是企业的本质是要是干嘛的？企业的本质是要生存的。那个这个这个其实是一个很现实的问题，尤其是这个疫情过后这几年，其实大家日子都都不太好过，对吧？那么那么企业的钱也不是大风刮来的。

那么投资人钱也不是大风刮来的是吧？你你肯定要跟企业说明你你开源这个东西对企业的一个回报是什么？那么那么那么那么focom他就采取了一种就是简单粗暴的这种方式啊，就相对来讲就简单粗暴，直接哎。

我你你用我这个东西O没问题。那达到了一定的规模之后，你就得给我交份子钱，交交买路费是吧？这个这个确实简单粗暴了一点，但是那个怎么讲呢？其实其实我从这个从企业这个角度来讲，其实我倒是蛮能理解。

就是企业它当时就是。在这个呃乌托邦这个理想的状态和他企业生存状态的这种情况下在挣扎过，他做做了这么样一个妥协。然后结果扔出去之后还是被网上一片骂。所以所以在这里呃我也抛一个问题。

可能也也值得大家思考一下，就是说我们做开源这个事情。当然我们是一个理想主义者，对吧？那么他和企业的生存之间，他他怎么产生一个平衡。

我觉得这样这也是一个就是嗯也也一直是困扰我也是也一直我估计大家也是经常能够呃想到的一个问题，今天反正借这个机会，也也再一次抛给大家吧。大家也可以和我们一起思考一下。对，这个事儿其实我也是听说啊。

也没有那么详细的了解，我就觉得呃可能是在现在的这个环境下，针对模型的开源，也对我们的开源组织啊提出了一个新的课题跟问题。就大家需去解决这个问题啊，尤其是就说企业说刚刚这位老师企业为什么开源。

企业除了要品牌啊，要盈利。其实他其实咱们这组织开源的组织，或者说我们整个社区能够让企业鼓励他愿意去做这件事情啊，希望跟大家探讨。好，谢谢。我我对这个事看。

我觉得就是其实呃方控这个其实设了一个是很好的里程碑。我觉得在此之后应该就再也没有这种状态的这个license的出现了啊，因为这个它本身是破坏了这种这种开源的最最本真的那一套秩序和规则啊。

然后这个也是承受了很大很大的压力都改回去。整个事件我都从头到现在还在follow他们，就是他们现在是特别的这个拥拥堵这个呃这个开源和这个开放的这个生态。所以我觉得就是还是发自本心吧，就是如果要是做开源。

那就是就是真正的全打开啊。如果要是做商业化，那就是这个去专心的做商业化啊，这里面我觉得是可以存在这种共存的生态的。但绝对不是这种通过改license的方式来去做这些取巧的事情啊。

他这个问题其实杨总最适合回答哈。来来来，我我总讲我我觉得啊这个我坦白说，我我从呃我觉得这个呃呃license是人家的选择。他有这个权利，但是呢就是不要产生这个误会，就是让大家觉得你是72。0。

因为大家可能做了一个assumption啊一个前前提假设你是这个开源的模式，你是应该是免费。但我希望就是说呃我们所有使用开源的人，我们用开源的不要做这种假设，因为那是人家的权利，人家人家的心血。

他就刚我们说他用来用来生成这个这个用来去赚钱的。这个我觉得是是对他投资人的一个一个11一个尊重啊，是天经地义的。那个呃但是呢就是说呃就是江督总刚才说的就是说你如果你是利息要开源。

你你有的东西我们事先要做清清楚楚的，不要给。一个模糊的概念啊，这个我觉得非常重要，你可以自己另立一个license啊，就你可以不叫这个apartache，你你可以叫一个自己的，这个没问题啊。

这在开源领域，这是很正常的对吧？你可以自己自己做一个而避免了这类事情，大概就不会有人骂你了。这个事情我我随是支持啊，就开源不是做公益，开源是一种商业模式啊。

就是呃嗯不没有人说你做开源就一定要免费的这个这个是这样子的。😊，O好。然后我觉得杨总最后一句话说特别好啊，就是开源并不是代表着做公益去免费啊。其实像这种就是day one去开源的公司啊。

我们也面临到从商业化的开始。其实你你我们也是阿巴奇 two这样子对其实也在这个商业化过程当中看到市面上有有一些人拿你这个东西自然而然的去和你去竞争。对其实你看到了之后。

你是会有点就会回想我当时做这个决定到底是不是错的啊，但既然我们前期吃了开源的红利，那我们就会坚持着走下去，然后帮助社区里面的更多人去受益啊，这个也。也去遵循我们自己的一个开源的一个初心吧。

还是把这个事情去做好。但是面临到商业化的平衡。可能我们唯独就是只有一个办法，就是做到商业化产品比开源更好。然后给我们的企业用户提供更加有价值的服务，提供更加企业化的一些服务。

这样的话可能才能做出一方面不辜负社区一方面又不付信任我们付钱的客户。对，其实这个中间的点还是挺难平衡的。我其实不太喜欢网上那些键盘侠啊，抓住一个东西啊，你原来免费，你现在为什么不免费。

或者你还是有条件的免费，你干嘛不不不直接就这样，其实这群人往往可能他们没有真正做过开源，也没有自己去去去run一个开源项目，甚至是在这上面去付出了更多的精力。他不知道那些人的艰辛是怎么样子的。

去怎么样去维持这样一个大的一个系统去很好的去运转。呃，但是其实开源的初心一定是利他的。我觉得一定是利他的对，但是后来有。😊，就这样那样的方式。所以我特别同意开是一种商业模式，大家保持一种好的心态就好了。

OK。啊，其实时间也差不多了。然后我们今天可能话题也比较多，也没有办法很透彻的去聊完啊。然后呃。我们这也是一个最后一个环节，其实两天的志愿大会非常的精彩，也非常欣慰的是呃，今年的线下活动越来越多了。

其实对于我们做技术人来讲的话，能坐在一起，能够去聊天，能够去沟通，是一件非常幸福的事情啊。然后这场盛宴也马上就要落幕了，非常感谢还能坐在这里的一些朋友们啊。

然后呃那就请各位专家最后用几句话的时间来总结一下你们这两天呃参会的一些经验。然后包括未来的一些感悟吧。😊，对，这嗯。在这两天那个资源的会反正还是呃，我觉得规格还是很高的。

基本上应该算是呃国内乃至全球这个范围。大家。

呃，呃人工智能这个领域做的最先进的这公司也好，或者是这个科研机构啊，其实大家都都都到齐了。我觉得是一个很好的一个技术的盛宴，或者是一个大的一个这个呃这个技术的一个party啊，我觉得蛮蛮好的。

就是这个完美的印证了。其其实我们现在。整个业界的这个。趋势热点确实在往在AI啊模型这个领域啊在推动。我觉得随时随之而来的是我很期待在未来的。几年里看到这个我们所一直所说的这个起点到底是怎么怎么发生的。

那么未来当我们啊进一步变老的时候，我们回过回过头来再看一看，哎，会想到这个起点之前的那个那个时代跟我们之后的时代啊，好像完全不一样，有这么一条明显的界限。

我想我我我认为这个明显的界限可能就是在啊今年和明年这么一个点。我觉得还是我们非常幸运的去见证这样一个时刻。谢谢，我们一同期待吧。来，孟老师呃，我是那个今天下午才参加这个论坛啊，但是我参加这个论坛论坛。

呃，之后呢就是刚开始听一两个之后，我就有点后悔了，我应该提前两天过来来参加这个会。呃，当然这个这个时光也不能倒毁，那只能在后面看看那个那个视频了。呃，有有那个视频的那个吗？录像吗？有是有哦，那行行。

那行，那我心里现在心里面舒服多了已经。那个呃最后总结一下吧，就是。这个这个我今天下午虽然只参加了半天啊，就是给我的感觉就是耳目一新，刷新了我的认知。好，谢谢大家。对。

我我是觉得这个办的这个会真是一个头脑的这个盛宴啊，让人感觉啊受益匪浅。然后也预祝未来咱们这研究院的这个会越办越好。然后我们一同为人类AI这个方向做一些啊这个推动跟贡献吧。呃，我是昨天晚上赶回的北京。

然后这个幸运的是我这个昨天在这个那个那个这个直播，我倒看了很多场啊，确实是这次的规格真的是特别的高，而且受到了很多启发啊。最后这个我觉得在点题一下我们的开源吧，我还是相信就是通过开源的方式啊。

这个一个两点，一个是汇集所有人的力量啊，这个让每一个人都能都能够有机会参与到这一次变革中。然后第二就是他的这种呃transparency，就是它透明性。

让每个人可以在这个整个开源的开放的这种体系内去贡献，并且让别人能看到你的贡献，保证了整个的这种可控和安全。我相信啊这个整个的开源会成为。未来这个在大模型领域里面，是整个人工智能的进程或者AI的进程里面。

一个绝对会爆发的一股大力量啊，我们一起期待。呃，我觉得大家看到了这个叉GDP的这个表象，就是呃AI人工智能突然之间成了全球最炙手可热的科技。呃，很多说未来G叫这啊将会成为我们的这个操作桌面的操作系统啊。

门户类。但是呢我另外我我其实想让大家呢更更多的去呃关注的就是这个AI的这个底层技术，开源社区，我们有很多非常好的这个开源项目跟开源的这个底层技术，我希望有更多的能够呃加入到这个开源的行业。

加入到我们这个开源的这个呃软件的生态。只有掌握了底层的技术啊。今天我们其实开会大家听到了很多这个呃开源项目，包括华为的这个例如？这这一系列的这今期大家听到了很多。其实这个才是我觉得这个才是我们中国开。

🎼能够强大的根本啊，这个我希望大我在这里就是希望大家能够更关注的就是我们这些开源项目，开源的技术。好，谢谢。好，开发者强泽中国讲大家都处在AI2。0时代的这个划时代的节点上面，希望大家积极参与进来。

那参与呃AI和数据开源最好的方式就是开源啊，希望大家呃多多支持以后FAI的活动，多多支持智源的活动，多多支持我们这样AIinfr的公司。好，谢谢大家今天顺利结束了，谢谢大家谢谢还留在现场的各位朋友们啊。

看到你们的笑脸，真的好开心，谢谢。😊。

AI系统论坛 - P1 - 智源社区 - BV1eV4y117xF

OK啊，谢谢大家。😊，Okay， good morning。 Since we have the some invited， very important speaker here。

and we have some foreigners here。 So allow me to give this opening in both the Chinese and English。

because we don't have the automatic translation system for this。😊，Bshop， so let me do it by myself。

嗯，那个呃大模型时代哈呃。😊，当我知道要缺这个work时，我一直在想是说whats the important thing for the for the large large model and especially how what is the important topic for the AI system in this new very important new trend for the to support the model scale大模型时代到底 AI system在组织这样子的我们应该放什么样的top进来能够让 aI system更好支大模型的发展那 of i think the very important thing is the performance is the large scale system performance the training the training最重要的其实是这个怎么样很高能的去支撑这个训练系统。

And the other thing， I think， is。The what kinds of chipet。

including the media chipet and including the the other architecture innovation to support the AI system。

另外一方面是底层我们有什么样子的 AI的 chipet，包括英伟达一代一代的新的 chipet，也包括我们很多新的呃芯片的架构。

And so that's why we have a arranged today's workshop。

including the high performance parallel optimization for deep learning and different kinds of chipet architecture。

so所以今我们很高兴邀请到了位专。😊，代表着我们的包括pyto，包括ray，也包包括vi这些的高性能的去优化我们的，尤其是训练的这个架构的性能。

同时也邀请到了呃几位代表芯片厂商的teco leader来介绍呃，在这方面他们的insight。But in between the our algorithm and the chip。

very very important is thecompr AIcompr。但是大家要注意，其实对我们越来越复杂的大模型的算法和下面越来越设计的很高性能的我们的硬件的呃这个GPU或者的的呃架构。

很重要的是中间的AI的编译器啊。So today， I also are very glad that we can invite a very。😊，Very typical。

very very famous compiler in AI including the P A P AI compiler and including the MO IR and also the the other maybe the next next generation aI compiler and also the some research for how to the things for the compiler今天也很高兴在 AI compiler这个重要的一个领域我们也邀请到了很有代表性的包括 touch的。

😊，编译器的 leader包括 MLIR啊呃 gogle啊 from gogle and还有可能是未来我们再去考虑下一代的 aI编译器包括我们来自于计算所中计算所代表的怎么用 automatic方法来优化 AI编译器O so today I don't want to spend a much long any longer time and just want to invite this speaker and because we have very very tight schedule and because so many so many so many things for the AI system today。

所以嗯那我们就不再花其他时间了。所以OK so let me啊 introducetrod the first。😊，Bpe。Alber Cohen， yeah。

let me have a introduction for him。 Albert is a research scientist at Google。

and he graduated from the University of Veia。😊，Sorry， I don't know if I pronounce it correctly。

no matter。 And actually， hes I， I think more thing more he's now work for Google and a lot of things related to the M O I R。

And， but he's the very active guide。 a lot of research and work for the G C before。 Yeah， actually。

he is the very famous person in the compiler area。 So that's welcome。😊，谢谢。😊。

Thank you for the very introduction and invitation I'm very excited to be here。

So I try to speak not too fast， but I have natural tendency to speak very fast。

So we are talking about large scale models language models in particular。

but I will talk about small things like mostly by making the most I mean。

more like in the bottom of fashion。 So if you want to get the best possible performance at large scale。

you have to start small from like the instructions at low level vectorization and the caches and optimizations for the that are very hardware specific。

So that's what I'm talking about mostly today about and。😊。

It's not in my background as you already mentioned Yhu bit I've been working in compilers for more than 20 years。

most likely you are aware of some of the work in the parallelizing and so-called polyheral compiler context if you have worked in the area but I don't want to to talk much about this today we are not into looking for parallel loops into legacy code anymore we have the chance that because of machine learning workloads parallelism is all over the place the question is how do you make good use of it how do you exploit all these degrees of freedom all these domainspec languages for ML and to extract the information you have put it into good use for reaching the best possible performance and in this space I've been working both on applying machine learning to compilers like。

15 years ago， and then I had a break， work on other things and then came back to using that again。

ML in compilers， more like new type of ML， like deep learning。

and also building compilers for ML more recently originally at InRa and Facebook。

and then I joined Google more than four years ago。So that's a quick introduction。

So why MLl and compiler， So you already say it， but if you want to get the best possible performance out of any like domain。

you need some kind of compiler that will assist the translation of the abstraction of that domain to get the best possible performance of the hardware so let me give some concrete extremes or examples。

Some people care mostly about。Some people mostly care about peak performance。

like most of the people working on language models have to rely on some form of operators optimized。

P you optimize for given a piece of hardware and other people mostly care about performance portability。

meaning that you want for example， the model developed on the data center to be easily portable to a mobile device and I took some kind of extremes here like the Waafer scale process of from cebras and edge TpU from Google there are many of course equivalent chips for mobile or edge devices So how do you get both typically how do you get the peak performancements you can for given chip and also how do you make it easier for programmers MLl programmers to port their models across all these different scales So that's what compilers are going to help you do and so this is tough because of this hardware diversity all these different scales but also on the software side things are not very nice although it's improving a little bit so there are many MLl frameworks of course tensorflow jackx by tor many other frameworks and also the model size and complexity。

😊，is really increasing very quickly so maybe some of you attended the presentation of my colleague Yan Chi yesterday on a mixture of experts。

so the complexity of the models is growing with this typically the size of the data sets。

the multimodalities and all the optimizations you may want to implement。😊。

Make the models more and more control intensive， so it's not only matrix product。

but at the bottom you still have like matrix product anyway。

but the complexity is increasing and that's really big difficulty for ML compilers as well。

So let's take a step back and try to understand what ML compilation really means in practice。

So the state of the art is。As any compiler would look like so you have a high level language。

in this case it's a domain specific language of standard operations， for example。

a Python embedded the domain specific language like Pytch or JX and you have some methods to analyze graphs of some operation of these operations apply high level transformations like automatic differentiation。

different ways of polyling， etc， and then there's some kind of magic thing underneath that's called a tensor compiler that will translate these graphs into efficient code that runs on CPUUs。

GPUs， CPUUs all kinds of hardware。So that's a very rosy， very beautiful picture。

but in practice it's not quite really that nice， it's not that glorious as I prefer to say。

on some hardware compilers are really doing a big part of the work like on Google TPUs。

there is no real like independent library。😊，Basically nobody can program it outside using the X compiler for TUs on GPUs from NviDdia。

it's quite different， so you have lots of NviDdia engineers writing library code like coDNN that is actually doing most of the efforts if you're running like transformer models most of the time is spent on coDNN operators and heavily optimized attention layer for example。

same thing for CPUUs and most hardware companies are spending quite some time writing hand optimized libraries so there's some level of automation usually but it's eventually very hand optimized code So what's the role of the compiler in this space if you're using libraries eventually so that's a real question and I'm kind of anticipating the next talk I'm sure that Penggu will tell you that compilers are great but。

Typically， most ML programmers will see it as a bonus。

so if you can compile and get better performance with legal default。

it's great I'm not going to waste your talk。😊，And so why is it a problem actually there are many reasons one reason is that it's difficult to implement fast neural network layers by hand。

of course， as you can imagine， it's most practitioners don't know how to do that you need to be a high performance computing expert you need to know the platform very well and the benefits of doing that can be huge so if you write na code it can be10 times smaller than sorry slower10 times slower than like peak performance and so basically anytime you do research on a new model or trying to tweak an attention layer bit or conversion layers a bit doing some kind of custom fusion。

you have to redo that， you have to implement again the lowle operators on your machine and that's very inefficient maybe some of you heard about the Triton project and language from open AI TVM or a library in that space and language in that space that's。

Succesful， so there is a lot of need for writing these kind of custom operations and optimizing them。

but it's still very tedious and you would rather not go back to writing lowleve code if you had a good compiler for it so what about ML compilers today on this picture that was this ML compiler are still there for a reason and the main task that ML compilers are very successful at dealing with today is applying high level transformations so like automatic differentiation I mentioned so I'm mostly looking into JX in this example but also high level distributed computation automation vectorization and of course figuring out at which level you want to apply just in time compilation so if you're able to I'm actually hiding in the slide I remember if you can actually control at what function graularity you want to apply a Giit compiler like XLA in the case of JX you would typically do that with this type of low level sorry very high level。

Abstractions。 so that' that's great benefit because you don't have to think as an MLl programmer in terms of low level optimizations。

everything is happening behind the scenes in these high levell transforms like Autod and in the Gi compiler。

The problem is that this is still very high level。 You're only doing like tracing the computation。

building syntax trees optimizing like building graphs recognizing graphs automatically and maybe iteratively trace and transform those graphs until you get to some cluster of operations that you can optimize together。

and most of the magic is still happening down there。 if you want good performance。

you need something to actually deliver good performance on the target。

And this is not this big cycle of tracing and transformation that will do it。

you need a library or you need the compiler underneath。 And that's what I'm focusing on here。😊。

So the type of benefits you can get from compilation are typically there are numerous but the main ones are getting rid of interpretation overhead。

that's the most likely purpose of using a compiler way that you don't want to dynamically interpret and dispatch the logic for different operations。

you can also use this for fusing operations the memory hierarchy like the caches。

local memories have to be leverage in a way and that's typically through fusion that you can do that so avoiding roundtris to main memory or across device and host interfaces。

you can also do a lot of optimizations at that level by looptyling unrolling vectorization etctera that will be necessary to leverage specific hardware and it's also very important for reducing the exable size。

the code size， especially on embedded mobile devices。

you can specialize the code to one very specific model， unlike libraries which have。

Provide operations for every possible model， basically。 So it's also used embedded space for that。

and also a very important thing。 you can do auto tuning。 So with libraries。

you have to think ahead of all the possible shapes。

all the possible operations context like layouts， etc ceter。 When you are compiling。

you can specialize on one particular shape and layout and the context in which an operation executes。

So that also gives rise to interesting automatic tuning techniques。 But okay。

I have to be very humble here because I've been working in the area for 20 years advertising for these great benefits。

but we are still there。 I mean， are we making any progress here。😊。

And basically the like ML now is everything that what that's what paying the bill。

but the problem still is still there， although we live in a more specialized world。

So we have to we have to think twice。 and I want to briefly advertise these auto tuning efforts from some colleagues。

😊，Presented at a PA conference a couple of years ago。

if you want to learn more about auto tuunning because this is a big part of our job。

this is one great example of things happening in the space of XLA for Tpus。

but we are also doing that for other targets just advertising for this piece of work led by my coding Wangpo and more generally if we want to make progress actually I'm coming here not to tell you how to do it I'm mostly coming here to ask for help and collaboration because after 20 years we are still there and so I'm going to ask a few questions like through some proposals in the rest of the presentation。

So my first claim is I think we need to move from compiling for M into more and more M using completionil。

So of course this is not new I worked on it like 15 years ago there was work before that。

but it's still very much immature。 So there are not so many production compilers that actually use MLl techniques a little bit of auto tuning offline。

but not so much when you are actually actively compiling code。😊。

The main reason is that it has been of course a difficult problem to optimize like and be complete problems or like scheduling。

register allocation， et cetera， forever， but now we are dealing with very hardware specific optimizations that are even hard to model correctly。

so we don't have a cost model we don't have an analytical means to reason about performance。

Typically， the only hope is that the machine itself can learn what is good， what is profitable。

what has to be optimized for given operational graph operations。

And one approach to do that is I would call it controllability。

So you want the compilers to be more open in the sense that there are more gray boxes。

So you want to intervene as an expert performance engineer into how the compiler generates code。

So it's the exact opposite of what I was showing at the beginning。

where you have a black box very abstract。 You said jet and it's magical。 In this case。

it's not magical at all。 you want to intervene and say I know how to optimize this particular operation。

Please do this for me automatically because otherwise I have to write triton code or could code or something So scheduling languages that have been popular for reason But on top of that。

you still would like to automate those schedules So you want to infer basically you want to search basically what's the best possible schedule for a given machine and given shape etc ceter。

And you want to also automatically build the schedules for you using machine learning techniques。😊。

So that's I think one very important thing and schedules。

there are actually many different types ofs or scheduling languages in hyperfa computing actually even started even earlier。

like in the early 90s there were some ideas or in that space in polyhedral compilers I worked on some of these techniques in like 15 years ago with language that we designed also with Nikcolola Lavaski at Facebook we had these tensor comprehensions work that also had schedules and now Heide and ProTVM you know are very popular in that space basically Heide change the rules of the game completely making these scheduling languages much nicer to use and much more embedded into domain languages so it's not new there are lot of work at NVDdia as well etctera in that space but。

And oh yeah， that's the one I was referring to 30 years back we already have this type of first。

but I'm not expecting you to read that So why schedules the main reason people want schedules。

as I said， is performance engineers want to be able to control what the compilers do because if they cannot they will never get the peak performance you want some kind of way to reuse the existing logic in the compiler without having to completely forgo the compiler and write lowlevel code code on a GPU and one typical example is when you have a clear optimization methodology in mind so in this case it's focusing on matrix product and conversions is the bliss methodology that is essentially sketching how product matrix multiplications are implemented on any acc or even CPUs these days and you have to decompose your computation into layers of tiling and at the bottom you have like some very optimized vectorized unroll code that will be very specific to your machine and actually I figured it。

top down way but the real way these methodologies are implemented is more like bottom up so you first write microchans of heavily optimized unroll loops and vectorized and vector instructions and then you slowly grow more like unclosing loops around these microcans to reflect the memory hierarchy and the partism hiarchy of the machine and so this is this b methodology that is quite popular we did some work in the area as well and realizing that in fact we can build search spaces we can build scheduling languages that have these kind of methodologies captured in a more specific way into the scheduling language and into the search base so that was a paper that I mean the tool was called Tit but it's not in the title that was joint work with In and colleagues from University of Utah in the US and we essentially showed that there are ways to automate the process a bit more than using TVM for example and I'm not going into details but in which。

TheHere is that。You can actually have more than one microcannel if you look at like one DNN library of Intel。

the ML library of Intel on x86， you essentially have three microcannels written in assembly language if you look at coDNN or coubs and NDIS it's about 20 but you can have more than one microcannel that have to be generated automatically if you want to some level of portability or in the worst case you write them by hand。

but you'd rather not do that but you select the best microcannels in this case you have this kind of cr shape of microcannels depending on the unrolling degree on the size basically of the microcannel and on top of that you can grow the rest of the stack completely automatically so I don't have time to go into details but let me skip that the scheduling language can be extremely simple in that case so you don't have to write very complex sequences of transformations you can only say I have like five basic primitives for organizing the computation above the microcannel I can decide on loop。

factors I can decide on what to vectorize like which dimension is it like row column et cetera vectorization。

I have to figure out ti sizes like block sizes， if you're on a GPU， how many threads。

how many blocks etc cetera you're going to have also and the rest is so you can yeah you have to generate the rest of the control flow this is this R construct and you have this fancy lambda thing at the bottom that is a way of sequencing channelss or microcanals so you need to accommodate for one very painful thing in hypophone computing which is that。

😊，All the data， all the sizes， all the shapes are not powers of two in practice。

I mean actually in transformers more and more it's like powers of two。

but on convols is definitely not powers of two， a very fancy thing like 34 or 17 or something like that not sometimes prime numbers even so you have to be able to compose multiple microcans until you reach the proper size so I'm sorry I'm going fast I'm not explaining those things in detail but but it makes the search space much easier to traverse at much smaller when you have such very specialized scheduling language and in this case in this graph we are comparing the TVM auto scheduler called Ans。

which is the blue bass so blue graphs so TVM works by chunks of 64 runs like empiricalical evaluations on the machine and every 64 runs so this is log scale at the bottom but this is 64。

😊，It will try to select using cost model that is being learned， the scenario。

best possible optimization using TVM schedules， and if you use our schedules which are more specialized and compressed you can you can very quickly converge like maybe 10 times less runs or even less than that。

Just a demonstration of working on the scheduling language helps if you want to reach the automatically the optimal solution。

So I like to make one proposal here and this is really again calling for help okay we see that there is some room for automation of schedules and writing more domain specific schedules。

but there's still one problem that we are facing it's going beyond those static shape like specialization so when you know everything about the layout the shape it's great you can do this completely automatic search offline and you get the best possible implementation for one very specific operation but in practice you still like to bridge the gap with what libraries offer like coulddNN coubla etc they provide you with and one stop shop basically for all possible shapes and it's kind of frustrating that you have this libraries that have very generic on one side and these compilers that do automatic tuning for just one possible shape So I call it TLO tie level operations so Google doesn't have anything there we're just asking questions but we'd like to devise some kind of interface where instead of thinking of。

😊，The high level library of operations that are essentially the ones you would write in Numpy or in JX or whatever MLl framework。

you have a library of operations that is automatically synthesized for given model and given hardware at the T level。

so I would argue that the compiler is extremely useful。

As this bli methodology shows to generate optimal code at the tile level。

like maybe on a block on the GPU or any code that runs on the L1 on or L2 cache size on the CPU。

But you don't really need the compiler to orchestrate all the computation at the level of the full node it quite intuitive that you will have some kind of runtime system。

some kind of dispatch logic at some point that is going to be interpreted。

If you're close to the instructions， you need to compile。 Otherwise， it's too expensive。

But if you add the level of like full operations， you don't really need a compiler。

The dynamic dispatch can be fast enough。 So there is this kind of boundary between tile level operations that are compiled underneath。

And above that boundary， you have interpret that can quickly dispatch。

Across these different operations， the challenge here is that you don't want those operations to be decided by an expert。

you want those operations tile level operations to be automatically synthesized for a given domain。

and I call it like a 2D paros surface so you want to trade basically preference for code size for specialization on a given domain So if you know exactly you're only going to run like large language models with this particular shapes it's no need for optimizing for like LSTMs you're only optimized for that particular shape and model architecture。

But still I think the problem is reasonably well definedfin。 there is no solution to do that yet。

I mean a couple of papers are coming close but if you're interested， I can mention them offline。

so briefly about MLAA since you mentioned MLA earlier so we are building infrastructure to address these issues likes scheduling compiler construction more portable reusable etc using the MLAya framework so I'm not going to give you a course on MLya we don't have time and there are plenty of resources online and maybe of you already know about it。

but it's MLya has been designed for extensibility， so basically it doesn't do anything。

but it's great framework for implementing compiler flows and also bridging frameworks for example。

you may be aware of something called stablehel which is now being used by many frameworks including Pytch to communicate with with XLA and there is this recent open ExcelLA infrastructure initiative that is endorse by many companies which is not governed by Google anymore so it is a separate organization。

Of course Google was there to start it up， but it's a community really like LVM like MLR to build this next generation portable compilers for ML and so I'm skipping MLAR examples sorry just mostly to focus on one aspect of MLR which is extensibility but in extensibility in a very specific way about how do we build schedules in an extensible way。

I told you schedules are very important for performance， very important research area as well。

but we don't want to start from scratch， we don't want to implement a new scheduling infrastructure like TVVM from scratch and using MLR what we can do is that we can start from the baseline optimization flow that takes。

The intermediate representation of the graphs that you are optimizing some like handcoded optimization and uristics and generate code and you can extend it with the same syntax and the same logic and abstractions of MLAI with another IR which represents the transformations this time so for example。

if you want to teach the compiler to do fusion of matrix product and softmax for attention layers you can explain those the logic of this fusion in terms of rewriting rules in terms of patterns in the AI itself and you can drive this this transform AR with either by an expert writing schedule by hand so it's very painful because it's an MLI logic but on syntax but you can of course use the DSL on top of it but so you can write this IR directly saying I want specifically to fuse this matrix product with this softmax or you can also embed a database of transformations that have that can be search automatically so you can add so some AI around it。

Some auto tuning logic that will automatically schedule this transformation。

So you can make every thing， every component I was showing earlier with schedules and automatic scheduling。

As an extenible component of MLya and so this is something we are working on so there are also some extralog。

maybe a little bit of C++ you have to provide for some transformations。

but most of the time you don't have to do it。 and so if you're interested in this approach So MLya can help you do that like building your own scheduling languages。

your own custom TVM if you want we call it the transform dialect and there was a great tutorial given by my colleague Alex X code with the main actually contributor of that project at the MLya at the LLVm sorry definitely last month so you can look it up and there is also a paper that was published recently So I don't have time to go into more detail I can conclude by just saying again we have problems to solve some of them we know well some of them have no clue so we are very interested in collaboration if you are in this room you already know that so that ML is not just about data models and compute but it's also about compilers otherwise ways you will not be in this room。

And it's also just the beginning so we have been working for 20 years and actually many more years on this type of hypo computing techniques。

but now in the field of ML we have much more advanced ML techniques to use as well so we should really bring those into the compilers as well thanks for your time。

😊。

Okay。Okay， okay， thank you。Yeah， so because the very tight schedule。

So I didn't arranged any Q a for this for today's any speaker。

but welcomed for any of your questions of line。 Yeah， so next I want to introduce Peng Wu。 Yeah。

actually， the one special thing I want to mentioned。

and I don't know how many of you have watch the the launch of pie touch 2 dot0 that event actually I online to watch that and right after the touch2 dot0 and the first invited speaker at the some important tackle announcement the first one is Peng Wu and。

😊，And she announced the compiler dynamo for Py 2 0。 And at that time， I think， wow。

Py have the compiler now。 So that's to be something the special or beginning things for P。 Yeah。

So Peng actually， she have work for IBM research more than 10 years。 Actually。

I also work for IBM research for the system for more than 18 years as well。😊。

And and she later was for I for Huawei and established Im the programming。😊，Lb， yeah。

and work for Huawei for seven years。7 years。 And then she joined the matter and let the compiler part for matter for three years。

Okay， let's welcome Pg yeah。😊，Alright。Okay， thanks for the introduction。

You might notice on this agenda。 we have2 P towards 2。0。

Talks， I didn't realize thats the second one， but I want to qualify this one。

So this one is focusing on how we are bringing compiler to the core of Pytorch。 And then later。

the next talk， Michael is going to focus more on how Pytor 2。

0 is helping the large language model training。So you've already heard one compiler talk and I saw in the agenda there are more。

So before I start， I want to give you a mental model of like not all compile M compilers are the same。

So one basic way to differentiate is in my mental model is to differentiate between。

Machine learning framework compiler and machine learning Acccelerator or hardware compiler so。

Albas talkg is more coming from the bottom from like closer to the hardware。

And because our compiler is called Pytorch compiler。 So we are more coming from the top。

and the thinking is very different because as a framework compiler。

what we are focusing on is how can we enable all these hardware vendors to bring Pytorch models to their hardware。

So there are things we do we have to do and there are things that we want the vendors to do。

So keep that question in mind on the thinking behind machine learning framework compiler。

So today I'm going to tell a story。 I know there are many people are building their own chips or even their own machine learning frameworks。

I hope at the end of talk， you could get a glimpse of the thinking of how we are burning compiler to Pytor 2。

0， not for the interests of research ideas， really for making real models run faster。Alright。

so this is the release note Earl this year， March 15， 2023。

This is where we actually release the Pytorwar 2。0 binary。

and it says that we want to offer the same eager mode development and user experience while fundamentally supercharge how Pytor operates at the compiler level under the hood。

So let me just simplify the message。 I want you to remember two words。Graph mode and ease of use。

So it was long believed by the industry that you can either have graph mode or ease of use。

but you cannot have both。 And in this Ptor 2。0 story， I'm gonna challenge that conventional wisdom。

So essentially， I'm gonna show you how do we have the cake and eat it， too。But before I get to 2。0。

let's。

Roow back five years to 1。0。 So Pytorch 1。0 is was announced almost exactly five years ago 2018 at the time。

almost all the major industry backed machine learning frameworks or choosing graph mode because it was believed it's rightly believe so that with graph mode。

you would have the ability to optimize using compiler and the performance leading would be a lot a higher。

if you optimize one at the time。 So Pytorch is actually was actually a late comeer in terms of machine learning frameworks。

And at the time， we made a critical， also risk a decision to。

Value ease of use above everything else。 The thinking is that we want to cater to machine learning researchers。

and for researchers， they actually value more time to market than performance initially。

But with that work we actually don't know so what we did is actually we are one of the few probably just go all in with non graph mode and then we compensate on the performanceman side by working very closely with vendors to optimize at the library level and optimize whatever we could within the constraints of eager mode execution。

So。The data showed that this bet paid off。 so since the 1。0 announcement at the time。

we were about 30% of researcher adoption。 and as you can see。

the curve is going up and around two and a half years marked after the 1。0 release。

we have passed the 50% mark and that essentially meant that were the number one machine learning framework used by machine learning researchers。

And you see a little bit of dip over there so actually I double clicked into that so this is based on same data source。

but rendered in a different way。 so the middle session。

the red part is a Pytorrch kind of researcher and market share and when you see the dip here is actually more about a few new up and coming machine learning framework and because this is in China so I want to highlight a few homegrown machine learning frameworks there is the mindsbo I believe here which sees a significant increase actually I used to work on the Minsb the accelerator compiler and then there is also the pal。

the purple one let's see and Jas is this green one and then there are like a lot of other things and from this picture you would see that there are a lot of players over there but Pytorrch because of this ease of use is really。

Becoming the anchor of a lot of the kind of the framework of choice。For researchers。Alright。

so now let's go to Pytor 2。0 what this talk would be focusing on one specific feature。

but a fundamental feature of 2。0。 We introduced this very simple API Tor compile as the primary API for introducing graph mode。

And。What this does is remember ease of use and graph mode。

So basically what you are when you are writing the model， you're still thinking in terms of eager。

So this is very different from the traditional graph mode based MLl framework in those framework you have to think about graph and that's why researchers didn't like that。

It's just not intuitive very hard to debug So here you write as if you are in eager。

but you do an annotation just one line change to indicate to the compiler this is a part that we want to make it work under graph。

So it's very， very simple right So does it work and actually in the Pytorrch conference announcement last December。

This is a data we showed and we're showing over 170 models。 Tim is a vision model。

torchbech is a bunch of highly popular research models and hugging phase is more like the today。

Former based models and the results are run on an media A100 and we combine results between AMP and flow 32 with more weights on AMP because that's more performing for training and all these data are for training so these are the geoamine performance speedups that we're reporting at the time and today the number has further increased。

Alright， so。You might wonder why do I make such a fuss about graph mode Almost all other machine learning frameworks use graph mode right so the problem is that because of Pytorch design for flexibility and expressiveness those good trades actually made it very hard to compile or to introduce graph mode with So if we look back on 1。

0 and 2。0 I could say that 1。0 is about a strategic decision of like who are we catering for and what are we giving up and what are we embracing for So that's 1。

0 for 2。0 it's really about actually the emergence of 2。

0 is really based on tech innovation So the moment we figured out how we can get the graph mode without sacrificing ease of use that's the moment that 2。

0 becomes real。And that moment is a torch dynamo moment。 Torch dynamo is an out of the box。

G capture 4 pi torch。😊，So if you have followed about Pytorrch compiler， I mean。

people didn't know about Pytorrch compilers maybe two。

three years ago because we have too many of those so we have tried many times and our previous graph capture always require significant menu effort when you are trying to work with real models。

So this menu effort ranges from either you have to change your graph or model to make it captureurable or you have to or if you are able to capture a graph。

you have to make sure it is correct when you replay it。

So torch scripts scripting effects tracing lazy tensor are all the previous generation graph capture mechanisms。

So how do we solve that problem， right， to make the graph capture reliably capturing the correct graph。

Basically， how do we make the mechanism both sound and alpha box。So let me give you some intuitions。

so the first insight we have is that all the previous graph capture is aiming at capturing one graph model and that's where all the constraints are coming into play where what if there is something that the compiler didn't understand because Python is a very flexible language so what we decided is to allow capturing partial graphs so that whenever we encounter something that we didn't like。

will just stop the graph graph break and fall back to eager。

And for its soundness because part of the graph capture is using tracing mechanism。

so we introduced guards into the graphs， and this would allow us to record what's the valid condition for this graph to be correct。

And in order to use those guards at runtime， we need to check whether the runtime condition satisfy the guard condition。

And if it doesn't， then will just in time recapture。

So it operates almost like a just in time compiler。

So to give you one example for the previous example。

this one I deliberate introduced one which requires a graph break。

so if you print out the graphs to the right hand side of what we captured for this example。

without if you didn't know about all the previous points。

you might be surprised to see actually three graphs that are highlighted by the colored bar over there because there is a data dependent control flow B do sum depending on the value of B。

it may or may not go into the if or else branch。And but there are other reasons that we graph break。

so for example， if we have something that's like outside the Python a see extension。

we don't know anything about it， we will graph break for soundless reasons。

and there are some of these conditions actually where over the last couple of months we're gradually reducing the reasons for graph breaks。

some are implementation limitations， some are just fundamental to the correctness of the program。

I talked about graph breaks， but I also want to show like we are supporting this torch dynamicyal graph capture we're really supporting a lot of very complex features of Python。

so here's a list of the complex things， how do we handle function call。

how do we handle comprehension and all these container types， loops control flow。

Lambda and so on and so forth。So I want to give you a glimpse of what the magic under the hood so this picture the left hand side is a default C Python behavior so this is what happens when you use E mode and to the right hand side especially the dotted box here and there those are the new things we added number one it's actually we're very lucky we have a standard python C Python feature that allows us to add these extensions so that means you don't have to download the special version of C Python you just need to use a particular modern version of it and here with this boxes the thing we talked about capturing partial graphs break and then compile the graph into binary and then execute the compile code doing the run-time check going to a cache and recapture all of these things happen transparently behind the scene so that's why users just have to annotate one line of code。

In order to go into the graph mode。So these things seem to be plausible does it really work we actually run torch dynamo with a very simple backend that just basically fall back to eager to test the robustness of the partial guard graph capture mechanism。

we run it over 14 k。GitHub Pytorch models with certain star level。

So it's not just trivial examples。 And our pass rate is like 99% above。

I didn't talk about integration to Torch Nanobo， but actually that's a major design point we really want different backend or accelerate compilers to integrate easily with Torch dmo so I'm going to talk a little bit on the Pytorch native backend were building that's the one here but there are a lot of vendors since the Pytor 2。

0 announcement and release are engaging with us almost all major。

Beend compilers are trying to integrate with us and we didn't put the exact number there because it's changing and it also depends on the support levels that will label it as experimental or more more stable ones。

And finally， we already actually show the previous performance member。

but what you want to show is that people might question whether partial graph would sacrifice performance for the backend compiler。

what we observe is that even though we are capturing partial graph the graph is still large enough for a lot of the optimizations to kick in like fusion optimizations and because now we can almost funnel any Pytorch compiler through the graph mode so the widen coverage actually more than compensated on the smaller graph that the graph break is introducing。

so we do see like quite significant every speedups on a wide side of benchmarks。

Okay so this is torch shineinmo I want to remind people that actually I think of as talk is all about like how do we optimize the actually generate efficient code so keep in mind that Torch dynamo is the breakthrough point for how 2。

0 exists but by itself capturing graph doesn't improve performance we just enable the backend compiler to connect with Pytorrch models so that magic for improving performance in the P2 stack is torch shineinammo to Kcrs is a Pytorrch native compiler actually I should say a Pytorrch native training compiler because there are a lot of compilers out there many are focusing on inference and there are a lot of compiler out there but fewer are designed for the Pytorrch IR and one of the reasons is because Pytorrch IR is very a Pytorrch offset is very large and complex has mutation all these unpleasant features that are convenient for library developed。

But not convenient for compiler。 So actually aiming for I design specifically for Pythtorch semantics is very important。

😊，I don't have time to go into the technical details on inductor。

but I just want to highlight a few things that's unique in Inductor number one。

Torch inductor actually， most of the PD2 stack is written in Python itself and it allows us to move really fast and make the things hackable because nowadays a lot more people know about Python than knowing about COC++。

And the second part is we started with instead of focusing。

ResNe or a few models demonstrate the value， we actually start with focusing on designing the framework to be general purpose to handle long tail apps first。

and this is also very important for handle real models。

So that's the breast first approach and the last one is the IR design。

so I would say that if there's one thing that you want to remember about torch inductor the unique aspect would be the PyTrch IR native design if you're interested in that or extend on torch inductor I would recommend you to look for more information online。

So just to give you a mental map of what torteinductor stack looks like。

there are many boxes over here， a lot of the compiler researchers might be focusing on the cogen aspect which is the hardest part and what's interesting for us is being practical we actually didn't do the cogen ourselves we actually rely on Triton very early we are a very early adopter of Triton so one message here is like when you are building a practical M compiler stack from top to bottom you actually really want to have the whole thing working like the minimum viable product and there if you can leverage other components if they can do the job you don't have to build it yourself so that's what we adopted it for the GPU cogen we rely on Triton and that turned out to be a very。

Beenefficial strategic bad。 And then we also have a C plus plus backend right now。

we're involving the Intel team developing the C plus parts backend， especially for the CPU。

So then theyre about already talked about like scheduling fusion so these are what typical machine learning optimizing compilers would do。

so I wouldn't say anything about it， the very unique thing that make everything else work well from PyTtorch is actually our IR design so how do we lower how do we design the IR again don't have time to go into the detail。

but I would if you were to design your own machine learning compiler to integrate with Pytort I would recommend you to look at how we are designing the Torduct IR。

All right， so I'm almost wrapping up my talk here， but I want you to take away with this picture in mind。

the left hand side going from eager mode is the 1。 x。Execution pass。 this is eager mode execution。

basically one operation at a time。And 2。0 with the Torchal compile interface is actually completely backward it's an optin interface。

so it's completely backward compatible with 1。0 and what you will see is that we are trying to funnel the model with the same programming interface into the graph mode which is this part as much as possible and and the key technology in this is actually this part to made it possible because as I mentioned before what made Pytorrch beloved made it really hard to graph capture。

so once we have this component figured out as an outer box experience is almost like turning on a faucet so the Pytorrch models just flow seamlessly into the graph mode and Torch inductor is the one that's developed in team which is I would say it's the best performing training compiler for Pytorrch today。

but I also want you to remember that the role of a machine learning。

Where compiler is not to build everything ourselves。 And because we do understand like we have。

Resources to invest in say GPU。 But what about the other accelerators。

So we do want to enable other vendors to hook their own compilers with this part。

We don't want them to worry about this。 This is so hard and not very interesting for them to figure out。

So here there are many other machine learning compilers。

This figure is a little bit simplified because there are actually different integration point for a machine learning accelerator compiler to interface with Ptorrch。

You could do it at this level like siblings of torch inductor。

You could actually add backends below toch inductor， for example。

the Intel CPU backend is something integration here and increasingly we're seeing people actually integrate at the Triton level so for example we've seen AMDs investing their GPU cogen into Trident so if you are connected with Trident。

this thing also flows naturally so I want you to keep in mind the lower in the stack you're integrate。

the more you can reuse what we build and the less work for you if that integration point is suitable for your hardware。

All right， so。Let's see。 Okay， so I'm gonna escape here。

but what I want to say if I reflect back on 2。0 I also had research background。

I think the one thing， one theme is we're trying to define machine learning framework compiler that works for real models and we are trying to be very。

very flexible that's all we're trying to do and a lot of decisions is to solve the hardest problems first and then try to reuse as much component as possible。

All right， so what's available now so if today you go to Pytorch Github nightD releasease you would already have a lot of the these are the core technologies that's already built in there and you have Tor compile as the compile mode API or G mode API it's a alpha feature you will have Torch inductor as a default backend for GPU you can use it for both inference and training you have dynamic shape as experimental feature but you have to use it with a flag on there's a lot of progress made on dynamic shapes since March and you can get the weekly updates from the dev development developer forum and we have three performance mode for Tor compile the default reduce overhead is for models where there is a lot of kernel launch so we made it work with Cgraph and other optimizations。

And Max also tuned this enables auto tuning。And what's coming next。 So for the。

Maybe before the next Pytororch conference， which is in October this year。

we are still continuing to improve performance because we do believe we are just scratching the surface of what's possible and we are also improving the composably with other Pytororch features for example。

quantization tensor subclassing and so on and so forth in the longer term beyond six months actually we are already doing a lot of work onto PD2 export this is the past where it requires a little of menu effort for you to export a whole model with guards resolved into a sable form and then you can carry this model to whatever runtime you have this is most recommended for if you have like embedded devices or inference in production where Python is not allowed。

And yes， we're talking about large models right so so far I have mainly talked about single GPU so now we are also heavily invested in P to distributed and in order to not。

😊，More than just optimizing for compute， We are trying to optimize communication as well。

And I think Michael probably would talk more about that。And to conclude， I just one message。

get involved， actually， it's a tremendous effort to build。AMachine learning compiler by yourself。

So I would highly recommend if your workload is using Pytor。

try to integrate at certain points with P2 stack。 It really save you a lot of a lot of the work that's not necessary and there is still a very。

very strong momentum for us continue to involve P2 stack so you can And also when you try P2。

give us feedbacks if there's anything that's not working or to be the direct compute contributor to P2 stack。

especially on the compiler side。All right， thank you。

Okay。Okay， thank you，朋g。Okay， so I think we have， yeah， we have two topic today。

And so that's why I we organize the local deep learning framework topic like aal pal and mind into the session in this afternoon in the other AI open source forum not in this one。

Okay， then let me introduce Michaelmin。 Yeah hes another old friend another old friend。

He actually work for IBM for a long time and and hes the inventor of the cell processor aelerator side。

Yeah， and I think some of you my still remember actually is almost the first general purpose the multi processor。

but with the general purpose call and also the a called to accelerate the workload at that time。

including the gaming name， those kind of things。 and many years。😊。

After now Michael he is now in matter and leading the acceleration Shen side for the pie 2 do0。

I I think so we can see the change of the pie to and it good for the very simple to。

to use very friendly to program。 And now it more focus on the performance。

So that's why we also the very happy to have the Michael here to share this kind of things for pie 2 do0 and to share his things with us。

Thank you。😊，してこか。Thanks for the kind introduction。嗯。

So I'm excited to be here today to talk about how we optimize by Tor Tudodo to。😊。

Be the workers for generative AI to be the environment of choice for developers in the generative AI field。

if we look at。Genrative AI， we find that generative AI today uses artificial intelligence models that are able to generate new and original content across a range of modalities。

images， text and music， and these models can produce realistic and creative outputs that have significant potential in a wide range of domains including art design。

entertainment， etc， what we know about generative AI models today is they are the largest neural network models in use and as a result they create a unique set of requirements。

The most common generative AI model today， the largest models are the largest language models which are advanced AI models that excel in generating humanlike text responses and they have proven incredibly powerful for understanding in generating natural language and enabling models to interact more naturally with humans。

an example of this is chatCT developed by open AI that's been trained on a very extensive corpusive text data so if we look at the language models size。

we find that over the last five years， language models have grown in size by five orders of magnitude that's a factor of 10 every year my background this a chip design and their factor of2 x every 18 months was consideredck Bckne。

Speed and it has transformed society and technology， as we all know。

that's why we are here compare that with 10 x in a year for AI models。

What comes with that is also an incredible demand for processing power and for new capabilities to take advantage of the hardware and to make these large language models affordable。

deployable and have the necessary。Speed to interact naturally with applications and with humans。

The second class of models are diffuser models or latent diffusion models LDMs。

and they excel in producing。Media output in particular image images， video， and more。

they use latent diffusion processes to create these high quality outputs， two common examples。

well known examples are Dli2 and stable diffusion。

So when we look at all of these generative AI models today。

we find three key requirements to make them performant。

to make them deployable to make them affordable。 first and foremost。

this speed and efficiency because these generative AI models are so computationally expensive to both train and query so efficient training and inference are。

Fundamentally important。For a widespread adoption of these models。When we look at these models today。

we find that they're all transformer models based on attention mechanisms。 So this is in particular。

a component that we want to optimize for to improve model performance and efficiency。And finally。

large language models， large gene AI models are large。Surprisingly or not。

And that means that they need distributed computing infrastructure to train， to make training。

Make the necessary progress to make training affordable and to fit all the parameters of a model into。

A device or a plurality of devices that are interconnected using distribution technologies。

So how do we solve that Well for speed and efficiency， Pang talked about torch compile。

that's the work for accelerating models， big and small。

and they offer a significant benefit to all of the generative AI models。

We optimize transformers with accelerated transformer implementations that we implement in PyTorch2O。

and finally for distributed processing， we have PyTtororch distributed with data parallel and fullyarded data parallel training。

So let me turn to how we accelerate the Pytorch transformformer API。

the standard API for transformers in Pytorch。So the PyTtororch API in general。

including the Pytorch transformformer API are designed for flexibility and these of use that is what attracts developers to PyTtororch P talked about that before that flexibility。

the ego mode execution and a number of options for each of the operators to create to create all types of neural networks with range with a range of choices whether that's doing normalization before the basic attention function or after using different types of activation functions and so forth。

what all of that brings is a transformer implementation that requires many PyTtororch operators to implement and to。

Control the computational complexity。 These are executed in sequence。

And allowing for all the different options that might be present， so in a nutshell。

the flexibility comes at the price of performance， usability comes at the price of performance。嗯。

With torch compile and with the accelerated transformers。

we can optimize transformer implementations， on the one hand we use fused kernels to combine multiple operations and avoid materializing large arrays。

large tensors that would introduce bottlenecks around memory access。

one of the pans of existence of anybody who has tried to optimize models for accelerators or CPUs for that matter。

and。They combine many operations， they fold the soft jamm into the matrix multiply。

they fold two matrix multiplies into a single larger structure。That way。

we can combine many of the operators and implement them with a single fused loop kernel。

The second optimization that we rely on is using a fast path architecture for inferencefr。

where we optimize inference for where we capture common inference patterns and use kernels that are optimized to exploit variable input sequence length。

So if we look at the literature how to accelerate tension， computation。

there's been steady progress starting with the paper in 2021， that's just two years ago。

That talked about how self-attention can be implemented without needing ON squared memory it introduced a concept of usingsing attention kernels to reduce memory usage。

and then last year tried Dao and his colleagues from Stanford University published a paper called flash attention fast and memory efficient exact attention the Di A that's based on these insights that Robin Stts first published a year before。

The team from Stanford University provided an optimized coUuda implementation for this algorithm and it beat out Nvidious entries for MLPf Transformer training last year in 2022 in June。

啊。And finally， metata's own FA research labs developed exformas。

which is similarly based on the observations by Robin Stotts with respect to optimizing for memory usage to speed up attention computation。

They released a package called Xformers that provides fast and memory efficient attention computation。

Functions that are domain agnostic and are widely used in the research community。

envision the N LP and more。So if we look at flash attention。

this this figure is taken from the flash attention paper， you can see the basic approach of。

Computing attention while reducing the memory usage， rather than materializing the end by N。

Mattrix from computing。Q， K T。The algorithm has an outer loop that loads sub blocks of the K and the B input into S RAM。

and then in an inner loop iterates over a Q to compute。

A subset of the final result that is then written to HM to the high bandwidth memory on GPU cards。

and then it proceeds to the next block， iterating again over the vector Q。

the query vector of attention。The outcome is this huge。

huge improvement of performance the authors of the F attentiontention paper report 7。

6 x speed up over the attention implementation in GT2。

Owing to folding all of these functions into a single kernel and if you look at these functions they all have in common that they take a large matrix as input and produce another large matrix as output and thereby bottleneck on memory excesses in each of the steps。

Let me turn briefly to Xformers Xforms is was developed by fair Metas research lab for AI and it consists of customizable blocks that are independent and can be used without the generic boiler plate code that comes with usual with。

A啊。APpiI is provided by Pytorch that office a brought set of options and flexibility。

These components are domain agnostic and depend on researchers to integrate them and to combine them to use for vision N LP and many other modalities。

This is a research first。Effort， research first package that contains bleeding edge components that are not yet available in mainstream libraries。

Or that was the case last year。And these components are built for efficiency and in particular memory efficiency use to give researchers high speed of iteration。

it uses its own ka kernels where necessary and otherwise dispatches to libraries like Holas that are available in the open source community today。

Here is a view of the speedups that can be obtained with Xformers showing a speed up up to 4 x for training and a significant improvement。

up to 50% in memory efficiency。So。Both flash attention and Exers were new based on papers published in 2021 and came out in 2022 and to see the speed at which Pytorch developed。

they launched in 2023， but Pytororch to thedo， one of the advantages of using an open source framework is the hackability。

the pluggability of new ideas and making Pytorch the go to environment for researchers to integrate their own work to have the most impact and make it available to the largest community of users。

TriD and his colleagues at Stanford had independently developed flash attention and。

Shortly before submitting the。Paper and the training results to the ML Perf benchmark competition。

they approached meta about integrating this capability into Pytorrch and so。We。

Worked both with the flash attention。codeode， but also and its developers。

but also with the Xform developers to integrate these new bleedinguting edge libraries into Pytorch and making them available out of the box for all developers we did that using a new operator scaletop product attention it's not only a new operator it's a new kind of Pytorch operator it's an operator that comes with multiple implementations that support different inputs and hardware models so before in Pytorch you had one implementation of each operator per hardware platform and that would cover the entire operating space this is different here but scale top product attention depending on different hardware types。

even different types of inputs。Sizes， dimensions， ratios， data types， et cetera。

it dispatches to different implementations。They all have a common interface。

the app of the underlying SDPA operator， and the high levelve SDPA operator implements a selection logic that looks at the inputs that considers the current hardware platform and figures out which implementation to call this allows models to take advantage of optimized implementations depending on what hardware they run on and at the same time makes models portable across different models and hardware types and finally we've integrated SDPA into the Pyth API for multihead attention and transformers both encoders and decoders to accelerate training and inference for new models but also for existing models that were developed and even trained before。

I to the0 was released with its support for accelerated transformers。

It goes hand in hand with forward and backward compatible weight formats。

So you can train with the new operator with the acceleratedcc transformers and save the weights to use with the legacy model if that is deployed some place or conversely。

you can use a previously trained model and fine tune or deploy for production using the accelerated transformer capabilities。

😊，So here is。How the scaled product attention plays out， the top level function。

iss implementation agnostic and then dispatches to one of three implementations for this is for NVDA GPUs in particular。

there is a fallback kernel SDPA math that that implements mathematical description of the attention logic calling internally a sequence of Pythtorch operators。

it is basically the legacy implementation and the fallback if no better implementation is available we have the SDPA flash attention kernel that provides a coupa implementation of flash attention for a100 and some other devices for 600 bit floating point data types and certain input common input sizes in cases where flashes available。

It's typically the fastest choice and because it is highly optimized for just these few operating conditions and uses in line PTX and all sorts of other performance enhancements and finally there's the SDPA memory efficient kernel that comes from the Xformer library that provides a coa implementation of memory efficient attention developed by Mes F Paris Research lab。

we have another implementation that is Tritonbased that we can use in the future for hardware that cannot take advantage of the F or the memory efficient implementations that implements but implements a cogenerator for the Triton kernels。

So this chart shows explores how to optimize large language models with accelerated transfer。

Transformers using And Harper's open source nanoGPD implementation as example， so step number one。

if you want good performance and efficiency is always enable to do compile there's really no excuse not to use it as Pg highlighted it has over 99% success rate。

a cross a broad range of very broad range of。Models that are out there today， and。

Then the next step is we replaced the Python implementation of attention with the scale do product attention operator that improves overflow handling because the integrated SDPA operator distributes how scaling works to avoid overflows it delivers better runtime but memory efficient kernels being faster than the math implementation and flash offering a further improvement and it delivers slower memory usage which allows you to use a bigger batch size。

finally for large language models patting the vocabulary size helps with Tensor core efficiency because downstream matrix multiplies can take advantage can take better advantage ditch of Tensor core Tensor cores when vocabulary sizes aligned so we see the improvement here。

We start with a baseline of about 250 milliseconds per batch training time when we enable torch compile it goes。

it drops to 140 ish milliseconds is we replace the legacy Python attention implementation that was in nanogptT with the different kernels that we have in accelerated transformers we are able to get another significant reduction and then finally patting the vocabulary size to take better advantage of Tensor course offers yet another boost the other thing that you see here is that with the memory efficient attention implementations that's both flash and the Xformer implementation you can use much larger batch sizes because demo they make more。

fficient use of memory and that in turn is another boost in performance If you look at this here the 2X speed up。

this plots the validation loss after one hour of training so flash attention by offering a faster iteration time offers。

Much better all loss。Regardless of batch size and you can see the distance between the two curves reflecting about 2x speed up between the python baseline and the flash and。

so then if we extrapolate that out to the improved validation loss that we get from using larger batches。

using larger batches in essence translates to another over 2x improvement in speedup。

of course that depends on specific convergence behavior of your specific model。

We worked with hugging face to optimize decota models and we found that we got up to 70% inference speedup for diffuser models and for training LLMs we got 70% training speed improvement and about 20% inference speedup in addition we got over 110% memory savings in some instances plus more importantly the models did not o for for many cases so accelerated transformers enabled new capabilities so in addition we have。

The fast bath logic and that for inference and the biggest benefit out of fast path is taking advantage of nest tensors these are a subclass of tor the tensor that Pg mentioned earlier。

and they allow to capture the variable length tensors。

inputs that are common in NLP processing and that can deliver up to 4 x speed up on BRT style models and up to 2。

5x inference speed up on vision transformers。So。We have parallel training support and Pyth2。

0 with both data parallel training and fully sharded parallel training。

I'll skip that in the interest of time and so I'll conclude with the。啊。

With with a summary that Pytor20 brings significant out of the box acceleration to Pytor transformer API and to models for training and inference that use transformers。

we've integrated that in torch text， torch vision torch multimod far sake。

And we've worked the hugging face to integrate as well。 and。By providing that library integration。

we can get performance out of the box for a broad set of models that were developed even before Pythch Studiodo。

finally Pythtorch Studiodo provides abstraction and portability using both Torch compile and the new SDPA interface that allows models to take advantage of new improvements that will come online both in the compiler and a new high performance kernels for transformers to deliver the best possible performance of models in the future。

even devices that are not available today with that thank you for your attention and I'll conclude my talk。

Thank you， Michael。 Thank you。 Yeah， Yeah， and it's amazing that a lot of good stuff is coming into the P touch2 dot O and not only to accelerating the inference side。

but also the important for the training side， so。😊，Okay， so let me introduce our next speaker， yeah。

Actually， Jing， he is came from any scale。 any scale。

I think people might heard about the Ray that is the another very good framework and especially for optimize the distributed training side。

So today， I'm very glad can invite Jing。 he actually is leading the machine learning team at any scale and any scale is the company who is supporting the Ray very fast group。

So let's welcome Jing，😊。

Yeah。YeahThanks for the kind introduction to yeah， very glad to be here I talking Bar Ray with the audience today。

My name is June。 I let the I lead the machine learning team at any skill。

which is the company that's behind the open source framework， Ray。😊，嗯。

So let me see if I can figure out how to use this thing。

So I don't have the slides actually， but fortunately， Michael just show the chart。

you know during the last talk， the scale of the machine learning workflows these days seems to be following some sort of exponential curve。

and it seems to be actually accelerating even fuel by the large model generative AI stuff。

So that's actually the reason we believe the folks at any scope believe why the framework of way sort of like catch a lot of attention and popularity gaining a bit of popularity lately。

when you're talking about open source frameworks， people often use the GiHub star as a metric for measuring how popular the framework is So here's a quick chart to show that。

The red lines right， and we sort of have caught up to Kafka since the last month in like half of the time and we are marching towards the spark right now。

嗯。So a little bit of history of the framework， I think six， seven years ago。

the two founders of any skill they were working on reinforcement learning at Berkeley。

the reinforcement learning at those days are a little bit different from today where the computation is actually usually blocked on the simulation side instead of the training side because reinforced learning is essentially just like randomly exploring in some simulated physical world。

And。The founders actually just found themselves repeatedly stuck in this situation where they need to write a lot of GRPC and talk to like how these remote simulated environment collect the training sample the actual training of the policy。

the reinforcement agent is actually pretty fast right。

So all the computations are like all blocked on the simulation side。😊。

So they thought like let's write some framework， you know， to make it easier to to do GRPC and to do。

you know， bandwidth efficient， you know， data movement and that kind of stuff。

So this is how the framework starts。 and this is also how why if you look at Ray RL。

which is like R reinforcement learning library that's built on top of Ray is one of the first library that's there。

things like day1。And it's a little bit。Un， I say。And then they quickly realized that。

you know this framework seems to be useful for not just reinforce learning。

but other types of distributed computing as well。 and the abstraction seems to be， you know。

nice and elegant， that's why they started the company any skill to you know try to commercialize Ray And since the companies founded we've added you know other libraries like Ser。

which is to tackle the inference and serving use case of the。😊，Yeah。

for for machine learning and also。Last year we launched Ray Air。

which is sort of like this umbrella。You know， term to。

to cover this end to end machine learning use case。 And also like more recently。

there's actually also Ro data set， which I'm gonna talk about later。

I didn't realize there's animation for this guy。So this is like a picture of the native ecosystem today。

So at the very bottom， you have physical computation， computing cluster and machines and all that。

and rate core sort of sits on top of the the physical computing devices to to extract away the infrastructure side of things。

And above rate core， you're pretty much just dealing with， you know， native Python。

and you don't have to worry about GPS or CPU or memory and all that kind of stuff。

And once you have rate core， then we build all these libraries， you know。

rating for deep deep learning rating tune for hyperpermeter tuning and serve and data set to like cover the entire into an machine learning workflow。

😊，Okay， so。Now that we have a high level picture of what you know。

the ray is and what the ecosystem might look like。

what I wanted to do is to get into some of the more specific。嗯。Use cases of the the the the。

the whole ecosystem。 I want to discuss the， the common pain points that we。

We see from our day to day life dealing with， you know。

customers and users and also explaining a little bit of why how the real libraries are trying to tackle those and try to like make those things easier。

The first thing is actually， so this is in like， you know， the workflow order。

So the first thing I want to talk about is the data ingeesttion side of things and。And we this is。呃。

那个 funny你的 we build。Per the last like this is the most recent addition to the to the ecosystem where we introduced array data set。

I think I think just yesterday， somebody was asking me， like。

why do you guys want to build a data set， you know。

Pytor has a data load they like hacking phase data has a data set the the answer was actually。

you know， while we are dealing with， you know， helping users and customers debugging their workload and dealing with these practical matters。

you actually found the the distributed data ingestion。

Is actually a little bit trickier than you than you think， right。

Because these thing these things normally run zone CPU。

like the the pre processing and data loading。Like there's multiple steps between you load the data and before they get to the GPU for training。

So that makes the， the cluster usually like a heterogeneous。

meaning like you will have different shape of the machine。

You will have different resources available on different nodes of the the machines。

And also when you， when the， the， the， the scale of your data gets large， oftentimes people will。

Csh if you go like data loader requires you to load all the memory， all the data into into memories。

I was actually always a little bit suspicious if somebody library tells me like I need to load all the data into memory at once。

right， usually those things don't work。😊，And because of Ray and because of this。

like shared memory space on top of multiple machines。 and within the cluster， the。

the team felt like we can build a library to make these things a little better。😊，And。

Oh another important thing is if you actually go the bug people's machine learning workloads。

you will realize like a lot to time times when they say the GPU utilization is pretty low。

the problem is actually happening on the ingestion side， you know。

some sort of like prefeion and stuff will solve those those cases。

So that's why we build a rate data set， which provides a distributed and resource of where。

Data transformation and ingestion， meaning， you know， if you have a cluster where you have three GPs。

you know， doing the actual like data parallel training and you have 30 CPU that's doing image reading and transformation before they gets free to GPU data sets are actually aware of these resources and will dispatch your work to the right note。

And then it's gonna try to like be smart and take you know， data locality into consideration。

and you know。And make the whole thing like pretty efficient。And I think just last release。

we also enable the streaming execution as default strategy， meaning。By default。

we'll never try to load your data all into memory once like everything is is streamed from all the way from the the source device and we will apply proper back pressure so that。

Like your job is efficient， but we don't， you know。

The performance one degree into like barkinggestion， basically。Cool， so the next is batch inference。

I， I mentioned this the the second， because although this is like the， the。

the step after you get the model， I w to discuss this next because it's also handled by the dataset set instead of like just doing ingestion。

😊，A common thing that once you've trained the model is to actually use the model and run it over like a large set of data。

This we call it like battery infant。 you can think of， you know， for example。

sometimes you have a large car of like tax data。 you want to run some embedding model to turn them into。

you know， embeddings。That that task actually has a very similar characteristic as the the ingestion part。

because you're still dealing with， you know， a heterogeneous cluster and the data loading will happen somewhere。

like from， you know， S3 cloud storage。 but the model needs to round GPU， right。

So that job is also handled we think the best by rate data set。 And。And I'm gonna show you。Actually。

some benchmark that we did， you know， more recently。

we were comparing using ray data set versus using， you know， the sage maker。

Batcher inferencing and also using spark to do， to do this like batch inferencing job。

Sage maker is actually really about because it's more。

Like a wrapper around this online serving system， which is totally not fit for offline model inferencing。

The more interesting part here is is the comparison comparison between radioius and and Spar。

The team naturally spend a lot of time optimizing the spark。😊。

Job to make sure were like doing a fair benchmark comparison。 And in the end， we were be。

we were able to roughly like outperform maybe 3 x compared with a multi spark cluster。

The reason behind that is because Sp constantly switches between you know Python and Java。

like these two words。 So your data gets serialized and decalized like really often between them。

And also， I think Sp has less flexible。😊，Processing fusing， so。They tied to you like overfusing。

you know， multiple steps together。 And you， if you have one step in between that like bottleneck on GPU。

then all your CPU steps are like slower as well。 That's where ray tasks shines and like give you some extra performance。

The funny thing about this is also， when we publish this benchmark， the。😊。

The folks at Databricks actually ping us and say。You know， we can optimize this better。

This is not fair。 And they spend some time。 And they， they， in the end， they like， yeah。

its something。We can do this rather than do this。诶。Okay， so about distributed training and tuning。

This is like a bread butter for any machine learning systems。

What we know this about distributed training is that。These days， the。

the ecosystem for training is like extremely fragmented， meaning。You know。

you just get like all kinds of frameworks that you can do this。 And also， things move so fast。

It's very hard to say which framework are wing or like right the industry is completely not consolidated onto any particular framework。

especially like these days， you start to use， you know。

on deep speed or like accelerate to do large model training。

which totally wasn't the case three months ago。 So what we felt like we should do for distributed training is we want to make the you know options open。

We want to make the system like very extensible So users don't get locked in to some single you know framework that。

They end up having to switch with a lot of effort。So the the Raing library is rather。You know。

lieway， it basically provides a lot of integrations with the existing training frameworks out there。

like Ptor lightning or D C or。Hgging face accelerate。

What we take care of is mostly the setting up the cluster。

setting the wrong time environment part of it。The actual deep learning and the distributed。

you know， communication is handled by the underlying。啊，library。

And that would allow that that basically like allow， you know。

these machine learning engineers and data scientists to do this without worrying about the hardware。

as long as you have a very cluster， like your job can be， you know， up and around。嗯。And also。

we made it so that it's very easy to turn a training job into a help department training job。

because。Rune is actually orchestrating the the all the work behind the in anyways。

so you just need to like switch a few lines of Python code to do that。Yeah。

rating is for some reason， is one of the most popular libraries。啊。That that Ray has。Cool。

so about serving， you know， we talk about the offline batch inference。

so in terms of online serving， what we see the users and customer Wang are auto skating because the GPUs are really expensive and the serving traffic is actually naturally like cyclic。

So so they want to scale down to like very few node you know during the night and scale up quickly。

So the all of skin speed is actually very crucial for any like practical serving system and they also want thought tolerance we basically like putting a lot of work introduce highly available serving maybe since last year and now you get to enjoy like highly available cluster and the race service deployment with relatively ease one thing I also want to mention is that from day one。

actually the selling point of race service because it's built on top of the Raycorps and the ray has this actor concept where you know you can write like a little microserv each thing using simple like Python class and that thing is actually backing all the。

model replicas， It made it very easy to do model composition。And for a lot of the use cases。

actually， it's not about a single model。 You want to， you know。

score something using a set of models in the like graph fashion。 that actually is a very。

It's like a pretty sweet spot for， for serve and the reason for lot people to use it。😊，And of course。

more recently， because of the large models we introduced some features that's not important before。

such as like streaming support， and we had to improve the scalability envelope the law just to be able to scale up the large model deployment。

Cool， so the answer is about generating VI。 I think the the talk these days will not be complete if you don't mention large model。

😊，嗯。The raise。Interaction with the the large model in general AI world is actually pretty early。

Even before I joined like maybe roughly around when I joined any skill。

we were working with this open source team。They were trying to train this model called GBJ。

which is a replica， tried to open source a replica of G3， I think。

And they got a lot of free credit from Google。 So they were training those things on TPU。

And we were helping them to celebrate cluster on TP U so they can like have a reasonable， you know。

developer experience。 instead of dealing with like a large cluster of TPU instances。😊。

So that's the when， this thing started。 We actually didn't。

Pay too much attention about this until very recently， when like data breakricks， they。

They fine tune dling on top of GJ。 everyone was surprised like， actually， the model is pretty good。

You know， it's better than you think。And， and other people who are using， you know。

a ray to do large model， including like cohere AI。 If you guys don't know， like the。

the founders of cohere are the inventors of the， the transformer structure。

And also we recently got permission from Open to say like they actually use the right train record to train G4。

So from our perspective， you know large model is not like a single kind of thing because there are model sizes that you can do with a single instance as long as you have a few GPU cards on the instance。

you can do a reasonable sized large model training on that。 so from our perspective。

we try to support the work for our customers and the open source communities by using by offering a spectrum of things。

for example， if you're okay with like one you know computer node an a GPU cards。

then we have these like off the shelf examples that you can just quickly wrong and your job will be running in no time and if you're trying to run these relatively smaller。

Scall， you know， large model training。 Then you can use the ecosystem， you know。

the native ecosystem library。And then we take care of the hardware and you can train your job。

And if you're really， really hotcore， like a GP ableI and cohere， who， you know。

who's trying to write your own custom training stack and optimize everything yourself。

then they actually use， they just they don't use any libraries。

but they use the rateco to to help with the developer and experience and also the iteration speed。

So that's， that's what I mentioned。 I think it's。It's useful thing to you know。

share at this conference。Okay， so I was when I was writing these slides。

I was looking at the some of our， you know， biggest open source and partners and and customers to see。

you know， what are the the most common use cases they have for Ray。 aside from。

you know the big model stuff。 surprisingly， actually the most common use cases they will build a internal rate cluster as their machine learning platform。

So that their data scientists， the machine learning engineer can basically just submit the jobs。

you know， to this cluster and they get the result， you know， without doing any。

know Kubernetes stuff or some because the scientists data scientists。

they get to interact with know Python， which is the thing that they use every day as super familiar that helps with their developer experience at law。

we obviously， so I don't have time to mention or， but our is sort of this。The only， you know。

of the shelf of choice， if you want to do production scale reinforcement learning and we actually have a pretty big users of of the library there。

and obviously and actually a very big， you know， adopter of from day one。 and they are sort of our。

you know。Colleague and they， they submitted a lot peers to the。To the code base。啊。Yeah， lastly。

I would encourage， you know， raise completely open source。 You can， you know。

please take a look at our Github and also the， the forum and try to get involved。

We welcome all the contributions from it。😊，The community， the company is actually relatively small。

We have very limited resource。 So a lot of times the the awesome things happen because of the community。

啊， that's it。Okay， thank you thanks share the Ray the and and those practice with those big name。

Next I want to introduce our next speaker doctor Tong Xinba。

actually the AI compiler is very important and it not only important for the big model the large foundation model。

but also to important to important to boost the boost the and adoption of the different architecture of the chips。

especially for for for this local market so B A AI our institute start the AI compiler this kinds of research direction from last year。

and so Tongin he is the leader for this direction。

So today I am very honor to introduce Tongin and invite him to deliver his speech in this forum。

Thank you。

I think to be fair， I'm going to use Chinese。

就今天我们给大家那个汇报一下，我们智源在那个AI编译器方面，就是主要是近半年呃，到一年这个时间的一些那个进展。现在只现在仍然是一个那个working progress的状态。对。对。

那个主要内容的话就是说我们先做一下那个背景介绍，就是主要是我们看一下，就是当前我们软硬件适配跟I编译器面临的一些呃痛点的问题。然后呢，我们一起跟这个厂商探讨一下现在的这个趋势，技术发展的趋势。

还有这个这个需求的趋势。另外就介绍一下我们那个智源编译器的整体的进展的情况。然后那个技术方面的话，就是说我们后面的主要的时间可能就是当然今天时间很少了。对，就是呃主要讲一下我们现在整体的这个设计思路。

还有还有几个这个关键技术点。对，后后面的话我们讲一下我们的那个展望和我们对未来的这个期望。对。呃呃是这样，就是说我们在做这个实际上我们是com，就是说我们智源主要是做这个模型跟算法之类的研究。

是我们去年开始，我们想深入去做这个系统的这个支持。对，因为我们觉得就是说有几个问题是要解决的。就是第一个就是我们国产很多这个专这个通用的GPU啊，还有这个面向这个模型训练加速器。但是到现在的问题的话。

就是说他可能就是支持这个上游框架的能力还相对较弱。然后我们想就是怎么样能够通过这个技术，尤其是compiler这个技术来去呃这个能让这个前端的这我这这个框架适配能更顺滑一些。对。

然后我们去年年底的时候呢，就是跟这个厂商，还有这个呃学术界的一些学者我我们做了一个简单的调调研问卷，就是主要是探讨一下现在的这个对编译器啊，还有软件适配的需求的问题。

然后那个呃我们稍微那个summarise这下，就是说一些。点问题集中在这儿，就是说对厂商来说，这个多框架的介入是一个比较头疼的问题。另外就是说AIBNG如何进行功能的泛化，性能的泛化。

兼容性也是一个安弄的这个这个问题。还有一些就是呃这个厂商对这个编器呃面向多种后端的优化能力，还是持一些这个就是有有一定怀疑态度。因为就是嗯不同的硬件的话，它的这个底层的架构啊。

还有结构都是不同的那你怎么样去设计一个这个这个通用的这个part技术还是挺困难的对。嗯，然由此的话可能会引出一些这个跟编辑相关的这个技术挑战。对。呃。

然后我我我我我也做了一个这个就是我画了一个这么一个图，就是让让大家预测，或者像评估一下现在这个呃不同的这个主流的这个AI编器现在的这个呃主要是面向试费的后端迁移性啊，还有扩展性如何。对。

另外就是说呃未来的发展趋势怎么样。假如说我们希望这个呃我们把图上这个这个技术向这个右上角去去推进的话，那呃对就是有哪些这个难点。对我做了一个这样的一个问卷。对，然后我们大家发现的话，就是我们简单看一下。

就是呃就是返回的这个意见吧。就是说正好看一下这个相对的位置是么样。但是这个并不是客观的我觉得他反映的主要是那个呃这个厂商还有学者对现在我们这个整个AIcomp生态的一些看法，或者或者主观的意见吧。对。

所以我们看一下就是说呃。总结下来是什么呢？就是说厂商就是这个呃当然我们从前面开始了，就是整个调研来说，就是厂商对前端设备的工作量呀，还有复杂性啊、不可控性有一定的焦虑。对，然后就是对这个从技术上讲。

就是对编译器的抽象能力，还有泛化能力有比较高的诉求。那么我们现在的这个state of的compilr的技术可能还没有完全达到这个这个这个厂商的要求。啊。

当然我我我我们也认识到就是多就是开发这种多后端的编译器是呃具有极大的这个技术挑战性的。最后就是我们通过那个那个那个调研的结果，我们看到就是呃我们普遍认为就是框架自带的这个编译器。

当然这个这个比如说这个toch加上triton对对对对，这这个刚才那个彭已经介绍了这个工作非常优秀的。然后那个应用性啊性能都非常优越。但是呢呃在迁移性和那扩展性。因为它主要面向这个pytoch呃。

这个自身的框架。所以在迁移性和那扩展性上可能还是存在一定的这个局限性的，或者至少大家呃感官或者说印象是这样的。嗯，就是呃另外就是这个呃这个面向这个可迁移性，还有扩展性的话。

就是呃我们主要主要的这个这个技术挑战性，就是如何设计更好的硬件抽象。对。OK就这实际上就是我们发现就是整个这个呃这个AI编译器技术还非常有挑战性的。然后那个呃我们也不可能解决所有的问题。

但是我们回过头来看呢，因为我们是有一个那个这个科技部的项目做支撑的有3年的这个计划。我们还是想从头来做一个稍微完整一点的这个编译器。然后我们的目标是什么呢？我们主要有三个目标。

第就是我们想去构建一个统一中立的这个下一代AI编译器的基础设施。然后呃比如说我们用通用的高层表示，然后用这个可扩展多层的抽象，这个有点像MR一样的对呃支持灵活的原编编译。

就是刚才那个ber介绍的这个我也是我非常喜欢MR最近的一个那的这部分。对这样就可以把这个这个呃编译器的优化跟这个ning啊，还有这个opposition可以解耦。对呃。

另外就是呃如果你想这个能够实现底层编译器跨平台的这个迁移的话，需要一个精准的。代价模型。还有就是我们现在MR也做的非常好，就是structure cogen这个是是。

也就说我们我们想去buil一个这种中立的下一代的AI变译器，而不是面向单一的这个这个前端的框架。然后第二个目标就是我们希望我们的这个I编译器的这个inrastructure。呃。

能够成为这个研究和产品落地的一个开源的平台。然后第三个目标就是说我们能希望他能真正的去帮助这个这个厂商去适配这个比如像大模型的这样的应用。对。呃，整个进展的话就是说我们去年主要是在这个调研。

还有这个立项的过程当中。对呃，包括这个去呃呃征集这个支援学者。对，然后我们正式的那个开发应该是从今年啊12月份开始的。对，然后现在的呃这个这个状态就是说呃我们这个我我们从这个pyto2。我们从py拖2。

0开始去支持。然后我们能lower到这个就是我们整个这个low框架是已经打好了。但是我们现在就是还没有完全实现这个后端。对对对对对。这样的一个状态啊，下面的话就是说由时间的限制。

就我们我们直接就是呃就深入到我们现在一些技术的细节。对，就是我们现在就是说因为我们想做一个稍微完整的一点的这样的一个编译器的架构。就是整体的这个思路的话啊。

还是建立在就是最近这几年的编译器整个的这个发展基础之上的。也就是说我们还是分成两个部分。第一个部分就是高层跟这个backend跟后端无关的这个那那我们前端的话。

当然我们通过像这个dynamo啊呃这个呃graphra capturing这样的技术。呃，或者是如如果是一个graphra framework哈，那我们也可以直接import它的这个graphra。

然后就是说我们可以有多个前端把不同的框架的这个呃这个模型或者是部分的计算图能low到我们的graphra IR上去。所谓的graphra I的话，就是呃用我们的这个这个中间表示表示的一个计算图。

然后我们在上面去做一些那个硬件无关的这个transs。嗯，最后的话就是说我们希望能够生成一个完整的一个相对完整的一个一个tensor这个penser计算中心的计算图。

然后之后的话我们会呃用这个就是说我们刚才说到的machine models cost models啊。我们去把它进行重新的这个算子拆分式融合，然后呢呃再把它lower到这个t级别这R上去那t生的话。

我们可能会会做一些这个进一步的这个面向代码生成的优化。但是可能会发现这个优化的效果不好。那我们会重新去进入这个优化的循一个非的这个循环。对这整体的一个那个是个架构的思路。

然后我们的那个所用的中间语言是我们现在我们自己重重新设计的一个中间叫ba basic step intermediatemedia language。它是一种比较简单的就是说一个轻量级的中间语言。

后面我会介绍一下。呃哦那我们这块，因为刚才那个是一个整体的一个一个一个通用的这个架构。对技术的架构。这个是我们呃现在这个 prototype就是说原形的这个面向0的一个这个是实现的一个架构那我们刚才就是我就用这个ygraph来做的前。

因为刚才彭经说到了，就是说呃其实有很多这个框架的那个功能是跟那个重序变相管就是说这个这个graph还有那个还有这个ization什么的这个是在这个框架的这个compr去完成的当然这个这可能不是在框架comp就是graph就是本身是一个一个一个一个变换的这个工具了。

然后出来之后呢，就是一个那我们的输入的话就是这个对然后我们把就是说我们上去对用loR来表示一个部分的计算图我们的locompr呢就是在。

helloR上去做一些这个这个SC基SC的这种data flow的优化。对，但是现在还还没有正式的开始。因为我们现在是我们阶段就是我们把这个这个hello已经实现出来了。

但是这个优化的部分还没有完全开始呢。对。那下一个阶段就是这sorry我这这个后面是有一些这个对，就是呃我们回头就看一下这个这个lower的过程，就是lower的过程的话。

其实跟这个呃呃我们还借助了FX的这个inrastructure也就是说我们生成的同样是一个个里面就看我这我个的子是吧？

那我 return个 node实际上是这个指向的一个函数是我们的buer function。然后我们再跑一这个就生成我们的的。

对因为我们的方我们的这个intermedia languagethon binding。好，那中间这段我们刚刚也说了。

就是这个是我们的呃这个中间表示那我们的comp实际上是用ra来实现的对那我我这个这是一个那个我们的一个小IR的一个前端的表示。

对我们会上面去做一些个前端的这这个S级别的这话后面的话我们还有一个就是说这个是比较的一个一个技术选择。

就是我们现在呃希望能够面对这个多种这个这个异硬件来来做一个这个呃通用的虚拟的这个runtime这一层。后他们只要去适配这些这个的话就能接受进来。对后面这个是我们现在我们打算开展呢。

就是我们现在还没做这个的IR这个今年的Q3Q的话，应该是主要的这个目标是这个这个R的应该是以个为中操作为中心的这个编的过程。对好，那就是主要的技术难点或者技术点的话，是这个R对我们希望他能够是提供一个。

稳定的这个上层框架接入的接口。然后它的抽象层次是跨越这个上层跟底层。这样我可以用它去实现这个high level的op和这个low level的这个code栈。对，好。

那我们整个这个fagIR就是说我们整个这个这个compiler就个端到端的项目，我叫fag IR就是它的技术路线我仍然是一个轻量级的层次化模块化的这么一个对呃一个设计。对。

然后bael本身的这个中间表示我们借鉴MR的这种层次化的这个设计。对，但就就是说这个后面我会因为时间的关系，我们会快一点介绍。对。呃，这这个是给大家看一下我们这个basil coreIR的这个情况。对。

因为我们这块看起来跟这个MR是有点相似之处的对。呃，但是我们我们相当我们强化了这个region payload。

就是说我们在这个呃这个呃cope capturing就是environment capturing上面，我们我们强调一下，就是region它是n capture的这个这个 payload。对的。

这个region的话是用这个双花块块表示的呃，单块的话是一个block blocklock的话，它会可capture它的 environmentviments。

所以我们可以用这个block来定义一个 function，一个closure都可以FN的话就是一个普通的一个一个一个operation。啊，那这个他就是呃简单的去看了它这个一个整个的这个IR的结构。

当当然我们这个上面是它的ide的这个语法，还有它的这个内部的结构。然后我们的这个表示的话，我们操作就是参测级别的操作的话。

我们是把它就是分类成这个不同类型的这个er这个类型的话就是说我们希望它是比这个像to，还有这个什么呃呃sableO稍微低一点的层次。但是比这个gene要稍微高一点的层次。对呃，那我们把它分成四类。

第一类的话就是只涉及到index map的这种view操作，再加上基于这个view的 copypy操作。第二个呢就是一个map类型的操作，然后是reduce类型操作专业类型操作为什么这么分呢？

就是说他们的实际上他们就是说呃他们的这个这个他们的计算的这个复杂性，还有这个存的这个特性是有明显的区别的，我我们把它分成这个四类。如果这呃就是以后如果有必要去这个设计新的这个类型。呃。

的这个这个操作的话也也是有可能。但是我们觉得现在的这个比如以转送为主的话，基本上都落到这几个里面去。嗯，然后举一个例子，就是说我们可以用这个view，就是view的话。

基本上就可以把这些这个tensor的这个index呃这个。呃，这个变换的之类的操作都一网打尽了。比如说transpose broadcastresha slice啊。

fe我们都是这个都可以用viewview来表示。然后呢，那个在view里面这个payload是用来做什么呢？就是这个payload定义了一个F find index map。那我们可以看最后一个例子。

比如说我们这view X是一个4乘5的一个一个一个tensor。然后把它这个呃比如像我们要做一个那个convolution的话，映射成一个四维的tenser。

那它的这个index对应关系实际上就是HIJK映射成H加J加呃那个I加K对。呃，map类型的话很简单，就是说他要么就是说它是没有输入的。

那么它的那个呃那表示就是说它的这个呃单位的就是说它的输出仅依赖最多每个输入的一个单个的单元的操作。这个叫map。那它有几个不同的这个操作啊，就是比如说这个这个ssper map。

那就是说它不需不去依赖任何的这个输入。但是呢它的输出单元的值跟只跟它的那个index相关。第二个呢就是我们定义了一个简单的这个map类型的计算。

对我们计算是先做了一个减法我做了一个exponential的计算。那这个payload实际上定义的是一个size之后的就map mapap是一个tensor计算。

那那个那个这个m接的这个它定义的个or之后的这个计把个5乘3的5乘3的，然后用一个这个这个函数来表示reduce的话就是我们用来去表示降维的这个操作。

对然后这个呃X reduce话就可以用来表示一系列的这种我只在第一维度去reduce加上加上这个size之操作。就我只在第一维度去我就以用这个 reduce一系列的这种非常通用的这个算融合的这个操作啊。

那那个jo的话实际上就是相当于是个或阵成操作的一个扩展。它表示什么呢？就是说我们在这当然我们有维度是不变的。但我们中间的话有些维度可能是需要这个交叉。对。

然后最低维度我们可以需要contra需要需要需要消去的。就这是一个这个也是一个比较通用的模式。然后它的这个实际上它的计算复杂度是比较高。而且它涉及到的data movement是比较复杂。

也是我们需要特别要注意的对然后这个针对这个jo的情况是这样这个例子里面可能就是一个矩战成的例子。然后他把一个就是100乘以5乘以1乘以3啊。

100乘以1乘以4乘以3到100乘以5乘以4这样的一个jo的操作的类型。那我们就用这个payload的3乘3到个sr来表示出来的。对，就是这这个刚才跟alber说的有点关系是什么呢？

就是说呃我们最终的这个就是外层的这个循环实际上是很容易解释出来的。但是内层的循环的话，比如在payload里面，这个我们叫s也也好，他可以用compr来去做深入的这个优化。对。

那里面如果再lower下去的话，我们可以用这扣栈的IR去来表示它。O呃下一步就是说我因为我们现在设计了高层的这个operation。那我们我们下一步就是说我们要去设计和实现我们code栈的部分。

对这部我们打算就是分成几个level去做就就最的话我们希望是一为中心这样一个示。对然后ex作为 class处理它在面可以 flow这这东西对对然后再往下这个降一的话呢。

我们就把显示的这个ism还有dastruction可以加上去。另外就是说在这一层我们去做 bufferization对第三层第三层就是level three的话。

我们是需要能够跟这个底的硬件能够做更紧密的映射关系，包括这个就是low level这样的这结构的比如个之的我都加加最后呢。来说只是一个这个这个后端的tart。

好，就这个现在是我们的working progress状态。因为我们现在没有还没有完全这个做完，所以没有这个performance的那个data给大家展示。

呃，我们未来发展定向呃，就是定位就是说我们希还是希望跟现在现有的这个这个开源的编译器有所区分。对，就是其实我们观察就是开源的编译器仍然存在大量的这个存存量问题。

我不觉得就是说我我们现在嗯就是说完全没有必要去开发一个新的这个编译器。我觉得完全是有这个容量的。就是说我们我们我们几个独立的编译器，然后去相互借鉴发展。这个完全是是可以的，没问题。对。呃。

然后就是就是当系统大到一定规模之后，就是完备度提高，就意味着易用性的这个可可靠性的下降。所以就是说呃我我们的目标也主要解决这易容性可靠性的这个问题。就易用性可靠性收益，可能不亚于这个性能的这个收益。对。

然后我们整体目标就是说仍然要保持轻量化，我们希望能够用10%的工作投入解决90%的问题就可以了。松耦合其实有有两点考虑。

第一个就是说我们不跟这个特定的这个这个呃理理论上我们不跟特定的这个框架来进行紧耦合。对呃，第二点就是说向下的话，我我们不希望能够烙聘到这个device这个设备商的这个生态里面去。

然后第三个就是我们要就是说这个Icomper就是跟传统compr不太一样，就是实际上这个自动优化的这个需求还是比较强的对，因为它里面涉及很多这个语编译的这个参数调优的这个问题。

我们希望能够结合这个自动调优技术来去改进这个这个性能。技术路线的话就是说我们仍然重点要放在这个杯的干高层的表示，重点表示简约可组合性。对，这样就为这种多多硬件的这个适配来提供这个条件。

然后第二点就跟实践相关的这个我觉得是我们一个我觉得是比较有意义的探索。就是我们要采用我们采用的是来开发这个编译基础设施。因为从长远看，我们觉得C加加的这作为这个structure的底层的语言。

它的codebase的可维护性安安安全性会带来很大的这个隐患。就是5年之后1年之后的话，我觉得C加加可能会逐渐退出舞台就是说它是基于这个兼兼容这个性能跟可靠加安全性的。我觉得目前来说是一个比较好的选择。

所以我们希望能够探索一下这个这个方向。现在有自己的那个 compile，比如说 lift的对吧？但是呢面向AI的这个就就是说我们说的这个acelerator compile现在没有先例。

我们希望能够在这儿做一些探索。呃呃生态合作这的话，就是说我们希望能跟厂商共同维护这个基础设施，还有后端代码生成。呃，同时也希望跟这个这个科研单位来合作探索这个编辑的前沿技术。

为什么。

う。好，谢谢白博。那个刚才白博呃介绍的这个呃智援在AI编译上的这个我们的那个我们的那个呃目标哈的确是挺ammb的那这对我们来说实际上是一个三年的rese项目也是一个教一个b bat。

那我们所以在从今年开始也会利用在智援大会的机会。每年都会给大家update一下我们的往前走的tage呃我们的状做到什么程度。或许我们到了明年也会有不同的方向上的，在编译器方向，我们该在这条路上该怎么走。

会大家更多的一些不同的思考。好呃呃我我我介绍呃呃下一位讲者是来自于呃昆仑新的呃罗航。😊。

诶， sorry。😔，是是。😔，哎等一下。😊，Whatject。Yeah， let me introduce our last speaker。 Mr。 Luo Luo。

he's from the the the company called the Kunun chip chipet。

And it's one of the major chip to do the AI acceleration。 And so less welcome。好，谢谢大家。嗯。

那我再用中文介绍一下我自己和这个昆仑新吧。那个我是来自昆仑新的研发总监罗航。那昆仑新呢是一家比较年轻的公司，在2021年拆分出来。但实际上呢，他已经有十年的一个历史。为什么呢？

是在原先是在百度的内部的一个部门叫智能芯片及架构部。那你看可以看到这个呃这个照片啊就是这个昆仑新二代芯片，我们现在主推的二代芯片的实拍图。所以这张图呢就是回顾了整个昆仑新的这个历史啊。

虽然说是才成立法法律意义上才成立两年的这个公司，但实际上这个技术和产品已经已经积累了10年。我们在2011年的时候就开始做这个FPG及FPG做这个AI加速器。啊，一直到2018年的时候，第一代芯片量产。

并且大规模推广。在2021年的时候，第二代芯片量产啊，现在主主推的就是第二代芯片。嗯。好，那进入正题就是呃这个第一part呢就是可能我会呃有一些这个带来一些一些这对计算产业发展的一个分享啊。

一个逻辑的分享。就是说呃大家可能近两年听这个AI芯片这个词就是听的比较多啊，有没有想过为什么近两年AI芯片啊，就突然火起来，为什么前两年没有啊，其实这个是带来我个人的一些思考。

就是我理解这AI芯片是新时代这个计算产业发展的一个必然趋势。这张图呢是从左到右是一个时间轴啊，那个重纵坐标是一个抽象的一个计算产业的一个系统架构啊。

那么从左到右我们可以看到从整个计算产业的发展趋势脉络来说，我们理解可以发可以大致划分为4个时代，最左边就是一个上古时代。这个上古时代面向的这个群体是科学家的群体。它的芯片。是定制化的处理器呃。

操作系统是unux。啊，这个这个上上面计算的任务呢，一般是。呃，这个实验室里面的一些科学计算对吧？然后到第二个时代，可能大家都比较熟知的，这个就是PC时代。

那我们PC时代可以看到芯片主流的芯片是叉86的芯片，操作系统是windows的操作系统。在这个时候，windows和叉86这两个强强联合形成了一个非常强大的wintail的生态。

在这个生态上诞生了非常多的。呃，丰很丰富的桌面的应用啊。比如说我们可能就是呃当时聊天工具QQ啊或者是浏览器啊，或者是一些单机路由器。这个时候这个时候的这个联网状态。

是一个呃呃还是规模比较小的一个有线局域网，对吧？嗯嗯，想想202000年2000年初的时候，网吧那个时候特别火嗯，就是对吧？就这个时候是PC时代的一个典型的一个现象，到第三个时代就是移动互联网时代。

现在我们人手一部手机，对吧？这个时代这个连接规模已经爆炸式的增长。它的典型的联网就是无线互联网。然后可以看到我们看也可以看到这个架构中间出了一。多了一条线，对吧？啊，可以看到这里多了一条线。

这条线代表什么？代表集团产业计团的架构代表出现了分化，为什么都会出现分化？是因为我们手持的这个终端设备，它必须要有一个低功耗的一个硬性的要求。而这个硬性要求是在上一个时代叉86基于叉86芯片做的这个。

这个价格我是没法满足的，所以它出现了结构的分化。而这个分化左边就是以ar为代表的低功耗的这个性处理器之上孕育出了安roid和IOSIOS这个生态。那右边还是呃中心侧啊，是就是或者是云端。

是叉86的芯片和linuxux构建的这个云端的生态。那这两这两套这个架构会呃也是在并行去发展。像比如说左边这个呃手持设手持设备上有各种各样繁荣的APP对吧？大家都可以体验到，实际上基本上生活呃。

这个这个呃线下和线下基本打通，都是通过APP去去去实现的。那在这个时代出现了一个很大的一个变化，就是因为我们手持终端的联网规模。报炸性增长之后，产生了大量的数据。这个数据有很大一批是非结构化的数据。

这种非企化数据它的一个重要的特征是。呃，向量化。这种向量化的数据，它是传统CPU处理过来，由此导致了什么呢？导致我们现在进入AI第四个时代，就是AI时代的时候，它分化更剧烈了。

就是CPU处理不过来的话呢，他一定需要有个特别擅长处理这非结构化数据的芯片啊，底层的这个架构运营而生。这就是为什么？右下角AI芯片在这个时代到来的的原因。

所以我们现在正在进入的是AI时代AI时代可以看到这个架构分化的越来越呃复杂啊。那基于AI芯片。之上，在相同城市，操作系统相同城市。诞生了呃，也不是说是因为AI芯片诞生了这两者深度学习框架。

AI芯片其实是其实并情发展的。它的他们之间的关系就很像呃这个CPU和操作系统的一个关系啊，对吧？所以为什么说深度学习框架就像是AI时代的这个操作系统。在这个之上呢。呃。

有很多大数据的应用以及各种各样的模型。现在讲了大模型对吧？大模型其实也是基于大数据炼炼单炼出来的一个模型嘛。那所以可以看到这个生态在AI时代的这个生态也分化出来越来越复杂。那这里我用两两句话来总结。

就是说呃呃呃借用这个对社会主要矛盾的一个表达啊，就是为什么会出现这样各种产业的一个。架构的一个迭代呢，主要就是人民群众日益增长的美好生活需求和计算系统的算力发展不平衡不充分之间的矛盾。这是。

计算产业架构迭代的第一驱动力。那每一次的这个。架构的变化或者是每一个时代的变化。就会有新的啊这个旧的生态会被的颠覆，新的生态就会涌现。那现在出现就会出现一个很巨大的一个机会。那这个巨大的机会。

重要一个表征是什么呢？可以看到。这张图是一个客观现实啊。这应该是一个研究报告上一张图，这张图表达的是什么？纵坐标是模型的参数规模。横坐标是时间轴啊，可以看到，其实是很明显的趋势就是模型的规模越来越大。

呈指数型的爆炸式增长。那前几年这个。bert在这儿300多兆的这个规模。bot当年推出的时候也是非常的精验啊，包打天下呃，霸榜很长时间，但是没几年。这个GPT3出来1751个参数。

那那大家也知道这个最近很火了，掐了GPT就是基于GPT3对吧？那这个规模指数型增长，那可以预见到未来规模模型的规模也会也会越来越大。这说明什么呢？其实就是说在AI时代。刚刚我说的这个旧的秩序被颠覆之后。

涌现出来的大量的新的机会就是大模型的机会。那大模型一定是对底层的大算力是有要求。那从我我看到一个研究，就是说模型的规模每增长1倍，模型的规模增长。跟算力需求的平方成正比。也就是说模型增长。

那算力增长更多啊，需求更多。所以可以看到这是一个很明显的趋势啊。那么从这个趋势来说，如果模型增长到一定规模，突破一个临近点的时之后会出现什么？这就是我们说的涌现。为什么大家呃。感受到这个叉GPT这么。

厉害。好像能理解人的这个自然语言，以及能够做很多这个思维的这个推理。为什么？嗯，现在学术界都把这个归结有归归结为涌县。那实际上涌县其实是一个很普遍的一个现象。在生物学中也有很多这个涌现的理论基础。

你比如说。最简单的就是我们的我们人脑为什么会产生意识？或许一直也是一个涌现的结果，对吧？这就这就如同我们。这有个GPT3为什么能够产生如此惊艳的效果？呃，我们不能理解这个为什么会产生如此经验效果。

就如同我们不能理解为什么我们的大脑会产生意识一样。我们可以把所有的归音都归一为涌现。那实际上这是有一个从生物学和AI研究来说是有是有一个一脉相承的一个理论基础的。可以看到右边这些图啊。

当模型增长到一定规模之后，哎，它的效果。有一个爆发式的增长，有个有个月迁。这就是涌线的一个效果。所以从这从从这从这些涌现的这个现象来说，也可以也可以呃在可预期的未来，也可以判断。

就是说模型越大可能它的效果会越好，对吧？所以所以这也这也就是一个大模型的一个趋势。未来模型可能会越来越大。随着跨模态多模态的一个模型的一个也呃一个1一个沉淀啊。

有更多更多的这个跨模态的知识沉淀压缩到一个模型中，这个模型规模是会越来越大。那于此运营而生的伴随着就是对AI算领的这个需求会越来越大。好。

这个第一part就是做了一些这个对计算产业的一个铺垫和趋势的一个一一些展望。那么。第二排我带来的这个分享就是那作为我们昆仑星，或者说在这个AI算利这个赛道的这些这些玩家来说，我们理解可能要经过产业化。

可能要必经三道窄门。第一道展呢就是量产。作为一个芯片公司，那量芯片的量产是。第一道咱们就是前提。就是说从芯片的设计构思一直到量产其实要经历很长的一个时间，周期差不多是两年的一个周期。

那如果没有跨越到这套展本的话，没法去覆盖前期的投入的巨大的一个成本。所以量产其实也是芯片企业。这个成熟和芯片稳定性，还有各种指标成熟度和和这个这个呃很重要的一个指标之一。第二个咱们就是生态。

其实本质上做芯片的公司是没法逃避生态和或者是没法逃避软件的。为什么呢？如果只做生态只做芯片，那上很多上层的应用，很多上层的客户，他根本业务根本用不起来。

那实际上每一个芯片公司都要去跨过第二道咱们去建设一个很完整的一个软件生态啊，这个软件生态可能包含很多技术站啊编辑器啊，甚至还有开发者社区啊，来帮助客户更好的用起这个芯片。

而事实上现在国国国内很多这个呃包括包括昆仑星自己啊，也都是在这个生态也在不断的完善中啊，好在昆仑新现在依托百度的这个这个整个AI的技术生态。百度在在AI的这个技术生态中也布局了十0年。

所以这块相对来讲还是相对比较完整一点。后面还有一个PPT会介绍的这一块。那第三个产呢就是产品化。那光做完生态，光光做了软件还远远不够，要把这个软件和硬件做成软硬一体的产品化的标品。这个产品换了标品。

有助于。这个芯片作为一个企业，能够形成这个业务的闭环和飞轮啊，做做项目实施和落地的时候，这个这个呃编辑成本才会更低。所以我理解这个这个做芯片的公司啊，可能不能仅仅只考虑硬件生态，还有产品化。

特别是软硬一体的产品化可能是很重要的一个。需要考虑的这个部分啊。好，第三趴就是那当然就是昆仑星在大模型这个行业有哪些实践？这个就是我刚才说的这个呃昆仑新结合百度的这个整个生呃整个AI的这个生态。

就是百度提出了。AI大理做这个概念。呃，包含4个四层框架，应该说是百度是国内首个全站自研，四层都自研的这个呃并且能够单独去交付的这个呃AI基础设施，就是四层架构啊。

是四层大底座最底层一层就是芯片这个在AI时代的。我们所说的算力都是AI算力啊，就芯片层科能心，中间就是非讲非讲就是深度学习框架啊，就是所谓的AI时代的操作系统。然后在这实上孵化运育出来这个文心大模型。

那文心大模型包含两类。一类是这个文心一言是NP的大语言模型。还有文心一个式这个大的这个呃文身图的这种这种CV的类的大模型啊。在这个大模型之上可以孵化出更多个的这样产业应用啊，基于大模型的产业应用。

那昆仑新在这样一个生态上，我们提出了大模型的解决方案是什么？就是底层。其实昆仑星主要关注的主要主要可以交付售卖的，主要还是底层的这个硬件和设施嘛。在这个硬件设施之上。

我们有各种各样形态的这个举证产品矩证啊，卡级的，还有服务器级的都有在这个之上，我们会提供昆仑星在支持大模型的呃这个昆仑新软件站，特别是叉FT这样我们会有一个大模型的加速库。

在这个之上会呃会有一些数据标注啊，所训练还有这个基于或者是其他的其他的开源的这个深度学习框架构建出来的这个框架级的生态以及之上的各种大模型大模型在上面在孵化很多应用啊，包括信对话沟通啊。

内容创作等等都可以都可以孵化出来。所以这个就是我刚才说的昆仑星主要推主要需要主要积累的这个核心的这个产品矩阵啊，可以分为这三个层次。那我们所说的大模型其实有多大到底有多大。

其实这个其实是一个是一个比较模糊的概念。我们这里划分了三个层次，从10亿到百亿的这个模型，可以在卡P标卡级上去做去做呃推理或者训练。那如果是百亿到千亿的这种规模，那我们建议就是在在这样一个呃呃服务器上。

这个服务器上面搭载了8颗芯片8颗芯片两两互联，它是OAM的这种模组，两两互联构建了是一个可以支持大不规模训练或者推理的这个服务器。如果在千亿级以上的这个这个呃模型啊。

比如说恰GBT这样1175亿个参数的这种恰GBT的话呢，就就就需要这种呃服务器组啊组呃这个组合成的这个集群。那经过我们实测呢呃推理的这个性能基本上相对于主流的呃这个150瓦这个产品啊。

GPU这种产品是有一定的加速的啊。啊，这我这里说的都是150瓦这个这个档次的。那这些技术指标我就不不一念了啊，大概就是说想说的是这种这种卡是P胎与标卡。现在主呃主推的这个P胎E标卡。

现在我们已经把所有主流的叉86的指令级的。呃，机型和arM指令机的机型全还有一些。呃，大规模的集群全做了适配啊，这这这是这是看才产品局中的这个表卡。还有类就是刚刚我们说我说的这个一体机一体机。

这个大概是6U的这个机器，这里面就是有有呃有一个窄板，上面有8颗8颗这个这个二代芯片。它通过这样一个top扑结构互联之后，可以达到比较好的一个并行训练啊一个效果。模型并形的效果。

那如果是多台机器组成的这个集群呢，我们同时可以提供。呃，集群纳管的一个框架啊，个高构建一个高可扩展的一个mas。那这里想说的就是昆仑新和百度的拍ddle拍le飞讲也做了很多很深度的这个技术优化。

比如说有这个啊呃数据并行，还有这个模型并行，还有分组切片等等流水线并行，还有这个参数的分级存储等等的各种技术的优化啊，这里这里我我就简单简单说一下这个参数分级存储什么概念。就是说。

那其实这个大模型很大参数和参数规模很大，可能可能卡上装不下。那装不下的话怎么办呢？就可能要分级存储，把热点数据装在卡上的这个有限的这个显存里，一些非热点呢可能装在装在host的内存里。

那更不热点的或者大模型的全量参数装在这个硬盘里，通过整体的一个协调，造成的呃使使这个这个整体的这个这个调度的这个成本的最低。同时我们跟智源这块也有非常非常深度的这个合作哈。

那比如说这个致源这里推出的这个大模型col大模型啊，我们也做了这个呃很好的一个适配，并且已经验证了大规模推推理的一个一个性能。😊，还有nex厂这个分分分布式的一个推理也支持了。

同时这里还有这个资源还推出了这个Eva系列的这个视觉大模型，我们也都做了全量的一个适配啊。这Eva系列呢它会我们在这个资源推出这个九鼎计算平台中也做了很完美的一个适配。所以在在这个9点9鼎这个平台中。

我们可以我们支持的这个呃这个依把这个系列模型这个视觉大模型的一个一个大模大规模的验证。同时资源不是在这里还有一个这个flag proof这样的一个测试框架啊，我们在这个测试框架中。

我们也支持了大部分的这个模型啊，保持10多个这个模型的评测生态。这个框架也提供了一个非常好的一个bechmark的一个测试标准。未来的话也会我们也会逐步的迭代这样一个模型。

会有这个把这个覆盖生生态覆盖做的越来越好。那这里举一些例子，就是在大模型应用可能会有哪些场景呢？就是这里说比如说。支持呃搜索和问答，这是非常这是很容易想到的非常典型的一个场景啊。像百度现在的这个搜索呃。

这个后台就很多都是昆仑星支持。昆仑星再加上百度的这个NOP大模型支持。同时还有一些场景，比如说能源行业，就电力行业的这个大大模型啊，他他们用在什么什么地方，就是说他们可能有很多规章制度非常非常庞大。

同时在这个设备的维护上非常非常繁琐。那通过大模型把这些知识都压缩到一个大模型之后呢，有助于提升到了这个效率。同时还有一些CV的场景的这个这个CVCV大模型啊，这里就呃就就就不不展开介绍了。

我们在这个智智慧工业的这个检测场景呢，我们也有使用这个CV大模型，能够很方便的让工厂的这个检测提升的这个效率啊，这个是这个智慧工业场景。我们的一个交构图。左边就是客户测的这个系统啊。

我们对它无侵入的改造啊，右边提供是整套这个大模型的可训练以及这个推理这个这个引擎。它只需要在应用层换一个调度引擎就就可以了。就所以对客户的侵入非常少。呃，再给我一点时间，好吧，有点点展望啊。

就是说这是带来我的个人那些思考啊，抱歉。😊，那实际上我们理解大模型对这个产业发生的这个范式发生了非常非常大的一个冲击，发生发生了非常大的变化啊。

呃原先是用各种各样小模型去解决各种各样分散的各种场景的问题。现在呢好了，大家有个大模型全部收敛了transform这样一个大模型的范之后呢。

可以通过大模型去去作为一个base做做为一个base line，然后去。😊，做呃少量数据的翻 two啊，去可以可以解决行业的一个垂类部署和问题。所以这个对产业的这个整个范式发生了变化。

所以我们理解未来可能大大模型这个产业会可能会分层最底层是有少数的大科技公司，以及有非常雄厚的资本的，一个非常雄厚的这个算力基础的这个公司去训练这样的一个一个非常庞大的一个大模型。

然后同时会有一些高科技公司处于中间层去在基于这样的这个大模型基础上去做行业的大行业模型的翻 two或者是落地啊，还有还有非常非常多的百花齐放的创业公司，基于很多大模型去做创业的这个应用。

这就是所谓的大模型原生的这个创业创业应用啊。所以这以未来可能可能很多创业公司要思考如何借用新来的大模型的技术去做一些创业。那OK还有最后一张图。

就是我们理解的这个最后的这个基于这个大模型这样一个趋势的发展啊，我们的这个产业终局会是什么样的？可以看到左边。左边我们可以理解是广义的1个IOT物联网，什么意思呢？

就是发挥捕捉现实世界中的所有信号的这个设备，我们都可以认为是物联网设备。比如说手机或者摄像头，对吧？好，右边是是承载这个AI芯片和AI大模型构建的是一个数字生命体的大脑。这里提出一个数字生命体的概念。

就是当未来大模型，还有大算力，再加上一个场景，还有若干的庞大的呃IUT设备组成了一个东西是什么？就很像很像越来越逼近人的智能。那也可以看可以看到人的大脑。

对吧人家大佬整个人封装的大脑封装的经验就是就是大模型啊，然后人的四肢就是这个这个感受世界万物的这个这个IOT。所以经过这个不断的迭代，这就是一个数字生命体。

这个数字生命体就可以应用在应用在企业或者企用用在国家啊。所以我们理解这个数字生命体，或许是或许是未来产业的一个终局的形态。好，谢谢大家。

呃，不好意思哈，前面那个没有特别控制这个时间哈，我们整个会已经delay了20多分钟啊，否则呃那个所以后面的session啊，每一个都请严格的遵守自己的时间，否则大家我担心我在刚才还在问说。

我们的午饭到几点，我担心大家没那个没机会吃午饭哈。这么多的呃听众今天加入。好，那呃我下面请出下一位呃讲者是来自于中科院计算所的郭琦郭博士。好，谢谢。😊。

好，那个呃非常感谢林总的介绍和那个邀请啊呃，非常荣幸今天能来参加那个北京资源大会。然后呃我是来自中天计算所的郭奇。今天报告的题目是面向大模型的算子自动调优技术。呃。

也是我们在算子的自动调优和代码三层方面做了一些探索。今天也是在这边跟大家一块分享一下。呃，这是今天报告的一个主要的内容呃，首先是简单的一个背景的一个介绍。呃，然后呃深度学习算法模型的规模。

大家都知道也是在快速的这样的一个增长。然后为了支支撑这样的一个大模型的这样高效的运运行，其实目前也涌现出了大量的领域专用的这样的一些呃架构。但是如何充分发挥这些领域专用架构这样的一个运算的一个潜力呢？

其实也是当前AI系统面临的关键的挑战之一。呃，这是1个AI系统这样的一个大致的一个情况。然后高性能算子库实际上是连接算法模型和底层硬件算力的一个非常重要的非常重要的桥梁。呃。

因为它直接决定了上层算法的是否能够高效的运行。然后底层的那个硬件它的算力，因为算力也在不断的增长，它的算力能否充分的发挥出来。呃，也正是因为高性能算子库，它有非常重要的这样的一个作用。

所以实际上其实各大厂商也都推出了自己的这样的高性能算子库。像英特尔的MKLDN还有英伟达的酷Nus等等，这个大家应该都非常熟悉了。呃，但是现在的高清算子库它的实现呢。

实际上主要还是依赖于专家的手工的手工的优化。那一方面呢是要求呃开发人员他对上升算法有深刻的了解。然后另外一方面呢，实际上他对底层的硬件架构，包括编程模型，他也有深刻的理解。

他这也可能写出这样的一个高性能的代码。所以这也导致高清算子库，它的开发周期啊和开发难度都非常大。所以难以满足目前深度学习应用快速部署的这样一个实际的需求。呃呃，这是因为高性能算子库它本身非常重要。

同时开发的代价又非常大。我们认为算子的自动调优和自动的这样一个代码生成呃，是能够有效的提升整个高性算子库的开发效率和运行效率的。

然后这边给的这张图的话是那个基于TVM的这样的一个典型的算子调优的一个整体的一个框架。呃后其中呃最核心的是要有这样的一个探索的一个模块。呃，它本质上是以这样的算子的一个表达式作为作为输入。

然后在给定的一个调度的空间当中去做呃去做探索。那么为了提升这样的一个探索的一个效率的话，一般都会构建起一个呃性能预测的这样的一个代价模型。通过这个代价模型的话，它能够提升整个搜索的一个效率。呃。

那么在找到了一个最优的这样的一个调度优化的策略之后的话，呃，会通过代码的这样的一个代码生成器，然后生成最终的代码，核心的目的呢还是希望能够自动生成，达到或者超过呃手工优化代码的一个性能。😊，呃。

那么因为模型的规模也在不断增长，在这样的一个大模型时代，实际上算子的自动调优技术的话，也面临了一些呃新的一些一些挑战。首先第一个其实前面很多嘉宾也都提到了，就是硬件的异构程度，它会变得越来越高。

实际上现在很多的算子的自动调优技术的话，其实呃主要还是在包括在CPU啊还有GPU上开展的会比较多多一些。那么在一些领域专用架构上面，实际上算子自动调优它还有很大的一个提升的提升的空间。

那么第二个的话就是因为算子的规模也变得非常的大，所以调优开销实际上也是编译的这样一个开销也会也会变得很大。那么怎么对这样一个呃自动调优的一个过程，包括也是在编译的过程做一个加速，呃，也是关注的一个点。

那么第三个的话就是呃很多大模型，它都有一些稀疏动态的结构。这实际上对于构建一个高效，并且准确的一个代价模型也提出了一些新的挑战。呃，那么呃那么我们的话在前两个方面目前也做了一些工作。

那么们后面的话就简要的呃。😊，分享一下我们在这方面做的一些初步的探索。那么第一个是面向专用架构的一个算子算子自动调优的技术。呃呃呃就基于整个这样的一个呃搜索的一个框架。

那么整个搜索空间实际上决定了我们最终能够找到的这样的一个调度策略。它的性能就是最终能够找到的代码的性能，到底它的一个上限到底是什么样的。那么我们认为对于领域专用的硬件来说。

我们不仅仅是追求更大的一个搜索空间。更重要的是追求一个更高质量的一个搜索空间。呃，这主要还是因为呃专用架构，它实际上跟通用架构相比，它还是有很多在体系结构层面的一些约束的。比如说像在上面，它做举证乘法。

它都是在一些固定的规模上面去做。然后像里面的片上的存储需要memory可能有一些固定的一个约束。那么这是因为这些约束的存在，就导致我们去刻画一个专用硬件。

它的一个程序的一个搜索空间就很难去做一个准确的描述，就会导致我们刻画的一个搜索空间，它质量会很差。里面很多的程序都可能是非法或者是无效的一个比例。呃无效的一些程序。呃，就比如说在那个微G器上，那么。

那我们呃前期做了一些实验，那么autoTVM的搜索空间，它非法程序的比例可能会达到呃95%。那么正是因为这搜索空间质量很差。那么一些传统的搜索算法在这个里面去做搜索的话，它效率就会很低。

就大部分找到都是呃无效的解或者是一些低效的一些解。😊，呃，那么呃这核心的原因前面也提到了，主要还是因为专用架构和通用架构相比，它存在大量呃复杂多样的一些约束。呃，那么正是因为这些体系结构。

包括在编程编程模型层面的一些约束的存在。呃，就导致我们去刻刻画它一个程序优化空间，就需要一些额外的一些约束变量。呃，也也会有更多的一些约束的一些数目。呃，比如说我们去刻画一个举证乘法的一个算子。

要准确的描述它一个程序优化的一个空间的话，可能需要173个变量。那么对应的约束的数目也会300多个。那么随着算子的规模，包括算子的复杂程度的增加。

那么呃需要刻画的这样的一个约束变量和约束数目也会逐步的增多。呃，那么另外一个层面的话，就是如果我们没有办法对这个程序空间做一个准确的描述的话，呃，就会导致现有的一些优化的算法呀。

就很容易陷入到局部最优呃，就比如说在一个这样不规则的优化空间当中去做搜索的话，传统的像一些模拟退火的方法呃，包括。我像一些呃遗算算法，这个用的比较多的呃，它的一个表现的效果啊，可能跟随机的算法呃相比。

并没有太多的一些优势。呃，所以在当前的专用架构上面，算的条约，我们认为存在两个大的问题。第一个就是说在搜索空间当中有效解的比例呃非常低。第二个就是说呃对搜索空间进行探索优化的一个算法效率也也太低了。呃。

所以针对这两个问题，我们希望能够同时解决搜索空间的一个精确描述和呃高效探索的问题。呃，那么针对第一个问题，前面也提到，因为它的那个约束呃非常多，那么要准确的描述的话，就是人工去手写手写300多个约束。

甚至写3800多个约束，基本上是不可能的。所以我们也是希望呃我们就通过一些预定的规则，呃，对程序做分析，然后自动的生成这样一个精确呃带精确约束的一个搜索空间。那么有了这样一个精确的一个搜索空间之后的话。

在这样一个因为因为这个空间呃可能会非常的不规则。在这样一个不规则的空间里面，我们就继续提出一个保持约束的一个演化算法来对这个空间做一个高效的探索。😊，呃。

那么这个的话就是呃我们怎么去对这个搜索空间做一个继续的描述，就是提出了一个基于规则的约束空间的自动生成的方法。然后这个框图的话是我们整个的一个呃大概的一个流程。呃，那么对于一个给定的算子来说，呃。

主要是给出它的一个计算的一个描述。后我们能够得到它的一个运算的一个带个图。那么在这个带个图的一个基础之上，呃，通过预定的呃，我们有两两类预定的规则，一类的话是那个呃针对调度策略的一个预定的规则。

还有一类是针对呃调度约束的预定规则。呃，那么首先通过调度策略的规则，我们是自动的生成它调度的模板。那么在这个调度模板的基础之上，我们通过调度约束的规则，自动的生成它的约束，就是最右边那一栏。

就最右边那一栏所显示的。呃，这约束还是还是比较复杂的。呃，那么整个这个过程都是全自动的生成的，最终能够构建起一个带精确约束的程序搜索空间。呃，那么第二个的话就在有了这样一个搜索空间之后的话。

就是对这个搜索空间进行一个高效要的一个探索。那么这边的话我们是提出一个保持约束的演化的这样一个方法。因为传统的演化计算的方法，它呃本质上是呃无约束的。呃，所以如果用传统的GA的方法的话。

它就很容易在搜索的过程当中就跳出我们之前所定义好的一个这样的带约束的一个空间。呃，所以我们提出的这个方法能够保证在整个搜索的过程当中，约束始终可以被满足，从而找到最优的解。呃。

那么这个是我们整体的一个实验的一个效果。然后也是在那个呃在在在呃多个英伟达的平台呃，包括V100啊，T40和A100上有比较好的一个效果。同时在其他的一些呃那个呃DNA上。

包括DL boost和VTA上也取得比较好的效果。呃，然后这个工作的话，我们是发表在今年的Spro上。呃，然后第二个的话是呃大模型算子的一个自动条约的一个加速。呃，那么呃对于大模型而言。

一个前面也提到啊，搜索优化的时间可能是一个潜在的一个瓶颈。呃，最主要的原因还是因为它在整个搜索的一个过程当中是需要生成大量的候选程序。然后这些候选程序呢都需要在真实的硬件上面去执行。

那么这个执行的一一方面是因为它的数目很多。另外一方面它执行的开销很大。呃，所以它的整个的呃搜索的过程也会也会比较长。那么大模型的规模的话，呃，规模不断的变大，就导致它的搜索空间也更加的大。

所以一般会评估更多的程序。呃，比如说像在那个auM和 answerer上面可能都需要评估4000个程序，才能保证搜索得到比较好的一个呃搜索到得到一个比较好的一个性能的程序。呃。

那么为了解决搜索优化时间过长的问题，然后也有一些研究工作是呃基于预训练模型的这样的一个编译的呃编译的代价模型。那么核心的思路呢就是说提前通过预训练的方法，呃预训练的方式提前构建出一些代价模型。

这样的话在整个编译搜索的过程当中，呃，就直接可以利用这个代价模型来对它的性能呃去做预测，就代替大多数的硬件测量。呃，同时呃对于少部分测量的结果，我们还可以对这个代价模型做翻 tune呃。

使得这个模型更加准确。然后这里面的一个代表性的工作，就是呃呃就是tenet呃tenet它和不使用预训练模型的这样一个呃这样的一个搜索优化的方式相比，它在优化的时间上面减少了10倍。呃。

但是预训练模型方方法的这样的一个核心的问题呢，就是说它构建呃整个模型的过程当中，它的开销会非常的大。呃，比如说像tensor的，我如果要针对整个神经网络去构建其它的一个代价模型的话。

它首先要在整个网络当中去选择呃计算的一个纸图。然后对每一个计算纸图呃，去采样等价的程序来去做一个性能的一个测量。呃，这里面核心的开销，就是说在硬件上面呃做性能测量的时间，呃，大大概需要4000小时。呃。

因为包括里面的纸图的数目啊，还有每一个纸图里面需要测量的程序数目都非常多。😊，呃，那么我们呃做的一个初步的探索，就是重点关注怎么去降低这里面的每一个纸图需要测量的一个程序的数目。呃。

我们也观察到在构建预训练模型的过程当中，实际上采样到的程序的性能，它的分布是非常嗯不均衡的。因为本身里面一些高性能程序，它的比例就非常的低。呃，那么过多的我们去采样一些低性能的程序的话。

就会导致呃会有非常大的一个冗余。所以我们要均衡程序的一个性能的分布来降低呃采样就训练集当中的一些冗冗余。😊，呃，然后这里的话我们也是呃呃针对如何减少域训练模型的一个构建开销。

提出了一个基于基于主动学习的这样的一个呃预训练的方法。呃，核心是呃提出了基于多样性选择策略的主动学习方法来高效的构建域训练的代价模型。那么基本的一个过程就是左边那个框图，大概大概有有四步。

首先第一个是做那个程序的一个呃采样。呃，这里面的话会呃随机的先采样呃，并且测量一些性能，产生一些有标签的数据集。然后基于这些有标签的数据集去做模型的训练。呃，第三个过程是关程是最关键的。

就是选择具体选择哪些程序做一个测量。这边是采用了一个多样性的一个选择策略，呃，选择有代表性的一个程序做测量。呃后再把这个测量的程序加到标签的有标签数据集当中做模型的一个更新。呃。

那么我们也是使用ten试的5%的这样一个训练数据集，就获得了更好的一个预示的精度和优化的效果。那么预训练的开销也是降低了20倍。呃，那么这个工作的话，我们也是发表在今年的ICLR上。呃。

最后做一个简单的一个总结。呃，然后呃我们认为算子调优技术是提升高性能算子库开发和运营效率的非常有效的手段。呃，那么也是随着深圳学习大模型与领域专用硬件硬件的一个快速的发展。呃。

算子调优技术也面临一些新的挑战。呃，包括硬件的硬度呃异构程度变得越来越高。所以可能怎么去提升在专用架构上面的一些算子调优的技术，可能是值得关注的一个点。

然后另外一个就是说怎么去进一步减少算子调优的一个开销。啊，以上就是我报告的内容，谢谢大家。😊。

Yeah。好，谢谢谢谢谢谢郭琦博士。那个郭博士给我们s了111分1。😊，1分钟30秒呃，很快啊，两个很好的很好的工作。那个呃我觉得可能这个今天时间太短了哈。

下一次我们可能会利用我们那个智援自己本身的一些社区活动，可以有充足的时间，样样过不是再给我们更详细的去介绍这两个呃很不错的工作。那下一个那个呃是呃带来的是呃来自我们智源研究院啊。

负责整个我们呃AI平台研发的呃田验啊，田艳给我们呃介绍支援。我们是怎怎么样用搭建我们的整个九鼎平台来支撑大模型训练以及芯片的架构的多样性。好，谢谢。😊，Okay。嗯，大家好。

我是智源研究院AI系统组的田燕。很荣幸有这样一个机会能给大家汇报一下我们团队的工作，也请大家多多指点。

嗯，感一下啊。诶。OK我今天汇报的内容呢主要分为三个部分。第一部分呢是背景大模型到底需要什么样的基础设施。这块前面的各位老师已经讲过不少了，我会快一些。第二部分呢是关于我们九鼎平台的一个介绍。

九鼎平台呢是我们智源内部的这个人工智能各种科研工作的1个AI基础平台，它承载了很多类型的模型任务。由于内容比较多呢，这里时间又有限，所以我们只选取了三个大模型比较相关的部分来讲。

最后呢是对未来的一些思考算是抛个砖吧。那么首先是背景大家在前面讲的也比较多了。那我们从历史上看，这个大模型的三波浪潮，其实每一波的发展呢都是一个数据算法和算力的共同发展。

数据和算力能力呢有效的支撑了模型算法能力的不断的提升。但同时呢它也indiate了，在当时那个水平线下，我们的基础设施。智能达到的这个能力呢是模型算法能力的一个天花板。嗯，这块呢算法角度讲。

大模型会越来越大越来越大。这个用的数据呢也会越来越多去train这些模型的数据集的size在持续的增长。那么所需要的算力呢，也是有着非常大的需求。那么在这样的背景下呢，我们基础设施首先要解决的。

就是怎么去支撑上层的模型的workload，去不断的去推高模型算法能力，触到的那个天花板。那么从另外一个角度去看呢。我们呃我们大模型需要什么样的基础设施。还有一个问题要考虑的是说。

大模型的一个开发范式是什么样的传统的模型开发范式，大家可能都是比较都是比较熟悉的。但大模型呢目前大家公认的是两个阶段。我的基础模型的训练，用海量的通用数据来做基础模型发布之后呢。

下游的行业希望用少量的这个行业数据进行模型微调试配合推理的一个部署。这样呢我们希望能以极低的成本去降低AI大规模产业化的一个门槛。在这样的背景下，要想做一个新的AI平台去sport这块的话。

显然是要支持这个大模型的范式的。所以说总结起来呢，我们的AI基础设施干的呢是两大部分的工作。第一部分是怎么去sport上层的这个workload去极致的优化我们的算力能力去推高整个的模型算法这一块能touch到的天花板。

然后第二部分呢是说我们怎么去支持我们的。模型研发流程去提高模型的生产效率。那么首先我先讲一下这个MLops的部分，这个所谓的各种的ops呢，它其实上做的是。工作质量和效率的一个提升和保障。它的本质是说。

我第一要解决工作流程的抽象和这个持续的优化。第二点呢要解决我广义的数据资产的管理。比如说我的代码模型、数据集版本和血员的管理。第三点呢是一些资源的生命周期管理。比如说我底层的算力资源任务的分配和调度。

那么落到这个大模型这一块的话，大模型有这么几个挑战。一个是说它的新范式呢对平台的这个需求是在持续演进变化的。这点鹏友也提到了，我们要用发展的眼光去看问题，落到大模型这样一个新兴领域来说也是非常必要的。

那么在这个过程中呢，由于大模型它本身的训练成本很高。然后后面的微调模型的性能非常依赖于基础模型能力。所以在这个过程中呢，我们对模型本身的管理评测优化，发布这一块的能力要求会比普通平台要更高。

那么大模型第二点特点。是说我的训练时间非常非常的长，成本很高，中间任何一个环节出错，对整个的这个发布都是有影响的。所以这一块的话，我们所以这一块我们要注意每一个环节训练的效率和稳定性。

第三点呢是咱们在现在这个阶段去做平台的话，平台一定会面临着普通模型和大模型混跑的这个情况。这对平台本身的这个灵活度要求也会非常的高。所以这里解决方法呢，我算抛个砖吧。一个是在设计上面。

我们要把这个基础能力进行模块化，这样能保证我们的产品能有灵活的迭代性，高内聚低耦和，这个是非常必要的。第二点是。大家做这个平台的时候，一定是根据自身的业务场景需求。

以核模型为做做核心资产来去设计自己的这个全流程的。当然这个过程中要很注意模型评测这方面能力的建设。最后一点呢是由于大模型整个任务流程的复杂性。

我们要非常重视模型任务生产环境和数据集之间血缘关系的保存和维护。这个在传统的一些计算平台上面是相对比较弱的。这样我们可以做到整个链条的这个追溯和对比。🤧sorry呃，放到九鼎平台上呢。

我们九鼎平台的科研任务更多。所以日常情况下呢。会对呃模型训练本身的任务管理和。呃，训练效率的优化这方面要求比较高。但是在推理服务部署方面呢，诉求会少一些。

我们整个呢是以一个建设平台生态的思路来做这个事情的。数据方面呢有数据平台去完成数据的清洗标注和压缩。模型评测方面呢有这个。刚发布的flag来完成模型的多维度评测，我们也有model hub来发布模型。

在九鼎平台内部这一块的话，我们的大模型的m op现在是以两条线路来组织的首先是这个基础模型的开发训练和评测发布的阶段。这个过程中呢，我们可能会在一个大模型持续训练的过程中。

这个拉 checkpoint出来去做评测，也有可能会re到上一个版本去反复的去迭代。直到我们有一个满意的结果出来。那么下面呢会基于这个基础模型的发布呃基础模型呢去做一些训练微调。

同样也离不开 checkpoint保存和评测的这一个过程。那么以上呢就是我们在M op方面的一些对大模型的探索。第二部分呢是这个训练效率优化，这是个非常大的top。它会涉及到我们的底层的算子优化。

整个的资源调度任务管理和I框架的配合，涉及到一些。并行训练的优化方案这块呃涉及非常广。但是我这里呢只抽了我们平台做手动的性能分析和一些自动并行优化方面的工作来。给大家汇报。首先呢这个训练的优化呢。

它是个持续迭代的这样一个lo的过程，不可能是一一把搞完的。所以我们平台在这方面呢。嗯，是做了一定的这个支持的平台这块我们要想跑一个任务的话，首先要创建一个实验。

这个实验里面呢会管理一组相关的任务配置以及这些任务的运行记录。所以在创建这中间的某些任务的时候呢，我们就可以去那个红框框出来地方，我们可以 enable我们的这个新性能分析的采样。

我们支持的这个标准的接口，也支持一些自定义的数据采样分析。比如说我可以看到一个sstep里头各阶段的耗时是多少资源占用是多少。通过这些分析优化完成之后呢，我们会在平台启动新的这个训练任务。

能跟历史任务去做回溯和比对，也能看到这个任务的资源使用情况。那么这一块呢基本上都是大家要抓数据去做手动分析的部分。然而并行训练这一块的优化呢，其实上嗯复杂度非常非常嗯 sorryor复杂度非常。

这里我受一个简单的例子先给大家来看，这是我们那个一个语言模型的case baselineline呢是一个TP加zero two的大家可以从这个截图上看到，我在那个optimizer的阶段去做的时候。

其实耗时是非常长的通信也很密集。第二个呢是结当时结合那个代码我们也发现了一部分的冗余计算这个优化呢比较简单，我们增加了的 bucket size提高了一个数量级，然后呢优化代码去除了冗余计算。

这块是达到了一个1。17倍的性能提升。后面呢我们也其实探索了一些其他方案。这个图呢是在able了那个zero3的时候的情况。大家可以可以看到这两段的内容。😊，嗯反向计算。

后这个red sorryor投影可能有点糊。然后呢，接下来下一层的这个organge呃 backward和这个red这个红色的部分是完全可以放在提前来做的实现一个计算和通信的 overlap。

所以这块呢我们那个修改优化之后呢，是大家可以看到能做到一部分的这个over大约提升了10%的这个性能。嗯，这个呢是手动优化的一个案例。其实这一块的并行优化工作是一个特别复杂的事情，一旦节点规模上去了。

我的并行策略，怎么去拆。这是个很麻烦的问题。所以我们也和北大的崔斌老师和图团队这边合作在平台上集成了一个自动并行优化方案叫。然后他呢能够对我们的硬件环境和模型进行采样的评估。

然后进行自动的搜索生成并行策略。嗯拿这个策略来去做训练。那么这块的呢右边放了一个呃呃2G16卡的一个bot的实验效果。可以看到最右边的这个gar的这个性能还是比较有优势的。

那么以上呢就是我们这个在大模型训练方面优化的一小部分工作。最后呢我们这个平台其实支持了很多类型的异购芯片。嗯，在这个芯片上呢，我们也有一些这个工作来给大家report。像我们昨天发布的的 code模型。

其实上是在天数至新的集群上训练呢，我们跑了36级的扩展加速，能够连续稳定运行，并且在中间呢enableable了像flash attention这类的优化技术。

我们也同样做了性能的采样分析和一些优化工作。嗯么在昆仑新上面呢，我们跑了qui发昨天发布的语言模型的一些推理任务。像视觉模型这一块呢，我们在做性能的调优。

然后硬件拓普相关的优化部分已经进入了联调和测试的这个阶段很快应该能上线。那在这个寒武纪上面呢，我们其实也跑了视觉模型的预训练任务和一些检测分割模型的。微调。那么包括这个华为的升腾和寒武纪。

还有昆仑新呢一起支持了昨天发布的大模型评测的平台flag e这是我们在国产芯片上的一些应用。在这个过程中呢，我们其实是发现我们的国产芯片整个软硬件的能力是越来越好的。在这个过程中也积累了一些相关的经验。

所以我们也推出了一款这个开源开放开箱即用的一个一个呃芯片的评测软件flag proof这个是和天数百度昆仑新还有华为刚加进来m和升腾两个团队一起来共建的。它支持呃不同。

它支持标准的chmark这样硬件本身的适配成本会很低。然后我们也支持多框架多种类型的任务模型，并且目前为止呢有天数之星和昆仑新等这个硬件有很多个模型case的覆盖。我们在不断的增强这一块对于用户来说呢。

我们也提供非常好用的命令航工具。去支持像道口环境的管理。然后这个测试任务整个全生命周期的一些管理。actly这个项目呢是我们整个flag open飞智大模型这个技术开源体系中的一个就是一个小的项目吧。

这个大模型的技术开源体系呢，也是我们致援和。国内外很多家企业、高校以及科研机构一起共建的大模型的这个技术体系，包括了我们的模型算法的代码一系列的这个数据工具和模型评测工具。

所以非常欢迎大家这个现在拿起手机扫码加入我们的这个技术交流群能够获得很多这个开开发者的支持。这个呃而且我们的这个开源开源的这个license是非常宽松的。

所以呃希望将来能有全球的这个开发者和我们一起去共同探索，共同共同创新，也能有企业来一起base在这个上面去构建它自己的AI软件和商业软件。嗯。嗯，以上呢就是九鼎平台的一些工作。那最后呢关于未来的思考。

我简单抛个砖吧，也希望大家能指点，就是开头说了这个嗯基础设施的能力和上层业务发展的这个能力永远是一个相辅相成的关系。所以做底层最先要看的呢？是说我们上层有什么样新的训练方法，新的模型结构。

新的应用场景出来，它对底层到底有什么样的这个挑战和问题。比如说世界模型要拿出来搞的话，肯定不是现在的这个这个玩法。那么站在底层的角度看呢。

其实上我们认为这四个象限的单机的分布式的操作系统框架层面的这些东西呢，都是值得关注的。他们之间的协同的关系是什么样子。在哪个点可能取得突破会去颠覆整个现在infrra的这个结构是需要持续关注的。

最后需要关注的还有一点，其实上人工智能的能力呢，影响到了各个领域，也包括infrra本身。AFAI system这一块的一些呃在工业界的应用进展其实上还没有那么多。但是在未来的话。

我们也是非常看好这一块的嗯。嗯，以上就是我今天的这个内容。好，谢谢大家。也谢谢。那个嗯呃因为因为今天那个的确我们安排了太多好的这些top哈，所以呃导致我们的时间也很紧，相当紧。

给每个speaker的时间也很紧。那所以呢这就是那个呃可能等会我们会有稍微有一个上的调整，就是说呃本来我们最后还有一个小的。那呃当时准备了一个问题给我们每一位参与panel的这个企业的代表。

那我们在这里头呢就是说呃我们最后会把那个can就先取消，取而代之的是说呃后面每个企业上来的时候，他们可以呃利用他的speech的时间，把这个呃希望想说的，就嵌到他的spech里头这样可能大家共从容一些。

呃，好，那呃我我请出下一位啊下一位是来自于必认的丁总呃他给我们带来这个基于高性能通用GPU怎么打造国产大模型的训练系统，谢谢。😊，呃李老师嗯。好。

那个今天非常荣幸有机会在AI系统专题论坛和大家呃讨论交流。呃，我是来自避刃的丁云帆。避刃科技是那个国产的这个通用GPU的公司。呃。

那我之前在百度一直在从事这个AI系统和这个广告推荐领域的大模型相关的一些工作哈。😊，嗯。好嘞，那今天那个我们交流分享内容主要分这个三部分呃。

第一个是我们看看这个GPT这种大模型训练那个到底呃存在哪些挑战。那第二个是基于逼认的这个国产的GPU，我们怎么去解决这些问题，构建这个大模型的这个呃训练系统啊。

最后我们看一下目前这个我们大模型的产业生态的一些合作的一些进展。😊，呃，P我觉得引爆了这个新的一轮科技革命哈。那从我们这个致源的这个近期今天的这些会议，我们看到很多这个主题都是跟大模型相关的。呃。

所以整个行业现在也也处在一种百模针验的这种状态哈。我们看到国内外实际上有很多这种基础的这种大模型。那也有很多相关的一种释范的应用，对那GPT呢就是为什么能成功这么火爆对吧？

我觉得总结起来是工程和算法这样的一个协同的一个创新。呃，这里面就说有三大因素啊啊，从这个数据呃算法算力三个维度。呃，数据其实是这个燃料也是这个基础哈，我觉得也是现在很多呃大模型公司面临的第一道的难关。

对吧？这个数据从高质量的数据从哪来呃，那第二个是这个算法，实际就是行业之前也有一些这个这个讨论哈，就是说GPT一下火爆了，都它有什么创新吗？对那其实大家说。😊，呃，从算法的角度呃。

好像很多也是公开的算法，对吧？可能有的也是别的公司做的，那他为什么能成功了？我觉得除了一些公开的东西之外，还有很多呃其实就是炼单数，对吧？那这些细节其实是这个成功掌握在细节中。

那这里面有很多包括这个像比如说蝙F16呢，它其实就是跟芯片的这种特性呃非常紧密相关的。😊，嗯，那第三个是算力，我觉得大模型呃需要这个基本上需要数千张GPU卡。

这个也是这个大公司和这个呃有钱人的这个游戏哈。对，那所以这里面当然另外一个就是说大模型本身的这个就是特点就是超大功模参数需要存出。那也需要这种专用的训练框架啊，去提升这个性能和可扩展性。

所以它也不是简单的这个堆积这个算力呢，就能够啊去解决这个这个算力的问题。那必刃科技，我们作为一家这个GPU的厂商，我我们会聚焦在算力这个维度啊，去促进这个大模型产业生态的一个发展。😊，呃。

我们这个论坛就叫系统论坛对吧？所以其实整个AI尤其是大模型里域，我觉得它正是一个系统的一个工程，也是一个软硬件协同的这样一个工程。那从这个图上我们也看到话。

我们这个硬件的这个架构和我们软件的这个训练的流程，它其实是非常紧密相关的硬件上的这个存储，包括CPU内存这个GPU的算力，包括这个互联啊，跟我们软件上你看每一个流程其实都有一个非常紧密的对等关系啊。

所以那核心的就是在于这个前线和反向计算里面对算力的需求啊，另外一个在这种大规模分布式的场景的话，对这个这个参数协同梯度更新的这种要求对单机内部的互联和多机的互联呢都提了很高的一个挑战。

那另外一个我们说这个大模型训练也是一个算法和工程协同为什么这么说呢？因为在这个系统里面比如我们举一个例子，以 size为例，提升 size上是有利于提升这个计算的效率发挥新。😊。

的性能的同时它能够降低大部分训练场景这种通信和计算的这样一个比例。对扩展性是有帮助的。但是它也受到了我们这个比如说呃GPU这个显存的一个约束。那也可能会受到在算法层面对这个g收敛上的一些约束。

所以它也是一个算工程的一个协同啊，那么我觉得总结起来，在呃整个在计算机体结构的角度去看这个事情呢，从计算啊通信啊，包括存储这三个维度都有很高的要求。另外一个在这种大规模的集训里面。

对于这种啊从1到1024这种扩展的时候，你的线性加速比怎么样啊，包括这个大规的集群稳定性怎么样？刚才资源的这个同时也分享了对吧？就大规模集训，其实这些都是工程上要解决的问题。😊，呃。

那前面我们是从这个技术的角度去看一下解决的问题。那这里我们尝试从用户的视角来看啊，那么要解决哪些问题。我总结下了5个哈，呃，这个第一个是capacity，就是这个大模型，你首先要存得下对吧？

你能够跑先解决这个基础的这个温饱需求啊，那第二个说这个calability就说当你能跑的之后，你要为了去提升性能，你扩展更多的节点，那么你这个系统的一个加速比怎么样。

你的这个框架是不是能够比较好的这种提供这种扩展的能力。那第三个是说usability一使用，因为其实现在这个大模型的生态包括有很多模型，很多框架对吧？那你你这个从用户的视角，你这个策略，你的算法啊。

这个生态是不是说易于被用户接受。那最后两个其实是最关键的写在后面不是应该不重要啊，其实非常关键。那就说用户都希望获得我的速度够快啊，我的成本够低。

这是真正大模型在生产环境中能够落地的很重要的因素那我们今天。😊，可能会重点看前面两个就存得下和这个易扩展。因为前面两个问题解决完之后吧，其实后面的问题就相对的迎刃而解了。

那这里我们看大模型的这些常见的一些训练策略呢呃比较常见这一个这个tensor并行。它的好处就来说这个像trans的模型就是非常符合这种特点。

但是它呢会引入一些比较大的一些通信的开销在里面第二个是这个流水线并行这个也是比较好的起到这个人多力量大嘛，对吧？一人干一部分啊，所以对这个参数的规模实际上是比较好的扩展能力。

但是当然我们从这个图可以看到哈，就是些灰色的部分实际都是空洞。那么这空洞其就意味着你的计算效率是变低的啊，所以所以它有有有好处也有很大的一些弊端哈。

那么呃比较常见的我们将这个tensor并行和流水线并行结合起来，是可以比较好的提升这个参数的规模的那除此之外，我们像zero这个呃这个微软的这个zero在这种数据并行的维度啊。

去扩展了这种参数规模切分的能力。所以呢它非常好用，对吧？因为它正常就是一个数据并行不挑模型啊但。😊，他的通信开销呢其实也还是比较大的哈。😊，那为了在这种更少的资源，甚至在单卡层面能够去跑大模型。

让大模型变成一个这个这个普通老百姓，对吧？也能够去尝试的这样一个事情。那微软又推出了这个zero的offload啊，甚至是这样的技术。那么这种技术它利用这种这个GPU的这个显存。

包括CPU的内存中间的那最后以及这个高性能的这个大容量的这种存储介质。通过这样一种三级的异构的一个混合存储架构去解决这个参数规模的一个问题啊那这个工作实际上因为我之前在百度19年的时候。

我们在我们广告这个这个核心的这种业务场景，在这种吸收大模型里面已经把这种技术做起来了。那这个工作也引用了我们相关的一个论文。😊，呃，那前面讲的这些技术呢，实际上是可以相互组合的哈。

那比较常见的是这个3D并行。呃，就将我们前面讲的tensor并行流水线并和zero dP那个三者进行结合起来。呃，可以实现一个规模这个参数的规模和性能的一个一个好的扩展性。呃。

但是呢这里面其实还是有进一步优化空间的。我们可以想象啊，当你这个增加机器的数量的时候，你的所有的显存加起来，如果已经超过了啊你模型的选存的一个需求。这个时候如果你为了更进一步提升性能。

你会增加更多的机器。但是还是会进行参数的一个切分。那么这种切分实际上是不必要的。因为它会带来额外的开销，它会降低系统的一个性能的一个可扩展性啊，所以所以这里面。😊，那呃百度飞讲啊。

那个是针对这种场景又提出了这个4D混合并行的策略啊，它实际上在下定这个维度呢是跟0DP是有类似的功能。但是呢它和它的数据并行是可以分开配置的。

所以他可以做到就是说参数的这种啊规模的扩展和性能的扩展这种解耦啊，从这个右边右下这个图，我们看到哈这个512张卡这样一个例子呃。

4D混合并行的一个策略呢相比于前面两种3D的策略大概有10到20%的一个性能的提升。所以我们可以看见啊，即使在同样的资源的情况下啊，你通过整个大拇的策略其实也是能够提升很好的性能的。😊。

那我们将前面的这个刚才讲的这个策略，我们把它对比起来啊，从这个通信的模式，包括对这个硬件上这个通通信top啊带宽的要求，以及这个策略对降低显存的和性能提升的一个影响，包括它这个方案是不是好用。

那我们看看它适用哪些场景。那我们重点看一下流线并行和这or并行。流线前面讲的通信要求比较低啊，所以呢但是它的计算效率不是很好啊，所以这通信额这个计算点个有有有利啊。

但这种我一般是应用在这个呃就是链路带宽相对低的场景，一般是多机之间去做sor并行它的特点就是相对来说啊通信量是比较大的啊，所以它对一般在单机内部这种高速互联的场景去用。那么把这些策略用完之后。

我们再去集合的时候，基本上是在多机行做啊，那除此之外，我们像这个offload啊comp这技术呢，其实对这种降低这个就是说这个显存的一个需求的效果是非常非常好的。但是对性能影响也非常大。所以说在一个。

😊，实的业务场景里面，我们给定一个模型的规模，然后给定一个资源。那么怎么将这些策略能够组合起来，让他跑的呃进首先能跑起来。第二个怎么跑得更快，这实际上还是有很多这种策略在里面。

所以其实刚才志援的同事也分享到，以后再怎么去做这种自动的巡优，对吧啊？😊，好，那我们前面分享这个整个GBD大门训练的一些挑战呢。我们再看下基于啊B刃的国产GPU，我们怎么去解决这些问题。😊，呃。

所以整体我们感觉是一个系统工程。所以我们需要端多端的去打造一个整体的一个解决方案。那么从最底层这种高性能这种基础设施啊，基于避的高性能的GPU去解决算力的问题。同时我们匹配相对应的高能的存储互联的技术。

那在此之基础设置构建一套这种这种平台刚才像九鼎的这个算平台就属于这一类我们怎么去管理这么多的资源向用户提一个应用的平台，后同时保证这个过程中这个任务是稳定可靠的能够弹性伸缩。

向上还有加速库大模型场景很大的特点就是对通信的会非常高所以这里我们也构建这种像这个我叫的这种种组合能的通讯库啊那大模型场景还有很一个特点就是说需要超大规模的训练架这可能是基于普通更的决方案那讲适配了所以再上去承接这个型的应用目前。

😊，啊啊，我在编着的GP上，我们针对一下GPT系列的这种常见的大部分的训练呢，我们都是可以做都可以支持的。呃，那前面我们讲的第一层是这个算例啊，呃，所以这里面我们以B的BR104这个P这个产品为例啊。

我们可以看到的话呃，从这个LP32这个TTF32包B16啊这些常见的这种算力这个性能是非常高的啊同时也有这个相关的这种专用的这种互联的能力。那这是单卡的一个性能。

对我们大模型需要从1到100到1到1000的吧这个后展。所以我们看在这个呃系统层面比如说单机8卡为例的话，怎么去提升这个单机的性能。那这里我们举了两个例子。

这种拓扑哈第一个这种PC的这种标准形态的这种加速卡。那这种卡一般来说是没有这种专用互联的能力的那在这之上我们是做这个blink的技术个桥节卡是可以提供额外的这种高速互联能力。

所以这其实对大目积场景是非常有有利的啊那第二个是这种OM形态的这个加速卡。因为这种卡呢它相对来说它的功耗更高一些，可以去呃支持更多的一些互联的端口。😊，啊，所以整体在系统构建上面。

它可以提供一个呃更好的一个互垫能力。那这里比如说举个例子，像可以构建这种环形的top扑啊，甚至是这个全互联的top扑啊，提升这个单机内部的一个通信带宽。😊，那有从单卡到单机，对吧？还不够。

我们要怎么去扩展一个集群。那这里怎么去打造这千张卡这样的一个一个大功模的集群。所以整体这个集群的设计，我觉得有几个理念嘛。

第一个是说啊是这种二层的一个clo的网络能够去保证这个集群是这个网络是没有收没有没有收敛的哈对，然后第二个就是说在可以有很好的可扩展性。啊第二个点第三个点就是说我们这个网络设计要要有一定的这种可靠性。

所以基本上每个呃这个这个机器有多个网卡，从数据面上是可以更可靠。那同时呢它也可以提升多机的这样一个呃通信的一个带宽。那这是从硬件层面去看哈。但是实际这个系统里面不是说光有这样硬件就可以了。

我们在大模音做策略的时候，包括我们通讯库在通信的时候，你怎么去呃利用这种不同的网卡的这种并行加速能力，怎么去在集群里面避免这种链路的冲突啊，减少这个网络的一个影响。

其实跟调度啊跟这个通讯库其实都是非常紧密相关的啊。😊，啊那在这样一个基学习平台的过程中，我们管理数千张这样的GPU卡。如果一个集群里面有不同的任务。那这个实上会更复杂。

其实刚才这个9鼎的这个同事也分享过，对吧？当你平台的任务种类很多的时候，你怎么保证资源的一个效率，同时保证大模型任务的一个一个稳定性所以从效率我们希望说大模型的任务能够尽量的聚焦在这个同样的交换机下面去提升这个通信的效率。

但如果集群的任务很多的时候，小任务混杂在里面，这个目标就达不到。所以我们需要构建这种任务的这种迁移的能力啊，将小一些这个资源碎片啊去做一个整理让这个空闲的资源尽量集中在这个交换机一个交换机下面。

我们去便于调度大模型的任务。那同时我觉得大模型的任务其实OPT为例哈，就是他们内讲整个一个训练的过程中有35次手动重启100多次故障对？说故障力很高。那大模型任务就非常容易挂掉了。

所以这个你怎么说在任务出现问题的情况下我怎么去解决容错的问。😊，题。如果我能够去进一步的这种自动伸缩，那么从资源效率就能够提供很好的一个保障啊，所以这些其实在真正的生产环境中，在大规模集训中。

其实要解决很难的问题的。😊，好，那我们这里举个例子，比如说基于这个避认这个我们104P这个呃GPU哈，我们怎么去做这种千亿参数的这种大大模型的一个训练。那这里我们可以看到这个load零的这个特点。

单机8张卡。那我们在四卡层面去做tenser并行。为什么这么做呢？因为tenser并上对通信的要求是比较高的，通信量比较大。4卡我们这个互联是这个带宽是非常高的啊。

那在单机八卡层面我们去做两级的流水线并行，因为流水线并行对通信的要求相对会比较低那，这个可能在系统层面它其实是不会带来什么这个性能这样一个一个副作用，对吧？

就有效的避免这个就是可能的一些硬件上的一些不足吧。😊，那单机如果放不下这个参数的规模，我们需要通过多机啊层面去通过进一步利入线去做这个参数的切分。能把这个模型能够承载下来。那当我们把模型承载下来之后。

如果我们为了更进一步去提升这个训练的性能，我们肯定要增加更多的机器。这个时候可以选择DP或者说P进一步的去去这个提升性能，同时如果用0的话，它有个好处它可以进一步的去做这个参数的切分。

能够降低这个单卡的一个显存的一个需求。那如果我了显存呃这个可以需求降下来之后，我们可以提升 size。那么它又进一步可以提升的计算的效率。所以我们看得出来，其实整个系统中很多变量啊。

你怎么把这个变量在这个固定的资源和模型规模情况下怎么利用好，其实是对性能是有很好的一个帮助的啊。😊，呃，那大模型的一个产业生态合作，我们可以看到，其实前面讲从这个算例啊，从这个继续学平台包括框架啊。

以及这个上面的这个甚至大模型的框架还包括模型整个技术站实际上是比较厚重的哈。那所以这种呃想落地其实也是有难度的。所以我们在这里也是跟这个更多的合作伙伴一起去打造整体的一个解决方案。呃。

那这里呃我们跟智源研究院在刚才讲些flag open的这个呃大模型的技术开源体系里面，并竟也是深度参与进去的。我们依托这个呃这个科技部的这个相关的项目。

目前我们正在开展感谢呃前面讲这个AI编辑相关的一些工作啊。😊，那第二个我们也是在这个支援的这个AI开放实资源实验室里面去做这个国产这个芯片和大模型的这个一些适配啊和落地应用的一些这个工作。对呃。

那另外一个我们再跟呃百度文星这边也是个比较紧密的合作。呃，因为我我之前一直在百度哈，所以呃这种相对合作会比较紧密一点。像目前跟百度飞讲这些模型适配啊，包括文心的一些基础模型适配，我们都已经做起来了。

所以后面也会一起的这个开展这个呃行业的一些落地应用。😊，那呃除此之外，我们在一些产学沿用的生态们也做了一些工作。呃。

我们和这个上海交通大学和呃包括达摩院呢呃在这个科技创新203年的这个新一代呃人工智能的重大项目中，呃，这个项目是这个大小模型这个端云协同进化与系统。

那我们联合基于避刃的这个国产GPU去打造这个大模型的训练平台和这个相关的这个呃这个落地示范应用啊。😊，呃，呃当然了。

我们现在也还在跟一些这个啊最终的用户啊在呃一些战略合作伙伴在开展一些这个大模型的一些这个这个相关的适配和落地应用的合作。啊，当然我们也希望跟更多的合作伙伴啊能够一起这个共建这个大模型的一个产业生态。好。

谢谢。😊。

谢谢谢谢丁总。那呃我们呃下面请来呃下一位呃speaker，来自media的高级总监呃，赖俊杰、赖博士，谢谢。😊，大家好，我来自 NVDdia。

然后也会用中文介绍 but before my presentation in Chinese I would present in Chinese I want to share something interesting in English first because know some speakers mentioned some keywords like IBM cell and in area because I was doing my internship at Yonghua's team 15 years ago at IBM on sale on sale current optimization and everything and then I got my PhD job from I。

In Han on NviDdia GPUs performance modeling and analysis then I got my job at NVDdia so。

This is I feel it's very interesting， you know how our lives cross together at today's forum， okay。行。

那接下来的话还是用用用中文介绍。然后我这边PPT比较少，一共8页啊，然后核心的话就一页，所以呢就是时间肯定应该来得及。呃，这一页的话就非常简单的介绍一下。

就是说呃那个大家就是呃比如说今天可能主要讲的就是我们如何能去更快的更方便的去训练出来这样的一些特别是一些大模型。但是呢就是刚才那个呃就是也有嘉宾也讲了，就是在实际的这样的一个工业场景里面的话。

其实有很多很复杂的一些问题。我举个最简单的例子，就是我们最近一段时间跟我们的很多客户在合作的一个事情，就是什么呢？就是呃那个比如说我们去跑一个1000卡，2000卡。

甚至更多卡的这样的一个一个一个一个一个大模型训练。那很有可能我跑着跑着就挂了，对吧？然后呢，就是呃就是甚即使是我们非常呃用我们的GPU也好。

用我们的这种呃就是很大的机器群去做这种模型训练的一些公司很大的互联网公司。他们在一开始的时候，就是可能在H出现之前，一般呢也没有那么大规模的这样的一些。😊，就是GPU去做这种分布式训练的一些经验。

那换句话说，就是可能从今特别是今年开始，我也发现呢，比如说我经常跑这样的一个很多量卡的任务的时候，可能我跑个几个小时啊，我这个这个这个这个这个这个任务就要重启这个就是中间遇到的问题可能是多种多样的啊。

有可能是比如说我们的所谓的GPU的卡掉了啊，有可能是比如说我们的网络这边的话，就是有有可能他一个link啊就坏掉了啊，有可能是我们的这个存储，甚至存储的这样的一个管理软件就是不响应了等等。

所以就是说实际的这样工业场景里面的话，它的问题会非常非常的复杂。然后呢就是我们呃就是刚才讲了，就是可能跟我们的很多这种呃那个工业界的客户合作的其实某种程度上第一件事情就是要花很多的这样的一些精力。

能让这样的一个大模型训练的任务的话，一个呃相对稳定。用的方式的话，运行足够长的时间。打比方说一个周啊，一个周的话，比如说我我遇到一次故障，或者说挂掉一次。

那我花个半个小时时间把这个job重新launch起来，还是比较能接受的。但是如果说你跑两个小时就要挂了，然后再花半个小时给它冲启这个工程上的话，就会就会非常的费劲嗯。那么就是呃甚至呢就是说呃。

还有非常非常简单的就是呃我我我比打比方说我这个任务挂了，你甚至要知道哪个地方挂了，都是一个问题，对吧？就是那么多的机器，那么多component，那么多的这样的一些部件，到底哪个东西坏了。

所以呢就是甚至是说像如何能够高效的就是用很多不同的软件，你要去监控的GPU要监控你的网络设备的，就用什么样的一些软件能够及时的发现到底它是什么样的故障。我这故障的话，是这个这个卡就是坏掉了。

我要去走一些这种换货的流程，还是说我把这个什么就是比说我的风扇速度调快点啊，就是让它温度尽量的控制在比如说70多度不要到达80多度这样的情况。

它就能继续稳定运行等等这样非常非常多的这常复杂的这工程上的问题。那么现在的话一般来说大家是怎么做呢？比如说举个例子，就是我们要跑1个124卡的这样一个部门训练的这样一个任务啊。

那么有可能呢我会去一个比如说1200块卡的这样一个池子。然后呢就是在。😊，开始的话我会去做一些alal check，就是让这些GPU去啊跑一些。

比如说一些memory intensive或者说comp intensive的这样的一些workload去看一下。比如说这就是先选出来1200张相对来说比较健康的这样一些卡。

然后呢我开始运行运行到20天之后有可能挂掉了啊，有可能这个任务挂掉挂掉之后，如说我要找到哪个地方坏了坏了之后，比如说假说是一个GPU的问题。

那么我把这几个呃GPU对应的这样的一个serv给他从这个池子里面1024这个子里面拿出去。从刚才的那个大的池里面还闲置那个点抓过来几个完了之后，从我的存储里面的话。

把我 checkpoint进来重启这样的一个任务啊，所以现在的话一般是这么干的。😊，呃，产品介绍我就不介绍了。然后呢就是这个地方的话稍微提那么一点点，就是大家可能就是呃就是可能用的比较多的。

或者说比较熟悉的是第一个就是那个M这个是一个开源的这样一个项目。就是那个就是也有很多其他的一些工作，借鉴了这样的一个开源项的一些思路。

然后呢就是当然就是这个这个开源项目的话也借鉴了很多其他的比如像等等里面的这样的一些一些工作。呃然后呢就是后面两个的话就刚才我说我不介绍了。

就是mo的话是我们的一个那个就是做自然语言语音的这样的一个呃开源的一个ki，然后最后那个东西的话就是叫mo framework就是这个的话是一个可以说是一个企业级的这样一个产品。

就是这个地方就是为什么稍微提一下呢，就是说还是那句话就是工业界的这样的一个实际的这样一个用户来讲的话，他不是说我有一个开源的项目放在那个地方啊，就可以了。就是他经常的问题是说。呃。

那比如说我甚至是我有一大堆的数据，我这些数据的话，该怎么去呃处理一下，清洗一下。然后呢变成我这个后面的这样的一些训练们可以呃用的这样的一个呃格式，甚至是这样的一些问题。

还有呢就是甚至问题是说啊我要去那个大模型，比如说那个40个 billion量还是多少的，我该买多少块GPU或者用多少服务器，我中间是用rocky还是用fin band。然后呢我这些超餐的话。

该怎么去设等等。这样的一些非常非常practical的问题。所以呢就是说这个产品里头就是对这种企业级客户的产品里头话。

会提供各种各样的这样的一些工具去帮助这些企业级客户去更好的去做这样的一些大家可能觉得比较傻瓜的这样的一些选择的这样的一些问题。😊，呃，NV linkN switchitch的话，我也就跳过去了。呃。

就是这一页的话稍微多花一点时间，就是可能是呃那个比较核心的这样的一个部分。就是说呃nemo里面的话一些呃呃呃nemo呃就是megaronLM或者说nemoron就是。呃，总之就是NV这边的话。

针对这种大模型，特别是这种transformer based的这样的一些呃大模型的话，在呃像各种各样的这样的一些并行策略的面一些核心的一些呃做法。呃，然后呢以及他的背后的一些想法或者说逻辑。

第一个的话就是最熟悉的最简单的就是数据并行。数据并行这边的话就是我也我也不讲了，就是说这个大家应该呃就是非常容易理解。就特别是呢在一开始我们所谓的去做呃开始的，别是开始一些CV的这种模型训练的时候。

那比说一块卡得比较慢。我用2块卡4块卡8块卡16块卡的时候，那最开始的大家肯定先奔着这个来的。然后呢就是特别是这种呃大模型的这些事情出来之后呢，就是逐渐发现的话，数据并行的话。

它它会有一些呃固有的这样不能说是缺陷啊，一些一些挑战或者问题。因为什么呢？就是说假如说你的数据并行的这样的一个你GPU也好或者说计算的这样的一个个一个节点也好比多了之它就意味着什么呢？

你要么是说你这样同一轮这个要非常非常的大，要么就是说那个我这个就global这个不变的话，你分到每一个GPU上的它这个这个这个的话就别。😊，小那么呃大家也都知道，现在的这样的一些处理器的话。

它处理能力比较强，里面有很多这样一些计算单元么之的。如果说这个太小的话，你这个GPU利用率就上不去。以呢就是为什么说像数据并行这条路的话。

开始的相就是就是用的卡也好这种这种服务器少的今的话就是光靠数据不才有了模型并这件事情是刚推出来的时候主要是做的第二个图这个工作。

就是刚才有嘉宾也介绍了就是像这各种各样横向的纵向的这样一些切分这个地值得提一下的就是刚才有一个图就是云帆这边那个就是那个个事情。就是模型的的话那最简单的逻辑就是这个网络纵向切就P放个放个就是中间。😊。

的话就是他肯定有个消息传递的这样一个过程啊，但是这样过程的话，就是那有那个那个图的话，大家稍微回忆一下，就中间会有一些灰色的这样的一些区域，就是就叫叫bubble。但实际上来说的话。

就是呃不管是那个microofIM还是其他的这样的一些呃做这种大部型分布式的这样一个框架，其实做了嗯就是比较嗯。😊，比较比较比较比较聪明的这样一些策略。然后呢就是来去呃就是尽量的让少一些。

打比方说是什么呢？就是我们最直观呃容易理解的就是说刚才说的比如说把0到3个放到PU上，然后呢就是4到7放到GPU1对吧？但是实际上来说的话就是说我们在就是说我去的候。

个PUU的放置的话并不是这样的一个就是呃从从最简从最低到高这样的一个线性这样切分的。实际上的话把它稍微打乱一下完了之后的话就是等等啊用这样的一些那个就是所谓的调度上的这样的一些策略能让尽量的让他那个灰色的区域一点。

然后呢就下面两个的话是NV这边就是比较新的一些工作。实际上去年的话就是才。那个那个发表的一些工作，就是呃那个呃就是一个是呃就是呃就是这两个的主要工作，它的主要目的是什么呢？就是说我们其实大家也都听到。

比如说有很多其他的工作，它的主要目的是说让GPU存或者GPU的量一定的这样的一个情况下，我能尽可能多的尽可能去训练更大的这样的一个模型。换句话说就是尽量的减少我这样的一个呃对于显存的这样的一个消耗。

或者是对显存的这样一个press。这两个工作的话主要也是做类似的工作。但是呢就是NV这边的这样的一个spoint是什么呢？就是说我在基本不影响我最后整体的compute efficiency的前提下。

我能够如何去减少对于GPU memory的 pressure啊，就是这两就是这个这个这个NV这边工作跟其他的工作最大的这样的一个出发点的不同。呃，然后呢就是呃sequence parallel。

它主要指的是什么呢？就是说我们那个transformer的。呃，一系列操作啊就是前面的模型并型的话，主要是在呃attention那些lay，还有那个MOP或者说那个前项的那几个 layer上面做的工作。

但是呢就是像 norm out这些东西的话，就是他对于计算的过程中前后显存消耗比较大。但是呢就是之前的就是你就是没有办法去做这样的一个模型并or parallel或说 parallel去做。

但是呢就是说我们现在是做的是的好处就是说你在sence的这样的一个方向上来看的话，实际上就是它一个sequence来看，它的这个计算是independent。

所以呢就是说sence是在sence这个这个维度上然再给他切几刀分成分给不同的几个PU它去并行了去算。呃，最后那个selective activation recomp是啥意思呢？

就是说呃先说那个activation recomp就是呃。为了减少对于呃就是activation，就是激活这些呃对于显存的占用呃，其中有的方法是什么呢？就是说。

我在呃一些呃就是我我我我我在显存里面保存呃一部分激活值。然后呢，就是呃比如说几层 layer，就是它的输入的那个那个激活。再算就是后项的时候，因为要用到所有的这样的激活值。那么我在做后项传播的时候。

我临时的去重新去算那些就是激活值呃就是这样子的话就是说它的核心的话还是那句话，就是说只保留一部分激活值。这我可以减少对于显存的这样的一个压力。但这样的问题显而易见的就是说我增加了大量的重复计算。

所以呢就是说NV这边的selective activation的话，它主要的区别就在于是说。我不是把就是不是这样非常粗暴的。

就是我我我就呃保留一部分就是某一些 layer的一一组 layer的这样的一个输入。而是呢看一看，就是我整个的这样的一个特别 transformformer这样的一个前项后项的计算过程中的话。

有哪一些 layer或者操作的话，它对于显存的占用比较高。但是它对于计算这块的需求比较少。呃，然后呢就是呃换句话说就是选择某一些特定的这样的一些层或者操作去做这样的一个呃activation的这样的一个事情啊。

这样子的话的好处是说我计省了一些显存。但是对于这种额外的计算的开销啊就比较少。那就是呃细节我就不讲了最后达到的一个效果是什么呢？就是大概就是我能省就是activation啊。

就是能省一多半的这样的一个activation的这样的一个显存的占用。但是呢对于计算的呃额外的开销的话，大概只有12这样的一个量级。所以呢就是说在这个地方稍微重复强调一下是什么呢？

就是NV这边的这样的一个stand或者做这些工作的一个核心的这样的一个点是什么呢？就是说我要去尽量的降低我整体的这样一个效率，尽量减少对显存占用。

但是一个前提是尽量的不减少整个计算系统的一个 efficiency。嗯，OK那个最后的话就是稍微做一个小的广告，就是我们这边在招人。然后大家的话如果有感兴趣的，就是说可以直接联系我们的那个呃那个HR。

然后呢，就是呃报一下我名字，应该能找到我这边。好，谢谢大家。😊，呃。I will comment the the early his beginning said his internship inI will comment that in the the the last session of thisO呃哎呃那我们今天呃请来呃下一位演讲者下一位演讲者是来自呃中国电信的李经李总。

谢谢。😊，嗯，大家好，我是最后一位。好消息呢，是等我讲完了之后，午饭就来了。但是不好的消息呢是大家必须要听我讲完，午饭才能来。😊，那个我呢是在中国电信呢一直从事云计算和计算平台。就是换句话说呢。

就是咱们大模型的底层的计算平台的构建的工作了。今天呢也是想跟大家在这个场合呢要聊一聊，就是基于大模型训练的这种高并发文件的一个访问的深度的一个优化。因为今天咱们在众多的演讲者中呢。

其实有不少同事都要提出来了，是说在我们如何在算子方面，在GPU方面，包括在模型方面，我们不断的去进行优化。其实最终的一个目的呢是说在模型越来越大的情况下。

那么我们如何能够高效的来提升我们的整个模型的效率达到一个更好的效果。呃，这个就不细说了，因为是整个大模型的发展趋势啊等等。其实大家都说的很多了。但是我在这里面其实想从另外一个维度来说的是说。

就是无论是说我们现在从通用大模型，然后到往后通过我们对一些特定场景，包括对数据的一些抽象来构建。面对某一些具体行业的这种行业模型，乃至于到这种特定的一些场景的模型。

乃至于说我们从最早期的这种单模态的模型，一直到现在随着客户的需求进入了多场景，多文件的引入以后，形成这种多模态的模型之后，其实我们发现在最底层呢，我们能够看到的是模型发展的趋势呢。

那就是它的参数的量级会成几何级数的增长。举了一个例子，在图的最最右下角吧，最左下角就是那种大模型从就是我们拿GPT来举个例子，可以看到它的参数量级呢，从GPTR一直到未来的GPT5。

的时候我们可以看到它的参数量级是乘几何级数在往上增长的。那么在几何级数往上增长的参数量级之下呢，我们看看会发生一些什么样的一些变化和对底层的存储等等这方面会产生一些什么样的需求。首先呢参数量级增长之后。

我们第一个能够看见的是它对参数量级的增长呢。那首先它是对我们训练数据的需求量就会越来越大。我们可以看到从几十个G一直到几百个几百个T，乃至于几千个P，类似于像这样的一个一个量级。

并且呢随着多模态的需求出现之后呢，我们可以看到呢，就是说原来我们都是从单一的文件。包括这种小文件，以及呢是类似于像这种那种结构化的数据，然后逐渐呢像类似于这种多模态的。

然后非结构化的数据的需求量会越来越大。那么再往下对底层的影响，我们就可以看到了。首先呢是原来我们。对底层呢用rom或者本地磁盘进行就能够进行存储。但是随着模型的参数量呢越来越增大呢，那么。本地的磁盘。

还有rom呢，其实永远是已经不能够支撑它了。那么从存储的量级上面，我们从T开始，可能后面一直要到。几十P上百P。那么我们对于这种存储的介质对它的要求就会越来越高。并且呢对它的带宽，以及呢对它的访问。

我们常说的IO这方面的要求呢也会越来越高。那么在这些变化之下，我们看到它的挑战是什么？我们大概总结归纳了一下，看看有几种挑战。一个呢就是对大容量存储的挑战。大容量存储的挑战呢。

我们现在可以看到呢就是从单模态走向多模态之后，对存储容量呢，它带动的就是我们的存储可能已经从本地的服务器开始要逐渐逐渐的走向专业的这种外部共享的一个存储。并且呢这种存储一定是要能够灵活的去扩展的。

一定是能够灵活的去扩展的这种方式。第二个呢就是高带宽和这种高IOPOS的这种IOPS这种挑战。因为在大模型的训练的过程中，需要更加快速的加载去种海量的小。文件的训练数据。

同时呢我们要因为GPU卡都很贵嘛，所以我们要降低成本，那么要尽量的去减少这种GPU卡的这种空载的等待的时间去提升这种算力的利用率。包括我们在看它在中间态的数据的时候。

他需要快速的去把这种中间态的数据去往存储里面去写。那么在这种情况下，一方面呢对带宽的需求，还有对那种高速并行的读写的需求的挑战会越来越大。最后呢就是还有这种可靠性。

因为前面也提到了存储介质的容量越来越大。那么在整个模型里面。存储接制的容量大了以后，像这样的存储，它的可靠性，其实直接决定了我们在模型在训练的过程中，它的一个效率和一个它的可持续性。

因为一块盘出存储的量大了以后，一块盘出了问题以后，它可能会对整个的数据的影响，就比以前那种小存储的影响会大很多。那么我们看到这几个挑战之后呢，我们看看。我们在实践的过程中，我们是如何去应对这些挑战的。

呃，中国电信呢是我们一直在致力于这种面向大模型训练的底层的支算平台的搭建。在这种搭建的过程中呢，就是我们可以看到这是一个技术的一个一个一个一个框架图。在这个框架图里面。

我们看到就是我们从几个方面去采用了一些实践中的一些措施呢来应对这方面的挑战。首先呢是应对这种大容量的存储的一个挑战。那么显然大容量存储，我们应对它的最好的方式呢，那就是。这种分布式的架构。

因为我们通过分布式的架构，可以把原数据呢往在我们的架构里面的多个节点里面去存储，而且呢可以通过类似于这种那个。积木式的这种扩容的方式。

就ing block这种方式呢来进行灵活的一个一个积木堆叠式的一个一种扩容。这样的成本呢就有一个极大的一个降低。目前呢可以做到的是能够达到了容量上达到1个10P这么一个一个量级。第二呢那就是针对高性能。

还有高并发性的这方面的一个挑战。在这里面我们通常呢是通过几个方式来去做几种措施吧，来去来去来去解决目前存在的问题。一个呢就是那个GDS，还有呢就是包括智能的预加速，还有那个类似于客户端的加速。

这个呢在后面的篇幅里面，我还会去说，在这里面是想说的呢是就是在网络层面上面在构建这种算力平台的时候，我们同时能够支持目前能够支持的是IB网络和roy的网络。我们通过这种高速带宽的网络呢，把这方面。

因为网络带宽导致的。瓶静的去极大的给它去降低。同时呢就是在最底层的时候，在存储介质上，我们现在广泛的在使用基于这种SSD的全闪的存储的方式。当然了，大家也知道就是这种方式的成本会比较高。

相信在未来的一段时间，随着成本的这方面的降低呢，我们为这种大模型的训练，它所提供的这种底层的架构的时候，那成本也会大幅的往下去降。那么在应对这种高可靠性的挑战方面。

HA的方式其实是一个相对比较目前看呢是比较成熟的这种这种方式。同时呢我们也通过这种类似于动态的纠缠码和缩列重构的这种方式来保证它的数据的一个可靠性和数据在丢失了之后的一个一个重构。

包括像硬盘的亚健康的管理。这个后面呢也会有一个详细的介绍。那除了刚才说的就是在硬件上面，还有带宽上面的一些应对性的应对性的措施和实践之外呢，那么说一下呢，就是从软件层面刚才也说了，在这个在这块呢。

我们要想讲的一下呢，就是说中间线现在我们也进行再进行开发呢，是什么呢？就是一个智能的预加载的一个方式。我们通过智能预加载和缓存加速这种结合的方式呢。

希望能够加速的是通过加速的是它的数据的一个提前的一个存取一个一个读取。因为我们也知道就是。就是就是我们想通过这种预加载的方式能够做到什么呢？是说。我们通过去观察和去学习在大模型，它去读取数据训练过程中。

它的行为方式，包括他哪些数据的经常读取的一个频繁度。我们通过这种方式呢来进行下一步的预测。我们去预测哪些数据，它能够会相对比较热门，在下一步的训练中，它能够会去读取。那么通过这种学习之后。

我们把大量的这方面预测的数据会提前抓到的系统的缓存里面去。抓到了缓存里面去之后呢，就是通过通过这种方式，显然呢你在模型有需求的时候，他发起了发起需求，它直接去向存储介质去读的时候，这个里面会产生。

在这种这种方式下面会产生一个延迟。那么这种延迟在数据量大的时候，其实这种延迟在整个系统里面的开销的时间，其实这是需要格外关注的。那么通过提前读取到缓存里面去之后呢。

其实某种程度上能够把这种延迟极大的去压缩。通过压缩之后，其实变相的也是提升了我们的训练的一个一个效率。另外呢就是在GTS方面，就是大家看这张图，呃，在传统的读取方面呢。

就是当GPU要去读取存储的数据开展训练的时候，通常的CPU是要参与到这里面的工作的。CPU要负责的是在数据的处理和数据的传输过程中，它都要分配资源，它进行控制。那么现在呢像英伟达呢。

现在它是把这方面的功能呢，它是做到了GPU的底层的芯片里面去。换句话说呢，就是GPU呢，它不通过要读取数据的时候它不通过它不需要通过CPU的干预来进行读取。

那么我们在开发中国电信的HPFS就是高性能的文件存储系统的时候呢，全面的去适配了这种GTS的能力。那么我们也是在HPFS的客户端。然后通过GDS的那个酷fi的库呢，然后实现了对。对。

请求端呢对GDS的一个支持，像GPU直接去发取发出那个调用的指令。然后在服务器端呢，我们通过这种RDMA的方式呢，然后通过它呢是实现了对GDS的支持之后呢，去直接形成了那个数据的一个读取。

通过这种方式呢，其实变相的也是能够增加了一方面呢数据的带宽。另外一方面呢降低了它数据读取的时延，同时还有一点好处呢，就是因为CPU不再参与这个读取的工作。实际上通过GDS呢，我们是绕过了主机的内存。

还有内核的协议站，通过这种方式呢，相当于是释放了一部分CPU的资源。那么释放出来资源干嘛用，在给其他的算力任务里面去给其他去给其他算力算力去去做资源的使用。

其实变相的我们也是降低了这个CPU的它的一个一个资源的一个使用。那么在它的稳定性方面，我们通过除了刚才说的措施之外呢，还有两个措施。一个呢就是通过动态纠缠码的方式，就是动态纠删码。大家都知道。

就是我们把数据在。海量的存储里面，我们切块，切完块之后，通过加入冗余的那个冗余的数据之后呢，我们通过合适的这种那个纠缠码的方案，我们把它分布在了各个节点上面去。

这样呢一旦某一块盘或者某一个数据丢失的时候呢，我们通过纠缠码的方式可以保证它数据的一个就是降低它的数据的一个丢失，并且能够保证一个数据的容错性。就是我们可以看到呢在3块盘丢失的情况下。

我们通过动态纠缠码的方式，可以把它对业务的影响的概率。就是如果要是比如说我们现在列出8个T的话，它影响的概率能够降到8。57乘10的-11次方，这个就已经很小了。

然后我们可以做到整个的系统的稳定性能够保持在12个9以上这么一个层面。并且呢在应用了这种缩列重构的方式之后呢，就是当我们某一个。比如说存储的集群里面某一块盘出现了问题之后。

那么我们去调整整个的它的数据片的大小，然后去重构这个串。那重构了串之后呢，相当于是这一块盘就退出了。然后通过通过重构串之后呢，数据呢，它一样呢是可以保持一个冗余，而且不间断，做到了一个不丢失。

而且就是即便丢失之后，我们通过其他的算法能够给它进行恢复。并且呢当这块盘恢复了之后，我们可以通过它自动重新进入到集群之后，我们再去调整它的。数据列的大小，让他加入到整个的集群里面去去恢复工作。

通过这两种方式呢，能够去保证我们整个的数据的一个安全的可靠性。然后还有呢就是因为前面也讲到了数据盘越来越多。数据盘多了之后呢，就是大家在使用这个数据盘的时候都知道，尤其使用时间长了之后。

数据盘的稳定性会降低，它经常会出现坏盘。一旦出现坏盘，并且就数据的介质越来越大的情况下，它出去坏盘。那么它会对整个数据的存储的质量会产生这种宏观性的影响。那么在这种时候。

我们也是开发了一套模型来进行训练。当然这个里面也很有意思嘛，就是我们通过训练的模型为模型的训练来提供来提供支持。那么它要做什么呢？它就是我们对所有的这里面的盘进行监控和检测，你包括它的温度，它的震动。

它的访问频率，它的IO等等这些来进行来进行检测和记录。这样呢现在能够做到对它的各种工况的读取之后进行综合分析。

我们能够做到提前14天能够对这块盘未来的工作状况进行预测。当我们发现它的IO降下来了之后，通过分析，我们可以把这块盘这块慢盘从整个的集群里面给它隔离出来。相当于是我们做了一个宏观的调控。

把它隔离出来之后，这块盘出来之后，那同时就是刚才前面讲到的动态纠缠码和缩列重构的方式的机制又开始起动。这样形成了一个系统化的循环，来保证整个数据的一个高的一个可靠性。那么说到最后说到最后呢，就是。

在整个的内存，我们面向大模型的实践过程中呢，就是我们在提高存储的一个效率的工作中呢，就是我们完全依托的是中国电信开发的这个天翼云的云销计算平台来实现这一系列的措施。从这个框架可以看到呢。

就是通过云销的计算平台。我们在底层将计算存储网络等一系列的节点来进行封装。然后通过天云的操作系统和云销计算平台的这种调度系统。我们把它进行封装了之后。

面向客户能够一体化的来提供一体化的来提供类似于网络计算带宽。然后包括模型辅助，还有等等相应的一系列的工具，向客户来一体化的来提供来提供这方面的工作。然后也是希望呢就是后续有机会呢，大家能够来试用呃。

天翼云的这个云销的至算平台，因为时间限制呢，就是具体的功能就不介绍了。时间很短。其实在这里面呢有很多是可以深入展开来深入讨论的。也是希望呢就是后续有机会线下的时候。

我们一起来进行在这方面的一些技术层面的深入的一个一个沟通。呃，我想介绍的基本上就这些，谢谢。好呃，这个不是最后的一个speer啊，因为我们cancel掉了那个panel。

所以我们把panel呃前面没有讲的呃，天数至星的，我们还是邀请他上来做一个很简短的一个 share。😊，好，谢谢呃。😊，呃，很荣幸啊成为最后的呃压轴的speaker。

然后嗯耽误大家最后在呃7到8分钟的时间。然后呃简单介绍一下我们和智源在大模型上的一些合作，以及天数之星。在大模型上目前已经推出了一些呃solution的方案。😊。

那呃首先很感谢智就是天视心作为GPGPU的这样一个厂商，实际上和智源有很深的合作。呃，就像刚才前面白博，然后田老师所介绍的。我们在AI芯片AI的呃编译器，然后还有九鼎的评测平台以及大模型的训练上。

这际上做了很多的深入的工作。那这一次呢我们和智源实际上一起输出了一个呃的呃code7B的模型。那这个模型的话实际上是智源基于天数的呃BI100的呃集群。然后来进行训练的。

然后这个训练的数据参数呢大概是在100B的这个呃代码之上来进行全量的一个训练。然后做一个pre的工作。这个整个工作在19天的时间里头来完成。最后来输出了一个呃这样子的模型。😊。

整个模型的效果呢也能达到呃human evaluation at onepas at one的话大概能到呃19超过19这样一个数。实际上在同级别的模型尺寸上面呃是一个呃达到一个Sso的一个水平了。

那在整个的这个合作里头，我们会发现说在大模型的训练里头，实际上呃芯片作为国产芯片来说，作为呃计算卡来说，那么通用性，还有一0一性是第要第一重要的点。那我们在整个这个工作里头，实际上从支援从英伟达的集群。

然后我们来支持这个BMtrain，就底下的分布式系统用的是BM train这样一套方案，从英伟达的集群，然后迁到天数的集群里头，就迁移的时间其实就是一天的时间就跑起来了。那当然这迁移之后。

实际上我们会发现集群的性能并没有达到我们所期望的那样子一个能力。那这个时候就要需要做对attention的算子去做优化。在flash attentiontention上面。那我们可能。

基于我们的通用性和易用性，我们在呃ku大层面去做了这个算子优化，包括了一些呃底层的OP，减少一些reduce。就是在这样子的优化之后。大概一周左右的时间，那整个集群就完全的跑起来了。

实际上整个的工作大概是一个月的时间。大家会看到说通用性和易用性一迁一性在这个里面是占了很重要的作用，才能保证在一个月之内完成这样子一个大模型的呃训练，并且得到一个相对比较reasonable的一个结果。

😊，然后第二点，我们在这个大模型的整个训练过程里面，我们会发现说呃集群的可扩展性实际上是第二重要的点。刚才其实前面有很多呃speakker都讲提到了，那如何去做这个呃在一个算例，然后因那个网络拓扑。

然后并行文件存储。这样子一个系统里头，怎么能够在这些点之间找到一个平衡的一个sweetly point的点。这个point的点能够让集群的可扩展能力最大。因为毕竟呃国产芯片。

整个集群在单卡的算力上跟NV的主流卡还是有差异的那可能靠的就是多机的这样子一个堆叠来追赶这样子一个整体的性能。那在这个里面，我们实际上有一套天数之星有一套完整的方案，我们做到了一个什么事情呢。

就是在整个集群的可扩展过程里头，随着节点的增加，我们可以一直保持呃，这个集群的效能在95%以上，就是线性加速比在95%以上。呃，这是第二个很重要的点。第三个很重要的点其实就是稳定性。

大贸型的训练的周期很长，整个的呃权中间的就是要保存的权重很多。然后数据要加载的量也很大。那在这个训练的过程里头，实际上天数之星保证了一件事情，就是在19天的时间里头是没有任何一次掉卡。那保证这个。

整个模型的训练能够平稳有效的smooth的往前走。这个是我们在整个过程里面所看到的。呃，在大模型训练上，我们和居恩一起合作，能够做到的一些点。然后呃回过头来呢，从产品的角度来说。

其实天数之星因为已经发布了三款呃新新那个卡，所以基本而且是量产了。那在这种情况下，我们实际上已经覆盖了AI的训练推理，还有科学计算，整个这个领域。那在大模型的训练的角度上面，实际上我们有完整的方案。

这个方案可以覆盖pre train的工作，可以覆盖呃PFT的fin tune也可以覆盖p tuning的这样子一些简单的呃优化工作。那这个是然后同时由于我们能够支持。呃，不同的分布式框架。

就除了deep speed，然后BM trainclo AI，然后还有micac这样的一些框架。我们在底层能够支持这样框架。所以我们可以做到一个很重要的点是能够很灵活的从单节点扩到数百个节点。

这是我们已经可以支持的呃，这样的一些开源模型的一些训练的工作。然后在推理上面的话呢，我们实际上是呃能够支持，也这些是我们目前已经支持的一些主流的一些大模型的一些个情况。

那会看到最重要的一个点就是我们能够做到在。呃。因为推理的时头其实最重要的一个点，实际上是多轮任务的多人同时对话。那在这个里头。

实际上大家知道在attention里面其实很重要的一件事情是你要不就是怎么保持上下文，要不就是在attention status，你怎么把它保存下来。然后当发现发生了用户切换的时候。

最后这个这个前一个用户的呃session status还能保持住。那在这上面我们是有完整方案的。我们可以做到在这个完整方案上多用户呃高并发的情况下。

我们可以做到呃我们的一体机可以做到800 tokens每秒啊，这也是一个我们呃独特的一个地方。😊，呃，整个的在底层就是大模型的支撑上面，其实呃天数之星实际上是做了很多的呃不同的工作。

就呃从硬件到编译器到呃分布式文分布式的这个训练系统，然后再到上层的应用的优化，实际上是呃包含了很多的步骤。

然后特别是要提的就是像现在的flash小小个子ex transform这样子一些算子我们都已经支持了。而且这个支持的话，对于上层应用用户来说，你用来调用的时候，你是无感知的。呃，最后说一下。

我们可能对未来的一个展望，就是在大模型训练里头，我们也会发现，实际上会碰到呃新的一些问题。那第一个问题其实就是算子的优化的问题。

那其实昨天我听到一个就来自o一个研究的其实也也讲到了就没有任何官方的数据去说G是一个还是个模型但际上在那个会上也谈到了，其实它是个那整个的在这个计算里头实际上怎么在这个这个算子上能够做的更快。

特别是从硬件加速的角度。然后能够从指令级的角度能够怎么做起来，这个是非常重要的一个点。然后推理的话呢实际上大家也都知道现可能如果去压缩去做蒸馏，这是大的一个点。

然后第三个的话就是存储的成本存储成本了本身要存储的这些日志。然后checkpoint以，其实还有一个很大的点，现在有一个新的方案，我们也在做的，就是说我们怎么把VME用起来。么把就是在多个呃多轮。😊。

对话切换不同用户之间切换的时候，我们怎么能够不用每次都带上下文，而把中间的attention的state存到NVM去。然后在下一轮切换的时候，快速加载回来。

这样子来保证这样子一个实时性低延时大吞吐的这样的一个效果。这个也是目前未来要解决的就是要进一步去优化解决的地方，最后的话就是互联网成本了。现在今天所有的大模型都已经是有钱人的游戏。

那infin的交换交加上交换机整个成本是非常高的那rock的话优势是可以在带宽上解决。但是呃在延时上实际上是有很大差距的那在这个点上，那怎么利用呃。

然后利用这样的一些其他的方式s的方式能够把尽量的把这些延迟都隐藏到进一步隐藏到计算里面去。就是我们会和呃分布式的这个训练框架进一步去配合去优化的点，那以上这些呢就是我今天想。😊，呃。

介绍和分享的内容很感谢呃，大家的时间。好，谢谢。😊，Okay， allow me to spend just one or two more minute to close。

And just like I said， I want to comment the the internship since I PMm。 And in this conference。

I certainly noticed seven， including myself，7 of our speaker。😊，Actually。

have worked for IBM as the researcher or internship or the product team for IBM system。

And it's not by design， actually because the AI， large foundation model。

we can have the chance to meet together again。 So that means that the system is so important for AI。

especially for the large foundation model and large foundation model。😊。

Is have the chance to drive system research to NAda。 So no matter how our tech career change。

We feel happy that we can meet together again to discuss the new problem together and embrace the new challenge together。

So again， in the last sentence is I want to appreciate all our speakers again。

Thank you for but prepare such a wonderful speeches today。 And another thing is for our speaker。

actually they flight a long way from US and French to hear。

and have the face to face discussion with us。 And again， I want to thanks all our audience。

stay such a long time until now。 So let's meet next year in next B AI conference。 Thanks。😊。