2024 Fall

Routine

希望可以每天看两个小时论文
爱心屋签到： aixinwu.sjtu.edu.cn/products/asw-store
中午12点抢羽毛球场
午/晚饭后乌灵💊
每日二GRISSO💊

Non-routine

Due

• 代领xhm毕业证 12/23
• 高中同学羽毛球局 12/23
• 二十花剧本杀 12/24 长寿路
• 红课论文 12/31
• 实验室桌更换 12/31

No Due

• SLR gun assembly
• JI VPN application
• Holo-Arm PRP application sheet
• 实验室电脑维修
• 请糕吃烤鱼
• Godot Learning [[Godot Learning Plan]]
• 《禅与摩托车的维修艺术》[[《禅与摩托车维修艺术》读书会p10]]
• 琪琪水彩
• 凉水彩
• 想画一幅新的水彩了
• 美罗城 云海肴 汽锅鸡
• 秋季expo 志愿者
• 寒假去哈尔滨玩

有生之年系列

• 手工🎸
• 出小孤独的cos with 糕
• 侍奉社

Archived

• 交登记表9/23 🔒Done! 2024-09-23 🕸️ 2024 Fall > Routine > Non-routine
• 501 self-introduction 9/24 🔒Done! 2024-09-24 🕸️ 2024 Fall > Routine > Non-routine
• Live2d 重置 [[live2d 复活计画]] 🔒Done! 2024-09-25 🕸️ 2024 Fall > Routine > Non-routine
• 实验室设备准备 🔒Done! 2024-09-26 🕸️ 2024 Fall > Routine > Non-routine
  • 显示器
    • 发票登记
  • 主机
  • 工位申请
• 苏州博物馆主馆抢票9/28 8:00p.m. 🔒Done! 2024-09-28 🕸️ 2024 Fall > Routine > Non-routine
• 毕设报销后续 🔒Done! 2024-09-30 🕸️ 2024 Fall > Routine > Non-routine
• Transformer 及其变体论文 🔒Done! 2024-09-30 🕸️ 2024 Fall > Routine > Non-routine
• 中国银行卡激活9/30 🔒Done! 2024-09-30 🕸️ 2024 Fall > Routine > Non-routine
• 实验室机箱 🔒Done! 2024-10-05 🕸️ 2024 Fall > Routine > Non-routine
  • 更换硬盘（遗留硬盘还有用处，不能直接格式化）
• Neovim类Cursor插件 https://github.com/yetone/avante.nvim [[Neovim Cursor (avante.nvim)]] 🔒Done! 2024-10-08 🕸️ 2024 Fall > Routine > Non-routine
• 博客添加AI助手 🔒Done! 2024-10-08 🕸️ 2024 Fall > Routine > Non-routine
• 中外合作办学十周年志愿者10/10 🔒Done! 2024-10-10 🕸️ 2024 Fall > Routine > Non-routine
• nvim plugin tutorial [[Basic Neovim Plugin Development Tutorial]] 🔒Done! 2024-10-10 🕸️ 2024 Fall > Routine > Non-routine
  • :h write-plugin
  • :h lua-guide
• 6801 HW1 10/14 🔒Done! 2024-10-13 🕸️ 2024 Fall > Routine > Non-routine > Due
• ColorfulDiff.nvim development 🔒Done!(https://github.com/Chen-Yulin/ColorfulDiff.nvim/tree/v0.0.1) 2024-10-14 🕸️ 2024 Fall > Routine > Non-routine > No Due
• 精神卫生中心-精神科就诊 10/15 13:30~14:00 🔒Done! 2024-10-16 🕸️ 2024 Fall > Routine > Non-routine > Due
• 实验室安全教育414A 10/15 16:00 🔒Done! 2024-10-16 🕸️ 2024 Fall > Routine > Non-routine > Due
• 入学教育二10/16 🔒Done! 2024-10-16 🕸️ 2024 Fall > Routine > Non-routine > Due
• https://www.callforpapers.co.uk/digitaltwin (Human Digital Twin For Improving Ergonomics And Worker’s Well-being) 🔒Done! 2024-10-16 🕸️ 2024 Fall > Routine > Non-routine > No Due
• hyprscroller mode+overview waybar [[Hyprscroller + Waybar]] 🔒Done! 2024-10-17 🕸️ 2024 Fall > Routine > Non-routine > No Due
• 501 inclass 10/18 🔒Done! 2024-10-19 🕸️ 2024 Fall > Routine > Non-routine > Due
• Godot game engine 调研 (https://docs.godotengine.org/en/stable/about/introduction.html#before-you-start) 🔒Done! 2024-10-19 🕸️ 2024 Fall > Routine > Non-routine > No Due
• Jolt physics engine (http://nilssondev.com/posts/my-journey-with-physics)[[Jolt vs PhysX]] 🔒Done! 2024-10-19 🕸️ 2024 Fall > Routine > Non-routine > No Due
• 米羔sama读书会《倦怠社会》10/19 (密院心语20:00～22:00) [[《倦怠社会》读书会p9]][[《倦怠社会》读书会p9]] 🔒Done! 2024-10-20 🕸️ 2024 Fall > Routine > Non-routine > Due
• 新生体检 10/20 🔒Done! 2024-10-21 🕸️ 2024 Fall > Routine > Non-routine > Due
• 6903 Reading 10/21 🔒Done! 2024-10-21 🕸️ 2024 Fall > Routine > Non-routine > Due
• Godot nvim development env (https://www.youtube.com/watch?v=cLWgjienc_s)[[Godot-Nvim Develop Environment]] 🔒Done! 2024-10-21 🕸️ 2024 Fall > Routine > Non-routine > No Due
• 博客评论区复活 🔒Done! 2024-10-22 🕸️ 2024 Fall > Routine > Non-routine > No Due
• 商学院项目座谈会 10/22 14:30 [[密院罗斯商学院双学位项目]] 🔒Done! 2024-10-22 🕸️ 2024 Fall > Routine > Non-routine > Due
• 新生校规校级学习检测10/21~10/27 🔒Done! 2024-10-24 🕸️ 2024 Fall > Routine > Non-routine > Due
• 501 hw1 10/28 🔒Done! 2024-10-26 🕸️ 2024 Fall > Routine > Non-routine > Due
• 6903 project proposal 10/28 🔒Done! 2024-10-30 🕸️ 2024 Fall > Routine > Non-routine > Due
• 6801 Assignment 2 10/30 🔒Done! 2024-10-30 🕸️ 2024 Fall > Routine > Non-routine > Due
• 四格漫画 🔒Done! 2024-10-30 🕸️ 2024 Fall > Routine > Non-routine > No Due
• seminar 11/1 🔒Done! 2024-11-04 🕸️ 2024 Fall > Routine > Non-routine > Due
• 小鹿 11/4 🔒Done! 2024-11-07 🕸️ 2024 Fall > Routine > Non-routine > Due
• 实验室 Seminar 11/6 14:00-16:00 🔒Done! 2024-11-07 🕸️ 2024 Fall > Routine > Non-routine > Due
• WW2Naval Mod（让这一切好好结束吧） 🔒Done! 2024-11-07 🕸️ 2024 Fall > Routine > Non-routine > No Due
  • 修复联机下AA对海bug
  • 船只倾斜对于AA俯仰和航向角的影响
  • UI更改
  • 船舵
  • 船只阻力重置
  • 潜艇相关
    • 水舱
    • 可装填鱼雷
    • 潜望镜舰长
    • 电池
    • 柴油机
    • 电机推进
    • 深弹
    • 水听
    • 声呐呐呐呐呐～
    • 雷达（针对水面以上的目标）
• 螺栓紧固机器人 🔒Done! 2024-11-07 🕸️ 2024 Fall > Routine > Non-routine > No Due
  • 树莓派供电问题
  • esp32视频实时传输[[ESP32-CAM Video Stream]]
  • 紧固装置联调
  • 支撑轮
  • 角钢角度更改
  • 头部升降步进电机驱动
    • 驱动板购买
  • 支撑轮
    • 设计
    • 组装
• 摇滚史密斯 🔒Done! 2024-11-07 🕸️ 2024 Fall > Routine > Non-routine > No Due
• 确认24SU TA工资尾款980RMB(十一月) 🔒Done! 2024-11-07 🕸️ 2024 Fall > Routine > Non-routine > No Due
• 电网AR横向 🔒Done! 2024-11-07 🕸️ 2024 Fall > Routine > Non-routine > No Due
  • 论文润色
    • 公式格式
    • 图片文字大小
  • paper相关图片，更换为贴近工地的渲染物体（通过label image）
    • 物体放置
    • 物体识别（待定）
  • 相关公式
• 约气膜羽毛球场 11/8 🔒Done! 2024-11-08 🕸️ 2024 Fall > Routine > Non-routine > Due
• 拿研究生证 11/8 🔒Done! 2024-11-11 🕸️ 2024 Fall > Routine > Non-routine > Due
• 6903 RA2 11/12 🔒Done! 2024-11-12 🕸️ 2024 Fall > Routine > Non-routine > Due
• 501 introduction 11/12 🔒Done! 2024-11-12 🕸️ 2024 Fall > Routine > Non-routine > Due
• 羽毛球 11/13 🔒Done! 2024-11-12 🕸️ 2024 Fall > Routine > Non-routine > Due
• 绿洲音乐节VIP排票 11/13 12:00 🔒Done! 2024-11-14 🕸️ 2024 Fall > Routine > Non-routine > Due
• 6801 Midterm (CTPP✅, calculator) 11/13 🔒Done! 2024-11-14 🕸️ 2024 Fall > Routine > Non-routine > Due
• 6801 Assignment 3 11/18 🔒Done! 2024-11-20 🕸️ 2024 Fall > Routine > Non-routine > Due
• 501 OH 11/18 19:00 🔒Done! 2024-11-20 🕸️ 2024 Fall > Routine > Non-routine > Due
• CosyPose 12/5 [[Cosypose (multi-view) Adaption]] 🔒Done! 2024-11-20 🕸️ 2024 Fall > Routine > Non-routine > Due
• 爱欲之死 [[《爱欲之死》读书会p12]] 🔒Done! 2024-11-20 🕸️ 2024 Fall > Routine > Non-routine > No Due
• 501 final presentation 11/21 🔒Done! 2024-11-26 🕸️ 2024 Fall > Routine > Non-routine > Due
• 读书会[[《学做工：工人阶级子弟为何继承父业》读书会p11]] 11/23 🔒Done! 2024-11-26 🕸️ 2024 Fall > Routine > Non-routine > Due
• 绿洲音乐节 11/24 15:00-21:00 🔒Done! 2024-11-26 🕸️ 2024 Fall > Routine > Non-routine > Due
• 6903 RA3 11/26 🔒Done! 2024-11-26 🕸️ 2024 Fall > Routine > Non-routine > Due
• 学做工：工人阶级子弟为何继承父业~/Book [[《学做工：工人阶级子弟为何继承父业》读书会p11]] (只看了一半) 🔒Done! 2024-11-27 🕸️ 2024 Fall > Routine > Non-routine > No Due
• 6903 Individual Paper https://dl.acm.org/doi/10.1145/3620666.3651367 11/28 (summary page, be in time, 9min) 🔒Done! 2024-11-28 🕸️ 2024 Fall > Routine > Non-routine > Due
• 羽毛球 12/3 气膜 🔒Done! 2024-12-03 🕸️ 2024 Fall > Routine > Non-routine > Due
• MS2 闲鱼寄出 12/3 🔒Done! 2024-12-03 🕸️ 2024 Fall > Routine > Non-routine > Due
• 买买买 🔒Done! 2024-12-03 🕸️ 2024 Fall > Routine > Non-routine > No Due
  • 桌灯
  • 收纳柜
  • 刷子
  • Ibanez GRG220PA1
  • Buffer调音器
  • THR10II 音箱
  • 键盘抽屉
• 约12点气膜羽毛球 🔒Done! 2024-12-04 🕸️ 2024 Fall > Routine > Non-routine > Due
• 琴房 12/6 9:00 am 🔒Done! 2024-12-06 🕸️ 2024 Fall > Routine > Non-routine > Due
• 《第七天》[[《第七天》读书会p13]] 🔒Done! 2024-12-06 🕸️ 2024 Fall > Routine > Non-routine > No Due
• SR concert 12/7 🔒Done! 2024-12-08 🕸️ 2024 Fall > Routine > Non-routine > Due
• 6801 Project Pre 12/11 10min 🔒Done! 2024-12-10 🕸️ 2024 Fall > Routine > Non-routine > Due
• 6801 HW4 12/11 🔒Done! 2024-12-10 🕸️ 2024 Fall > Routine > Non-routine > Due
• 机器人俱乐部午餐会 12/11 12pm 🔒Done! 2024-12-11 🕸️ 2024 Fall > Routine > Non-routine > Due
• 6903 Project Pre [[FLamby]] 12/12 🔒Done! 2024-12-12 🕸️ 2024 Fall > Routine > Non-routine > Due
• 各种发票(https://sjtu.feishu.cn/sheets/shtcnoqVzifk0yMeDdji7VTb0He) 🔒Done! 2024-12-13 🕸️ 2024 Fall > Routine > Non-routine > No Due
  • 步进丝杆
  • 型材
  • 树莓派供电
  • DM542
  • 直流驱动板
  • 滑轮
  • 键鼠
  • 3D打印#1
  • 3D打印#2
  • m6螺丝/母/垫片
• 6801 Final Exam 12/16 CRQ 113 2pm 🔒Done! 2024-12-16 🕸️ 2024 Fall > Routine > Non-routine > Due
• 逛逛expo~~ 12/18 🔒Done! 2024-12-18 🕸️ 2024 Fall > Routine > Non-routine > Due
• 6903 Final Exam 12/19 DZY 3-105 🔒Done! 2024-12-19 🕸️ 2024 Fall > Routine > Non-routine > Due
• 6903 Project [[FLamby]] 12/19 src, 12/20 lsj report 12/22 submit 🔒Done! 2024-12-19 🕸️ 2024 Fall > Routine > Non-routine > Due
• 糕的读书会 12/21 SJTU徐汇校区 🔒Done! 2024-12-21 🕸️ 2024 Fall > Routine > Non-routine > Due

Rich Sutton

March 13, 2019

The biggest lesson that can be read from 70 years of AI research is that general methods that leverage computation are ultimately the most effective, and by a large margin. The ultimate reason for this is Moore’s law, or rather its generalization of continued exponentially falling cost per unit of computation. Most AI research has been conducted as if the computation available to the agent were constant (in which case leveraging human knowledge would be one of the only ways to improve performance) but, over a slightly longer time than a typical research project, massively more computation inevitably becomes available. Seeking an improvement that makes a difference in the shorter term, researchers seek to leverage their human knowledge of the domain, but the only thing that matters in the long run is the leveraging of computation. These two need not run counter to each other, but in practice they tend to. Time spent on one is time not spent on the other. There are psychological commitments to investment in one approach or the other. And the human-knowledge approach tends to complicate methods in ways that make them less suited to taking advantage of general methods leveraging computation.  There were many examples of AI researchers’ belated learning of this bitter lesson, and it is instructive to review some of the most prominent.

In computer chess, the methods that defeated the world champion, Kasparov, in 1997, were based on massive, deep search. At the time, this was looked upon with dismay by the majority of computer-chess researchers who had pursued methods that leveraged human understanding of the special structure of chess. When a simpler, search-based approach with special hardware and software proved vastly more effective, these human-knowledge-based chess researchers were not good losers. They said that “brute force” search may have won this time, but it was not a general strategy, and anyway it was not how people played chess. These researchers wanted methods based on human input to win and were disappointed when they did not.

A similar pattern of research progress was seen in computer Go, only delayed by a further 20 years. Enormous initial efforts went into avoiding search by taking advantage of human knowledge, or of the special features of the game, but all those efforts proved irrelevant, or worse, once search was applied effectively at scale. Also important was the use of learning by self play to learn a value function (as it was in many other games and even in chess, although learning did not play a big role in the 1997 program that first beat a world champion). Learning by self play, and learning in general, is like search in that it enables massive computation to be brought to bear. Search and learning are the two most important classes of techniques for utilizing massive amounts of computation in AI research. In computer Go, as in computer chess, researchers’ initial effort was directed towards utilizing human understanding (so that less search was needed) and only much later was much greater success had by embracing search and learning.

In speech recognition, there was an early competition, sponsored by DARPA, in the 1970s. Entrants included a host of special methods that took advantage of human knowledge—knowledge of words, of phonemes, of the human vocal tract, etc. On the other side were newer methods that were more statistical in nature and did much more computation, based on hidden Markov models (HMMs). Again, the statistical methods won out over the human-knowledge-based methods. This led to a major change in all of natural language processing, gradually over decades, where statistics and computation came to dominate the field. The recent rise of deep learning in speech recognition is the most recent step in this consistent direction. Deep learning methods rely even less on human knowledge, and use even more computation, together with learning on huge training sets, to produce dramatically better speech recognition systems. As in the games, researchers always tried to make systems that worked the way the researchers thought their own minds worked—they tried to put that knowledge in their systems—but it proved ultimately counterproductive, and a colossal waste of researcher’s time, when, through Moore’s law, massive computation became available and a means was found to put it to good use.

In computer vision, there has been a similar pattern. Early methods conceived of vision as searching for edges, or generalized cylinders, or in terms of SIFT features. But today all this is discarded. Modern deep-learning neural networks use only the notions of convolution and certain kinds of invariances, and perform much better.

This is a big lesson. As a field, we still have not thoroughly learned it, as we are continuing to make the same kind of mistakes. To see this, and to effectively resist it, we have to understand the appeal of these mistakes. We have to learn the bitter lesson that building in how we think we think does not work in the long run. The bitter lesson is based on the historical observations that 1) AI researchers have often tried to build knowledge into their agents, 2) this always helps in the short term, and is personally satisfying to the researcher, but 3) in the long run it plateaus and even inhibits further progress, and 4) breakthrough progress eventually arrives by an opposing approach based on scaling computation by search and learning. The eventual success is tinged with bitterness, and often incompletely digested, because it is success over a favored, human-centric approach.

One thing that should be learned from the bitter lesson is the great power of general purpose methods, of methods that continue to scale with increased computation even as the available computation becomes very great. The two methods that seem to scale arbitrarily in this way are search and learning.

The second general point to be learned from the bitter lesson is that the actual contents of minds are tremendously, irredeemably complex; we should stop trying to find simple ways to think about the contents of minds, such as simple ways to think about space, objects, multiple agents, or symmetries. All these are part of the arbitrary, intrinsically-complex, outside world. They are not what should be built in, as their complexity is endless; instead we should build in only the meta-methods that can find and capture this arbitrary complexity. Essential to these methods is that they can find good approximations, but the search for them should be by our methods, not by us. We want AI agents that can discover like we can, not which contain what we have discovered. Building in our discoveries only makes it harder to see how the discovering process can be done.

从 70 年的人工智能研究中可以得到的最大教训是，利用计算的通用方法最终是最有效的，而且是最大的优势。其根本原因是摩尔定律，或者更确切地说是其对单位计算成本持续呈指数下降的概括。大多数人工智能研究都是在代理可用的计算是恒定的情况下进行的（在这种情况下，利用人类知识将是提高性能的唯一方法之一），但与典型的研究项目相比，在稍长的时间内，不可避免地会出现大量的计算可用。为了寻求在短期内产生影响的改进，研究人员试图利用他们对该领域的人类知识，但从长远来看，唯一重要的是利用计算。这两者不必相互矛盾，但在实践中它们往往是相互矛盾的。花在其中一个上的时间就是没有花在另一个上的时间。人们在心理上承诺投资于一种方法或另一种方法。而人类知识方法往往会使方法复杂化，使其不太适合利用利用计算的通用方法。人工智能研究人员迟迟没有吸取这一惨痛教训的例子有很多，回顾一下其中最突出的一些例子很有启发意义。
在计算机象棋中，1997 年击败世界冠军卡斯帕罗夫的方法是基于大规模深度搜索。当时，大多数计算机象棋研究人员对此感到沮丧，他们一直在寻求利用人类对象棋特殊结构的理解的方法。当一种更简单的、基于搜索的方法加上特殊的硬件和软件被证明更为有效时，这些基于人类知识的象棋研究人员就不是善于输的人了。他们说，“蛮力”搜索这次可能赢了，但这不是一种通用策略，而且无论如何它也不是人们下棋的方式。

这些研究人员希望基于人类输入的方法能够获胜，但结果却令他们失望。 计算机围棋也出现了类似的研究进展模式，只是推迟了 20 年。最初，人们付出了巨大的努力，利用人类知识或游戏的特殊功能来避免搜索，但一旦搜索被大规模有效应用，所有这些努力都被证明是无关紧要的，甚至更糟。同样重要的是使用自学来学习价值函数（就像在许多其他游戏甚至国际象棋中一样，尽管学习在 1997 年首次击败世界冠军的程序中并没有发挥重要作用）。自学和一般的学习就像搜索一样，因为它能够发挥大规模计算的作用。搜索和学习是人工智能研究中利用大量计算的两类最重要的技术。在计算机围棋中，就像在计算机国际象棋中一样，研究人员最初的努力是利用人类的理解力（这样就不需要太多的搜索），直到后来，通过采用搜索和学习才取得了更大的成功。

在语音识别方面，20 世纪 70 年代，DARPA 赞助了一场早期的竞赛。参赛者包括大量利用人类知识（单词、音素、人类声道等知识）的特殊方法。另一方面，一些较新的方法更具统计性质，并且基于隐马尔可夫模型 (HMM) 进行更多的计算。统计方法再次战胜了基于人类知识的方法。这导致了整个自然语言处理领域发生了重大变化，几十年来，统计和计算逐渐占据了主导地位。语音识别中深度学习的兴起是朝着这一一致方向迈出的最新一步。深度学习方法更少地依赖人类知识，使用更多的计算，再加上对大量训练集的学习，从而产生了更好的语音识别系统。就像在游戏中一样，研究人员总是试图制造出按照他们认为自己的想法运作的系统——他们试图将这些知识放入他们的系统中——但最终却适得其反，浪费了研究人员大量的时间，而摩尔定律让大规模计算成为可能，并找到了一种充分利用它的方法。

在计算机视觉中，也有类似的模式。早期的方法将视觉设想为搜索边缘、广义圆柱体或 SIFT 特征。但今天所有这些都被抛弃了。现代深度学习神经网络只使用卷积和某些类型的不变性的概念，而且表现要好得多。

这是一个很大的教训。作为一个领域，我们还没有彻底学会它，因为我们还在继续犯同样的错误。要看到这一点，并有效地抵制它，我们必须了解这些错误的吸引力。我们必须学会不那么痛苦.

和我的想法非常相近，完成度也很高啊喂。可以参考他的实现思路，引用的文章等等。

nvidia-smi返回的是driver所能支持的最新的cuda版本
系统安装的cuda版本可以随意，torch会优先使用虚拟环境中安装的cuda版本

Conda管理Cuda

安装指定版本

1

conda install nvidia/label/cuda-12.4.0::cuda-toolkit -c nvidia/label/cuda-12.4.0  

安装最新版本

1

conda install cuda-toolkit

使用ssh作为命令行远程工具，启动远程的jupyter lab并且在本地的浏览器中打开。

远程运行：

1

jupyter lab --no-browser --port=8080

--no-broswer is very important

output:

1
2
3
4
5
6
7
8
9
10

...
[I 2024-12-10 14:30:24.585 ServerApp]     http://127.0.0.1:8080/lab?token=0061d1eb31396b1bc3cd77a7161b2084da1dedcdeca0600c
[I 2024-12-10 14:30:24.586 ServerApp] Use Control-C to stop this server and shut down all kernels (twice to skip confirmation).
[C 2024-12-10 14:30:24.603 ServerApp]

    To access the server, open this file in a browser:
        file:///home/bohanfeng/.local/share/jupyter/runtime/jpserver-11659-open.html
    Or copy and paste one of these URLs:
        http://localhost:8080/lab?token=0061d1eb31396b1bc3cd77a7161b2084da1dedcdeca0600c
        http://127.0.0.1:8080/lab?token=0061d1eb31396b1bc3cd77a7161b2084da1dedcdeca0600c

本地运行：

1

ssh -L 8080:localhost:8080 bohanfeng@192.168.2.102

本地浏览器访问：
http://127.0.0.1:8080/lab?token=0061d1eb31396b1bc3cd77a7161b2084da1dedcdeca0600c

Intro

数字孪生(DT)作为现实世界非常精确的映射虽然可以用于高精度的训练但是生产DT资产过于繁琐且没有泛化性，不能做到zero-shot。
数字表亲(DC)通过比对模型特征，从模型库中选择类似的表亲模型，用于重建场景训练机械臂。让机械臂针对不同第一次见的场景具有泛化性。
（a）它减少了手动微调的需要，以保证一定的保真度，从而能够完全自动化地创建数字表亲，（b）它通过提供一组增强的场景来训练机器人策略，从而有助于更好地应对原始场景中的变化。

Methodology

ACDC is our automated pipeline for generating fully interactive simulated scenes from a single RGB image, and is broken down into three steps:
(1) an extraction step, in which relevant object masks are extracted from the raw input image
(2) a matching step, in which we select digital cousins for individual objects extracted from the original scene
(3) a generation step, in which the selected digital cousins are post-processed and compiled together to form a fully-interactive, physically-plausible digital cousin scene.

Repository: https://github.com/owkin/FLamby

Installation

1
2
3
4
5
6
7
8

git clone https://github.com/owkin/FLamby.git
cd FLamby
conda env create -f environment.yml
conda activate flamby
pip install -e .[all_extra]
pip install wget
pip install lifelines
pip install jupyterlab

Dataset

Fed-TCGA-BCRA
https://owkin.github.io/FLamby/fed_tcga_brca.html

Baseline Learning

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

import torch
from flamby.utils import evaluate_model_on_tests

# 2 lines of code to change to switch to another dataset
from flamby.datasets.fed_tcga_brca import (
    BATCH_SIZE,
    LR,
    NUM_EPOCHS_POOLED,
    Baseline,
    BaselineLoss,
    metric,
    NUM_CLIENTS,
    Optimizer,
)
from flamby.datasets.fed_tcga_brca import FedTcgaBrca as FedDataset

Import several macros, datasets and metrics.

1
2
3
4
5
6

# Instantiation of local train set (and data loader)), baseline loss function, baseline model, default optimizer
train_dataset = FedDataset(center=0, train=True, pooled=False)
train_dataloader = torch.utils.data.DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True, num_workers=0)
lossfunc = BaselineLoss()
model = Baseline()
optimizer = Optimizer(model.parameters(), lr=LR)

In this script, the pooled parameter is set to False when creating the FedDataset instances. This indicates that the dataset is not pooled, meaning that the data is kept separate for each client or center. Each client or center has its own local dataset, which is a common setup in federated learning to simulate real-world scenarios where data is distributed across different locations or devices.

1
2
3
4
5
6
7
8

# Traditional pytorch training loop
for epoch in range(0, NUM_EPOCHS_POOLED):
    for idx, (X, y) in enumerate(train_dataloader):
        optimizer.zero_grad()
        outputs = model(X)
        loss = lossfunc(outputs, y)
        loss.backward()
        optimizer.step()

正常的训练流程

1
2
3
4
5
6
7
8
9
10
11
12
13
14

# Evaluation
# Instantiation of a list of the local test sets
test_dataloaders = [
            torch.utils.data.DataLoader(
                FedDataset(center=i, train=False, pooled=False),
                batch_size=BATCH_SIZE,
                shuffle=False,
                num_workers=0,
            )
            for i in range(NUM_CLIENTS)
        ]
# Function performing the evaluation
dict_cindex = evaluate_model_on_tests(model, test_dataloaders, metric)
print(dict_cindex)

使用的evaluation metric是lifelines.utils.concordance_index，返回的是c_index

Federated Learning

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

import torch
from flamby.utils import evaluate_model_on_tests

# 2 lines of code to change to switch to another dataset
from flamby.datasets.fed_tcga_brca import (
    BATCH_SIZE,
    LR,
    NUM_EPOCHS_POOLED,
    Baseline,
    BaselineLoss,
    metric,
    NUM_CLIENTS,
    get_nb_max_rounds
)
from flamby.datasets.fed_tcga_brca import FedTcgaBrca as FedDataset

# 1st line of code to change to switch to another strategy
from flamby.strategies.fed_avg import FedAvg as strat

1
2
3
4
5
6
7
8
9
10
11
12
13

# We loop on all the clients of the distributed dataset and instantiate associated data loaders
train_dataloaders = [
            torch.utils.data.DataLoader(
                FedDataset(center = i, train = True, pooled = False),
                batch_size = BATCH_SIZE,
                shuffle = True,
                num_workers = 0
            )
            for i in range(NUM_CLIENTS)
        ]

lossfunc = BaselineLoss()
m = Baseline()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

# Federated Learning loop
# 2nd line of code to change to switch to another strategy (feed the FL strategy the right HPs)
args = {
            "training_dataloaders": train_dataloaders,
            "model": m,
            "loss": lossfunc,
            "optimizer_class": torch.optim.SGD,
            "learning_rate": LR / 10.0,
            "num_updates": 100,
# This helper function returns the number of rounds necessary to perform approximately as many
# epochs on each local dataset as with the pooled training
            "nrounds": get_nb_max_rounds(100),
        }
s = strat(**args)
m = s.run()[0]

# Evaluation
# We only instantiate one test set in this particular case: the pooled one
test_dataloaders = [
            torch.utils.data.DataLoader(
                FedDataset(train = False, pooled = True),
                batch_size = BATCH_SIZE,
                shuffle = False,
                num_workers = 0,
            )
        ]
dict_cindex = evaluate_model_on_tests(m, test_dataloaders, metric)
print(dict_cindex)

FedAvg vs FedAvgFineTuning

FedAvg

FedAvgFineTuning