一个栗子

假设您患有肾结石并去看医生。医生告诉你有两种治疗方法，治疗 A（开放手术 open surgery）和治疗 B（体外冲击波碎石术 ESWL）。

你问哪种治疗效果更好，医生说：“一项研究发现治疗 A 的成功概率高于治疗 B。”

你说：“我会接受治疗 A，谢谢！”

这时医生打断你，“但同样的研究还研究了哪种治疗效果更好，这取决于患者是大肾结石还是小肾结石。”

你说：“好吧，我有大肾结石还是小肾结石？”

你说话的时候，医生又打断了你，说：“其实没关系。你看，他们发现治疗 B 比治疗 A 成功的概率更高，不管你的肾结石是大还是小。”

你可能想知道你是否没看错。听起来不可能。但这是真的：在一项实际研究中，发现治疗 B 比治疗 A 对大肾结石和小肾结石起作用的概率更高，尽管事实上治疗 A 的总体 概率高于治疗 B。这是研究数据：

表中的第一项显示，80 名大肾结石患者接受了 A 治疗，治疗帮助了其中 55 人，成功率为 69%。这不如治疗 B 好，它帮助了 263 名大肾结石患者中的 192 人，成功率为 73%。以类似的方式，第二行显示治疗 B 比治疗 A 对患有小肾结石的人更有效。

但是当你把每一列的数字加起来时，你会发现治疗 A 确实比治疗 B 整体效果更好。

值得花时间检查所有数字加起来检验一下，并说服自己我没有欺骗你.

刚刚展示的这种现象被称为辛普森悖论。如果你和包括我在内的大多数人一样，那么辛普森悖论在你第一次见到它时就会令人震惊。因为它违反了我们对世界推理的本能方式。而且，正如我们看到的那样，辛普森悖论不仅是一种怪异的现象，而且它经常在具有重要决策后果的地方出现。

表达式

我们抽离出符号表达：

如果

那么，推不出

以上就是辛普森悖论比较通俗易懂的表达式了。

我们忽略了什么

从数据生成过程（因果模型）来看分析.

事实证明，小肾结石被认为是不严重的病例，治疗 B（体外冲击波碎石术 ESWL）比治疗 A（开放手术 open surgery）更加激进。

对于小肾结石，医生更有可能推荐保守疗法 A，因为病情不太严重，患者最有可能首先成功恢复。

对于严重的大肾结石，医生往往选择更激进的疗法 B。即使疗法 B 在这些病例中表现更好，由于是更严重的病例，疗法 B 的总体恢复率低于疗法 A.

在这个现实世界的例子中，肾结石的大小（病例的严重性）是一个混合变量，它会同时影响自变量（疗法）和因变量（恢复率）.

为了确定哪种治疗方法确实更好，我们需要通过对两组数据进行分离并比较组内的恢复率而不是按组聚合来控制混合变量。

这样看来激进的治疗 B（体外冲击波碎石术 ESWL）效果更好.

如果有潜在变量（特别是混合变量）存在，牢记：整体数据未必可靠，要通过科学合理的分组来查看具体细致的数据。

启示

• 数据从来都不是完全客观的。我们必须对这些数字持怀疑态度.
• 辛普森悖论的出现是因为人们忽略了研究的因果关系，一旦我们理解了数据生成的机制，我们就可以寻找影响结果的其他因素，而图表不会告诉你这些.
• 充分考察事件的潜在影响因素和维度，系数消除分组数据基数差异造成的影响.
• 要求我们具备科学辩证思维，客观看待关联现象。很多时候，我们选择相信直觉，因为我们的直觉往往很准。但是，在信息不全或者信息非对称的情况下，直觉常常是是值得怀疑的。

构建向量空间模型

将文档转化为向量来表示，这样文档与文档之间就可以定量的去度量他们之间的关系，挖掘文档之间的联系。上面提到的 Word2Vec 是把单词转化为向量来表示，这样词与词之间就可以定量的去度量他们之间的关系，挖掘词之间的联系.

比如将词的维度降维到 2 维，用下图的词向量表示词:

似乎发现了什么不得了的事情。

对于自然语言书写的文本这种非结构化信息，从文本中抽取出的特征来量化来表示文本信息，构建向量空间模型，并基于数学模型的处理，将文本转换为机器可以理解的语言的方式是很重要的。

举个栗子

要实现文章推荐，就需要从一堆文章中找出一些内容相似的文章。基本思路就是，如果文章的关键词越相似，那么他们的内容就会越相似。

我们先从几个简单的句子着手。

句子A：我这里有苹果和西瓜。

句子B：我喜欢吃西瓜，不喜欢吃苹果。

句子C：我喜欢吃蔬菜。

第一步：数据清洗

简单去除标点符号等干扰信息。

句子A: 我这里有苹果和西瓜

句子B: 我喜欢吃西瓜 不喜欢吃苹果

句子C: 我喜欢吃蔬菜

第二步：分词

使用分词工具进行分词。

句子A:

[ '我', '这里', '有', '苹果', '和', '西瓜' ]

句子B:
[
  '我', '喜欢',
  '吃', '西瓜',
  '不', '喜欢',
  '吃', '苹果'
]

句子C:

[ '我', '喜欢', '吃', '蔬菜' ]

第三步：去重收集所有句子中所有的词

[
  '我',   '这里', '有',
  '苹果', '和',   '西瓜',
  '喜欢', '吃',   '不',
  '蔬菜'
]

第四步：计算词频

词频背后的假设是文章的重要程度即文章的相关度与单词在文档中出现的次数成正比。文章的关键词应当比文章中的其他词出现的次数多。

句子A:

{
  '我': 1,
  '这里': 1,
  '有': 1,
  '苹果': 1,
  '和': 1,
  '西瓜': 1,
  '喜欢': 0,
  '吃': 0,
  '不': 0,
  '蔬菜': 0
}

句子B:
{
  '我': 1,
  '这里': 0,
  '有': 0,
  '苹果': 1,
  '和': 0,
  '西瓜': 1,
  '喜欢': 2,
  '吃': 2,
  '不': 1,
  '蔬菜': 0
}

句子C:

{
  '我': 1,
  '这里': 0,
  '有': 0,
  '苹果': 0,
  '和': 0,
  '西瓜': 0,
  '喜欢': 1,
  '吃': 1,
  '不': 0,
  '蔬菜': 1
}

第四步：词频标准化

文章的篇幅有长有短，为了便于不同文章的比较，进行” 词频” 标准化。词频标准化的目的是把所有的词频在同一维度上分析。

词频标准化有两种方案：

方案一：

方案二：

一般情况下，第二个标准化方案更适用，因为能够使词频的值相对大点，便于分析。

有时候常常用 这个值来代替原来的 TF 取值。这样的计算保持了一个平衡，既有区分度，但也不至于完全线性增长。

这里使用比较简单的方案一作为栗子：

句子A:

{
  '我': 0.16666666666666666,
  '这里': 0.16666666666666666,
  '有': 0.16666666666666666,
  '苹果': 0.16666666666666666,
  '和': 0.16666666666666666,
  '西瓜': 0.16666666666666666,
  '喜欢': 0,
  '吃': 0,
  '不': 0,
  '蔬菜': 0
}

句子B:
{
  '我': 0.125,
  '这里': 0,
  '有': 0,
  '苹果': 0.125,
  '和': 0,
  '西瓜': 0.125,
  '喜欢': 0.25,
  '吃': 0.25,
  '不': 0.125,
  '蔬菜': 0
}

句子C:

{
  '我': 0.25,
  '这里': 0,
  '有': 0,
  '苹果': 0,
  '和': 0,
  '西瓜': 0,
  '喜欢': 0.25,
  '吃': 0.25,
  '不': 0,
  '蔬菜': 0.25
}

第五步：计算逆文档频率

仅有词频 (TF) 不能比较完整地描述文档的相关度。因为语言的因素，有一些单词可能会比较自然地在很多文档中反复出现，比如这里中的 “我”、“和” 等等。这些词大多起到了链接语句的作用，是保持语言连贯不可或缺的部分。

很明显，如果有太多文档都涵盖了某个单词，这个单词也就越不重要，或者说是这个单词就越没有信息量。因此，我们需要对词频 (TF) 的值进行修正，而 逆文档频率 (IDF) 的想法是用文档频率 (DF) 的倒数来进行修正。

如果一个词越常见，那么分母就越大，逆文档频率就越小越接近 0。分母之所以要加 1，是为了避免分母为 0（即所有文档都不包含该词）。log 表示对得到的值取对数。为什么要用 log 函数？log 函数是单调递增，求 log 是为了归一化，保证逆文档频率不会过大。用 Log 进行变换，也是一个非线性增长的技巧，这样的计算保持了一个平衡，既有区分度，但也不至于完全线性增长。

句子A:

{
  '我': -0.2876820724517809,
  '这里': 0.4054651081081644,
  '有': 0.4054651081081644,
  '苹果': 0,
  '和': 0.4054651081081644,
  '西瓜': 0,
  '喜欢': 0,
  '吃': 0,
  '不': 0.4054651081081644,
  '蔬菜': 0.4054651081081644
}

句子B:
{
  '我': -0.2876820724517809,
  '这里': 0.4054651081081644,
  '有': 0.4054651081081644,
  '苹果': 0,
  '和': 0.4054651081081644,
  '西瓜': 0,
  '喜欢': 0,
  '吃': 0,
  '不': 0.4054651081081644,
  '蔬菜': 0.4054651081081644
}

句子C:

{
  '我': -0.2876820724517809,
  '这里': 0.4054651081081644,
  '有': 0.4054651081081644,
  '苹果': 0,
  '和': 0.4054651081081644,
  '西瓜': 0,
  '喜欢': 0,
  '吃': 0,
  '不': 0.4054651081081644,
  '蔬菜': 0.4054651081081644
}

第六步：计算 TF-IDF

可以看到，TF-IDF 与一个词在文档中的出现次数成正比，与该词在整个文档库中的出现次数成反比。

句子A:

{
  '我': -0.047947012075296815,
  '这里': 0.06757751801802739,
  '有': 0.06757751801802739,
  '苹果': 0,
  '和': 0.06757751801802739,
  '西瓜': 0,
  '喜欢': 0,
  '吃': 0,
  '不': 0,
  '蔬菜': 0
}

句子B:
{
  '我': -0.03596025905647261,
  '这里': 0,
  '有': 0,
  '苹果': 0,
  '和': 0,
  '西瓜': 0,
  '喜欢': 0,
  '吃': 0,
  '不': 0.05068313851352055,
  '蔬菜': 0
}

句子C:

{
  '我': -0.07192051811294523,
  '这里': 0,
  '有': 0,
  '苹果': 0,
  '和': 0,
  '西瓜': 0,
  '喜欢': 0,
  '吃': 0,
  '不': 0,
  '蔬菜': 0.1013662770270411
}

第七步：列出文档向量

这里准确来说应该是 TF-IDF 特征向量，这是一个稀疏矩阵。下面把它作为描述文章特征的向量。

说明一点，这里的文章的特征不是由某几个关键词的 TF-IDF 值决定的，而是由所有的词的 TF-IDF 值共同决定的。

句子A:

[
  -0.047947012075296815,
  0.06757751801802739,
  0.06757751801802739,
  0,
  0.06757751801802739,
  0,
  0,
  0,
  0,
  0
]

句子B:

[
  -0.03596025905647261,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0.05068313851352055,
  0
]

句子C:

[
  -0.07192051811294523,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0.1013662770270411
]

可以对文档向量进行标准化，使得这些向量能够不受向量里有效元素多少的影响，也就是不同的文档可能有不同的长度。把向量都标准化为一个单位向量的长度。这个时候再进行点积运算，就相当于在原来的向量上进行余弦相似度的运算。

第八步：计算余弦相似度

到这里，如何寻找两篇相似文章的问题转变成了如何计算这两个向量的相似程度的问题。

什么叫做向量相似？

一般地，如果两个向量平行或重合，我们认为这两个向量相似度为 。如果这两个向量垂直，或者说正交，我们认为这两个向量的相似度为 。

以二维空间为例， 和 是两个向量，我们要计算它们的夹角 。余弦定理告诉我们，可以用下面的公式求得：

假定和是两个维向量，我们把这些向量放到维欧几里得空间中讨论，向量之间的距离使用欧几里得距离。

假定是 ，是 ，则与的夹角的余弦等于：

{
  '句子A': {
    '句子A': 1.0000000000000002,
    '句子B': 0.21934876427664535,
    '句子C': 0.21934876427664535
  },
  '句子B': {
    '句子A': 0.21934876427664535,
    '句子B': 1,
    '句子C': 0.33484380220099325
  },
  '句子C': {
    '句子A': 0.21934876427664535,
    '句子B': 0.33484380220099325,
    '句子C': 1
  }
}

第九步：余弦相似度按照降序排序

两两计算向量夹角的余弦值，然后按降序排列，取排在最前面的几个文章，就是相似度较高的文章，作为推荐结果。

{
  '句子A': {
    '句子A': 1.0000000000000002,
    '句子B': 0.21934876427664535,
    '句子C': 0.21934876427664535
  },
  '句子B': {
    '句子B': 1,
    '句子C': 0.33484380220099325,
    '句子A': 0.21934876427664535
  },
  '句子C': {
    '句子C': 1,
    '句子B': 0.33484380220099325,
    '句子A': 0.21934876427664535,
  }
}

相同句子的余弦值是 . 余弦值越接近，就表明夹角越接近度，也就是两个向量越相似.

第十步：收集推荐结果

{
  '句子A': [ '句子B', '句子C' ],
  '句子B': [ '句子C', '句子A' ],
  '句子C': [ '句子B', '句子A' ]
}

即：

A-B
B-C
C-B

A 和 C 之间没什么关系。

源码实现

Volantis 主题实现文章推荐

https://github.com/volantis-x/hexo-theme-volantis/blob/684c40333b16b5d1df1a9e4a7f1da90216e5a17a/scripts/helpers/ 文章推荐.js

UI 界面是随手写的，又不是不能用（

代码变量是中文写的，方便易读。其实是中间出 Bug 了，然后调试 Debug 时顺便整的活

PE

• 官方镜像和安装介质
• 老毛桃 UEFI 版

操作系统

• windows 镜像库

Win11 安装跳过 tpm 2.0 检测的方法

TPM 对笔者来说毫无用处

打开 Windows 11 的 ISO 镜像安装包，打开后将目录 Source 中的 install.wim 文件复制到桌面上。然后解压 Windows 10 的 ISO 安装包，然后将 Win11 的 install.win 文件拷到解压后的 win10 安装包的 sources 文件夹，双击 Windows 10 安装包里的 setup.exe 文件开始安装，借用 Windows10 安装程序去安装 Windows11 系统

• W10 Digital License Activation Script

笔者发现装完系统以后 win11 已经激活了，是因为之前使用了 W10 Digital License Activation Script。

Office

• Office 镜像库
• Office Tool Plus

  Office Tool Plus 入门教程

• kms list

  kms.loli.best 1688

浏览器

• Chrome
• Firefox
• Tor Browser

安全管理

• 火绒安全
• 腾讯电脑管家
• Kaspersky

暂时只装火绒。

Windows 应用商店

• 7-zip
• Ubuntu On windows
• Kali Linux

IDE 文本编辑器

• Visual Studio Code
• Visual Studio

  vs2022 永久激活密钥：
  Visual Studio 2022 Enterprise：VHF9H-NXBBB-638P6-6JHCY-88JWH
  Visual Studio 2022 Professional：TD244-P4NB7-YQ6XK-Y8MMM-YWV2J

• CodeBlocks
• JetBrains Pycharm
• JetBrains Idea

  https://www.exception.site/essay/how-to-free-use-intellij-idea-2019-3

• Notepad++
• Eclipse
• MyEclipse
• Typora
• Matlab

代理工具

• Clash for Windows
• V2rayN
• ShadowsocketsR

DOH

• 阿里：https://dns.alidns.com/dns-query
• 腾讯：https://doh.pub/dns-query

驱动

• NVIDIA
• ATK Package
• cuda
• cudnn

开发环境

• TDM-GCC x64

• python

  pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple

  Writing to %appdata%\pip\pip.ini

• anaconda

• Java SE Development Kit

• nvm

  找到 nvm 文件位置，点开 settings.txt

  root: C:\software\nvm path: C:\software\nodejs node_mirror: https://npm.taobao.org/mirrors/node/ npm_mirror: https://npm.taobao.org/mirrors/npm/

  使用

  nvm ls // 看安装的所有node.js的版本 nvm list available // 查显示可以安装的所有node.js的版本 nvm install 版本号 // 例如：nvm install 16.16.0 nvm use 版本号 // 切换到使用指定的nodejs版本

版本控制

• Git
• GitHub DeskTop

配置 .gitconfig

[user]
    name = MHuiG
    email = xxxxxx@qq.com
    signingkey = BA16368BD4C4169C
[gui]
    encoding = utf-8
[filter "lfs"]
    smudge = git-lfs smudge -- %f
    process = git-lfs filter-process
    required = true
    clean = git-lfs clean -- %f
[http]
    schannelCheckRevoke = false
[commit]
    gpgsign = true
[gpg]
    program = C:\\software\\GnuPG\\bin\\gpg.exe
[init]
    defaultBranch = main
[core]
    editor = \"C:\\software\\Microsoft VS Code\\bin\\code\" --wait

聊天工具

• QQ
• 微信
• 企业微信
• Telegram Desktop

远程连接

• Xshell
• Xftp
• SecureCRT
• VNC

数据库

• MySQL
• Navicat
• mongoDB
• Robo 3T
• redis
• RedisDesktopManager

截屏工具

• ScreenToGif
• Greenshot

GPG

• keybase
• Gpg4win

下载工具

• 迅雷
• 百度网盘
• Aria2

杂项

• 搜狗输入法
• VMware

  16: ZF3R0-FHED2-M80TY-8QYGC-NPKYF

• XMind
• PostMan
• 网易有道词典
• CAJViewer
• BestTrace
• StarUML
• HDFView
• Adobe Photo Shop
• 网易云音乐
• MathType
• PotPlayerPortable
• Dism++
• UltraISO
• MyDiskTest
• DiskGenius

chrome 扩展

• AdBlock — 最佳广告拦截工具
• Enable Copy
• MetaMask
• Tampermonkey BETA
• Wappalyzer - Technology profiler
• 迅雷下载支持

windows 导出备份 WiFi 密码

@echo off 
 
for /f "skip=9 tokens=1,2 delims=:" %%i in ('netsh wlan show profiles') do @echo %%j | findstr -i -v echo | netsh wlan show profiles %%j key=clear >>%USERPROFILE%\desktop\Wi-Fi-code.txt
start %USERPROFILE%\desktop\Wi-Fi-code.txt

windows 提权

装完系统先搞权限。

夺回 Windows 系统权限

碰到过这样的提示：“无法使用内置管理员账户打开 XX 程序，请使用其他账户登录”

其实已经使用管理员账户登录了，为什么还会出现这样的提示呢？

这是因为使用的内置账户没有对应用程序的操作权限，可以使用注册表来夺回 Windows10 系统权限。

账户详解：

使用的管理员账户，就是使用用户名或微软账号登录到 Windows 的账号，管理权限无限近似于 Administrator，但在某些文件 / 文件夹的操作上，还是不如真正的 Administrator 好用。

在 Windows 内置的账户中，还有两个比 Administrator 权限更高的账户，一个是肉眼可见的 System 权限，最终的 Boss 则是 TrustedInstaller，其实所有账户中它也不是最高的那个，但剩下的无论通过什么方式，都挖掘不出来了，也许超级账户就是 Microsoft 自己了。

Windows 夺回系统权限的操作方法：

• 1、Win+R 组合键之后，输入 regedit ，打开注册表；
• 2、定位到：HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System ，在右侧栏找到 FilterAdministratorToken ，双击后将数值数据修改为 1 之后点击 确定。（如果没有的话，就使用鼠标右键新建个 DWORD（32位） 值，将其命名为 FilterAdministratorToken 。）
• 3、之后再定位到：HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System\UIPI ，将右侧的默认项目的数值数据修改为 1。
• 4、完成上述操作后，重启电脑或注销当前 Windows 账户后，再进入 “控制面板 - 系统与安全 - 用户账户控制设置”，将 “通知选项” 设置为默认就 OK 了。

开启 administrator 账户

net user administrator /active:yes

右键菜单权限选项

Windows Registry Editor Version 5.00
[-HKEY_CLASSES_ROOT\*\shell\runas]
[HKEY_CLASSES_ROOT\*\shell\runas]
@="获取超级管理员权限"
"Icon"="C:\\Windows\\System32\\imageres.dll,-78"
"NoWorkingDirectory"=""
[HKEY_CLASSES_ROOT\*\shell\runas\command]
@="cmd.exe /c takeown /f \"%1\" && icacls \"%1\" /grant administrators:F"
"IsolatedCommand"="cmd.exe /c takeown /f \"%1\" && icacls \"%1\" /grant administrators:F"
[-HKEY_CLASSES_ROOT\Directory\shell\runas]
[HKEY_CLASSES_ROOT\Directory\shell\runas]
@="获取超级管理员权限"
"Icon"="C:\\Windows\\System32\\imageres.dll,-78"
"NoWorkingDirectory"=""
[HKEY_CLASSES_ROOT\Directory\shell\runas\command]
@="cmd.exe /c takeown /f \"%1\" /r /d y && icacls \"%1\" /grant administrators:F /t"
"IsolatedCommand"="cmd.exe /c takeown /f \"%1\" /r /d y && icacls \"%1\" /grant administrators:F /t"
[-HKEY_CLASSES_ROOT\dllfile\shell]
[HKEY_CLASSES_ROOT\dllfile\shell\runas]
@="获取超级管理员权限"
"HasLUAShield"=""
"NoWorkingDirectory"=""
[HKEY_CLASSES_ROOT\dllfile\shell\runas\command]
@="cmd.exe /c takeown /f \"%1\" && icacls \"%1\" /grant administrators:F"
"IsolatedCommand"="cmd.exe /c takeown /f \"%1\" && icacls \"%1\" /grant administrators:F"
[-HKEY_CLASSES_ROOT\Drive\shell\runas]
[HKEY_CLASSES_ROOT\Drive\shell\runas]
@="获取超级管理员权限"
"Icon"="C:\\Windows\\System32\\imageres.dll,-78"
"NoWorkingDirectory"=""
[HKEY_CLASSES_ROOT\Drive\shell\runas\command]
@="cmd.exe /c takeown /f \"%1\" /r /d y && icacls \"%1\" /grant administrators:F /t"
"IsolatedCommand"="cmd.exe /c takeown /f \"%1\" /r /d y && icacls \"%1\" /grant administrators:F /t"

Windows Registry Editor Version 5.00
;恢复原始权限  
[HKEY_CLASSES_ROOT\*\shell\runas-]  
@="恢复原始权限"
"Icon"="C:\\Windows\\System32\\imageres.dll,101"
"NoWorkingDirectory"=""
; && takeown /f \"%1\"
[HKEY_CLASSES_ROOT\*\shell\runas-\command]  
@="cmd.exe /c takeown /f \"%1\" && icacls \"%1\" /reset && cacls \"%1\" /e /r \"%%USERNAME%%\""
"IsolatedCommand"="cmd.exe /c takeown /f \"%1\" && icacls \"%1\" /reset && cacls \"%1\" /e /r \"%%USERNAME%%\""
[HKEY_CLASSES_ROOT\exefile\shell\runas2-]  
@="恢复原始权限"
"Icon"="C:\\Windows\\System32\\imageres.dll,101"
"NoWorkingDirectory"=""
[HKEY_CLASSES_ROOT\exefile\shell\runas2-\command]  
@="cmd.exe /c takeown /f \"%1\" && icacls \"%1\" /reset && cacls \"%1\" /e /r \"%%USERNAME%%\""
"IsolatedCommand"="cmd.exe /c takeown /f \"%1\" && icacls \"%1\" /reset && cacls \"%1\" /e /r \"%%USERNAME%%\""
[HKEY_CLASSES_ROOT\Directory\shell\runas-]  
@="恢复原始权限"
"Icon"="C:\\Windows\\System32\\imageres.dll,101"
"NoWorkingDirectory"=""
[HKEY_CLASSES_ROOT\Directory\shell\runas-\command]  
@="cmd.exe /c takeown /f \"%1\" /r /d y && icacls \"%1\" /reset && cacls \"%1\" /e /r \"%%USERNAME%%\""
"IsolatedCommand"="cmd.exe /c takeown /f \"%1\" /r /d y && icacls \"%1\" /reset && cacls \"%1\" /e /r \"%%USERNAME%%\""

Windows Registry Editor Version 5.00
;取得文件修改权限  
[HKEY_CLASSES_ROOT\*\shell\runas]  
@="获取管理员权限"
"Icon"="C:\\Windows\\System32\\imageres.dll,102"
"NoWorkingDirectory"=""
[HKEY_CLASSES_ROOT\*\shell\runas\command]  
@="cmd.exe /c takeown /f \"%1\" && icacls \"%1\" /grant administrators:F"
"IsolatedCommand"="cmd.exe /c takeown /f \"%1\" && icacls \"%1\" /grant administrators:F"
[HKEY_CLASSES_ROOT\exefile\shell\runas2]  
@="获取管理员权限"
"Icon"="C:\\Windows\\System32\\imageres.dll,102"
"NoWorkingDirectory"=""
[HKEY_CLASSES_ROOT\exefile\shell\runas2\command]  
@="cmd.exe /c takeown /f \"%1\" && icacls \"%1\" /grant administrators:F"
"IsolatedCommand"="cmd.exe /c takeown /f \"%1\" && icacls \"%1\" /grant administrators:F"
[HKEY_CLASSES_ROOT\Directory\shell\runas]  
@="获取管理员权限"
"Icon"="C:\\Windows\\System32\\imageres.dll,102"
"NoWorkingDirectory"=""
[HKEY_CLASSES_ROOT\Directory\shell\runas\command]  
@="cmd.exe /c takeown /f \"%1\" /r /d y && icacls \"%1\" /grant administrators:F /t"
"IsolatedCommand"="cmd.exe /c takeown /f \"%1\" /r /d y && icacls \"%1\" /grant administrators:F /t"

Windows Registry Editor Version 5.00
[-HKEY_CLASSES_ROOT\*\shell\runas]
[-HKEY_CLASSES_ROOT\exefile\shell\runas2]
[-HKEY_CLASSES_ROOT\Directory\shell\runas]
[-HKEY_CLASSES_ROOT\*\shell\runas-]
[-HKEY_CLASSES_ROOT\exefile\shell\runas2-]
[-HKEY_CLASSES_ROOT\Directory\shell\runas-]

获取 TrustedInstaller 超级权限

TrustedInstaller 超级权限是凌驾于管理员权限和系统权限之上的存在

TrustedInstaller 超级权限的添加方法：

下载注册表权限修改工具 SetACL:

https://helgeklein.com/download/#download-setacl

SetACL 文档：

https://helgeklein.com/setacl/

https://helgeklein.com/setacl/documentation/command-line-version-setacl-exe/

按照如下格式设置执行获取权限命令：

SetACL -on 对象名称 -ot 对象类型 -actn 操作

对象名称 (-on)：这是 SetACL 应操作的对象的路径。
对象类型（-ot）：对象名称指的是什么类型的对象：文件或目录（file）、注册表项（reg）、服务（srv）、打印机（prn）、网络共享（shr）
操作 (-actn)：SetACL 应该如何处理指定的对象

注册表值权限获取就可以用如下命令：

SetACL.exe -on "HKEY_CLASSES_ROOT\XXX\{xxxxxxx-666-5555-EEEE-yyyyyy}" -ot reg -actn setowner -ownr "n:Administrators"
;;注释：将上述注册表项所有者更新到管理员 Administrator（默认为不可更改的 TrustedInstaller ）。
SetACL.exe -on "HKEY_CLASSES_ROOT\XXX\{xxxxxxx-666-5555-EEEE-yyyyyy}" -ot reg -actn ace -ace "n:Administrators;p:full"
;;注释：让上述注册表项所有者 Administrator 获取全部权限。

注意，上述命令缺一不可，而且要按照先后顺序执行。

友情提醒：命令 SetACL -on 对象名称 -ot 对象类型 -actn 操作 适合文件、文件夹（需要写详细路径）和注册表项目超级权限获取，各位可按需提权，出于安全考虑，切勿滥用。如果修改完毕，还可以考虑把命令中的管理员 Administrator 替换为 TrustedInstaller 再次执行命令，恢复系统默认，确保安全。

windows 取消登录界面的名字

• 1、打开 regedit。
• 2、定位到以下位置：\HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System\，找到名为 dontdisplaylastusername 的键值，双击它，然后将它的数值数据改为 1。
• 3、将鼠标光标放在左侧树状列表的 System 项上，单击右键，选择新建 - DWORD（32 位）值，并将该值命名为：DontDisplayLockedUserID。
• 4、双击我们刚刚新建的名为 DontDisplayLockedUserID 的 DWORD（32 位）值，你将看到一个编辑 DWORD（32 位）值的窗口。在这个窗口中，将 DontDisplayLockedUserID 的数值数据改为 3。
• 5、修改完成后，关闭注册表编辑器，在开始菜单中点击你的头像，再点击锁定，你将看到锁屏界面。
• 6、按回车键，或者使用鼠标点击屏幕，你将看到 Win 登录界面。这时我们可以看到，我们的名字已经显示为 “解锁电脑”。
• 7、要登录 Win，你需要手动输入用户名和密码或者 PIN，需要注意的是，这个用户名以 C:\Users 中的为准。如果你不清楚你当前的用户名，那么可以打开命令提示符后，里面显示的是 C:\Users\XXX >，那么当前的用户名就是 XXX ，在登录 Win 时，将 XXX 填入用户名的输入框即可。

要将 Win10 登陆界面恢复为显示姓名也非常简单，只需再次来到注册表，然后双击名为 dontdisplaylastusername 的键值，将它的数值数据改为 0 即可。

windows 取消登录界面电源按钮

1、按下 Win+r 打开运行，输入 regedit 回车，打开注册表编辑器；
2、定位至：HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System，然后你就会看到 shutdownwithoutlogon 这个 32 位的 DWORD 值；
3、双击 shutdownwithoutlogon，打开编辑界面，将数据设置为０；原值为 1.
4、操作完成后，你就会发现，登陆界面的电源按钮没了。

上帝模式

即 God Mode 完全控制面板

开启方法:

新建文件夹重命名为

GodMode.{ED7BA470-8E54-465E-825C-99712043E01C}

时间显示到秒

实验中发现 win11 删除了注册表 ShowSecondsInSystemClock，需要先下载安装 startallback，然后笔者放弃了时间显示到秒。

• win11 需要先下载安装 startallback, win10 直接修改注册表
• 修改注册表 HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\Advanced
• 新建 DWORD (32 位) 值 改为 1: “ShowSecondsInSystemClock”=dword:00000001
• 重启

使用注册表隐藏磁盘盘符

具体操作如下：

注：在开始之前，请使用 Administrator 帐户登录 Windows10。

• 1、首先，将鼠标光标放在 “此电脑” 图标上，点击右键，再点击管理。
• 2、在窗口左侧的树状列表中展开本地用户和组，点击用户文件夹。
• 3、双击帐户列表中的 Administrator 项，将账户已禁用项取消勾选，然后点击确定按钮。
• 4、这时，点击开始按钮，再点击你的头像，你可以看到 Administrator 项，只要点击它，我们就可以 以 Administrator 帐户登录 Windows 了。
• 5、以 Administrator 账户登录 Windows 后，打开 regedit。
• 6、定位到以下位置：\HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\Explorer\
• 7、在窗口右侧的空白处点击鼠标右键，选择新建 - 新建 DWORD（32 位）值，并将该值命名为：NoDrives
• 8、以下是一份对照表，这个表我们接下来有用。

　　A：1
　　B：2
　　C：4
　　D：8
　　E：16
　　F：32
　　G：64
　　H：128
　　I：256
　　J：512
　　K：1024
　　L：2048
　　M：4096
　　N：8192
　　O：16384
　　P：32768
　　Q：65536
　　R：131072
　　S：262144
　　T：524288
　　U：1048576
　　V：2097152
　　W：4194304
　　X：8388608
　　Y：16777216
　　Z：33554432
　　所有：67108863

想要隐藏 E 盘，查表可知，该盘对应的值为 16。

• 9、双击我们刚刚新建的名为 NoDrives 的 DWOED（32 位）值，将该值基数改为 10 进制，再将该值的数值数据设置为 16。
• 10、重启电脑后，打开文件资源管理器（此电脑），可见，E 盘已经消失了。
• 11、要进入 E 盘非常简单，我们只需在文件资源管理器的地址栏输入：E:\，然后回车即可。

如何恢复？

如果你不想再隐藏 E 盘，那么你可以通过以下方式恢复：

以 Administrator 帐户登录 Windows。打开 regedit，定位到以下位置：\HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Policie，找到名为 NoDrives 的 DWORD（32 位）值，双击该值，将其数值数据改为 0，然后重启即可。

重置组策略

在 Windows 系统中，通过组策略我们可以设置系统的各种软件、计算机和用户策略等。不小心将组策略中的设置修改错了，导致系统中的很多组件都无法使用了，这该怎么办呢？这时候重置组策略编辑器是最好的解决办法

还原本地安全策略

用于管理 Windows 安全选项的安全策略与组策略使用了不同的管理控制台 ——secpol.msc（本地安全策略），该安全设置管理单元对组策略进行了扩展，可方便个人用户或域管理员手动配置和定义计算机安全策略。

如果你对 Windows 的安全管理策略不太了解，又自己手动更改了一些乱七八糟的设置，可以通过如下步骤对本地安全策略进行还原：

• 1、使用 Windows + X 快捷键打开「命令提示符（管理员）」；
• 2、执行如下命令：

  secedit /configure /cfg %windir%\inf\defltbase.inf /db defltbase.sdb /verbose

• 3、命令执行完成之后需要重启计算机才能生效，如果某些组件仍出现奇怪的问题，可以通过下面介绍的步骤来重置组策略对象。

使用命令行重置组策略对象

此种方法比较特殊，我们可以直接从安装 Windows 的分区中直接删除组策略配置文件夹，以达到全部重置目的：

• 1、使用 Windows + X 快捷键打开「命令提示符（管理员）」；
• 2、执行如下命令：

  RD /S /Q "%WinDir%\System32\GroupPolicyUsers" RD /S /Q "%WinDir%\System32\GroupPolicy" gpupdate /force

• 3、命令执行完成后重启计算机即可。

禁用设置和控制面板

该方法适用于：Win10 + 专业版 / 企业版 / 教育版

• 1、运行 gpedit；
• 2、定位到：用户配置 - 管理模板 - 控制面板，在窗口的右侧找到并双击禁止访问 “控制面板” 和 PC 设置；
• 3、在弹出的窗口中选择已启用，点击确定按钮；
• 4、当你完成这些步骤后，用户将无法打开设置。

该方法适用于：Win10 + 家庭版

重要提醒：编辑注册表是有风险的，如果你不小心误操作，这则可能对你电脑的系统造成不可逆转的损害，在继续之前，我们建议你备份注册表或者创建系统还原点。

• 1、运行 regedit；
• 2、定位到：\HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Policies\Explorer\，在窗口右侧的空白处单击鼠标右键，选择新建 - DWORD（32 位）值，并将此值命名为：NoControlPanel；
• 3、双击刚刚新建的名为 NoControlPanel 的 DWORD（32 位）值，将数值数据由 0 改为 1 ，点击确定按钮；
• 4、完成这些步骤后，用户将无法打开设置。

如何恢复？

• 1、如果你是使用组策略编辑器来禁用设置和控制面板的，要恢复原样，你需要进入组策略编辑器，来到以下目录：用户配置 - 管理模板 - 控制面板，在窗口的右侧重新找到禁止访问 “控制面板” 和 PC 设置，双击它，然后在弹出的窗口中将已启用改回未配置，点击确定按钮。
• 2、如果你是使用注册表编辑器来禁用设置和控制面板的，要恢复原样，你需要进入注册表编辑器，来到以下目录：\HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Policies\Explorer\，在窗口的右侧找到名为 NoControlPanel 的 DWORD（32 位）值，双击它，将数值数据由 1 改成 0 ，点击确定按钮。

禁用注册表

没事不要乱动注册表 / 邪恶

Windows Registry Editor Version 5.00

[HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System]
"DisableRegistryTools"=dword:00000001

[Version]
Signature=“$CHICAGO$”
[DefaultInstall]
DelReg=del
[del]
HKCU,Software\Microsoft\Windows\CurrentVersion\Policies\System,Disableregistrytools,1,00,00,00,00

右键选择安装解锁

reg add "HKEY_LOCAL_MACHINESOFTWAREMicrosoftWindowsSelfHostApplicability" /v "BranchName" /d "fbl_release" /t REG_SZ /f
reg add "HKEY_LOCAL_MACHINESOFTWAREMicrosoftWindowsSelfHostApplicability" /v "ThresholdRiskLevel" /d "low" /t REG_SZ /f
reg deldte "HKEY_LOCAL_MACHINESOFTWAREMicrosoftWindowsSelfHostApplicability" /v "ThresholdInternal" /f
reg deldte "HKEY_LOCAL_MACHINESOFTWAREMicrosoftWindowsSelfHostApplicability" /v "ThresholdOptedIn" /f

小试身手

我猜您和我们一样会很兴奋在以太坊区块链上部署智能合约并与之交互。

别担心，作为我们的第一个智能合约，我们会将其部署在本地测试网络上，因此您不需要任何开销就可以随意部署和运行它。

编写合约

第一步访问 Remix 并创建一个新文件。 在 Remix 界面的左上角添加一个新文件，并输入所需的文件名。

在这个新文件中，我们将粘贴如下代码：

// SPDX-License-Identifier: MIT
pragma solidity >=0.5.17;

contract Counter {

    // Public variable of type unsigned int to keep the number of counts
    uint256 public count = 0;

    // Function that increments our counter
    function increment() public {
        count += 1;
    }

    // Not necessary getter to get the count value
    function getCount() public view returns (uint256) {
        return count;
    }

}

如果您曾经写过程序，应该可以轻松猜到这个程序是做什么的。 下面按行解释：

• 第 3 行：定义了一个名为 Counter 的合约。
• 第 6 行：我们的合约存储了一个无符号整型 count，从 0 开始。
• 第 9 行：第一个函数将修改合约的状态并且 increment() 变量 count。
• 第 14 行，第二个函数是一个 getter 函数，能够从智能合约外部读取 count 变量的值。 请注意，因为我们将 count 变量定义为公共变量，所以这个函数是不必要的，但它可以作为一个例子展示。

第一个简单的智能合约到此结束。 正如您所知，它看上去像是 Java、C++ 这样的面向对象编程语言中的一个类。 现在可以运行我们的合约了。

部署合约

当我们写了第一个智能合约后，我们现在可以将它部署在区块链中并运行它。

在区块链上部署智能合约实际上只是发送了一个包含已编译智能合约代码的交易，并且没有指定任何收件人。

我们首先点击左侧的编译图标来编译合约：

然后点击编译按钮：

您可以选择 “自动编译” 选项，这样当您在文本编辑器中保存内容时，合约始终会自动编译。

然后切换到部署和运行交易屏幕：

在 “部署和运行交易” 屏幕上，仔细检查显示的合约名称并点击 “部署”。 在页面顶部可以看到，当前环境为 “Javascript VM”，这意味着当前我们在本地测试区块链上部署智能合约并交互，这样测试可以更快，也不需要任何费用。

点击 “部署” 按钮后，您可以看到合约在底部显示出来。 点击左侧的箭头展开，可以看到合约的内容。 这里有我们的变量 counter、函数 increment() 和 getter getCounter()。

如果您点击 count 或 getCount 按钮，它将实际检索合约的 count 变量的内容，并显示出来。 因为我们尚未调用 increment 函数，它应该显示 0。

现在点击按钮来调用 increment 函数。 您可以在窗口底部看到交易产生的日志。 当按下检索数据按钮而非 increment 按钮时，您看到的日志有所不同。 这是因为读取区块链的数据不需要任何交易（写入）或费用。 因为只有修改区块链的状态需要进行交易。

在按下 increment 按钮后，将产生一个交易来调用我们的 increment() 函数，如果我们点击 count 或 getCount 按钮，将读取我们的智能合约的最新状态，count 变量大于 0。

使用事件记录智能合约中的数据

在 solidity 中，事件是智能合约可触发的调度信号。 去中心化应用或其他任何连接到以太坊 JSON-PRC API 的程序，都可以监听这些事件，并执行相应操作。 可以建立事件的索引，以便稍后可以搜索到事件历史记录。

在撰写这篇文章之时，以太坊区块链上最常见的事件是由 ERC20 代币转账时触发的 Transfer 事件。

event Transfer(address indexed from, address indexed to, uint256 value);

事件签名在合约代码内声明，并且可以使用 emit 关键字来触发。 例如，transfer 事件记录了谁发起了转账 (from)，转账给谁 (to)，以及转账的代币数转账 (value)。

我们再次回到 Counter 智能合约，决定在每次值发生变化时进行记录。 由于这个合约不是为了部署，而是作为基础，通过扩展来构建另一个合约：因此它被称为抽象合约。 在我们 counter 示例中，它将类似于如下：

pragma solidity 0.5.17;

contract Counter {

    event ValueChanged(uint oldValue, uint256 newValue);

    // Private variable of type unsigned int to keep the number of counts
    uint256 private count = 0;

    // Function that increments our counter
    function increment() public {
        count += 1;
        emit ValueChanged(count - 1, count);
    }

    // Getter to get the count value
    function getCount() public view returns (uint256) {
        return count;
    }

}

注意：

• 第 5 行：我们声明了事件及其包含的内容、旧值以及新值。

• 第 13 行：当我们增加 count 变量的值时，我们会触发事件。

如果我们现在部署合约并调用 increment 函数，如果您在名为 logs 的数组内单击新交易，我们将看到 Remix 会自动显示它。

日志在调试智能合约时非常有用，另一方面，如果您构建一个不同人使用的应用，并且使分析更容易跟踪和了解您的智能合约的使用情况，那么日志也是非常重要的手段。 交易生成的日志会显示常见的区块浏览器中，并且，举例来说，您也可以使用它们来创建链外脚本，用于侦听特定的事件，并且这些事件发生时采取相应操作。

注册钱包

安装 Chrome MetaMask 插件

https://chrome.google.com/webstore/detail/metamask/nkbihfbeogaeaoehlefnkodbefgpgknn

注册绑定你的账号。

添加 BSC Testnet （测试网络）

添加自定义网络

• 网络名称：BSC Testnet

• RPC URL: https://data-seed-prebsc-1-s1.binance.org:8545/

• 链 ID: 0x61

• 区块浏览器：https://testnet.bscscan.com/

• 货币符号: BNB

每日领取测试 BNB

进入 https://testnet.binance.org/faucet-smart , 填入账户 Address 领取测试链的 BNB。

BNB 用于支付测试网络的燃料费用.

在 metamask 钱包中也可以看到这笔 BNB 到账了。

发行 MHGC (MHuiGCoin) 代币

进入 Remix 环境 中

FILE EXPLORERS

依次创建三个文件: EIP20.sol、EIP20Factory.sol、EIP20Interface.sol。

/*
Implements EIP20 token standard: https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
.*/


pragma solidity ^0.4.21;

import "./EIP20Interface.sol";


contract EIP20 is EIP20Interface {

    uint256 constant private MAX_UINT256 = 2**256 - 1;
    mapping (address => uint256) public balances;
    mapping (address => mapping (address => uint256)) public allowed;
    /*
    NOTE:
    The following variables are OPTIONAL vanities. One does not have to include them.
    They allow one to customise the token contract & in no way influences the core functionality.
    Some wallets/interfaces might not even bother to look at this information.
    */
    string public name;                   //fancy name: eg Simon Bucks
    uint8 public decimals;                //How many decimals to show.
    string public symbol;                 //An identifier: eg SBX

    function EIP20(
        uint256 _initialAmount,
        string _tokenName,
        uint8 _decimalUnits,
        string _tokenSymbol
    ) public {
        balances[msg.sender] = _initialAmount;               // Give the creator all initial tokens
        totalSupply = _initialAmount;                        // Update total supply
        name = _tokenName;                                   // Set the name for display purposes
        decimals = _decimalUnits;                            // Amount of decimals for display purposes
        symbol = _tokenSymbol;                               // Set the symbol for display purposes
    }

    function transfer(address _to, uint256 _value) public returns (bool success) {
        require(balances[msg.sender] >= _value);
        balances[msg.sender] -= _value;
        balances[_to] += _value;
        emit Transfer(msg.sender, _to, _value); //solhint-disable-line indent, no-unused-vars
        return true;
    }

    function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
        uint256 allowance = allowed[_from][msg.sender];
        require(balances[_from] >= _value && allowance >= _value);
        balances[_to] += _value;
        balances[_from] -= _value;
        if (allowance < MAX_UINT256) {
            allowed[_from][msg.sender] -= _value;
        }
        emit Transfer(_from, _to, _value); //solhint-disable-line indent, no-unused-vars
        return true;
    }

    function balanceOf(address _owner) public view returns (uint256 balance) {
        return balances[_owner];
    }

    function approve(address _spender, uint256 _value) public returns (bool success) {
        allowed[msg.sender][_spender] = _value;
        emit Approval(msg.sender, _spender, _value); //solhint-disable-line indent, no-unused-vars
        return true;
    }

    function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
        return allowed[_owner][_spender];
    }
}

import "./EIP20.sol";

pragma solidity ^0.4.21;


contract EIP20Factory {

    mapping(address => address[]) public created;
    mapping(address => bool) public isEIP20; //verify without having to do a bytecode check.
    bytes public EIP20ByteCode; // solhint-disable-line var-name-mixedcase

    function EIP20Factory() public {
        //upon creation of the factory, deploy a EIP20 (parameters are meaningless) and store the bytecode provably.
        address verifiedToken = createEIP20(10000, "Verify Token", 3, "VTX");
        EIP20ByteCode = codeAt(verifiedToken);
    }

    //verifies if a contract that has been deployed is a Human Standard Token.
    //NOTE: This is a very expensive function, and should only be used in an eth_call. ~800k gas
    function verifyEIP20(address _tokenContract) public view returns (bool) {
        bytes memory fetchedTokenByteCode = codeAt(_tokenContract);

        if (fetchedTokenByteCode.length != EIP20ByteCode.length) {
            return false; //clear mismatch
        }

      //starting iterating through it if lengths match
        for (uint i = 0; i < fetchedTokenByteCode.length; i++) {
            if (fetchedTokenByteCode[i] != EIP20ByteCode[i]) {
                return false;
            }
        }
        return true;
    }

    function createEIP20(uint256 _initialAmount, string _name, uint8 _decimals, string _symbol)
        public
    returns (address) {

        EIP20 newToken = (new EIP20(_initialAmount, _name, _decimals, _symbol));
        created[msg.sender].push(address(newToken));
        isEIP20[address(newToken)] = true;
        //the factory will own the created tokens. You must transfer them.
        newToken.transfer(msg.sender, _initialAmount);
        return address(newToken);
    }

    //for now, keeping this internal. Ideally there should also be a live version of this that
    // any contract can use, lib-style.
    //retrieves the bytecode at a specific address.
    function codeAt(address _addr) internal view returns (bytes outputCode) {
        assembly { // solhint-disable-line no-inline-assembly
            // retrieve the size of the code, this needs assembly
            let size := extcodesize(_addr)
            // allocate output byte array - this could also be done without assembly
            // by using outputCode = new bytes(size)
            outputCode := mload(0x40)
            // new "memory end" including padding
            mstore(0x40, add(outputCode, and(add(add(size, 0x20), 0x1f), not(0x1f))))
            // store length in memory
            mstore(outputCode, size)
            // actually retrieve the code, this needs assembly
            extcodecopy(_addr, add(outputCode, 0x20), 0, size)
        }
    }
}

// Abstract contract for the full ERC 20 Token standard
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
pragma solidity ^0.4.21;


contract EIP20Interface {
    /* This is a slight change to the ERC20 base standard.
    function totalSupply() constant returns (uint256 supply);
    is replaced with:
    uint256 public totalSupply;
    This automatically creates a getter function for the totalSupply.
    This is moved to the base contract since public getter functions are not
    currently recognised as an implementation of the matching abstract
    function by the compiler.
    */
    /// total amount of tokens
    uint256 public totalSupply;

    /// @param _owner The address from which the balance will be retrieved
    /// @return The balance
    function balanceOf(address _owner) public view returns (uint256 balance);

    /// @notice send `_value` token to `_to` from `msg.sender`
    /// @param _to The address of the recipient
    /// @param _value The amount of token to be transferred
    /// @return Whether the transfer was successful or not
    function transfer(address _to, uint256 _value) public returns (bool success);

    /// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
    /// @param _from The address of the sender
    /// @param _to The address of the recipient
    /// @param _value The amount of token to be transferred
    /// @return Whether the transfer was successful or not
    function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);

    /// @notice `msg.sender` approves `_spender` to spend `_value` tokens
    /// @param _spender The address of the account able to transfer the tokens
    /// @param _value The amount of tokens to be approved for transfer
    /// @return Whether the approval was successful or not
    function approve(address _spender, uint256 _value) public returns (bool success);

    /// @param _owner The address of the account owning tokens
    /// @param _spender The address of the account able to transfer the tokens
    /// @return Amount of remaining tokens allowed to spent
    function allowance(address _owner, address _spender) public view returns (uint256 remaining);

    // solhint-disable-next-line no-simple-event-func-name
    event Transfer(address indexed _from, address indexed _to, uint256 _value);
    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}

SOLIDITY COMPILER

我们选择 0.4.21 版本的编译环境.

点击编译.

在这里你可以将源码发布到 IPFS.

Metadata of "eip20" was published successfully.
token/EIP20.sol : 
dweb:/ipfs/QmZemboWkhVyhYMRyCJmjwhw4caenvXS5Mw7Uc5tdE77jP
token/EIP20Interface.sol : 
dweb:/ipfs/QmWQEUAdy5QnnCTGsEtRfedZrVG2xZ77YfKiPE5MVvQiSS
metadata.json : 
dweb:/ipfs/QmWFrJHPJLEWJGAoXpq8MD1pGJsvdcfxhPiW5SDXiwEvm8

DEPLOY & RUN TRANSACTIONS

运行环境选择 Injected Web3

因为我们用的是 metamask 钱包；Account 账户填写 metamask 钱包账户；此时浏览器插件会弹出，我们选择连接账户。点击下一步，点击连接.

在 DEPLOY 中输入部署信息，合约构造函数的输入参数.

_INITIALAMOUNT: "21000000000000000000000000"
_TOKENNAME: "MHuiGCoin"
_DECIMALUNITS: "18"
_TOKENSYMBOL: "MHGC"

发币数量 21000000, 和比特币一样，向中本聪致敬。

货币名称 MHuiGCoin，最小货币单位 18（decimaUnits），货币简称 MHGC。

点击 transact.

点击确认支付燃料费用.

从 Deployed Contracts 复制部署的合约地址: 0xeb86A66E2d4A51F8de3d4d0F509f18A15Cde68F6.

导入代币合约

进入部署合约的 MetaMask 账户，点击导入代币.

输入代币合约信息

• 代币合约地址：0xeb86A66E2d4A51F8de3d4d0F509f18A15Cde68F6

• 代币符号：MHGC

• 小数精度：18

可以看到我的账户中有 21000000 MHGC (MHuiGCoin)

代币转账测试

我们创建一个新的账户，并导入上面的代币合约.

我们向目标账户发送 1 MHGC 测试

需要支付测试网络的燃料费用.

转账发送成功.

测试网络资源管理器

在资源管理器中查看 资产:

https://testnet.bscscan.com/token/0xeb86A66E2d4A51F8de3d4d0F509f18A15Cde68F6

可以看到资源信息和公开的转账记录.

如你所见这些在区块链中已经发生的历史信息是无法更改的.

安全风险提示

任何人都可以创建代币，包括创建现有代币的假版本。了解更多关于 欺诈和安全风险.

2016 年 6 月，The DAOEther 的漏洞造成损失 5000 万美元，而开发者试图达成共识的解决方案。DAO 的程序在黑客删除资金之前有一段时间的延迟。以太坊软件的一个硬分叉在时限到期之前完成了攻击者的资金回收工作。

2021 年 9 月 24 日，中国人民银行发布进一步防范和处置虚拟货币交易炒作风险的通知。通知指出，虚拟货币不具有与法定货币等同的法律地位。比特币、以太币、泰达币等虚拟货币具有非货币当局发行、使用加密技术及分布式账户或类似技术、以数字化形式存在等主要特点，不具有法偿性，不应且不能作为货币在市场上流通使用 。

最后

MHGC 获取方式

测试网络

• 网络名称：BSC Testnet

• RPC URL: https://data-seed-prebsc-1-s1.binance.org:8545/

• 链 ID: 0x61

• 区块浏览器：https://testnet.bscscan.com/

• 货币符号: BNB

代币合约

• 代币合约地址：0xeb86A66E2d4A51F8de3d4d0F509f18A15Cde68F6

• 代币符号：MHGC

• 小数精度：18

尾巴

联系我，发我地址，在 BSC Testnet 下可领取 100 MHGC.

共发行 21000000 MHGC, 集齐 22000000 MHGC 可领取精美礼品一份.

Just For Fun.

参考资料

• Welcome to Ethereum

This message is used to verify that this feed (feedId:83048545374666752) belongs to me (userId:82913974185265152). Join me in enjoying the next generation information browser https://follow.is.

唯物辩证法的总特征

唯物辩证法的基本观点是：世界是普遍联系的有机整体，同时又是变化发展的。联系和发展的观点是唯物辩证法的总特征。

事物的普遍联系

联系指事物内部各要素之间和事物之间相互影响、相互制约、相互作用的关系。

联系的特性及其具体内容如下表所示：

事物的变化发展

事物的相互联系包含事物的相互作用，而相互作用必然导致事物的运动、变化和发展。

发展是前进的、上升的运动，发展的实质是新事物的产生和旧事物的灭亡。

联系与发展的基本环节

内容与形式、本质与现象、原因与结果、必然与偶然、现实与可能构成了联系和发展的基本环节。

唯物辩证法的三大规律

对立统一规律

唯物辩证法的实质和核心

对立统一规律是唯物辩证法的实质和核心，其原因如下：

• 对立统一规律揭示了事物普遍联系的根本内容和变化发展的内在动力，从根本上回答了事物为什么会发展的问题。
• 对立统一规律是贯穿量变质变规律、否定之否定规律以及唯物辩证法基本范畴的中心线索，也是理解这些规律和范畴的 “钥匙”。
• 对立统一规律为人们提供了认识世界和改变造世界的根本方法 —— 矛盾分析析方法。

对立统一规律又称矛盾规律，矛盾是辩证法的核心概念，是否承认矛盾，是否承认矛盾是事物发展的动力和源泉，是辩证法和形而上学的根本分歧。

矛盾的两种基本属性是同一性和斗争性，矛盾的同一性和斗争性相互联结，相辅相成。

内因和外因

内因指事物发展变化的内部原因，是事物自身的矛盾。

外因指事物之间的相互联系、相互影响，是事物变化的条件。

二者的关系：内因是事物变化的依据，外因是事物变化的条件，外因必须通过内因起作用，内因与外因共同推动事物的发展。

矛盾的普遍性和特殊性

矛盾的普遍性指矛盾存在于一切事物中，存在于一切事物发展过程的始终，即” 矛盾无处不在，矛盾无时不有”。

矛盾的特殊性指各个具体事物的矛盾、每一个矛盾的各个方面在发展的不同阶段上各有其特点。矛盾的特殊性决定了事物的不同性质。

二者关系：矛盾的普遍性和特殊性是辩证统一的。矛盾的普遍性即矛盾的共性，矛盾的特殊性，即矛盾的个性。矛盾的共性是无条件的、绝对的。矛盾的个性是有条件的、相对的。任何现实存在的事物的矛盾都是共性和个性的有机统一，共性寓于个性之中，没有离开个性的共性，也没有离开共性的个性。

主次矛盾和矛盾的主次方面

主要矛盾：处于支配地位，对事物的发展起决定作用

次要矛盾：处于从属地位，对事物的发展起次要作用

主要矛盾和次要矛盾的联系：

• 相互依赖，相互影响
• 两者在一定条件下相互转化

矛盾的主要方面：处于支配地位，起主导作用的方面

矛盾的次要方面：处于被支配地位，不起主导作用的方面

矛盾的主要方面和矛盾的次要方面的联系：

• 相互依赖，相互影响
• 两者在一定条件下相互转化

方法论：

要坚持 “两点论” 和 “重点论” 的统一，“两点论” 和 “重点论” 的统一要求我们看问题既要全面地看，又要看主流、大势、发展趋势。

量变质变规律

量、质、度

量是事物的规模、程度、速度等可以用数量关系表示的规定性。

质是一事物区别于其他事物的内在规定性。

度是保持物质的稳定性的数量界限，即事物的限度、幅度和范围，这启示我们在认识和处理问题时，要掌握适度度原则。

量变和质变

量变和质变的区别如下表所示：

量变和质变的联系，辩证关系：

• 量变是质变的必要准备；
• 质变是量变的必然结果；
• 量变和质变是相互渗透的；
• 量变和质变是相互依存，相互贯通的，量变引起质变，在新质的基础上，事物又开始新的量变，如此交替循环，构成了事物的发展过程。

否定之否定规律

肯定因素和否定因素

肯定因素指维持现存事物存在的因素。

否定因素指促使事物灭亡的因素。

辩证否定观

辩证否定观的具体内容如下：

• 否定是事物的自我否定，是事物内部矛盾运动的结果。
• 否定是事物发展的环节，是旧事物向新事物的转变，是旧质到新质的飞跃。
  - 否定是新旧事物联系的环节，新事物孕育产生于旧事物，新旧事物是通过否定环节联系起来的。
• 辩证否定的实质是 “扬弃”，即新事物对旧事物既批判又继承，既克服其消极因素又保留其积极因素。

否定之否定

事物的辩证发展过程经过 “肯定 —— 否定 —— 否定之否定” 三个阶段。

否定之否定规律揭示了事物发展的前进性与曲折性的统一。这表明，事物的发展不是直线式前进，而是螺旋式上升的。按照否定之否定规律办事，要求我们树立辩证的否定观，正确看待事物发展的过程，既要看到道路的曲折，又要看到前途的光明。

物质

物质的定义

物质是不依赖于人类的意识而存在，并能为人类的意识所反应的客观存在。

物质的唯一特性是客观实在性。

物质和运动

物质和运动是不可分割的，二者关系及其具体内容如下表所示：

运动和静止

物质的运动是绝对的，而物质在运动过程中又有某种相对的静止。

运动和静止的区别如下表所示：

运动和静止的联系：

• 静止是一种不显著的运动，是运动的特殊状态；动中有静，静中有动，世界上一切事物的存在和发展，都是绝对运动和相对静止的统一。
• 只承认静止而否认运动是形而上学的不变论，只承认绝对运动而否认相对静止则导致相对主义和诡辩论。

时间和空间

时间和空间是物质运动的存在形式。

时间是指物质运动的持续性、顺序性，特点是一维性，即时间的流逝一去不复返。

空间是指物质运动空间的广延性、伸张性，特点是三维性，即空间具有长、宽、高三方面的规定性。

物质运动总是在一定的时间和空间中进行的，没有离开物质运动的 “纯粹” 时间和空间，也没有离开时间和空间的物质运动。

意识

意识的含义

意识是物质世界长期发展的产物，是人脑的机能和属性，是客观世界的主观映像。

意识是社会的人所特有的精神活动及其成果的总和。从内容上看，人的意识是知、情、意三者的统一。

意识的本质

意识是人脑这种特殊物质器官的机能。

意识是对客观存在的反映，其在内容上是客观的，在形式上是主观的。

物质和意识的辩证关系

物质和意识的辩证关系体现在：物质决定意识，意识对物质具有反作用（意识的能动作用）。

意识的能动作用主要表现在：

• 意识活动具有目的性和计划性；
• 意识活动具有创造性；
• 意识具有指导实践改造客观世界的作用（最重要的表现）；
• 意识具有调控人的行为和生理活动的作用。

正确认识和把握物质和意识的辩证关系，还需要处理好主观能动性和客观规律性的关系：

• 尊重客观规律是正确发挥主观能动性的前提；
• 只有充分发挥主观能动性，才能正确认识和利用客观规律。

前言

世界上的所有人都是由这些元素和化合物组成的，他们的平常甚至让我们高智能的人类感到尴尬。

事实上，人体的 99% 都是由空气、水、碳以及白垩组成，另外还能找到少量的比较特别的元素，如铁、锌、磷和硫。实际上，组成人体的所有物质加起来最多花几十块钱就能买到。

但是，也不知道怎么的，这些数以万计的普普通通的原子能够携手起来，组成一个能够思考呼吸的活生生的人。

这些简单的积木是如何组合在一起。这无疑是最令人着迷的问题。

你可能会认为仅仅通过科学是不能够回答这个神奇的问题的。但是你敢肯定吗？现在，我们有理由相信，科学已经在这个大胆解释这个问题方面超越了宗教和哲学的解释力。

下面我们将通过一系列相互盘根错节的伟大发现来解释自然界的不为人知的一面。

在这之中蕴含了世上最基本的法则，即不确定性的产生。

这是关于看似廖无生气、毫无目的和动机的物质世界，是如何自发的产生这些极其精细的绚丽的自然。

这是关于世间最基本的法则是如何使这个世界展现出混沌和不可预测性，如何通过简单的物质创造出人。

这是关于一个奇异的发现，即有序和混沌之间，奇特而难以置信的联系。

图灵的方程式

自然界充满了生长、发展和混乱，其中到处都是离奇的形状和杂乱的斑点。自然界的图案从来都不会固定不变，从来都不会按原样重复。

这一切看上去混乱的现象都受到数学方程式的影响。事实上，他们完全被数学规则所支配。这种数学规则与我们长久以来的直觉相悖。因此不难相信第一个能够担负此揭示自然界的数学根基重任的人会拥有超乎寻常的智慧。

他即是一个伟大的科学家，同时也是一个大悲剧。

他 1912 年生于伦敦，他的名字就是阿兰・图灵。

阿兰・图灵是一个不凡之人，他是有史以来最伟大的数学家之一。他提出了许多具有基础性的理论和见解。他的思想为现代计算机的出现提供了理论基础。

在二战期间，他在布莱切利园工作，也就是今天的米尔顿凯恩斯外。当时政府正在这里进行一个叫做 X 站的秘密项目。他的建立是为了破解德军的情报密码。

X 站项目组的密码破解人员做出了卓越有成效的工作，其中图灵的贡献至关重要。他亲自参与了破解德国海军密码的工作，因为他的工作数以万计的盟军得以幸存，同时这也导致战略形势的有利扭转。

但是图灵的天赋不仅仅表现在破解密码上，这仅仅是他那超乎常人的洞察力的一部分。对于图灵来说，自然界的密码才是终极密码。在他的一生中，他热切的寻找着破解这个密码的方法。

图灵是一个很有独创精神的人，他意识到这样一种可能性，简单的数学方程式可以描述复杂的生物世界的一些现象。他的这种想法以前从来没有人尝试过，自然界中所有的迷中最吸引图灵的，就是如何能够使用数学方程式来描述人类的智能。

图灵迷上这个想法是有原因的，这就是年轻的克里斯托弗・马尔孔的死。图灵是同性恋，克里斯托弗・马尔孔的死，在那时以及他的一生产生了重要的影响。克里斯托弗・马尔孔突然的死亡了导致阿兰图灵在情感方面产生了极大的触动。但是你能想象，他想把这个事实用科学来解释，他想解释的问题是，我们的心智怎么了，什么是心智。

图灵相信生物界的复杂的系统是可以用数学方程式来描述的，并且人类的智能也是如此。

他的这种信念导致了现代计算机的产生。

之后一个更加激进的想法出现在图灵的脑中，这个想法就是通过简单的数学描述来解释胚胎中发生的复杂的过程。

这个过程被叫做形态发生。它非常令人费解，起初胚胎中的所有细胞都是相同的，细胞们开始组合到一起，并且细胞之间渐渐产生了差异，这是如何发生的呢？物质不会自己思考，也没有一个中央系统在里面进行调度，一开始都是一样的细胞，为什么有的能够变成皮肤，而有的却变成了眼睛呢？

形态发生是一类现象中的一个例子，这类现象叫做自组织现象。

在图灵之前没有人懂得自组织现象的机制。

直到 1952 年 图灵发表了他的这一篇论文，阐述了用数学方程式来解释形态发生现象。论文中的大胆的猜测是令人震惊的，其中图灵使用了一个在天文学和原子物理学中很常见的一种数学方程式，来描述生命过程。

之前从来没有人做过这种尝试，然而图灵的方程式却第一次的做到了，描述了一个生物系统的自我组织的过程，这解释了即使简单的、毫无自然界事物特性的东西，也可以演变出栩栩如生的东西。

图灵的成果中令人大吃一惊的地方是，我们可以通过设定非常简单，甚至简单到可以仅仅通过简单的方程式就能描述的初始状态，然后让它进行演变。然后突然间，复杂和混乱就会出现，产生的复杂图案就像是自然界的结果。

从许多方面来看这些都是难以置信的。

其实图灵的方程式描述的都是我们很熟知的东西，但是从来没有人将这些数学方程式应用到生物学领域。

试想一阵风吹过沙丘，进而产生了一系列图形。小颗粒自我组织成波纹浪花和沙丘，即使那些小颗粒是彼此相同的。并且没有人告诉他们到底要怎么去组成属于他们的那一部分。

图灵认为，以一种非常形似的方式，在胚胎中渗过的化学物质可能会引导细胞进行自我组织，进而产生各种不同的形状。这是图灵给出的非常粗略的解释，他阐述了一堆毫无生气的化学物质，如何演化为各种不同的形状。

在他的论文中做了一些改进，来使他的方程式能够自发的产生生物图案，那种与动物表皮相似的图案。

图灵到处向别人展示自己生成的图形，你看这难道不像母牛身上的图案吗，其他人的反应是，这个人的脑子有问题吧。但是图灵相信自己在做一件有意义的事情，他们的确像母牛身上的花纹，这就解释了母牛拥有这种斑点花纹的现象。

这样一个数学从未触及的领域，生物界的图案，生成动物斑纹，突然间，这个领域向我们敞开了门。

我们发现数学方程式在这个领域会有用武之地，即使图灵提出的方程式，并不是这一新理论的全部，但仍然是一次重要的创举，提出了这种新方法的可能性。

我们现在知道形态发生，要比图灵所描述的数学方程式复杂多了。事实上，关于 DNA 分子确切的运转机制，仍然是现代科学上争论的话题。

但是图灵提出的数学支配万物的观点确是革命性的，阿兰・图灵的论文是整个形态发生理论的奠基石，他为我们提供了一种解释，连达尔文都没能提出的，解释自然界生物花纹的产生机制。

达尔文仅仅告诉我们，生物的花纹是来源于基因的，并且这种花纹的继承是决定于环境的，但是达尔文并没有揭示，这种生物花纹到底是如何生长的，而这是真正的迷。

图灵的贡献在于提供了了解这种化学机制的途径。图灵提出了一种伟大而勇敢的见解。

不幸的是我们仅仅能够推测这颗伟大的大脑，是如何想出这些的，在他发表他的开创性论文之后不久，一个可怕的并且完全可以避免的悲剧摧毁了他的生命。

在他在布莱切利园破解密码工作之后，你一定可以想到图灵会得到很多赞誉，以感谢他为国家做出的贡献。这再明显不过了。战后发生在他身上的事情是一个悲剧，这是英国科学史上令人感到羞耻的事情。

同年，图灵发表了关于形态发生的论文，他与阿诺德默里这个男人发生了短暂的情感，但是这段情感发展的很令人不愉快，默里对图灵进行了一次入室盗窃，但图灵将这件事情报告给警察的时候，警察连同图灵一起逮捕了。法庭上，原告声称，图灵以他的学历来诱导默里走上了歧途。图灵被判有严重的猥亵罪，法官给了图灵可怕的选择，他要么进监狱，要么接受雌性荷尔蒙注射，进而治疗他的同性恋倾向，他选择了后者。这导致了他连续不断的消沉。

1954 年 6 月 8 日，图灵的尸体被他的清洁工发现。他是一天前死于咬了一口自己注入了氰化物的苹果，结束了自己的生命。

阿兰图灵死的时候 41 岁，这对于科学来说是一种无法估量的损失。图灵不曾想到他的思想会启发后人，将一种全新的数学方法应用到生物学领域。科学家发现他发现的这种方程式，确实能够解释好多生物组织的形态。

回头看看，我们知道图灵真正捕捉到了复杂与混乱源于简单规则，这样的法则。他意外的迈出了，通往新科学的第一步。

贝洛索夫的试液

这个过程的第二步更是始料未及，可悲的是伟大的第二步也是一个悲剧。

在 20 世纪 50 年代初，在图灵发表他的对后人影响巨大的论文之际，一名杰出的俄国化学家 斯・贝洛索夫，开始了他自己的探索，关于自然界中的化学。

正在高墙铁网之后的苏维埃卫生部，他正在研究我们的身体是如何从糖中提取能量的。像图灵一样贝洛索夫也是在一个个人项目中工作，他刚刚完成了一段从事科学工作的经历。

贝洛索夫构想好了一种新的化合物配方，来模仿人体内葡萄糖的吸收，这种混合物就摆在实验室的座位前面，在被摇晃的时候清澈而透明。

在他添加最后一种试剂的时候，整个混合物的颜色发生了变化。

当然，这还不算什么特别的，就像我们将墨汁倒入水中水也会改变颜色。

但是接下来发生的事情令人感到惊奇，混合物又变得清澈无色了。

贝洛索夫感到很吃惊，化学物质混合以后会发生反应，但这个过程不能自发的发生逆反应，在不受外界干预的情况下发生可逆变化。

你可以很容易的将一个无色的液体变成有色的，但这个过程的逆过程却不太可能。这太奇怪了，贝洛索夫的试液并没有简单的发生逆变化，试液被摇晃后，就不断的在无色和有色之间变化，就好像这个试液在受一种神秘的内部机制驱动一样。

他非常谨慎小心地又重复多次这个实验，他的混合物能够不断的在无色和有色之间变化，他发现的东西好像魔术一样。一个好像是违反自然法则的物理现象。

贝洛索夫觉得自己的发现意义重大，将自己的发现记录下来，并努力让更多的人了解他的发现，但是当他将他的发现递交到一个顶尖的苏联科学杂志的时候，他收到了一个完全出乎意料的诅咒式的回复，杂志的编辑告诉贝洛索夫，他的发现是不可能在实验室重现的，因为这与基本的物理法则相违背，对这个现象的唯一的解释就是，贝洛索夫在实验的时候出了错，他的发现是不会被出版的。

这个拒绝深深的打击了贝洛索夫，他感到非常的羞辱，结果放弃了自己的实验，而后他又放弃了自己从事的事业。

具有悲剧色彩的讽刺是，由于贝洛索夫所处的闭塞环境，贝洛索夫从来没有机会看到图灵的工作成果。如果他看到了图灵的发现，就能为自己的发现提供有力的证据，事实上，贝洛索夫的不稳定试液，不仅没有违背物理法则，而且是实在就是真实的，能够体现图灵的预言的例子，尽管这两者的发现初看起来并没有什么联系。

其他科学家发现，如果将贝洛索夫的试液的一种变种，不加搅拌的放入培养皿中，而不是摇晃他们的话，他们就会发生自我组织，事实上 ，他们产生的条纹会比图灵预测的花纹要复杂。

他们会产生令人惊诧的复杂的条纹，毫无预兆。

贝洛索夫实验的惊奇之处在于，它能生成一种系统，这种系统产生了图灵方程式所预测的图案，在一个看上去无色的溶液中，产生了这种奇异的原型图案，这明显不是什么抽象科学，贝洛索夫图案的运动模式 ，与我们心脏在跳动的时候周围细胞的运动模式完全相同。动物的皮毛和心脏的跳动，自组织现象在自然界中随处可见。

牛顿经典物理学

为什么在科学界在图灵和贝洛索夫的年代 ，却对这种想法不感兴趣甚至持有敌意呢？

原因就是人类的臭毛病，主流科学家不喜欢这种观点，这与主流科学家的科学直觉相违背，也与现有的科学成就相违背，若想改变这种观念，我们需要一种彻底的，改变传统的发现。

实际上，在 20 世纪初期，科学家们把宇宙看作一个巨大而复杂的机械装置，有点像一个大号的太阳系仪，整个宇宙就好像是一个巨大的错综复杂的机器 ，严格的遵守着数学规则。如果你知道这个机器的运转机制和初始状态，那么随着你转动这个手柄，它将严格地按照预期的行为运转。

在牛顿生活的时代里，当人们在探索驱使宇宙运转的法则时，他们把宇宙看作这种按照确定规则运转的机器。宇宙就好比是一个被设定好的机器，遵循确定的法则按部就班的按照这个法则运转。

宇宙中复杂的现象是有复杂的内部规则驱使的，但是一旦一开始让它运转它只会做一件事。人们从这里看到的现象，都可以使用严格的数学公式来描述。

这实际上是很简单的事情，一旦找到能够描述系统运行的数学方程式，那么你就能够预测系统的走向。

这是一个伟大的想法。

它开始于牛顿的万有引力。万有引力成功的解释了行星围绕太阳运转的现象。科学家们后来又不断的发现了新的方程，牛顿物理似乎已成为了预言宇宙的终极方法。

它给我们暗示了这样一种可能，从原则上讲，未来是可以预测的。

我们采用的测量手段越精确，我们就能越精确的预测未来的情形。

但是牛顿物理产生了一个可怕的后果，如果有一个系统我们能够用数学方程式精确描述，就像这个太阳仪一样，那么一旦它表现出了一些我们不能预测的行为之后，科学家就只能认为，是有某种外界力量影响了这个系统，比如说是沙土跑进去了，或者是小零件磨损了，或者有人对它进行了认为的改动。

一般情况下，我们会这样假设，如果我们遇到了非预期的现象，那么这种现象应该是来自系统外部的干扰，而不是来自系统内部的。不可预测的现象，不是来自系统的本身，而是来自与外部对它的影响。

从这种观点的角度来看，自我组织这种现象是很荒谬的，而图灵和贝洛索夫所表达的，复杂图案可以从系统中自我生成，而不需要外界力量是非常受当时的主流科学所忌讳的。

要想使人接受自我组织理论，那么，就必须推翻牛顿物理学，但这看上去很不可能，无论如何这种新思想在 60 年代末期，成为了新时代的奇景。

蝴蝶效应

然而同时，伴随着登月计划，一小群信奉牛顿力学的科学家，意外的发现了一些事情不对劲，完全不对劲。

在 20 世纪后半叶，科学界的噩梦出现了，这个噩梦，动摇了牛顿的思想，并将我们推向了一片思想的混乱。

具有讽刺意味的是，迫使科学界接受自我组织理论的事情，是一种我们叫做混沌的现象。

混沌这个词被广泛使用，但是在科学领域中，它有它专指的意义。它指的是在一个能被数学方程式精确描述的系统中，可以自发生成不可预测的现象，并且不需要任何外界的干预。

通过使用非常简单的法则或方程式，并且里面不包含任何的随机性，系统中的所有元素都是确定的，并且我们完全掌握系统的法则，即使是这样的系统也会产生完全不可预测的现象。

混沌的发现并不讨主流科学的喜欢，有一个人迫使科学界接受混沌，他就是美国的气象学家爱德华・洛伦兹。

在 20 世纪 60 年代早期，他试图寻找能够预测天气变化的数学模型。就像许多他的同事一样，他相信天气系统与我们太阳系仪是一样具有确定性的，一个可以被数学描述和预测的物理系统。

但是他错了，当洛伦兹写下一个用于描述气流的及其简单的数学方程式时，这些方程式并没有达到他预想的目的，他们没有做出任何有价值的预测，这就好像说某一天中的一阵清风，将会决定一个月后的某天是冰雪连天，还是清空万里。

对于一个像太阳系仪这样精准的系统来说，怎么会产生不可预测性呢？

这源于他的内部构造，由于齿轮的链接方式。

事实上，在某种情况下，即使在初始的时候有一点点误差，哪怕这个误差小到难以测量，这个误差会随着机械的运转而不断被放大，随着系统的运转，系统的状态会一点一点的偏离你所期望的状态。

洛伦兹在一次演讲中表达了这一颠覆性的想法，演讲的题目是 —— 一只蝴蝶在巴西扇动翅膀会使美国的德克萨斯刮一场龙卷风吗？

这是一次有力而吸引人的演讲，数月之内，我们的语言中就添加了一个新的词汇 —— 蝴蝶效应。

蝴蝶效应就是混沌系统的标志，它开启了之后的一切。

在 70 年代早期 一个叫罗伯特・梅的年轻澳大利亚人，正在研究一个数学方程式，用它来模拟生物种群随时间的变化。

但是这个过程中同样牵扯到蝴蝶效应，哪怕生物的繁殖率发生了极小的变动，都会导致种群数量结果发生巨大的变化，这个数值可能会毫无征兆的上下起伏。

传统的使用数学方程式，来描述系统行为的方法似乎走到了死胡同，某种意义上，这是信仰牛顿学说的人的美梦之终结。

随着我们的计算能力的提高，我们就有能力处理更复杂的方程组，但刚才我们所看到的否认了这种观念。

你可以从一个及其简单的方程式开始，这个方程式简单而不存在任何的随机性，但是如果它产生的行为能够表现出一种混沌性，那么你就不能再回溯到系统的初始状态了。

数百年来所建立的科学观点在几年内就被瓦解了，可以精确描述宇宙的运行的这一想法变成了幻影。

看上去具有逻辑确定的事情，却变得更像是一种信仰。更糟的是，这种现像到处都是。因为混沌到处都是。

似乎不可预测性是固有的，存在于我们生活的宇宙中。

全球气候可能会在几年的时间内，发生剧烈的变化；股市可能会毫无征兆的崩盘；我们可能会在一夜之间从地球上灭绝。

如果这种事情发生的话 没有人能够阻止，不幸的是，我不得不说以上这些都是真的。但是盲目的恐惧混沌现象是毫无意义的。

因为混沌是一条基本的物理法则，我们必须承认它是生活中的一部分。

混沌理论的出现一直影响到之后 20 到 30 年人们的思想，它改变了人们对于科学工作的看法，它深刻的改变了科学家看问题的方式，以至于科学家们现在已经离不开混沌理论了。

混沌理论想要说明的是，简单的数学方程式能够繁衍出复杂的行为，这种复杂性超出你我的想象，所以简单而机械的系统能够表现出复杂和丰富的行为。

混沌理论的发现，是科学史上的一次重大的转折点，它摧毁了牛顿信仰者的梦想，科学家们现在越来越看得惯图灵和贝洛索夫在自发生成花纹上所做的工作。

自反馈系统

更重要的是，由于他们的工作，一个伟大的真相浮出水面，那是一种内在而隐蔽的关联，一个贯穿宇宙的关联，关联着自然的神秘力量和自我组织现象，以及蝴蝶效应产生的混沌结果。

图灵、贝洛索夫、梅、洛伦兹这些人都分别发现了一种重大思想的不同侧面。他们发现自然界具有固有的不可预测性，这种不可预测性的内部驱动力，也可以使系统表现出特定的结构和花纹，有序与混沌，似乎要比我们想象的要联系的更加紧密，但这种联系是如何实现的呢？贝洛索夫的花纹与天气变化之间有什么联系呢？

首先，虽然两个系统都有复杂的工作机制，但他们都是基于及其简单的是数学法则，其次，这些数学法则都具有一种独特的特性，都具有自我链接的特性或者说是自反馈。

为了向你展示这一点，展示简单的自反馈系统的力量，将使用一种看上去简单甚至无聊的实验。

身后的屏幕连接到一台摄像机，这台摄像机同时也在拍摄着我和屏幕，这样不断的循环就能产生无数个人的影像，都投影到屏幕上，这是一个典型的自反馈系统。图片中不断的嵌套着其他的图片。

这乍看上去肯定有规则，但当我们放大镜头，奇怪的事情发生了，我首先发现的是实物图像和屏幕上显示的图像不像了，火柴的微小运动被迅速放大，当影像在摄像机和屏幕之间反复映射的时候，即使我能用精确的数学对外的每一步动作进行描述，但我却不能预测火焰微小的变化，会导致最终的图像如何变化，这就是一种实实在在的蝴蝶效应。

下面的现象变得更离奇了，通过像系统中添加一点点的扰动，这些奇异而美丽的图案就出现了，这种简单的依赖反馈的系统，呈现出了混沌与有序，同样的数学方程式同时产生了混沌和有序的图案。

这将改变你对世界的看法，在传统观念中，自然界都是有序的，混乱存在与系统之外，即有序与混乱是相互独立的这种想法是错的，其实混乱和有序，就像同一架钢琴上弹出的高音和低音，这个发现有史以来第一次如此接近自然界的数学本质。

我们能从图灵的工作，以及化学和生物中得到的，最重要的启示是，所有复杂的图形都是来自，宇宙间简单的演变过程，像扩散， 像化学反应率，这些简单的过程最终导致了图案的产生，所以到处能看到图案，他们不断的产生。

曼德勃罗集合

从 70 年代开始越来越多的科学家，开始接受混沌理论，以及对自然界能够自发产生复杂花纹的认可，但是有一位科学家比别人走的更远，对这个令人惊奇颇感迷惑的问题带了个新思路，他是一个具有传奇色彩的不喜欢按套路出牌的人，他叫伯努瓦・曼德勃罗。

伯努瓦・曼德勃罗 并不是一个寻常的孩子，他跳了两个年级。并且由于他是战时欧洲的犹太人，所以他受到的正规教育极其有限，他基本上是靠自学以及亲属对他的教育，他从来没有正式的学习过字母，甚至没有学过 5 以上的乘法。

但是和图灵一样，曼德勃罗具有一种洞悉事物本质的本领，他能从混乱中看到我们所看不到的规律，他能够发现形式和结构，然而我们却仅仅能看到一片混乱，他能够感知一种新奇的数学，用来支配整个自然界的运转。

曼德勃罗的一生都致力于找到一种能够揭示自然界复杂性的一种数学支持。

曼德勃罗当时为 IBM 工作，而不是学校的学术圈内，他试图解决一大堆的问题，关于自然界以及金融界的不确定性，在各个方面的表现。

我觉得他知道自己，所做的所有工作都是一个大问题的不同侧面。

他是一个具有原创精神的人，他觉得求解这个大问题是他真正想做的事情。

在曼德勃罗看来，几百年来传统的数学研究都仅限于，规则的图形是一种很不可取的行为，就像直线和圆，传统的数学是没有办法描述不规则的形状的，而真实世界确是有不规则形状组成的，就像这个鹅卵石，它是一个球体还是一个立方体呢，还是它们中间的某种形状？他到底是一种什么形状？

曼德勃罗想，是否有一种法则，能够描述自然界的不规则性，那些蓬松的云朵、树和河流的分支，以及蜿蜒的海岸线之间有什么共同的数学基础。

是的，有的。

自然界中所有的形状的共同特点，就是自相似性。这指的是事物的局部，不断的在更微小的尺度上重复自己，不断的精细到每一个细微之处，树枝就是一个绝好的例子，他们不断的分叉，重复这这个简单的过程，在更微小的尺度上不断重复这这个过程。

我们的肺的结构同样遵循这个原则构建，我们体内血管的分布同样遵循这样的规则，河流分成更小的溪流也是这样，自然界可以依照这种方法不断重复各种形状。

看看这个罗马花椰菜，他的总体结构是由许多重复的小圆锥组成的，曼德勃罗意识到自我重复性，是一种全新的几何学的基础，并给这种几何图形起了一个名字 —— 分形。

分形看上去非常简单直观，但是我们如何才能用数学对它进行描述，你能够利用分形的本质画一幅相似的图形吗？那么这张图形会像什么？你能仅使用一些简单的数学法则，来绘制一幅看上去像是自然创造的图案吗？

曼德勃罗找到了答案。

曼德勃罗爱 20 世纪 50 年代末就职与 IBM，因此有机会使用计算机，并且利用计算机这个工具来寻找自然界的数学本质。

在新一代的超级计算机的帮助下，他开始研究一个看上去很奇怪，但却异常简单的数学方程式，使用这个数学方程式可以绘制一幅不同寻常的图形，我将向你展示的是一幅非常吸引人的图画。它完全由数学产生，惊人之举往往不同寻常。

这就是曼德勃罗集合，他被称为上帝的指纹，当我们仔细看看这幅图后，你就知道我们为什么这么叫了。

>> 鼠标选择区域放大查看曼德勃罗集合细节 <<

就像树和花椰菜一样，你看得越仔细你发现的细节就越多，在这个集合中的每一个图形，都包含了无穷多个小图形，小的子图无穷无尽，然而所有这些复杂的分支都来自有一个简单的方程，这个方程有一个非常重要的特性，它是自反馈的。

每一次输出都成为了下一次计算的输入，这种反馈系统展示了一个简单的，方程式是如何展现出无比绚丽的图案的。

但是令人惊奇的是，曼德勃罗集合并不是一个奇怪的数学巧合，它的这种无穷分形的特性，反映了一种自然的有序的本性，图灵图案、 贝洛索夫的化学反应、曼德勃罗的分形都分别指向了一个自然本质。

简单的法则 无穷的创造

当我们看到自然界的复杂面貌时，我们倾向于问，他们来自哪里，我们总是抱有这样的观念。

简单的事物不能导致复杂性的产生，复杂的现象必须源于复杂的设计。

但是我们刚才看到的数学方程式告诉我们，极其简单的法则也会繁衍出复杂的现象。

当你看到复杂现象的时候，你应该想到，驱使它产生的只不过是简单的法则，所以同一个方程式从不同的角度看，既简单又复杂，这就意味着我们需要重新思考，简单性于复杂性之间的关系。

复杂的系统可以基于简单的法则。

这是一个重大的启示，也是一种伟大的思想。它似乎适用于整个世界。

看看这群飞鸟，每一只鸟都遵循简单的法则，但是整个鸟群确是一个极其复杂的东西，他会自动的避开障碍在没有领航情况下进行自我导航，甚至是做计划。

虽然这个鸟群的行为很显著，但我们却不能预测他的行为，它不会重复原先的行为，即使是在相同的环境下。

就像贝洛索夫的化学反应一样，每次你进行这个化学反应产生的图案都稍有不同，他们可能看上去相似但却不可能相同。

对于自反馈的影响和 沙丘同样是这样，我们知道它会产生某种图像，但是我们却不能预测确切的形状。

生物进化的原料

我们关心的问题是，大自然能够以这种方式将简单的法则，演绎出复杂的现象吗？

试着解释一下为什么会有生命的存在，它能够解释为什么充满砂石的世界，是怎么产生人类的吗？

毫无生机的事物是如何变得充满智能的呢？

进化正是基于这些简单的生物花纹，进化将这些当成原料，并把它们以不同的方式结合在一起，看看哪些结合方式有效，哪些无效，

保存那些有效的结合，并在它们的基础上进一步演化。

这是一个完全没有意识控制的变换过程，但这基本上就是现实中发生的事情，放眼望去，进化的过程到处都是使用自然界的自我组织的图案。

我们的心脏使用类似贝洛索夫反应的方式来驱使它有节律跳动，我们的血管的组织形式就像分形，就连我们的脑细胞也是遵循极其简单的规则，进化过程丰富并筛选这我们的世界的复杂性。

这是近代科学最有魅力的发现。

计算机模拟的进化机制

一方面你拥有一个具有自组织能力的复杂系统，它可以产生不可预测的行为，另一方面需要将进化机制作用于它，这样才能产生适应环境的东西，进化通过无拘无束的创造力，约束着系统的演确实难以置信。

但当这个约束过程发生在宇宙级的时间尺度上，就容易理解了，从地球上第一次出现生物到我们人类的产生，整整花了 35 亿年的时间，但是我们现在手头上，有一种可以在更短的尺度上模拟这个过程的发明。

你知道我指的是什么吗？

很可能你天天就坐在这个发明面前，当然，这就是计算机。

现代的计算机每秒可以进行上亿次计算，我们可以让它们做一些奇特的事情，它们可以模拟进化过程，确切的说，计算机可以利用进化规则，来约束自己产生真实世界中的现象，使用进化规则来约束和筛选生物组织。

现在，计算机科学家发现这种能够自我演变的软件，可以取代人类最聪明的头脑来解决问题。

我们在最初的实验研究中发现，进化这种系统就像一种算法一样创造着，能够适应环境的复杂系统。

托斯顿和他的研究小组的研究目标是，使用计算机模拟的进化机制，来创造能够控制躯体运动的虚拟大脑。

一开始他们随即设置了 100 个虚拟大脑，就像你看到的这样这些大脑很笨，然后进化的力量来了，计算机自动的选择表现稍好的大脑，然后让它们产生后代，然后再选择能够做的更好的大脑，并让它们继续产生后代，下一代中能够更好的控制躯体行动的大脑，会继续得到繁殖后代的机会。

令人惊奇的是，通过 10 代的繁衍，虽然还是有一些不稳定，但这些小人确实能够行走了。

更神奇的事情是，你最终得到了一种能够正确行走的东西，但是令人感到有点害怕得到是，你却不知该它为什么能走，以及是如何行走的。

你眼睁睁看着这个大脑，却不知道它内部是如何工作的，因为这个结果是进化自动产生的结果，经过 20 代的繁衍后，

我们看到了这个，

变成了这个，

这些虚拟生物随后演化出了比行走更复杂的行为，它们产生的行为，是很难通过传统的编程方式实现的，它们对于突发事件做出了像人类一样的反应。

即使这些算法都是由我们人类编写的，但当它们一旦开始进化之后，我们就难以加以控制了，然后我们预想不到的事情就发生了。

真有一种滑稽的感觉，你创造了它们，然后它们抛开你自己做主，一种不假思索的不断尝试的进化过程，创造了这些能够行动并作出反应的虚拟生物。

我们这里看到的是一个绝妙的实验证据，来证明简单的法则具有无穷的创造力，看着计算机里面自动表演着难以用写程序的方式描述的行为，它是一个展现自我组织能力的绝好例子。

这说明了进化本身，就像我们看到的其他系统一样，是一个基于简单法则和回馈的系统，在这个系统中复杂性自发的产生了。

想想看，这个简单的法则就是，机体需要重复略有变化的行为，反馈来源于环境，这种环境选择了更适应它的行为得到生存，结果就是，在没有可以设计和规划的情况下，前所未有的复杂性就这样产生了。

有意思的事情是，一个个体可以进化到更高的一个结构状态，一旦你获得了一种包含某种行为的系统，并且这些行为可以被选择，被某种过程选择或被环境的反馈选择。所以进化过程这个达尔文学术的中心议题，在某种意义上就是图灵的反馈系统运行在多个过程之上。

尾声

这就是整个事情的本质，未经过精心设计的极其简单的法则，能够无意识的创造出无比复杂的系统。

这样看来，这些计算机虚拟的生物就是自组织系统，就像贝洛索夫在他的化学实验中发现的现象一样，就像沙丘和曼德勃罗集合所呈现出的现象一样，就像我们的肺、心脏以及我们这个星球上的天气系统。

伟大的设计并不需要一个伟大的设计者，这就是宇宙所固有的本性。

令人难以接受这种观点的是，所有形状、花纹和结构的产生，并不需要一个有意识的创造者，但这种设计本身可能需要一个更聪明的设计者，他做的事情就是将整个宇宙，作为一个巨大的仿真，在这里你设定了一些初始条件，然后一切的一切都自发的产生了。

伴随着所有的惊奇，伴随着所有的美丽，图案形成的数学本质预示着同样的图案会在许许多多不同的场合出现。

如化学生物系统，在这些系统的本质里，都存在同样的数学基础，在这些内部本质的外面，就是我们看到的今天的这个世界。

我想，这是一个令人兴奋的想法，那么我们最终能从这些当中学到什么呢？

这就是宇宙间所有的复杂性，所有的多样性，都源于一些简单而毫无目的的法则的不断繁衍的结果，但是请记住，尽管这个过程力量无比，但他却具有固有的不可预测性，即使我可以充满信心的告诉你未来精彩无限，但我仍要负责任的告诉你，未来将会发生什么确是不为人知的。

Lambda 架构

Hadoop 作为解决对大数据量低成本规模化的处理的解决方案被广泛应用

但是 MapReduce 或者 Hive 很难做到低延迟，用 Storm 开发的实时流处理技术可以帮助解决延迟性的问题，但它并不完美

• Storm 不支持 exactly-once 语义，因此不能保证状态数据的正确性

• Storm 不支持基于事件时间的处理

后来出现了一种混合分析的方法，它将上述两个方案结合起来，既保证低延迟，又保障正确性 ——Lambda

Lambda 架构是由 Storm 的作者 Nathan Marz 提出的一个实时大数据处理框架

Marz 在 Twitter 工作期间开发了著名的实时大数据处理框架 Storm，Lambda 架构是其根据多年进行分布式大数据系统的经验总结提炼而成

Lambda 的目标:

• 高容错、低延时、可扩展

Lambda 特性

• 整合离线计算和实时计算

• 读写分离和复杂性隔离

• 可集成 Hadoop，Kafka，Storm，Spark，HBase 等

Marz 认为大数据系统应具有以下的关键特性（Lambda 架构的关键特性）：

• Robust and fault-tolerant（容错性和鲁棒性）：让系统从错误中快速恢复

• Low latency reads and updates（低延时）：响应是低延时

• Scalable（横向扩容）：通过增加机器的个数来提高系统的性能

• General（通用性）：支持多领域的数据分析（金融、社交、电子商务等）

• Extensible（可扩展）：以最小的开发代价来增加新功能

• Allows ad hoc queries（方便查询）：即时查询，快速简便的进行查询

• Debuggable（易调试）：快速定位错误

Lambda 架构通过分解的三层架构来解决问题

• Batch Layer

• Speed Layer

• Serving Layer

Batch Layer

理想状态下，任何数据查询都可以从表达式 Query= function (all data) 获得，但是若数据达到相当大的一个级别（例如 PB），且还需要支持实时查询时，就需要耗费非常庞大的资源

可以将数据提前进行计算处理成为 Batch View，这样当需要执行查询时，可以从 Batch View 中读取结果。这样一个预先运算好的 View 是可以建立索引的，因而可以支持随机读取

Batch Layer 总结为：

• Batch View = function(all data)

• Query = function(BatchView)

Speed Layer

Batch Layer 的离线处理可以很好的满足大多数应用场景，但有很多场景的数据是不断实时生成，并且需要实时查询处理。Speed Layer 正是用来处理增量的实时数据并生成 Realtime View

Speed Layer 处理的数据是最近的增量数据流，Batch Layer 处理的是全体数据集

Speed Layer 为了效率，接收到新数据时不断更新 Realtime View，而 Batch Layer 根据全体离线数据集直接得到 Batch View

Speed Layer 是一种增量计算，所以延迟小

Speed Layer 总结为：

• RealtimeView＝function(RealtimeView，new data)

Batch Layer 和 Speed Layer 优点：

• 容错性：Speed Layer 中处理的数据也不断写入 Batch Layer，当 Batch Layer 中重新计算的数据集包含 Speed Layer 处理的数据集后，当前的 Realtime View 就可以丢弃，这也就意味着 Speed Layer 处理中引入的错误，在 Batch Layer 重新计算时都可以得到修正。这点也可以看成是 CAP 理论中的最终一致性（Eventual Consistency）的体现

• 复杂性隔离：Batch Layer 处理的是离线数据，可以很好的掌控。Speed Layer 采用增量算法处理实时数据，复杂性比 Batch Layer 要高很多。通过分开 Batch Layer 和 Speed Layer，把复杂性隔离到 Speed Layer，可以很好的提高整个系统的鲁棒性和可靠性

• Query = function( Batch View , Realtime View )

• Realtime View = function( Realtime View , new data )

• Batch View = function( all data )

Serving Layer

用于响应用户的查询请求，合并 Batch View 和 Realtime View 中的结果数据集到最终的数据集

Kappa 架构

Lambda 架构有时会出现批量数据和实时数据结果对不上的问题

LinkedIn 的 Jay Kreps 提出了一个新的架构：KAPPA

它的理念是：鉴于大家认为批量数据和实时数据对不上是个问题，它直接去掉了批量数据；而直接通过队列（Kafka），放入实时数据之中。

例如：将所有的数据直接放到原来的 Kafka 中，然后通过 Kafka 的 Streaming，去直接面向查询

该架构也存在着一些问题：

• 不能及时查询和训练。例如：我们的分析师想通过一条 SQL 语句，来查询前五秒的状态数据。这对于 KAPPA 架构是很难去实现的

• 面对各种需求，它同样也逃不过每次需要重新做一次 Data Streaming。也就是说，它无法实现 Ad—hoc 查询，我们必需针对某个需求事先准备好，才能进行数据分析

• 新数据源的结构问题。例如：要新增一台智能硬件设备，我们就要重新开发一遍它对应的适配格式、负责采集的 SDK、以及 SDK 的接收端等，即整体都要重复开发一遍

IOTA 架构

IOTA 架构整体思路

设定标准数据模型，通过边缘计算技术把所有的计算过程分散在数据产生、计算和查询过程当中，以统一的数据模型贯穿始终，从而提高整体的预算效率，同时满足即时计算的需要，可以使用各种 Ad-hoc Query 来查询底层数据

• Common Data Model（核心）：从数据收集到数据存储和处理使用统一的数据模型

​ “主 - 谓 - 宾”、“对象 - 事件”、“产品 - 事件”、“地点 - 时间” 模型等等

​ 例，“X 用户 – 事件 1 – A 页面（2018/4/11 20:00）

• SDKs：数据的采集端，不仅仅是过去的简单的 SDK，在复杂的计算情况下，会赋予 SDK 更复杂的计算，在设备端就转化为形成统一的数据模型来进行传送

• Real Time Data：实时数据缓存区，这部分是为了达到实时计算的目的，海量数据接收不可能海量实时入历史数据库，那样会出现建立索引延迟、历史数据碎片文件等问题。因此，有一个实时数据缓存区来存储最近几分钟或者几秒钟的数据。这块可以使用 Kudu 或者 Hbase 等组件来实现。这部分数据会通过 Dumper 来合并到历史数据当中。此处的数据模型和 SDK 端数据模型是保持一致的，都是 Common Data Model，例如 “主 - 谓 - 宾” 模型

• Historical Data：历史数据沉浸区，这部分是保存了大量的历史数据，为了实现 Ad-hoc 查询，将自动建立相关索引提高整体历史数据查询效率，从而实现秒级复杂查询百亿条数据的反馈。例如可以使用 HDFS 存储历史数据，此处的数据模型依然 SDK 端数据模型是保持一致的 Common Data Model

• Dumper：Dumper 的主要工作就是把最近几秒或者几分钟的实时数据，根据汇聚规则、建立索引，存储到历史存储结构当中，可以使用 map reduce、C、Scala 来撰写，把相关的数据从 Realtime Data 区写入 Historical Data 区

• Query Engine：查询引擎，提供统一的对外查询接口和协议（例如 SQL JDBC），把 Realtime Data 和 Historical Data 合并到一起查询，从而实现对于数据实时的 Ad-hoc 查询。例如常见的计算引擎可以使用 presto、impala、clickhouse 等

• Realtime model feedback：通过 Edge computing 技术，在边缘端有更多的交互可以做，可以通过在 Realtime Data 去设定规则来对 Edge SDK 端进行控制

探索

当年，哥德巴赫异想天开就想离散的世界的阶乘能不能用连续世界的积分来表达。

哥德巴赫有个好朋友叫伯努利，伯努利有个学生叫欧拉。欧拉有个学生叫拉格朗日，拉格朗日有个学生叫柯西

哥德巴赫与伯努利交流，问伯努利：有没有离散世界和连续世界可以相等的呢？

伯努利想不明白，就问他的学生欧拉，然后欧拉一晚上想出来了。故事结束

伽玛函数

换元，令 则

推导

建立递推式

由于

得到：

当时，

当时，

如：

又如：

数学归纳可得：

参考文献

Γ 函数 wikipedia

One

设 , 满足 ,.

(1) 证明存在，并求其值。

(2) 求.

我们称叫做递推式，也叫迭代式。

上一步的函数值是下一步的自变量，如此循环往复。

迭代过程：

绘制图像

相当于在两条曲线的夹缝中求生存，最终的极限值趋近于 0.

数列、、单调减少，且有下界 0.

(1) 用数学归纳法证明有界.

1. 验证.

2. 设.

3. 则.

于是有下界 0.

且显然.

由单调有界准则，存在，记为.

由 , 得 , 解得 , 于是.

(2)

.

由于存在，由归结原则:.

Two

(1) 证明方程在内有唯一实根；

(2) 对于 (1) 中的，任取 , 定义 , 证明.