Magicland https://blog.mhuig.top/favicon.ico 宠辱不惊，看庭前花开花落；去留无意，望天上云卷云舒。 2026-05-05T04:18:00.000Z https://blog.mhuig.top/ MHuiG Hexo 空白的答案 https://blog.mhuig.top/p/cb3fc42/ 2026-05-05T03:51:00.000Z 2026-05-05T04:18:00.000Z

当唐僧师徒历经九九八十一难抵达灵山，阿傩、伽叶却因未得 “人事” 而传无字真经。孙悟空怒而质问，佛祖却笑着说：“白本者，乃无字真经，倒也是好的。” 这像极了《功夫熊猫》里的神龙秘籍：阿宝打开卷轴，只映出自己的脸，茫然失措时，阿宝的父亲传授祖传面汤 “那鲜汤的秘密配方就是不加料，根本就没什么秘方，要做出特别的东西你必须相信他很特别。” 原来，所谓的秘密配方，不过是让你相信自己手中的汤就是最好的汤。

“昨天是段历史，明天是个谜团，而今天是天赐的礼物，像珍惜礼物那样珍惜今天。” 我们总在追逐未来的答案，却忘了当下的每一刻都是答案本身。唐僧在取经路上经历的每一次磨难，都是无字真经的注脚，燃灯古佛曾暗笑 “东土众生愚迷，不识无字之经”；阿宝在厨房领悟的 “相信自己”，才是神龙秘籍的真谛。那些看似空白的智慧，其实藏在我们对当下的专注里，就像鲜汤的秘密，不在于添加多少调料，而在于你是否相信自己手中的食材本就独一无二。

“昨日已成过去，未来充满可能，唯有珍惜现在。” 当我们不再执着于寻找某个 “标准答案”，而是相信自己正在创造答案时，空白就变成了无限的可能。阿傩的无字经不是敷衍，而是让师徒明白：真经不在纸上，而在取经的每一步；神龙秘籍的空白不是欺骗，而是让阿宝明白：力量不在卷轴里，而在他对自己的信任中。就像那碗鲜汤，真正的秘方，是你愿意为它倾注的热爱与信心。

或许，生活给我们的每一个 “空白”，都是在邀请我们写下自己的答案。毕竟，最珍贵的秘籍，从来不是别人给的，而是你相信自己能创造的。

]]> 昨天是段历史，明天是个谜团，而今天是天赐的礼物，像珍惜礼物那样珍惜今天。 https://blog.mhuig.top/p/person-archive/ 2026-05-04T06:59:00.000Z 2026-05-04T10:18:00.000Z



开始阅读

History of mathematics

]]> 历史人物梳理历史人物的生平轨迹与重大事迹，深入剖析了其时代背景下的关键抉择与行动，并系统评估了其在文化或科学领域所产生的持久历史影响与贡献。 爱与时空的星际救赎：《星际穿越》中的生存抉择与人性光辉 https://blog.mhuig.top/p/56c48370/ 2025-11-22T00:08:00.000Z 2025-11-23T22:18:00.000Z

地球危机与生存觉醒

我们曾经仰望星空

We used to look up at the sky and wonder at our place in the stars, now we just look down and worry about our place in the dirt.

我们曾经仰望星空并且期许总有一天可以登陆其他星球，但现在我们只能低头担心我们居住地的废土。

玉米地

Cooper: Mankind was born on Earth. It was never meant to die here.

库珀：人类生在地球，但绝不应该在这里灭亡。

灰尘密码

告别地球与父女约定

墨菲汽车

墨菲定律并非指的是那些变坏的事情必会发生

Murphy’s law doesn’t mean that something bad will happen. It means that whatever can happen, will happen.

墨菲定律并非指的是那些变坏的事情必会发生，而是指那些能够发生的事情，就会发生。

墨菲玉米地

你难道没有告诉你女儿你是去拯救世界的吗

Brand: Couldn’t you’ve told her you were going to save the world?

布兰德：你难道没有告诉你女儿你是去拯救世界的吗？

No

当你为人父母了以后

你会非常清楚一件事

那就是你得确保你的孩子有安全感

Cooper: No. When you become a parent, one thing becomes really clear. And that’s that you want to make sure your children feel safe.

库珀：没有。当你为人父母了以后，你会非常清楚一件事，那就是你得确保你的孩子有安全感。

Dr. Brand: Not sure of what I’m more afraid of, them never coming back, or coming back to find we’ve failed.

布兰德博士：不知道我更害怕哪个，是他们不会再回来了，还是回来却发现我们失败了。

Murph: Then let’s succeed.

墨菲：那我们就成功啊。

星际航行与伦理抉择

TARS

Cooper: What’s your trust setting TARS?

库珀：塔斯，你的信任值是多少？

TARS: Lower than yours apparently.

塔斯：显然比你们低。

TARSsea

Absolute honesty isn’t always the most diplomatic, nor the safest form of communication with emotional beings.

跟情绪化的存在体沟通，绝对的坦诚既是不明智的外交手段，也是不安全的做法。

永恒号

Brand: You might have to decide between seeing your children again and the future of the human race.

布兰德：你必须在再次见到你的孩子和人类的未来之间做出决定。

黑洞

We need to go well beyond the boundaries of our own existence. We can’t think as individuals…

我们需要前往距离我们生存的世界极其遥远的地方，我们不可以作为一个个体来思考这个问题……

悬窗

We’ll find a way; we always have.

我们会找到办法的，我们总有办法。

时空错位与亲情回响

今天是我的生日

因为你当年走的时候说，等你回来的时候我们俩大概就一样大了

因为你当年走的时候说，等你回来的时候我们俩大概就一样大了b

现在我已经到了你离开时的年纪

如果你能早点回来就太好了

Murph: Today is my birthday. And it’s a special one because you once told me that when you came back, we might be the same age. Well, now I’m the same age that you were when you left… and it’d be really great if you came back soon.

墨菲：今天是我的生日。这个生日很特殊，因为你当年走的时候说，等你回来的时候我们俩大概就一样大了。现在我已经到了你离开时的年纪…… 如果你能早点回来就太好了。

你就是未来守护孩子的幽灵

Once you’re a parent, you’re the ghost of your children’s future.

从孩子出生开始父母就成为了他们的幽灵。

五维真相与文明救赎

爱是唯一

可以超越时间和空间的事物

Love is the one thing we’re capable of perceiving that transcends time and space.

爱是唯一可以超越时间和空间的事物。

不要温顺地走进那良夜

人之暮年，更当厚积薄发

怒火，用怒火燃尽最后的光华

Do not go gentle into that good night,

不要温和地走进那良夜，

Old age should burn and rave at close of day;

人之暮年，更当厚积薄发；

Rage, rage against the dying of the light.

怒火，用怒火燃尽最后的光华。

Though wise men at their end know dark is right,

智者虽明白，黑夜终将到来，

Because their words had forked no lightning they

他们的言语已无法化作闪电，

Do not go gentle into that good night

不要平静地走进那夜晚，

Rage, rage against the dying of the light.

怒火，用怒火燃尽最后的光华。

五维时空

Time is relative, okay? It... it can stretch and it can squeeze, but... it can't run backwards. Just can't. The only thing that can move across dimensions, like time, is gravity.

时间是唯一能穿越所有维度的存在，它可以在不同维度空间里变慢或者变快，却无法倒流。

你就是我的幽灵

STAY留下

It was me, Murph. I was your ghost.

是我，墨菲，我就是你的幽灵。

但我知道你会回来

我回来了墨菲

穿越时空的是爱

书架

墨菲

爱是永恒不变的力量

]]> 《星际穿越》中，地球危机下库珀率队星际航行寻找新家园，面临个人情感与人类未来的抉择。通过五维空间交流，他与女儿墨菲的思念诠释爱超越时空，最终人类团结寻得生存希望。 https://blog.mhuig.top/p/zeta-archive/ 2025-09-14T06:59:00.000Z 2025-11-20T10:18:00.000Z



开始阅读

Zeta Archive

]]> 黎曼Zeta函数是解析数论核心工具，通过级数展开式定义于复平面，经解析延拓覆盖全平面，非平凡零点位于实部0到1的临界带内。函数具对称性，其整函数变换形式满足自变量s与1-s对应值相等，与素数分布紧密关联。Riemann猜想提出所有非平凡零点实部均为1/2。 https://blog.mhuig.top/p/notes-datacom/ 2023-12-03T05:59:00.000Z 2025-11-20T10:18:00.000Z



开始阅读

数据通信网络

]]> 数据通信网络依赖分层架构实现设备互联，核心为OSI七层模型与TCP/IP四层模型。物理层定义比特流传输规范，数据链路层通过MAC地址与帧同步确保节点通信，网络层依赖IP协议完成路由寻址，传输层提供TCP可靠传输与UDP实时传输选项。应用层集成HTTP、DNS等协议直接服务用户，通过封装与解封装机制实现跨层协作，是互联网通信的基础框架 辛普森悖论|你还相信数据吗 https://blog.mhuig.top/p/2f345bb/ 2022-09-22T08:14:00.000Z 2025-11-20T10:18:00.000Z

数据是一个有力的武器，它既能被用来澄清现实，也能被用来混淆是非

你知不知道，数据也会说谎？

一个栗子

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

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

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

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

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

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

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

治疗 A 有帮助治疗 B 有帮助
大肾结石69% (55 / 80)73% (192 / 263)
小肾结石87% (234 / 270)93% (81 / 87)
所有患者83% (289 / 350)78% (273 / 350)

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

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

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

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

表达式

我们抽离出符号表达：

统计对象 1统计对象 2
分项指标 1
分项指标 2
总计

如果

那么，推不出

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

我们忽略了什么

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

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

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

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

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

疗法病例的严重性

恢复率疗法病例的严重性

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

小肾结石恢复率疗法

大肾结石恢复率疗法

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

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

启示

  • 数据从来都不是完全客观的. 我们必须对这些数字持怀疑态度.
  • 辛普森悖论的出现是因为人们忽略了研究的因果关系，一旦我们理解了数据生成的机制，我们就可以寻找影响结果的其他因素，而图表不会告诉你这些.
  • 充分考察事件的潜在影响因素和维度，系数消除分组数据基数差异造成的影响.
  • 要求我们具备科学辩证思维，客观看待关联现象。很多时候，我们选择相信直觉，因为我们的直觉往往很准。但是，在信息不全或者信息非对称的情况下，直觉常常是是值得怀疑的。
]]> 辛普森悖论揭示数据整体趋势与分组趋势可能矛盾，如肾结石治疗案例中，A疗法整体成功率高于B疗法，但分组看B对大小结石成功率均高于A。其根源是忽略混杂变量，警示需通过科学分组与因果分析避免数据误读。 尝试在博客中添加简易文章推荐功能 https://blog.mhuig.top/p/175a1706/ 2022-09-15T11:13:00.000Z 2025-11-20T10:18:00.000Z

把文档转换成 “向量”，并且尝试用线性代数等数学工具来解决信息检索这类问题，至少可以追溯到 20 世纪 70 年代. 想到在 Hexo 这种静态博客系统，特别是 GitHub Page 这种 Serverless 服务中使用 Word2Vec 等深度学习方法似乎并不现实，所以这里使用的是一个非常简单经典的 TF - IDF 算法.

TF - IDF 算法原来是搜索引擎中的核心部分，谷歌百度已经使用 TF - IDF 作为内容排名因素很长一段时间.

现在的搜索引擎一般用如下的算法计算网站页面得分：score (页面得分) = TFIDF 分 * x + 链接分 * y + 用户体验分 * z（其中 x + y+z = 100%），TFIDF 分值百度大约占 40% 左右的权重，谷歌更是达到了 50%.

这是百度的计算方法： score (页面得分) = 40% 的内容质量相关性（TFIDF）+ 40% 的用户体验分 + 20% 的链接分（域名 + 外链）.

搜索引擎使用 TF - IDF 来计算内容质量相关性，我们这边也可以用它来计算文章内容相关性，然后实现简易文章推荐功能。

当然也可以使用文章的 tags 标签最为推荐依据，但是这样过于依赖人工标注数据，顺便最近发现在 Hexo 中分类和标签只能在 source/_posts 文件夹中使用才能渲染出来。

构建向量空间模型

将文档转化为向量来表示，这样文档与文档之间就可以定量的去度量他们之间的关系，挖掘文档之间的联系. 上面提到的 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 时顺便整的活

]]> 详解在静态博客中利用TF-IDF算法实现文章推荐功能的过程，包括文本分词、词频-逆文档频率计算、向量空间模型构建及余弦相似度匹配，解决传统标签推荐依赖人工标注的局限，提供技术实现思路。 记一次重装系统 (Win11) https://blog.mhuig.top/p/de4b9576/ 2022-08-11T01:18:00.000Z 2025-11-20T10:18:00.000Z

电脑开机后要先卡顿 30 min，然后才能正常工作，还有不明程序一直在读写磁盘，噪声太大了，没救了重装系统吧。

win11

重装系统之后操作瞬间就流畅很多~

意料之外：重装系统之后，win11 自带的杀软开始报毒，之前在虚拟机看过镜像中是没有这个病毒文件的。使用老毛桃制作启动盘，事先格式了系统盘，推测可能是老毛桃启动盘释放的病毒文件，或者是上一个系统的隐藏分区释放的病毒文件，google: 老毛桃启动盘携带木马病毒，这里建议使用微软官方的镜像和安装介质。

重装系统前的备份列表 以下内容适用于 win10 与 win11

PE

操作系统

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 系统

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

Office

浏览器

安全管理

暂时只装火绒。

Windows 应用商店

  • 7-zip
  • Ubuntu On windows
  • Kali Linux

IDE 文本编辑器

代理工具

DOH

驱动

  • 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版本

版本控制

配置 .gitconfig

.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

聊天工具

远程连接

数据库

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

截屏工具

GPG

下载工具

杂项

chrome 扩展

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

windows 导出备份 WiFi 密码

Wi-Fi-code.bat
@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

右键菜单权限选项

管理员取得所有权.reg
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"
恢复原始权限.reg
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%%\""
取得文件修改权限.reg
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"
移除权限选项.reg
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 ，点击确定按钮。

禁用注册表

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

禁用注册表.reg
Windows Registry Editor Version 5.00

[HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System]
"DisableRegistryTools"=dword:00000001
解锁注册表.inf
[Version]
Signature=“$CHICAGO$”
[DefaultInstall]
DelReg=del
[del]
HKCU,Software\Microsoft\Windows\CurrentVersion\Policies\System,Disableregistrytools,1,00,00,00,00

右键选择安装解锁

修复注册表.cmd
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
]]> 记录因电脑卡顿重装Win11的经历，包括重装前备份列表，适用于Win10/11、使用微软官方镜像的建议，以及重装后系统激活、软件安装、权限夺回、登录界面优化等操作指南。 https://blog.mhuig.top/p/wiki-copoko/ 2022-06-12T04:11:00.000Z 2025-11-20T10:18:00.000Z



开始阅读

CoPoKo

]]> CoPoKo是基于GPL3.0 Only协议的开源工具包，包含核心模块Telegram机器人、控制面板及周边工具和系统接口，旨在为用户提供可爱的机器人助手。 部署第一个智能合约 https://blog.mhuig.top/p/6a03238d/ 2022-03-01T02:12:00.000Z 2025-11-20T10:18:00.000Z

注意访问本文的引用链接可能需要魔法


对区块链最好的描述是将其描述为一个公共数据库，它由网络中的许多计算机更新和共享。

小试身手

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

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

编写合约

第一步访问 Remix 并创建一个新文件。 在 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++ 这样的面向对象编程语言中的一个类。 现在可以运行我们的合约了。

部署合约

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

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

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

Remix工具栏中的编译图标

然后点击编译按钮：

Remix solidity编译器的编译按钮

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

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

Remix工具栏的部署图标

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

Remix solidity编译器的部署按钮

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

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

Remix solidity编译器的函数按钮

现在点击按钮来调用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 会自动显示它。

Remix截屏

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

注册钱包

安装 Chrome MetaMask 插件

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

安装 Chrome MetaMask 插件

注册绑定你的账号。

添加 BSC Testnet （测试网络）

添加自定义网络

添加自定义网络

添加自定义网络 BSC Testnet

每日领取测试 BNB

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

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

领取测试 BNB

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

BNB到账

发行 MHGC (MHuiGCoin) 代币

进入 Remix 环境 中

FILE EXPLORERS

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

依次创建三个文件

EIP20.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];
    }
}
EIP20Factory.sol
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)
        }
    }
}
EIP20Interface.sol
// 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 版本的编译环境.

选择 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

运行环境选择 Injected Web3

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

连接账户

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

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

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

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

点击transact.

transact

点击确认支付燃料费用.

支付燃料费用

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

复制部署的合约地址

导入代币合约

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

点击导入代币

输入代币合约信息

  • 代币合约地址：0xeb86A66E2d4A51F8de3d4d0F509f18A15Cde68F6

  • 代币符号：MHGC

  • 小数精度：18

输入代币合约信息

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

21000000 MHGC

代币转账测试

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

创建一个新的账户

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

发送 1 MHGC 测试

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

支付测试网络的燃料费用

转账发送成功.

转账发送成功

转账发送成功

测试网络资源管理器

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

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

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

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

安全风险提示

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

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

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

最后

MHGC 获取方式

测试网络

代币合约

  • 代币合约地址：0xeb86A66E2d4A51F8de3d4d0F509f18A15Cde68F6

  • 代币符号：MHGC

  • 小数精度：18

尾巴

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

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

Just For Fun.

参考资料

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.

]]> 本文详解在以太坊测试网络部署智能合约流程：用Remix编写Solidity计数器合约，编译后通过JavaScript VM本地测试；引入事件记录状态变化，再基于EIP20标准创建代币合约，配置MetaMask连接BSC测试网，完成代币部署与交互。 一组粗略的类比 https://blog.mhuig.top/p/6dc844b7/ 2021-10-02T03:00:00.000Z 2025-11-20T10:18:00.000Z

这是一个关于生物学与深度学习的粗略类比的笔记, 这些类比中的大多数都是非常推测性和探索性的，但我发现它们很有趣并且值得思考.

生物学深度学习
外界环境输入数据
认知过程特征提取
基因神经网络权重结构 (特征)
基因突变神经网络权重结构改变
性状神经网络功能
细胞神经元
组织 (细胞分化)神经网络在后面的层
器官神经网络专门处理特定任务的组件
个体模型
繁殖迭代
反馈调节优化器 (eg: 梯度下降) 更新网络的机制
自然选择损失函数定向衡量性能
进化学习
进化 = 基因突变 + 自然选择 (定向)学习 = 神经网络权重结构改变 + 损失函数定向衡量性能
基因决定性状神经网络权重结构可以决定神经网络功能
个体繁殖模型迭代
]]> 通过14组概念对比，将生物学与深度学习进行粗略类比，如外界环境对应输入数据、基因类比神经网络权重结构、自然选择类似损失函数，探索两者在进化与学习机制上的相似性。 唯物辩证法 https://blog.mhuig.top/p/6ace289f/ 2021-09-15T07:13:00.000Z 2025-11-20T10:18:00.000Z

唯物辩证法是关于自然界、人类社会以及人类思维领域发展最一般规律的科学，它在坚持唯物论观点的基础上，研究世界的运行状况、形态和发展规律，进一步回答客观世界究竟 “怎么样” 的问题。

唯物辩证法的总特征

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

事物的普遍联系

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

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

特性具体内容
客观性事物的联系是事物本身所固有的，不是主观臆想的
普遍性任何事物内部的不同部分和要素之间都是相互联系的；任何事物都不能孤立存在，都同其他事物处于一定的联系之中，整个世界是相互联系的统一整体。
多样性世界上的事物是多样的，事物之间的联系也是多样的
条件性条件是对事物存在和发展发生作用的诸要素的总和。条件对事物发展和人的活动具有支持或制约作用；条件是可以改变的；改变和创造条件不是任意的，必须尊重事物发展的客观规律。

事物的变化发展

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

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

联系与发展的基本环节

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

唯物辩证法的三大规律

对立统一规律

唯物辩证法的实质和核心

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

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

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

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

内因和外因

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

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

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

矛盾的普遍性和特殊性

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

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

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

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

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

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

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

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

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

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

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

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

方法论：

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

量变质变规律

量、质、度

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

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

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

量变和质变

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

区别量变质变
性质事物数量的增减和组成要素次序的变动事物根本性质的变化，是事物由一种质态向另一种质态的飞跃
特点渐进的、不显著的变化根本的、显著的变化
呈现状态统一、相持、平衡和静止统一物的分解、平衡和静止的破坏
结果事物还是其自身，没有变成另一事物事物不再是其自身，而变成了另一事物

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

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

否定之否定规律

肯定因素和否定因素

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

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

辩证否定观

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

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

否定之否定

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

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

]]> 唯物辩证法以联系和发展为总特征，通过对立统一、量变质变、否定之否定三大规律揭示事物本质。对立统一规律作为实质核心，阐释矛盾的同一性与斗争性、普遍性与特殊性，提供矛盾分析方法；量变质变规律说明发展是量变到质变的过程；否定之否定规律揭示事物螺旋式上升的趋势，是认识和改造世界的根本方法论。 辩证唯物论 https://blog.mhuig.top/p/171a81d0/ 2021-09-14T06:50:00.000Z 2025-11-20T10:18:00.000Z

辩证唯物论是关于世界的的物质性学说、关于物质和意识的辩证关系学说，它采用辩证法的观点研究世界的本质，所要说明的是世界的本质 “是什么” 的问题。

辩证唯物论的基本观点是：世界的本原是物质，主张物质决定意识，意识是对物质的反映；同时，意识对物质有能动的反作用，承认世界是物质的，物质具有客观实在性。

物质

物质的定义

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

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

物质和运动

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

关系理解误区
物质是运动的物质，运动是物质固有的根本属性任何具体的物质形态只有在运动中才能保持自己的存在，世界上不存在脱离运动的物质离开运动谈物质会导致形而上学
运动是物质的运动，物质是运动的承担者任何运动都有自己的承担者或者载体，离开物质载体的运动是不存在的离开物质谈运动导致唯心主义

运动和静止

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

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

运动静止
含义宇宙间一切事物、现象的变化和过程两种情形：一是指空间的相对位置暂时不变，二是指事物的根本性质暂时不变
性质无条件的、永恒的和绝对的有条件的、暂时的和相对的

运动和静止的联系：

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

时间和空间

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

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

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

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

意识

意识的含义

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

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

意识的本质

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

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

物质和意识的辩证关系

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

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

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

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

  • 尊重客观规律是正确发挥主观能动性的前提；
  • 只有充分发挥主观能动性，才能正确认识和利用客观规律。
]]> 辩证唯物论主张世界本原是物质，物质决定意识且具客观实在性，意识对物质有能动反作用。物质与运动不可分割，运动绝对而静止相对；时间空间是物质运动存在形式。核心是物质意识辩证关系及主观能动性与客观规律性统一。 我们从哪里来？ https://blog.mhuig.top/p/dad4292a/ 2021-06-06T03:51:00.000Z 2025-11-20T10:18:00.000Z

这里探讨的是一个非常简单的问题，我们是怎么来到这里的？

前言

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

事实上，人体的 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 代的繁衍后，

我们看到了这个，

很笨的大脑

变成了这个，

复杂的行走行为

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

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

你创造了它们，然后它们抛开你自己做主

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

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

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

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

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

尾声

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

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

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

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

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

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

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

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

]]> 这里探讨的是一个非常简单的问题，我们是怎么来到这里的？文章探讨人类从简单元素到生命体的构成，介绍图灵用数学方程式解释生物形态发生（如动物斑纹生成），以及贝洛索夫发现的试液自发变色现象，印证简单规则可产生复杂生物现象。 曼德勃罗集 | 上帝的指纹 https://blog.mhuig.top/p/64e72a75/ 2021-06-06T03:50:37.000Z 2025-11-20T10:18:00.000Z

曼德勃罗集被誉为上帝的指纹，其通过简单迭代公式生成无限复杂图案，展现混沌系统的自相似性特征，揭示隐藏在无序表象下的宇宙深层规律，是分形几何与非线性科学的经典研究对象。

]]> 自相似性揭示宇宙的深层规律 记一次仅在 IPv4 环境下访问 IPv6 网络的经历 https://blog.mhuig.top/p/5e9edb45/ 2021-04-11T01:24:00.000Z 2025-11-20T10:18:00.000Z
]]> 记一次仅在IPv4环境下访问IPv6网络的经历 神秘数字 4.669 https://blog.mhuig.top/p/373468cd/ 2021-02-10T01:50:00.000Z 2025-11-20T10:18:00.000Z

从无序迈向有序

Mandelbrot set

分叉图

4.669

费根鲍姆常数：混沌理论中的普适标度律

引言：从无序中发现有序

1975 年，洛斯阿拉莫斯国家实验室的一位不起眼的助手米切尔・费根鲍姆（Mitchell Feigenbaum）在研究非线性映射时，做出了一个改变混沌理论发展轨迹的发现。当时，他使用一台价值 795 美元的 HP-65 可编程计算器，对逻辑斯蒂映射（Logistic map）进行数值迭代计算。这个看似简单的工具，却帮助他揭示了隐藏在复杂非线性系统背后的惊人规律。

费根鲍姆观察到，当参数逐渐增大时，系统会经历一系列的倍周期分岔：从稳定的不动点（周期 1）分岔出周期 2，接着是周期 4、周期 8，依此类推，最终进入混沌状态。通过计算相邻分岔点之间的距离比值，他发现这些比值似乎收敛于一个固定的数值。经过多次迭代计算，费根鲍姆猜测这个极限值约为 4.6692，这就是后来被称为费根鲍姆常数（Feigenbaum constant）的第一个普适常数，通常记为 。

更令人惊讶的是，费根鲍姆进一步验证了这个常数的普适性。他发现，不仅在逻辑斯蒂映射中，在正弦映射等其他具有二次极大值的非线性映射中，倍周期分岔过程都遵循相同的收敛规律，分岔参数间隔比的极限同样是 。这一发现揭示了非线性系统从有序走向混沌过程中的普适行为，为混沌理论的发展奠定了重要基础。

历史背景：混沌理论的诞生与费根鲍姆的突破

混沌理论的前身可以追溯到 20 世纪初，法国数学家亨利・庞加莱（Henri Poincaré）在研究三体问题时首次观察到了非线性系统的敏感性。然而，混沌理论作为一门独立学科的兴起，则是在 20 世纪 60 年代至 70 年代。

1963 年，美国气象学家爱德华・洛伦兹（Edward Lorenz）在研究大气对流模型时发现了 "蝴蝶效应"，即初始条件的微小差异可能导致系统长期行为的巨大变化。这一发现揭示了确定性系统中内在的随机性，为混沌理论的发展拉开了序幕。

与此同时，在数学领域，研究人员开始关注非线性映射的动力学行为。1976 年，罗伯特・梅（Robert May）在《自然》杂志上发表了一篇具有里程碑意义的论文，介绍了逻辑斯蒂映射在描述种群动态时表现出的复杂行为，包括倍周期分岔和混沌现象。这篇论文引起了广泛关注，激发了更多学者对非线性动力学的研究兴趣。

正是在这样的学术背景下，米切尔・费根鲍姆开始了他对非线性映射的深入研究。费根鲍姆的学术道路并非一帆风顺。他在麻省理工学院获得粒子物理博士学位后，因对当时新兴的混沌理论产生浓厚兴趣，转而投身这一 "非主流" 领域的研究，甚至因此一度失去了在康奈尔大学的职位。直到 1974 年，他加入洛斯阿拉莫斯国家实验室，才有机会专注于非线性动力学的研究。

在洛斯阿拉莫斯实验室，费根鲍姆使用 HP-65 计算器，对逻辑斯蒂映射进行了大量数值计算。他计算了系统从周期 1 到周期 2、周期 4、周期 8 等一系列分岔点的参数值，并观察到相邻分岔点之间的距离比值似乎趋于一个常数。通过不懈的努力和大胆的猜测，费根鲍姆最终提出了这一普适常数的存在，并于 1978 年在《统计物理学杂志》（Journal of Statistical Physics）上发表了题为《一类非线性变换的定量普适性》（Quantitative Universality for a Class of Nonlinear Transformations）的开创性论文，正式确立了这一发现。

费根鲍姆的工作最初遭遇了不少质疑，部分原因是缺乏严格的数学证明。然而，随着计算机技术的发展和更多数值实验的验证，他的发现逐渐被学术界接受。1982 年，数学家奥斯卡・兰福德（Oscar E. Lanford III）通过计算机辅助证明，为费根鲍姆普适性理论提供了更坚实的数学基础。

费根鲍姆常数的发现，不仅为混沌理论提供了一个重要的定量工具，也深刻改变了人们对非线性系统的认识。它揭示了看似杂乱无章的混沌现象背后隐藏的有序结构，展示了非线性世界的奇妙规律。

费根鲍姆常数的定义与数学表达

费根鲍姆常数是描述非线性系统倍周期分岔通向混沌过程中普适行为的两个重要常数。第一个费根鲍姆常数 表征分岔参数间隔的几何收敛率，第二个费根鲍姆常数 则描述分岔后周期轨道宽度的衰减率。

第一费根鲍姆常数

考虑一个单参数非线性映射 ，其中 是控制参数。当 逐渐增大时，系统可能经历一系列倍周期分岔。设 是系统发生 周期分岔时的临界参数值。例如， 对应周期 2 分岔点， 对应周期 4 分岔点，依此类推。费根鲍姆发现，当 趋于无穷大时，相邻分岔点之间的距离比值收敛于一个常数：

这个极限值 就是第一费根鲍姆常数。通过数值计算，费根鲍姆得到 。

以逻辑斯蒂映射 为例，费根鲍姆计算得到的分岔点参数值如下： （周期 2 分岔）， （周期 4 分岔）， （周期 8 分岔）， （周期 16 分岔）， （周期 32 分岔）。

计算相邻分岔点的距离比值： ， ， ， 。

进而得到比值： ， ， 。

可以看到，这些比值逐渐趋近于费根鲍姆常数 。

第二费根鲍姆常数

除了分岔参数间隔的收敛，费根鲍姆还发现分岔后周期轨道的 "宽度" 也呈现几何衰减。设 是 周期轨道的特征宽度（例如，轨道点的最大距离），则当 趋于无穷大时，宽度比值收敛于第二个普适常数 ：

通过数值计算，费根鲍姆得到 。

这两个费根鲍姆常数 和 共同刻画了非线性系统从有序到混沌转变过程中的标度行为，体现了不同非线性系统在倍周期分岔序列中的普适特征。

费根鲍姆常数的推导方法

费根鲍姆常数的推导和计算是一个复杂的过程，涉及数值迭代、函数方程求解和重整化群方法等多种技巧。下面将详细介绍几种主要的推导方法。

1. 数值迭代法：从分岔点计算到常数估计

费根鲍姆最初发现常数 的方法就是通过数值迭代。这种方法虽然直观，但需要高精度的计算和对分岔点的精确确定。

以逻辑斯蒂映射 为例，数值迭代法的步骤如下：

a) 寻找分岔点 ：对于每个 ，找到使系统出现稳定 周期轨道的参数值 。这通常需要使用牛顿法等数值方法求解方程 及其稳定性条件。

b) 计算分岔间隔比：根据定义，计算相邻分岔点之间的距离比值 ，并观察其收敛趋势。

c) 外推估计极限值：通过对有限 下的比值进行外推，估计 时的极限值，即费根鲍姆常数 。

这种方法的精度受到数值计算精度和分岔点确定准确性的限制。费根鲍姆使用 HP-65 计算器进行计算，虽然在当时已经是先进的工具，但精度仍然有限。现代计算机可以通过更高精度的计算和更有效的分岔点搜索算法，得到更精确的 值。

2. 重整化群方法：费根鲍姆函数方程

为了从理论上解释常数 和 的普适性，费根鲍姆引入了重整化群的思想，建立了著名的费根鲍姆函数方程。这种方法不仅能够解释常数的普适性，还为常数的数值计算提供了更系统的框架。

2.1 函数方程的建立

考虑一个具有二次极大值的单峰映射 。费根鲍姆假设，在分岔聚集点附近，经过适当的标度变换，映射的迭代会收敛到一个普适的不动点函数 。具体来说，他提出了以下泛函方程：

其中 是第二费根鲍姆常数（标度因子），负号反映了映射的反射对称性。这个方程被称为费根鲍姆 - 茨维塔诺维奇方程（Feigenbaum-Cvitanović equation）。

除了上述泛函方程，不动点函数 还需要满足一些边界条件： （归一化条件，极大值点）， （二次极大值条件）， 对于 （有界性）。

2.2 线性化与本征值问题

为了求解费根鲍姆函数方程，我们可以将其在不动点函数 附近线性化。考虑微小扰动 ，令 是方程的一个近似解。代入方程并忽略高阶项，可以得到关于 的线性本征值方程。

费根鲍姆证明，这个线性算子的最大本征值就是第一费根鲍姆常数 。因此，求解这个本征值问题可以得到 的数值。

2.3 数值求解方法

求解费根鲍姆函数方程通常采用迭代法。赵平波和胡岗提出了一种基于级数展开的重整化方法，其步骤如下：

a) 假设不动点函数 的级数展开形式： （只包含偶次项，因为 是偶函数）。

b) 将级数展开代入泛函方程，比较等式两边同次幂的系数，得到关于系数 和常数 的方程组。

c) 求解这个方程组，得到 的近似表达式和 的值。

d) 通过线性化方程，求解本征值问题，得到 的值。

Lanford 等人利用计算机辅助证明，通过高次多项式逼近 ，得到了高精度的 和 值。这种方法的精度主要取决于多项式展开的阶数和数值计算的精度。

3. 分形几何与多标度分析

另一种推导和理解费根鲍姆常数的角度是通过分形几何和多标度分析。Kuznetsov 和 Osbaldestin 提出了一种基于重整化群函数方程的方法，用于计算费根鲍姆吸引子的广义维数。

他们从分区函数出发，考虑了如下形式的特征值问题：

其中 是与广义维数相关的本征函数， 是本征值。通过求解这个方程，可以得到广义维数 与参数 和 的关系：

特别地，当 时，可以得到关联维数 。通过这种方法，Kuznetsov 和 Osbaldestin 不仅验证了费根鲍姆常数的普适性，还计算了不同非线性映射的广义维数。

4. 符号动力学与信息熵方法

近年来，研究人员尝试从符号动力学和信息熵的角度来理解费根鲍姆常数的起源。Smith 提出了一种基于信息熵的准精确解析方法，试图将费根鲍姆常数与黄金比例和自然对数底等基本常数联系起来。

Smith 定义了符号序列的熵，并假设倍周期分岔对应于熵的特定变化。通过分析熵的积分与普适标度的关系，他得到了一个近似公式：

其中 是黄金比例。代入数值后，这个公式给出 ，与精确值的误差仅为 0.01% 。

虽然这种方法尚未给出费根鲍姆常数的严格解析表达式，但它揭示了费根鲍姆常数与其他基本数学常数之间可能存在的深刻联系，为进一步研究提供了新的思路。

费根鲍姆常数的普适性与推广

费根鲍姆常数的普适性是其最引人注目的特点之一。最初在逻辑斯蒂映射中发现的 和 ，后来被证明在一大类非线性映射中都存在。这种普适性不仅体现在数学模型中，还在物理实验中得到了验证。

普适性的范围与条件

费根鲍姆证明，对于所有具有二次极大值的单峰映射，倍周期分岔序列的收敛率都由相同的常数 和 刻画。这里的关键条件是映射在临界点（极大值点）处具有二次行为，即映射的泰勒展开式中最低阶非零导数是二阶导数。

对于具有更高阶临界点的映射，普适常数会发生变化。例如，对于四次映射，费根鲍姆常数 的值约为 7.284 ；对于六次映射，约为 9.296 ；对于八次映射，约为 10.048 。这些结果表明，普适常数的值取决于映射的 "类型"，通常由临界点的阶数决定。

实验验证：从电路到流体

费根鲍姆常数的普适性不仅在数学模型中得到证实，还在物理实验中被观察到。以下是几个典型的实验验证例子：

1. 非线性电路实验

许成伟等人利用 FD - NCE - 1I 型非线性电路混沌实验仪，通过调节电路参数，观察到了从倍周期分岔到混沌的转变过程。他们测量了不同周期分岔点对应的非线性电阻电压，并计算了相邻分岔点电压差的比值。实验结果得到的费根鲍姆常数约为 4.56 ，与理论值 的相对误差约为 2.3% 。

实验误差主要来源于电压表的精度限制和分岔点判断的主观性。使用更高精度的测量设备和更严格的分岔点判断标准，可以进一步减小误差，更精确地验证费根鲍姆常数的普适性。

2. RLD 电路中的混沌现象

除了传统的蔡氏电路（Chua's circuit），研究人员还在其他非线性电路中观察到了费根鲍姆普适性。例如，在电阻 - 电感 - 二极管（RLD）电路中，通过逐步改变参数，可以观察到倍周期分岔序列，并计算得到费根鲍姆常数 的实验值，与理论值吻合良好。

3. 流体力学实验

在流体力学中，从层流到湍流的转捩过程也被认为与倍周期分岔有关。虽然直接测量流体系统中的费根鲍姆常数具有挑战性，但一些实验间接证实了非线性动力学普适性的存在。例如，在热对流实验中观察到的周期倍增现象，为费根鲍姆理论提供了物理支持。

推广：超费根鲍姆普适性

费根鲍姆普适性的发现激发了研究人员对更广泛普适行为的探索。杜雷鸣等人研究了 Lorenz 映射系统中的超 Feigenbaum 普适性，发现了一种新的超几何收敛行为。

通过超高精度的数值计算，他们发现 Lorenz 映射中存在一种不同于传统 Feigenbaum 普适性的收敛行为，表现为超几何收敛。这种新的普适行为的收敛比约为 0.6300 ，不同于黄金分割比（约 0.618）。

这一发现扩展了人们对非线性系统普适性的认识，表明除了传统的 Feigenbaum 普适性外，还可能存在其他类型的普适行为，值得进一步深入研究。

费根鲍姆常数的应用与意义

费根鲍姆常数的发现不仅具有深刻的理论意义，还在多个领域有着广泛的应用前景。从物理学到工程技术，从生物学到经济学，费根鲍姆常数为理解非线性系统的复杂行为提供了一个重要的定量工具。

1. 混沌控制与同步

混沌系统的一个重要特点是对初始条件的极端敏感性，这使得长期预测变得困难。然而，费根鲍姆常数所描述的倍周期分岔序列为混沌控制提供了思路。通过微小的参数扰动，可以将系统稳定在某个周期轨道上，从而实现对混沌的控制。

例如，在激光系统中，混沌行为可能导致输出不稳定。利用费根鲍姆常数所揭示的分岔规律，可以设计反馈控制机制，将激光系统稳定在某个周期状态，提高输出稳定性和可控性。

2. 非线性时间序列分析

在实际应用中，许多系统的动态行为可以通过时间序列来观测（如股价波动、心率变化、气候数据等）。费根鲍姆常数为分析这些时间序列提供了一个重要的参考。

通过计算时间序列的自相似性和标度指数，可以判断系统是否处于混沌状态，以及是否经历了倍周期分岔过程。费根鲍姆常数的存在可以作为系统进入混沌的一个特征标志，有助于我们理解和预测复杂系统的行为。

3. 实验物理中的标度律验证

费根鲍姆常数的普适性为实验物理提供了一个重要的验证标准。在研究新的非线性系统时，观察倍周期分岔序列并计算分岔参数间隔比，可以检验系统是否符合费根鲍姆普适性。如果实验结果与理论值 吻合良好，则说明系统属于具有二次极大值的普适类，从而可以利用已知的理论结果来分析系统行为。

例如，在非线性光学实验中，通过观察激光与物质相互作用产生的倍周期分岔现象，可以验证费根鲍姆常数的普适性，并深入理解光与物质相互作用的非线性动力学机制。

4. 数学上的意义：常数的本质与未解之谜

尽管费根鲍姆常数已被广泛接受和应用，但其数学本质仍然是一个未解之谜。与圆周率 和自然对数底 不同，费根鲍姆常数目前没有已知的解析表达式，也不清楚它是否为无理数或超越数。

费根鲍姆常数的普适性暗示它可能与某些深刻的数学结构有关。Smith 等人尝试将 与黄金比例 和自然对数底 等基本常数联系起来，得到了一些近似公式，如 。虽然这些公式的精度有限，但启发我们思考费根鲍姆常数与其他数学常数之间可能存在的内在联系。

理解费根鲍姆常数的数学本质，可能需要发展新的数学理论和方法，这不仅对非线性动力学，而且对整个数学领域都具有重要意义。

结论与展望

费根鲍姆常数的发现是混沌理论发展史上的一个里程碑。从 1975 年费根鲍姆使用 HP-65 计算器的初步发现，到如今成为非线性动力学普适性的核心概念，费根鲍姆常数见证了人类对复杂非线性世界认识的深化。

费根鲍姆常数的普适性揭示了不同非线性系统在走向混沌过程中的共同规律，为我们理解复杂系统提供了一个统一的框架。通过数值迭代、泛函方程求解和重整化群等方法，我们不仅能够精确计算费根鲍姆常数，还能深入理解其背后的数学物理本质。

在应用方面，费根鲍姆常数为混沌控制、时间序列分析和实验物理验证等提供了重要工具。从电子电路到流体力学，从生物学到经济学，费根鲍姆常数的影响跨越了多个学科领域，展现了基础科学研究的广泛应用前景。

然而，仍有许多未解之谜等待探索。费根鲍姆常数的解析表达式是什么？它与其他数学常数之间是否存在深刻的联系？除了传统的倍周期分岔，是否还存在其他类型的普适行为？这些问题的解答，可能需要数学家和物理学家的跨学科合作，以及计算技术的进一步发展。

随着人工智能和高性能计算的兴起，我们有望发展出更高效的数值方法，更精确地计算费根鲍姆常数，并探索更高维度和更复杂非线性系统中的普适行为。同时，新的实验技术可能会在更多物理系统中验证费根鲍姆普适性，甚至发现新的普适类和普适常数。

费根鲍姆常数的故事告诉我们，即使在看似杂乱无章的混沌现象中，也可能隐藏着惊人的秩序和规律。通过不懈的探索和创新，人类终将揭开自然界的神秘面纱，理解我们所处的复杂世界。费根鲍姆常数，这个从非线性系统中诞生的数字，将继续指引我们在混沌与秩序的边界探索前行。

]]> 本文深入解析混沌理论中的核心常数4.669（费根鲍姆常数），揭示非线性系统从有序到混沌的普适规律。通过逻辑斯蒂映射等案例，阐述倍周期分岔过程中参数间隔比的收敛特性，介绍数值迭代与重整化群等推导方法，探讨其在物理实验与复杂系统分析中的应用价值。 大数据架构演变 https://blog.mhuig.top/p/7e3480e9/ 2021-02-07T12:51:00.000Z 2025-11-20T10:18:00.000Z

在 Hadoop 系列框架还没出现之前，数据分析工作已经经历漫长的发展，其中以 BI 系统为主的数据分析，已经有非常成熟和稳定的技术解决方案和生态系统，BI 系统的架构图如下：

BI系统的架构图

BI 又叫商业智能，其包括与传统业务系统的区别在于：业务系统更注重于事务型的数据处理，用来支撑企业的各业务线；而 BI 是将企业中所有数据汇聚成数据仓库（DW）并对其进行分析型操作，其中 Cube 是 BI 的核心模块。Cube 是一额更高层的业务抽象模型，在 Cube 上可以进行上钻、下钻、切片等操作、

事务型的数据

Cube

BI 系统都是基于关系型数据库，关系型数据库使用 SQL 语句进行操作，但是 SQL 在多维操作相对较弱，所以 Cube 有自己独有的查询语言多维查询语言 —— MDX

大多数的数据库服务厂商都提供 BI 服务，轻易便可搭建出一套 OLAP 分析系统

OLTP 联机事务处理，表现为企业中的应用系统如 OA、CRM、ERP、财务软件等供各部门使用

OLAP 联机分析处理，也叫决策支持系统 DSS，通常进行使用者是企业高管或部门管理者

但是随着互联网发展，BI 系统也暴露除了一些缺点:

  • BI 系统多以分析业务数据产生结构化数据为主，对于非结构化和半结构化数据处理乏力。例如图片、文本、音频的存储、分析。

  • 随着异构数据源增加，要解析数据内容进入数据仓库，则需要非常复杂的 ETL 程序，从而导致 ETL 变得过于庞大和容易出错，需要大量人力进行维护

  • 随着数据的增长，性能会成为瓶颈，在 TB / PB 级别的数据处理上表现的尤为乏力

  • 数据仓库的原始数据都是只读的用来分析，不存实务操作者导致传统的范式约束大大影响了性能

由于 BI 的一系列问题，在以 Hadoop 生态圈的大数据分析平台逐渐表现出其优异性，围绕 Hadoop 体系的生态圈也不断变大，对于 Hadoop 系统来说，从根本上解决了传统数据仓库瓶颈的问题

随着大数据平台的不断发展，现在主要对数据的处理时效进行区分为

  • 针对于 T + 1 数据的离线处理架构，其主要应用框架由 Hadoop、Hive、Sqoop 等组成

  • 针对实时数据的流式处理架构，其主要由 Spark、Flink、Flume、Kafka 等组成

Lambda 架构

“我们正在从 IT 时代走向 DT 时代 (数据时代)。IT 和 DT 之间，不仅仅是技术的变革，更是思想意识的变革，IT 主要是为自我服务，用来更好地自我控制和管理，DT 则是激活生产力，让别人活得比你好”

—— 阿里巴巴董事局主席马云。

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

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

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

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

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

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

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

Nathan Marz

Lambda 的目标:

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

Lambda 特性

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

  • 读写分离和复杂性隔离

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

Lambda

Lambda

Lambda

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 的接收端等，即整体都要重复开发一遍

Kappa架构

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 端进行控制

IOTA架构

]]> 解析大数据架构从BI系统到Hadoop离线/实时处理的演变，对比Lambda架构（Hadoop+Storm混合处理）、Kappa架构（纯流处理）及IOTA架构（统一数据模型+边缘计算）的技术特点与应用场景，展现数据处理范式从T+1到实时计算的发展历程。 离散世界与连续世界的联系 https://blog.mhuig.top/p/2b995a0c/ 2021-01-02T12:34:00.000Z 2025-11-20T10:18:00.000Z

探索

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

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

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

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

伽玛函数

换元，令 则

推导

建立递推式

由于

得到：

当 时,

当 时,

如：

又如：

数学归纳可得：

参考文献

Γ 函数 wikipedia

]]> 本文探讨离散与连续数学世界的联系，聚焦伽玛函数如何实现阶乘的连续化表达。通过推导伽玛函数积分形式及递推关系Γ(α+1)=αΓ(α)，证明其与阶乘的等价性Γ(n+1)=n!，并给出Γ(1/2)=√π等特殊值计算。 一大波题目正在来袭 https://blog.mhuig.top/p/bc43343e/ 2020-12-06T13:33:00.000Z 2025-11-20T10:18:00.000Z

]]> 发布数学题目集合，请做好解题准备。文章可能包含各类数学题型及解题思路，适合数学爱好者或学习者进行练习与能力提升。 回顾几个有趣的小题目 https://blog.mhuig.top/p/ce5b71c0/ 2020-11-16T13:08:00.000Z 2025-11-20T10:18:00.000Z

One

设 ,满足 , .

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

(2) 求.

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

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

迭代过程：

绘制图像

在两条曲线的夹缝中求生存

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

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

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

1. 验证 .

2. 设 .

3. 则 .

于是有下界 0.

且显然 .

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

由 ,得 ,解得 ,于是 .

(2)

.

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

Two

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

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

交点就在那里可是就是不知道它是几

是超越方程，只能求得数值解，不能求得解析解，交点就在那里，可是就是不知道它是几.

在两条曲线的夹缝中求生存

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

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

Three

设 , , ,证明存在且其极限是方程 的根.

是超越方程解不出解析解，交点就在那里，可是就是不知道它是几。

x=cosx

(1) 证 在内有唯一实根。

令 ,则 , .

且 .

.单调递减.

. 唯一

(2) 证 .

构造 .

由拉格朗日中值定理:

数学归纳

由于

故连续放缩得

于是 且 有界.

故 .

.

即

Four

设 , , , .若存在，求的取值范围.

数学归纳

1. .

2. 设 .

3. 则

单调增加。

若存在，记为

.

于是有交点.

交点

函数值相同导数值斜率相同

故 时,有交点.

又 时,

2. 设

3. 则 .

有上界.

综上，当 时,存在，且值为 的根.

[注]

(1) 当 时，有 2 个交点.

eg. 当 时， ,.

2个交点

(2) 当在怎样的正数取值范围内取值时，曲线 和直线 必相交？

曲线 和直线 相交的充要条件是存在 ，使得 ,即

即属于 的值域. 由于 =0. 故只需求出的最大值则的取值范围就是.

可得 唯一驻点. 当 时 ,当 时 ,

时为在 内的最大值.

由此，曲线 和直线 相交的充要条件是满足 .

]]> 本文回顾多个有趣数学题，围绕递推数列展开，通过迭代过程分析对数、余弦、指数等函数生成的数列，运用单调有界准则、拉格朗日中值定理等证明极限存在并求解，探讨数列在函数曲线“夹缝”中的收敛特性。 宇宙的本质是计算 https://blog.mhuig.top/p/92a4ae9/ 2020-11-06T00:35:00.000Z 2025-11-20T10:18:00.000Z

如果认为物理学家的任务是发现自然是什么，那就错了，物理学家关心的是我们关于自然能说点什么。

—— 尼尔斯・玻尔

想象一下，一望无际的大平面被分成了许许多多方格子。每个格子里正好能放下一个 “细胞”。这个细胞不能运动，它可以是死的，也可以是活的；但它的状态，是由它周围 8 个细胞的死活决定。

规则

至于决定的规则，在这个例子里只有这么几条：

  • “人口过少”：任何活细胞如果活邻居少于 2 个，则死掉。
  • “正常”：任何活细胞如果活邻居为 2 个或 3 个，则继续活。
  • “人口过多”：任何活细胞如果活邻居大于 3 个，则死掉。
  • “繁殖”：任何死细胞如果活邻居正好是 3 个，则活过来。

产物

而下面这几张图，全是遵循这几条简单规则的产物。

"脉冲星"

它的周期为 3，看起来像一颗周期爆发的星星。

脉冲星

“滑翔者”

每 4 个回合 “它” 会向右下角走一格。虽然细胞早就是不同的细胞了，但它能保持原本的形态。

滑翔者

“轻量级飞船”

它的周期是 4，每 2 个回合会向右边走一格。

轻量级飞船

“滑翔者枪”

它会不停地释放出一个又一个滑翔者。

滑翔者枪

“繁殖者”

它会向右行进，留下一个接一个的 “滑翔者枪”。动图最后一帧定格时用三种颜色区分了繁殖者本体、滑翔者枪和它们打出来的滑翔者。

繁殖者

Game Of Life

上面这几条规则别名 “生命游戏”，可能是最出名的一套规则组。

最早研究细胞自动机的科学家是冯・诺伊曼，后来康韦发明了上面展示的这个最有趣的细胞自动机程序：《生命游戏》，而 wolfram 则详尽的讨论了一维世界中的细胞自动机的所有情况

这个游戏被许多计算机程序实现了。Unix 世界中的许多 Hacker 喜欢玩这个游戏，他们用字符代表一个细胞，在一个计算机屏幕上进行演化。

import numpy as np
import matplotlib.pyplot as plt
 
 
class GameOfLife(object):
 
  def __init__(self, cells_shape):
    """
    Parameters
    ----------
    cells_shape : 一个元组，表示画布的大小。
 
    Examples
    --------
    建立一个高20，宽30的画布
    game = GameOfLife((20, 30))
     
    """
 
    # 矩阵的四周不参与运算
    self.cells = np.zeros(cells_shape)
 
    real_width = cells_shape[0] - 2
    real_height = cells_shape[1] - 2
     
    self.cells[1:-1, 1:-1] = np.random.randint(2, size=(real_width, real_height))
    self.timer = 0
    self.mask = np.ones(9)
    self.mask[4] = 0
   
  def update_state(self):
    """更新一次状态"""
    buf = np.zeros(self.cells.shape)
    cells = self.cells
    for i in range(1, cells.shape[0] - 1):
      for j in range(1, cells.shape[0] - 1):
        # 计算该细胞周围的存活细胞数
        neighbor = cells[i-1:i+2, j-1:j+2].reshape((-1, ))
        neighbor_num = np.convolve(self.mask, neighbor, 'valid')[0]
        if neighbor_num == 3:
          buf[i, j] = 1
        elif neighbor_num == 2:
          buf[i, j] = cells[i, j]
        else:
          buf[i, j] = 0
    self.cells = buf
    self.timer += 1
   
  def plot_state(self):
    """画出当前的状态"""
    plt.title('Iter :{}'.format(self.timer))
    plt.imshow(self.cells)
    plt.show()
 
  def update_and_plot(self, n_iter):
    """更新状态并画图
    Parameters
    ----------
    n_iter : 更新的轮数
    """
    plt.ion()
    for _ in range(n_iter):
      plt.title('Iter :{}'.format(self.timer))
      plt.imshow(self.cells)
      self.update_state()
      plt.pause(0.2)
    plt.ioff()
           
 
if __name__ == '__main__':
  game = GameOfLife(cells_shape=(60, 60))
  game.update_and_plot(200)

这个游戏可以在这里玩~

https://playgameoflife.com/

https://funnyjs.com/jspages/game-of-life.html

规律

蝴蝶扇动翅膀，引起大洋彼岸的风暴。

简单的底层逻辑，导致了纷繁复杂的生命现象。

微观遵循简单的逻辑， 而宏观上会表现出纷繁复杂的现象。

如此简单的程序能生成如此复杂的行为，这意味着什么？沃尔夫勒姆认为，这正是我们宇宙的本质；我们的世界就是计算，是一套简单的规则生成的复杂现象。

附：xkcd 的一幅漫画。也许我们的宇宙就是细胞自动机的计算结果呢。

也许我们的宇宙就是细胞自动机的计算结果呢

以上漫画译自 https://xkcd.com/505/ ，并以 Creative Commons Attribution-NonCommercial 2.5 License 许可证发布。

最后，漫画里有一格的背景是黑的，一个粒子上有两个（一样的）二进制数指着它。如果你计算一下它俩的十进制.....

42

The Answer to Life，the Universe and Everything is 42.

Why is 42 ?

请用 Python 或者其他高级语言执行一下类似如下命令

>>> ord('*')
42

简单地说，42 是*的 ASCII 码，*代表什么？就是Life, the Universe, and Everything啊.

]]> 本文通过康威生命游戏展示细胞自动机原理：简单规则（如邻居数量决定细胞生死）可涌现复杂动态（脉冲星、滑翔者等）。沃尔夫勒姆认为此机制揭示宇宙本质，微观简单规则经计算生成宏观复杂现象，呼应玻尔物理关注对自然的描述的哲学观点。 互联网进化！ https://blog.mhuig.top/p/9feab2fa/ 2020-11-05T23:00:00.000Z 2025-11-20T10:18:00.000Z

简介

《互联网进化论》书中提出 "互联网的未来功能和结构将于人类大脑高度相似, 也将具备互联网虚拟感觉, 虚拟运动, 虚拟中枢, 虚拟运动神经系统",并绘制了一幅互联网虚拟大脑结构图.

互联网进化论

  • 云计算是互联网的核心硬件层和核心软件层的集合, 也是互联网中枢神经系统的萌芽.

  • 大数据代表了互联网的信息层 (数据海洋),是互联网智慧和意识产生的基础.

  • 物联网, 传感器在源源不断的向互联网大数据层汇集数据.

疑问：互联网的进化显示生命进化的方向性

达尔文进化论认为生物进化并不是从低级到高级的进化，进化没有预定的方向；生物进化是自然选择的结果。

达尔文进化论动摇了神学的土壤和基础，但互联网的进化却可能引发神秘但有趣的问题 —— 互联网和人脑为什么向同一方向进化？

互联网的未来结构是人类的大脑结构，互联网的每一个创新都是对数万年前已经存在人脑功能的模仿。科学实验证明大脑中也经拥有 Google 一样的搜索引擎，Facebook 一样的 SNS 系统，IPv4 一样的地址编码系统，思科一样的路由系统。

40 多年来人类从不同的方向在互联网领域进行创新，并没有统一的规划将互联网建造成什么结构，但有一天人类抬起头来观看自己的产品，将发现这个产品与大脑的结构高度相似，而且可以作为揭开大脑之谜的钥匙。这是一个非常奇特的现象。

终极结论

“看不见的手” 像幽灵一样盘踞在人类社会的发展过程中，时隐时现，如果说社会学、经济学还只是模糊的看到这只手的影子，那么互联网的进化有可能第一次把 “这只看不见的手” 逼到科学的解剖刀下。如何解剖它，那需要未来更多的研究者思考和实践，相信这个秘密的解开将会给人类带来重大而深远的影响 。

互联网，宇宙和大脑的关系是互联网进化论的终极结论：互联网将宇宙和大脑结合在一起，结构无限逼近人脑结构，空间上无限逼近宇宙边缘，在无穷时间点，宇宙，大脑，和互联网三者将合为一体，进化成为宇宙大脑或智慧宇宙。

]]> 本文探讨《互联网进化论》提出的核心观点：互联网功能与结构正逼近人脑，云计算、大数据、物联网分别对应其中枢、信息层与感知系统。文章质疑其与达尔文进化论的矛盾，指出互联网对人脑功能的模仿现象，最终提出互联网、宇宙与大脑将进化融合为智慧宇宙的终极假说。 BERT 预训练模型及其应用案例 https://blog.mhuig.top/p/48f700eb/ 2020-11-05T07:47:00.000Z 2025-11-20T10:18:00.000Z

预训练模型最开始是在图像领域提出的，获得了良好的效果，近几年才被广泛应用到自然语言处理各项任务中。

  • (1) 2003 年 Bengio 提出神经网络语言模型 NNLM，从此统一了 NLP 的特征形式 ——Embedding；

  • (2) 2013 年 Mikolov 提出词向量 Word2vec，延续 NNLM 又引入了大规模预训练（Pretrain）的思路；

  • (3) 2017 年 Vaswani 提出 Transformer 模型，实现用一个模型处理多种 NLP 任务。

  • (4) 基于 Transformer 架构，2018 年底开始出现一大批预训练语言模型 (3 个预训练代表性模型 BERT [2018]、XLNet [2019] 和 MPNet [2020])，刷新众多 NLP 任务，形成新的里程碑事件。

  • (5) GPT

  • (6) ChatGPT/DeepSeek

注：本文写于 2020 年，上面 5 和 6 是笔者在五年后加的, ChatGPT 几乎解决了 NLP 的所有任务。现在的媒体宣传太离谱辣，仿佛一夜之间 GPT 就普及大众了。

预训练模型的应用通常分为两步:

  • 第一步：在计算性能满足的情况下用某个较大的数据集训练出一个较好的模型。

  • 第二步：根据不同的任务，改造预训练模型，用新任务的数据集在预训练模型上进行微调。

预训练模型的好处是训练代价较小，配合下游任务可以实现更快的收敛速度，并且能够有效地提高模型性能，尤其是对一些训练数据比较稀缺的任务。换句话说，预训练方法可以认为是让模型基于一个更好的初始状态进行学习，从而能够达到更好的性能。

要讲自然语言的预训练，得先从图像领域的预训练说起。

图像领域的预训练

图像领域的预训练

设计好网络结构以后，对于图像来说一般是 CNN 的多层叠加网络结构，可以先用某个训练集合比如训练集合 A 或者训练集合 B 对这个网络进行预先训练，在 A 任务上或者 B 任务上学会网络参数，然后存起来以备后用。假设我们面临第三个任务 C，网络结构采取相同的网络结构，在比较浅的几层 CNN 结构，网络参数初始化的时候可以加载 A 任务或者 B 任务学习好的参数，其它 CNN 高层参数仍然随机初始化。

之后我们用 C 任务的训练数据来训练网络，此时有两种做法，一种是浅层加载的参数在训练 C 任务过程中不动，这种方法被称为 “Frozen”;

另外一种是底层网络参数尽管被初始化了，在 C 任务训练过程中仍然随着训练的进程不断改变，这种一般叫 “Fine-Tuning”，顾名思义，就是更好地把参数进行调整使得更适应当前的 C 任务。

对于层级的 CNN 结构来说，不同层级的神经元学习到了不同类型的图像特征，由底向上特征形成层级结构。

对于层级的CNN结构来说，不同层级的神经元学习到了不同类型的图像特征，由底向上特征形成层级结构

如果我们手头是个人脸识别任务，训练好网络后，把每层神经元学习到的特征可视化肉眼看一看每层学到了啥特征，你会看到最底层的神经元学到的是线段等特征，图示的第二个隐层学到的是人脸五官的轮廓，第三层学到的是人脸的轮廓，通过三步形成了特征的层级结构，越是底层的特征越是所有不论什么领域的图像都会具备的比如边角线弧线等底层基础特征，越往上抽取出的特征越与手头任务相关。

正因为此，所以预训练好的网络参数，尤其是底层的网络参数抽取出特征跟具体任务越无关，越具备任务的通用性，所以这是为何一般用底层预训练好的参数初始化新任务网络参数的原因。

而高层特征跟任务关联较大，实际可以不用使用，或者采用 Fine-tuning 用新数据集合清洗掉高层无关的特征抽取器。

用ImageNet来做网络的预训练

一般我们用 ImageNet 来做网络的预训练，主要有两点，一方面 ImageNet 是图像领域里有超多事先标注好训练数据的数据集合，分量足是个很大的优势，量越大训练出的参数越靠谱；另外一方面因为 ImageNet 有 1000 类，类别多，算是通用的图像数据，跟领域没太大关系，所以通用性好。

Word Embedding

现有的机器学习方法往往无法直接处理文本数据，因此需要找到合适的方法，将文本数据转换为数值型数据，由此引出了 Word Embedding 的概念，Word Embedding 算法携带了语义信息且维度经过压缩便于运算。

语言模型

语言模型

为了能够量化地衡量哪个句子更像一句人话，可以设计如上图所示函数，核心函数 P 的思想是根据句子里面前面的一系列前导单词预测后面单词的概率大小。

神经网络语言模型

神经网络语言模型

NNLM 是从语言模型出发 (即计算概率角度)，构建神经网络针对目标函数对模型进行最优化，训练的起点是使用神经网络去搭建语言模型实现词的预测任务，并且在优化过程后模型的副产品就是词向量。

Word2Vec

2013 年最火的用语言模型做 Word Embedding 的工具是 Word2Vec，后来又出了 Glove。

Word2Vec

Word2Vec 有两种训练方法，一种叫 CBOW，核心思想是从一个句子里面把一个词抠掉，用这个词的上文和下文去预测被抠掉的这个词；

第二种叫做 Skip-gram，和 CBOW 正好反过来，输入某个单词，要求网络预测它的上下文单词。

使用 Word2Vec 或者 Glove，通过做语言模型任务，就可以获得每个单词的 Word Embedding。

Word Embedding 的使用

Word Embedding的使用

我们有个 NLP 的下游任务，比如 QA，就是问答问题，所谓问答问题，指的是给定一个问题 X，给定另外一个句子 Y, 要判断句子 Y 是否是问题 X 的正确答案。

句子中每个单词以 Onehot 形式作为输入，然后乘以 Word Embedding 矩阵 Q，就直接取出单词对应的 Word Embedding。

使用 Word Embedding 等价于把 Onehot 层到 embedding 层的网络用预训练好的参数矩阵 Q 初始化。

这跟前面讲的图像领域的低层预训练过程其实是一样的，区别无非 Word Embedding 只能初始化第一层网络参数，再高层的参数就无能为力了。

下游 NLP 任务在使用 Word Embedding 的时候也类似图像有两种做法，一种是 Frozen，就是 Word Embedding 那层网络参数固定不动；另外一种是 Fine-Tuning，就是使用新的训练集合训练，在训练过程中，更新 Word Embedding 这层参数。

Word Embedding 的问题

Word Embedding的问题

是多义词问题。多义词是自然语言中经常出现的现象，也是语言灵活性和高效性的一种体现。

多义词对 Word Embedding 来说有什么负面影响？如上图所示，比如多义词 Bank，有两个常用含义，但是 Word Embedding 在对 bank 这个单词进行编码的时候，是区分不开这两个含义的，因为它们尽管上下文环境中出现的单词不同，但是在用语言模型训练的时候，不论什么上下文的句子经过 word2vec，都是预测相同的单词 bank，而同一个单词占的是同一行的参数空间，这导致两种不同的上下文信息都会编码到相同的 word embedding 空间里去。所以 word embedding 无法区分多义词的不同语义，这就是它的一个比较严重的问题。

从 Word Embedding 到 ELMO

ELMO 是 “Embedding from Language Models” 的简称。在此之前的 Word Embedding 本质上是个静态的方式，所谓静态指的是训练好之后每个单词的表达就固定住了，以后使用的时候，不论新句子上下文单词是什么，这个单词的 Word Embedding 不会跟着上下文场景的变化而改变。

ELMO 的本质思想是：事先用语言模型学好一个单词的 Word Embedding，此时多义词无法区分，实际使用 Word Embedding 的时候，单词已经具备了特定的上下文了，这个时候可以根据上下文单词的语义去调整单词的 Word Embedding 表示，这样经过调整后的 Word Embedding 更能表达在这个上下文中的具体含义，自然也就解决了多义词的问题了。所以 ELMO 本身的思路是根据当前上下文对 Word Embedding 动态调整。

从Word Embedding到ELMO

ELMO 采用了典型的两阶段过程，第一个阶段是利用语言模型进行预训练；第二个阶段是在做下游任务时，从预训练网络中提取对应单词的网络各层的 Word Embedding 作为新特征补充到下游任务中。

使用这个网络结构利用大量语料做语言模型任务就能预先训练好这个网络，如果训练好这个网络后，输入一个新句子 ，句子中每个单词都能得到对应的三个 Embedding: 最底层是单词的 Word Embedding，往上走是第一层双向 LSTM 中对应单词位置的 Embedding，这层编码单词的句法信息更多一些；再往上走是第二层 LSTM 中对应单词位置的 Embedding，这层编码单词的语义信息更多一些。也就是说，ELMO 的预训练过程不仅仅学会单词的 Word Embedding，还学会了一个双层双向的 LSTM 网络结构，而这两者后面都有用。

从Word Embedding到ELMO

上图展示了下游任务的使用过程，比如我们的下游任务仍然是 QA 问题，此时对于问句 X，我们可以先将句子 X 作为预训练好的 ELMO 网络的输入，这样句子 X 中每个单词在 ELMO 网络中都能获得对应的三个 Embedding，之后给予这三个 Embedding 中的每一个 Embedding 一个权重 a，这个权重可以学习得来，根据各自权重累加求和，将三个 Embedding 整合成一个。然后将整合后的这个 Embedding 作为 X 句在自己任务的那个网络结构中对应单词的输入，以此作为补充的新特征给下游任务使用。对于上图所示下游任务 QA 中的回答句子 Y 来说也是如此处理。因为 ELMO 给下游提供的是每个单词的特征形式，所以这一类预训练的方法被称为 “Feature-based Pre-Training”。

从 Word Embedding 到 GPT

从Word Embedding到GPT

GPT 是 “Generative Pre-Training” 的简称，从名字看其含义是指的生成式的预训练。GPT 也采用两阶段过程，第一个阶段是利用语言模型进行预训练，第二阶段通过 Fine-tuning 的模式解决下游任务。

Transformer

Transformer 是个叠加的 “自注意力机制（Self Attention）” 构成的深度网络，是目前 NLP 里最强的特征提取器。

Transformer 是一种基于 encoder-decoder 结构的模型. 在机器翻译任务上的表现超过了 RNN，CNN，只用 encoder-decoder 和 attention 机制就能达到很好的效果，最大的优点是可以高效地并行化。

Transformer

自注意力机制模型

人类视觉通过快速扫描全局图像，获得需要重点关注的目标区域，也就是一般所说的注意力焦点，而后对这一区域投入更多注意力资源，以获取更多所需要关注目标的细节信息，而抑制其他无用信息。

这是人类利用有限的注意力资源从大量信息中快速筛选出高价值信息的手段.

深度学习中的注意力机制从本质上讲和人类的选择性视觉注意力机制类似，核心目标也是从众多信息中选择出对当前任务目标更关键的信息。

Attention 在同一个英语句子内单词间产生的联系。

自注意力机制模型

自注意力机制模型

Self Attention 可以捕获同一个句子中单词之间的一些句法特征（比如图展示的有一定距离的短语结构）或者语义特征（比如图展示的 its 的指代对象 Law）。

很明显，引入 Self Attention 后会更容易捕获句子中长距离的相互依赖的特征，因为如果是 RNN 或者 LSTM，需要依次序序列计算，对于远距离的相互依赖的特征，要经过若干时间步步骤的信息累积才能将两者联系起来，而距离越远，有效捕获的可能性越小。

SelfAttention 在计算过程中会直接将句子中任意两个单词的联系通过一个计算步骤直接联系起来，所以远距离依赖特征之间的距离被极大缩短，有利于有效地利用这些特征。除此外，SelfAttention 对于增加计算的并行性也有直接帮助作用。这是为何 Self Attention 逐渐被广泛使用的主要原因。

GPT 如何使用

GPT如何使用

把任务的网络结构改造成和 GPT 的网络结构是一样的。然后，在做下游任务的时候，利用第一步预训练好的参数初始化 GPT 的网络结构，对网络参数进行 Fine-tuning，使得这个网络更适合解决手头的问题。

从 GPT 和 ELMO 及 word2Vec 到 Bert

从GPT和ELMO及word2Vec到Bert

Bert 采用和 GPT 完全相同的两阶段模型，首先是语言模型预训练；其次是使用 Fine-Tuning 模式解决下游任务。和 GPT 的最主要不同在于在预训练阶段采用了类似 ELMO 的双向语言模型，当然另外一点是语言模型的数据规模要比 GPT 大。

BERT 本质上是一个自编码（Auto Encoder）语言模型，为了能见多识广，BERT 使用 3 亿多词语训练，采用 12 层双向 Transformer 架构。注意，BERT 只使用了 Transformer 的编码器部分，可以理解为 BERT 旨在学习庞大文本的内部语义信息。

具体训练目标之一，是被称为掩码语言模型的 MLM。即输入一句话，给其中 15% 的字打上 “mask” 标记，经过 Embedding 输入和 12 层 Transformer 深度理解，来预测 “mask” 标记的地方原本是哪个字。

input:   欲把西[mask]比西子，淡[mask]浓抹总相宜
output:  欲把西[湖]比西子，淡[妆]浓抹总相宜

例如我们输入 “欲把西 [mask] 比西子，淡 [mask] 浓抹总相宜” 给 BERT，它需要根据没有被 “mask” 的上下文，预测出掩盖的地方是 “湖” 和 “妆”。

MLM 任务的灵感来自于人类做完形填空。挖去文章中的某些片段，需要通过上下文理解来猜测这些被掩盖位置原先的内容。

训练目标之二，是预测输入的两句话之间是否为上下文（NSP）的二分类问题。继续输入 “ 欲把西 [湖] 比西子，淡 [妆] 浓抹总相宜”，BERT 将预测这两句话的组合是否合理（这个例子是 “yes”）。（随后的研究者对预训练模型探索中证明，NSP 任务过于简单，对语言模型的训练作用并不是很大）

通过这两个任务和大规模语料训练，BERT 语言模型可以很好学习到文本之间的蕴含的关系。

从GPT和ELMO及word2Vec到Bert

NLP 的四大任务

NLP的四大任务

绝大部分 NLP 问题可以归入上图所示的四类任务中：

一类是序列标注，这是最典型的 NLP 任务，比如中文分词，词性标注，命名实体识别，语义角色标注等都可以归入这一类问题，它的特点是句子中每个单词要求模型根据上下文都要给出一个分类类别。

第二类是分类任务，比如我们常见的文本分类，情感计算等都可以归入这一类。它的特点是不管文章有多长，总体给出一个分类类别即可。

第三类任务是句子关系判断，比如 Entailment，QA，语义改写，自然语言推理等任务都是这个模式，它的特点是给定两个句子，模型判断出两个句子是否具备某种语义关系；

第四类是生成式任务，比如机器翻译，文本摘要，写诗造句，看图说话等都属于这一类。它的特点是输入文本内容后，需要自主生成另外一段文字。

NLP的四大任务

根据任务选择不同的预训练数据初始化 encoder 和 decoder 即可。这是相当直观的一种改造方法。当然，也可以更简单一点，比如直接在单个 Transformer 结构上加装隐层产生输出也是可以的。不论如何，从这里可以看出，NLP 四大类任务都可以比较方便地改造成 Bert 能够接受的方式。这其实是 Bert 的非常大的优点，这意味着它几乎可以做任何 NLP 的下游任务，具备普适性，这是很强的。

BERT 的应用案例

下载 bert 预训练模型

Google - BERT 源码 https://github.com/google-research/bert 下载预训练模型。

下载bert预训练模型

我这里选择中文的 BERT，下载解压后的目录如下：

下载bert预训练模型

安装 bert-as-service

顾名思义，将 BERT 模型直接封装成一个服务，堪称上手最快的 BERT 工具。作者是肖涵博士。

使用 pip 安装：

pip install bert-serving-server # server
pip install bert-serving-client # client, independent of `bert-serving-server

开启 BERT service

bert-serving-start -model_dir E:\nlp\chinese_L-12_H-768_A-12

安装bert-as-service

安装bert-as-service

使用客户端获取句子编码

安装bert-as-service

安装bert-as-service

案例一 查找最相近的句子

根据 bert 获取句子向量，并计算出句子之间的余弦相似度，找出最相似的句子。

# 导入bert客户端
from bert_serving.client import BertClient
import numpy as np

class SimilarModel:
    def __init__(self):
        self.bert_client = BertClient()

    def close_bert(self):
        self.bert_client .close()

    def get_sentence_vec(self,sentence):
        '''
        根据bert获取句子向量
        :param sentence:
        :return:
        '''
        return self.bert_client .encode([sentence])[0]

    def cos_similar(self,sen_a_vec, sen_b_vec):
        '''
        计算两个句子的余弦相似度
        :param sen_a_vec:
        :param sen_b_vec:
        :return:
        '''
        vector_a = np.mat(sen_a_vec)
        vector_b = np.mat(sen_b_vec)
        num = float(vector_a * vector_b.T)
        denom = np.linalg.norm(vector_a) * np.linalg.norm(vector_b)
        cos = num / denom
        return cos

if __name__=='__main__':
    # 从候选集condinates 中选出与sentence_a 最相近的句子
    condinates = ['为什么天空是蔚蓝色的','太空为什么是黑的？','天空怎么是蓝色的','明天去爬山如何']
    sentence_a = '天空为什么是蓝色的'
    bert_client = SimilarModel()
    max_cos_similar = 0
    most_similar_sentence = ''
    for sentence_b in condinates:
        sentence_a_vec = bert_client.get_sentence_vec(sentence_a)
        sentence_b_vec = bert_client.get_sentence_vec(sentence_b)
        cos_similar = bert_client.cos_similar(sentence_a_vec,sentence_b_vec)
        if cos_similar > max_cos_similar:
            max_cos_similar = cos_similar
            most_similar_sentence = sentence_b

    print('最相似的句子：',most_similar_sentence)
    bert_client .close_bert()
    # 为什么天空是蔚蓝色的

案例二 简单模糊搜索

将问题编码为向量：

from bert_serving.client import BertClient
doc_vecs = bc.encode(questions)

最后，我们准备接收新查询并针对现有问题执行简单的 “模糊” 搜索。为此，每次出现新查询时，我们都将其编码为向量，并使用来计算其点积 doc_vecs。将结果递减排序；并返回前 k 个类似的问题，如下所示：

while True:
    query = input('your question: ')
    query_vec = bc.encode([query])[0]
    # compute normalized dot product as score
    score = np.sum(query_vec * doc_vecs, axis=1) / np.linalg.norm(doc_vecs, axis=1)
    topk_idx = np.argsort(score)[::-1][:topk]
    print('top %d questions similar to "%s"' % (topk, query))
    for idx in topk_idx:
        print('> %s\t%s' % ('%.1f' % score[idx], questions[idx]))

现在运行代码并键入查询，查看此搜索引擎如何处理模糊匹配：

简单模糊搜索

案例三 法条推荐

介绍

根据刑事法律文书中的案情描述和事实部分，预测本案涉及的相关法条；

数据说明

所使用的数据集是来自 “中国裁判文书网” 公开的刑事法律文书，其中每份数据由法律文书中的案情描述和事实部分组成，同时也包括每个案件所涉及的法条、被告人被判的罪名和刑期长短等要素。

数据集共包括 268 万刑法法律文书，共涉及 202 条罪名，183 条法条，刑期长短包括 0-25 年、无期、死刑。

数据利用 json 格式储存，每一行为一条数据，每条数据均为一个字典。

fact: 事实描述

meta: 标注信息，标注信息中包括:

criminals: 被告 (数据中均只含一个被告)

punish_of_money: 罚款 (单位：元)

accusation: 罪名

relevant_articles: 相关法条

term_of_imprisonment: 刑期

刑期格式 (单位：月)

death_penalty: 是否死刑

life_imprisonment: 是否无期

imprisonment: 有期徒刑刑期

这里是简单的一条数据展示: 

{
   "fact": "2015年11月5日上午，被告人胡某在平湖市乍浦镇的嘉兴市多凌金牛制衣有限公司车间内，与被害人孙某因工作琐事发生口角，后被告人胡某用木制坐垫打伤被害人孙某左腹部。经平湖公安司法鉴定中心鉴定：孙某的左腹部损伤已达重伤二级。",  
   "meta": 
   { 
       "relevant_articles": [234], 
       "accusation": ["故意伤害"], 
       "criminals": ["胡某"], 
       "term_of_imprisonment":
       { 
          "death_penalty": false, 
          "imprisonment": 12, 
          "life_imprisonment": false
       }
   }
}

实现流程

进入 OpenCLaP 下载刑事文书 BERT，并运行 bert-as-service 服务。

创建一个连接到 BertServer 的 BertClient
from bert_serving.client import ConcurrentBertClient
bc = ConcurrentBertClient()
获取编码向量和标签
def get_encodes(x):
    # x 是 batch_size 大小的行 ，每行都是一个json对象
    samples = [json.loads(l) for l in x] # 一个 batch_size 大小的连续样本
    text = [s['fact'][:50] + s['fact'][-50:] for s in samples] # 获取案情描述和事实部分文字
    features = bc.encode(text) # 使用bert将字符串列表编码为向量列表
    # 随机选择一个标签
    labels = [[str(random.choice(s['meta']['relevant_articles']))] for s in samples]
    return features, labels
构建 TensorFlow DNN 模型的分类器
estimator = DNNClassifier(
    hidden_units=[512], # 每层隐藏单元的 Iterable 数.所有层都完全连接.
    feature_columns=[tf.feature_column.numeric_column('feature', shape=(768,))], # 包含模型使用的所有特征列的iterable.集合中的所有项目都应该是从 _FeatureColumn 派生的类的实例.
    n_classes=len(laws), # 标签类的数量.默认为 2,即二进制分类,必须大于1.
    config=run_config, # RunConfig 对象配置运行时设置
    label_vocabulary=laws_str, # 字符串列表,表示可能的标签值.如果给定,标签必须是字符串类型,并且 label_vocabulary 具有任何值.如果没有给出,这意味着标签已经被编码为整数或者在[0,1]内浮动, n_classes=2 ；并且被编码为{0,1,...,n_classes-1}中的整数值,n_classes> 2.如果没有提供词汇表并且标签是字符串,也会出现错误.
    optimizer=tf.train.AdamOptimizer(),# 优化函数
    dropout=0.1 # 当不是 None 时,我们将放弃给定坐标的概率.
    )
训练和评估
# 输入函数
input_fn = lambda fp: (tf.data.TextLineDataset(fp) # TextLineDataset接口提供了一种方法从数据文件中读取。只需要提供文件名（1个或者多个）。这个接口会自动构造一个dataset，类中保存的元素：文中一行，就是一个元素，是string类型的tenser。
                       # map将分别对Dataset的每个元素执行一个函数，而apply将立即对整个Dataset执行一个函数
                       .apply(tf.contrib.data.shuffle_and_repeat(buffer_size=10000)) # repeat重复和shuffle重排 tf.data.Dataset.repeat 转换会将输入数据重复有限（或无限）次；每次数据重复通常称为一个周期。tf.data.Dataset.shuffle 转换会随机化数据集样本的顺序。
                       # 将此数据集的连续元素合并为批。
                       .batch(batch_size)
                       # tf.py_func()接收的是tensor，然后将其转化为numpy array送入我们自定义的get_encodes函数，最后再将get_encodes函数输出的numpy array转化为tensor返回
                       .map(lambda x: tf.py_func(get_encodes, [x], [tf.float32, tf.string], name='bert_client'),
                            num_parallel_calls=num_parallel_calls)
                       .map(lambda x, y: ({'feature': x}, y))
                       .prefetch(20)) # 创建一个从该数据集中预提取元素的Dataset 大多数数据集输入管道应以调用结束prefetch。这允许在处理当前元素时准备以后的元素。这通常会提高延迟和吞吐量，但以使用额外的内存存储预取元素为代价。
# TrainSpec确定训练的输入数据以及持续时间
train_spec = TrainSpec(input_fn=lambda: input_fn(train_fp))
# EvalSpec结合了训练模型的计算和输出的详细信息.计算由计算指标组成,用以判断训练模型的性能.输出将训练好的模型写入外部存储.
eval_spec = EvalSpec(input_fn=lambda: input_fn(eval_fp), throttle_secs=0) # 第一次评估发生在throttle_secs秒后
# 训练和评估
train_and_evaluate(estimator, train_spec, eval_spec)
运行 tensorboard 可视化训练过程
tensorboard --logdir=law-model

运行tensorboard可视化训练过程

运行tensorboard可视化训练过程

案例四 互联网新闻情感分析

介绍

对新闻情绪进行分类，0 代表正面情绪、1 代表中性情绪、2 代表负面情绪。

数据说明

FieldTypeDescription
idString新闻 ID News ID
textString新闻正文内容 Content of news text
labelString新闻情感标签 Emotional label in news

实现流程

加载数据集
def load_dataset(filepath):
    dataset_list = []
    f = open(filepath, 'r', encoding='utf-8')
    r = csv.reader(f)
    for item in r:
        if r.line_num == 1:
            continue
        dataset_list.append(item)
    
    # 空元素补0
    for item in dataset_list:
        if item[1].strip() == '':
            item[1] = '0'

    return dataset_list
网络类，全连接层
class Net(nn.Module):
    # in_dim=768, out_dim=3
    def __init__(self, in_dim, out_dim):
        super(Net, self).__init__()

        self.linear1 = nn.Linear(in_dim, 500)
        self.linear2 = nn.Linear(500, 400)
        self.linear3 = nn.Linear(400, 300)
        self.linear4 = nn.Linear(300, 200)
        self.linear5 = nn.Linear(200, out_dim)
    
    def forward(self, x):
        x = self.linear1(x)
        x = self.linear2(x)
        x = self.linear3(x)
        x = self.linear4(x)
        x = self.linear5(x)
        return x
计算每个 batch 的准确率
def  batch_accuracy(pre, label):
    pre = pre.argmax(dim=1)
    correct = torch.eq(pre, label).sum().float().item()
    accuracy = correct / float(len(label))

    return accuracy
训练
for epoch in range(EPOCHS):
    step = -1
    for text, label in train_loader:
        # tuple转list
        text = list(text)
        label = list(label)
        label = list(map(int, label))
        # 使用中文bert，生成句向量
        sen_vec = bertclient.encode(text)
        sen_vec = torch.tensor(sen_vec)
        label = torch.LongTensor(label)
        label = label.cuda()
        # 输入到网络中，反向传播
        pre = net(sen_vec).cuda()
        loss = criterion(pre, label)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        # 更新loss曲线，并计算准确率
        step = step + 1
        flag = flag + 1
        if step % 100 == 0:
            acc = batch_accuracy(pre, label)
            print('epoch:{} | batch:{} | acc:{} | loss:{}'.format(epoch, step, acc, loss.item()))
测试
net.load_state_dict(torch.load('net.pt'))

test_result = []
for item in test_dataset:

    sen_vec = bertclient.encode([item[1]])
    sen_vec = torch.tensor(sen_vec)

    with torch.no_grad():
        pre = net(sen_vec).cuda()
        pre = pre.argmax(dim=1)
        pre = pre.item()
        test_result.append([item[0], pre])

        # 写入csv文件
        df = pd.DataFrame(test_result)
        df.to_csv('test_result.csv',index=False, header=['id', 'label'])
训练可视化

训练可视化

训练可视化

训练可视化

控制台输出

控制台输出

参考文献

从 Word Embedding 到 Bert 模型 — 自然语言处理中的预训练技术发展史

Transformer

深度学习中的注意力模型

谷歌的 bert

肖涵博士的 bert-as-service

Serving-Google-BERT-in-Production-using-Tensorflow-and-ZeroMQ

CAIL2018 数据集

刑事文书 BERT:

tensorboard 使用详解

Visdom 可视化工具

互联网新闻情感分析

]]> 详解BERT预训练模型原理，包括从Word2Vec到ELMO、GPT的技术演进，Transformer架构与双向语言模型特性，以及在句子相似度计算、模糊搜索等场景的应用，解析NLP四大任务适配方法与Fine-Tuning流程。 尝试使用 GPU 加速计算 https://blog.mhuig.top/p/56213be8/ 2020-10-11T01:11:00.000Z 2025-11-20T10:18:00.000Z

大规模训练，gpu 和 cpu 速度差别很大。

概述

GPU

  • CPU (Central Processing Unit) 即中央处理器。
  • GPU (Graphics Processing Unit) 即图形处理器。

当程序员为 CPU 编写程序时，他们倾向于利用复杂的逻辑结构优化算法从而减少计算任务的运行时间，即 Latency。
当程序员为 GPU 编写程序时，则利用其处理海量数据的优势，通过提高总的数据吞吐量（Throughput）来掩盖 Lantency。

GPU

其中绿色的是计算单元，橙红色的是存储单元，橙黄色的是控制单元。

首先你需要硬件支持，一块能够支持 GPU 加速计算的显卡，这里以 NVIDIA 的 GPU 为例。

CUDA

CUDA（Compute Unified Device Architecture），是显卡厂商 NVIDIA 推出的运算平台。 CUDA™是一种由 NVIDIA 推出的通用并行计算架构，该架构使 GPU 能够解决复杂的计算问题。

CUDA 提供了一种可扩展的编程模型，使得已经写好的 CUDA 代码可以在任意数量核心的 GPU 上运行。只有运行时，系统才知道物理处理器的数量。

CUDA

CUDNN

NVIDIA cuDNN 是用于深度神经网络的 GPU 加速库。它强调性能、易用性和低内存开销。NVIDIA cuDNN 可以集成到更高级别的机器学习框架中，如加州大学伯克利分校的流行 CAFFE 软件。简单的，插入式设计可以让开发人员专注于设计和实现神经网络模型，而不是调整性能，同时还可以在 GPU 上实现高性能现代并行计算。

支持 GPU 的计算框架

Tensorflow-GPU

安装教程参考 https://tensorflow.google.cn/install

需要注意的是 严格对应 tensorflow_gpu、Python、 编译器、 cuDNN、CUDA 的版本关系。

相关对应关系 windows 平台可参考:

Tensorflow 文档

显卡驱动与 Cuda 版本之间的对应关系

cuda 与 cudnn 版本之间的对应关系

打开 NVIDIA 控制面板进入系统信息，可查看当前支持的 CUDA 驱动版本。

查看当前支持的CUDA驱动版本

这里的 CUDA 驱动版本是指你只可以安装该版本及以下版本的 CUDA。

根据实际情况，笔者计划使用的环境是：

  • tensorflow_gpu-1.14.0
  • python 3.7
  • MSVC 2017
  • cuDNN 7.4.2.24
  • CUDA 10.0.130

安装 CUDA

进入cuda-toolkit-archive 选择需要的 CUDA Toolkit 版本下载安装即可。

笔者选择 network 安装方式。注意第一个路径是选择临时解压路径。选择自定义安装，取消安装不需要的应用，如 NVIDIA GeForce Experience。

在 cmd 中执行：

nvcc -V

nvcc -V

需要注意配置相关环境变量。

安装 CUDNN

进入cudnn-archive 选择需要的 CUDA Toolkit 版本下载解压即可。

笔者将 CUDA 默认安装在C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v10.0

将 CUDNN 解压到C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v10.0中即可。

或者配置单独的环境变量。

安装 Tensorflow-GPU

如果之前安装过 cpu 版本的 Tensorflow 需要进行卸载.

若在虚拟环境中使用 conda 安装，conda 会自动安装相关的 cuda 和 cudnn 依赖。

conda install tensorflow-gpu

安装Tensorflow-GPU

下面给出一段 GPU 测试程序：

import time
import tensorflow as tf
begin = time.time()
with tf.device('/gpu:0'):
    rand_t = tf.random_uniform([50,50],0,10,dtype=tf.float32,seed=0)
    a = tf.Variable(rand_t)
    b = tf.Variable(rand_t)
    c = tf.matmul(a,b)
    init = tf.global_variables_initializer()
sess = tf.Session(config=tf.ConfigProto(log_device_placement=True)) #强制使用GPU
sess.run(init)
print(sess.run(c))
end = time.time()
print(end-begin,'s')

运行结果:

2020-10-11 09:36:56.713905: I tensorflow/core/platform/cpu_feature_guard.cc:142] Your CPU supports instructions that this TensorFlow binary was not compiled to use: AVX AVX2
2020-10-11 09:36:56.742138: I tensorflow/stream_executor/platform/default/dso_loader.cc:42] Successfully opened dynamic library nvcuda.dll
2020-10-11 09:36:57.193243: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1640] Found device 0 with properties:
name: GeForce GTX 960M major: 5 minor: 0 memoryClockRate(GHz): 1.176
pciBusID: 0000:01:00.0
2020-10-11 09:36:57.199952: I tensorflow/stream_executor/platform/default/dlopen_checker_stub.cc:25] GPU libraries are statically linked, skip dlopen check.
2020-10-11 09:36:57.204946: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1763] Adding visible gpu devices: 0
2020-10-11 09:36:58.622428: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1181] Device interconnect StreamExecutor with strength 1 edge matrix:
2020-10-11 09:36:58.626880: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1187]      0
2020-10-11 09:36:58.630073: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1200] 0:   N
2020-10-11 09:36:58.633910: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1326] Created TensorFlow device (/job:localhost/replica:0/task:0/device:GPU:0 with 1382 MB memory) -> physical GPU (device: 0, name: GeForce GTX 960M, pci bus id: 0000:01:00.0, compute capability: 5.0)
Device mapping:
/job:localhost/replica:0/task:0/device:GPU:0 -> device: 0, name: GeForce GTX 960M, pci bus id: 0000:01:00.0, compute capability: 5.0
2020-10-11 09:36:58.657797: I tensorflow/core/common_runtime/direct_session.cc:296] Device mapping:
/job:localhost/replica:0/task:0/device:GPU:0 -> device: 0, name: GeForce GTX 960M, pci bus id: 0000:01:00.0, compute capability: 5.0

random_uniform/RandomUniform: (RandomUniform): /job:localhost/replica:0/task:0/device:GPU:0
2020-10-11 09:36:58.683509: I tensorflow/core/common_runtime/placer.cc:54] random_uniform/RandomUniform: (RandomUniform)/job:localhost/replica:0/task:0/device:GPU:0
random_uniform/sub: (Sub): /job:localhost/replica:0/task:0/device:GPU:0
2020-10-11 09:36:58.690684: I tensorflow/core/common_runtime/placer.cc:54] random_uniform/sub: (Sub)/job:localhost/replica:0/task:0/device:GPU:0
random_uniform/mul: (Mul): /job:localhost/replica:0/task:0/device:GPU:0
2020-10-11 09:36:58.705871: I tensorflow/core/common_runtime/placer.cc:54] random_uniform/mul: (Mul)/job:localhost/replica:0/task:0/device:GPU:0
random_uniform: (Add): /job:localhost/replica:0/task:0/device:GPU:0
2020-10-11 09:36:58.719880: I tensorflow/core/common_runtime/placer.cc:54] random_uniform: (Add)/job:localhost/replica:0/task:0/device:GPU:0
Variable: (VariableV2): /job:localhost/replica:0/task:0/device:GPU:0
2020-10-11 09:36:58.738611: I tensorflow/core/common_runtime/placer.cc:54] Variable: (VariableV2)/job:localhost/replica:0/task:0/device:GPU:0
Variable/Assign: (Assign): /job:localhost/replica:0/task:0/device:GPU:0
2020-10-11 09:36:58.749906: I tensorflow/core/common_runtime/placer.cc:54] Variable/Assign: (Assign)/job:localhost/replica:0/task:0/device:GPU:0
Variable/read: (Identity): /job:localhost/replica:0/task:0/device:GPU:0
2020-10-11 09:36:58.759648: I tensorflow/core/common_runtime/placer.cc:54] Variable/read: (Identity)/job:localhost/replica:0/task:0/device:GPU:0
Variable_1: (VariableV2): /job:localhost/replica:0/task:0/device:GPU:0
2020-10-11 09:36:58.769854: I tensorflow/core/common_runtime/placer.cc:54] Variable_1: (VariableV2)/job:localhost/replica:0/task:0/device:GPU:0
Variable_1/Assign: (Assign): /job:localhost/replica:0/task:0/device:GPU:0
2020-10-11 09:36:58.776819: I tensorflow/core/common_runtime/placer.cc:54] Variable_1/Assign: (Assign)/job:localhost/replica:0/task:0/device:GPU:0
Variable_1/read: (Identity): /job:localhost/replica:0/task:0/device:GPU:0
2020-10-11 09:36:58.792460: I tensorflow/core/common_runtime/placer.cc:54] Variable_1/read: (Identity)/job:localhost/replica:0/task:0/device:GPU:0
MatMul: (MatMul): /job:localhost/replica:0/task:0/device:GPU:0
2020-10-11 09:36:58.808352: I tensorflow/core/common_runtime/placer.cc:54] MatMul: (MatMul)/job:localhost/replica:0/task:0/device:GPU:0
init: (NoOp): /job:localhost/replica:0/task:0/device:GPU:0
2020-10-11 09:36:58.823256: I tensorflow/core/common_runtime/placer.cc:54] init: (NoOp)/job:localhost/replica:0/task:0/device:GPU:0
random_uniform/shape: (Const): /job:localhost/replica:0/task:0/device:GPU:0
2020-10-11 09:36:58.838355: I tensorflow/core/common_runtime/placer.cc:54] random_uniform/shape: (Const)/job:localhost/replica:0/task:0/device:GPU:0
random_uniform/min: (Const): /job:localhost/replica:0/task:0/device:GPU:0
2020-10-11 09:36:58.853758: I tensorflow/core/common_runtime/placer.cc:54] random_uniform/min: (Const)/job:localhost/replica:0/task:0/device:GPU:0
random_uniform/max: (Const): /job:localhost/replica:0/task:0/device:GPU:0
2020-10-11 09:36:58.868493: I tensorflow/core/common_runtime/placer.cc:54] random_uniform/max: (Const)/job:localhost/replica:0/task:0/device:GPU:0
[[1405.2429  1441.7413  1364.38    ... 1480.2251  1279.0061  1620.0938 ]
 [1232.6589  1344.4458  1169.7095  ... 1205.1284  1040.5566  1421.967  ]
 [1209.3164  1180.3206  1158.1396  ... 1200.0344  1014.03217 1222.5107 ]
 ...
 [1298.9648  1262.9236  1205.6918  ... 1396.479   1090.7253  1437.241  ]
 [1118.2473  1209.0151  1077.7229  ... 1180.7025  1076.4694  1139.742  ]
 [1200.8866  1297.2266  1260.01    ... 1289.4297  1165.2448  1433.4183 ]]
2.6225805282592773 s

可以看到 GPU 已经在工作了。

同时可以在 cmd 中运行 nvidia-smi【C:\Program Files\NVIDIA Corporation\NVSMInvidia-smi.exe】监控 GPU 使用情况和更改 GPU 状态。

Keras-GPU

conda 直接安装即可, 注意需要先安装 tensorflow-gpu。

conda install keras-gpu

Pytorch-GPU

再也找不到比官网更详尽的文档了，请直接参考 https://pytorch.org/。

conda install pytorch torchvision cudatoolkit=10.0

GPU 测试程序：

import torch
flag = torch.cuda.is_available()
print(flag)

ngpu= 1
# Decide which device we want to run on
device = torch.device("cuda:0" if (torch.cuda.is_available() and ngpu > 0) else "cpu")
print(device)
print(torch.cuda.get_device_name(0))
print(torch.rand(3,3).cuda())

输出结果：

True
cuda:0
GeForce GTX 960M
tensor([[0.0208, 0.2799, 0.4918],
        [0.0020, 0.1067, 0.8207],
        [0.5531, 0.0994, 0.2108]], device='cuda:0')
]]> 对比CPU与GPU计算差异，详解NVIDIA CUDA/cuDNN环境搭建步骤，提供TensorFlow-GPU/PyTorch-GPU安装指南及版本匹配规则，附GPU测试代码与运行结果验证 R 语言初步 https://blog.mhuig.top/p/fe073ab3/ 2020-10-10T12:30:00.000Z 2025-11-20T10:18:00.000Z

尝试使用 R 语言进行数据处理

安装 R

进入 https://www.r-project.org 下载安装包即可.

安装包，载入包的命令

安装包

install.packages("mlbench")

载入包

library(mlbench)

更新所有包

update.packages(ask=FALSE, checkBuilt=TRUE)

导入数据集

dataset <- read.csv("C:\\R\\bin\\iris.csv", header=FALSE)

概要分析

显示头 10 行

head(dataset,n=10)
    V1  V2  V3  V4          V5
1  5.1 3.5 1.4 0.2 Iris-setosa
2  4.9 3.0 1.4 0.2 Iris-setosa
3  4.7 3.2 1.3 0.2 Iris-setosa
4  4.6 3.1 1.5 0.2 Iris-setosa
5  5.0 3.6 1.4 0.2 Iris-setosa
6  5.4 3.9 1.7 0.4 Iris-setosa
7  4.6 3.4 1.4 0.3 Iris-setosa
8  5.0 3.4 1.5 0.2 Iris-setosa
9  4.4 2.9 1.4 0.2 Iris-setosa
10 4.9 3.1 1.5 0.1 Iris-setosa

显示数据集的每类样本所占比例

library(mlbench)
data(PimaIndiansDiabetes)
y <- PimaIndiansDiabetes$diabetes
cbind(freq=table(y), percentage=prop.table(table(y))*100)
    freq percentage
neg  500   65.10417
pos  268   34.89583

每个属性的值的分布情况

summary(dataset)
      V1              V2              V3              V4       
Min.   :4.300   Min.   :2.000   Min.   :1.000   Min.   :0.100  
1st Qu.:5.100   1st Qu.:2.800   1st Qu.:1.600   1st Qu.:0.300  
Median :5.800   Median :3.000   Median :4.350   Median :1.300  
Mean   :5.843   Mean   :3.054   Mean   :3.759   Mean   :1.199  
3rd Qu.:6.400   3rd Qu.:3.300   3rd Qu.:5.100   3rd Qu.:1.800  
Max.   :7.900   Max.   :4.400   Max.   :6.900   Max.   :2.500  
     V5           
Length:150        
Class :character  
Mode  :character

可视化数据属性

箱线盒

# 加载数据集
data(iris)
# 为每个属性创建单独的框线图
par(mfrow=c(1,4))
for(i in 1:4) {
boxplot(iris[,i], main=names(iris)[i])
}

箱线盒

柱状图

data(iris)
par(mfrow=c(1,4))
for(i in 1:4) {
hist(iris[,i], main=names(iris)[i])
}

柱状图

曲线图

library(lattice)
data(iris)
par(mfrow=c(1,4))
for(i in 1:4) {
plot(density(iris[,i]), main=names(iris)[i])
}

曲线图

条形图

library(mlbench)
data(BreastCancer)
# 为每个分类属性创建条形图
par(mfrow=c(2,4))
for(i in 2:9) {
counts <- table(BreastCancer[,i])
name <- names(BreastCancer)[i]
barplot(counts, main=name)
}

条形图

相关图

# 加载程序包
library(corrplot)
# 加载数据
data(iris)
# 计算相关性
correlations <- cor(iris[,1:4])
# 创建相关图
corrplot(correlations, method="circle")

相关图

散点图

# 加载数据
data(iris)
# 按类别着色的成对散点图
pairs(Species~., data=iris, col=iris$Species)

散点图

密度图

# 加载程序包
library(caret)
# 加载数据
data(iris)
# 按类值为每个属性绘制密度图
x <- iris[,1:4]
y <- iris[,5]
scales <- list(x=list(relation="free"), y=list(relation="free"))
featurePlot(x=x, y=y, plot="density", scales=scales)

密度图

]]> 介绍R语言基础操作，包括安装包、导入数据、概要分析及样本比例统计；提供箱线图、柱状图、相关图等可视化方法，以iris和糖尿病数据集演示数据探索流程。 手把手教你用 Python 开始第一个机器学习项目 https://blog.mhuig.top/p/110850a/ 2020-10-10T11:43:00.000Z 2025-11-20T10:18:00.000Z

熟悉一个新的平台或者一个新的工具最好的方式就是从头到尾踏实的完成一个机器学习项目

这里以 PimaIndiansdiabetes.csv 数据集为例。

Download Data Set

PimaIndiansdiabetes.csv 数据集介绍

  • 1、该数据集最初来自国家糖尿病/消化/肾脏疾病研究所。数据集的目标是基于数据集中包含的某些诊断测量来诊断性的预测 患者是否患有糖尿病。
  • 2、从较大的数据库中选择这些实例有几个约束条件。尤其是，这里的所有患者都是 Pima 印第安至少 21 岁的女性。
  • 3、数据集由多个医学预测变量和一个目标变量组成 Outcome。预测变量包括患者的怀孕次数、BMI、胰岛素水平、年龄等。
  • 4、数据集的内容是皮马人的医疗记录，以及过去 5 年内是否有糖尿病。所有的数据都是数字，问题是（是否有糖尿病是 1 或 0），是二分类问题。数据有 8 个属性，1 个类别：
    • 【1】Pregnancies：怀孕次数
    • 【2】Glucose：葡萄糖
    • 【3】BloodPressure：血压 (mm Hg)
    • 【4】SkinThickness：皮层厚度 (mm)
    • 【5】Insulin：胰岛素 2 小时血清胰岛素（mu U / ml ）
    • 【6】BMI：体重指数 （体重 / 身高）^2 ）
    • 【7】DiabetesPedigreeFunction：糖尿病谱系功能
    • 【8】Age：年龄 （岁）
    • 【9】Outcome：类标变量 （0 或 1）

数据可视化了解数据集的结构

现在是时候看一下我们的数据集了。当前步骤中我们从不同的角度观察数据。

加载数据集

首先 import pandas 模块调用 read_csv 方法加载数据集。 

from pandas import read_csv
# 加载数据集
filename = 'pima-indians-diabetes.csv'
dataset = read_csv(filename, header=None)

显示数据实例个数、属性个数

使用 pandas 中的 shape 方法查看数据集的维度特征，显示数据实例个数 (行)、属性个数（列）。

# 显示数据实例个数、属性个数
dataset.shape
#(768, 9)

看到有 768 个实例，9 个属性。

前 10 个样本情况

使用 head 方法观察数据前 10 行。实际地仔细观察数据向来都是好办法。

# 前10个样本情况
dataset.head(10)
012345678
061487235033.60.627501
11856629026.60.351310
28183640023.30.672321
318966239428.10.167210
40137403516843.12.288331
55116740025.60.201300
637850328831.00.248261
71011500035.30.134290
82197704554330.50.158531
9812596000.00.232541

显示每个属性的统计概要

看一下每个属性的统计概要。

这里包括总数，均值，std，最小值，最大值以及一些百分比。

# 显示每个属性的统计概要（包括总数，均值，最小值，最大值以及一些百分比）
dataset.describe()
012345678
count768.000000768.000000768.000000768.000000768.000000768.000000768.000000768.000000768.000000
mean3.845052120.89453169.10546920.53645879.79947931.9925780.47187633.2408850.348958
std3.36957831.97261819.35580715.952218115.2440027.8841600.33132911.7602320.476951
min0.0000000.0000000.0000000.0000000.0000000.0000000.07800021.0000000.000000
25%1.00000099.00000062.0000000.0000000.00000027.3000000.24375024.0000000.000000
50%3.000000117.00000072.00000023.00000030.50000032.0000000.37250029.0000000.000000
75%6.000000140.25000080.00000032.000000127.25000036.6000000.62625041.0000001.000000
max17.000000199.000000122.00000099.000000846.00000067.1000002.42000081.0000001.000000

箱线盒图

导入 matplotlib，绘制每一个输入变量的箱线图。这能让我们更清晰的了解输入属性的分布情况。

from matplotlib import pyplot
# 线盒图
dataset.plot(kind='box')
pyplot.show()

箱线盒图

柱状图

# 柱状图
dataset.hist()
pyplot.show()

柱状图

看起来输入变量中有 3 个可能符合高斯分布。这个现象值得注意，我们可以使用基于这个假设的算法。

多变量散点图

看一下变量之间的相互关系，所有属性两两一组互相对比的散点图。这种图有助于我们定位输入变量间的结构性关系。

# 多变量散点图
from pandas.plotting import scatter_matrix
scatter_matrix(dataset)
pyplot.show()

注意下图中某些属性两两比对时延对角线出现的分组现象。这其实表明高度的相关性和可预测关系。

多变量散点图

交叉验证

交叉验证的基本思想是把在某种意义下将原始数据进行分组, 一部分做为训练集，另一部分做为验证集，首先用训练集对分类器进行训练, 再利用验证集来测试训练得到的模型，以此来做为评价分类器的性能指标。

用交叉验证的目的是为了得到可靠稳定的模型。

对数据进行 3、5、7 交叉验证，比较结果。

十折交叉验证

# MLP for Pima Indians Dataset with 10-fold cross validation via sklearn
from keras.models import Sequential
from keras.layers import Dense
from keras.wrappers.scikit_learn import KerasClassifier
from sklearn.model_selection import StratifiedKFold
from sklearn.model_selection import cross_val_score
import numpy


# Function to create model, required for KerasClassifier
def create_model():
    # create model
    model = Sequential()
    model.add(Dense(12, input_dim=8, activation='relu'))
    model.add(Dense(8, activation='relu'))
    model.add(Dense(1, activation='sigmoid'))
    # Compile model
    model.compile(loss='binary_crossentropy',
                  optimizer='adam',
                  metrics=['accuracy'])
    return model


# fix random seed for reproducibility
seed = 7
numpy.random.seed(seed)
# load pima indians dataset
dataset = numpy.loadtxt("pima-indians-diabetes.csv", delimiter=",")
# split into input (X) and output (Y) variables
X = dataset[:, 0:8]
Y = dataset[:, 8]
# create model
model = KerasClassifier(build_fn=create_model,
                        epochs=150,
                        batch_size=10)
# evaluate using 10-fold cross validation
kfold = StratifiedKFold(n_splits=10, shuffle=True, random_state=seed)
results = cross_val_score(model, X, Y, cv=kfold)
print(results.mean())

3 交叉验证

# 3 交叉验证
kfold = StratifiedKFold(n_splits=3, shuffle=True, random_state=seed)
results = cross_val_score(model, X, Y, cv=kfold)
print(results.mean())

5 交叉验证

kfold = StratifiedKFold(n_splits=5, shuffle=True, random_state=seed)
results = cross_val_score(model, X, Y, cv=kfold)
print(results.mean())

7 交叉验证

# 7 交叉验证
kfold = StratifiedKFold(n_splits=7, shuffle=True, random_state=seed)
results = cross_val_score(model, X, Y, cv=kfold)
print(results.mean())

结果

交叉验证Result
30.75
50.7252864837646484
70.7383295553071159
100.7382946014404297

改变神经网络结构

加深，加宽，看看什么结构对模型性能有较大影响。

加深

# 改变神经网络结构，（加深，加宽），看看什么结构对模型性能有较大影响。
# 加深
def create_model_1():
    # create model
    model = Sequential()
    model.add(Dense(12, input_dim=8, activation='relu'))
    model.add(Dense(12, input_dim=12,activation='relu'))
    model.add(Dense(12, input_dim=12,activation='relu'))
    model.add(Dense(12,input_dim=12, activation='relu'))
    model.add(Dense(12,input_dim=12, activation='relu'))
    model.add(Dense(8, input_dim=12,activation='relu'))
    model.add(Dense(8, input_dim=8,activation='relu'))
    model.add(Dense(8, input_dim=8,activation='relu'))
    model.add(Dense(8, input_dim=8,activation='relu'))
    model.add(Dense(8, input_dim=8,activation='relu'))
    model.add(Dense(1, activation='sigmoid'))
    # Compile model
    model.compile(loss='binary_crossentropy',
                  optimizer='adam',
                  metrics=['accuracy'])
    return model
model = KerasClassifier(build_fn=create_model_1,
                        epochs=150,
                        batch_size=10)
kfold = StratifiedKFold(n_splits=3, shuffle=True, random_state=seed)
results = cross_val_score(model, X, Y, cv=kfold)
print(results.mean())

加宽

# 改变神经网络结构，（加深，加宽），看看什么结构对模型性能有较大影响。
# 加宽
def create_model_2():
    # create model
    model = Sequential()
    model.add(Dense(24, input_dim=8, activation='relu'))
    model.add(Dense(16, activation='relu'))
    model.add(Dense(1, activation='sigmoid'))
    # Compile model
    model.compile(loss='binary_crossentropy',
                  optimizer='adam',
                  metrics=['accuracy'])
    return model
model = KerasClassifier(build_fn=create_model_2,
                        epochs=150,
                        batch_size=10)
kfold = StratifiedKFold(n_splits=3, shuffle=True, random_state=seed)
results = cross_val_score(model, X, Y, cv=kfold)
print(results.mean())

加深加宽

# 改变神经网络结构，（加深，加宽），看看什么结构对模型性能有较大影响。
# 加宽 加深
def create_model_2():
    # create model
    model = Sequential()
    model.add(Dense(24, input_dim=8, activation='relu'))
    model.add(Dense(24, input_dim=24, activation='relu'))
    model.add(Dense(24, input_dim=24, activation='relu'))
    model.add(Dense(24, input_dim=24, activation='relu'))
    model.add(Dense(24, input_dim=24, activation='relu'))
    model.add(Dense(12, input_dim=24, activation='relu'))
    model.add(Dense(12, input_dim=12, activation='relu'))
    model.add(Dense(12, input_dim=12, activation='relu'))
    model.add(Dense(12, input_dim=12, activation='relu'))
    model.add(Dense(12, input_dim=12, activation='relu'))
    model.add(Dense(12, input_dim=12, activation='relu'))
    model.add(Dense(8, input_dim=12, activation='relu'))
    model.add(Dense(8, input_dim=12, activation='relu'))
    model.add(Dense(8, input_dim=12, activation='relu'))
    model.add(Dense(8, input_dim=12, activation='relu'))
    model.add(Dense(8, input_dim=12, activation='relu'))
    model.add(Dense(1, activation='sigmoid'))
    # Compile model
    model.compile(loss='binary_crossentropy',
                  optimizer='adam',
                  metrics=['accuracy'])
    return model


model = KerasClassifier(build_fn=create_model_2, epochs=150, batch_size=10)
kfold = StratifiedKFold(n_splits=3, shuffle=True, random_state=seed)
results = cross_val_score(model, X, Y, cv=kfold)
print(results.mean())

结果

操作Resault
加深0.7096354166666666
加宽0.7057291666666666
加深加宽0.7174479166666666

  • 更深的模型，意味着更好的非线性表达能力，可以学习更加复杂的变换，从而可以拟合更加复杂的特征输入。

  • 网络更深，每一层要做的事情也更加简单了。

    上面就是网络加深带来的两个主要好处，更强大的表达能力和逐层的特征学习。

    而宽度就起到了另外一个作用，那就是让每一层学习到更加丰富的特征，比如不同方向，不同频率的纹理特征。

可视化训练过程

# 可视化训练过程（损失函数关系图，精确度关系图）
import matplotlib.pyplot as plt
# Fit the model
model = KerasClassifier(build_fn=create_model,
                        epochs=150,
                        batch_size=10)
history = model.fit(X,
                    Y,
                    validation_split=0.33,
                    epochs=150,
                    batch_size=10,
                    verbose=0)
# list all data in history
print(history.history.keys())

# summarize history for accuracy
plt.plot(history.history['accuracy'])
plt.plot(history.history['val_accuracy'])
plt.title('model accuracy')
plt.ylabel('accuracy')
plt.xlabel('epoch')
plt.legend(['train', 'test'], loc='upper left')
plt.show()
# summarize history for loss
plt.plot(history.history['loss'])
plt.plot(history.history['val_loss'])
plt.title('model loss')
plt.ylabel('loss')
plt.xlabel('epoch')
plt.legend(['train', 'test'], loc='upper left')
plt.show()

可视化训练过程

可视化训练过程

源码

]]> 以皮马印第安人糖尿病数据集为例，详解用Python完成机器学习项目的完整流程：数据加载与可视化分析、3/5/7/10折交叉验证对比、神经网络结构（加深/加宽）优化实验，附模型训练过程可视化及二分类任务实现代码。 How to Setup Your Python Environment for Machine Learning With Anaconda https://blog.mhuig.top/p/2f550c8c/ 2020-09-11T14:30:00.000Z 2025-11-20T10:18:00.000Z

In this tutorial, we will cover the following steps:

  • 1.Download Anaconda
  • 2.Install Anaconda
  • 3.Start and Update Anaconda
  • 4.Update scikit-learn Library
  • 5.Install Deep Learning Libraries

Download Anaconda

In this step, we will download the Anaconda Python package for your platform.

Install Anaconda

In this step, we will install the Anaconda Python software on your system.
This step assumes you have sufficient administrative privileges to install software on your system.

Start and Update Anaconda

In this step, we will confirm that your Anaconda Python environment is up to date.

Anaconda comes with a suite of graphical tools called Anaconda Navigator. You can start Anaconda Navigator by opening it from your application launcher.

Conda is fast, simple, it’s hard for error messages to hide, and you can quickly confirm your environment is installed and working correctly.

  • 1.Open a terminal (command line window).
  • 2.Confirm conda is installed correctly, by typing:
conda -V

conda 4.8.2
  • 3.Confirm Python is installed correctly by typing:
python -V

Python 3.7.6
  • 4.Confirm your conda environment is up-to-date, type:
conda update conda
conda update anaconda

You may need to install some packages and confirm the updates.

  • 5.Confirm your SciPy environment.

The script below will print the version number of the key SciPy libraries you require for machine learning development, specifically: SciPy, NumPy, Matplotlib, Pandas, Statsmodels, and Scikit-learn.
You can type “python” and type the commands in directly. Alternatively, I recommend opening a text editor and copy-pasting the script into your editor.

Update scikit-learn Library

In this step, we will update the main library used for machine learning in Python called scikit-learn.

  1. Update scikit-learn to the latest version.
    At the time of writing, the version of scikit-learn shipped with Anaconda is out of date (0.17.1 instead of 0.18.1). You can update a specific library using the conda command; below is an example of updating scikit-learn to the latest version.
    At the terminal, type:
conda update scikit-learn

Alternatively, you can update a library to a specific version by typing: 

conda install -c anaconda scikit-learn

Install Deep Learning Libraries

conda install theano
conda install -c conda-forge tensorflow
conda install keras
conda install graphviz

Summary

Version

First MLP

Download Data Set
]]> 详细讲解使用Anaconda搭建机器学习Python环境的步骤：下载安装Anaconda、验证更新conda与Python版本、配置SciPy库生态，更新scikit-learn至最新版，并安装Theano、TensorFlow、Keras等深度学习框架及依赖工具。 初探 Cloudflare Workers 边缘计算 https://blog.mhuig.top/p/4a0f523a/ 2020-08-31T11:53:00.000Z 2025-11-20T10:18:00.000Z 尝试在边缘运行 JavaScript

什么是边缘计算

边缘运算（Edge computing），又译为边缘计算，是一种分散式运算的架构，将应用程序、数据资料与服务的运算，由网络中心节点，移往网络逻辑上的边缘节点来处理。边缘计算将原本完全由中心节点处理大型服务加以分解，切割成更小与更容易管理的部分，分散到边缘节点去处理。边缘节点更接近于用户终端装置，可以加快资料的处理与传送速度，减少延迟。在这种架构下，资料的分析与知识的产生，更接近于数据资料的来源，因此更适合处理大数据。

OpenStack（是一个由 NASA 和 Rackspace 合作研发并发起的，以 Apache 许可证授权的自由软件和开放源代码项目）社区的定义概念：

“边缘计算是为应用开发者和服务提供商在网络的边缘侧提供云服务和 IT 环境服务；目标是在靠近数据输入或用户的地方提供计算、存储和网络带宽”。

章鱼理论秒懂边缘计算

章鱼理论：用 "脚" 解决问题的边缘计算！

作为无脊椎动物中智商最高的一种动物，章鱼拥有巨量的神经元，但 60% 分布在章鱼的八条腿（腕足）上，脑部仅有 40%。

也就是说：

章鱼理论

用脚解决问题的边缘计算

警告：本文从以下开始跑题。

== 需要 M03-GLORIA 程序特殊访问权限 ==

正在读取资料。请稍等.......

[拒绝访问]
[该数据已被删除]

正在读取备份。请稍等.......

本博客边缘计算的搭建方案

本博客目前采用 Vercel、Cloudflare、GithubPages 多线部署，未来可能会考虑添加██████等其他线路。笔者在此解释 Cloudflare 线路的边缘计算部署方案。

本博客边缘计算的搭建方案

正如你所见，静态页面托管存储在 Github 仓库██████中，并开启GitHub Pages 服务，使用Cloudflare Workers 实现边缘计算处理逻辑，LeanCloud 数据库存储网站动态数据。

笔者在这里只谈部署思路，由于███████████████████████████████████，相信应该不会有人愿意开源公开自己的后端程序，安全策略以及██████████████████████等等。

实现网站镜像

目前 Cloudflare 线路即为 GithubPages 的镜像站，我不说相信你也可以看出来，当然我也可以随时切换为 Vercel 或者██████或者██████的镜像站。

在网络边缘拦截用户请求，并修改请求中的request.url.hostname,将对用户请求的域解析替换为原始真实 URL，实现隐藏真实网络基础设施的目的。

具体实现可以查阅相关文档

/**
 * An object with different URLs to fetch
 * @param {Object} ORIGINS
 */
const ORIGINS = {
  "starwarsapi.yourdomain.com": "swapi.co",
  "google.yourdomain.com": "google.com",
}

async function handleRequest(request) {
  const url = new URL(request.url)
  // Check if incoming hostname is a key in the ORIGINS object
  if (url.hostname in ORIGINS) {
    const target = ORIGINS[url.hostname]
    url.hostname = target
    // If it is, proxy request to that third party origin
    return fetch(url.toString(), request)
  }

  // Otherwise, process request as normal
  return fetch(request)
}

addEventListener("fetch", event => {
  event.respondWith(handleRequest(event.request))
})

隐藏前端 API 密钥

由于调用数据库 API 需要使用 AppID 和 AppKey：

Key

而直接将他们写在前端页面存在安全风险，因此笔者将数据库 API 密钥直接写在了 Cloudflare Worker 中。

以本站的评论系统为例，在前端页面插入伪造的 API 密钥以作混淆，下图一看就知道是伪造的密钥。

伪造的API密钥

在网络边缘拦截用户请求，判断请求合法性，动态更改请求标头替换为真实的 API 密钥，并向后端数据库转发请求，实现数据交互时隐藏 API 密钥。

具体实现可以查阅相关文档

自定义防火墙规则

从 CF-IPCountry HTTP 标头检索 IP 地理位置信息，以判断访问者合法性██████████████████，对于非法访问者████████████████████████████。笔者配合使用████████████数据库实现动态████████████████████████。

How does Cloudflare handle HTTP Request headers?

Configuring Cloudflare IP Geolocation

记录请求日志

由于目前 Cloudflare Workers 没有███████████的功能██████████████████，因此笔者使用 Leancloud 数据库的REST API 发送 HTTP 请求来与 数据库 进行交互。

Cloudflare Workers 默认在事件的response发送完成后结束边缘的相关进程，这里笔者使用event.waitUntil(promise Promise),延长事件的生存期，而不会阻止事件的response发送。使用此方法可以通知运行时以等待需要比正常的发送响应时间更长的时间运行的任务（例如，日志记录，对第三方服务的分析，流和缓存）。

将所有请求记录到数据库中，以便需要时调查取证或者█████████。

HTTP2 server push

多路复用，是 HTTP / 2 众多协议优化中最令人振奋的特性，它大大降低了网络延迟对性能的影响，而对于资源之间的依赖关系导致的 “延迟”，Server Push 则提供了手动优化方案。

通常，只有在浏览器请求某个资源的时候，服务器才会向浏览器发送该资源。Server Push 则允许服务器在收到浏览器的请求之前，主动向浏览器推送资源。比如说，网站首页引用了一个 CSS 文件。浏览器在请求首页时，服务器除了返回首页的 HTML 之外，可以将其引用的 CSS 文件也一并推给客户端。

本站在返回的请求中添加 HTTP 标头实现 HTTP2 server push。

if(request.headers.get("content-type")=="text/html; charset=utf-8"){
   response.headers.set("Link", "</css/style.css>; rel=preload; as=style,</js/app.js>; rel=preload; as=script, <https://cdn.jsdelivr.net>; rel=preconnect; crossorigin, <https://cdn.jsdelivr.net>; rel=dns-prefetch")
}

具体实现可以查阅相关文档

CORS header proxy

由于██████████████████需要前端实现跨域，可以直接添加 HTTP 标头实现。

const corsHeaders = {
  "Access-Control-Allow-Origin": "*",
  "Access-Control-Allow-Methods": "GET, HEAD, POST, OPTIONS",
  "Access-Control-Allow-Headers": "Content-Type",
}

具体实现可以查阅相关文档

其他应用

更多 Examples

[文件已删除]

搭建其他镜像站

上面介绍镜像自己的博客，如法炮制，你也可以镜像其他网站，例如 Github、█████████、█████████、█████████等，请勿用于非法用途，否则后果自负。

下面是一个随便在百度中搜索到的脚本，几乎随便一搜都可以找到它，大家不会都用一个吧。

// 你想镜像的站点
const upstream = 'zh.wikipedia.org'
 
// 针对移动端适配站点，没有就和保持和上面一致
const upstream_mobile = 'zh.wikipedia.org'
 
// 禁止某些地区访问
const blocked_region = []
 
// 禁止自访问
const blocked_ip_address = ['0.0.0.0', '127.0.0.1']
 
// 你想镜像的站点
const replace_dict = {
    '$upstream': '$custom_domain',
    '//zh.wikipedia.org': ''
}
 
// 剩下的就不用管了
addEventListener('fetch', event => {
    event.respondWith(fetchAndApply(event.request));
})
 
async function fetchAndApply(request) {
 
    const region = request.headers.get('cf-ipcountry').toUpperCase();
    const ip_address = request.headers.get('cf-connecting-ip');
    const user_agent = request.headers.get('user-agent');
 
    let response = null;
    let url = new URL(request.url);
    let url_host = url.host;
 
    if (url.protocol == 'http:') {
        url.protocol = 'https:'
        response = Response.redirect(url.href);
        return response;
    }
 
    if (await device_status(user_agent)) {
        upstream_domain = upstream
    } else {
        upstream_domain = upstream_mobile
    }
 
    url.host = upstream_domain;
 
    if (blocked_region.includes(region)) {
        response = new Response('Access denied: WorkersProxy is not available in your region yet.', {
            status: 403
        });
    } else if(blocked_ip_address.includes(ip_address)){
        response = new Response('Access denied: Your IP address is blocked by WorkersProxy.', {
            status: 403
        });
    } else{
        let method = request.method;
        let request_headers = request.headers;
        let new_request_headers = new Headers(request_headers);
 
        new_request_headers.set('Host', upstream_domain);
        new_request_headers.set('Referer', url.href);
 
        let original_response = await fetch(url.href, {
            method: method,
            headers: new_request_headers
        })
 
        let original_response_clone = original_response.clone();
        let original_text = null;
        let response_headers = original_response.headers;
        let new_response_headers = new Headers(response_headers);
        let status = original_response.status;
 
        new_response_headers.set('access-control-allow-origin', '*');
        new_response_headers.set('access-control-allow-credentials', true);
        new_response_headers.delete('content-security-policy');
        new_response_headers.delete('content-security-policy-report-only');
        new_response_headers.delete('clear-site-data');
 
        const content_type = new_response_headers.get('content-type');
        if (content_type.includes('text/html') && content_type.includes('UTF-8')) {
            original_text = await replace_response_text(original_response_clone, upstream_domain, url_host);
        } else {
            original_text = original_response_clone.body
        }
 
        response = new Response(original_text, {
            status,
            headers: new_response_headers
        })
    }
    return response;
}
 
async function replace_response_text(response, upstream_domain, host_name) {
    let text = await response.text()
 
    var i, j;
    for (i in replace_dict) {
        j = replace_dict[i]
        if (i == '$upstream') {
            i = upstream_domain
        } else if (i == '$custom_domain') {
            i = host_name
        }
 
        if (j == '$upstream') {
            j = upstream_domain
        } else if (j == '$custom_domain') {
            j = host_name
        }
 
        let re = new RegExp(i, 'g')
        text = text.replace(re, j);
    }
    return text;
}
 
async function device_status (user_agent_info) {
    var agents = ["Android", "iPhone", "SymbianOS", "Windows Phone", "iPad", "iPod"];
    var flag = true;
    for (var v = 0; v < agents.length; v++) {
        if (user_agent_info.indexOf(agents[v]) > 0) {
            flag = false;
            break;
        }
    }
    return flag;
}

Cloudflare workers blog

cloudflare-worker-blog

一个在 Github 上的开源实例，██████████████████████████████████████████████████
██████████████████████████████████Cloudflare workers + Github 实现的动态博客系统█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████。
。

jsproxy

jsproxy 一个基于浏览器端 JS 实现的在线代理，████████████████████████████████████████

█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████。

项目主要用于以下技术的研究：

  • 网站镜像 / 沙盒化
  • 钓鱼网站检测技术
  • 前端资源访问加速

█████████████████████████████，否则█████████████。

加速 Google Analytics

cloudflare-workers-async-google-analytics

The Cloudflare Workers implementation of an async Google Analytics.

██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████。

以上代码，请勿将其用于非法用途，否则后果自负。

严禁未经授权的人员进行访问

肇事者将被监控，定位并处理

]]> 本文介绍Cloudflare Workers边缘计算技术的应用实践，包括通过拦截请求实现网站镜像与隐藏真实基础设施、在边缘环境存储API密钥以提升前端安全、配置自定义防火墙规则及HTTP2 Server Push优化性能，同时提供相关JavaScript实现代码示例。 https://blog.mhuig.top/p/notes-spark/ 2020-05-06T23:56:00.000Z 2025-11-20T10:18:00.000Z



开始阅读

Spark

]]> Apache Spark是加州大学伯克利分校开发的分布式计算框架，核心是弹性分布式数据集（RDD），支持内存计算，比Hadoop MapReduce快10-100倍。通过DAG引擎优化执行计划，提供SQL查询（Spark SQL）、流处理（Structured Streaming）和机器学习（MLlib）等组件，支持Java、Python等多语言API，广泛应用于大数据分析、实时处理和AI训练场景。 https://blog.mhuig.top/p/notes-ubuntu/ 2020-05-05T23:56:00.000Z 2025-11-20T10:18:00.000Z



开始阅读

Ubuntu

]]> Ubuntu是Canonical开发的开源Linux发行版，基于Debian构建，以易用性和广泛兼容性著称。提供桌面、服务器、云等多版本，每两年发布LTS版（长期支持），如24.04 LTS（Noble Numbat），默认搭载GNOME桌面环境与APT包管理，支持ZFS文件系统和全盘加密，广泛用于个人电脑、服务器及IoT设备。 Travellings 开往下一个地方 https://blog.mhuig.top/p/4bd2472f/ 2020-05-04T11:47:00.000Z 2025-11-20T10:18:00.000Z

互联网将人与人之间的距离大大减小，却还是形成了大大小小的孤岛。只有熟人间才知道彼此，而陌生人永远只能是陌生人。

什么是开往 - 友链接力

开往 - 友链助力是传统友链的增强，我们不必互相知道了解彼此，标准的审查让友好的朋友加入我们，只需要一个徽标，占用一块位置，我们所有人都联系在了一起，简单而又强大。

开往 - 友链接力

旅行愉快

日常大家可以点击 banner 或者 footer 栏中的 “Travellings” 图标去参观其他博主的博客，祝大家旅行愉快。

站台

这里是下一站的站台，来场星际旅行吧~。

开往-友链接力

]]> 针对互联网孤岛现象，本文介绍开往友链接力，传统友链的增强形式，通过统一徽标与标准化审查，让陌生博主无需互知即可建立连接，点击图标即可跳转访问其他博客，实现简单而强大的博客互联。 哈勃望远镜在你生日那天看到了啥 https://blog.mhuig.top/p/6af346a8/ 2020-05-04T08:50:00.000Z 2025-11-20T10:18:00.000Z

About

1990 年，NASA 将哈勃望远镜送进太空。多年来哈勃望远镜一直在探索宇宙，拍摄了许多珍贵的图像。

2020 年是哈勃望远镜服役的第 30 年，为此 NASA 公开了哈勃望远镜拍摄的 366 张珍贵图像。

哈勃望远镜每周 7 天，每天 24 小时不间断地探索宇宙。 这意味着它在一年中的每一天都观察到了一些迷人的宇宙奇观。

What did Hubble look at on your birthday? 可以在 NASA 网站 中输入月份和日期来查找。

What Did Hubble See on Your Birthday?

大图警告

点击查看
]]> 1990年发射的哈勃望远镜服役30周年之际，NASA公开366张每日宇宙图像。用户可通过NASA官网输入生日日期，查看当天哈勃拍摄的宇宙奇观，感受太空探索的魅力。 大数据技术概述 https://blog.mhuig.top/p/376025fe/ 2020-05-01T00:02:00.000Z 2025-11-20T10:18:00.000Z

大数据时代

大数据时代

第三次信息化浪潮

根据 IBM 前首席执行官郭士纳的观点，IT 领域每隔十五年就会迎来一次重大变革

信息化浪潮发生时间标志解决问题代表企业
第一次浪潮1980 年前后个人计算机信息处理Intel、AMD、IBM、苹果、微软、联想、戴尔、惠普等
第二次浪潮1995 年前后互联网信息传输雅虎、谷歌、阿里巴巴、百度、腾讯等
第三次浪潮2010 年前后物联网、云计算和大数据信息爆炸将涌现出一批新的市场标杆企业

信息科技为大数据时代提供技术支撑

  • 存储设备容量不断增加

存储价格随时间变化情况

  • CPU 处理能力大幅提升

CPU晶体管数目随时间变化情况

  • 网络带宽不断增加

网络带宽随时间变化情况

数据产生方式的变革促成大数据时代的来临

数据产生方式的变革

大数据的特征及数据科学面临的挑战

大数据的特征及数据科学面临的挑战

大数据概念

大数据概念

数据量大

数据量大

数据类型繁多

数据类型繁多

处理速度快

处理速度快

价值密度低

价值密度低

大数据的影响

图灵奖获得者、著名数据库专家 Jim Gray 博士观察并总结人类自古以来，在科学研究上，先后历经了实验、理论、计算和数据四种范式

实验、理论、计算和数据四种范式

在思维方式方面，大数据完全颠覆了传统的思维方式：

  • 全样而非抽样
  • 效率而非精确
  • 相关而非因果

大数据关键技术

技术层面功能
数据采集利用 ETL 工具将分布的、异构数据源中的数据如关系数据、平面数据文件等，抽取到临时中间层后进行清洗、转换、集成，最后加载到数据仓库或数据集市中，成为联机分析处理、数据挖掘的基础；或者也可以把实时采集的数据作为流计算系统的输入，进行实时处理分析
数据存储和管理利用分布式文件系统、数据仓库、关系数据库、NoSQL 数据库、云数据库等，实现对结构化、半结构化和非结构化海量数据的存储和管理
数据处理与分析利用分布式并行编程模型和计算框架，结合机器学习和数据挖掘算法，实现对海量数据的处理和分析；对分析结果进行可视化呈现，帮助人们更好地理解数据、分析数据
数据隐私和安全在从大数据中挖掘潜在的巨大商业价值和学术价值的同时，构建隐私数据保护体系和数据安全体系，有效保护个人隐私和数据安全

两大核心技术

两大核心技术

大数据计算模式

大数据计算模式

代表性大数据技术

Hadoop

Hadoop

Hadoop—MapReduce

  • MapReduce 将复杂的、运行于大规模集群上的并行计算过程高度地抽象到了两个函数：Map 和 Reduce
  • 编程容易，不需要掌握分布式并行编程细节，也可以很容易把自己的程序运行在分布式系统上，完成海量数据的计算
  • MapReduce 采用 “分而治之” 策略，一个存储在分布式文件系统中的大规模数据集，会被切分成许多独立的分片（split），这些分片可以被多个 Map 任务并行处理

MapReduce工作流程

Hadoop—YARN

YARN 的目标就是实现 “一个集群多个框架”，为什么？

一个企业当中同时存在各种不同的业务应用场景，需要采用不同的计算框架

  • MapReduce 实现离线批处理
  • 使用 Impala 实现实时交互式查询分析
  • 使用 Storm 实现流式数据实时分析
  • 使用 Spark 实现迭代计算

这些产品通常来自不同的开发团队，具有各自的资源调度管理机制
为了避免不同类型应用之间互相干扰，企业就需要把内部的服务器拆分成多个集群，分别安装运行不同的计算框架，即 “一个框架一个集群”

  • 导致问题
  • 集群资源利用率低
  • 数据无法共享
  • 维护代价高

YARN 的目标就是实现 “一个集群多个框架”，即在一个集群上部署一个统一的资源调度管理框架 YARN，在 YARN 之上可以部署其他各种计算框架
由 YARN 为这些计算框架提供统一的资源调度管理服务，并且能够根据各种计算框架的负载需求，调整各自占用的资源，实现集群资源共享和资源弹性收缩
可以实现一个集群上的不同应用负载混搭，有效提高了集群的利用率
不同计算框架可以共享底层存储，避免了数据集跨集群移动

YARN

Spark

Spark

Spark

Flink

Flink

Beam

Beam

Beam

]]> 解析大数据时代特征（数据量大、类型多、速度快、价值密度低），阐述其对科学研究范式（实验、理论、计算、数据）和思维方式（全样、效率、相关）的变革，详解Hadoop/Spark等核心技术及数据采集、存储、处理全流程。 Mac Code 代码块全屏 https://blog.mhuig.top/p/91953e39/ 2020-04-30T06:06:00.000Z 2025-11-21T00:22:00.000Z

本项测试可能已失效

代码块全屏测试

How To Use?

导入库文件即可 (写于 2020 年需要 jquery)

<link rel='stylesheet' href='https://cdn.jsdelivr.net/gh/MHuiG/blog-cdn@1.1.12/css/me.css'>
<script src='https://cdn.jsdelivr.net/gh/MHuiG/blog-cdn@1.1.12/js/me.js'></script>

去除 jquery 原生 js 版本 (2025 年 11 月)：

js code
// 获取所有figcaption元素并添加点击事件监听
document.querySelectorAll('figcaption').forEach(figcaption => {
  figcaption.addEventListener('click', function() {
    // 切换全屏状态标志
    const isFullscreen = !window.CodeBlockFullscreen;
    window.CodeBlockFullscreen = isFullscreen;
    
    // 获取相关DOM元素
    const postElement = document.getElementById('post') || document.getElementById('docs') || document.getElementById('page');
    if(!postElement) return;
    const parentElement = this.parentElement;
    const grandParentElement = parentElement.parentElement;
    const htmlElement = document.documentElement;
    const gutterElements = document.querySelectorAll('.highlight > table .gutter');
     
    // 为元素添加/移除全屏相关类
    postElement.classList.toggle('code-block-fullscreen', isFullscreen);
    parentElement.classList.toggle('code-block-fullscreen', isFullscreen);
    grandParentElement.classList.toggle('code-block-fullscreen', isFullscreen);
    parentElement.classList.toggle('code-block-fullscreen-overflow-auto', isFullscreen);
    htmlElement.classList.toggle('code-block-fullscreen-html-scroll', isFullscreen);
    
    
    // 处理多个gutter元素
    gutterElements.forEach(gutter => {
      gutter.classList.toggle('code-block-fullscreen-gutter', isFullscreen);
    });
  });
});
css code
/*code-block-fullscreen*/
.code-block-fullscreen {
    position:fixed !important;
    top:0 !important;
    left:0 !important;
    width:100% !important;
    height:100% !important;
    min-width:100% !important;
    z-index:9999999 !important;
    margin:0 !important;
    animation:elastic 3s !important;
}
.code-block-fullscreen-html-scroll {
    overflow:hidden;
}
.code-block-fullscreen-overflow-auto {
    overflow:auto;
}
.code-block-fullscreen-gutter {
    height: calc(97vh) !important;
    padding: 16px 12px !important;
    vertical-align: top !important;
}
cpp code
#include <iostream>
using namespace std;
 
int main() 
{
    cout << "Hello, World!";
    return 0;
}
python code
#!/usr/bin/python

print ("Hello, Python!")
code
#include <cstdio>
#include <iostream>
#include <vector>

using namespace std;

const int SIZE = 5e6 + 1;

struct edge
{
    int to_node, id;
    edge(int t, int i): to_node(t), id(i) {}
    ~edge() = default;
};

vector<int> edges[SIZE];
vector<edge> querys[SIZE];
int father[SIZE], mark[SIZE], ans[SIZE];

int n, m, s;

int getfa(int x)
{
    if (father[x] == x)
        return x;
    else
        return father[x] = getfa(father[x]);
}

void tarjan(int x)
{
    mark[x] = 1;
    for (auto i = edges[x].begin(); i != edges[x].end(); i++)
    {
        if (mark[*i])
            continue;
        tarjan(*i);
        father[*i] = x;
    }
    for (auto i = querys[x].begin(); i != querys[x].end(); i++)
    {
        int y = (*i).to_node, id = (*i).id;
        if (mark[y] == 2)
            ans[id] = getfa(y);
    }
    mark[x] = 2;
}

int main()
{
    int u, v;
    scanf("%d%d%d", &n, &m, &s);
    for (int i = 1; i <= n; i++)
    {
        father[i] = i;
        mark[i] = 0;
    }
    for (int i = 1; i < n; i++)
    {
        scanf("%d%d", &u, &v);
        edges[u].emplace_back(v);
        edges[v].emplace_back(u);
    }
    int x, y;
    for (int i = 1; i <= m; i++)
    {
        scanf("%d%d", &x, &y);
        if (x == y)
            ans[i] = 0;
        else
        {
            querys[x].emplace_back(edge(y, i));
            querys[y].emplace_back(edge(x, i));
        }
    }
    tarjan(s);
    for (int i = 1; i <= m; i++)
        printf("%d\n", ans[i]);
    return 0;
}
]]> 代码块全屏功能通过监听用户点击事件触发样式切换，利用JavaScript动态修改DOM元素尺寸与层级，配合CSS过渡效果实现平滑显示。需处理滚动条适配、背景遮罩及快捷键操作，常见于在线代码编辑器与技术文档平台，提升代码阅读与编辑体验。 图片墙 https://blog.mhuig.top/p/e9fadccb/ 2020-04-28T04:05:00.000Z 2025-11-20T10:18:00.000Z

流量警告
Flow warning

]]> 图片墙通过网格布局、动态加载与响应式设计，整合多尺寸图像实现视觉叙事。采用瀑布流或 masonry 布局优化空间利用，支持点击放大、分类筛选及懒加载功能，广泛应用于摄影作品集、社交媒体相册及电商商品展示，平衡美学呈现与用户交互体验。 时间之箭 https://blog.mhuig.top/p/564714f9/ 2020-04-22T01:42:00.000Z 2025-11-20T10:18:00.000Z

时间就像一只箭，射向未知的前方，把过去永远留在后面。
Time is like an arrow, shooting towards the unknown, leaving the past behind forever.

每个人 你所热爱的一切
Every piece of everyone, of everything you love,

你所憎恨的一切

of everything you hate,

你所拥有的最宝贵的东西

of everything you hold most precious,

在宇宙生命中最为伊始的几分钟内

was assembled by the forces of nature

由自然的力量合成

in the first few minutes of the universe,

在恒星的中心转化

transformed in the hearts of starts

或者在它们燃烧的消亡中诞生

or created in their fiery deaths

而当你去世的时候

And when you die,

这些碎片将回到宇宙中

those pieces will be returned to the universe

进入无限的死亡又重生的轮回之中

in the endless cycle of death and rebirth.

太阳的命运也是所有恒星的命运

The fate of the sun is the same as for all starts.

终有一天   他们都会消亡

One day, they must all eventually die

宇宙将会陷入永无止境的黑暗之中

and the cosmos will be plunged into eternal night.

这便是时间箭头最深远的影响

And this is the most profound consequence of the arrow of time.

这便是时间箭头最深远的影响

我刚用相机捕捉到的

The light that I've just captured

这个光点二百五十万年前踏上了旅程

in my camera began its journey 2.5 million years ago.

那时地球上还没有人类

At that time, on Earth, there were no humans.

远古的祖先能人

Homo habilis, our distant ancestors,

正在非洲广袤的平原上漫步

wereroaming the plaints of Africa,

就是在那些光线

and as those light rays travelled

平行于无垠宇宙的同时

through the vastness of space.

人类不断进化

our species evolved,and thousands

一代又一代的生老病死

and thousands and thousands of qenerations of humans lived

周而复始

and died,

旅途开始的二百五十万年后

and then 2.5 million years after their journey began,

这些远道而来的信使

these messengers from the depths of space

穿越漫长的时间

and from way back in our past,

映入现在我们的眼帘

arrived here on Earth.

我们与那些遥远星系息息相关

we are in a very real sense connected to these qalaxies,

无论它们是如何与我们天各一方

no matter how far away they are across the universe,

那些经历过数十亿年旅行到达地球的光线

connected by the light

终究会把我们联系在一起

that's journeved billions of ears to reach us.

生星时代

“生星时代”

The Stelliferous Era -

恒星漫天的时代

the age of the starts.

我们的太阳只是银河系两千亿颗恒星中的一颗

Our sun is just one of 200 billion starts in our qalaxy.

我们的星系也只是可观测的宇宙范围内的

Our qalaxy is one of 100 bllion

一百亿个星系中的一个

in the observable universe.

数不尽的星球上有数不胜数的岛屿

And countless islands of countless stars.

数不尽的星球上有数不胜数的岛屿

当我们注意太空的时候

When we look out into space,

我们也是在寻找自己的起源

we are looking into our own origins.

我们的故事就是宇宙的故事

Our story is the story of the universe.

因为我们是恒星真正的孩子

Beacuse we are truly children of the starts.

注入进我们的身体的

and written into every atom

每一个原子和分子

and every molecule of our bodies

就是宇宙从大爆炸

is the entire history of the universe

到现在全部的历史

from the Big Bang to the present day.

像婚戒黄金一样的珍宝

对我们来说   像婚戒黄金一样的珍宝

It's quite a thought that something as

实际上也可以在一颗遥远的   数百万光年

precious to us as the gold in a wedding ring was

甚至数十亿光年远的恒星上产生
actually forged in the death of a distant star.

从宇宙起源到最后一个黑洞消失的这个过程中

as measured from its beainning to the evappration of the last black hole.

生命 正如我们所知
life as we konw it, is only possible

只有百分之千亿分之
for one thousandth of a billion billion billionth

千亿分之千分之一的可能性
billion billion billionth billion billion billionth of a percent.

所以对于我来说

And that's why for me

宇宙中最迷人的奇迹不是恒星

the most astonishing wonder of the universe isn't a star

不是行星   也不是星系

or a planet or a galaxy

甚至根本不是一个物质

It isn't a thing at all

而是时间里的一瞬间

It's an instant in time

那个瞬间   就是现在

And that time is now.

当我们仰望天空

You see, when we look up into the sky,

望向遥远的恒星和星系时

at distant starts and galaxies,

我们其实是在仰望过去

then we're looking back in time

因为光从那些遥远天体到达地球需要时间

because the light takes time to journey from them to us.

而光从那个红点处传播到我们这里

And the light from that red dot has been travelling to us

差不多经历了整个宇宙史

for almost the entire history of the universe.

我们看到的是一百三十亿年前

You see, what we're looking at here is an event that happened

发生的事件

13 billion years ago.

我们看到的是宇宙初期的一颗恒星

What we're looking at here is the explosive death

爆炸灭亡的景象

of one of the first starts in the universe.

一日为二十四个小时

一日为二十四个小时

A day on Earth is the 24 hours

即地球绕轴自转一周

it takes our planet to rotate once on its axis.

一月为二十九天半

一月为二十九天半

Our months are based on the 29-and-a-half days

即月亮在夜空完成盈亏圆缺

it takes the moon to wax and wane in the night sky.

一年为三百六十五天又四分之一天

一年为三百六十五天又四分之一天

And a year is the 365-and-a-quarter days

即地球绕太阳公转一周

it takes us to orbit once around the sun.

人类的生命便消逝在这些熟悉的时间量程之内

These familiar timescales mark the passing of our lives.

这是宇宙无法避免的真相

It's an inescapable fact of the universe,

也被写入了物理学基本定律

written into the fundamental laws of physics,

整个宇宙将消亡

整个宇宙将消亡

The entire cosmos will die,

银河系中的两千亿恒星将全部消亡

Every single one of the 200 billion starts in our galaxy will go out.

如同太阳末日   便是地球末日

And just as the death of the sun means the end of life on our planet,

每一颗恒星的灭亡

so the death of every star

都可能预示着宇宙中其他某种生命的灭亡

will extinguish any possibility of life in the universe.

永恒的变化是人类生命中最基本的部分

永恒的变化是人类生命中最基本的部分

Permanent change is a fundamental part of what it means to be human.

随着时间流逝   我们都会变老
We all age as the years pass by.

人们出生   成长   死亡
People are born, they live, they die.

我想这只是生命中悲悲喜喜的一部分
I suppose it's part of the joy and tragedy of our lives.

但纵观宇宙
But out there in the universe,

那些宏伟的如史诗般的循环好像永恒不变
those grand and epic cycles appear eternal and unchanging.

然而这只是错觉
But that's an illlusion.

宇宙长河就如同我们的生命一样
You see, in the life of the universe, just in our lives,

一切都在不可逆转地变化
everything is irreversibly changing.

组成巨大的冰块重回冰川

我们从没见过浪花离开过湖面
We never see waves travelling across lakes.

聚集在一起   组成巨大的冰块重回冰川
coming together and bouncing chunks of ice back onto glaciers.

我们被迫前往将来
We are compelled to travel into the future.

那是因为
And that's because

时间箭头规定   随着时间流逝
the arrow of time dictates that as each moment passes,

万物也在发生变化
things change.

变化一旦发生   就无法更改
And once these changes have happend, they are never undone.

这些循环看似永恒不变

这些循环看似永恒不变
These cycles seem eternal and unchanging,

但随着时间之书徐徐展开
but as the story of time unfolds,

一条真理跃然眼前

一条真理跃然眼前
afundamental truth is revealed.

没有什么能够永恒

没有什么能够永恒
Nothing lates forever.

]]> 时间之箭作为物理学基本定律，决定宇宙万物不可逆变化：恒星生灭、宇宙终将消亡，人类与遥远星系通过数十亿年旅行的星光相连，生命元素源于恒星，印证时间流逝与宇宙演化的深刻关联。 Hello World https://blog.mhuig.top/p/4a17b156/ 2020-04-19T06:24:00.000Z 2025-11-20T10:18:00.000Z

你好，世界！

全新的主题，熟悉的代码，怎能不再次心动？

这是 MHuiG 的又一个博客！

原博客数据不再迁移此处，将其作为该博客的子站
我的 NoteBook: https://mhuig.github.io/NoteBook/

后注: 原博客数据已迁移此处 【NoteBook 已闭源】

]]> <p>你好，世界！</p> 理解卷积 https://blog.mhuig.top/p/xa6297acc/ 2020-03-09T12:05:00.000Z 2025-11-20T10:18:00.000Z

本文的目的是深入的理解卷积, 通过一些示例, 卷积将会成为一个非常简单的想法.

抛球的经验

想象一下，我们将一个球从某个高度掉落到地面上，球在该地面只能在一个方向上运动, 如果您将球放下然后从其着陆点上方再次放下, 球可能会前进的距离是多少?

让我们分解一下。在第一次下落之后，它将以概率降落距起点个单位，其中是概率分布。

现在，在第一次下落之后，我们将球捡起并从其首次着陆点上方的另一个高度下落。球从新起点滚动单位的概率为,其中如果从不同高度掉落，则可能是不同的概率分布。

在第一次下落之后，我们将球捡起并从其首次着陆点上方的另一个高度下落。

如果我们确定了第一个的结果，我们就知道了球的移动距离，对于球的总距离为，第二个球的移动距离也固定为，其中 。因此发生这种情况的可能性就是 。

让我们考虑一个具体的离散示例。 我们希望总距离为。如果它第一次滚动 ，则第二次它必须滚动 ,才能达到我们的总距离 。 这个概率是 。

一个具体的离散示例

但是，这不是我们达到的总距离的唯一方法。球第一次可以滚动个单位，第二次可以滚动个单位。 或第一次为，第二次为。 只要将和加和等于，它就可以取任意值。

达到3的总距离的方法

这个概率分别是 和 。

为了找出球到达总距离的总可能性，我们不能仅考虑一种到达的可能方式。 相反，我们考虑将划分为两个球和的所有可能方法，并对每种方法的概率求和。

我们已经知道，对于每种情况， 的概率就是 。 因此，对 的每个解求和，我们可以将总似然表示为：

事实证明，我们正在做卷积! 特别地，定义在处的和的卷积定义为：

如果我们用 代替，我们得到：

这是卷积的标准定义。

为了更具体一点，我们可以考虑球可能着陆的位置。 在第一次下降之后，它将以概率降落在中间位置。 如果它降落在处，则它有概率 降落在位置处。

考虑球可能着陆的位置

为了得到卷积，我们考虑所有中间位置。

考虑所有中间位置

可视化卷积

有一个很好的技巧，可以帮助人们更轻松地思考卷积。

首先，观察。 假设一个球从其起点降落一定距离的概率为。 然后，此后，它从着陆点开始的距离为的概率为 。

观察

如果我们知道球在第二次下降后落在位置上，那么前一个位置是的概率是多少？

概率是多少？

因此，先前位置为的概率为 。

现在，考虑每个中间位置有助于球最终降落在的概率。 我们知道第一滴将球放到中间位置的概率是。 我们还知道，如果它降落在上，它进入的概率为 。

考虑每个中间位置

对所有求和，我们得到了卷积。

这种方法的优点是，它使我们可以在单个图片中可视化卷积在值处的评估。 通过移动下半部分，我们可以评估其他值的卷积。 这使我们能够从整体上理解卷积。

例如，我们可以看到分布对齐时达到峰值。

分布对齐时达到峰值

且随着分布之间的交点变小而缩小。

随着分布之间的交点变小而缩小

过在动画中使用此技巧，实际上可以从视觉上理解卷积。

下面，我们可以看到两个框函数的卷积：

两个框函数的卷积

有了这种观点，很多事情就会变得更加直观。

让我们考虑一个非概率示例。 卷积有时在音频处理中使用。 例如，一个函数可能会使用其中有两个尖峰但在其他所有地方为零的函数来创建回波。 当我们的双尖峰功能滑动时，一个尖峰首先击中一个时间点，将该信号添加到输出声音中，然后又出现另一个尖峰，并添加第二个延迟副本。

高维卷积

卷积是一个非常笼统的想法。我们还可以将它们用于更大的尺寸。

让我们再次考虑一个落球的例子。现在，随着位置的下降，它的位置不仅在一维，而在二维。

二维落球的例子

卷积与以前相同：

但是，现在，和是向量。更明确地说，

或在标准定义中：

就像一维卷积一样，我们可以将二维卷积视为将一个函数滑动到另一个函数之上，相乘和相加。

一种常见的应用是图像处理。我们可以将图像视为二维函数。许多重要的图像转换都是卷积，您可以在其中将图像函数与一个非常小的局部函数（称为 “卷积核”）进行卷积。

卷积核

卷积核滑动到图像的每个位置，并计算一个新像素作为其浮动像素的加权和。

例如，通过平均 3x3 像素矩阵，我们可以使图像模糊。 为此，我们的内核在框中的每个像素上取值，

使图像模糊

我们还可以通过在两个相邻像素上取值和，在其他所有位置取零来检测边缘。 也就是说，我们减去两个相邻像素。 当并排像素相似时，这大约等于零。 然而，在边缘上，相邻像素在垂直于边缘的方向上有很大不同。

检测边缘

卷积神经网络

那么，卷积与卷积神经网络有何关系？

考虑一个具有输入和输出的一维卷积层，就像这样：

一维卷积层

正如我们观察到的，我们可以用输入来描述输出：

通常，A 将是多个神经元。 但是假设它只是一个神经元。

回想一下，神经网络中的典型神经元描述为：

其中，是输入。 权重，描述了神经元如何连接到其输入。 负权重表示输入抑制神经元的激活，而正权重则鼓励神经元激活。 权重是神经元的心脏，控制神经元的行为。说多个神经元是相同的，这与说权重相同是一回事。

卷积将为我们处理的是神经元的这种连线，描述了所有权重以及哪些权重相同。

通常，我们一次而不是单独描述一个层中的所有神经元。 诀窍是要有一个权重矩阵：

例如，我们得到：

矩阵的每一行都描述了将神经元连接到其输入的权重。

但是，返回到卷积层，因为同一神经元有多个副本，所以许多权重出现在多个位置。

许多权重出现在多个位置

对应于等式：

因此，通常，权重矩阵会将每个输入连接到具有不同权重的每个神经元：

像上面的卷积层的矩阵看起来很不一样。 相同的权重出现在多个位置中。 而且由于神经元没有连接到许多可能的输入，因此存在很多零。

与上述矩阵相乘与与，，卷积相同。 滑动到不同位置的功能对应于在那些位置具有神经元。

二维卷积层呢？

二维卷积层

二维卷积层的布线对应于二维卷积。

考虑上面的示例，通过使用卷积来检测图像边缘，方法是在周围滑动一个内核并将其应用于每个面片。 就像这样，卷积层会将神经元应用于图像的每个 patch。

结论

我们在此博客文章中介绍了许多数学机制，但是获得的结果可能并不明显。 卷积显然是概率论和计算机图形学中的有用工具，但是从卷积的角度说卷积神经网络有什么好处呢？

第一个优点是我们拥有一些非常强大的语言来描述网络的布线。 到目前为止，我们所处理的示例还不够复杂，以至于无法清楚地看到这种好处，但是通过卷积可以使我们摆脱大量令人不快的簿记工作。

其次，卷积具有明显的实施优势。 许多库提供高效的卷积例程。 此外，尽管卷积天真地看起来是运算，但使用一些相当深的数学见解，就有可能创建实现。 我们将在以后的文章中对此进行更详细的讨论。

实际上，在 GPU 上使用高效并行卷积实现对于计算机视觉的最新进展至关重要。

参考文献

[English] Understanding Convolutions

]]> 本文通过抛球概率模型直观解释卷积概念：两次下落总距离的概率等于所有分段距离组合的概率之和，即离散卷积公式(f∗g)(c)=∑f(a)g(c−a)。进一步扩展到二维卷积，举例图像处理中模糊、边缘检测等应用，并揭示卷积神经网络通过共享权重实现高效特征提取的原理，其核心是滑动窗口的加权求和运算。 JavaScript 反调试 https://blog.mhuig.top/p/bfe2ff2a/ 2020-02-26T02:36:00.000Z 2025-11-20T10:18:00.000Z

总结一下关于 JavaScript 反调试技巧方面的内容。本文的目的是收集与 JavaScript 中的反调试有关的小窍门（其中一些已经被恶意软件或商业产品使用）。


对于 JavaScript 来说，你只需要花一点时间进行调试和分析，你就能够了解到 JavaScript 代码段的功能逻辑。而我们所要讨论的内容，可以给那些想要分析你 JavaScript 代码的人增加一定的难度。不过我们的技术跟代码混淆无关，我们主要针对的是如何给代码主动调试增加困难。


本文所要介绍的技术方法大致如下：

    1. 检测未知的执行环境（我们的代码只想在浏览器中被执行）；
    1. 检测调试工具（例如 DevTools）；
    1. 代码完整性控制；
    1. 流完整性控制；
    1. 反模拟；

简而言之，如果我们检测到了 “不正常” 的情况，程序的运行流程将会改变，并跳转到伪造的代码块，并 “隐藏” 真正的功能代码。

函数重定义

这是一种最基本也是最常用的代码反调试技术了。在 JavaScript 中，我们可以对用于收集信息的函数进行重定义。比如说，console.log() 函数可以用来收集函数和变量等信息，并将其显示在控制台中。如果我们重新定义了这个函数，我们就可以修改它的行为，并隐藏特定信息或显示伪造的信息。
我们可以直接在 DevTools 中运行这个函数来了解其功能：

console.log("HelloWorld");
var fake = function() {};
window['console']['log']= fake;
console.log("Youcan't see me!");

运行后我们将会看到：

VM127:1 HelloWorld

你会发现第二条信息并没有显示，因为我们重新定义了这个函数，即 “禁用” 了它原本的功能。但是我们也可以让它显示伪造的信息。比如说这样：

console.log("Normalfunction");
//First we save a reference to the original console.log function
var original = window['console']['log'];
//Next we create our fake function
//Basicly we check the argument and if match we call original function with otherparam.
// If there is no match pass the argument to the original function
var fake = function(argument) {
  if (argument === "Ka0labs") {
    original("Spoofed!");
  } else {
    original(argument);
  }
}
// We redefine now console.log as our fake function
window['console']['log']= fake;
//Then we call console.log with any argument
console.log("Thisis unaltered");
//Now we should see other text in console different to "Ka0labs"
console.log("Ka0labs");
//Aaaand everything still OK
console.log("Byebye!");

如果一切正常的话：

VM84:1 Normalfunction
VM84:11 Thisis unaltered
VM84:9 Spoofed!
VM84:11 Byebye!

实际上，为了控制代码的执行方式，我们还能够以更加聪明的方式来修改函数的功能。比如说，我们可以基于上述代码来构建一个代码段，并重定义 eval 函数。我们可以把 JavaScript 代码传递给 eval 函数，接下来代码将会被计算并执行。如果我们重定义了这个函数，我们就可以运行不同的代码了：

//Just a normal eval
eval("console.log('1337')");
//Now we repat the process...
var original = eval;
var fake = function(argument) {
  // If the code to be evaluated contains1337...
  if (argument.indexOf("1337") !==-1) {
    // ... we just execute a different code
    original("for (i = 0; i < 10;i++) { console.log(i);}");
  }
  else {
    original(argument);
  }
}
eval= fake;
eval("console.log('Weshould see this...')");
//Now we should see the execution of a for loop instead of what is expected
eval("console.log('Too1337 for you!')");

运行结果如下：

VM171:1 1337
VM172:1 Weshould see this...
VM173:1 0
VM173:1 1
VM173:1 2
VM173:1 3
VM173:1 4
VM173:1 5
VM173:1 6
VM173:1 7
VM173:1 8
VM173:1 9

  通过这种方式修改程序流是一个很酷的技巧，但是正如我们在一开始所说的那样，它是最基本的技巧，很容易被发现并被击败。这是因为在 JavaScript 中，每个函数都有一个方法 toString（或 Firefox 中的 toSource）返回其自己的代码。因此，仅需要检查所需函数的代码是否已更改。当然，我们可以重新定义方法 toString / toSource，但是我们陷入了同样的情况：function.toString.toString() 。

断点

为了帮助我们了解代码的功能，JavaScript 调试工具（例如 DevTools）都可以通过设置断点的方式阻止脚本代码执行，而断点也是代码调试中最基本的了。
如果你研究过调试器或者 x86 架构，你可能会比较熟悉 0xCC 指令。在 JavaScript 中，我们有一个名叫 debugger 的类似指令。当我们在代码中声明了 debugger 函数后，脚本代码将会在 debugger 指令这里停止运行。比如说：

console.log("Seeme!");
debugger;
console.log("Seeme!");

很多商业产品会在代码中定义一个无限循环的 debugger 指令，不过某些浏览器会屏蔽这种代码，而有些则不会。这种方法的主要目的就是让那些想要调试你代码的人感到厌烦，因为无限循环意味着代码会不断地弹出窗口来询问你是否要继续运行脚本代码：

setTimeout(function(){while (true) {eval("debugger")}})
setInterval(function() {var a = new Date(); debugger; return new Date() - a > 100;}, 100);

时间差异

这是一种从传统反逆向技术那里借鉴过来的基于时间的反调试技巧。当脚本在 DevTools 等工具环境下执行时，运行速度会非常慢（时间久），所以我们就可以根据运行时间来判断脚本当前是否正在被调试。比如说，我们可以通过测量代码中两个设置点之间的运行时间，然后用这个值作为参考，如果运行时间超过这个值，说明脚本当前在调试器中运行。
演示代码如下：

setInterval(function(){
 var startTime = performance.now(), check,diff;
 for (check = 0; check < 1000; check++){
  console.log(check);
  console.clear();
 }
 diff = performance.now() - startTime;
 if (diff > 200){
  alert("Debugger detected!");
 }
},500);

DevTools 检测（I）[Chrome]：getter

这项技术利用的是 div 元素中的 id 属性，当 div 元素被发送至控制台（例如 console.log(div) ）时，浏览器会自动尝试获取其中的元素 id。如果代码在调用了 console.log 之后又调用了 getter 方法，说明控制台当前正在运行。
简单的概念验证代码如下：

let div = document.createElement('div');
let loop = setInterval(() => {
  console.log(div);
  console.clear();
});
Object.defineProperty(div,"id", {get: () => {
  clearInterval(loop);
  alert("Dev Tools detected!");
}});

DevTools 检测（II）[Chrome]：大小更改

如果打开了 DevTools（除非将其取消对接打开），则 window.outerWidth / Height 和 window.innerWidth / Height 之间的差异将发生变化，因此可以循环检测。Devtools-detect 使用此技巧：

const widthThreshold = window.outerWidth - window.innerWidth > threshold;
const heightThreshold = window.outerHeight - window.innerHeight > threshold;
const orientation = widthThreshold ? 'vertical' : 'horizontal';

隐式流完整性控制

当我们尝试对 JavaScript 代码段进行模糊处理时，第一步就是开始重命名一些变量和函数，以阐明源代码。您只需将代码拆分为较小的代码块，然后开始在此处和此处重命名。在 JavaScript 中，我们可以检查函数名称是否已更改或保持相同的名称。或更准确地说，我们可以检查堆栈跟踪是否包含原始名称和原始顺序。
使用 arguments.callee.caller，我们可以创建堆栈跟踪，以保存先前执行的函数。我们可以使用此信息来生成一个哈希，该哈希将成为用于生成用于解密 JavaScript 其他部分的密钥的种子。这样，我们就可以对流的完整性进行隐式控制，因为如果重命名功能或要执行的功能顺序稍有不同，则创建的哈希将完全不同。如果哈希不同，则生成的密钥也将不同。如果密钥不同，则无法解密代码。为了更好地理解它，请参见下一个示例：

function getCallStack() {
  var stack = "#", total = 0, fn =arguments.callee;
  while ( (fn = fn.caller) ) {
    stack = stack + "" +fn.name;
    total++
  }
  return stack
}
function test1() {
  console.log(getCallStack());
}
function test2() {
  test1();
}
function test3() {
  test2();
}
function test4() {
  test3();
}
test4();

执行此代码时，您将看到字符串 #test1test2test3test4 。如果我们修改（我邀请您这样做）任何函数的名称，返回的字符串也将不同。我们可以使用该字符串计算安全哈希，然后将其用作种子，以得出用于解密其他代码块的密钥。有趣的是，如果由于密钥无效（分析人员更改了函数名称）而无法解密下一个代码块，则可以捕获异常并将执行流重定向到伪路径。

VM50:10 #test1test2test3test4

请记住，此技巧需要与强大的混淆功能结合在一起才能使用。

隐式代码完整性控制

  在 “ 函数重新定义” 部分的结尾，我们提到可以使用 toString（）方法检索 JavaScript 中函数的代码。就像我们说过的那样，这对于检查函数是否已重新定义很有用，实际上，可以使用相同的想法来知道函数的代码是否被修改。

效果较差的方法是计算函数或代码块的哈希并将其与已知表进行比较。但是这种方法确实很愚蠢。一种更现实，更有效的方法可以重复使用我们之前在堆栈跟踪中使用的相同策略。我们可以计算代码块的哈希值，并将其用作解密其他代码块的密钥。

创建隐式完整性控件的最漂亮方法是在 md5 中使用冲突。基本上，我们可以创建在自己的函数中测试其自己的 md5 的函数。为了在功能内执行检查，我们需要进行碰撞处理（我们想创建类似的东西 function(){ if (md5(arguments.callee.toString() === '<md5>') code_function; } )。

该技术背后的概念与用于生成图像文件的概念相同，在自己的图片中显示了 md5 校验和。这是一个经典示例：显示自己的 md5 校验和的 gif。

显示自己的md5校验和的gif

(注: 本站的图片处理策略可能更改了图片 md5 值, 点击查看原图 => 显示自己的 md5 校验和的 gif)

关于如何产生这种冲突，有大量的文章（甚至在 PoC || GTFO 中出现了一些示例），但是我阅读并可以复制的第一个文章是使用 PHP 编写的。您可以非常快速地预先计算生成碰撞所需的块。实际上，这是@cgvwzq 创建的示例，通过这种方式检查了函数内容的完整性。

如前所述，我们需要对这种技术进行强力混淆。

代理对象 (old, 已弃用)

代理对象是目前 JavaScript 中最有用的一个工具，这种对象可以帮助我们了解代码中的其他对象，包括修改其行为以及触发特定环境下的对象活动。比如说，我们可以创建一个嗲哩对象并跟踪每一次document.createElement调用，然后记录下相关信息：

const handler = { // Our hook to keep the track
  apply: function (target, thisArg, args){
    console.log("Intercepted a call tocreateElement with args: " + args);
    return target.apply(thisArg, args)
  }
}
  
document.createElement= new Proxy(document.createElement, handler) // Create our proxy object withour hook ready to intercept
document.createElement('div');

接下来，我们可以在控制台中记录下相关参数和信息：

VM216:3 Intercepted a call tocreateElement with args: div

我们可以利用这些信息并通过拦截某些特定函数来调试代码，但是本文的主要目的是为了介绍反调试技术，那么我们如何检测 “对方” 是否使用了代理对象呢？其实这就是一场 “猫抓老鼠” 的游戏，比如说，我们可以使用相同的代码段，然后尝试调用 toString 方法并捕获异常：

//Call a "virgin" createElement:
try {
  document.createElement.toString();
}catch(e){
  console.log("I saw your proxy!");
}

信息如下：

"function createElement() { [native code] }"

但是当我们使用了代理之后：

//Then apply the hook
const handler = {
  apply: function (target, thisArg, args){
    console.log("Intercepted a call tocreateElement with args: " + args);
    return target.apply(thisArg, args)
  }
}
document.createElement= new Proxy(document.createElement, handler);
  
//Callour not-so-virgin-after-that-party createElement
try {
  document.createElement.toString();
}catch(e) {
  console.log("I saw your proxy!");
}

没错，我们确实可以检测到代理：

VM391:13 I saw your proxy!

我们还可以添加 toString 方法：

const handler = {
  apply: function (target, thisArg, args){
    console.log("Intercepted a call tocreateElement with args: " + args);
    return target.apply(thisArg, args)
  }
}
document.createElement= new Proxy(document.createElement, handler);
document.createElement= Function.prototype.toString.bind(document.createElement); //Add toString
//Callour not-so-virgin-after-that-party createElement
try {
  document.createElement.toString();
}catch(e) {
  console.log("I saw your proxy!");
}

现在我们就没办法检测到了：

"function createElement() { [native code] }"

代理对象

异常把戏不能再使用了。幸运的是，我们仍然可以通过 toString 长度检测代理对象的使用。例如，document.createElement的大小为 42（Chrome）：

document.createElement.toString().length
42

另一方面，当我们创建代理时，此值将更改：

const handler = {
    apply: function(target, thisArg, args) {
        console.log("Intercepted call");
        return target.apply(thisArg, args);
    }
}

document.createElement = new Proxy(document.createElement, handler);

document.createElement.toString().length
29

因此，我们可以执行以下操作：

if (document.createElement.toString().length < 30) {
    console.log("I saw your proxy");
}
else {
    console.log("Not a proxy");
}

此技巧不能在 windoww 对象中使用，但仍然有用。

限制环境

如引言中所述，我们想要做的一件事就是尝试检测代码是否在正确的环境中执行。
我们所谓的 “正确的环境” 是：

  • 该代码正在浏览器（不是仿真器，不是 NodeJS 等）中执行。
  • 该代码正在指定给它的域 / 资源中执行（不是本地服务器）

例如，我们可以用来证明代码是否在本地执行的简单检查是：

// Pretty stupid idea found in commercial software
if (location.hostname === "localhost" || location.hostname === "127.0.0.1" || location.hostname === "") {
    console.log("Don't run me here!")
}

如果我们在本地 html 中运行此 JavaScript 代码段，则会看到以下消息：

VM28:3 Don't run me here!

按照这个想法，另一个检查选项是用于打开文档的处理程序（类似 if (location.protocol == 'file:'){...}），或者尝试通过 HTTP 请求进行测试，以确定是否有其他资源（图像，css 等）可用。当然，所有这些方法都非常容易被绕过。
 如果代码是在 NodeJS 中执行的（或者正如我们在本文中提到的：将流更改为伪造的路径），则可以避免执行代码。这很危险，但是我在野外看到使用 NodeJS 来解决 JavaScript 挑战并绕过反暴力缓解措施。
我们可以尝试检测仅存在于浏览器上下文中的对象的存在：

//Under NodeJS
   try { 
   console.log(window); 
   } catch(e){ 
      console.log("NodeJS detected!!!!"); 
   }
 
NodeJS detected!!!!

反之亦然：在 NodeJS 中，我们具有浏览器上下文中不存在的对象。

//Under the browser
console.log(global)
VM104:1 Uncaught ReferenceError: global is not defined
    at <anonymous>:1:13

//Under NodeJS
  console.log(global)
{ console: 
   Console {
     log: [Function: bound log],...
     ...

我们可以搜索仅存在于浏览器中的大量元数据。我们可以检索到的一些此类想法可以在 Panopticlick Project 中看到。

相关文献

javascript-antidebugging

]]> 本文总结JavaScript反调试技巧，包括函数重定义（如劫持console.log）、调试器检测（debugger指令/时间差异分析）、环境验证及代码/流完整性控制，通过检测异常执行环境跳转伪造代码，增加主动调试难度而非依赖代码混淆。 Python 如何调用 C https://blog.mhuig.top/p/b6ffaac2/ 2020-02-24T07:45:00.000Z 2025-11-20T10:18:00.000Z

Python 语言特点：简单，明确，优雅，高效率，同时 Python 语言的可扩展性和可嵌入性很强，又被成为 “胶水语言”。但是 Python 语言有一个最大的缺点，便是运行速度慢，所以当你对速度有要求时，你可以用 C 语言来编写你的关键代码，或者当你希望某些算法不公开时，也可以把你的程序用 C 编写，然后在你的 Python 程序中使用它们。本文将介绍在 Python 程序中如何调用 C…

编写 C 语言代码

一个简单的 c 语言程序，实现了两个整数的加法运算

#include <stdio.h>

int sum(int a,int b){
    return a + b;
}

生成 so 库文件

使用命令：

gcc -fPIC -shared main.c -o lib.so

so 库文件不能跨平台使用，如果你在 Windows 下面生成的，便只能够在 Windows 下面使用，使用命令以后，生成后缀为.so 的库文件

编写 Python 程序来调用 C 语言

  • 把 so 库文件放入我们的 Python 项目中
  • 使用 ctypes 库中的 CDLL 来加载库 lib_main = CDLL (‘so 库文件路径’)
  • 调用 C sum_value = lib_main.sum(10, 20)
# ctypes的库
from ctypes import *

# 加载so库
lib_main = CDLL('./lib.so')  # CDLL加载库

sum_value = lib_main.sum(10, 20)

print(sum_value)

最终得到结果 30

ctypes 库是 Python 提供的一个外部函数库，提供 C 语言兼容集中数据类型，可以允许调用 C 编译好的库，已下附上 ctypes 库官方文档：https://docs.python.org/3/library/ctypes.html

]]> Python因运行速度限制，可通过C编写关键代码提升性能或保护算法。本文介绍调用流程：编写C加法函数，用gcc生成.so库，再通过Python的ctypes库加载并调用C函数实现跨语言计算。附ctypes官方文档链接。 Npm 更换源 https://blog.mhuig.top/p/ba036091/ 2020-02-23T11:02:00.000Z 2025-11-20T10:18:00.000Z

由于 npm 的源在国外，所以国内用户使用起来有很多不方便，比如拖慢下载速度。

如何使用

有很多方法来配置 npm registry 地址，下面根据不同情境列出几种比较常用的方法。以淘宝 npm 为例

更换为淘宝 npm 源

npm config set registry http://registry.npmmirror.com

使用 npm 官方镜像

npm config set registry https://registry.npmjs.org/

NPM 检查并更新项目依赖的版本

#### 安装
npm install -g npm-check-updates
#### 检查当前目录下可更新的依赖项
ncu
#### 升级 package.json
ncu -u
#### 根据更新的 package.json 安装新版本
npm install

已知的 npm 镜像源

目前国内除了淘宝（npmmirror），已知的 npm 镜像源还有：

已知的 Nodejs 预编译包：

淘宝 NPM 镜像站喊你切换新域名啦

【公告】淘宝 npm 域名即将切换 && npmmirror 重构升级

https://zhuanlan.zhihu.com/p/465424728

【望周知】淘宝 NPM 镜像站喊你切换新域名啦

https://zhuanlan.zhihu.com/p/430580607

要点总结如下：

    1. 淘宝 NPM 镜像站品牌升级，新品牌为 npmmirror （NPM 中国镜像站）。
    1. 广为人知的淘宝 NPM 镜像老域名（*.npm.taobao.org）将在 2022.06.30 号正式下线和停止 DNS 解析。
    1. 涉及到的域名迁移如下：
http://npm.taobao.org => http://npmmirror.com
http://registry.npm.taobao.org => http://registry.npmmirror.com
    1. 可能产生的大影响：
      简而言之，所有写死的都得换。
      企业用户需要联系 网管/IT/SRE 更新防火墙白名单。
      存量应用的 lock 文件，开发者需要自行执行 sed 等指令去替换或重新生成。
      本地 npmrc 里面的 registry 地址（如果有，则）需要开发者自行更新。
本文已经过时的内容备份

2022.02.12 移除内容

## 如何使用

有很多方法来配置npm registry地址，下面根据不同情境列出几种比较常用的方法。以淘宝npm为例

### 临时使用

``bash
npm --registry https://registry.npm.taobao.org install express
``

### 持久使用

``bash
npm config set registry https://registry.npm.taobao.org
``

配置后可通过下面方式来验证是否成功：

``bash
npm config get registry
``

或者

``bash
npm info express
``

### 更换为淘宝npm源

``bash
npm install -g cnpm --registry=https://registry.npm.taobao.org
``

通过cnpm更新模块

``bash
cnpm install expresstall express
``

### 使用官方镜像


``bash
npm config set registry https://registry.npmjs.org/
``

## 总结


更换为淘宝npm源

``bash
npm config set registry https://registry.npm.taobao.org
``

使用官方镜像

``bash
npm config set registry https://registry.npmjs.org/
``

NPM检查并更新项目依赖的版本

``bash
#### 安装
npm install -g npm-check-updates
#### 检查当前目录下可更新的依赖项
ncu
#### 升级 package.json
ncu -u
#### 根据更新的 package.json 安装新版本
npm install
``

]]> 本文介绍国内用户提升npm下载速度的方法，包括切换至淘宝、官方及华为云等镜像源，使用npm-check-updates更新项目依赖，并提醒淘宝npm镜像站品牌升级后的域名切换及配置更新事项。 LBS 球面距离公式 https://blog.mhuig.top/p/5e7ad437/ 2020-02-23T01:40:00.000Z 2025-11-20T10:18:00.000Z

维基百科推荐使用 Haversine 公式，理由是 Great-circle distance 公式用到了大量余弦函数， 而两点间距离很短时（比如地球表面上相距几百米的两点），余弦函数会得出 的结果， 会导致较大的舍入误差。而 Haversine 公式采用了正弦函数，即使距离很小，也能保持足够的有效数字。 以前采用三角函数表计算时的确会有这个问题，但经过实际验证，采用计算机来计算时，两个公式的区别不大。 稳妥起见，这里还是采用 Haversine 公式。

Haversine 公式

其中

为地球半径，可取平均值 6371.137km

, 表示两点的纬度；

表示两点经度的差值。

距离计算函数

下面就是计算球面间两点 (lat0, lng)-(lat1, lng1) 之间距离的函数。

from math import sin, asin, cos, radians, fabs, sqrt
 
EARTH_RADIUS=6371           # 地球平均半径，6371km
 
def hav(theta):
    s = sin(theta / 2)
    return s * s
 
def get_distance_hav(lat0, lng0, lat1, lng1):
    "用haversine公式计算球面两点间的距离。"
    # 经纬度转换成弧度
    lat0 = radians(lat0)
    lat1 = radians(lat1)
    lng0 = radians(lng0)
    lng1 = radians(lng1)
 
    dlng = fabs(lng0 - lng1)
    dlat = fabs(lat0 - lat1)
    h = hav(dlat) + cos(lat0) * cos(lat1) * hav(dlng)
    distance = 2 * EARTH_RADIUS * asin(sqrt(h))
 
    return distance

相关文献

LBS 球面距离公式

]]> 详解LBS应用中的球面距离计算方案，推荐采用Haversine公式解决短距离计算时的舍入误差问题，提供Python实现代码：通过经纬度弧度转换、半正矢函数(hav)及地球半径(6371km)计算两点距离，附完整函数实现。 https://blog.mhuig.top/p/notes-nosql/ 2020-02-08T23:56:00.000Z 2025-11-20T10:18:00.000Z



开始阅读

NoSQL

]]> NoSQL（Not Only SQL）指非关系型数据库，是对传统关系型数据库的补充，支持海量数据存储与灵活扩展，无需固定模式。分为键值（如Redis）、文档（如MongoDB）、列族（如HBase）和图数据库（如Neo4j）四大类，分别适用于缓存、内容管理、大数据分析和社交网络等场景。基于CAP理论和BASE模型，在一致性、可用性和分区容错间权衡，满足高并发与分布式需求。 如何加密你的 Python 代码 https://blog.mhuig.top/p/b190dcb/ 2020-02-05T05:08:00.000Z 2025-11-20T10:18:00.000Z

讲述了如何通过修改 Python 解释器达到加解密 Python 代码的目的。

前言

本文将首先介绍下现有源码加密方案的思路、方法、优点与不足，进而介绍如何通过定制 Python 解释器来达到更好地加解密源码的目的。

现有加密方案

由于 Python 的动态特性和开源特点，导致 Python 代码很难做到很好的加密。社区中的一些声音认为这样的限制是事实，应该通过法律手段而不是加密源码达到商业保护的目的；而还有一些声音则是不论如何都希望能有一种手段来加密。于是乎，人们想出了各种或加密、或混淆的方案，借此来达到保护源码的目的。

常见的源码保护手段有如下几种：

  • 发行 .pyc 文件
  • 代码混淆
  • 使用 py2exe
  • 使用 Cython

下面来简单说说这些方案。

发行 .pyc 文件

思路

大家都知道，Python 解释器在执行代码的过程中会首先生成 .pyc 文件，然后解释执行 .pyc 文件中的内容。当然了，Python 解释器也能够直接执行 .pyc 文件。而 .pyc 文件是二进制文件，无法直接看出源码内容。如果发行代码到客户环境时都是 .pyc 而非 .py 文件的话，那岂不是能达到保护 Python 代码的目的？

方法

把 .py 文件编译为 .pyc 文件，是件非常轻松地事情，可不需要把所有代码跑一遍，然后去捞生成的 .pyc 文件。

事实上，Python 标准库中提供了一个名为 compileall 的库，可以轻松地进行编译。

执行如下命令能够将遍历 目录下的所有 .py 文件，将之编译为 .pyc 文件：

python -m compileall <src>

然后删除 目录下所有 .py 文件就可以打包发布了：

find <src> -name '*.py' -type f -print -exec rm {} \;

优点

  • 简单方便，提高了一点源码破解门槛
  • 平台兼容性好，.py 能在哪里运行，.pyc 就能在哪里运行

不足

  • 解释器兼容性差，.pyc 只能在特定版本的解释器上运行
  • 有现成的反编译工具，破解成本低

python-uncompyle6 就是这样一款反编译工具，效果出众。

执行如下命令，即可将 .pyc 文件反编译为 .py 文件：

uncompyle6 *compiled-python-file-pyc-or-pyo*

代码混淆

如果代码被混淆到一定程度，连作者看着都费劲的话，是不是也能达到保护源码的目的呢？

思路

既然我们的目的是混淆，就是通过一系列的转换，让代码逐渐不那么让人容易明白，那就可以这样下手：

  • 移除注释和文档。没有这些说明，在一些关键逻辑上就没那么容易明白了。
  • 改变缩进。完美的缩进看着才舒服，如果缩进忽长忽短，看着也一定闹心。
  • 在 tokens 中间加入一定空格。这就和改变缩进的效果差不多。
  • 重命名函数、类、变量。命名直接影响了可读性，乱七八糟的名字可是阅读理解的一大障碍。
  • 在空白行插入无效代码。这就是障眼法，用无关代码来打乱阅读节奏。

方法

方法一：使用 oxyry 进行混淆

http://pyob.oxyry.com/ 是一个在线混淆 Python 代码的网站，使用它可以方便地进行混淆。

假定我们有这样一段 Python 代码，涉及到了类、函数、参数等内容：

# coding: utf-8

class A(object):
    """
    Description
    """

    def __init__(self, x, y, default=None):
        self.z = x + y
        self.default = default
    
    def name(self):
        return 'No Name'


def always():
    return True


num = 1
a = A(num, 999, 100)
a.name()
always()

经过 Oxyry 的混淆，得到如下代码：

class A (object ):#line:4
    ""#line:7
    def __init__ (O0O0O0OO00OO000O0 ,OO0O0OOOO0000O0OO ,OO0OO00O00OO00OOO ,OO000OOO0O000OOO0 =None ):#line:9
        O0O0O0OO00OO000O0 .z =OO0O0OOOO0000O0OO +OO0OO00O00OO00OOO #line:10
        O0O0O0OO00OO000O0 .default =OO000OOO0O000OOO0 #line:11
    def name (O000O0O0O00O0O0OO ):#line:13
        return 'No Name'#line:14
def always ():#line:17
    return True #line:18
num =1 #line:21
a =A (num ,999 ,100 )#line:22
a .name ()#line:23
always ()

混淆后的代码主要在注释、参数名称和空格上做了些调整，稍微带来了点阅读上的障碍。

方法二：使用 pyobfuscate 库进行混淆

pyobfuscate 算是一个颇具年头的 Python 代码混淆库了，但却是 “老当益壮” 了。

对上述同样一段 Python 代码，经 pyobfuscate 混淆后效果如下：

# coding: utf-8
if 64 - 64: i11iIiiIii
if 65 - 65: O0 / iIii1I11I1II1 % OoooooooOO - i1IIi
class o0OO00 ( object ) :
 if 78 - 78: i11i . oOooOoO0Oo0O
 if 10 - 10: IIiI1I11i11
 if 54 - 54: i11iIi1 - oOo0O0Ooo
 if 2 - 2: o0 * i1 * ii1IiI1i % OOooOOo / I11i / Ii1I
 def __init__ ( self , x , y , default = None ) :
  self . z = x + y
  self . default = default
  if 48 - 48: iII111i % IiII + I1Ii111 / ooOoO0o * Ii1I
 def name ( self ) :
  return 'No Name'
  if 46 - 46: ooOoO0o * I11i - OoooooooOO
  if 30 - 30: o0 - O0 % o0 - OoooooooOO * O0 * OoooooooOO
def Oo0o ( ) :
 return True
 if 60 - 60: i1 + I1Ii111 - I11i / i1IIi
 if 40 - 40: oOooOoO0Oo0O / O0 % ooOoO0o + O0 * i1IIi
I1Ii11I1Ii1i = 1
Ooo = o0OO00 ( I1Ii11I1Ii1i , 999 , 100 )
Ooo . name ( )
Oo0o ( ) # dd678faae9ac167bc83abf78e5cb2f3f0688d3a3

相比于方法一，方法二的效果看起来更好些。除了类和函数进行了重命名、加入了一些空格，最明显的是插入了若干段无关的代码，变得更加难读了。

优点

  • 简单方便，提高了一点源码破解门槛

  • 兼容性好，只要源码逻辑能做到兼容，混淆代码亦能

不足

  • 只能对单个文件混淆，无法做到多个互相有联系的源码文件的联动混淆
  • 代码结构未发生变化，也能获取字节码，破解难度不大

使用 py2exe

思路

py2exe 是一款将 Python 脚本转换为 Windows 平台上的可执行文件的工具。其原理是将源码编译为 .pyc 文件，加之必要的依赖文件，一起打包成一个可执行文件。

如果最终发行由 py2exe 打包出的二进制文件，那岂不是达到了保护源码的目的？

方法

使用 py2exe 进行打包的步骤较为简便。

1. 编写入口文件。本示例中取名为 hello.py：

print 'Hello World'

2. 编写 setup.py：

from distutils.core import setup
import py2exe

setup(console=['hello.py'])

3. 生成可执行文件

python setup.py py2exe

生成的可执行文件位于 dist\hello.exe。

优点

  • 能够直接打包成 exe，方便分发和执行
  • 破解门槛比 .pyc 更高一些

不足

  • 兼容性差，只能运行在 Windows 系统上
  • 生成的可执行文件内的布局是明确、公开的，可以找到源码对应的 .pyc 文件，进而反编译出源码

使用 Cython

思路

虽说 Cython 的主要目的是带来性能的提升，但是基于它的原理：将 .py/.pyx 编译为 .c 文件，再将 .c 文件编译为 .so(Unix) 或 .pyd(Windows)，其带来的另一个好处就是难以破解。

方法

使用 Cython 进行开发的步骤也不复杂。

1. 编写文件 hello.pyx 或 hello.py：

def hello():
    print('hello')

2. 编写 setup.py：

from distutils.core import setup
from Cython.Build import cythonize

setup(name='Hello World app',
     ext_modules=cythonize('hello.pyx'))

3. 编译为 .c，再进一步编译为 .so 或 .pyd：

python setup.py build_ext --inplace

执行 python -c "from hello import hello;hello ()" 即可直接引用生成的二进制文件中的 hello () 函数。

优点

  • 生成的二进制 .so 或 .pyd 文件难以破解
  • 同时带来了性能提升

不足

  • 兼容性稍差，对于不同版本的操作系统，可能需要重新编译
  • 虽然支持大多数 Python 代码，但如果一旦发现部分代码不支持，完善成本较高

定制 Python 解释器

考虑前文所述的几个方案，均是从源码的加工入手，或多或少都有些不足。假设我们从解释器的改造入手，会不会能够更好的保护代码呢？

由于发行商业 Python 程序到客户环境时通常会包含一个 Python 解释器，如果改造解释器能解决源码保护的问题，那么也是可选的一条路。

假定我们有一个算法，能够加密原始的 Python 代码，这些加密后代码随发行程序一起，可被任何人看到，却难以破解。另一方面，有一个定制好的 Python 解释器，它能够解密这些被加密的代码，然后解释执行。而由于 Python 解释器本身是二进制文件，人们也就无法从解释器中获取解密的关键数据。从而达到了保护源码的目的。

要实现上述的设想，我们首先需要掌握基本的加解密算法，其次探究 Python 执行代码的方式从而了解在何处进行加解密，最后禁用字节码用以防止通过 .pyc 反编译。

加解密算法

对称密钥加密算法

对称密钥加密（Symmetric-key algorithm）又称为对称加密、私钥加密、共享密钥加密，是密码学中的一类加密算法。这类算法在加密和解密时使用相同的密钥，或是使用两个可以简单地相互推算的密钥。

对称加密算法的特点是算法公开、计算量小、加密速度快、加密效率高。

常见的对称加密算法有：DES、3DES、AES、Blowfish、IDEA、RC5、RC6 等。

对称密钥加解密过程如下：

对称密钥加解密过程

明文通过密钥加密成密文，密文也可通过相同的密钥解密为明文。

通过 openssl 工具，我们能够方便选择对称加密算法进行加解密。下面我们以 AES 算法为例，介绍其用法。

AES 加密

指定密码进行对称加密

openssl enc -aes-128-cbc -in test.py -out entest.py -pass pass:123456

指定文件进行对称加密

openssl enc -aes-128-cbc -in test.py -out entest.py -pass file:passwd.txt

指定环境变量进行对称加密

openssl enc -aes-128-cbc -in test.py -out entest.py -pass env:passwd

AES 解密

指定密码进行对称解密

openssl enc -aes-128-cbc -d -in entest.py -out test.py -pass pass:123456

指定文件进行对称解密

openssl enc -aes-128-cbc -d -in entest.py -out test.py -pass file:passwd.txt

指定环境变量进行对称解密

openssl enc -aes-128-cbc -d -in entest.py -out test.py -pass env:passwd

非对称密钥加密算法

密钥加密（英语：public-key cryptography，又译为公开密钥加密），也称为非对称加密（asymmetric cryptography），一种密码学算法类型，在这种密码学方法中，需要一对密钥，一个是私钥，另一个则是公钥。这两个密钥是数学相关，用某用户公钥加密后所得的信息，只能用该用户的私钥才能解密。

非对称加密算法的特点是算法强度复杂、安全性依赖于算法与密钥但是由于其算法复杂，而使得加密解密速度没有对称加密解密的速度快。

常见的对称加密算法有：RSA、Elgamal、背包算法、Rabin、D - H、ECC 等。

非对称密钥加解密过程如下：

非对称密钥加解密过程

明文通过公钥加密成密文，密文通过与公钥对应的私钥解密为明文。

通过 openssl 工具，我们能够方便选择非对称加密算法进行加解密。下面我们以 RSA 算法为例，介绍其用法。

生成私钥、公钥

辅以 AES-128 算法，生成 2048 比特长度的私钥

openssl genrsa -aes128 -out private.pem 2048

根据私钥来生成公钥

openssl rsa -in private.pem -outform PEM -pubout -out public.pem

RSA 加密

使用公钥进行加密

openssl rsautl -encrypt -in passwd.txt -inkey public.pem -pubin -out enpasswd.txt

RSA 解密

使用私钥进行解密

openssl rsautl -decrypt -in enpasswd.txt -inkey private.pem -out passwd.txt

基于加密算法实现源码保护

对称加密适合加密源码文件，而非对称加密适合加密密钥。如果将两者结合，就能达到加解密源码的目的。

在构建环境进行加密

我们发行出去安装包中，源码应该是被加密过的，那么就需要在构建阶段对源码进行加密。加密的过程如下：

在构建环境进行加密

  • 1. 随机生成一个密钥。这个密钥实际上是一个用于对称加密的密码。
  • 2. 使用该密钥对源代码进行对称加密，生成加密后的代码。
  • 3. 使用公钥（生成方法见 非对称密钥加密算法）对该密钥进行非对称加密，生成加密后的密钥。

不论是加密后的代码还是加密后的密钥，都会放在安装包中。它们能够被用户看到，却无法被破译。而 Python 解释器该如何执行加密后的代码呢？

Python 解释器进行解密

假定我们发行的 Python 解释器中内置了与公钥相对应的私钥，有了它就有了解密的可能。而由于 Python 解释器本身是二进制文件，所以不需要担心内置的私钥会被看到。解密的过程如下：

Python 解释器进行解密

  • 1.Python 解释器执行加密代码时需要被传入指示加密密钥的参数，通过这个参数，解释器获取到了加密密钥
  • 2.Python 解释器使用内置的私钥，对该加密密钥进行非对称解密，得到原始密钥
  • 3.Python 解释器使用原始密钥对加密代码进行对称解密，得到原始代码
  • 4.Python 解释器执行这段原始代码

可以看到，通过改造构建环节、定制 Python 解释器的执行过程，便可以实现保护源码的目的。改造构建环节是容易的，但是如何定制 Python 解释器呢？我们需要深入了解解释器执行脚本和模块的方式，才能在特定的入口进行控制。

脚本、模块的执行与解密

执行 Python 代码的几种方式

为了找到 Python 解释器执行 Python 代码时的所有入口，我们需要首先执行 Python 解释器都能以怎样的方式执行代码。

直接运行脚本
python test.py
直接运行语句
python -c "print 'hello'"
直接运行模块
python -m test
导入、重载模块
python
>>> import test  # 导入模块
>>> reload(test)  # 重载模块

直接运行语句 的方式接收的就是明文的代码，我们也无需对这种方式做额外处理。
直接运行模块和导入、重载模块这两种方式在流程上是殊途同归的，所以接下来会一起来看。
因此我们将分两种情况：运行脚本和加载模块来进一步探究各自的过程和解密方式。

运行脚本时解密

运行脚本的过程

Python 解释器在运行脚本时的代码调用逻辑如下：

       main            WinMain
[Modules/python.c] [PC/WinMain.c]
             \         /
              \       /
               \     /
                \   /
                 \ /
               Py_Main
           [Moduls/main.c]

Python 解释器运行脚本的入口函数因操作系统而异，在 Linux/Unix 系统上，主入口函数是 Modules/python.c 中的 main 函数，在 Windows 系统上，则是 PC/WinMain.c 中的 WinMain 函数。不过这两个函数最终都会调用 Moduls/main.c 中的 Py_Main 函数。

我们不妨来看看 Py_Main 函数中的相关逻辑：

[Modules/Main.c]
--------------------------------------

int
Py_Main(int argc, char **argv)
{
    if (command) {
        // 处理 python -c <command>
    } else if (module) {
        // 处理 python -m <module>
    }
    else {
        // 处理 python <file>
        ...
        fp = fopen(filename, "r");
        ...
    }

处理和的部分我们暂且先不管，在处理文件（通过直接运行脚本的方式）的逻辑中，可以看到解释打开了文件，获得了文件指针。那么如果我们把这里的 fopen 换成是自定义的 decrypt_open 函数，这个函数用来打开一个加密文件，然后进行解密，并返回一个文件指针，这个指针指向解密后的文件。那么，不就可以实现解密脚本的目的了吗？

自定义 decrypt_open

我们不妨新增一个 Modules / crypt.c 文件，用来存放一些自定义的加解密函数。

decrypt_open 函数大概实现如下：

[Modules/crypt.c]
--------------------------------------

/* 以解密方式打开文件 */
FILE *
decrypt_open(const char *filename, const char *mode)
{
    int plainlen = -1;
    char *plaintext = NULL;
    FILE *fp = NULL;

    if (aes_passwd == NULL)
        fp = fopen(filename, "r");
    else {
        plainlen = aes_decrypt(filename, aes_passwd, &plaintext);
        // 如果无法解密，返回源文件描述符
        if (plainlen < 0)
            fp = fopen(filename, "r");
        // 否则，转换为内存文件描述符
        else
            fp = fmemopen(plaintext, plainlen, "r");
    }
    return fp;
}

这里的 aes_passwd 是一个全局变量，代表对称加密算法中的密钥。我们暂时假定已经获取该密钥了，后文会说明如何获得。而 aes_decrypt 是自定义的一个使用 AES 算法进行对称解密的函数，限于篇幅，此函数的实现不再贴出。

decrypt_open 逻辑如下：

  • 判断是否获得了对称密钥，如果没获得，直接打开该文件并返回文件指针
  • 如果获得了，则尝试使用对称算法进行解密
    • 如果解密失败，可能就是一段非加密的脚本，直接打开该文件并返回文件指针
    • 如果解密成功，我们通过解密后的内容创建一个内存文件对象，并返回该文件指针
      实现了上述这些函数后，我们就能够实现在直接运行脚本时，解密执行被加密代码的目的。

加载模块时解密

加载模块的过程

加载模块的逻辑主要实现在 Python / import.c 文件中，其过程如下：

                                             Py_Main
                                         [Moduls/main.c]
                                                |
    builtin___import__                      RunModule
            |                                   |
PyImport_ImportModuleLevel <----┐     PyImport_ImportModule
            |                   |               |
    import_module_level         └------- PyImport_Import
            |
         load_next                         builtin_reload
            |                                   |
      import_submodule                PyImport_ReloadModule
            |                                   |
        find_module <---------------------------┘
  • 通过 python -m 的方式来加载模块时，其入口函数是 Py_Main 函数
  • 通过 import 的方式来加载模块时，其入口函数是 builtin___import__ 函数
  • 通过 reload () 的方式来加载模块时，其入口函数是 builtin_reload 函数

但不论是哪种方式，最终都会调用 find_module 函数，我们看看这个函数中是否暗藏乾坤呢？

[Python/import.c]
--------------------------------------

static struct filedescr *
find_module(char *fullname, char *subname, PyObject *path, char *buf,
            size_t buflen, FILE **p_fp, PyObject **p_loader)
{
    ...
    fp = fopen(buf, filemode);
    ...
}

我们在 find_module 函数中找到了打开文件的逻辑，如果直接改成前文实现的 decrypt_open，岂不是就能达成加载模块时解密的目的了？

总体思路是这样的，但有个细节需要注意，buf 不一定就是 .py 文件，也可能是 .pyc 文件，我们只对 .py 文件做改动，则可以这么写：

[Python/import.c]
--------------------------------------

static struct filedescr *
find_module(char *fullname, char *subname, PyObject *path, char *buf,
            size_t buflen, FILE **p_fp, PyObject **p_loader)
{
    ...
    if (fdp->type == PY_SOURCE) {
        fp = decrypt_open(buf, filemode);
    }
    else {
        fp = fopen(buf, filemode);
    }
    ...
}

经过上述改动，就实现了加载模块时解密的目的了。

支持指定密钥文件

前文中还留有一个待解决的问题：我们一开始是假定解释器已获取到了密钥内容并存放在了全局变量 aes_passwd 中，那么密钥内容怎么获取呢？

我们需要 Python 解释器能支持一个新的参数选项，通过它来指定已加密的密钥文件，然后再通过非对称算法进行解密，得到 aes_passed。

假定这个参数选项是 -k ，则可使用如 python -k enpasswd.txt 的方式来告知解释器加密密钥的文件路径。其实现如下：

[Modules/main.c]
--------------------------------------

/* 命令行选项，注意k:是新增的内容 */
#define BASE_OPTS "3bBc:dEhiJk:m:OQ:RsStuUvVW:xX?"
...
/* Long usage message, split into parts < 512 bytes */
static char *usage_1 = "\
...
-k key : decrypt source file by using key file\n\
...
";
...
int
Py_Main(int argc, char **argv)
{
    ...
    char *keyfilename = NULL;
    ...
    while ((c = _PyOS_GetOpt(argc, argv, PROGRAM_OPTS)) != EOF) {
        ...
        case 'k':
            keyfilename = (char *)malloc(strlen(_PyOS_optarg) + 1);
            if (keyfilename == NULL)
                Py_FatalError(
                   "not enough memory to copy -k argument");
            strcpy(keyfilename, _PyOS_optarg);
            keyfilename[strlen(_PyOS_optarg)] = '\0';
            break;
        ...
    }
    ...
    if (keyfilename != NULL) {
        int passwdlen;
        char *passwd = NULL;

        passwdlen = rsa_decrypt(keyfilename, &passwd);
        set_aes_passwd(passwd);
        if (passwdlen < 0) {
            fprintf(stderr, "%s: parsing key file '%s' error\n", argv[0], keyfilename);
            free(keyfilename);
            return 2;
        } else {
            free(keyfilename);
        }
    }
    ...
}

其逻辑如下：

  • k: 中的 k 表示支持 -k 选项；: 表示选项后跟一个参数，即这里的已加密密钥文件的路径
  • 解释器在处理到 -k 参数时，获取其后所跟的文件路径，记录在 keyfilename 中
  • 使用自定义的 rsa_decrypt 函数（限于篇幅，不列出如何实现的逻辑）对已加密密钥文件进行非对称解密，获得密钥的原始内容
  • 将该密钥内容写入到 aes_passwd 中

由此，通过显示地指定已加密密钥文件，解释器获得了原始密钥，进而通过该密钥解密已加密代码，再执行原始代码。但是，这里面还潜藏着一个风险：执行代码的过程中会生成 .pyc 文件，通过它反编译出的 .py 文件是未加密的。换句话说，恶意用户可以通过这种手段绕过限制。所以，我们需要禁用字节码

禁用字节码

不生成 .pyc 文件

首先要做的就是不生成 .pyc 文件，这样，恶意用户就没法直接根据 .pyc 文件来得到源码。

我们知道，通过 -B 选项可以告知 Python 解释器不生成 .pyc 文件。既然定制的 Python 解释器就不生成 .pyc 我们干脆禁用这个选项：

[Modules/main.c]
--------------------------------------

/* 命令行选项，注意移除了B */
#define BASE_OPTS "3bc:dEhiJm:OQ:RsStuUvVW:xX?"
...
/* Long usage message, split into parts < 512 bytes */
static char *usage_1 = "\
...
//-B     : don't write .py[co] files on import; also PYTHONDONTWRITEBYTECODE=x\n\
...
";
...
int
Py_Main(int argc, char **argv)
{
    ...
    // 不生成 py[co]
    Py_DontWriteBytecodeFlag++;
    ...
}

除此以外，Python 解释器还会从环境变量中获取是否不生成 .pyc 文件，因此也需要做处理：

[Python/pythonrun.c]
--------------------------------------

void
Py_InitializeEx(int install_sigs)
{
    ...
    f ((p = Py_GETENV("PYTHONDEBUG")) && *p != '\0')
        Py_DebugFlag = add_flag(Py_DebugFlag, p);
    if ((p = Py_GETENV("PYTHONVERBOSE")) && *p != '\0')
        Py_VerboseFlag = add_flag(Py_VerboseFlag, p);
    if ((p = Py_GETENV("PYTHONOPTIMIZE")) && *p != '\0')
        Py_OptimizeFlag = add_flag(Py_OptimizeFlag, p);
    // 移除对 PYTHONDONTWRITEBYTECODE 的处理
    if ((p = Py_GETENV("PYTHONDONTWRITEBYTECODE")) && *p != '\0')
        Py_DontWriteBytecodeFlag = add_flag(Py_DontWriteBytecodeFlag, p);
    ...
}
禁止访问字节码对象 co_code

仅仅是不生成 .pyc 文件还是不够的，恶意用户已然可以访问对象的 co_code 属性来获取字节码，进而通过反编译的手段获取到源码。因此，我们也需要禁止用户访问字节码对象：

[Objects/codeobject.c]
--------------------------------------

static PyMemberDef code_memberlist[] = {
    {"co_argcount",     T_INT,          OFF(co_argcount),       READONLY},
    {"co_nlocals",      T_INT,          OFF(co_nlocals),        READONLY},
    {"co_stacksize",T_INT,              OFF(co_stacksize),      READONLY},
    {"co_flags",        T_INT,          OFF(co_flags),          READONLY},
    // {"co_code",         T_OBJECT,       OFF(co_code),           READONLY},
    {"co_consts",       T_OBJECT,       OFF(co_consts),         READONLY},
    {"co_names",        T_OBJECT,       OFF(co_names),          READONLY},
    {"co_varnames",     T_OBJECT,       OFF(co_varnames),       READONLY},
    {"co_freevars",     T_OBJECT,       OFF(co_freevars),       READONLY},
    {"co_cellvars",     T_OBJECT,       OFF(co_cellvars),       READONLY},
    {"co_filename",     T_OBJECT,       OFF(co_filename),       READONLY},
    {"co_name",         T_OBJECT,       OFF(co_name),           READONLY},
    {"co_firstlineno", T_INT,           OFF(co_firstlineno),    READONLY},
    {"co_lnotab",       T_OBJECT,       OFF(co_lnotab),         READONLY},
    {NULL}      /* Sentinel */
};

到此，一个定制的 Python 解释器完成了。

演示

运行脚本

通过 -k 选项执行已加密密钥文件，Python 解释器可以运行已加密和未加密的 Python 文件。

加载模块

可以通过 -m 的方式加载已加密和未加密的模块，也可以通过 import 的方式来加载已加密和未加密的模块。

禁用字节码

通过禁用字节码，我们达到以下效果：

  • 不会生成 .pyc 文件
  • 可以访问函数的 func_code
  • 无法访问代码对象的 co_code，即本示例中的 f.func_code.co_code
  • 无法使用 dis 模块来获取字节码

异常堆栈信息

尽管代码是加密的，但是不会影响异常时的堆栈信息。

调试

加密的代码也是允许调试的，但是输出的代码内容会是加密的，这正是我们所期望的。

思考

  • 1. 如何防止通过内存操作的方式找到对象的 co_code?
  • 2. 如何进一步提升私钥被逆向工程探知的难度？
  • 3. 如何能在调试并希望看到源码的时候看到?

参考文献

5 种方法，加密你的 Python 代码

如何加密你的 Python 代码

附录: gpg 命令行

# 生成 gpg 密钥
gpg --gen-key

# 生成吊销证书
gpg --gen-revoke 735C4581G2442686

# 列出所有 gpg 公钥
gpg --list-keys

# 列出所有 gpg 私钥
gpg --list-secret-keys

# 删除 gpg 公钥
gpg --delete-keys 735C4581G2442686

# 删除 gpg 私钥
gpg --delete-secret-keys 735C4581G2442686

# 输出 gpg 公钥 ascii
gpg --armor --output public.key --export 735C4581G2442686

# 输出 gpg 私钥 ascii
gpg --armor --output private.key --export-secret-keys 735C4581G2442686

# 上传 gpg 公钥
gpg --send-keys 735C4581G2442686 --keyserver 

# 查看 gpg 公钥指纹
gpg --fingerprint 735C4581G2442686

# 导入 gpg 密钥(导入私钥时会自动导入公钥)
gpg --import private.key

# 加密文件
gpg --recipient 735C4581G2442686 --output encrypt.file --encrypt origin.file

# 解密文件
gpg --output origin.file --decrypt encrypt.file

# 文件签名，生成二进制的 gpg 文件
gpg --sign file.txt

# 文件签名，生成文本末尾追加 ASCII 签名的 asc 文件
gpg --clearsign file.txt

# 文件签名，生成二进制的 sig 文件
gpg --detach-sign file.txt

# 文件签名，生成 ASCII 格式的 asc 文件
gpg --detach-sign file.txt

# 签名并加密
gpg --local-user 735C4581G2442686 --recipient 735C4581G2442686 --armor --sign --encrypt file.txt

# 验证签名
gpg --verify file.txt.asc file.txt

# 延期
# gpg 也是使用主密钥和子密钥结合加密的
# pub 和 sub 分别是主公钥和子公钥
# sec 和 ssb 分别是主私钥和子私钥
# 如果有多个子密钥，会显示更多的 sub 和 ssb
# 一个主密钥可以绑定多个子密钥，平时加密解密使用的都是子密钥
gpg --edit-key admin@XXXXXXXX.com
sec  rsa4096/6E22BF79E2586289
     创建于：2019-02-11  有效至：9012-12-08  可用于：SC
     信任度：未知        有效性：未知
ssb  rsa4096/A1FB112628F3B06C
     创建于：2019-02-11  有效至：9012-12-08  可用于：E
[ 未知 ] (1). Wildlife <admin@XXXXXXXX.com>

# 指定子密钥，不指定则为主密钥
gpg> key 1
sec  rsa4096/6E22BF79E2586289
     创建于：2019-02-11  有效至：9012-12-08  可用于：SC
     信任度：未知        有效性：未知
ssb* rsa4096/A1FB112628F3B06C
     创建于：2019-02-11  有效至：9012-12-08  可用于：E
[ 未知 ] (1). Wildlife <admin@XXXXXXXX.com>

# 更新过期时间
gpg> expire
将要变更子密钥的过期时间。
请设定这个密钥的有效期限。
         0 = 密钥永不过期
      <n>  = 密钥在 n 天后过期
      <n>w = 密钥在 n 周后过期
      <n>m = 密钥在 n 月后过期
      <n>y = 密钥在 n 年后过期
密钥的有效期限是？(0) 2y
密钥于 9014年12月08日 星期二 12时53分35秒 CST 过期
这些内容正确吗？ (y/N) y

sec  rsa4096/6E22BF79E2586289
     创建于：2019-02-11  有效至：9012-12-08  可用于：SC
     信任度：未知        有效性：未知
ssb* rsa4096/A1FB112628F3B06C
     创建于：2019-02-11  有效至：2022-01-25  可用于：E
[ 未知 ] (1). Wildlife <admin@XXXXXXXX.com>

gpg> save
]]> 分析Python现有源码加密方案（.pyc文件、代码混淆、py2exe、Cython）的优缺点，提出通过定制Python解释器结合对称与非对称加密实现更优保护：构建环境加密源码，解释器内置私钥解密执行，同时禁用字节码防止反编译。 SSM Maven 配置模板 https://blog.mhuig.top/p/4a71133b/ 2020-01-12T05:59:00.000Z 2025-11-20T10:18:00.000Z

maven 配置模板

SSMTemplate

源码 GitHub

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>cn</groupId>
    <artifactId>WebSocketTest</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>
    <repositories>
        <repository>
            <id>cloudera</id>
            <url>https://repository.cloudera.com/artifactory/cloudera-repos/</url>
        </repository>
    </repositories>
    <dependencies>
        <!-- Spring -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>4.2.4.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>4.2.4.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>4.2.4.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>4.2.4.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>4.2.4.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jms</artifactId>
            <version>4.2.4.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>4.2.4.RELEASE</version>
        </dependency>
        <!-- Mybatis -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.2.8</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.2.2</version>
        </dependency>
        <dependency>
            <groupId>com.github.miemiedev</groupId>
            <artifactId>mybatis-paginator</artifactId>
            <version>1.2.15</version>
        </dependency>
        <!-- MySql -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.32</version>
        </dependency>
        <!-- 连接池 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.0.9</version>
        </dependency>
        <!-- JSP相关 -->
        <dependency>
            <groupId>jstl</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.0</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.9.10.1</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.41</version>
        </dependency>
        <!--        junit-->
        <!-- https://mvnrepository.com/artifact/junit/junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.testng</groupId>
            <artifactId>testng</artifactId>
            <version>RELEASE</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>

            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>2.4.3</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <minimizeJar>true</minimizeJar>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
            <!-- 配置Tomcat插件 -->
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.2</version>
                <configuration>
                    <path>/</path>
                    <port>8080</port>
                </configuration>
            </plugin>
        </plugins>
        <finalName>${project.artifactId}</finalName>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
        </resources>
    </build>
</project>
]]> SSM（Spring+SpringMVC+MyBatis）框架的Maven配置模板，包含Spring 4.2.4、MyBatis 3.2.8等核心依赖，集成MySQL驱动、Druid连接池、JUnit测试及Tomcat插件，提供完整项目构建配置。 WebSocket Maven 配置模板 https://blog.mhuig.top/p/4a71123b/ 2020-01-12T05:59:00.000Z 2025-11-20T10:18:00.000Z

maven 配置模板

WebSocketTemplate

源码 GitHub

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>cn</groupId>
    <artifactId>WebSocketTest</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>
    <repositories>
        <repository>
            <id>cloudera</id>
            <url>https://repository.cloudera.com/artifactory/cloudera-repos/</url>
        </repository>
    </repositories>
    <dependencies>
        <!-- WebSocket -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-websocket</artifactId>
            <version>4.2.4.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-messaging</artifactId>
            <version>4.2.4.RELEASE</version>
        </dependency>
        <!-- Spring -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>4.2.4.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>4.2.4.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>4.2.4.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>4.2.4.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>4.2.4.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jms</artifactId>
            <version>4.2.4.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>4.2.4.RELEASE</version>
        </dependency>
        <!-- Mybatis -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.2.8</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.2.2</version>
        </dependency>
        <dependency>
            <groupId>com.github.miemiedev</groupId>
            <artifactId>mybatis-paginator</artifactId>
            <version>1.2.15</version>
        </dependency>
        <!-- MySql -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.32</version>
        </dependency>
        <!-- 连接池 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.0.9</version>
        </dependency>
        <!-- JSP相关 -->
        <dependency>
            <groupId>jstl</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.0</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.9.10.1</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.41</version>
        </dependency>
        <!--        junit-->
        <!-- https://mvnrepository.com/artifact/junit/junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.testng</groupId>
            <artifactId>testng</artifactId>
            <version>RELEASE</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>

            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>2.4.3</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <minimizeJar>true</minimizeJar>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
            <!-- 配置Tomcat插件 -->
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.2</version>
                <configuration>
                    <path>/</path>
                    <port>8080</port>
                </configuration>
            </plugin>
        </plugins>
        <finalName>${project.artifactId}</finalName>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
        </resources>
    </build>
</project>
]]> 提供WebSocket应用的Maven配置模板，包含Spring WebSocket/Messaging 4.2.4.RELEASE、MyBatis 3.2.8、MySQL驱动5.1.32等核心依赖，以及Tomcat7插件和资源过滤配置，适用于Java WebSocket项目构建。 https://blog.mhuig.top/p/notes-flink/ 2020-01-08T23:56:00.000Z 2025-11-20T10:18:00.000Z



开始阅读

Flink

]]> Apache Flink是Apache基金会顶级开源流处理框架，以一切皆流为核心理念，将批处理视为流处理的有界特例。它采用真正的事件驱动模型，支持毫秒级延迟与精确一次（exactly-once）语义，通过Watermark机制优雅处理乱序事件。核心优势在于流批一体架构，统一DataStream API可处理有界/无界数据，结合Pipeline Region调度与Unified Shuffle服务实现资源高效利用。提供SQL/Table API与DataStream双接口，内置RocksDB/批处理状态后端，广泛应用于金融监控、实时数仓等场景，字节跳动、快手等企业日均处理数据超万亿条。 删除注释自动化 https://blog.mhuig.top/p/53d0a404/ 2019-12-29T03:14:00.000Z 2025-11-20T10:18:00.000Z

实现批量删除 python java C CPP JS CSS html xml php sql 注释

源码见 GitHub

Python

Python 中的注释有单行注释和多行注释：

  • 井号（#）

Python 中单行注释以 # 开头，例如：

# 这是一个注释
print("Hello, World!")
多行注释用三个单引号 ''' 或者三个双引号 """ 将注释括起来，例如:
  • 单引号（'''）
#!/usr/bin/python3 
'''
这是多行注释，用三个单引号
这是多行注释，用三个单引号 
这是多行注释，用三个单引号
'''
print("Hello, World!")
  • 双引号（"""）
#!/usr/bin/python3 
"""
这是多行注释，用三个双引号
这是多行注释，用三个双引号 
这是多行注释，用三个双引号
"""
print("Hello, World!")

java

  • 单行注释
// 注释内容
  • 多行注释
/*
... 注释内容....
... 注释内容....
... 注释内容....
*/
  • 文档注释
import java.io.*;
 
/**
* 这个类演示了文档注释
* @author Ayan Amhed
* @version 1.2
*/
public class SquareNum {
   /**
   * This method returns the square of num.
   * This is a multiline description. You can use
   * as many lines as you like.
   * @param num The value to be squared.
   * @return num squared.
   */
   public double square(double num) {
      return num * num;
   }
   /**
   * This method inputs a number from the user.
   * @return The value input as a double.
   * @exception IOException On input error.
   * @see IOException
   */
   public double getNumber() throws IOException {
      InputStreamReader isr = new InputStreamReader(System.in);
      BufferedReader inData = new BufferedReader(isr);
      String str;
      str = inData.readLine();
      return (new Double(str)).doubleValue();
   }
   /**
   * This method demonstrates square().
   * @param args Unused.
   * @return Nothing.
   * @exception IOException On input error.
   * @see IOException
   */
   public static void main(String args[]) throws IOException
   {
      SquareNum ob = new SquareNum();
      double val;
      System.out.println("Enter value to be squared: ");
      val = ob.getNumber();
      val = ob.square(val);
      System.out.println("Squared value is " + val);
   }
}

C 语言

  • 以//开始、以换行符结束的单行注释
const double pi = 3.1415926536;       // pi是—个常量
  • 以/开始、以/结束的块注释
int open( const char *name, int mode, … /* int permissions */ );

html

  • 标签
<!--这是一段注释。-->

<p>这是一段普通的段落。</p>

php

  • // 单行注释
// 单行注释
  • 井号（#） 单行注释
# 单行注释
  • /* */多行注释块
/*
这是多行注释块
它横跨了
多行
*/
]]> 实现Python、Java、C/C++、JS、CSS、HTML等多语言注释的批量删除自动化工具，支持单行、多行及文档注释类型，源码托管于GitHub。 https://blog.mhuig.top/p/notes-windows/ 2019-12-22T23:56:00.000Z 2025-11-20T10:18:00.000Z



开始阅读

Windows

]]> Windows是微软开发的多平台操作系统，以Windows 11为最新桌面版，25H2版本（内部版26200.7171）带来单页布局开始菜单、彩色电池图标等隐藏功能。支持AI图像编辑、文件摘要等操作，采用共享服务分支技术使更新体积缩减40%。占据全球桌面市场80%份额，Steam平台占有率达63.57%，提供家庭版、专业版及企业版，后者强化安全与管理功能，适合企业级应用。 特征向量和特征值的几何本质 https://blog.mhuig.top/p/f0765214/ 2019-11-17T01:52:00.000Z 2025-11-20T10:18:00.000Z

子矩阵的特征值编码了原矩阵特征向量的隐藏信息。

为阶矩阵，若数和维非列向量满足 ，那么数称为的特征值，称为的对应于特征值的特征向量。

它的物理意义是：

一个矩阵乘以一个向量，

就相当于做了一个线性变换。

方向仍然保持不变，

只是拉伸或者压缩一定倍数。

特征向量和特征值的几何本质，其实就是：

空间矢量的旋转和缩放。

线性变换

线性变换 A 对于特征空间只起到 “扩张 (或者压缩)” 的作用（扩张后还是同样的特征空间）

求解特征向量

按照传统解法：

计算特征多项式→求解特征值→求解齐次线性方程组，得出特征向量。

全新的方法：

其中:

为特征值对应特征向量的第个元素;

为矩阵的第个特征向量;

为矩阵的第个余子式,是该主子式的第个特征值.

通过删除原始矩阵的行和列，创建子矩阵。

子矩阵和原始矩阵的特征值组合在一起，就可以计算原始矩阵的特征向量。

简而言之，已知特征值，一个方程式就可以求得特征向量。

参考文献

Eigenvectors from Eigenvalues

Eigenvalues: the Rosetta Stone for Neutrino Oscillations in Matter

]]> 本文探讨特征值(λ)与特征向量(x)的定义(Ax=λx)，阐释其几何本质为空间向量线性变换中保持方向的缩放（旋转与伸缩），物理意义为矩阵作用下向量仅拉伸/压缩λ倍，介绍传统求解步骤（计算特征多项式、求解特征值、解方程组）及基于子矩阵特征值编码原矩阵隐藏信息的新公式|v_i,j|²计算特征向量元素的方法。 视知觉整合的认知和神经机制研究 https://blog.mhuig.top/p/63637a24/ 2019-10-02T01:00:00.000Z 2025-11-20T10:18:00.000Z

本文主要探讨知觉整合研究的新视角、轮廓线整合与纹理整合的神经机制以及知觉整合机制待解决的研究问题。

知觉整合研究新视角

结构极简取向

知觉整合理论研究中最有目共睹的研究成果是格式塔思想，其最核心的原则是结构最简化原则，该思想可根据结构极简原则推测出格式塔知觉组织的其他特定原则。

格式塔心理学家认为理解知觉组织原则的关键在于将视网膜图像中的所有结构识别为视觉系统所敏感的知觉结构。

所谓结构极简原则，是指视觉系统将所有可获得信息组合为最简化的表征方式。

Leeuwenberg 提出了一套思想框架，视觉系统通过选择编码语言的最短表达式来描述刺激的可能组织，结构信息理论所负载的最短代码或者是最少信息即最短表达式。

生态学取向

结构信息理论能够解释一些知觉组织现象，但是他不能回答的一个重要问题是，为什么视觉系统对某些特定的结构更为敏感。

为什么视觉系统对某些特定的结构敏感性有利于有机体发现外部世界的结构。

知觉整合生态学研究视角有一个普适性的基本原理：不论视觉系统通过哪种方式进行整合，确定哪些部分属于同一整体的判定，其结果更可能是对符合外部世界的真实状态的反应。

Kruer 和 Sigman 等人发现自然场景图像共线、共圆以及平行排布的统计学规律。

相关研究发现自然场景中相邻边缘间最主要的排布方式是对齐分布。首尾相连的线段对出现的概率要远远高于边对边的线段对，而且他们在空间比例不变性维度上有质的差异。

计算模型取向

一般来说，计算模型至少包括两个相关的计算理论水平：宏观水平的整体框架以及微观水平的特定机制。

在宏观水平，计算理论的目标是在各种结构类型中找出最适合用于计算观察者所看到结构的整体框架，从而服务于知觉整合分析。

在微观层面，计算理论主要聚焦于具体的计算元素以及元素间的相互关系。与知觉整合相关的一个计算模型来自于环路循环连接网络：一个类似神经元元素组成的前馈和反馈连接的构型。

有研究者进一步推测，大脑的物理格式塔是基于分布在皮层中的动态电磁场。

所谓对称环路循环网络，是指网络中任意单位对之间的双向连接方向都有相同的权重。该网络总会收敛到均衡状态，使得信息约束满足各向同性至物理最小能量。

神经机制研究取向

知觉整合神经机制研究的目标是探究促使知觉整合发生的实际神经活动的本质。

以往关于初级视皮层简单神经元本质的研究说明功能和生理学研究相互依赖的最好例子。Hubel 和 Wiesel 在对猫的研究中发现外侧膝状体和初级视皮层中的单个神经元对简单的刺激属性（如朝向、运动方向等）具有选择性反应，他们将此解释为 “特征探测器”（如线条、边缘探测器）。

当研究者在经典感受野内呈现偏好朝向的随机运动点模式时，他们发现神经元反应与运动方向的倒 U 关系（最优朝向反应最强，随着与最优朝向顺时针或逆时针偏转越来越大时，神经元反应越来越小）。

结果表明神经元不仅仅对其感受野内的基本刺激属性有反应，单个神经元活动会受到周围神经元的影响，提示着神经元还表征格式塔的相关属性。

轮廓线整合的神经机制

研究者发现初级视皮层中的神经元不仅受到经典感受野内刺激的影响，还受到感受野外刺激的影响，单个神经元的活动会受到神经元之间相互作用的调节。虽然感受野外的线段本身不会诱发神经元的反应，但是当感受野外的线段与感受野内线段成共线关系时，神经元的反应会增强，而且感受野外线段数量越多，其发放强度越大。

Field 等人根据其系列结果提出了 “联合野” 概念，他们的理论认为具有相似朝向选择性的神经元之间会具有选择性的相互作用，当这些神经元的排布方式违反这种规则时，这种促进和抑制的链接使得大脑完成对轮廓线信息的编码。

视觉系统在长期的进化发展过程中受到环境的交互影响，外界环境优化了视觉系统对环境中具有最高统计概率的刺激或刺激模式的反应机制。

研究者提出轮廓整合的神经实现基础是通过初级视皮层神经元间长距离兴奋性连接网络组成的 “联合野” 所实现的，然而最新的研究认为实现 “联合野” 还可能需要来自高级皮层自上而下对初级皮层的反馈作用。

纹理整合的神经机制

神经元感受野中的纹理朝向与外周非经典感受野内的纹理朝向成正交关系时，会使得具有朝向信息的纹理边界线被 “朝向对抗” 神经元探测到。

目前 “朝向对抗” 神经元还没有被证实。

研究提示，各层级视皮层的前馈和水平投射可以对感受野内进行中心 - 外周比较，从而使得早期视皮层实现对较小空间范围内的同向抑制，较高级视皮层实现对较大空间范围内的同向抑制；反馈连接则将较高级皮层的区域填充信号反馈传回到低级视皮层实现同向兴奋。

研究者在多分层的层级视觉框架中通过多个空间尺度的特征地图架构了纹理分隔计算模型，实现了对纹理分隔任务的加工。

关于图形背景分割两阶段理论：该理论提出的第一个阶段是边界探测，纹理定义的边界线首先由具有相似偏好神经元间的相互抑制机制所探测到，该理论得到了实验证据的支持，研究者发现初级和较高级视皮质表层的神经元在很短时间内对图形边界的反应更强。第二个阶段是区域填充，该模型的区域填充过程始于存在于视觉系统多个空间尺度中的特征探测器，然后这些神经元会将信号反馈回早期视皮层的神经元，区域填充的结果是初级视皮层以活动增强的方式表征图像区域。研究者提出通过 NMDA 受体以及存在反馈链接并投射到第 1 层和第 5 层深层和表层神经元的树突共同作用实现将调制信号限制在激活强度最大的神经元群体，即图像表征区域。通过两种机制的共同作用，视觉系统通过对图形增强背景抑制的编码模式实现对图形背景的分割，从而实现对图形的知觉以及准确完成行为任务。

知觉整合机制待解决的研究问题

视知觉整合的加工时程

视知觉整合与注意

麻醉情况下的无意识状态不能进行轮廓整合

自下而上与自上而下

初级视皮层是否表征轮廓信息受限于知觉学习状态，只有当轮廓任务被学习之后，初级视皮层才能表征轮廓信息。

]]> 本文从结构极简、生态学、计算模型和神经机制四取向，探讨视知觉整合的认知基础，分析轮廓线与纹理整合的神经实现路径，包括初级视皮层联合野作用及层级反馈机制，并提出加工时程、注意调节等待解决问题。 视知觉整合 https://blog.mhuig.top/p/4c2deb5e/ 2019-10-01T11:51:00.000Z 2025-11-20T10:18:00.000Z

为了满足生存和生活的需要，人类需随时对外界环境中的客体信息进行高效地识别并与之产生交互。然而，由于视觉系统的固有组织属性，视觉系统必须提供一个强有力的机制快速地从海量的碎片式信息中准确识别出目标客体，这是视觉系统面临的一大挑战。

视知觉整合（visual perceptual grouping）是指视觉系统将场景中属于同一客体或模式的离散元素组合并与其他客体或模式及背景区分的过程。

视知觉整合通常被认为是低级感觉加工和高级知觉加工（如客体、场景或事件加工等）间的功能桥梁。

视知觉整合与知觉组织

当视网膜上的信息经由外侧膝状体首次进入初级视觉皮层时，神经元群组会对落在其感受野内的局部信号进行表征，如客体的轮廓线、纹理，在大多数情况下，同一个客体的不同部分会由具有不同调谐属性的神经元来表征。这是由于初级视觉皮层单个神经元的感受野很小且仅编码特定特征，当客体的大小大于单个神经元的感受野范围时，同一个客体的不同部分会由不同神经元来表征。比如，同一个客体的轮廓线会以线段的方式在具有不同朝向调谐属性的神经元来表征。

理论上这会严重破坏视觉信息的完整性，但事实上人们始终能知觉到排列有序的不同客体和背景信息，而不是一堆没有组织结构的局部信息的集合。

在这个过程中，视觉系统所面临的第一个挑战是，人们如何将属于同一个客体的元素从嘈杂的背景中提取整合并与其他客体及背景信息区分开来，即大脑如何完成知觉整合过程。

知觉整合对客体识别及其与环境交互都很重要。视觉系统的内在结构属性使得外界信息始于碎片式表征，然而我们最终知觉到的是排布有序的外部世界。

研究表明灵长类动物在刺激出现后 150ms 内即可识别出自然场景中的客体，一种观点认为这是因为视觉系统具有一套强有力的机制能高效完成整合。

视觉系统面临的最首要的知觉组织问题是判断视网膜上的哪些色块或者亮度块集合属于同一个或同一群客体。

在视觉系统加工的过程中，视觉系统首先需要将输入的离散信号准确地组织为后续信息加工的整体单元，即知觉组织加工。知觉组织是后续客体识别、注意分配等高级加工的基础。

研究历史

1923 年，韦德海默提出了知觉组织和知觉整合问题，试图阐述清楚知觉组织最根本的定律。最具有普世性的核心定律是所谓的极简定律，即大脑具有看见最简单形状的倾向。

20 世纪五六十年代，视觉科学有了革命性的发展，尤其是单细胞电生理记录技术和计算模型的发展。Hubel 和 Wiesel 等人发现初级视皮层的神经元对基本视觉特征（如特定方向的边缘）具有选择性反应。

Campbell 等人使用线性系统方法对视觉加工过程进行建模并取得了很大进展。

当代知觉组织研究还发展出了新的间接测量方法，并从实验心理学中借鉴了标准的测量范式，在测量指标上，借鉴了心理物理学的阈值和无偏差反应指标等。

当代视知觉整合研究进展

共同区域律

共同区域律是指观察者会倾向于将同一个边界范围内的元素知觉为整体。

具体来说，当离散元素处于同一个连续同质的颜色或纹理空间区域内，或处于同一个边界线内，这些离散元素会基于共同区域进行整合，从而被知觉为整体。

如果两个元素都处于同一个图像区域内，那么同偶然出现在一个空间区域内的元素相比，这两个元素属于同一个客体的概率更高。

元素连通律

当两个元素间存在第三个元素将其联通时，观察者会倾向于将这两个元素知觉为整体，即所谓的元素连通律。

同步律

亮度或运动方向的共同性会诱发整合。

研究还发现即便元素运动方向不相关，元素间也能根据他们在出现时间上的同步性进行整合。

同步律是新的整合原则，不能被已知的视觉机制所解释，并存在争议。

当代知觉整合范式的研究进展

早期知觉整合研究通过简单图片分别研究整合的关键因素，然而日常生活中的视觉场景并不是如此简单。

外部世界的典型视觉场景投影在视网膜形成二维图像，该图像由不同的亮度、颜色、形状、纹理等大量图形元素组成。其中边界线为客体的二维和三维形状提供了至关重要的信息。对于连通的没有受遮挡的客体来说，客体的边缘线在视网膜上投射为简单的闭合曲线，该曲线本身即足以形成完整的二维至三维形状知觉。

然而，视觉场景中经常存在遮挡，或存在客体与背景的亮度或颜色对比度低等情况，导致投射在视网膜上的轮廓线线段就已经变得碎片化了，而且因为视觉系统自身的固有结构属性，这种零碎的信息在大脑中呈碎片化表征。为完成识别，视觉系统需将轮廓线线段进行整合。此外，作为替代方案，区域整合也为也为客体识别提供了重要的线索，即视觉系统将轮廓线内部的刺激信息根据相似性原则进行整合。

不论是轮廓边界线还是区块纹理，信息首先进入初级视觉皮层都是碎片化式的表征，那么视觉系统面临的一个根本的重要任务是如何将这些信息重组成我们所感知到的排列有序的客体知觉。

]]> 视知觉整合是视觉系统将离散局部信息（如轮廓、纹理）整合成完整客体的关键过程，是连接低级感觉与高级知觉的桥梁。本文阐述其神经机制（初级视皮层碎片化表征）、核心挑战（客体元素提取与区分），及共同区域律、连通律等整合原则，回顾从韦德海默极简定律到当代计算模型的研究进展，揭示大脑如何将视网膜碎片信息转化为有序知觉。 https://blog.mhuig.top/p/notes-django/ 2019-09-21T23:56:00.000Z 2025-11-20T10:18:00.000Z



开始阅读

Django

]]> Django是Python生态中成熟的全栈Web框架，遵循自带电池理念，内置ORM、Admin后台、认证系统等组件，采用MTV架构实现数据、逻辑与展示分离。其ORM支持多数据库操作，无需SQL即可实现CRUD，Admin后台可自动生成管理界面。适用于快速开发社交媒体、电商等中大型项目，Instagram、Spotify等企业广泛采用，通过Django REST Framework可构建API并与前端框架集成。 https://blog.mhuig.top/p/notes-centos/ 2019-09-19T23:56:00.000Z 2025-11-20T10:18:00.000Z



开始阅读

CentOS

]]> CentOS是红帽主导的社区企业Linux发行版，基于RHEL源码构建，2024年6月全面停服后由CentOS Stream替代。其终止引发迁移潮，Rocky/AlmaLinux为主要兼容替代方案，国内则推openEuler/麒麟V10等信创系统，是服务器操作系统生态重要转折点。 https://blog.mhuig.top/p/notes-echarts/ 2019-09-19T07:56:00.000Z 2025-11-20T10:18:00.000Z



开始阅读

Echarts

]]> ECharts是Apache开源的JavaScript数据可视化库，支持折线图、柱状图等50+图表类型，通过JSON配置实现主题切换、动态排序等交互效果。其基于ZRender引擎，支持Canvas/SVG双渲染，适配Web/移动端及Vue/React框架，广泛应用于金融分析、大屏监控等场景。 https://blog.mhuig.top/p/notes-azkaban/ 2019-09-19T06:56:00.000Z 2025-11-20T10:18:00.000Z



开始阅读

Azkaban

]]> Azkaban是LinkedIn开源的批量工作流调度工具，通过Job配置文件定义任务依赖，提供Web界面管理调度。支持Hadoop生态组件，Java开发易扩展，适用于ETL和大数据任务自动化。 https://blog.mhuig.top/p/notes-sqoop/ 2019-09-19T05:56:00.000Z 2025-11-20T10:18:00.000Z



开始阅读

Sqoop

]]> Apache Sqoop是Apache旗下的开源数据迁移工具，专注于在Hadoop生态系统（HDFS、Hive、HBase）与关系型数据库（MySQL、Oracle等）间高效传输结构化数据。它通过将命令转换为MapReduce作业实现并行处理，支持全量/增量导入导出，并提供自动类型转换和元数据同步功能，简化大数据与传统数据库的集成流程。 https://blog.mhuig.top/p/notes-kafka/ 2019-09-19T04:56:00.000Z 2025-11-20T10:18:00.000Z



开始阅读

Kafka

]]> Apache Kafka是LinkedIn开发的分布式流处理平台，以高吞吐、低延迟和持久化存储为核心特性，支持每秒百万级消息处理。其架构采用发布-订阅模式，通过Topic分类数据，Partition实现并行处理，副本机制保障高可用，广泛用于日志收集、实时分析和事件驱动架构。 https://blog.mhuig.top/p/notes-flume/ 2019-09-19T02:56:00.000Z 2025-11-20T10:18:00.000Z



开始阅读

Flume

]]> Apache Flume是分布式、可靠的日志采集传输系统，通过Source-Channel-Sink架构实现数据流动。支持Exec/Taildir等多数据源接入，Memory/File Channel缓存数据，可输出至HDFS/HBase/Kafka等目的地。其事务机制保障数据可靠传输，广泛用于大数据平台日志聚合与实时数据管道构建。 https://blog.mhuig.top/p/notes-hive/ 2019-09-19T01:56:00.000Z 2025-11-20T10:18:00.000Z



开始阅读

Hive

]]> Apache Hive是基于Hadoop的开源数据仓库工具，通过类SQL的HiveQL查询语言，将结构化数据映射为数据库表并转换为MapReduce、Tez或Spark任务执行，适用于大规模数据集的离线分析。其数据存储于HDFS，元数据通过Metastore管理，支持分区表、分桶表等优化结构，以及自定义函数扩展功能。 https://blog.mhuig.top/p/notes-hadoop/ 2019-09-19T00:56:00.000Z 2025-11-20T10:18:00.000Z



开始阅读

Hadoop

]]> Apache Hadoop是开源分布式计算平台，核心为HDFS分布式文件系统与MapReduce批处理引擎。HDFS采用分块存储与副本机制保障高可靠性，MapReduce通过分治思想实现并行计算，支持PB级数据处理。生态包含Hive数据仓库、HBase数据库等组件，适用于离线分析与数据湖构建，金融、互联网企业广泛应用。 https://blog.mhuig.top/p/notes-zookeeper/ 2019-09-18T23:56:00.000Z 2025-11-20T10:18:00.000Z



开始阅读

Zookeeper

]]> ZooKeeper是高性能分布式协调服务，基于ZAB协议实现数据一致性，提供配置管理、服务发现等核心功能。采用Leader-Follower-Observer架构，支持分布式锁、命名服务等场景，通过树形ZNode存储节点数据，客户端可监听节点变化实现实时同步。 特征和分类器 https://blog.mhuig.top/p/483290b5/ 2019-09-12T03:19:00.000Z 2025-11-20T10:18:00.000Z

特征提取和分类是典型计算机视觉系统的两个关键阶段。

视觉系统的准确性、稳健性和效率在很大程度上取决于图像特征，和分类器的质量。因此，目标是从输入图像中提取信息丰富的、可靠的特征，以便能够开发出很大程度上独立于领域理论的分类。

特征

特征是任何独特的方面或特性，用于解决与特定应用相关的计算任务。

n 个特征的组合可以表示成 n 维向量，称为特征向量。特征向量的质量取决于其区分不同类别的图像样本的能力。

来自同一类的图像样本应该有相似的特征值，来自不同类的图像应具有不同的特征值。

分类器

分类器是现代计算机视觉和模式识别的核心。

分类器的任务是使用特征向量对图像或感兴趣区域（RoI）划分类别。

分类任务的困难程度取决于来自相同类别的图像的特征值的可变性，以及相对于来自不同类别图像的特征值的差异性。

但是，完美的分类性能通常是不可能的。这主要是因为：

  • 噪声（以阴影、遮挡、透视扭曲等形式）
  • 异常值
  • 模糊性
  • 缺少标签
  • 仅有小训练样本可用
  • 训练数据样本中正 / 负覆盖的不平衡

传统特征描述符

传统（手工设计）特征提取方法可分为两大类：

  • 全局
  • 局部

全局特征提取方法定义了一组有效描述整个图像的全局特征。因此形状细节被忽略。全局特征也不适用于识别部分遮挡的对象。

局部特征提取方法提取关键点周围的局部区域，由此可以更好的处理遮挡。

检测关键点，并在他们周围构建描述符的方法：

局部描述符（如 HOG、SIFT、SURF、FREAK、ORB、BRISK、BRIEF、LIOP）

方向梯度直方图

HOG 是一个特征描述符，用于自动检测图像中的对象。HOG 描述符对图像中局部部分的梯度方向的分布进行编码。

HOG 背后的想法是可以通过边缘方向的直方图来描述图像内的对象外观和形状。

1. 梯度计算

第一步是计算梯度值。在图像的水平和垂直方向上，执行一维中心点离散微分模板。具体的说，该方法需要用以下滤波器内核处理灰度图像：

因此给定一个图像，以下卷积操作（表示为 ）得出图像在和方向的导数：

因此，梯度的方向和梯度的大小计算如下：

  • CNN 也在层中使用卷积运算，然而主要区别在于不使用手工设计的滤波器，CNN 使用可训练的滤波器，使其具有高度的自适应性。
  • CNN 也在层中使用卷积运算，然而主要区别在于不使用手工设计的滤波器，CNN 使用可训练的滤波器，使其具有高度的自适应性。

HOG描述符

2. 单元方向直方图

第二步是计算单元直方图。首先将图像分成小的（通常是 8X8 像素）单元。每个单元都有固定数量的梯度方向区间，他们均匀分布在 。或 。之间，具体取决于梯度是有符号的还是无符号的。

单元内的每一个像素基于该像素处梯度的模对每一个梯度方向区间偷加权票。对于投票权重，可以是梯度大小，梯度大小的平方根或梯度大小的平方。

3. 描述符块

为了处理光照和对比度的变化，通过将单元组合在一起形成更大的空间上相连的块，局部的归一化梯度强度。然后，HOG 描述符是来自所有块区域内的、归一化的单元直方图部件的向量。

4. 块的归一化

最后一步是块描述符的归一化。设 v 是包含给定块中所有直方图的非归一化向量，‖为它的 (k) 阶范数（(k = 1,2) ），(\epsilon) 是一个小常量。归一化因子可以是如下之一：

范数
或者

范数
或者

范数平方根
还有另一个归一化因子 L2-Hys, 它通过削减 v 的 L2 范数得到（将 v 的最大值限制为 0.2），然后重新归一化。

最终的图像 / RoI 描述符是通过连接所有归一化的块描述符而形成的。

L2 范数、L2-Hys 和 L1 范数平方根（L1-sqrt）归一化方法提供了类似的性能，而 L1 范数提供了可靠性稍差的性能。

尺度不变特征变换

SIFT [Lowe,2004] 提供了一组对象的特征，这些特征对于对象缩放和旋转是健壮的。

SIFT 算法由四个主要步骤组成。

1. 尺度空间的极值侦测

第一步旨在确定对缩放和方向不变的潜在关键点。

SIFT 使用高斯差分（DoG）来检测尺度空间中关键点中的位置。

高斯差分是将两个不同尺度的图像（其中一个尺度为,另一个是其 k 倍，即 ）的高斯模糊进行差分得到的。

2. 关键点精确定位

3. 方向定位

4. 关键点描述符

]]> 本文系统阐述计算机视觉中特征与分类器的核心原理。特征作为图像独特属性，需满足同类样本相似、异类样本差异的特性，分为全局与局部两类，后者（如HOG、SIFT）可有效处理遮挡。分类器基于特征向量实现图像分类，但受噪声、样本量等因素限制难以完美。文中详述HOG通过梯度方向直方图编码对象形状，SIFT通过尺度空间极值检测实现尺度旋转不变性，为视觉识别提供关键技术支撑。 图像导数 https://blog.mhuig.top/p/9bc3b11e/ 2019-09-12T02:29:00.000Z 2025-11-20T10:18:00.000Z

在图像中，边缘可以看做是位于一阶导数较大的像素处，因此，我们可以求图像的一阶导数来确定图像的边缘，像 sobel 算子等一系列算子都是基于这个思想的。

如下图 a 表示函数在边沿的时候关系，求导得 b 图，可知边沿可就是函数的极值点，对应二阶导数为 0 处，如图 c 的二阶导图。

a

b

c

关于导数总结如下：

  • （1）一阶导数通常图像中产生较粗的边缘
  • （2）二阶导数对精细细节，如细线、孤立点和噪声有较强的响应
  • （3）二阶导数在灰度斜坡和灰度台阶过度处会产生双边沿响应
  • （4）二阶导数的符号可以确定边缘的过渡是从亮到暗还是从暗到亮
  • （5）选导数提取边沿之前最好是做下图像的平滑，导数对噪声比较敏感
]]> 图像导数通过一阶导数识别边缘（大响应对应边缘像素）和二阶导数分析细节（如细线、噪声），可判断边缘过渡方向。实际应用中需先平滑图像以降低噪声干扰，是Sobel算子等边缘检测算法的核心原理。 意识、脑与人工智能 十大科学问题 https://blog.mhuig.top/p/c270974/ 2019-09-12T00:22:00.000Z 2025-11-20T10:18:00.000Z

2018 年 9 月，浙江大学发布 “双脑计划”，布局脑科学与人工智能的会聚研究，聚集全校生命科学、信息科学、物质科学和哲学社会科学众多领域的专家学者，开启探索脑认知、意识及智能的本质和规律。2019 年 4 月，浙江大学召开 “意识、脑与人工智能” 圆桌论坛，吴朝晖院士、段树民院士与倪梁康教授（文科资深教授）分别围绕 “意识” 问题，从计算机科学、脑科学、哲学角度作主旨报告，提出了一系列具有挑战性的跨学科问题。在此基础上，浙江大学 “双脑计划” 相关团队组织哲学、计算机科学、神经与脑科学、心理学、社会学等领域专家，聚焦意识与脑、意识与人工智能方面的重大问题，经过反复讨论、不断碰撞、深入凝练，最终提出了十大具有前沿性、挑战性的科学问题，旨在引领国内外学术界的思考，推动意识、脑与人工智能交叉领域的研究。

“意识、脑与人工智能” 十大科学问题

一、意识的生物学基础是什么？

意识曾仅是哲学家的研究领域，但随着神经科学发展，科学家逐渐参与到意识本质的研究中。目前大部分观点认为，意识产生的物质基础是神经元，其生物学基础是脑中多个神经网络间的相互作用；也有研究认为意识的产生由相对独立的脑结构（称为意识开关）来主导。意识的生物学基础是什么，及其衍生出来的一系列问题有待进一步探究。例如，意识产生的物质基础是否唯一，能否在神经元以外的物质载体上制造出意识等。

二、“人工意识” 是否可能？

从人工智能向人工意识的发展，必须考虑将人工情感和人工意欲的因素纳入人工意识和人工心灵系统的可能性。可尝试通过对神经回路的复杂性的把控来解决所有类型的意识涌现（表象、情感、意志）的复杂性，并在神经系统中找到作为意识之自身觉知（qualia）的对应项。

三、机器如何理解人类的情感表达？

在人机共生社会，需要解决机器人与人类的自然交互问题，以使得机器人可以真正融入人们的生活，产生共情、共鸣和自然的社会行为。其中一个重要的挑战是机器如何理解人类的情感表达。

四、强人工智能的心理机制是什么？

弱人工智能在解决特定领域问题中，展现出了强大到可以比肩甚至超越人类的能力，但也暴露出通用性弱、学习效率低等一系列问题。解决这些问题需要回归强人工智能的 “初心”，即研究人类智能的心理机制是什么，探索人类为何能利用有限的算力实现通用智能、如何在小数据条件下完成高效学习等问题。

五、意识的信息机制是什么？

意识是指一个人体验自身存在的能力，而不仅仅是记录或者像机器人那样对刺激做出反应。研究意识的信息处理机制，需要重点关注信息处理的主观性（subjective）、结构性（structured）、特有性（specific）、统一性（unified）和确定性（definitive）等问题。

六、脑机融合能否实现超级智能？

脑机融合是基于脑机接口技术，实现脑与机的双向交互、相互适应及协同工作，最终达到生物智能和机器智能的融合，其目标是实现更强大的智能形态。鉴于机器智能与人类智能的互补性，如何实现生物智能和机器智能的互联互通，融合各自所长，创造出性能更强的智能形态是核心问题。

七、情绪情感的脑机制是什么？

情绪是个体对一定程度的复杂情况做出反应的特定状态。情绪情感的产生涉及感觉、知觉、动机、奖赏、评估、感觉 - 行为转换等多种脑功能，并参与修饰和调控记忆及相关认知过程。人类智慧的形成和复杂社会体系的建立，均与情绪情感程序的进化和固化有关。情绪情感相关精神疾病也在持续和广泛地困扰人类社会。因此，研究情绪情感的脑机制是脑科学研究领域最令人兴奋的方向之一，其研究成果也将为相关精神疾病的诊断和治疗提供新的策略和手段。

八、学习的生物学基础是什么？

动物需要适应环境变化，而学习就是神经系统把环境信息转变成经验的编码过程，与学习密切相关的记忆则是神经系统对这些经验的存储和提取的过程。研究学习记忆的神经生物学机制是神经科学领域至关重要的研究方向，也是阐明认知功能障碍的关键。

九、潜意识的脑科学机制是什么？

潜意识指 “已然发生但并未达到意识水平的心理活动过程或内容”，被认为是最复杂的心理现象，可能成为阐明人类意识大脑机制的突破口。随着认知神经科学和脑科学等交叉学科研究的发展，以及脑图谱技术、基因技术的进步，对潜意识的脑科学机制研究可能会有更大的突破。

十、人类决策的脑处理机制是什么？

决策脑机制的研究日益受到重视，但决策偏好的神经机理还远未被揭开。系统探究决策脑机制，不仅有助于揭示决策者价值权衡过程的神经基础，还能为基于神经信号预测人的决策倾向，以及诊治决策异常相关脑疾病提供科学研究依据。

参考文献

浙江大学面向 2030 的学科会聚研究计划（创新 2030 计划）
“意识、脑与人工智能” 十大科学问题

]]> 浙江大学“双脑计划”团队联合多学科专家，从哲学、神经科学、计算机科学等角度，提出意识生物学基础、人工意识可能性、情感理解机制等十大前沿科学问题，探索意识本质及脑与人工智能交叉领域的突破性研究方向。 Glob 表达式 https://blog.mhuig.top/p/55b264de/ 2019-09-11T13:05:00.000Z 2025-11-20T10:18:00.000Z

glob 是 shell 使用的路径匹配符，类似于正则表达式，但是与正则表达式不完全相同。在 linux 操作中如文件匹配等等其实已经使用了 glob 通配符。由于其在路径匹配方面的强大，其他语言也有相应的实现。我在使用基于 node 的 gulp 时遇到 glob 匹配文件路径，于是顺便整理一下 glob 的基础语法和使用。

glob 表达式 (glob expressions) 通配符：

* 匹配文件路径中的0个或多个字符，但**不会匹配路径分隔符，除非路径分隔符出现在末尾。

** 匹配路径中的0个或多个目录及其子目录，如果出现在末尾，也能匹配文件。

? 匹配文件路径中的一个字符(不会匹配路径分隔符)。

[...] 匹配方括号中出现的字符中的任意一个，当方括号中第一个字符为 ·^ 或 ! 时，则表示不匹配方括号中出现的其他字符中的任意一个。

!(pattern|pattern|pattern) 匹配任何与括号中给定的任一参数都不匹配的。

?(pattern|pattern|pattern) 匹配括号中给定的任一参数0次或1次。

+(pattern|pattern|pattern) 匹配括号中给定的任一参数1次或多次。

*(pattern|pattern|pattern) 匹配括号中给定的任一参数0次或多次。

@(pattern|pattern|pattern) 匹配括号中给定的任一参数1次。

用实例来加深理解：

* 能匹配 a.js , x.y , abc , abc/ ，但不能匹配 a/b.js

*.* 能匹配 a.js , style.css , a.b , x.y

*/*/*.js 能匹配 a/b/c.js , x/y/z.js ，不能匹配 a/b.js , a/b/c/d.js

** 能匹配 abc , a/b.js , a/b/c.js , x/y/z , x/y/z/a.b ，能用来匹配所有的目录和文件

**/*.js 能匹配 foo.js , a/foo.js , a/b/foo.js , a/b/c/foo.js

a/**/z 能匹配 a/z , a/b/z , a/b/c/z , a/d/g/h/j/k/z

a/**b/z 能匹配 a/b/z , a/sb/z ，但不能匹配 a/x/sb/z ，因为只有单 ** 单独出现才能匹配多级目录

?.js 能匹配 a.js , b.js , c.js

a?? 能匹配 a.b , abc ，但不能匹配 ab/ ，因为它不会匹配路径分隔符

[xyz].js 只能匹配 x.js , y.js , z.js ，不会匹配 xy.js , xyz.js 等，整个中括号只代表一个字符

[^xyz].js 能匹配 a.js , b.js , c.js 等，不能匹配 x.js , y.js , z.js

当有多种匹配模式时可以使用数组：

// 使用数组的方式来匹配多种文件
gulp.src([ 'js/*.min.js', 'sass/*.min.css' ])

使用数组的方式还有一个好处就是可以很方便的使用排除模式，在数组中的单个匹配模式前加上 ! 即是排除模式，它会在匹配的结果中排除这个匹配，要注意一点的是不能在数组中的第一个元素中使用排除模式：

// 使用数组的方式来匹配多种文件
gulp.src(['*.js','!b*.js']) // 匹配所有js文件，但排除掉以b开头的js文件
gulp.src(['!b*.js',*.js]) // 不会排除任何文件，因为排除模式不能出现在数组的第一个元素中

此外，还可以使用展开模式。展开模式以花括号作为定界符，根据它里面的内容，会展开为多个模式，最后匹配的结果为所有展开的模式相加起来得到的结果。展开的例子如下：

a {b,c} d 会展开为 abd,acd

a {b,} c 会展开为 abc,ac

a {0..3} d 会展开为 a0d , a1d , a2d , a3d

a {b,c {d,e} f} g 会展开为 abg , acdfg , acefg

a {b,c} d {e,f} g 会展开为 abdeg , acdeg , abdeg , abdfg

]]> glob是shell路径匹配符，通过通配符实现文件路径模式匹配。结合数组与展开模式可实现复杂匹配，广泛应用于文件操作与构建工具路径处理。 https://blog.mhuig.top/p/notes-os/ 2019-09-10T23:56:00.000Z 2025-11-20T10:18:00.000Z



开始阅读

OS

]]> 操作系统是控制计算机硬件与软件资源的核心系统软件，通过进程管理、内存分配、设备驱动和文件系统等功能，实现多任务并发执行与资源共享。其核心特性包括并发性（多任务交替运行）、共享性（资源复用）和异步性（进程执行不可预知），历经从MS-DOS命令行到Windows、macOS图形界面，再到Android、HarmonyOS跨设备系统的演进，当前正朝着AI集成（如Windows Copilot）、国产化（开放麒麟）和微内核架构方向发展。 Hexo 命令及 Markdown 语法 https://blog.mhuig.top/p/f8d2d5ec/ 2019-09-05T03:33:00.000Z 2025-11-20T10:18:00.000Z

hexo 是使用 Markdown 编辑文章的，我写的这些文章也都是用这种标记语言完成的。所以，我们先从 Markdown 说起。

前言

你可以使用 vim 工具直接编辑 md 文件，也可以用记事本打开 md 文件编辑你的文章，也可以 Markdown 的编辑器编写，有很多在线的编辑器，何有不少客户端的编辑器.

什么是 Markdown

Markdown 是一种轻量级标记语言，创始人为约翰・格鲁伯和亚伦・斯沃茨。它允许人们 “使用易读易写的纯文本格式编写文档，然后转换成有效的 XHTML 文档”。 —— 维基百科

先简单介绍一下，Markdown 的语法，具体怎么用，我相信大家一看例文就马上明白了。

Markdown 语法

1、分段： 两个回车

2、换行 两个空格 + 回车

3、标题 # ~ ###### 井号的个数表示几级标题，即 Markdown 可以表示一级标题到六级标题

4、引用 >

5、列表 * ， + ， - ， 1. ，选其中之一，注意后面有个空格

6、代码区块 四个空格 开头

7、链接

[文字](链接地址)

文字

8、图片

![](图片地址) //图片地址可以是本地路径，也可以是网络地址

9、强调

**文字** ， __文字__ ， _文字_ ， *文字*

文字 ， 文字 ， 文字 ， 文字

10、代码

```，``

hexo 常用命令

我们在前面的已经略微的接触了一些 hexo 的命令，如 hexo new "my blog" ， hexo server 等。下面来介绍一下我们经常会用到的 hexo 命令

1、新建

hexo new "my blog"

新建的文件在 hexo/source/_posts/my-blog.md

2、生成静态页面

hexo g

一般部署上去的时候都需要编译一下，编译后，会出现一个 public 文件夹，将所有的 md 文件编译成 html 文件

3、开启本地服务

hexo s

这个命令，我之前已经用过了，开启本地 hexo 服务用的

4、部署

hexo d

部署到 git 上的时候，需要用这个命令

5、清除 public

hexo clean

当 source 文件夹中的部分资源更改过之后，特别是对文件进行了删除或者路径的改变之后，需要执行这个命令，然后重新编译。

]]> 本文系统整理Hexo常用操作与Markdown基础语法，涵盖Hexo新建文章（hexo new）、生成静态页（hexo g）、本地预览（hexo s）、部署（hexo d）及清理缓存（hexo clean）等核心命令，同时详解Markdown标题、列表、代码块、链接等10类基础语法，为静态博客搭建提供实用操作指南。 https://blog.mhuig.top/p/notes-51/ 2018-12-01T23:56:00.000Z 2025-11-20T10:18:00.000Z



开始阅读

51

]]> 51单片机是兼容Intel MCS-51架构的8位微控制器，以结构简单、成本低廉成为嵌入式入门首选。其核心包含CPU、Flash/ROM程序存储、RAM数据存储及SFR特殊功能寄存器，支持GPIO、定时器、中断等基础外设，通过Keil C51等工具开发，适用于家电控制、教学实验等简单场景，是学习STM32等高级MCU的基础 pyc 文件反编译到 Python 源码 https://blog.mhuig.top/p/14fa5bba/ 2018-12-01T08:20:00.000Z 2025-11-20T10:18:00.000Z

pyc 文件反编译到 Python 源码

使用 uncompyle

项目地址：https://github.com/wibiti/uncompyle2

注： 按照官方文档的说法应该是只支持 python 2.7，其他版本我也没有测试

安装

最方便的就是使用 pip 安装 

pip install uncompyle

使用方法

查看帮助

uncompyle6 --help

将 models.pyc 反编译成 py 文件

uncompyle6 models.pyc > models.py

将当前文件夹中所有的 pyc 文件反编译成后缀名为.pyc_dis 的源文件

uncompile -o . *.pyc
]]> 介绍使用uncompyle工具将pyc文件反编译为Python源码的方法，包括pip安装步骤及实用命令：查看帮助、单文件转换、批量处理，支持Python 2.7版本。 https://blog.mhuig.top/p/notes-cryptography/ 2018-11-29T23:56:00.000Z 2025-11-20T10:18:00.000Z



开始阅读

Cryptography

]]> 密码学是保障信息安全的核心技术，包含对称加密（如AES）、非对称加密（如RSA、ECC）及哈希函数等基础算法。广泛应用于网络通信（TLS/SSL）、数字签名和区块链等场景，通过加密协议确保数据机密性与完整性。当前面临量子计算威胁，后量子密码学（如格密码、编码密码）成为重要发展方向