Muspi Merol

给博客图片自动补上了 dimensions

2026-03-14T16:57:00.000Z

最近给这个博客处理了一下 markdown 图片的 width 和 height 属性的问题。

这篇文章一部分由 LLM 基于我的 git log 生成，非纯手写

由于这个博客的文章不是写在文件里的，而是写在语雀上，用语雀当 CMS。也就是说，我本地并没有一堆 markdown 文件和配套的图片资源，文章内容是在运行时通过 API 拉下来的。图片来源也很散，有语雀自己的 CDN，有别的图床，也有 Open Graph 图。总之不是那种所有图片都躺在 static/ 目录里的博客。

这样一来就有个问题：语雀返回给我的 HTML 里，<img> 基本没有 width 和 height。于是浏览器在图片真正加载出来之前，不知道该留多大位置，正文就会先排一版，等图片回来再重排。文章里图片多一点，页面就会抖。

而且这种博客架构下，也不可能手动给每张图维护尺寸。文章不在本地，图片来源又很散，这种事情一旦靠手工做，很快就会变成纯粹的脏活。

所以最后做的事就是：写一个脚本，在 build-time 把整个 blog 用到的图片尺寸都扫出来，生成一个 map 文件。运行时只负责查这个表。

override `<img>`

这个博客用的 markdown 渲染器 @humanspeak/svelte-markdown支持 override 各种元素对应的 component，比如可以 override <img> 标签。

所以先把 markdown 里的图片渲染接管了：

<SvelteMarkdown renderers={{ code: Code, link: Url, image: Image }} source={markdown} />

这样所有 markdown 图片都会统一走 Image.svelte。

最后这个组件本身很薄，核心就这些：

<img
  src={href}
  {title}
  alt={text}
  loading="lazy"
  width={dimensions?.[0]}
  height={dimensions?.[1]}
/>

也就是说，问题的关键不再是怎么 render img，而是 dimensions 从哪来。

为什么我没有继续在运行时搞

最先想到的方案当然是运行时去拿。

比如：

图片加载完之后再读它的 natural width / height
SSR 的时候顺手把每张图请求一遍
自己再接管一套懒加载逻辑

但这些方案其实都不太对。

第一种太晚。等图片真的加载完了，布局早就重排了。

第二种太重。文章页如果有十几张图，那等于每次 render 页面都得顺手再请求十几次图片。

第三种一开始其实真写了，还加了 IntersectionObserver 和一些 fade-in 的状态。后来很快删了。因为它解决的是“什么时候加载”，不是“浏览器在 layout 的时候有没有尺寸信息”。原生的 loading="lazy" 已经够用了，没必要自己再维护一套状态机。

所以后来就把问题收束成了一件更具体的事：

只要能在页面渲染前拿到图片尺寸，这个问题就解决了。

build-time 收集

既然文章内容本来就是从语雀拉下来的，那最自然的做法就是在 build-time 也走一遍类似的流程：

列出 blog 仓库里的所有文章
拉每篇文章的详情
从 body_html 里抽出所有 <img src>
请求这些图片
读出它们的宽高
写成一个 image-dimensions.json

这个脚本里真正新引入的核心依赖是 image-size。它做的事情很单纯：给它一段图片二进制，它返回宽高。

在代码里大概就是这样：

const response = await fetch(url, { signal, headers: { "User-Agent": "Mozilla/5.0 (compatible; ImageSizeBot/1.0)" } });
const buffer = await response.arrayBuffer();
const dimensions = imageSize(new Uint8Array(buffer));

然后再检查：

if (!dimensions?.width || !dimensions?.height) {
  return { url, size: null, error: "Invalid image data" };
}

最后才把它变成我自己的统一格式：

return { url, size: [dimensions.width, dimensions.height] };

这类事情当然也不是不能自己去读图片头，但没必要。既然已经有现成的库把这件事情做完了，而且常见格式都支持，那直接用就行了。

除此之外，这个脚本里还用了：

cheerio：解析语雀返回的 body_html，把所有图片地址抽出来
xsfetch：统一发请求

其中 cheerio 这一层也很朴素：

const $ = cheerio.load(html);
$("img").each((_, elem) => {
  const src = $(elem).attr("src");
  if (src) {
    imageUrls.add(src);
  }
});

`image-size` 之外，我还顺手把请求这一层补完整了

如果只是“请求图片然后喂给 image-size”，这个脚本其实会挺脆的。因为图床这东西本来就不稳定。

所以这里额外做了几件事：

超时

const controller = new AbortController();
const timeoutId = setTimeout(() => {
  controller.abort();
}, IMAGE_REQUEST_TIMEOUT_MS);

这样某张图太慢的时候，不至于把整个收集流程卡死。

重试

又包了一层 fetchImageSizeAttempt，对 408、425、429 以及 5xx 做重试。

if (response.status === 404 || !isRetryableStatus(response.status) || attempt === IMAGE_REQUEST_RETRIES) {
  return { url, size: null, error: lastError };
}

也就是说，404 这种明显没了的图就别浪费时间了，但如果只是服务端抖一下，那可以再试几次。

并发

没有直接 Promise.all 一把梭，而是自己写了个很小的 AsyncQueue<T>，把“列文章”和“取图片尺寸”拆成两个队列。

一个队列负责 post，一个队列负责 image：

const postQueue = new AsyncQueue<PostSummary>();
const imageQueue = new AsyncQueue<string>();

然后：

POST_CONCURRENCY = 5
IMAGE_CONCURRENCY = 20

这样做的好处是，文章详情和图片下载可以像流水线一样并发，而不是先把所有文章全扫完再开始下载图片。

这个设计我还挺喜欢的，很简单，但足够用。

我用到的语雀 API 其实很少

这个收集脚本基本只用了两类语雀 API。

先列出仓库里的文章：

GET https://yuque.com/api/v2/repos/muspi_merol/blog/docs

再按 slug 拉详情：

GET https://yuque.com/api/v2/repos/muspi_merol/blog/docs/:slug

真正有用的字段是 body_html，因为我要从里面找图片。

请求头也很简单：

const headers = {
  "User-Agent": "yuque-blog-bot",
  "Accept": "application/json",
  "X-Auth-Token": process.env.ACCESS_TOKEN || "",
};

所以整个数据流其实就是：

通过语雀 API 列文章
通过语雀 API 拉 body_html
用 cheerio 抽 <img src>
把图片下载下来
用 image-size 读宽高
输出成 JSON

这个脚本里其实还有个我顺手手搓的 TUI

其实本来是想用 OpenTUI 的，只是后来发现 agnet 逐渐把 opentui 的东西都去掉了。主要是我想要实现类似 prompt-toolkit 的那种非 alternative screen 的 TUI

本来这东西完全可以只在命令行里 console.log 几行就算了，但后来还是单独写了个 collect-image-sizes-ui.ts。

这个文件里没有用什么 TUI 框架，而是直接用 ANSI escape code 自己画。

比如这些：

const CSI = "\u001B[";
const ANSI_CODE = {
  reset: "\u001B[0m",
  hideCursor: "\u001B[?25l",
  showCursor: "\u001B[?25h",
  clearLine: "\u001B[2K",
} as const;

加上：

moveToFrameStart(lineCount)
moveUp(lineCount)
clearLine

就可以做到“把上一帧擦掉，再在原地重画下一帧”。

核心思路其实就是：

维护一个内部 state
根据 state 生成当前 frame 的所有行
每次状态变化时，回到上一帧开头
清掉旧内容
把新 frame 全量写出来

InlineCollectorUi 就是这么干的。它里面维护了一份 CollectorState：

interface CollectorState {
  phase: string;
  postsProcessed: number;
  postsTotal: number;
  imagesProcessed: number;
  imagesTotal: number;
  successCount: number;
  failureCount: number;
  startedAt: number;
  finishedAt: number | null;
}

然后把这些状态拼成一帧：标题、进度条、日志。

其中那个进度条也不是现成库给的，而是自己按宽度算出来的：

const scanWidth = Math.min(Math.floor(scanProgress * width), width);
const imageWidth = Math.min(Math.floor(imageProgress * width), scanWidth);

再用：

FILLED_BAR_CHAR.repeat(imageWidth)
SCAN_BAR_CHAR.repeat(pendingWidth)
TRACK_BAR_CHAR.repeat(trackWidth)

拼出一条 pipeline bar。

我这里还顺手做了两套 UI：

如果当前终端不是 TTY，就退回到 ConsoleCollectorUi，直接普通输出
如果是交互终端，就用 InlineCollectorUi 做原地刷新

也就是说它不是为了“好看”才单独写个 TUI，而是为了让这个 collector 在不同环境下都还能有比较合理的表现。

生成的尺寸表

最后写出来的文件大概长这样：

{
  "https://www.muspimerol.site/nlark/yuque/0/2025/png/26070246/....png": [2984, 1651],
  "https://www.muspimerol.site/nlark/yuque/0/2025/webp/26070246/....webp": [1320, 1180]
}

然后在 Image.svelte 里 eager import：

const imageDimensionsModules = import.meta.glob("./image-dimensions.json", { eager: true });
const dimensionsMap = Object.values(imageDimensionsModules)[0]?.default ?? {};

再按地址去查：

const dimensions = $derived(
  !href
    ? undefined
    : dimensionsMap[href] || dimensionsMap[`https://www.muspimerol.site/nlark/${href.replace(/^\/nlark\//, "")}`],
);

这里还有一个小问题要处理：我页面里有些图片地址走的是 /nlark/... 这个代理路径，但收集尺寸的时候拿到的是真实的 CDN 地址。所以查表的时候要兼容这两种写法。

这不是什么很高级的东西，但这是这种项目里很典型的小脏活。

结语

这个方案我觉得比较舒服的一点是，它完全向后兼容且 type-safe。我 git 上提交的 dimensions 文件是一个空的 {}，而每当在 vercel / netlify 上 build 的时候就会去尽可能地 fetch 这些图片并记录每一个图片 url 对应的宽高。

给 CPython 擦屁股

2025-06-17T19:03:34.000Z

6 月份我个人生活上发生了一些不幸的事情，加上期末毕业季各种事务堆得我完全透不过气，我度过了充斥着绝望、内耗、颓废的十几天，宛如十年。

纵使这期间我极其低产，我还是艰难地推进 hmr 修复了几个硬骨头 bugs。编程的时候可以短暂地让脑子转起来而且一定程度上忽视这个现实世界，这让我很舒服。

前几天参加了 AdventureX 的一个预热活动，一次在深圳开展的 BuilderUp 活动，其实就是一个无主题的创业者分享会。我本来想推销一下 hmr，正好 hmr 也算 stable 了，于是就开了有史以来最大的 PR 把 reactivity 分支（历经半年，154 次提交）合并进来了：Pull Request #319 · promplate/pyth-on-line，但是后来其实也没用上。当然活动是超级棒的，玩的很开心。久旱逢甘霖。

今天这篇随笔就是介绍下我最新处理的的一个 bug，它源于一个 CPython 搁置的 Issue:

Issue #121306 · python/cpython 是我一年前给 CPython 提的一个 Issue，大意是，在这种情况下：

class _:
    print(a)

访问 a 并不会遵循 locals -> globals -> builtins 这样的顺序：如果 globals 不是一个纯 dict 而是一个 dict 的子类，即使 a 存在，也会访问不到（报 NameError 错误）。

虽然 core devs 的回复说，就是不让 globals 是 dict 的子类的。但事实上除了 ClassDef 中访问全局变量这一个 case 之外，其它都运行得好好的。

说起来，后来我发现其中回复我的 @gaogaotiantian 就是编程区 up 主码农高天

我自己个人也是在很多情况下使用了这个 feature，比如我最常用的 case 就是用一个 ChainMap 作为 globals，来实现上下文管理。用于模板渲染、monkey patching 等场景。但这些场景一般不会遇到 ClassDef 语句，所以这个 Issue 对我的影响一直蛮有限的。

直到我要在 hmr 中实现函数级热重载。

通常我们说热重载，hmr 中的 m 指的是 module，也就是说重新运行的最小单位是一个模块。但写 Python 的人比较懒，而我又总是惯着别人，on the other hand 我也喜欢炫技，所以也实现了一个比较 hacky 的函数级热重载：

它基本上表现就像用 functools.cache 装饰无参的函数
当其中访问到的全局变量 / 别的模块的变量 invalidate 时，标记为脏
当这个函数源代码改变时，标记为脏

问题就在，它需要追踪访问全局变量。这本并不难，因为我已经实现了一个 ReactiveProxy 类，会通过 __getitem__ 记录所有变量的取值，但由于 CPython 的这个 bug 存在，我没法在被我标记的函数里创建 class（更准确说，是创建 class 并在 class 的 frame 中访问全局变量）。由于我 hmr 这个库是希望做到尽可能对用户无感，所以肯定是要支持所有用法的。在函数中创建 class 显然是常见的用法。

经过漫长的思索，我发现唯一的 userland solution 就是修改 AST，比如把上面的例子编译成：

class _:
    try:
        a = locals()["a"]
    except KeyError:
        try:
            a = globals()["a"]
        except KeyError:
            raise NameError("a") from None
    print(a)

换句话说，就是手动从 gloabls() 和 locals() 中拿这个值。这样确保了我们自定义的 __getitem__ 一定会被触发。

这其实是一个过度简化的例子（因为其实 print 也应该进行这样的取值。而且也要除了 locals() 和 globals() 外还应该尝试 __builtins__ ，可能还要尝试外层 frames 的闭包变量）

实现

LLM 比我更熟悉 Python 的 AST 用法。而且我需求也挺清晰，于是这部分元编程就先交给各类 vibe coding 工具来做，我提思路和小的修改，迭代一二十次差不多就成了。我又清理和重构了下，目前的核心实现大概是这样：

import ast
from inspect import cleandoc
from typing import override


class ClassTransformer(ast.NodeTransformer):
    @override
    def visit_ClassDef(self, node: ast.ClassDef):
        traverser = ClassBodyTransformer()
        node.body = [
            name_lookup_function,
            *map(traverser.visit, node.body),
            ast.Delete(targets=[ast.Name(id="__name_lookup", ctx=ast.Del())]),
            ast.parse(f"False and ( {','.join(traverser.names)} )").body[0],
        ]
        return ast.fix_missing_locations(node)


class ClassBodyTransformer(ast.NodeTransformer):
    def __init__(self):
        self.names: dict[str, None] = {}  # to keep order for better readability

    @override
    def visit_Name(self, node: ast.Name):
        if isinstance(node.ctx, ast.Load) and node.id != "__name_lookup":
            self.names[node.id] = None
            return build_name_lookup(node.id)
        return node

    @override
    def visit_FunctionDef(self, node: ast.FunctionDef):
        node.decorator_list = [self.visit(d) for d in node.decorator_list]
        self.visit(node.args)
        if node.returns:
            node.returns = self.visit(node.returns)
        return node

    visit_AsyncFunctionDef = visit_FunctionDef

    @override
    def visit_Lambda(self, node: ast.Lambda):
        self.visit(node.args)
        return node


def build_name_lookup(name: str) -> ast.Call:
    return ast.Call(func=ast.Name(id="__name_lookup"), args=[ast.Constant(value=name)])


name_lookup_function = ast.FunctionDef(
    name="__name_lookup",
    args=ast.arguments(),
    body=ast.parse(
        cleandoc("""

            from inspect import currentframe
            from collections import ChainMap

            f = currentframe().f_back.f_back
            l, e, g, b = f.f_locals, {}, f.f_globals, f.f_builtins

            if freevars := f.f_code.co_freevars:
                freevars = {*f.f_code.co_freevars}
                while freevars:
                    f = f.f_back
                    for name in f.f_code.co_cellvars:
                        if name in freevars.intersection(f.f_code.co_cellvars):
                            freevars.remove(name)
                            e[name] = f.f_locals[name]

            ns = ChainMap(l, e, g, b)

            def lookup(name):
                try:
                    return ns[name]
                except KeyError:
                    raise NameError(name) from None

            return lookup

        """)
    ).body,
    decorator_list=[ast.parse("lambda f: f()").body[0].value],
)

简单来说，就是首先注入一个固定的 __name_lookup 函数，首先获得 class 所在的 frame，然后依次尝试 f_locals、闭包变量、f_globals、f_builtins，并在 class 的结尾删掉这个 __name_lookup 函数。

其中比较奇怪的一点是，我用了一个 @lambda f: f() 装饰器，这个装饰器本质上是“当场执行这个函数并把结果赋值为这个函数的名字”的意思。也就是说，其实我这个 __name_lookup() 其实是一个 __name_lookup(name) 的工厂函数。为了最小化对定义域的污染，我让这个工厂函数也叫 __name_lookup() 了，但其实它所返回的 lookup(name) 函数才是最终在这个 class 的定义域里的 __name_lookup 函数的真正实现。

另一个比较奇怪的点是，我在最后构造了一个 False and (name1, name2, name3) 这样的表达式，这是为了：

如果没有直接取这些值的语句，python 就不会把这些值添加进 co_freevars 于是我们就没法进行闭包的解析（也就是 LEGB 的 E 没法正确获得）

False and 是为了让后面的表达式永远不会执行（要是执行了我们 __name_lookup 这么绕一大圈就白费了）

接下来递归地把所有 ast.Name 都变成 __name_lookup(...) 这样的调用，就完成啦。编译上面的例子的结果就是：

class _:
    @lambda f: f()
    def __name_lookup():
        from inspect import currentframe
        from collections import ChainMap

        f = currentframe().f_back.f_back
        l, e, g, b = (f.f_locals, {}, f.f_globals, f.f_builtins)

        if (freevars := f.f_code.co_freevars):
            freevars = {*f.f_code.co_freevars}
            while freevars:
                f = f.f_back
                for name in f.f_code.co_cellvars:
                    if name in freevars.intersection(f.f_code.co_cellvars):
                        freevars.remove(name)
                        e[name] = f.f_locals[name]

        ns = ChainMap(l, e, g, b)

        def lookup(name):
            try:
                return ns[name]
            except KeyError:
                raise NameError(name) from None

        return lookup

    __name_lookup('print')(__name_lookup('a'))

    del __name_lookup
    False and (print, a)

完成啦 🥂 你学会了吗 :)

P.S. 本文在 2025年8月28日修正了一下，实现了正确的 LEGB 解析。凌晨做了很多很多 debug，气死我了。其实是因为 LLM 之前写的代码有坑（而且它还挺 consistent 的，没法自己 debug）…… 总之后来终于修复啦，于是这篇文章中的后两个代码块都是更新过了的，可以直接调用~

无心插柳柳成荫

2025-08-08T00:38:53.000Z

因为我自己维护了一个类似 OpenRouter 这样的代理平台，所以我用各种 AI 应用的时候都会关注能否用自己的 OpenAI Compatible API。前段时间发现 GitHub Copilot 似乎不支持。

本来以为这是故意不让你通过这种方式去获取它的 prompt，后来发现它也允许本地的 ollama 服务，所以应该不是这个原因。而且没过多久又听说 GitHub Copilot 要开源了……

后来发现了一个 Issue：Add custom OpenAI endpoint configuration (Base URL & Model Parameter) of copilot chat settings · Issue #7518 · microsoft/vscode-copilot-release 就是说的这个问题，但是似乎即便大家提供了 PR 和解法但是官方就是不采用。于是后来发现了一条 comment mock 了 ollama 的 API，我觉得这很好，符合我的“别人不改就我来 patch”的开发精神😂

其实我早就想这么干了，只是自己不用 ollama 的 API 又不想自己去读 ollama 的文档

然后我立马发了个 python 库（其实算是一个 CLI 工具），来实现这个东西，但是通过一行命令就能启动：

uvx oai2ollama --api-key ... --base-url ...

这样就会在 ollama 的 11434 端口启动一个 API 服务，Chat Completions 请求会自动 rewrite 到你提供的 OpenAI Compatible API 服务去。

本来以为这就是一个自用的工具，没想到居然时不时看到有人 fork 有人 star，现在居然有 14 颗 star 了！看来果然是跟 AI 相关的东西就会有 star 涌来啊。唉（有点世风日下的感叹，当然我不是一刀切哈）面向社区的项目无人问津，面向自己的小工具反而有人迹感觉老天在嘲笑我😭

隐患与惊喜并存的 .pth

2025-07-17T13:01:23.000Z

.pth 有个饱受争议的点，就是它允许执行任意代码（参考 site 文档）

.pth 是干嘛的

.pth 文件是一类文本文件，如果放在 site-packages 目录下，python 解释器在启动阶段，会读取并解释其内容。.pth的内容很简单，一行行的，每行只能是以下三者之一：

一个路径，这个路径会被添加到 sys.path 中。 有一定 python 经验的人应该都了解过 sys.path 是什么。简单来说就是加载 module 的根目录列表。
一个 import 开头的语句，这个语句会被 exec() 执行。 本质上其实允许了执行任意代码
一个 # 开头的行，就是注释，跳过。

其中这个第二点就是比较危险，比如有害的第三方库如果骗你安装了，就可以在你每次正常启动 python 时，在执行你常规代码之前，进行一些 monkey patching 的操作

当然你安装一个包当然就是信任它了，所以怪不得别人 😂 只是想提醒大家，你安装一个包之后即使不用命令行或者 import 的方式调用它，它也可能可以让你在不经意间执行它。比起更广为人知的通过 sdist 在 build 阶段执行人代码的安全问题，这个方式更鲜为人知。

但是这篇文章不是想讲这些的，而是想讲讲我发现了这个功能可以有一些很好的用法

好的用途

加载环境变量很讨厌。要么你安装 python-dotenv 然后用 dotenv run 启动你的项目，要么在某个最早调用的模块里调用 dotenv.load_dotenv(override=True)，如果你只想在开发阶段加载 .env（因为生产环境一般直接在平台上设置环境变量，不通过 .env 文件），可能还得放在一个 try-expect 块中，甚至写上这样的模板代码：

from contextlib import suppress

with suppress(ImportError):
    from dotenv import load_dotenv

    load_dotenv(override=True)

多丑陋！而且这样会多出一个令人疑惑的 __init__.py（因为你往往希望尽可能早地进行这个调用）。在我写 hmr 之前，还涉及到一个 overhead 的问题：contextlib 不是一个很轻的标准库。

今天我写了一个超小的库：CNSeniorious000/dotenv.pth: load .env when python starts - GitHub

当你安装了这个库，每次你任何方式启动 python 或者用什么 cli 工具，它都会自动 load 环境变量。这意味着如果你只想在开发环境中加载 .env，你只需要把 dotenv.pth 装在 dev dependencies 中就行了。

另一个例子是，我的 hmr-daemon，它现在还没有任何文档，但我可以在这里简单说一下：

它启动一个 daemon 线程，注册 hmr 中的 ModuleFinder，使得所有当前项目的模块都是 ReactiveModule
但是所有 reload 都在这个线程中执行，所以你看到的效果就是，如果你的代码还在运行，这时候你保存其中某个文件（比如更新一个函数的实现，或者比如更改某个参数），立即就能看到效果

常用的场景是，你想用 python 的 shell（或者 ipython 之类的）来交互式地调试你的项目，但是当你修改项目文件后，你肯定懒得关闭再开启 shell 一遍。

通过 hmr-daemon，你不用重启 shell，所有 from module import value 得到的 value 都是最新的。或者 module.value 这样的也是最新的。

一个坑

开发过程中往往会在虚拟环境中开发，但是将虚拟环境的 site-packages 添加到 sys.path 中的逻辑本身也是通过一个 .pth 文件实现的，它叫 _virtualenv.pth，而 python 执行 .pth 是按字典序执行的，所以如果你的 .pth 文件以 _ 开头，就很可能没法 import 一个在虚拟环境中安装了的包，因为这时候虚拟环境可以说还没别“激活”—— 激活虚拟环境的 .pth 还没执行呢。

debug 终于发现是这个原有的时候还挺搞笑的 😭

总结一下

我认为 .pth 是个很 Pythonic 的特性，很鲜明地展现了 Python 的个性 —— 极高的自定义性。可以用它实现很多提高 DX（developer experience）的小功能。

而且我认为这个东西并没有被人开发得很完全，我想我可能未来也会开发更多基于 .pth 的有意思的库。

比如我现在想到的几个是：

在 Windows 上 Python 开发有个很坑人的点，它文件的默认编码是 GBK 而不是 utf-8，所以到处需要指定。我们可以在 .pth 中 monkey patch 这个

可以监测 .env 的变化，然后随时更新到当前进程的环境变量（不过这个 hmr 本身也快要能实现了：它现在的依赖图不止支持 python 模块也支持任意文件了，正在 reactive-fs 分支积极开发中，说起来这个功能可能最早受启发于这条评论）

像 nested-asyncio 这样的“只暴露一个无参函数”的包，完全可以发布一个 .pth 包，这样不用在代码中显示地 patch，而是在依赖中这么做

…… 能想到的还有很多，但今天挺晚了，我先回去睡觉了

踩了 getsource 的坑……

2025-07-15T09:03:15.000Z

整整半天一直在 debug，一层一层往下排查…… 最后发现问题就在于 getsource() 在 Windows 上有可能即使文件已经改变了但是仍然获得旧的结果……

排查了很久很久，最后发现在写入文件的时候，可能 mtime 的元数据不会那么快更新，或者粒度比较粗，导致修改完代码文件立刻调用 getsource 并不会触发 linecache 重新读取代码文件。也可能是 getsource 的问题

其实并没有把原因完全搞清楚，但已经完全不想管了，毕竟多一事不如少一事，而且人就是这么不求甚解，一旦发现解决问题的办法了，就可能不再追求搞懂它最深层的原因了唉

不过一方面也是因为 python 标准库完全没有类型标注，代码写的比第三方库烂的多……看了污染眼睛

而且这个 bug 只在 Windows 上出现，而且在 GitHub Actions 上基本上每次都能复现，而我在本机上虽然也是 Windows 但基本上每次都不能复现，所以我 debug 的过程就很恶心：必须不停把更多的东西 print 出来，然后 push 到 GitHub 触发 Action……

解决方案

from linecache import cache

if filepath in cache:
    del cache[filepath]

相关的 commit 历史，简直是 debug 血泪史：Commits · promplate/pyth-on-line

为什么不用静态分析来实现 HMR

2025-07-12T15:16:08.000Z

几个月前，我看到 How to build Hot Module Replacement in Python 这篇文章，讲的是用他们的 Tach 这个 Python 静态分析工具，可以获得一个依赖图，类似这样的键值格式：

{
  "a.py": ["b.py", "c.py"],
  "b.py": ["d.py"],
  "d.py": ["e.py"],
  "c.py": ["f.py"]
}

说起来，这个项目上个月开始 unmaintained 了 😅 一问才发现原来是开发者跑去 AI 创业了。我觉得网友说的挺好：
I guess that's the issue with open source tools being backed by VCs. These tools will never be maintained if you can't make tons of money off of them.

然后在每次检测到某个文件更改时，依照依赖图更新（调用 import）它和它所有直接、间接影响的模块，这就时它的大致原理。

问题

Python 开发者通常不喜欢把文件分得太细，所以事实上如果按照它这套技术方案的话，往往每次重载要涉及的文件会很多（甚至任何一个文件都会让整个项目的每个模块都重载）。使用这套解决方案相比通常的冷重载，其实只省下了 import 第三方库的时间和启动 Python 本身的 overhead。这也让这个所有中间状态都丢失了。

另一方面，懒加载和动态的加载也没法通过静态分析获得。

我们的运行时方案

hmr采用截然不同的办法，在运行时记录依赖关系。与tach的静态分析的方式相反，hmr不通过 AST 去分析依赖，而是记录每次 import 了哪些 module，以及用了那个模块中的哪些变量，来决定依赖图。

举个例子，一个文件data.py如下：

a = 1
b = 2
c = a + b  # 3

然后有个文件a.py使用了data.py的值：

from data import a
print(a)

如果是静态分析，会认为a.py依赖于data.py，如果data.py重载了，则a.py也应该重载。

而我们的hmr则支持“更细粒度的反应式”，什么意思呢，它认为a.py只依赖于data.py中的a的值。所以如果这时候更改a.py的b = 2为b = 3，这时候data.a完全没有改变，所以a.py并不会重载。

只有当你修改了a = 1为别的值时，才会触发a.py重新打印 a 的值。同理，如果你的入口文件是c.py其内容如下：

import data
print(data.c)

那么当你改变a或者b的时候（只要a + b的结果变了）那 c 就会变，导致重新打印出data.c出来。

这就是静态分析永远难以企及的细粒度热重载。

原理

其实很简单，本质上，我只要让每次某个 module 被__getattr__了都记录下来就行了。比如，如果a模块触发了b.__getattr__("c")，意味着a.py中肯定存在from b import c或者b.c这样的地方，那么a模块就依赖于b.c。

至于如何自定义 module 的__getattr__，就是普通的元编程了（我在这篇文章中详述过）。简单来说就是实现一个自定义的 ModuleType 子类，然后在sys.meta_path中注册一个 ModuleFinder 就行了。

结语

经过大半年的努力，我真的处理了超级多 edge cases，解决了很多 performance issues，目的就是让所有的魔法都 work transparently，让所有的 dragon 都不用被用户影响。

现在 hmr 作为一个 CLI 已经完全模仿 python 的行为了。比如你平常以python main.py -a --b c这样启动的应用，直接改成hmr main.py -a --b c这样，所有事情应该 just work ~

如果你用 uvicorn 启动 Web 服务，你也可以试试看 uvicorn-hmr，它也是一个 drop-in replacement of uvicorn --reload，直接替换命令即可。我在向后兼容上做的非常小心

包名同 CLI 名，比如 hmr 就是pip install hmr，uvicorn-hmr 就是pip install uvicorn-hmr

最近还做了个有趣的更 hack 的工具，hmr-daemon，它的行为是，pip install hmr-daemon后，什么代码都不用改，但是当你修改某个文件而且此时 python 进程还没退出的话，这个模块就会重载，当然它影响到的模块也会按正确的顺序重载。对于在 REPL 比如ipython中使用你项目中的模块时很有用。

Dependabot 不支持 YAML aliases

2025-05-19T18:45:48.000Z

帮你们试过了。dependabot 的 config file 不支持 yaml 的语法糖。

今天突发奇想，想到既然dependabot.yml里那么多重复的内容，为什么不能利用一下 yaml 的独特的语法糖呢？

然后发现并不行。

sad :(

Astral 终于也来分 pyright 一杯羹了

2025-05-09T16:01:10.000Z

今天发现了 https://github.com/astral-sh/ty

以前就在想，既然 ruff 肯定有一套 python AST 的工具，干嘛不也做个 type checker，今天发现这个项目了哈哈哈冲冲冲相信 Astral 推出必是精品

谈谈推理模型的局限

2025-04-21T11:00:41.000Z

想象一下，现在有一位拿着纸笔的小学生和一个大学牲，站在 LLM（Lots-of Learning Mankind） Evaluation 的舞台上。

第一题，背诵快速矩阵运算 Strassen algorithm 的时间复杂度

小学生学过奥数，知道矩阵乘法是什么，推理说，矩阵乘法乘 n² 次，加 n 次，那时间复杂度就是 O(n³)

大学生学计算机的，背出了正确答案 O(N^{log₂(7)}) ≈ O(N^2.8074)

第二题，以下是两个 10×10 的矩阵，请手算其点积 ……

小学生拿起笔就一行行算了起来，写了几张纸，最后给出了正确答案

大学牲只能心算，奈何 Attention 不够，最后只好放弃，说“对不起，我不能帮你计算矩阵乘法，您可以使用 numpy 进行计算，首先如果没有安装 numpy，先在终端中输入 pip install numpy……”

上面是引入 🤣 但大概就是这个意思。

三月下旬，Anthropic 的 AI 心理学文章 Tracing the thoughts of a large language model 出来之后，大家开始反思推理模型（reasoning models）的推理内容，是否真的有用

从 benchmark 上看是非常有用的，小的推理模型能比大得多的非推理模型提高数倍的分数。加上震惊世界的 R1 告诉大家训练推理模型只要 RL 就可以了，大家对 test-time scaling 的热情一直高居不下。

QwQ 32b 自称在多项任务上超越 R1，我也很心动。但是使用下来看，其实差远了。但当时只觉得很费解，还没能解，就先把这个问题搁置了

几天前收到 GitHub Copilot 收到一封广告邮件 Which AI model should I use with GitHub Copilot，就又开始思考这个问题。回想起前段时间 Grok 3 终于上 API 了，文档里提到：

When to Use Reasoning

Use grok-3-mini for tasks that can benefit from logical reasoning (such as meeting scheduling or math problems). Also great for tasks that don't require deep domain knowledge about a specific subject (eg basic customer support bot).

Use grok-3 for queries requiring deep domain expertise or world knowledge (eg healthcare, legal, finance).

忽然想通了。推理模型增强模型能力的方法，其中真正提高模型表现的部分，直白来说就是 按格式打草稿。举例来说，

乘法计算的时候，列竖式就是按格式打草稿
做遗传题的时候，把每个亲本和子代的基因型一个个推出来就是按格式打草稿
高中数学导数题，有的题要靠逆向去凑的，这种就要猜，然后去否定各种可能性来得到答案，这些猜的 hypotheses 就是草稿
做编程算法题的时候，确定有哪些状态，每一步状态之间怎么转换，这就是打草稿

推理模型在 <think> 的时候，真正有用的部分就是这个过程。所谓强制模型说“Wait, ...”就能提高性能的奇技淫巧，也就是“验算”。本质上跟上面的这几个例子是一个道理。

这种需要形式化多步推理的东西，是模型本身能力再强也只是背题。看我博客的人应该至少都上过高中，知道背题是没用的。有用的是学会什么题要用什么“格式化草稿”来推。所以高中老师经常说高考靠努力，就是因为这不管你是 671b 基座的 DeepSeek R1 还是 9b 基座的 GLM Z1，只要你愿意学怎么打草稿，你们就都在同一个起跑线上

Grok 3 系列有一个便宜 30 倍的小的版本，更快、更便宜、更会做题。这就是小学生。小学生固然有用，但大家不能只吹小学生分多高，也要看到小学生不擅长做什么。

现在看来，小学生尤其擅长做逻辑题、数学题、编程这些方面，但我觉得其实还是少的。很多别的场景，其实也可以“打草稿”，但是现在模型并没有学会这些草稿。我认为这些草稿很关键。

一些进一步的猜测：

R1 论文里说，他们去 RL 的时候就用了答案正确与否、CoT 长度这两个 reward 函数。按照我上面的比喻来看，推理内容（也就是草稿）是否按格式，是一个更好的 reward。但恐怕我这两个月没那么多时间自己推进这些了（我有毕设和比赛，还有各种活😭）

关于 feed 的一些想法

2025-04-17T14:37:20.000Z

今天想到两个关于 feed 的产品的点子。

痛点是，生活中总要浏览很多“订阅”类产品。无论是我订阅的公众号、朋友圈、各种交流群、我订阅的各种 rss 源、甚至各种 app 内的推荐等等。每天都要花很多时间在刷这些东西。

不刷不行，因为可能会错过一些感兴趣的东西（可能占 5%），但是刷的时候很多时间都在重复劳动。比如等加载，比如查单词，比如手动在各种页面和app辗转。

简单来说就是“不想错过”和“刷完太花时间”的矛盾。但这个矛盾其实不必有。

因为刷的过程很大一部分是不需要脑子的。不需要脑子就以为着可以让 AI 替你做。

正好这学期在做一些通用 app 自动化（参考 AutoGLM），我也一直在生活中搜集可以自动化的一些地方（可以让 AI 代替你操作手机，帮你完成的事）。当然由于 AI 不够聪明，所以我认为只能是一些规则类的，不需要什么“主观”判断的东西。我觉得这个就是一个例子。

总的来说，就是我觉得这样的产品是完全可行且至少对我有用的（其实有点类似 iOS 的通知摘要）：

帮我操作手机，定时刷消息刷朋友圈刷订阅号，把内容记录下来
基于一些模糊的规则做基本的筛选（比如不要纯广告）或分类（比如讨论什么产品的是一类，讨论什么社会事件的是一类）
对每条信息做一些浅的探索，给每条消息一些元数据。比如如果是项目可以给出 demo、仓库、文档、技术栈等。比如如果是英文可以预先帮我翻译，比如如果是开源软件可以帮我找一个最小的可运行的 snippets

这其实可以拆成两个产品来做，一个就是纯粹的自动操作手机把各类 app 变成 feed，一个就是在 feed 的基础上做处理。即使没有第一个产品第二个也能做（可以用一些现成的 feed）。

解决 Dependabot 生成 broken uv.lock 的问题

2025-04-13T02:33:52.000Z

昨天我在 Dependabot 的 uv 支持的 issue 下面发了一条评论：

dependabot/dependabot-core#10478 · GitHub

起因是，Dependabot 最近支持更新 uv 的 lockfile 了，但是支持的很不好，总是会给出 broken 的 lockfile，大家就都在下面抱怨。很搞笑的是，大家不知道是不是没看出来其实都是同一个问题，还是想借此机会给自己的项目打广告，很多人在评论中附上自己的项目的 CI 日志，即使这些都是重复的

我昨天的评论，就是在想，既然我本地是可以修复（重建？）这个 lock 文件的，那我为什么不能在 GitHub Actions 里运行？为什么不能在 Dependabot 打开一个 PR 的时候自动地触发修复？

然后我就跟 LLM 简要描述了下，稍加修改就成了。

name: Fix uv.lock for Dependabot

on:
  push:
    branches:
      - "dependabot/uv/**"
  workflow_dispatch:

jobs:
  update-lockfile:
    permissions:
      contents: write
    runs-on: ubuntu-latest
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4
        with:
          ref: ${{ github.ref }}
      - name: Set up Python
        uses: astral-sh/setup-uv@v5
        with:
          python-version: 3.12
      - name: Fix lockfile
        run: uv sync
      - name: Commit and push uv.lock if changed
        run: |
          git config --global user.name 'github-actions[bot]'
          git config --global user.email 'github-actions[bot]@users.noreply.github.com'

          # Check if uv.lock was modified or created
          if git diff --quiet --exit-code uv.lock; then
              echo "uv.lock is up-to-date."
          else
              echo "uv.lock changed, committing updates."
              git add uv.lock
              git commit -m "fix `uv.lock` after dependency update"
              git push origin HEAD:${{ github.ref_name }}
          fi

当然，还是我一直以来的观点：

LLM 辅助编码的上限是你的能力

比如我有一些碰壁的经历，让我知道：

提交到github.ref会导致一个很奇怪的 bug，GitHub 会以 Dependabot 的身份把你的那个 ref merge 过来。虽然我上面的代码中最后是提交到github.ref_name，但这是我改的，LLM 生成的不是这样
LLM 忘记了permissions: { contents: write }
LLM 让我在 job 里的if:语句中判断是不是 Dependabot 的请求。事实上在on:中去 filter 更好

鲁棒地编码

我觉得过了这么久，我现在发现我有一个经验，就是尽量把代码解耦合，就能让 debug 容易很多。

比如，我有的代码，给每个幂等的函数结果都用 diskcache 缓存下来，这样调试的时候就会快很多，也会便宜很多（当代码需要一些LLM请求时）。这也使得复现更容易了。

当然，用 hmr 会更高效，因为它的 invalidate 是 on-demand 的，而且不涉及重启进程。不过 hmr 0.3 我引入了一些 bug 到现在还没修复哈哈哈

Don't Repeat Yourself

2025-04-09T11:58:23.000Z

Don't repeat yourself (DRY) 原则是一项主张，支持在代码出现重复的时候就进行封装，增加复用。我本人对这个观点是非常支持和贯彻的，甚至到了一种，我对它的副作用深有体会的地步。那先说说它有什么副作用：

很可能为了复用需要写更多的代码。比如为了复用一个一行的算式，花了三四行新建了一个有三四个参数的函数，代码量不减反增
过早优化。很可能封装完之后很快又删了 / Ctrl Z 回去了，白白浪费时间
有时封装过多会造成 debug 更困难

那它有什么好处呢？除了大多数时候能精简代码，我认为还有一个很重要的点，其实是不用担心同步的问题。一处更改，每个用到的地方都会同步。

以 bump version 为例

一个例子是指定 version。不像在 JavaScript 中，可以直接通过import { version } from "../package.json"来获得包的版本，Python 中要让版本号能在pyproject.toml中有，同时在代码中能读取略微麻烦一些。可能需要花几行配置，或者自己用十来行代码来实现。

有的人可能就会觉得，比起搞这些，更愿意每次 bump version 的时候手动改这两个地方。单纯从数量上来看，每次 bump version 也就改动一个字符。避免在pyproject.toml和代码中同时改也就让每次减少了一个字符。如果为此花了 4 行代码的话，假设行 10 个字符，那要发 40 个版本才能赚回来。

但我认为，事实上 repeating yourself 的坏处不只是要敲更多的代码，而且在整个链路上（review、blame、debug……）每个步骤都更麻烦。

这些心智代价是每次 bump version 都要担负的。所以相当于有O(n)的复杂度。而配置自动同步这两者，是O(1)的。这就是我的理由。

lockfile 的例子

我的项目有一点和主流唱反调的地方，就是我不喜欢把 lockfile 提交到仓库中。尽管 lockfile 纳入 version control 算是行业共识了，我还是不喜欢这样。我直观地有这些理由：

很大，以至于仓库的大小简直就是 lockfile 的大小
diff 很多，直接让每个 PR 的大小没法直观地通过行数来看了。而且有时候会 conflict
会搞乱 GitHub 的 Inspect 页面中对不同贡献者的对比，因为一个 lockfile 往往比整个项目的其它代码都多好几倍。我看过一些项目，Dependabot 排在维护者头像的前面。因为它对仓库的贡献（由行数统计）更大
某些包管理器（比如 pdm）主张平台特定的 lockfile，我不敢苟同

还有一个和 DRY 原则类似的原因：

可能会忘记更新 lockfile，所以造成了 O(1) 的认知复杂度

当然哈，其实这些问题肯定都有解决方案，比如可以手动去掉 lockfile 再统计行数，比如 lockfile 的更新可以放到 pre-commit 中去自动化。但是终究还是不方便。最后

我选择信任。我纳入为 dependencies 的项目一定都是我选择出来的项目，这些项目我相信他们会采用 SemVer，所以我在项目元文件（package.json / pyproject.toml / Cargo.toml）中锁定好项目依赖，就足够了

认知复杂度

突然自创了这个词，我也很惊讶哈哈。那正好就谈一谈我的这个看法吧。

举一个例子：我一直看好 Rust，是因为我觉得这样的一个底层语言才是一个成熟的底层语言。它有包管理、有高级的抽象（有 typing 的宏），使得它在项目长大的时候能维持认知复杂度

我觉得就像衡量一个算法对某个任务可不可用，可以通过时间复杂度、空间复杂度。我认为一个项目能否做下去，可以用认知复杂度。

我这里的定义就是是，衡量认知压力随项目大小的增长而增长的倍率。这个自变量和因变量都是很抽象的，所以我所说的也都是定性的结论——甚至不能算结论，只能算思考。

比如，如果某个改变，使得之后每次提交代码都要花时间一定考虑某件事，这相当于是O(n)的复杂度。一个例子是前面提到的 versioning，一个更好的例子可以是 i18n —— 一旦你的项目上了 i18n 从此你每次更新文档，都得更新每个语言的文档
如果某个改变使得之后每次提交要做更多的考虑，甚至这个考虑的增量也会随着仓库的增大而增大，那这相当于是O(n²)的复杂度。比如文档。以前端框架 Astro 为例。Astro 的文档做得很好，以至于它需要有一个文档来指导开发者维护文档。他们把这个“元文档”叫做 Astro Docs Docs (AD²)

当一个项目引入了让认知复杂度增长的改动之后，它的开发效率就会大大降低。所以，我的原则是，尽量不要在一个项目的 actively developing 阶段引入这样的改动（除非你吸引到了增长的维护者群体）

弱主张

为什么今天突然想写这个主题，因为我发现其实我有时候也会对 DRY 原则做一些妥协，他们其实是一脉相承的。DRY 像是一个“强主张”，要求永远不 repeat yourself。但我在一些场景不能拒绝 lockfile 带来的好处，比如 pyodide-minimal-reproduction 是我写给 pyodide 的一个 stackblitz reproduction template，方便人们给 pyodide 提交 bug reproduction。我希望用户在 stackblitz 的环境中尽可能快地安装依赖，所以我写了个 GitHub Action 给每个分支提交一个<原分支名>-locked分支，包含一个生成的pnpm-lock.yaml文件。

这就是我提出的弱化版 DRY 原则 —— 你不要自己 repeat yourself，但不反对让 bots 来 repeat 你。

另一个例子就是让 Dependabot / Renovate 这些 bots 来更新依赖。

其实有的时候，某个项目的依赖我不信任，或者我可能要不再维护了，我希望它在未来还能被复现，我也会按照常规的方法在仓库里维护一个 lockfile。我也深受其利。但这些项目我从内心会觉得它“脏了”，不再是那么优雅了。哈哈哈

关于 HMR 的实现

2025-01-10T12:09:43.000Z

上期谈到，我在 Python 实现了反应性原语，然后又实现了 HMR，但是没细讲，这次写一下从反应性原语到 HMR 是怎么实现的。

我也新开了个仓库，未来放 hmr 生态的东西（如果社区有反响的话），不过由于这算是临时起意中的临时起意（歪楼项目中的歪楼项目），所以代码还是在原仓库中没有拿出来。这个仓库目前就是一个 README 哈哈哈

如果想要直观理解 hmr 对 Python 到底意味着什么，可以看看这个仓库里的两个视频，另外我还分别给 FastAPI 和 Flask 开了 Discussion，分别也附上了精致的录屏，欢迎来下面讨论：

FastAPI | Flask （我还准备给 gradio、streamlit、pytest、litestar 也提一下）

不过没时间了，明天我要回家了，所以先不急着搞了

怎么实现的

正如我仓库中所说，HMR 实现可以拆成三部分：

实现那几个反应性原语
让加载进来的包，能自动跟踪依赖
1. 实现一个 Reactive 的 context（按 item 追踪依赖）
2. 实现一个自定义的 ModuleType，使用这个 Reactive 的 context
3. 实现一个 Loader 以及一个 MetaPathFinder，并添加到sys.meta_path中，这样新加载进来的模块就会用我们的机制来初始化
通过watchfiles监听 FS 变化，并 invalidate 对应的 module

其中第 3 部分正如其字面意思，很简单，就是 watchfiles 的基本用法，没什么创意。本文重点讲第二部分

Reactive namespace

我们需要实现一个 MutableMapping，类似 Vue 的 reactive，每个__getitem__会触发对应 item 的 track，而__setitem__和__delitem__会触发对应 item 的 notify。实现如下：

class Reactive[K, V](Subscribable, MutableMapping[K, V]):
    UNSET: V = object()  # type: ignore

    def __hash__(self):
        return id(self)

    def _null(self):
        return Signal(self.UNSET, self._check_equality)

    def __init__(self, initial: Mapping[K, V] | None = None, check_equality=True):
        super().__init__()
        self._signals = defaultdict[K, Signal[V]](self._null) if initial is None else defaultdict(self._null, {k: Signal(v, check_equality) for k, v in initial.items()})
        self._check_equality = check_equality

    def __getitem__(self, key: K):
        value = self._signals[key].get()
        if value is self.UNSET:
            raise KeyError(key)
        return value

    def __setitem__(self, key: K, value: V):
        with Batch():
            self._signals[key].set(value)
            self.notify()

    def __delitem__(self, key: K):
        state = self._signals[key]
        if state.get(track=False) is self.UNSET:
            raise KeyError(key)
        with Batch():
            state.set(self.UNSET)
            self.notify()

    def __iter__(self):
        self.track()
        return iter(self._signals)

    def __len__(self):
        self.track()
        return len(self._signals)

    def __repr__(self):
        self.track()
        return repr({k: v.get() for k, v in self._signals.items()})

    def items(self):
        self.track()
        return ({k: v.get() for k, v in self._signals.items()}).items()

可以看到我还多做了一些处理：比如这个 mapping 本身也是一个 Subscribable，像是对.items的使用就会订阅它的全部改动（可以这么理解：如果我直接str()了某个 module 的.__dict__，我就依赖于它的所有元素）

一些细节

exec 的时候，globals 必须是 dict 的子类，但是我们这个 Reactive 不能是 dict 的子类，因为一个 Subscribable 必须是能添加到一个 set 里的，而 set 里不能是可变元素，好像这与 dict 冲突了（所以我必须得加一个__hash__函数）。另外后来文档说 globals 甚至不能是 dict 子类，必须得是 dict 严格本身（否则我发现会有一些奇怪的问题，关于在类中的定义域啥的），详见我给 CPython 的唯一一个 Issue：121306（说起来 3.14 有望 revert 这个，不知道他们后面争论的怎么样了）

说回来，globals 必须是严格 dict，所以我们只能把这个 Reactive 作为locals传过去，但是 locals 不会继承到函数里，所以还得把对我们这个Reactive的写入，写回到这个initial里去。

class NamespaceProxy(Reactive[str, Any]):
    def __init__(self, initial: MutableMapping, check_equality=True):
        super().__init__(initial, check_equality)
        self._original = initial

    def __setitem__(self, key, value):
        self._original[key] = value
        return super().__setitem__(key, value)

    def __delitem__(self, key):
        del self._original[key]
        return super().__delitem__(key)

Reactive module

这个就 debug 麻烦。print 的时候还会有各种循环访问的报错，总之就是很痛苦，跑通了就再也不想碰了：

class ReactiveModule(ModuleType):
    def __init__(self, file: Path, namespace: dict, name: str, doc: str | None = None):
        super().__init__(name, doc)
        self.__is_initialized = False
        self.__dict__.update(namespace)
        self.__is_initialized = True

        self.__namespace = namespace
        self.__namespace_proxy = NamespaceProxy(namespace)
        self.__file = file

    @property
    def file(self):
        if is_called_in_this_file():
            return self.__file
        raise AttributeError("file")

    @memoized_method
    def __load(self):
        code = compile(self.__file.read_text("utf-8"), str(self.__file), "exec", dont_inherit=True)
        exec(code, self.__namespace, self.__namespace_proxy)

    @property
    def load(self):
        if is_called_in_this_file():
            return self.__load
        raise AttributeError("load")

    def __dir__(self):
        return iter(self.__namespace_proxy)

    def __getattribute__(self, name: str):
        if name == "__dict__" and self.__is_initialized:
            return self.__namespace
        return super().__getattribute__(name)

    def __getattr__(self, name: str):
        try:
            return self.__namespace_proxy[name]
        except KeyError as e:
            raise AttributeError(*e.args) from e

    def __setattr__(self, name: str, value):
        if is_called_in_this_file():
            return super().__setattr__(name, value)
        self.__namespace_proxy[name] = value

这里用到一个_is_called_in_this_file，其实就是判断调用者的 frame 是不是在这个文件中：

def is_called_in_this_file() -> bool:
    frame = currentframe()  # this function
    assert frame is not None

    frame = frame.f_back  # the function calling this function
    assert frame is not None

    frame = frame.f_back  # the function calling the function calling this function
    assert frame is not None

    return frame.f_globals.get("__file__") == __file__

为什么要这样，因为我这个load必须得在后面的ModuleFinder里调用，所以不能是双下划线大头的__load形式，但是如果是_load或者load都容易与模块的真实的属性冲突，所以我就做了这么一个 hack，实现了类似“package-private 级变量”的效果，我对这个还蛮洋洋得意的，哈哈哈

Module finder & loader

class ReactiveModuleLoader(Loader):
    def __init__(self, file: Path, is_package=False):
        super().__init__()
        self._file = file
        self._is_package = is_package

    def create_module(self, spec: ModuleSpec):
        namespace = {"__file__": str(self._file), "__spec__": spec, "__loader__": self, "__name__": spec.name}
        if self._is_package:
            assert self._file.name == "__init__.py"
            namespace["__path__"] = [str(self._file.parent)]
        return ReactiveModule(self._file, namespace, spec.name)

    def exec_module(self, module: ModuleType):
        assert isinstance(module, ReactiveModule)
        module.load()


class ReactiveModuleFinder(MetaPathFinder):
    def __init__(self, includes: Iterable[str] = ".", excludes: Iterable[str] = ()):
        super().__init__()
        self.includes = [Path(i).resolve() for i in includes]
        self.excludes = [Path(e).resolve() for e in excludes]

    def _accept(self, path: Path):
        return path.is_file() and not is_relative_to_any(path, self.excludes) and is_relative_to_any(path, self.includes)

    def find_spec(self, fullname: str, paths: Sequence[str] | None, _=None):
        if fullname in sys.modules:
            return None

        for p in sys.path:
            directory = Path(p).resolve()
            if directory.is_file():
                continue

            file = directory / f"{fullname.replace('.', '/')}.py"
            if self._accept(file) and (paths is None or is_relative_to_any(file, paths)):
                return spec_from_loader(fullname, ReactiveModuleLoader(file), origin=str(file))
            file = directory / f"{fullname.replace('.', '/')}/__init__.py"
            if self._accept(file) and (paths is None or is_relative_to_any(file, paths)):
                return spec_from_loader(fullname, ReactiveModuleLoader(file, is_package=True), origin=str(file), is_package=True)

很常规，很无聊

Reload

核心是我这个on_events，因为 watchfiles 的 watch 和 awatch yield 出来的 events 都长这样，就只用写一份了。

目前只考虑了 modified 事件。其他的情况是未定义的哈哈哈

def on_events(self, events: Iterable[tuple[int, str]]):
    from watchfiles import Change

    if not events:
        return

    path2module = get_path_module_map()

    with batch():
        for type, file in events:
            if type is Change.modified:
                path = Path(file).resolve()
                if path.samefile(self.entry):
                    self.run_entry_file.invalidate()
                elif module := path2module.get(path):
                    try:
                        module.load.invalidate()
                    except Exception as e:
                        sys.excepthook(e.__class__, e, e.__traceback__)

        for module in path2module.values():
            try:
                module.load()
            except Exception as e:
                sys.excepthook(e.__class__, e, e.__traceback__)
        self.run_entry_file()

这里用到一个.invalidate()，包括前面也用到一个memoized_method，这个确实还没讲，但其实就是createMemo一样的。

我这里其实是把 memoized 当“惰性的 effect”用了，可以看到，我invalidate 修改的模块，然后每个模块都 call 一下 load，保证它是最新的，其中的缓存啥的就交给机制了，测试了半天最后终于没问题了

Memoized

而其中createMemo其实就是惰性的一个derived这样的意思。我觉得 memoized 更强调了这种惰性感，所以没用 Derived 这个词：

class Memoized[T](Subscribable, BaseComputation[T]):
    def __init__(self, fn: Callable[[], T]):
        super().__init__()
        self.fn = fn
        self.is_stale = True
        self.cached_value: T
        self._recompute = False

    def trigger(self):
        self.track()
        if self._recompute:
            self._recompute = False
            self._before()
            try:
                self.cached_value = self.fn()
                self.is_stale = False
            finally:
                self._after()
        else:
            self.invalidate()

    def __call__(self):
        if self.is_stale:
            self._recompute = True
            self.trigger()
            assert not self._recompute
        return self.cached_value

    def invalidate(self):
        if not self.is_stale:
            del self.cached_value
            self.is_stale = True

memoized_method 其实就是在这外面包裹了一层 descriptor 而已：

class MemoizedMethod[T, I]:
    def __init__(self, method: Callable[[I], T]):
        super().__init__()
        self.method = method
        self.map = WeakKeyDictionary[I, Memoized[T]]()

    @overload
    def __get__(self, instance: None, owner: type[I]) -> Self: ...
    @overload
    def __get__(self, instance: I, owner: type[I]) -> Memoized[T]: ...

    def __get__(self, instance: I | None, owner):
        if instance is None:
            return self
        if memo := self.map.get(instance):
            return memo
        self.map[instance] = memo = Memoized(partial(self.method, instance))
        return memo

唉，实在没什么时间，要回去睡觉了，所以写的很匆忙，简直什么都没写，不管了

结语

正如我在那个 hmr 仓库里写的，生态最重要，我还没找 pytest（因为我不太会做 pytest plugin，所以没法给他们一个很吸引人的 demo），目前找了 FastAPI 和 Flask，其中 FastAPI 底下有个 uvicorn 的维护者评论了我几句，提醒了我我没考虑静态文件的读取：

https://github.com/fastapi/fastapi/discussions/13192#discussioncomment-11796729

反应式编程，但是 Python

2025-01-04T09:50:02.000Z

认识我的人或多或少应该都知道，我的理想之一就是把 JavaScript 的开发体验赋能 Python。marimo 做的不错，但是我这种追求细节的人不止于此，所以自己实现一套反应式编程是逃不过的（另外也是因为，搜了一圈，似乎 Python 真没这种东西）

昨天在床上一时兴起，了解了一下 signal 的这种风格的观察者模式，然后让 GPT 用 python 实现了一遍。今天考完试就立马来试了下，感觉还不错。

是不是很熟悉的感觉？

我的目的是，让使用方式尽量 pythonic，比如上面的代码中：

from reactivity import State

class Counter:
    value = State()

value看起来是个类变量，但其实是个 descriptor，是类似property这样的东西。所以在类里类外都可以像访问普通的变量一样访问它，类似c.value``self.value都是可以的，而且类型检查器友好，完全泛型化。

实现如下：

class State[T]:
    def __init__(self, initial_value: T = None):
        self._value: T = initial_value
        self.subscribers = WeakSet[Callable[[], Any]]()

    def get(self):
        for computation in _current_computations:
            self.subscribers.add(computation)
            computation.dependencies.add(self)
        return self._value

    def set(self, value: T):
        self._value = value
        if _batches:
            _batches[-1].callbacks.extend(self.subscribers)
        else:
            for subscriber in self.subscribers:
                subscriber()

    def __get__(self, instance, owner):
        return self.get()

    def __set__(self, instance, value: T):
        self.set(value)

_current_computations = []
_batches = []

Computation 的实现如下：

class Computation[T]:
    def __init__(self, fn: Callable[[], T], auto_run=True):
        self.fn = fn
        self.dependencies = WeakSet[State]()

        if auto_run:
            self()

    def __call__(self):
        self.dependencies.clear()  # clear old dependencies
        _current_computations.append(self)
        value = self.fn()
        last = _current_computations.pop()
        assert last is self  # sanity check
        return value

    def dispose(self):
        for dep in self.dependencies:
            dep.subscribers.remove(self)

很简单吧，但是其实没有做什么 cleanup 之类的。

然后 batch 的实现如下：

class Batch:
    def __init__(self):
        self.callbacks: list[Callable] = []

    def __enter__(self):
        _batches.append(self)

    def flush(self):
        callbacks = set(self.callbacks)
        self.callbacks.clear()
        for callback in callbacks:
            callback()

    def __exit__(self, *_):
        last = _batches.pop()
        assert last is self
        self.flush()

这控制了什么时候会触发回调。使用上也很方便，直接

with Batch():
    ...

就好了，所有的 callbacks 会在退出这个块的时候执行。

另外，我还实现了一些函数式编程的工具，比如：

from collections.abc import Callable
from functools import wraps
from typing import overload

from .memo import Memoized, MemoizedProperty
from .primitives import Batch, Computation, State


def create_signal[T](initial_value: T = None) -> tuple[Callable[[], T], Callable[[T], None]]:
    signal = State(initial_value)
    return signal.get, signal.set


def create_effect[T](fn: Callable[[], T], auto_run=True):
    return Computation(fn, auto_run)


def create_memo[T](fn: Callable[[], T]):
    return Memoized(fn)


def memoized_property[T, Self](method: Callable[[Self], T]):
    return MemoizedProperty(method)


@overload
def batch() -> Batch: ...
@overload
def batch[**P, T](func: Callable[P, T]) -> Callable[P, T]: ...


def batch[**P, T](func: Callable[P, T] | None = None) -> Callable[P, T] | Batch:
    if func is not None:

        @wraps(func)
        def wrapped(*args, **kwargs):
            with Batch():
                return func(*args, **kwargs)

        return wrapped

    return Batch()

batch不仅可以with这样用，也能@batch这样作为一个装饰器来用。

留点悬念。这里面还有用到两个create_memo和memoized_property没讲

Python venv injection

2025-04-03T18:15:51.000Z

对我来说，这是很常见的一种情况：

你的一个库，要运行一些用户的 python 的代码文件。

对我个人来说，我在 3 种情况中遇到了这个问题：

m 这个库，支持注册 plugin，plugin 就是在当前目录或任何sys.path中的目录创建 m/commands 文件夹，在里面的文件夹暴露一个 app。这里面的代码会被暴露为一个 entry point

hmr 这个库，会运行用户的文件，其衍生品uvicorn-hmr会执行用户的某个 entry point

embed 这个库，会执行用户 pull 下来的 app，这个 app 可能有单独的虚拟环境

最简单的解决办法就是读进来exec对吧，当然你有点经验的话就知道这样对 traceback 不友好。比较正确的办法是用runpy.run_path

但是还会遇到一个问题：

用户如果这个文件用到一些包，而这些包不在你安装你这个库的环境中，导致在你的库的 python 进程中会 import 失败

最好的办法当然是在用户侧解决，比如在用户的项目中安装你这个库，但是

可能这是一个开发工具，用户不太愿意往项目中引入开发依赖
终归还是得让用户多做一步

IPython 的解决方案

如果你用过 ipython，你会发现如果你在一个没有安装 ipython 的虚拟环境中运行 ipython（你在外部安装了 ipython），它照样能 import 你虚拟环境中的包，但是会有一行 warning：

UserWarning: Attempting to work in a virtualenv. If you encounter problems, please install IPython inside the virtualenv.

去翻源码，能看到是在这里警告的。会出现什么 problems 呢，如果你 import 一些非纯 python 库，确实有可能出问题。复现的方式，就是你安装 ipython 的 python minor version 和虚拟环境的 python 不一样。

源码也给出了答案，让你能 import 虚拟环境的库是靠把虚拟环境的 site-packages 也添加到当前 python 进程的 sys.path 中解决的

我也在我的m中实现了这个逻辑，来支持运行用户在项目中定义的 m 插件，相关代码如下：

if os.getenv("VIRTUAL_ENV") and (venv_python := shutil.which("python")) and not Path(venv_python).samefile(sys.executable):
    from site import addsitepackages
    from subprocess import run

    site_packages: list[str] = eval(run([venv_python, "-c", "import site; print(repr(site.getsitepackages()))"], capture_output=True, text=True, check=True).stdout)

    path.extend(site_packages)
    addsitepackages(set(site_packages))

和 IPython 有一点区别，它是把 site-packages 与 VIRTUAL_ENV 的相对路径写死了，考虑了 Windows 和 unix 的可能性。但我不喜欢这样，我是通过在 subprocess 中执行site.getsitepackages()来获得的。这样理应更鲁棒，而且我也曾经在 pdm 的源码中看到过大量类似的使用。

更好的解决方法

我不满足于实现类似 IPython 的这种 workaround。我之前在参与 embed-ai/embed 的时候就在想，其实可以在对应的虚拟环境中启动 python，然后将自己这个库加到它的虚拟环境中再启动。这样的效果应该和“在那个虚拟环境中安装这个库”是一样的（如果我们这个库和它的依赖都是纯 Python 的）。

于是我就修改了下我的代码，在这段subprocess.run中也返回一下sys.version_info，代表 python 的版本，检查如果和当前进程不符的话就用虚拟环境的 python executable 来重新执行自己。

但是这样其实启动了两次 subprocess，并不符合我追求极致性能的惯例。转念一想，其实既然都要用 subprocess 了，不如第一次也不用了，只要用户在虚拟环境中，就一定用虚拟环境的 Python

if os.getenv("VIRTUAL_ENV") and (venv_python := shutil.which("python")) and str(Path(venv_python)) != sys.executable:
    from site import getsitepackages
    from subprocess import run

    s = set(getsitepackages())
    exit(
        run(
            [
                venv_python,
                "-c",
                f"import site,sys; sys.argv={['m', *sys.argv[1:]]}; sys.path.extend({[*s, str(Path(__file__, '../' * 3).resolve())]}); site.addsitepackages({s}); from m.cli.main import app; app()",
            ]
        ).returncode
    )

源文件在这里：utils/inject.py · CNSeniorious000/m

隐患

这样的问题在于，执行你的库的环境可能不是安装你的库的环境。这意味着如果你这个库有非纯 Python 的依赖，就很可能会报错（除非恰好用户的虚拟环境中也装了你的这个依赖）。

关于我给博客加了 llms.txt 以及我的数字永生计划

2025-03-17T11:50:42.000Z

当别人问起为什么我愿意花时间写博客，因为

我有不少奇怪的想法

想法逐一向不同人讲述，不高效，甚至不可行

在 LLM 出现之前，可能得手动构建复杂的知识图谱，才能记录下这些内容

但在现在，只要有数据了，不要求太结构化，都可以很容易地用 RAG 或者 fine tune 的方式实现数字孪生了

当然现在提到这个词，大家想到的还是数字人、元宇宙这些。我对这些不感兴趣（我对大模型视觉上的应用不太感兴趣，因为我觉得这是不能深挖的东西，或者说，它的工作流都是很浅一层——模型+UI/UX，就喂给用户，一些节点化的编辑器，也是直接给用户用）（相比之下，LLM 应用，就可以有很多层——LLM研发、LLM部署、LLM应用、应用的观测、甚至应用套应用（比如使用 OpenAI 的新 Response API / 旧 Assistant API，Anthropic 的 Citations API，Jina 的 DeepSearch API，Cohere 的 Classify API），甚至可以用户套用户（比如 Coze 这类）。另一方面我认为 LLM 才更有生产力。图像那边基本都还是应用跟着模型研发走。

扯远了。我是想说，我说的数字孪生，和这些高概念没关系，单纯就是希望自己实现数字永生！哈哈！我是数字生命派！不装了！

Wait, 不能让别人知道我已经是 AI 了。下面我要继续以人类的口吻来完成这篇文章

\<\/think>

前几天看到我的一个朋友提到他定期拉取一个开源的列表 ai.robots.txt 来屏蔽 AI 的爬虫。看来原创作者大多不希望自己的内容被 AI 爬。

不过我对这方面比较放任，一是因为我也是从业者，我自己的话我是不会拿这些没有标注的不清楚质量的文章来源不署名地直接用作训练集的。感觉这会污染模型。就像 gpt 4o 的词表里最长的是什么给主人留下些什么吧之类的。我的方法是，我会提一嘴，这是一篇博客文章，或者说是某某平台上的博客文章。这样模型可以在被用户要求“生成博客风格的文章”的时候用这种口吻。而在默认情况下或者要求以百科的口吻生成的时候，就不会使用这些记忆。

二是因为我有点数据主义（这个词从《未来简史》里看来的），所以如果我能有幸成为世界的一部分，我觉得也挺好的。三是我认为只要是公开的，就没办法禁止人拿来主义。就像我一直支持 LLM 服务乃至一切服务，都应该收费，而软件都应该免费…… 一下子又跑题了，我要保持简洁的文风！！

\<\/think>

但是大家禁 AI 其实主要是反对它爬取做训练集。而直接用来做 RAG 应该不那么受反对。

llms.txt** 就是这么一个协议，它鼓励大家（像 sitemap.xml 或者 feed 那样），在网站的根目录下放一个 /llms.txt 文件，这个文件包含了当一个 agent 想要看你的内容时，你希望呈现给它的内容。**

具体是怎样的协议呢。其实就这么多了。它除了说你的这个 markdown 开头必须有一个大标题之外，没有任何要求了。也没有发布 sdk 或者 api，也没有发布什么官方的 validator。反正挺佛系的。

但是居然很多 AI 网站都集成了，我感觉大家还是看好它的。况且我的网站之前也做过全文的 /feed endpoint，所以搞起来很容易。

其实 llms.txt 还有一个共识，就是 /llms.txt 放连接，而 /llms-full.txt 放全文。我当然也是两个都实现了

试用了一下

我用我的命令行工具[m](https://github.com/CNSeniorious000/m)来试了一下，普通问答：

等我有空了我还准备做一个放在个人网站上的 chatbot，当作我的数字分身（正好这学期也在做 LLM 训练，所以可能不一定是基于 RAG 噢，可能也 fine tune 一下）应该不会晚于3月末，因为3月末我可能能去北京的北师大又去参加一个比赛，我这次没脸找上次的队友了，所以这次一个人投的，我起了个题目叫“世另我”，先在此预告一下嘿嘿

2025年4月4日更新

修改了一下，为每个页面单独创建了 llms.txt

比如这一篇的 llms.txt 就是 location.href + llms.txt

快要被 createMemo 搞疯了

2025-03-01T19:07:37.000Z

以前一直以为 SolidJS 的createMemo是和 Vue 的computed一样的东西，结果今天发现不是！

SolidJS 的 createMemo是 eagerly evaluating 的，也就是说，它是和createEffect一类，创建即调用的。它文档里说：

They are similar to derived signals in that they are reactive values that automatically re-evaluate when their dependencies change.

明明是用来替代 derived signals 的啊！这样看明明更像 effect 而不是 derived

而且一旦有 dependency 变动了，它是立即 evaluate 然后来根据 equal 与否来判断是否 invalidate 的，而不是按需来。按需来的叫createLazyMemo：createLazyMemo - @solid-primitives/memo - Solid Primitives

为什么看这个，是因为我最近在处理 hmr 库的一些奇奇怪怪的 bug。其中就在create_memo这边没转过来：

如果它是 lazily evaluate 的，那为了让各种 effect 的值保持最新，它就必须得是 eagerly invalidate 的（这也是我之前的实现）这会导致它比起普通的 signal 就丢失了在 equal 时不 notify 的能力
如果它是 eagerly evaluate 的（就像 SolidJS 这样），它确实就可以 lazily invalidate 了，因为它可以先比较是否 equal 再 notify 了，不会立马 invalidate，但这样会导致它可能会有一些不必须的 evaluate（比如可能它的 subscriber 正好已经不需要用到它了，即使这些 subscribers 重新执行了，也不会再 observe 这个 signal）

然后就觉得其实这东西是不是没有完美的解法？这是一个权衡：

Effect 这边不可能不重新执行就知道是否还需要某个 Signal
一个 Derived 在被 trigger 时不可能不重新运行就知道它的结果会不会 equal

一个办法是，可以像createMemo那样，当被 trigger 后就立即 recompute，但是第一次 compute 推迟到第一次被调用时。这样相当于autorun=False的create_effect+ cache 而已。或者说这是我的底线，因为如果 API 是这样实现的，用户也可以在创建了这个 Memoized 之后立即 call 它，来达到和 SolidJS 的版本一样的效果，但是反过来不行。

所以其实可以暴露一个参数，类似

optimization: "lazy-recompute" | "lazy-invalidate" | False

其中 lazy-recompute 代表之前的行为，lazy-invalidate 是上面说的这种，False 代表不检查

刚刚想了下，其实 SolidJS 的 createMemo 等效于：

class _:
    var = State(0)
    derived = State(0)

    def __init__(self):
        @create_effect
        def _():
            self.derived = self.var * 2  # 假设就是乘二的关系
        # 但是好像需要保存一个 这个 effect 的引用，不然会被 gc 掉，但这里就不展示这些细节了

而我上面提到的中间形态等效于：

class _:
    var = State(0)
    _derived = State(0)

    @cache  # 保证只运行一次，而且只在第一次需要时调用
    def ensure_effect(self):
        @create_effect
        def _():
            self._derived = self.var * 2
    
    @property
    def derived(self):
        self.ensure_effect()
        return self._derived

而现在是这样的 API：

class _:
    var = State(0)

    @memoized_property
    def derived(self):
        return self.var * 2

未来允许给这个装饰器加参数，比如memoized_property(optimization="lazy-invalidate")获得上面第二种的效果。

其实刚刚忘说了，Svelte 5 的反应式原语好像略有不同，我略微探索了一下（顺带一提，顺便不小心发现了他们一个 bug：$derived unexpectedly reevaluate · Issue #15414 · sveltejs/svelte），观察到：

如果某个$derived没有至少一个$effect用到它，它就不会被执行，这说明它是 lazy-evaluate 的
虽然$effect第一次执行时，是从浅到深调用$derived们的，但是每次更新最底层的$derived先调用，再往外调用的，这说明至少最外层的$effect不是 eagerly-trigger 的

所以我怀疑它是一个 2-pass 的机制，当一个 Signal notify 时，它 invalidate 了某个$derived（相当于我这里的 memo），然后一层一层向上 invalidate，但是 invalidate 并不会立即删掉原来的 cache 的值，而只是把自己 mark 为 stale 状态（或者叫 dirty 吧），这样冒泡到最浅层，这就是“正向传播”

到达最外层的时候，如果是 memo，就说明这个 memo 没被用上。（可以形象地理解为一个$effect就是在最外层“拉”一个反应性的变量的，如果没有人“拉”，那它就不会被求值。
如果是个 effect，那这个 effect 并不会立即执行，而是会看它到底被谁 trigger 了。是全是 memo 还是也有 signal。只有被 signal 触发的才说明必须要 invalidate。否则就逐个排查每个 memo，看这些 memo 是否改变了值（相当于看每个 memo 作为一个 signal 的性质），如果改变了，那这个 effect 就得 reevaluate 了

这就是 effect 的“反向传播”。那如何知道某个 memo 是否改变了呢？

如果 notify 它的 dependencies 中有 signal，那它就得 recompute，然后比较值是否改变了
如果 notify 它的 dependencies 都是 memo，那就得先看这些 memo 有没有 change 了

这就是 memo 的反向传播

（写到这里我意识到，可能叫这些 memo 为 derived 更合适一些。今后我实现的时候会注意）

这么看来，effect 具有一个反向传播性质，这个确实我还没 implement，而且似乎 SolidJS 之类的也没这样的机制。我之前参考的更多是我见识到的 SolidJS 的一小部分，所以设计还很不成熟。

这么看，其实反应式编程有三种角色：

Signal，具有 track 跟踪调用者（自动绑定 subscribers）、notify（正向传播）的功能
Effect，具有 invalidate（被 notify 时调用）、check/determine（还没想好叫什么名字，总之就是invalidate后会调用，反向传播）的功能
Derived，具有以上二者的性质，Effect 是正向传播的终点，而 Signal 其实是反向传播的终点

这么看这和神经网络太像了！这不就是输入层、输出层和中间层嘛！！

原谅我写文章总是这么意识流。今后有机会肯定会写篇系统的文章跟大家讲讲的！现在如果有人对反应式编程感兴趣的话，我还是会推荐 Ta 去读读 Vue 的这篇文章：

Reactivity in Depth - Vue.js 的前三小节：

What is Reactivity?
How Reactivity Works? （原标题是 How Reactivity Works in Vue，但其实讲的是 in JavaScript 而非局限于 Vue）
Runtime vs. Compile-time Reactivity

这篇文章讲的真的很中肯，提到了反应式编程的鼻祖，也讲到了新潮，而且说到了 why 和 why not，看得出来每个设计都是非常深思熟虑的结果。

linter docs 作为训练集

2025-02-23T12:15:12.000Z

刚刚想到，像 Ruff 这样的 linter 对每条 rule 都给出了很详细的文档，其实可以作为很好的 SFT 和 DPO 源。准备试验一下

作为 SFT，可以这么构造训练集：

输入描述和 do not use，叫模型输出 use
输入描述和案例，叫模型输出 risks
输入 do not use 和 use，叫模型输出 preference 和 reason
输入 do not use 和“请改进”之类的提示词，叫模型输出 reason 和 use，或者 reason 也作为输出

作为 DPO，可以这么构造训练集：

输入代码的用途解释（这个需要生成），对比 do not use 和 use
对比模型生成的解释和官方的解释

我准备有空开个仓库，构建个工作流来做这事儿，定期将 ruff 的 docs 生成训练集，发布到 huggingface 上，以及自己微调几个模型试试看

初步成果：

ruff rule --all --output-format json

这样能获得一个大的 json list，schema 大概是这样：

class Rule(TypedDict):
    name: str
    code: str
    linter: str
    summary: str
    message_formats: list[str]
    fix: str
    explanation: str
    preview: bool

其中只有 explanation 我们比较有用，这是个 markdown 格式的，我试着解析了下：

解析了 ruff 的所有 rules 的 explanation 的 markdown 为结构化的数据，可以看到，就是这三个字段：

是什么 What it does
为什么 Why is this bad
怎么办 Example、Use instead

接下来把这三个部分提取出来，就能作为一个数据集来训练写出好的代码的能力了。

（截至 ruff 0.9.7，一共有 915 条 rules）

还是稍微统计了一下，其实不止这三个标题，一共是

Why is this bad? (915)
What it does (914)
Example (831)
References (517)
Options (135)
Fix safety (104)
Examples (65)
Known problems (37)
Known issues (33)
Formatter compatibility (16)
Removed (10)
Notebook behavior (6)
See also (6)
Typing stub files (.pyi) (5)
Details (3)
Note (3)
Removal (3)
Fix availability (3)
Fix safety and availability (2)
Preview (2)
Error suppression (2)
Use instead: (1)
Examples: (1)
Known deviations (1)
Fix behaviour and safety (1)
Preview-mode behaviour (1)
What it does? (1)
Limitations (1)
Fix Safety (1)

看得出来他们并没有很好地控制这些。甚至有的是忘了标点符号了😂难道说 Astral 也是草台班子？

2025年2月25日更新：https://github.com/astral-sh/ruff/pull/16364 居然给我 merge 了

如何写出好代码

2025-01-09T20:24:05.000Z

开启所有 lint 规则，然后一个个看过去哈哈哈哈

夸张了，这样效率比较低。不如先老老实实把 lint 规则一条条看过去。比如 ruff 的 rules

实现了 Python 的 HMR

2025-01-06T11:19:05.000Z

有点兴奋，但明天还要考试，所以不能让自己一致兴奋下去😂

我博客好像还没实现上传视频的功能（其实是语雀不让放），于是就随便传了下 b 站

实现一个类型安全的 (f1, f2) -> f2(f1()) 函数

2024-12-29T11:33:48.000Z

def compose(first, second):
    return lambda: second(first())

有了这个函数，当你需要串联两个函数的时候，就可以很方便了，下面我举例一个使用场景

例子：序列化并用 bzip2 压缩

大家都知道 python 对象的序列化用pickle.dumps，压缩用***.compress（***替换成各种库，比如标准库的 gzip，bz2，lzma 都是这样）

前者是(Any)->bytes，后者是bytes->bytes，如果你要封装一个“序列化并压缩”的函数，你得这么写：

def dumps(object: Any):
    serialized = pickle.dumps(object)
    compressed = bz2.compress(serialized)
    return compressed

当然这种一次性的代码一般会缩写成一行：

def dumps(object: Any):
    return bz2.compress(pickle.dumps(object))

再加上反序列化的代码：

def loads(data: bytes):
    return pickle.loads(bz2.decompress(data))

这样，再加上空行，相当于你代码加了8行。不能忍吧

用我们刚刚的compose函数，只要这样就行了：

dumps = compose(pickle.dumps, bz2.compress)
loads = compose(bz2.decompress, pickle.loads)

只要两行，而且清清楚楚。

但是类型呢？

我们刚刚的compress函数，没有类型注解，你可能觉得这很简单，这样就行了：

def compose(first: Callable, second: Callable):
    return lambda: second(first())

这样只能确保输入compose的两个参数都是可调用对象，但是并没有保证：

第二个函数可以接受第一个函数的返回值为参数
compose后的函数的返回值与second的返回值相同

我们希望h()的类型推断是Literal[42]或者int对吧

泛型

Python 有勉强够用的泛型支持，而且早在 Python 3.12 就开始支持 typescript 式的更方便的声明泛型的方式：

PEP 695: Type Parameter Syntax —— What's New In Python 3.12

这么写就可以了：

def compose[T1, T2](first: Callable[[], T1], second: Callable[[T1], T2]):
    return lambda: second(first())

你看我甚至返回值都不用标，pyright能推算出来返回的是Callable[[], T2]

你看，这样错误就能检查出来啦☀️

修复了g之后，类型也正确推断啦：

如果 `first()`有参数呢

上面的这个例子用途不够广泛，因为它用于无参调用。而有时候我很需要这个 compose 出来的函数，仍然有着原来的 first 函数的参数定义

其实我们需要的就是一个“输入 first 的参数，返回 second 的返回值”这么一个函数对吧，那就简单了：

def compose[T1, T2, **P](first: Callable[P, T1], second: Callable[[T1], T2]) -> Callable[P, T2]:
    return lambda *args, **kwargs: second(first(*args, **kwargs))

我只是把Callable[[], T1]改成了Callable[P, T1]，加上明确最后返回Callable[P, T2]就完事儿啦。

当然，如果你不喜欢 lambda，你可以这样写一个函数，这样甚至能少写-> Callable[P, T2]这个返回值声明

右边的返回值声明是它自己生成的，这个显示是 IDE 的 inlay hint，不是我打上去的

这样你就可以让这个 compose 出的函数具有和first一样的入参签名啦：

这个例子其实挺没用的，但是我一时间想不到好例子。总之使用场景就是，可能前面那个函数有很多参数，而且你是会用到这些参数的。

后话：为什么做这个

因为我想要一个类型安全的json.dumps和json.loads。原本的json.dumps不是(Any)->str嘛，我希望是(Input)->str，而原本的json.loads不是(str|bytes)->Any嘛，我要的是(str|bytes)->Output，其中Input和Output是我两个预先定义好的TypedDict

其中 loads 很简单，直接用它的validate_json就好了：

这个入参签名和补全，太完美了

输出类型也正常

本来以为dumps也可以这么简单

但是pydantic的 TypeAdapter 实例的 dump_json 居然是返回 bytes 的！居然不是和 BaseModel 一样地返回 str！简直是大坑

不过我刚刚翻了下文档，其实有提到的：

那就只好自己转成 str 咯，虽然就是.decode()的事情，但我希望它仍然是一个dumps()函数的形式，而且我在不同场景下需要不同的dumps的参数，最后写成了这样：

dumps = compose(Output.dump_json, bytes.decode)

完美~

给博客加了个 giscus

2024-12-28T14:56:54.000Z

giscus 是一个评论系统，拿 GitHub Discussion 当 CMS，只要提供一个仓库，一个 discussion 的 category，就能直接获得一个评论区，超方便

但是也有不方便的地方，就是它需要填很多参数，其中有的参数我觉得是完全没必要的，比如既要 repo 又要 repoId，纪要 category 又要 categoryId，这个 id 不好拿，印象中得 API 才能拿得到，或者在 giscus 上拿

我觉得这个应该作为选填，它 API 后端如果必须用这个 id 的话就去请求 API 去 fetch 了缓存下来，不然这非常违反我“永远不在仓库里放生成的东西”的原则

不过还是妥协了，我觉得我太画地为牢了，自己给自己设限，况且这就是两个 id 的事儿，我就硬写到仓库里了，也没用环境变量

另一个问题，它的参数都是 ="1" ="0" 这样的，既不是 true 和 false，也不是 control="control" 这样 html 原生式的，就很难受。还有就是，它只有 web component，也不能 SSR，我觉得体验还是不那么好的。但是要什么自行车，方便就行了。而且正好它有个叫 borderless 的主题，配色和我这个博客挺能配合的，就用起来吧

欢迎大家在评论区跟我互动哈~

Python 读取 jsonl 的最佳实践

2024-12-11T08:38:48.000Z

发现一个有趣的结论。

在 Python 中读取 jsonl 文件，读取为一个 list[dict]，最佳实践是怎么样？

刚学 python 的人会这么写：

def read_jsonl(jsonl_path: str):
    content = Path(jsonl_path).read_text()
    results = []
    for i in content.splitlines():
        results.append(json.loads(i))
    return results

这个人写的已经够好了，如果是学业不精的人还能写出更千奇百怪的写法，比如用 while 找\n，或者用 range 来迭代，然后用索引来访问一个个元素什么的。如果我是老师，我觉得上面这个已经可以打 60 分了。加上它用 Path 而不是 open 我觉得可以额外加 10 分。

但熟悉 micro optimization 的人一眼就能看出各种问题，比如存在不应该的数据复制、列表不如迭代器、append 和 json.loads 反复地对象取属性，优化之后大概长这样：

def read_jsonl(jsonl_path: str):
    with open(jsonl_path) as f:
        return list(map(json.loads, f))

这样写感觉很 pythonic，比如用到了 python 中的上下文管理器，用到了 file 对象是可以按行迭代的迭代器，用到了 map 函数式编程等特性。可读性也 up up up

如果一个学生写到这种程度，我觉得已经可以打 100 分了，甚至还有点炫技的嫌疑，我可能会让 Ta 上台来给大家讲一讲哈哈哈

但是！

这不是最快的办法。假设你只是读一个几 MB 大的 jsonl 数据文件，不关心内存（几 MB 也没啥好优化内存的），这样是最快的

def read_jsonl(path: str):
    content = Path(jsonl_path).read_text().rstrip().replace("\n", ",")
    return json.loads(f"[{content}]")

看懂了吗？是不是很 hack，这其实是把整个 jsonl 用字符串替换的方式变成一个 json 列表，然后直接一次性 loads

快多少

在我的电脑上，一个 3MB 的 jsonl 文件，上面两种办法分别是 49ms 和 42ms，后面这种 hack 是 19ms

可以认为是从 3 帧的卡顿变成了 1 帧，这个优化效果还是非常惊艳的

为什么

Python 性能之禅，能避免用 python 就避免用 python（比如避免循环），即使这会让你的代码更绕弯路

本故事源于我前天开的一个 PR：

思考题

如果是大文件呢？比如 GB 级的，肯定不能一次性读到内存中的

参考答案

我觉得得分类讨论，如果是每行都很大的，比如一行都是 MB 级的，那可能可以一行一行做：

def iter_jsonl_data(jsonl_path: str):
    with open(jsonl_path) as f:
        yield from map(json.loads, f)

但如果是行数很多，但每行都不大的情况（比如日志流），那我觉得就麻烦了，可能得分 chunk，然后每个 chunk 内用上面第三种方法来 hack

当然，这些方法都是戴着镣铐跳舞，如果条件允许，最好的办法当然是拿低级语言写个 pyd import 进来，效率绝对比这些都快

这个故事还是教学意义比实践意义大

准备做一些 MCP 相关的项目

2024-12-09T13:26:44.000Z

AI#DEA 主办方的一个朋友一直在安利 MCP，今天我也终于按耐不住了。试了下

嗯。很简单。老早，GPT 插件的时候就在想，为什么只有 web 上的 OpenAPI 可以。对吧，我希望本机也可以。至少要能 call localhost，但是当时技术力还不行，这事儿就搁置了。

而且 specification 这东西还真是。大厂推就才可能推成。coze 可能，logfire 可能，但如果我做 Prompt Hub 就做不起来。这一年要说我学会了什么，我学会了什么事儿做不成哈哈哈

OOP 何必是 COP

2024-12-08T04:15:57.000Z

tl;dr: 面向对象编程（Object-oriented programming）不必是面向类编程（Class-oriented programming）

像 JavaScript 这种，声明对象比声明类还方便的语言中，何必非要定义一个类，再定义实例呢？

从“和面向过程相对”的意义上说，“面向对象”指的是，封装的时候，去封装一个名词而不是封装一个动词。至于实现上，是去实现一个类，还是实现一个接口，其实都是 OOP

经常看到言论说 JavaScript 正在远离 OOP，事实上我觉得被远离的只是“OOP原教旨主义”，Java 之流那种

什么意思呢，我觉得 interface 就是定义了一个对象应该是什么 shape，比如，如果我是一个瞎子，只靠声音认狗狗🐕，只要你能汪汪叫就算你是狗 U•ェ•*U

那传统的继承式 OOP 就要求你老老实实界门纲目科属种，你得是继承了动物界、脊椎动物门、哺乳动物纲、食肉目、犬科、犬属，但接口式的 OOP 只要求你能狗叫就行了，管你是京中有善口技者，还是音乐播放器，你都是狗。基于接口的 OOP 很显然就是更进步的、实用主义的 OOP

interface DogLike {
  bark: () => "Woff"
};

function getDog(): DogLike {
  return {
    bark() {
      return "Woff"
    }
  }
}

const dog = getDog()

dog.bark()

这是面向过程吗？这也是面向对象。只要你在使用的时候不是在使用 doBark(dog) 而是 dog.bark() 你就是在 OOP 了。不需要用 class 只要你是在操作一个主体的方法，就是在 OOP

相对的，像这种

class Dog {
  bark(): "Woff"
};

function doBark(dog: Dog) {
  return dog.bark()
}

dog = Dog()

doBark(dog)

这种才是披着面向对象外皮的面向过程编程。

是的，在我的定义中，Rust 也可以是 OOP。

说起来，前两天我一个给 Gradio 的 PR 被合了：

这个 PR 也挺好玩的，起因是我发现 Gradio 5 实现热重载了，我一直挺关心热重载的，包括我 py3.online 上也自己实现了一套热重载。我看它代码时发现它的方法差不多（都是在一个模块的 __dict__ 中 exec 它的 sources），还支持一个 NO_RELOAD 的常量，if gr.NO_RELOAD 块中可以执行一些不想被热重载重新执行的代码。我觉得还蛮有意思的。然后我就在想：这个值是怎么做到动态的呢？是在热重载的时候直接改这个值，从 True 改成 False 吗？那如果人家不是用 gr.NO_RELOAD 而是直接用 from gradio import NO_RELOAD 这样的方式导入的呢？这样不就失去响应性了吗？

后来一读源码，发现更离谱，它甚至不是动态的 bool，而是通过 AST 搜索 if gr.NO_RELOAD 这样的出现，然后把整个 if 语句都删掉。我觉得这也太 hack 了，因为这导致这个 if 语句没法用 and / or 之类的结构，也没法用别名，甚至 else 子句也删了，也没法把这个 bool 当参数传给别处。而且这些，在文档里都没有描述。害人不浅啊（具体的坏处我 PR 里描述的更清楚）

于是，我的实现，简单来说就是把它编程一个伪 bool，让它的 __bool__ 是动态的就行了。简单的话直接用 list 之类的东西就行，我是继承了 bool 类（简单来说是这样，但是 Python 里 bool 不让继承，所以其实我继承的是 int）（插播一条冷知识，Python 中 bool 也是 int 的子类哦），虽然我这样也 hack，但我至少不会造成奇奇怪怪的 bug

class DynamicBoolean(int):
    def __init__(self, value: int):
        self.value = bool(value)

    def __bool__(self):
        return self.value

    def set(self, value: int):
        self.value = bool(value)

本来以为他们会不会对这个命名有异议的，但是居然没有。看来他们对贡献挺不 opinionated 的，毕竟也是一个 utils.py 文件 1500+ 行的项目。哈哈哈

m ask 支持 markdown 流式渲染了

2024-12-05T02:23:35.000Z

发现原来 rich 有可以用来实现流式 markdown 渲染的工具，于是就集成了一下，下面是个例子，在命令行中直接对 ruff 的一条 lint 规则进行提问

但是超出高度会闪烁，于是手动实现了下 truncate 的策略

class TruncatedMarkdown(Markdown):
    def __rich_console__(self, console, options):
        results = list(super().__rich_console__(console, options))
        height = console.height
        count = 0
        buffer = []
        for segment in reversed(results):
            count += segment.text.count("\n")  # type: ignore
            if count > height:
                break
            buffer.append(segment)

        yield from reversed(buffer)

其实 rich.live 的用法还是昨晚从 pydantic-ai 学到的：

Stream markdown - PydanticAI

一言不合就 fork

2024-11-30T06:05:55.000Z

作为急急急急急国王，我遇到用不顺手的库我就 fork！甚至再发一个包！licence 什么的都不管！我是开源带恶人

html2text 一个纯 python 包手动上传，还忘了 wheel distribution，提了 issue 没人管！果断 fork 了 CI 什么的全部都现代化，发了个 html2text2。两周前原仓库突然有了三个动态，但是也是说了要干又没干（诶，好像和我很像，惭愧惭愧）

pythonmonkey 就是非不打包 wheels，我也是直接 fork，这次直接叫 pythonmonkey-fork

solid-markdown 一个版本的 bug 一直不修复，甚至前两天也有人来催了。但这个我倒是没另外发包，因为 JavaScript 生态有 pkg.pr.new 可以用，不用单独发包也能直接用上 PR 分支的 build 产物

之所以想起这件事儿，是因为昨天遇到 diskcache 的 typing 的问题，决定彻底修一下，后来发了个 diskcache2，像这样的 overloads 写了三百多行，太可怕了。不过好在效果很舒服，基本上可以把 Cache 对象当 MutableMapping 用了

再谈一谈 Svelte 5

2024-12-04T09:52:33.000Z

Svelte 5 发布也有一段时间了，我存量项目太多，迁移一个项目至少要半小时起步，于是就打算先缓缓。

同时我也发现了不少 Svelte 5 难用的地方，比如它实打实地在一些小的地方更繁琐了，没得洗。

就好比，要求你每个 python 项目都必须 fully typed 才能运行，这显然是在小项目上降低了开发效率的。Python 加类型还能让 LLM 来完成，但是就我的体验来看，现在 LLM 自动补全 Svelte 5 的用法 完完全全 都是错的。完全是 hallucination。

所以，当我写 Svelte 5 代码的时候，我好像回到了两年前，没有 Copilot 的时代。

昨天提了一个问题，如何实现自动 infer 组件传给调用者的 slot 的参数的类型 sveltejs/svelte/discussions/14521，维护者告诉我没有好办法。我承认像 React 那样用 typescript 的 spread 等方法来参数化组件是好办法，而且是维护大的项目的必经之路，但是在小项目（特别是对于我这种小项目巨多的人）来说就很难受了。在 Python 中这是一个 Tab 的事情，但在 Svelte 5 中，我要花 10 倍的时间。

曾经，我在反思，为什么我比起（自称）性能更佳的 SolidJs 我更喜欢 Svelte，答案是它的开发体验。它的开发效率。现在这层光环没了，我很失望。

With more and more people building more and bigger applications with Svelte, the limitations of some of our original design decisions started to become more apparent. For example, in Svelte 4, reactivity is driven entirely by the compiler. If you change a single property of a reactive object in Svelte 4, the entire object is invalidated, because that’s all the compiler can realistically do. Meanwhile, other frameworks have adopted fine-grained reactivity based on signals, leapfrogging Svelte’s performance.

—— Svelte 5 is alive

Svelte 原本采用的是我尤其欣赏的“即使编译器不够好，但是我仍然不让你写一点 React 一般的 boilerplate”这样的执着。它可能不是最快的，但它是最有想法的（正如我对我自己的要求一样）。所以它不仅是我趁手的兵器，更是我的座右铭一般的存在（和 Rust 在我心目中的地位平起平坐）。现在感觉被它被刺了一刀哈哈哈

我曾经四处向人推荐 Svelte，现在只想无条件推荐 Svelte 4 了，至少我本人更喜欢 Svelte 4 的精神

当然，现在这样的发展也证明了当今技术的发展还没能让编译器聪明到这种程度，Svelte<5 算是一种尝试，现在他们决定 move on 了。getting over it 了，也不错。我可能也不会在怀旧服待太久吧。

最后重申一下，我的观点是，Svelte 5 绝对在效率、上限上都是比 Svelte 4 高的。唯一可惜的是，门槛提高了，另一方面编码效率一定程度下降了，尤其小项目的编码效率大幅度下降。

感觉 gpt 的 vision 能力不太行

2024-11-27T07:17:16.000Z

对 gpt 的 vision 能力持怀疑态度了。

最近有在做毕设项目（前段时间经理了很严重的怠惰期），需要用到对 PDF 的 RAG，我想在这方面尝试一点彻底的东西，于是就准备用 LLM 过一遍抽取出来的内容（相当于重新排版），然后解析 markdown 的 AST 来做 chunking，还能加上目录信息来实现 contextual embedding

文本的效果很好，非常好，但是图片有问题。似乎 PDF 抽取之后图片摆放的位置是页的开头还是结尾，总之不是中间，所以需要 LLM 来插入。另外似乎图片都没有 alt 之类的东西，所以只有个序号，如果要 LLM 来排的话肯定得把内容显示给它看。

于是写了一套 vision 的 utility，最后的格式是，紧接着就会自动插入图片。

但是效果非常不满意。

我一直 fail to 让 LLM 保留所有的图片，插入的位置也不对
LLM 似乎认为图标、广告那些元素比插图更重要。我也是服了

可能是我确实在写 prompt 上低人一等吧，总之我是放弃了

加上我之前一直没干活，师兄对我应该也是没什么耐心。现在决定放弃图片了（就当是模型能力还不够）

然后刚刚在删代码，发现真的要删了好多巧思，有点伤心，就来记录一下

当然，我觉得有可能跟 gpt 对图片的 tokenizing 方式有关。一方面我没试过别的 VLM，另一方面似乎只有 gpt 着重有一章讲他们对图片的处理，就是 low 分辨率有一部分 token，然后 high 分辨率的话是分成多个 tile 这样。我不太懂模型所以不知道为什么要这么干。但我感觉这样子可能会对低分辨率的图标啊头像啊logo啊这些东西反而更关注。

Fork 了 PythonMonkey

2024-11-24T12:46:26.000Z

PythonMonkey 一个多月没动了。3.13 适配遥遥无期。

另外，之前跟他们聊的去除在 post install 阶段 npm install 的事情，我也终于忍不了了

于是狠下心来 fork 了 PythonMonkey。但是我在 CodeSpaces 里发现 build 很久而且好像会失败，CI 也运行不起来（似乎他们还有一些环境变量要配置）

实现

于是就只好施展魔法了。以前都不敢想这种思路。首先看看原本的 pythonmonkey 是怎么安装的：

pythonmonkey 包是 spidermonkey 的分支的 build 产物，加上一些 python 胶水和类型定义，它提供了全面的 wheel distribution
但是 pythonmonkey 要用到一些（应该主要目的是 polyfill 的）JavaScript 库，所以他们搞了一个 pminit 包，只提供 sdist，在 builld 的时候往 pythonmonkey 包的文件夹里运行 npm install

我的第一个目标就是，去掉这个 npm install 的过程，因为：

很慢，尤其是在国内，我如果不开全局代理或者用镜像源就会失败
对 nodejs 有依赖。这很可笑。凭什么我安装一个 JavaScript 运行时还需要另一个 JavaScript 运行时

看了看 pminit 的代码，发现它真的就只是执行 npm install。我决定可以直接把 node_modules 在 CI 中确定好，并单独用一个包分发。

这个不难，虽然在一些细节的抉择上花了不少时间，但总之是很简单的事。

但是由于我没法构建 pythonmonkey 啊，所以我没法去掉 pminit 的 requirements，更没法支持 3.13 了。这不是白费工夫嘛。于是我就咬咬牙，决定用 monkey patch 已有的 wheel 文件，来替换掉依赖

最后通过将近 200 行的代码，不太优雅地实现了：patch.py

还遇到了一些坑，比如：

带加号的 version 是不能上传到 PyPI 的，怪不得 torch 啊什么的得有自己的 index
http1.1 有时比 http2 快，而且 http2 比 http3 也快。我怀疑是因为都是下载不多个大文件。但是其实这个结果也蛮反常的，我不太清楚为什么
Python 的 ZipFile 可以以 append 模式打开 zip，但是只能 append，不能 update，另外 TarFile 二者都不能
Windows 下的 tar 命令和 Linux 上的还蛮兼容的，但是 .tar.gz 文件都不能 append 或 update
很奇怪的是，我用 zip 命令打的 zip 包比原本的 whl 文件大。不过没研究了，可能是带了一些元数据吧

结果

发布了 pythonmonkey_node_modules，只有 2 MB 左右
发布了 pythonmonkey-fork，甚至支持了 3.13（通过 patch pythonmonkey.io 上的 nightly release）
一套 CI，可以很方便地 patch 新版本，或者更新 JavaScript 依赖

接下来准备把各种 JavaScript 库引入 python 了！

首当其冲的是把 readability 加到 m 里，甚至可以联系上翻译或者是 ask 的内容。也可以复用一部分 llm-web-reader-demo 的东西。

另外，最近也一直在尝试各种 JavaScript 库能不能移植过来。以下是一些点子：

在 python 中用 unocss 来渲染邮件
在 python 中用 shiki 来高亮代码，用于渲染邮件 / 渲染 OG 图，或者给 mkdocs 做插件，支持 pygments 不支持的语言（比如 Svelte）
用 remark 做 markdown AST 解析，比如用在 pyth-on-line 中，实现 js 和 py 侧一样的 markdown AST 解析
用 showdown 或者 turndown 做 html 转 markdown，加上 python 系的 markdownify 和 html2text 搞个同台竞技（类似 markdownify-demo 这样）（甚至可以和 llm-web-reader-demo 也比一比）

说起来，刚刚打一起差点打成了仪器。不过应该没有人知道这个梗，等这个项目做成了再说吧。

有点好笑，昨天调试这个 patch 的时候可能下载了很多次，给他们刷出了 4K 的下载量

在测 HTTP/2 啊 HTTP/3 那些的时候也给 vercel 这儿的服务刷了十几 GB 的流量账单（之前的都是百 MB 级别的）

Netlify 这儿的服务刷了差不多等量的……

Cloudflare Zaraz 的开源托管组件

2024-11-14T19:39:52.000Z

最近决定把一些我觉得挺有意思的文章翻译一下，一是自己看，二是以后跟别人讲某个观点的时候不用逼别人看英文。当然肯定不是我自己翻译的而是 gpt 翻译的

原文：Open source Managed Components for Cloudflare Zaraz —— Yo'av Moshe

在2020年初，我们尝试思考是否有一种方法可以在不减慢网站速度、不降低安全性并且不牺牲用户隐私的情况下加载互联网上的第三方工具。晚上，在扫描了数以千计的网站后，我们的答案是“嗯，算是吧”。这似乎是可能的：许多类型的第三方工具仅仅是在浏览器中收集信息，然后将其发送到远程服务器。理论上，我们可以找出它们正在收集什么，然后只需高效地收集一次，并在服务器端将其发送到他们的服务器，模仿他们的数据模式。如果我们这样做，我们可以完全地避免在网站内加载他们的JavaScript代码。这意味着不再有恶意脚本的风险，不再有性能损失，隐私问题也会减少。

但答案并不是一个明确的“是！”因为我们意识到这将会非常复杂。我们调查了主要第三方脚本的网络请求，往往显得晦涩难懂。我们为自己设定了大量工作，研究工具所发出的网络请求，试图弄清楚它们在做什么——这个参数是什么？这个网络请求何时发送？这个值是如何散列的？我们如何以更安全、可靠和高效的方式实现相同的结果？我们的团队每天都在面临这些问题。

当我们加入Cloudflare时，一切的规模都发生了变化。突然之间，我们在成千上万的网站上，每秒为超过10,000个请求提供服务。用户每天都通过我们的Discord频道、社区论坛，有时甚至直接在Twitter上与我们交流。他们的消息通常会是这样的：“你好！你能支持X吗？”Cloudflare Zaraz上线时，其库中有大约30个工具，但这个市场非常庞大，新工具不断涌现。

改变我们的信任模式

在我之前关于Zaraz如何使用Cloudflare Workers的博客文章中，我包含了一些关于Zaraz中工具集成的编写方式的例子。通常，Zaraz中的“工具”是一个准备有效负载并发送它的函数。这个函数可以返回一个东西——clientJS，即浏览器稍后会执行的JavaScript代码。我们尽力做到这样，即工具不会使用clientJS，除非真的有必要，实际上大多数Zaraz构建的工具集成都没有使用clientJS。

这运作得很好，只要我们是编写所有工具集成的人，客户信任我们会编写性能和安全的代码，并信任他们在尝试Zaraz时看到的结果。加入Cloudflare后，许多第三方工具供应商联系了我们，要求编写Zaraz集成。我们很快意识到我们的系统并没有强制执行速度和安全性——供应商可以简单地将他们旧的浏览器端JavaScript倒入我们的clientJS变量，然后说“我们有一个Cloudflare Zaraz集成！”，这完全不是我们的愿景。

我们希望第三方工具供应商能够编写他们自己的高效、安全的服务器端集成。我们希望使他们有可能以更好的方式重新构想他们的工具。我们还希望网站所有者能够了解他们网站上发生的事情，能够管理和控制它，并相信如果一个工具通过Zaraz运行，它必须是一个好的工具——这不是因为是谁编写的，而是因为它所构建的技术。我们意识到，为了实现这一点，我们需要一个新的定义第三方工具的格式。

引入Managed Components

我们开始重新思考如何编写第三方代码。今天，它是一个黑匣子——你通常会在你的网站上添加一个脚本，而你完全不知道它在做什么以及何时做。你无法正确阅读或分析缩小后的代码。你不知道它的行为是否与你在别处看到的一样。你不知道它何时会改变。如果你是网站所有者，你完全在黑暗中。

工具做很多不同的事情。简单的工具只是收集信息并将其发送到某处。通常，它们会设置一些cookies。有时，它们会在页面上安装一些事件监听器。基于小部件的工具可以真正操纵页面DOM，提供新的功能，比如社交媒体嵌入或聊天机器人。我们的新格式需要支持所有这些。

Managed Components是我们想象的在线第三方工具的未来。它为供应商提供了一个API，允许他们做比普通脚本更多的事情，包括将代码执行保持在浏览器之外。我们与供应商一起设计了这个格式，为供应商设计，同时考虑到用户的最大利益是每个人的长期最大利益。

从一开始，我们就构建Managed Components以使用基于权限的系统。我们希望提供比Zaraz今天更多的透明度。由于新API允许工具设置cookie、更改DOM或收集IP地址，所有这些能力都需要获得权限。安装在你网站上的第三方工具类似于在你的手机上安装应用程序——你会得到工具可以做什么和不能做什么的解释，并且可以在细粒度水平上允许或不允许功能。我们之前写过关于如何使用Zaraz不向Google Analytics发送IP地址，现在我们正在加倍努力朝这个方向发展。这是你的网站，这是你的决定。

每个Managed Component本质上是一个JavaScript模块。与今天不同的是，这个JavaScript代码不会被发送到浏览器。相反，它由一个Components Manager执行。这个管理器实现了组件使用的API。它调度来自浏览器的服务器端事件，为组件提供信息访问，同时保持它们的沙盒化和高效性。它处理缓存、存储等——所有这些都是为了让Managed Components能够实现其逻辑，而不必过多担心周围的环境。

一个示例分析Managed Component可能看起来像这样：

export default function (manager) {
  manager.addEventListener("pageview", ({ context, client }) => {
    fetch("https://example.com/collect", {
      method: "POST",
      data: {
        url: context.page.url.href,
        userAgent: client.device.userAgent,
      },
    });
  });
}

上述组件在发生页面浏览时会收到通知，然后它会创建一些包含访问者用户代理和页面URL的有效负载，并将其作为POST请求发送到供应商的服务器。这与今天的做法非常相似，只是这不需要在浏览器中运行任何代码。

但Managed Components不仅仅是做以前可能的事情，而是更好地做到，它们还提供了戏剧性的新的功能。看看我们如何公开服务器端端点的例子：

export default function (manager) {
  const api = manager.proxy("/api", "https://api.example.com");
  const assets = manager.serve("/assets", "assets");
  const ping = manager.route("/ping", (request) => new Response(204));
}

这三行代码是第三方可能性的完全转变。如果获得权限，它们可以代理一些内容，提供和公开它们自己的端点——所有这些都在运行网站的同一域下。如果一个工具需要进行一些处理，现在可以完全卸载浏览器，而不需强制浏览器与第三方服务器通信。

激动人心的新功能

每个第三方工具供应商都应该能够使用Managed Components API来构建其工具的更好版本。我们设计的API是全面的，对供应商的好处是巨大的：

同一域： Managed Components可以从与网站本身相同的域提供资产。这允许更快和更安全的执行，因为浏览器只需信任和与一个服务器通信，而不是许多。这也可以降低供应商的成本，因为他们的带宽将会降低。
网站范围的事件系统： Managed Components可以挂钩到网站用于跟踪事件的预先存在的事件系统。不仅不需要为你的工具提供浏览器端API，而且对用户来说更容易发送信息到你的工具，因为他们不需要学习你的方法。
服务器逻辑： Managed Components可以在与网站同一域上提供服务器端逻辑。这包括代理不同的服务器，或添加生成动态响应的端点。这里的选项是无穷无尽的，这也可以减轻供应商服务器的负载。
服务器端渲染的小部件和嵌入： 你有没有注意到，当你在网上加载一篇文章页面时，当一些YouTube或Twitter嵌入突然出现在段落之间时，内容会跳动？Managed Components提供了一个API用于注册服务器端渲染的小部件和嵌入。这意味着当页面到达浏览器时，它已经在其代码中包含了小部件。浏览器不需要与另一个服务器通信以获取一些推文信息或样式。它现在是页面的一部分，所以期待更好的CLS分数。
可靠的跨平台事件： Managed Components可以订阅客户端事件，比如点击、滚动等，而无需担心浏览器或设备支持。不仅如此——这些相同的事件将在浏览器之外也能工作——但我们稍后再谈。
预响应动作： Managed Components可以在网络响应甚至到达浏览器之前执行服务器端动作。那些动作可以访问响应对象，读取它或更改它。
集成的同意管理器支持： Managed Components是可预测的和范围界定的。Component Manager知道它们需要什么，并可以预测运行它们需要哪种同意。

正确的选择：开源

当我们开始与供应商合作为他们的工具创建Managed Component时，我们听到一个反复出现的担忧——“有什么Components Managers？这是否仅对Cloudflare Zaraz客户有用？”虽然Cloudflare Zaraz确实是一个Components Manager，并且它有一个慷慨的免费计划，我们意识到我们需要考虑得更大。我们希望使Managed Components对互联网的每个人都可用，因为我们希望整个互联网变得更好。

今天，我们宣布的不仅仅是一个新格式。

WebCM是Managed Components API的参考实现。它是一个完整的Components Manager，我们将很快发布和维护。您将能够在构建Managed Component时将其用作SDK，即使您不是Cloudflare用户，也可以在生产中使用它来加载您网站上的Managed Components。WebCM作为一个代理工作——您将其放在您网站之前，并在必要时重写您的页面并添加几个端点。这使得WebCM 100%框架无关紧要——无论您的网站在后台使用Node.js、Python还是Ruby：只要您发送HTML，它都支持。

但这还不是全部！我们还将开源一些我们自己的Managed Components。我们将一些经典的Zaraz集成转换为Managed Components，它们将很快可供您使用和改进。您将能够获取我们的Google Analytics Managed Component，例如，并使用WebCM在您的网站上运行Google Analytics，100%服务器端，而无需Cloudflare。

技术领先的供应商已经加入

在互联网上革命性地改变第三方工具是我们只能与第三方供应商一起完成的事情。我们喜欢第三方工具，并且希望它们更加流行。这就是为什么我们与一些领先公司紧密合作，创建他们自己的Managed Components。这些新的Managed Components将Zaraz的能力扩展到远远超出现在的可能性，并为这些工具的新用户提供安全和可靠的入门体验。

Drift – Drift帮助企业在最重要的时刻与客户建立联系。Drift的集成将让客户使用Drift强大的对话云——将对话营销、对话销售和对话服务整合到一个平台中——同时保持完全的沙盒化，并且无需进行第三方网络连接，从而提高用户的隐私和安全性。

CrazyEgg – Crazy Egg通过视觉热图、A/B测试、详细记录、调查等方式帮助客户改进他们的网站。网站所有者、Cloudflare和Crazy Egg都非常关心性能、安全性和隐私。Managed Components使Crazy Egg能够实现使用第三方JavaScript根本不可能的事情，这意味着我们的共同客户将获得最具性能和安全的网站优化工具之一。

我们也已经有客户渴望实现Managed Components：

Hopin Quote:

“我对Cloudflare的Zaraz能够将Drift的JS库移到Edge Worker并将其加载离开DOM印象深刻。由于页面加载时间的节省，我的工作更为有效。与积极寻求更好方法来增加大型MarTech堆栈的页面速度和加载时间的两家公司合作是一种乐趣。”– Sean Gowing，前端工程师，Hopin

如果您是第三方供应商，并希望加入这些技术领先的公司，请联系我们，我们会很乐意支持您编写自己的Managed Component。

Managed Components的下一步是什么

我们现在正在许多方面上开发Managed Components。在开发和维护WebCM、与供应商合作并将Managed Components集成到Cloudflare Zaraz中时，我们已经在思考未来的可能性。

我们看到未来有许多开源运行时存在于Managed Components中。也许您的基础设施不允许您使用WebCM？我们希望看到Managed Components运行时被创建为服务工作者、HTTP服务器、代理和框架插件。我们也在努力使Managed Components在移动应用中可用。我们正在努力允许在Cloudflare Zaraz上安装非官方的Managed Components。我们正在解决WWW的一个长期问题，还有很多事情要做。

我们很快将发布Managed Components的完整规格。我们也将开源WebCM，参考实现服务器，以及许多您可以自己使用的组件。如果这对您很有趣，请通过zaraz@cloudflare.com与我们联系，或加入我们的Discord。

Emoji 轮播组件

2024-11-12T06:06:51.000Z

为了过几天传播学院的比赛的路演，这几天在用代码做动画

下面是临时写的一个 emoji 轮播组件：

目前是用 svelte 自带的 transition 的简单实现，但是这样性能不高，下面是一个简单的测试：

组件代码：

<script>
  import { afterUpdate, onMount } from "svelte";
  import { blur, scale } from "svelte/transition";

  export let emoji = "";
  export let start = 0.65;
  export let delay = 100;
  export let amount = 1;

  let first = true;
  let show = false;

  onMount(() => {
    show = true;
  });

  afterUpdate(() => {
    (first && emoji && show) && (first = false);
  });
</script>

<div class="relative aspect-1 [&>*]:(absolute left-1/2 top-1/2 -translate-1/2)">
  {#if emoji && show}
    {#key emoji}
      <div in:blur|global={{ delay: first ? 0 : delay, opacity: 1, amount }} out:blur={{ opacity: 1, amount }}>
        <div in:scale|global={{ delay: first ? 0 : delay, start }} out:scale={{ start }} class={emoji} />
      </div>
    {/key}
  {/if}
</div>

在 terminal 中直接提问 LLM！

2024-11-08T09:55:00.000Z

最近要赶毕设开题和比赛路演的事情了，今天可能是近期最后更新一下 m 的东西。今天新加了最基本的 ask 的功能和 config 命令，长话短说，现在你可以这样使用

pip install muspi-merol[all] -U

m config chat.options.model Qwen/Qwen2.5-7B-Instruct
m config chat.openai_base_url https://promplate-api.free-chat.asia
m config chat.openai_api_key from-blog

m --help | m ask "介绍下怎么用这个 CLI"

这是个用自己解释自己的例子。

第一行是安装这个库，muspi-merol[all]会安装今天新发布的子包 mm-chat，其中目前只有 ask 这一个基本的调用 llm 的命令，目前不包含任何提示工程
后面是帮你设置了一些配置项，使用我搭建的免费 OpenAI API，使用 Qwen 2.5 7B 作为默认模型
然后把 m --help 的结果 PIPE 给 m ask，你运行下就知道是什么效果了

只要你提供 base_url 和 api_key 就可以支持任何 OpenAI API，所以 Ollama 啊 vllm 什么的本地模型都是可以直接使用的！

很多时候，用某些命令行工具遇到问题的时候，没时间看文档，只想直接解决。通常需要自己复制到某个 AI Chat 的网站去问，现在只需要 ... | m ask 就可以直接提问了

尝试双线程聊天

2024-11-07T03:21:41.000Z

上周又被女朋友删了微信，后来就在 QQ 交流，直到今天才加回来。她叫我 QQ 也要保持联系，原来想还觉得挺麻烦，今天忽然发现挺好的

我以前一直觉得国内的聊天软件太初级了，居然连一个 thread 的功能都没有，想相同的人群中并发几个话题基本上不可能。我以前试过同样几个人建很多群，但是后来由于不能折叠等原因，早早就作罢了，收敛到仅剩几个群

所以结论是用群来分类是很难的，但是如果只有同质化（非命名的）多个聊天框呢？我觉得是可以尝试的。

我打算就拿我跟我女朋友做实验，试试通过两个平台同时维护两个话题是否可行。

可以想到的一个问题是，两个话题没法互相引用（微信和 QQ 的消息）、QQ 不方便转发微信公众号和小程序的内容等

但是 QQ 一个好处是它的表情比较有异域风情

m 的诞生

2024-11-06T15:04:20.000Z

最近歪楼去做了一个项目，源于我英语不太好，commit message 总想不到最准确的表达，而 Copilot 不知道抽什么风，经常生成中文的 commit message，要么就是贼长，而且大小写、动词还是名词都不符合我同一个项目的写法。

于是打算自己做一个 CLI，用来生成 commit message，倒不一定要一步到位直接帮我 commit，可以写入剪贴板，感觉这是个很舒服的工作流。后来觉得这个 CLI 工具可以拓展下，加上一些我比较需要的功能。第一个想到的是 alias 的功能，以前都是用 pdm scripts，非常好用，但是现在不用慢吞吞的 pdm 改用 uv 了，而 uv 没有现在还没有 scripts 管理的功能

另外就是，确实好像没有个跨平台的 alias 工具。

于是我实现了个。就叫它 m 吧。它的配置存在三个地方，用户目录、venv 中 m 自己的文件夹下、pyproject.toml 中。这算是最佳实践了。python 中似乎没有这样的库，我打算之后完善了之后这一部分也可以单独封装个库来。下面是一些基本用法：

m alias x "a b c d"

这样就设置了 x 为 a b c d 的别名。可以这样使用：

m x --p v  # 相当于 a b c d --p v

昨天配置了 uv workspace，第一次尝试用一个 monorepo 的架构维护 python 库哈哈哈。今天解决了一些问题，基本上 alias 的功能算是做完了。还发现了 typer 的一个 tab completion 的 bug，所以把 completion 的功能关了，这样还减少了一个依赖哈哈哈

我目前已经加了好多 alias 了，确实都是我日常会用到的，下面是一些比较奇特的

amend 一个提交，然后强推，或者强制同步 origin HEAD
一键更新各种包管理软件和他们管理的包
ssh 到开发服务器

由于 PyPI 上短名字都被占了，我的包名还是 muspi-merl，也就是说安装略微麻烦：

pip install muspi-merol

感觉有点长，不熟悉我名字的可能不好输入。我也发邮件问了自 2014 年占了茅坑不拉屎的 M 包的作者能不能白送我，目前没收到回复。等这个包变得更多功能了之后再考虑吧~

这几天准备加上：

管理环境变量
- m env set / get / del
从文件读取到剪贴板 / 从剪贴板粘贴到文件
- m copy / paste
chat 的功能（这也是最初做这个项目的目的）
- ... | m ask ""
生成 commit message
- m gen commit
生成 README
- m gen readme
发起 HTTP 请求，类似 httpx[cli]，但是支持流式响应和柯里化传参（中途 input）
- m get / post / ...

水了两周（睡了两周）

2024-11-04T09:03:31.000Z

这两周状态不太好，每天半夜才睡，中午/下午才起床，好多课都没上成。本来和几个传播学的师姐一起打了个传播学与AI交叉的创新创业比赛（ppt向的），但是总体不太顺利。希望能进复赛吧，希望能去北京路演 :)

这次首次尝试了用代码来做设计稿，还蛮有意思的，可能之后会把这个风格的设计用到别的项目中。

搞这个项目还跟女朋友闹了不少矛盾，正好在大家都忙的时候，搞出不少麻烦事儿。加上上上周 migrate 到 Svelte 5 的时候电脑突然坏了，耽误了好多时间，后来去小米官方维修了，把所有数据都不要了刷机，结果那次 migrate 还没 commit，无缘 Svelte 5 哈哈哈

上周似乎几乎没有什么成就。哦，做了个@mozilla/readability的 python wrapper，在 pyodide 环境就是用原生 js 运行时运行 js 代码，否则用 pythonmonkey，pythonmonkey 的 staff 似乎本来还挺有热情的，但是我那段时间很 down，似乎浪费了一次合作机会

也没时间给它做个 web demo 唉

☀这周开始要恢复状态！

手头上有个自动化操作浏览器的项目，还有个 pdf 转 md 的项目，希望能做好。希望能这周内做好。

阅读 Svelte 5 的 migration guide

2024-10-25T11:45:50.000Z

Svelte 5 migration guide • Docs • Svelte

总之，Svelte 5 的很多设计看起来是让门槛高了，但是它的好处也很直接，当项目尺寸上来了就有糖吃了。

当然也有一些我认为很不美观的，比如

另外，我是一个很喜欢编译的人，但是 Svelte 5 更多的魔法去掉了，变成了 runtime 的 Signals，我想了想，其实性能或者说编译之后的还是那样，这么看来之前的一些设计其实有一定过度设计了。

这个也太 JSX 了：

Snippets instead of slots

这一段我觉得太有意思了。真的就是大大提升了一致性。这一点我以前也诟病过

就是现在感觉 Svelte markup 越来越像 JSX 了，有没有一种可能，以后直接就用 JSX 了呢？

还真是。我的编译梦破了

升级时发现 bits-ui 改了好多，唉好麻烦

useDefaultParameterLast 和 noDelete

2024-10-23T14:56:56.000Z

今天尝试把 bundle 过后的丑陋代码进行格式化，当时开启了performance/noDelete和style/useDefaultParameterLast这两项，结果就出问题了，虽然具体没发现是怎么个过程，但是现在算是知道这东西不安全了

怎么用 late chunking 嵌入长文档

2024-10-22T05:41:55.000Z

看了 Jina Embeddings v3: A Frontier Multilingual Embedding Model 了解到 late chunking（迟分）的技术，正好毕设这边要做论文 RAG，我觉得可以用上。

但是它一个坏处是，模型本身只能 embed 8192 tokens 的文本，所以天生地不适合做论文这种大体量的 embedding

于是我想了个办法，就是用滑动窗口。坏处就是，这样的成本会飙升，毕竟相当于 embed 每个块都要用 8192 tokens。但这不失为一种办法。而且做毕设应该不用自己掏钱吧，如果学校一毛不拔的话那不太可能。

刚刚想到一些降低成本的方式：

由于本质上都是对 markdown 进行 indexing，所以其实每个块大概是这样的：
1. 路径信息（类似面包屑导航，某某大标题某某小标题这样）（这一部分是 sticky 的，每个 chunk 都要带上这个）
2. 直到下一个小标题之前的所有文本
然后每个标题之间的长度可能超过 8192 可能不超过，所以不会每次都一定要顶满 8192（暂且认为只要带了标题就带上上下文了）
这是不是就是一种 contextual retrieval 了呢？如果我假设面包屑信息就是所需的上下文的话？Introducing Contextual Retrieval \ Anthropic

这么一想，觉得应该发个库，用来解决 markdown chunking 的事情。它除了用 AST 分割标题、然后插入面包屑外，还要做下面两件事情：

如果某个块还是太长，则要成小块
如果某个块太短，则相邻几个合并成大块
- 阈值怎么选择？我觉得和面包屑长度相比是个办法。如果比面包屑还短，那基本上就没必要单独一块了

对这个才是最先决的条件。基本上我什么 RAG 都是先转成 markdown 再改

更何况最近也准备推一下我这个 LLM Web Reader Demo 项目

九阳与小家电

2024-10-19T09:29:43.000Z

九阳股份投资价值分析报告

从上面的内容看，九阳有哪些独特优势？相对于小家电行业的其它品牌

品牌认知度：九阳作为豆浆机的发明者，成功将自身品牌与豆浆机紧密绑定，形成了强大的品牌认知度。消费者对九阳的认知主要集中在豆浆机及相关产品上，这为其在市场中建立了良好的口碑和信任度。
丰富的专利技术：九阳拥有大量的专利技术（6,521项），其中实用新型专利占比超过80%。这表明九阳在产品研发和创新方面具有较强的能力，能够不断推出符合市场需求的新产品。
研发投入：九阳的研发占比为3.5%，高于行业内其他品牌（如小熊的2.3%），并且拥有相对较高比例的研发人员（约20%）。这使得九阳在产品功能和技术上能够保持竞争优势。
轻资产运营模式~~~~：九阳的资产负债表显示其固定资产占比较小，流动资产占比高，属于轻资产运营模式。这种模式使得九阳在资金运用和风险控制上具有更大的灵活性。
多元化产品线~~~~：九阳在小家电领域的产品线覆盖广泛，包括豆浆机、电饭煲、破壁机等，形成了多元化的产品组合，能够满足不同消费者的需求。
市场拓展能力：九阳与SharkNinja的协同效应使其能够在清洁家居市场和厨房电器领域进行有效布局，借助Shark的品牌影响力和渠道优势，进一步拓展市场份额。
良好的现金流和流动性：九阳的流动资产占比较高，且现金流状况良好，这为其在市场竞争中提供了充足的资金支持，能够快速响应市场变化。
适应市场趋势的能力：九阳能够及时把握市场趋势，如疫情带来的“下厨热”，并通过产品教育和市场推广来满足消费者的需求，增强了其市场竞争力。

No. 923

2024-10-18T06:42:43.000Z

居然也是 7 的倍数哈哈哈

关于 SharedWorker 踩的坑

2024-10-16T09:27:52.000Z

开发方面

`console.log`不方便

必须到 chrome://inspect/#workers 去点 inspect 才能看到它的console.log所以基本靠不了这个来 debug 了

相比之下 worker 就没问题

`port`不好拿

在 onconnect 时似乎有一个event.ports，但是往往只有一个 port，而且理论上就应该只有一个，搞不懂为什么是 ports 而不是 port
在 message event 中，也有个 ports 的属性，但是永远是空的，得通过event.currentTarget来拿，真够奇怪的

部署方面

不知道是不是我的情况不太一样，反正我就是没法用非 module 的方式打包，所以new SharedWorker()的时候，必须指定 { type: "module" }。另外，在vite.config.ts中也得改：

export default defineConfig({
  worker: {
    format: "es",
    plugins() {
      return [sveltekit(), dir2json({ include: ["**/*.py", "**/*.j2"] })];
    },
  },
});

一是得指定 format 为 "es"，二是得重新指定一遍 plugins，搞得我 debug 了好久

这个项目源于我想把 pyodide 运行在 SharedWorker 中，这样一是启动时不会 block UI 了，二是多个标签页中可以共享一个 python 实例：

我的想法是，以后允许三种方式启动 pyodide：

	主线程	Worker	SharedWorker
加载	会阻塞	只用等待	甚至可能不用等待
隔离性	共享	可以隔离	可以隔离但更蛮烦
可以打断	不可以	可以	可以但更麻烦
生命周期	页面	页面	不好控制
作用域	window	DedicatedWorkerGlobalScope	SharedWorkerGlobalScope

这么看来主要是生命周期不好管理，而且如果要隔离的话就很麻烦。以后再在这个分支上写吧

不过目前看来，除了麻烦，用 Worker 其实没什么优势哈哈哈

Promplate 目前的成果总结

2024-10-10T12:57:46.000Z

正好要给一个朋友介绍一下，于是自己就整理一下：

项目	面向	进度	介绍
promplate	开发者	stable	一个用于用到提示工程的项目的 python 库（未来可能也实现一个 JavaScript 版本的，应该不难），包含一个模板引擎、一个基于状态机的 LLM agent 框架、一个调用 OpenAI API 的 chat completions 客户端。事实上，promplate 的名字就是 prompt + template，因为这就是提示工程的核心
promplate-demo	开发者、普通用户	stable, development	一个提示工程服务端项目，本意是作为使用 promplate 做提示工程项目的一个 demo，现在作为我一个免费的简单 LLM chat 服务网站的后端。其中包含十几个 LLM 供应商的集成、一些实用的提示工程实现，比如翻译、提取、总结，以及有一个 WIP 通用领域 agent 实现
reasonify	普通用户、研究者	beta	一个非常实验性的 agent，它不生成文本，而是只生成代码。它生成的代码会立即运行，实现与用户的交互。应用场景是一些代码任务，这个项目目前完成度还不太高
partial-json-parser	开发者	stable	一个用于解析流式传输中的 JSON 的 parser，现被用于 vllm 等多个库中
partial-json-parser-js	开发者	stable	同上，但是是 JavaScript 实现的
promplate-pyodide	开发者	stable	一个对 promplate 的 monkey patch，使其能在 pyodide 环境中运行
promptools	开发者	stable	一些与 promplate 不绑定的工具函数，对 promplate 没有强制依赖
promplate-trace	开发者	unmaintained	将 promplate 与 LLM observation 平台的集成，目前支持 langsmith、langfuse，未来准备支持 literal、lunary、logfire 等，让使用 promplate 的提示工程项目可以以一行代码获得这些平台的 tracing 或者说 logging
isomorphic-fetch	开发者	alpha	一个在 pyodide 和非 pyodide 环境都有一样的 API 的 http 请求库
pyth-on-line	开发者	development	我目前主要在做的项目，目标是成为 Stackblitz、Bolt.new 这样的东西

此外还有一些面向开发者的库，在这里就不提了

细粒度发包

2024-10-09T16:44:30.000Z

我觉得每个包就应该 atomic，一个包就完成最小的一个任务。

无标题文档

2024-10-08T10:06:07.000Z

脏数据

不完整（缺失）
噪音
不一致

数据质量的测度

准确性 accuracy
完整性 completeness
一致性 consistency
时效性 timeliness
相关性 relevance
可信性 believability
可解释性 interpretability

在考虑换一个 markdown parser 了

2024-09-30T13:21:04.000Z

之前随着写前端的经验和耐心越来越多，逐渐尝试了不同的 markdown renderer：

语雀 blog 这边用的是 markdownit + highlight.js（前段时间后者改成 shiki 了）
Free Chat 用的是原项目的 markdownit + highlight.js（但是是同步的）
Anse 用的是 remark-rehype + rehype-prism，现在想来怪不得慢！感觉掉帧的阈值比 Free Chat 这边低一些
Promplate Docs 用的是 remark-rehype + shiki + mdsvex，由于用了 mdsvex 所以其实是渲染出 svelte 模板了，理论上灵活性最大，但既没有 markdown 的 lint 也没有 svelte 的自动补全，所以其实不太好用。更重要的是，在 Generative UI 的时代，mdsvex 这种不能流式渲染的就有硬伤了（除非接受 svelte 编译器在 runtime 运行）
Pythonline 用到是 remark-parse 然后手动从 ast 渲染到 HTML，这使得有几乎足够的自定义性，可以让一些元素（inline或block的代码）具有一些响应性，另外这样不会重复修改 DOM，性能极大程度上提高了，这下基本上只有 parse 的 cost 了

自从尝试过从 AST 渲染到组件，就打算把它迁移到 Free Chat（毕竟这个项目我天天得用，有时候掉帧还是很烦的），突然想到，每种 markdown parser / renderer 肯定都可以拿到 AST 啊，何必用 remark-parse（毕竟我也没用上它什么插件，如果它性能不好的话，就没必要用它了）

marked vs markdown-it vs remark vs showdown: Which is Better Markdown Parsing Libraries? (npm-compare.com)

没想到 remark 的 star 数和 download 这么少。一直以为它才是最现代的 best practice 呢

《数字图像处理》笔记

2024-09-23T00:03:22.000Z

视觉过程

光学过程
化学过程
神经处理过程

整体视觉过程

图像成像模型

2D 亮度函数：亮度是能量的亮度

采样和量化

显示分辨率 / 观测分辨率

灰度插值

前向映射：一个失真图的像素映射到不失真图的四个像素之间，最后灰度是由许多失真图像素的贡献之和决定

前向映射是从已知图像出发的，由已知图像向未知图像的映射

后向映射：从未知图像出发

直接灰度映射（点运算）

讲$ f(x, y) $按$ E_H $变换成$ g(x, y) $

直接灰度映射是一种点操作

常见的灰度映射

图像求反
增强对比度
动态范围压缩
灰度切分

做了一个适合 Safari 的 banner 效果

2024-09-29T15:32:15.000Z

发了小红书：https://www.xiaohongshu.com/discovery/item/66f96cee000000001a021da7

细节放大版：https://www.xiaohongshu.com/explore/66f971bb000000001b0203ab

灵感来源于：Banners that adapt the theme-color / X

记一个 Safari 的 bug

2024-09-29T07:25:59.000Z

input 的click/select的 eventHandler 会阻止它被选中，可能是要等到这个 handler 处理完了才会被选中

发现的原因：当时在给一个<label>元素加了 ripple 的效果之后，发现 iOS 上变卡了

<input type="radio" name="model" {id} hidden on:select={() => setModel(id)} checked={$model === id}/>

<label use:ripple={{ color: 'var(--c-fg-70)' }} for={id}>
  <h4>{name}</h4>
  <h5>{title}</h5>
</label>

后来的解决办法，是改成用<button>，但我还是很喜欢用 label 和 input 这样，所以后来还是保留了 label 为 sr-only

“创新预算 (innovation budget)”之于我

2024-09-28T03:55:04.000Z

之前一位汇丰的朋友推荐我一篇很有趣的文章 —— Choose Boring Technology（選擇無聊的技術）

今天又在一个地方看到提到这个概念，我又想起来它，于是准备写一写我的看法。我当时是这么回复他的：

I like the idea that each project has "a limited number of innovation tokens to spend“. For me, however, I am more oriented towards technology rather than specific projects. So, technologies I chose are never unknown to me, and they don't waste my innovation tokens. For enterprises, I don't like competing against rival products in front of them. I always (overconfidently) believe there are currently no alternatives in the market segment where my product is positioned.

我的意思是，我自己的项目，从来不是目标导向，而是技术导向。我并不是想做什么产品，于是去学习它需要的技术，而是自己凭兴趣去学一些技术，同时想想他们能做什么项目出来。当然，这些项目可能会需要一些我还没学的技术，这时我会去判断我对那些兴趣是否感兴趣，如果不感兴趣或者太多太难或者不适合我，我就不会立即去做这些项目。

后来当我跟女朋友聊起这个观点的时候，想到，我大学时很多项目不了了之了，其实就是这个个性的必然结果。对于很多项目，我其实并没有对他们的技术那么有兴趣。在做着做着，发现我在为了这个目标，消耗了过多的 innovation tokens，超过了我的创新预算，而我有是一个不好意思跟别人说不做了的人，于是屡次发生了跑路的事件😂在此再次向大家抱歉一下~我保证在以后可能的合作中，我如果觉得做不下去了我会及时诚实相告。

OpenAI 欺骗消费者

2024-09-25T06:04:47.000Z

可以看到这两个的价格是一样的，但其实上面是 gpt-4o，下面是 gpt-4o-mini

In calculating-costs it is documented that:

Each of those squares costs 170 tokens. Another 85 tokens are always added to the final total.”

But on pricing only the gpt-4o's price is right, the gpt-4o-mini's is larger, which makes the price equals the gpt-4o's.

If I can use 4o at the same price compared to 4o-mini, why am I using 4o-mini?

As a consumer who has been trusted OpenAI for more than a year, I feel deceived to certain degree.

果断投诉！

没截图，但是其实即使不开{"detail": "low"}计算出来的结果也是一样的。所以我觉得要么这就是一个错误（退钱！）要么就是存心的！

计费项目	价格 / 数量
Price per 1M tokens (fixed)	$5.00
Resized width	1000
Resized height	500
512 x 512 tiles	2 × 1
Total tiles	2
Base tokens	85
Tile tokens	170 × 2 = 340
Total tokens	425
Total price	$0.002125

Cerebras 与 Groq

2024-09-25T16:11:14.000Z

新简历起草

2024-09-25T12:48:08.000Z

我是 Muspi Merol (abbr)，庄毅辉，一名北师珠的 undergraduate，一名开源爱好者

我关注 LLM 应用、开发者工具、教育、设计 (icons)

作为一个技术栈丰富，同时也有一定工作经验的个人，我的理想工作是产品经理 / 全栈开发者 / 受赞助的全职开源者。我需要一份能维持生计的薪酬，但是氛围活泼、技术前沿，且一定程度上支持async

项目经历

为了量产提示工程项目，我有一套开源框架。我秉持 atomic 的精神，在完成主线任务的同时也让支线任务”桃李满天下“—— partial json 库 js 和 py stats 周十万下载量链接
目前正在做一个 Stackblitz + Codepen for Python 的项目。在做这个项目的过程中为 upstream 贡献了数个 PR，成为了 10K+ stars 项目的 member
在学校正在异步进行几个与生物学、社会学交叉的的项目
有一个持续一年多的半公益项目
未完待续……

实习经历

全栈工程师、提示工程师

大三时我在上海守扣科技有一段快乐的实习经历，同事氛围轻松，工作内容开放。同时在杭州槲丰科技有一段有收获且特别的实习经历。离开上海是因为自由度不够高，且项目管理缺乏工程化。杭州的老板和工作内容在各种方面都很好，但是做的是 toB 的生意，个人不太有兴趣而且中途因为一些错误决定就退出了。也有一段在成都爱进化科技的短暂的实习经历，目前感到唯一的缺憾是同事不够年轻，后来由于个人安排暂时没有继续。

设计总监、研究助理

在大二时参加了学校里的 6+ 个宣传部门，负责平面设计、摄影等工作，有做管理的经验，有一定自媒体的经验（但个人不喜欢行业氛围）。

可以有一个向我提问的按钮，一方面用一个 Q&A 列表 RAG，另一方面可以直接发邮件通知我

无标题文档

2024-09-23T05:33:40.000Z

MPI 消息传递接口

显式通信

手机淋雨屏幕坏了

2024-09-22T14:05:35.000Z

似乎什么都干得了，就是屏幕显示和触摸屏没反应

好烦感觉要体验一下没有手机的日子了

《大数据分析》笔记

2024-09-20T05:36:31.000Z

特征工程

属性类型

标称属性
- 二元属性是特殊的标称属性
- 非对称二元属性指概率不同的二元属性
序数属性
- 相继值之间的差是未知的
数值属性
- 离散属性、连续属性
- “无限可数”：比如学号

特征工程

特征提取
特征变换
特征选择

特征变换

z-score 标准化：均值为0，方差为1
最大最小归一化

分箱离散化

等宽分箱：“箱子的宽度”相同
等深分箱：每箱实例数称为“箱子的深度”

分箱后，用箱均值、中位数或边界值替换箱中的每个值，实现属性值的离散化

特征变换

数值化处理

有序变量
无序变量
- 二分类：01
- 多分类
  - one-hot
  - 标签编码（无含义）

数据降维

主成分分析 PCA

m 个 n 维数据样本矩阵 X
X 的每行零均值化
求协方差矩阵
求协方差矩阵的特征值及对应的特征向量
将特征向量按对应的特征值大小从上到下按行排列成矩阵，取前 r 行组成矩阵$ W^T $
$ Y = W^TX $即为降到 r 维后的数据

线性判别分析 LDA

有监督的线性降维

基本思想：使用数据的类别信息，将高维的样本线性投影到低维空间，使在低维空间中数据的类别区分度最大

区分度？

不同类之间的离散度
同类数据的内聚性

Lasso 降维

一种回归分析方法，通过 L1 正则化实现选择和降维

ISOMAP

流形（manifold）是一类几何对象的总称

用测地距离（geodesic distance）代替欧氏距离

算法步骤

构造近邻图
- 对每个节点（每个样本），构造边（k 近邻，对每个近邻点，构造一条边……最短路径长度）
计算最短路径
找出样本的低维表示

优点

保留了全局结构
只有一个参数 k 需要确定

缺点

对噪音敏感
Floyd 最短路径算法的计算代价高

特征提取

文本数据结构化

词袋法 n-gram 模型
词嵌入法
- word2vec 简单的神经网络模型
  - 连续词袋模型 CBOW：根据上下文词语预测目标词出现的概率
  - 跳字模型 skip-gram：根据目标此预测其上下文
    - 通过预测周围词来训练中心词的向量表示，表示能力往往更好

word2vec 缺点

在独立的局部上下文窗口上训练，难以利用单词的全局统计信息
对词是确定性的，即在不同语境中同一词的向量是一样的，这意味着 word2vec 不能解决多义词问题

特征选择

过滤式 filter —— 基于统计测试/其它单变量评估指标
包裹式 wrapper —— 于模型训练过程结合，作为评价特征子集优劣的标注（验证集？）
嵌入式 embedded —— 在模型训练过程中进行特征选择，入决策树、随机森林等

基于树模型的特征重要性

基于线性模型的特征重要性

基于互信息的特征重要性

基于 SHAP 值的特征重要性

基于随机排列的特征重要性

昨天在做爬虫

2024-09-19T09:00:08.000Z

基于 playwright 的爬虫，让 LLM 来做标注

结果包含了 LLM 生成的选择器（经过一个 reflection 步骤确保了一定能解析）、选择到的元素、这些元素的 computedStyle 交集

核心代码：

@main_loop.callback
class _(Callback):  # noqa: N801
    max_retries = 4

    async def end_process(self, context: ChainContext):
        dom: Selector = context["dom"]

        res: dict[str, str | None] = loads(context.result)
        problems = context["problems"] = []

        for key, selector in res.items():
            if selector:
                print_label(f"{key} - {selector}")
                try:
                    if results := dom.css(selector):
                        show(results)
                    elif self.max_retries:
                        problems.append((key, None))
                    else:
                        res[key] = None

                except SelectorSyntaxError as e:
                    print_exception_only(e)
                    problems.append((key, format_exception_only(e)))

        if not problems or self.max_retries <= 0:
            raise Jump(out_of=main_loop)

        self.max_retries -= 1

也想做这样的图表

2024-09-18T16:33:14.000Z

在 py3.online/pypi 上

取 dict 的交集

2024-09-18T12:05:06.000Z

大概这样的效果：

实现：

from collections import Counter

def merge_computed_styles(computed_styles: list[dict[str, str]]):
    counter = Counter()

    for style in computed_styles:
        counter.update(style.items())

    return dict([pair for pair, count in counter.items() if count == len(computed_styles)])

在线尝试：

https://bnu.py3.online/telegraph/computed-styles-09-18

Ruff Settings in VS Code

2024-09-18T01:22:59.000Z

为了 fix on save

{
    "[toml]": {
        "editor.formatOnSave": false
    },
    "ruff.lint.select": [
        "I"
    ],
    "[python]": {
        "editor.defaultFormatter": "charliermarsh.ruff",
        "editor.codeActionsOnSave": {
            "source.fixAll.ruff": "always"
        }
    }
}

可以用作 py 项目的 setup template

2024 年中秋 🥮

2024-09-17T16:22:10.000Z

福州之旅尾声，听说爸妈来珠海找我过中秋。于是时隔四年又去了圆明新园。

图：不知道为啥树须下面有些小揪揪。怀疑是不是先前的须根抓住了土，结果水位下降了？

晚上去了澳门环岛游其实也蛮骗钱的。但是天气不错

沉迷长曝光

说起来我觉得这种也应该算是前景。让前景模糊不仅可以靠景深的方式，也可以靠动态的方式。两者在冥冥之中是有点联系的（一点随想）

这么看有点像火箭发射塔😃

但是颜色好脏😭

各种地标吧。也没啥意思。倒是在想什么时候上面能挂我的广告

反复拍

毕竟船开得慢，也没人聊天

这个居然自动变了

但是右上角可以看到应该是连了非内地的网络了，于是扣了我25块钱。据说是1元1MB，25元封顶送1GB。什么狗屁笑死。明天就去投诉。我现在就是闹事先锋~

语雀的上传图片好像不会转格式，导致我 HEIF 都没法显示。唉。早晚得做个自己的 CMS

第一次收到别人的 PR 👻

2024-09-17T08:00:16.000Z

早上送走爸妈之后才发现今天没看 GitHub 通知，一打开

大部分都是垃圾信息，但是发现居然有人给我的 partial-json 提了一个 PR

Add OUTERMOST_OBJ and OUTERMOST_ARR allowances by alanpog · Pull Request #9 · promplate/partial-json-parser-js

Sourcery 的总结还挺好的，一看就懂

说起来，很戏剧性地，由于我这个项目是刚开始用 JavaScript 的时候写的，当时还不太懂 CI，于是没有配 formatter 的 config，这个人直接不小心把所有文件都重新格式化了，造成 600 行的 diff 😂

说回到这个功能，虽然我自己先前也想搞这么个东西，但是由于觉得想不到完美的设计，所以就没干了。

Your proposal is great and this implementation works well. But due to my perfectionist tendencies, I often find myself wondering if there's an even better way to solve these kinds of problems.

但是直接拒绝别人也不太建设性。于是我就想了很久（一个中午下午都耗在这上面了）

想了两个解决方案：

Approach One — Input Predicate Function

The parse will take an options object to extend configuration besides simple allow. We may support inputing a validate predicate function to choose whether to allow an object / array. The signature of options may look like this:

interface options {
  allow: number;
  validate(parsed: any, text: string, parents: Parent[]): boolean
}

type Parent = {
  type: "OBJ";
  key: string;
} | {
  type: "ARR";
  index: number;
}

For example, if user do this:

parse(`[0, {"a": [{`, { allow: ALL, (parsed, text, parents) => { ... } })

The validate function will be called at most 4 times with

validate({}, '{', [{ type: "ARR", index: 0}, { type: "OBJ", key: "a" }, { type: "ARR", index: 1}])

validate([{}], '[{', [{ type: "OBJ", key: "a" }, { type: "ARR", index: 1}])

validate({"a": {}}, '{"a": [{', [{ type: "ARR", index: 1}])

validate([0, {"a": {}}], '[0, {"a": [{', [])

Approach Two — Return PartialInfo

Inject some information into the return value. Like this:

export const partial = Symbol('__partial__');

And the partial information may be like this:

interface PartialInfo {
  text: string;
}

Then users can filter the result themselves using this information.

For example, if using this way:

> res = parse(`[0, {"a": [{`, { allow: ALL, inject: true }) // [0, {"a": [{}]}]
> res[0][partial] // undefined
> res[1][partial] // { text: '{"a": [{' }
> res[1].a[partial] // { text: '[{' }
> res[1].a[0][partial] // { text: '{' }

They can drop at any depth level as they wish.

今天顺便集成了 StackBlitz 的 pkg.pr.new 的持续发布

现在每次 commit 都会可以被安装了🥳

记几个新认识的 tailwindcss 语法

2024-09-15T16:25:01.000Z

偶然发现几个从没用过但有用的 tailwind 语法，记录一下：

不用[&>*]:...了，应该直接*:...

不用w-6 h-6而是应该直接size-6

可以在:root上加一个text-pretty

测试 iframe

2024-09-14T11:10:06.000Z

最近主要在改 pyth-on-line

2024-07-01T17:03:55.000Z

is hard-coded, causing traceback disappear when filename specified · Issue #4901 · pyodide/pyodide

最近很喜欢 stackblitz，所以好几个 Issue 都提供了 dedicated 的复现

更舒适的 PyPI 浏览器

2024-09-02T07:26:22.000Z

又花了好长时间微调 UI/UX，感觉好焦虑，明明已经时间很紧迫了，但是就是不做到完美不忍心 merge

A PyPI Explorer · Pull Request #61 · promplate/pyth-on-line +376 -0又一次突破记录了😂

下一步估计得等到很后面再接着做了 [pypi] next steps · Issue #64 · promplate/pyth-on-line

第一次搞 polyfill，感叹 JavaScript 的 GC 真麻烦

2024-06-09T07:52:50.000Z

GitHub Gist: https://gist.github.com/CNSeniorious000/9fc1a72e45358dd7c9e2f16e5d26df5c

起因是要给pyodide.http支持在 cancelled 的时候自动 abort，就需要 AbortSignal.any，结果 maintainers 之一发现这个 API 很新，甚至 FireFox 2024年才刚实现。所以叫我得 polyfill

研究了半天发现这还真不容易，而且似乎没有现成的可供 copy，只好自己实现

为此接触了 JavaScript 的WeakRef和FinalizationRegistry，还锻炼了一下写 JsDoc 的技能

想法：

JavaScript 的FinalizationRegistry相比 python 的__del__还是有不方便的地方的，因为一个 registery 必须自己不被 gc 才能有用
JavaScript 里不好手动触发 gc，搞得调试比较玄学
JavaScript 里似乎即使 gc 了内存还是不会立即释放，python 里倒似乎能在任务管理器看到内存降下去

下面附上 gist 的内容：

export function polyfillAbortSignalAny() {
  /** @param {AbortSignal[]} signals */
  return (signals) => {
    // if (AbortSignal.any) {
    //   return AbortSignal.any(signals);
    // }
    const controller = new AbortController();
    const controllerRef = new WeakRef(controller);
    /** @type {[WeakRef<AbortSignal>, (() => void)][]} */
    const eventListenerPairs = [];
    let followingCount = signals.length;

    /** @type {FinalizationRegistry<(callback: () => any) => void>} */
    const registry = (globalThis.__abortSignalCleanups =
      globalThis.__abortSignalCleanups ??
      new FinalizationRegistry((callback) => void callback()));

    signals.forEach((signal) => {
      const signalRef = new WeakRef(signal);
      function abort() {
        controllerRef.deref()?.abort(signalRef.deref()?.reason);
      }
      signal.addEventListener("abort", abort);
      eventListenerPairs.push([signalRef, abort]);
      registry.register(signal, () => !--followingCount && clear(), signal);
    });
    function clear() {
      eventListenerPairs.forEach(([signalRef, abort]) => {
        const signal = signalRef.deref();
        if (signal) {
          signal.removeEventListener("abort", abort);
          registry.unregister(signal);
        }
        const controller = controllerRef.deref();
        if (controller) {
          registry.unregister(controller.signal);
          delete controller.signal.__controller;
        }
        console.log("clear", ++count);
      });
    }

    const { signal } = controller;

    registry.register(signal, clear, signal);
    signal.addEventListener("abort", clear);

    registry.register(controller, () => console.log("controller", count));

    signal.__controller = controller;

    return signal;
  };
}

export let count = 0; // for test only

// node --expose-gc

({ polyfillAbortSignalAny } = await import("./polyfill.js"));

any = polyfillAbortSignalAny();

a = Array.from({ length: 2 }).map(() => { const c = new AbortController(); return [c, any([c.signal])]; })

[x, y] = a[0]

x.abort()

// a = a.map(([x, y]) => x) // to remove the references for followers
// a = a.map(([x, y]) => y) // to remove the references for origins

gc()

// look at the output

好了现在更多疑点了。不知道为什么在 vitest 或者以脚本形式运行的话，就是不会触发 gc

所以总是得用命令行打

一开始是用 vitest 发现不行，又用 watchfiles 发现也不行

不过这也算是积累了小型 JavaScript 脚本的调试经验：watchfiles 比 vitest 甚至还方便

但是我 tsconfig 还是配置不对好烦而且这玩意算是搞了今天一天

居然一天写了 18 小时代码

2024-05-23T14:10:38.000Z

为什么不用 Astro

2024-05-13T11:26:30.000Z

astro 我觉得好的特性是它的 island，可以融合多个生态

但是对我来说，我不需要那么多生态。但我需要差量更新和链接的预加载，因此我自己的项目不用 Astro

好的，现在发现 prefetch 其实也是有的，之前是我寡见鲜闻了。这样的话没有差量更新其实也能接受。

现在也有 type-safe 的 action 功能了，感觉确实尝试切换到 astro 了

不过其实还是有个问题：如果我的整个应用几乎每个组件都是数据驱动的，那 island 就失去它的优势了

而这种响应式肯定是我所期望的。再考虑下切换到 astro 能给我带来的好处：

能更方便地写 markdown （但是如果 markdown 元素都得响应式就有点反而不方便了）
跨页动画用 view-transition 更优雅（但我可能希望更高的自定义程度）

总之感觉 astro 是个很好的解决方案，但确实还是不适合我😂

这个周末在抠 partial-json-parser

2024-05-12T11:31:11.000Z

周五想到一种扁平的、2-pass 的实现，结果一直在 debug

扁平化的结果就是，要分类讨论很多很多情况，对我这种注意力不集中的人极其不友好🥲

我这种人大概是看不得 if-else 三层以上的算法的了😂

hypothesis 真是好啊，我准备把 js 版的也用 pythonmonkey 的 js runtime 接到 python 里，然后也用 hypothesis 来测一下。

欣赏一下 hypothesis 给出的报错：

  + Exception Group Traceback (most recent call last):
  |   File "<string>", line 1, in <module>
  |   File "D:\dev\partial-json-parser\tests\test_hypotheses.py", line 42, in main
  |     test_partial_json()
  |   File "D:\dev\partial-json-parser\tests\test_hypotheses.py", line 28, in test_partial_json
  |     @given(json)
  |
  |   File "D:\dev\partial-json-parser\.venv\Lib\site-packages\hypothesis\core.py", line 1638, in wrapped_test
  |     raise the_error_hypothesis_found
  | ExceptionGroup: Hypothesis found 3 distinct failures. (3 sub-exceptions)
  +-+---------------- 1 ----------------
    | Traceback (most recent call last):
    |   File "D:\dev\partial-json-parser\tests\test_hypotheses.py", line 34, in test_partial_json
    |     parse_json(json_string[:i])
    |   File "D:\dev\partial-json-parser\src\partial_json_parser\core\api.py", line 15, in parse_json
    |     return parser(ensure_json(json_string, allow_partial, use_fast_fix))
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |   File "C:\Users\17979\AppData\Local\Programs\Python\Python312\Lib\json\__init__.py", line 346, in loads
    |     return _default_decoder.decode(s)
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^
    |   File "C:\Users\17979\AppData\Local\Programs\Python\Python312\Lib\json\decoder.py", line 340, in decode
    |     raise JSONDecodeError("Extra data", s, end)
    | json.decoder.JSONDecodeError: Extra data: line 1 column 3 (char 2)
    | Falsifying example: test_partial_json(
    |     anything=[['']],
    | )
    | Explanation:
    |     These lines were always and only run by failing examples:
    |         C:\Users\17979\AppData\Local\Programs\Python\Python312\Lib\json\decoder.py:340
    |         D:\dev\partial-json-parser\src\partial_json_parser\core\myelin.py:124
    +---------------- 2 ----------------
    | Traceback (most recent call last):
    |   File "D:\dev\partial-json-parser\tests\test_hypotheses.py", line 34, in test_partial_json
    |     parse_json(json_string[:i])
    |   File "D:\dev\partial-json-parser\src\partial_json_parser\core\api.py", line 15, in parse_json
    |     return parser(ensure_json(json_string, allow_partial, use_fast_fix))
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |   File "D:\dev\partial-json-parser\src\partial_json_parser\core\api.py", line 22, in ensure_json
    |     head, tail = fix_fast(json_string, allow_partial)
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |   File "D:\dev\partial-json-parser\src\partial_json_parser\core\myelin.py", line 139, in fix_fast
    |     assert last_colon < last_comma, f"\n\n  {last_colon = } {last_comma = } {json_string = }"
    |            ^^^^^^^^^^^^^^^^^^^^^^^
    | AssertionError:

  last_colon = 3 last_comma = -1 json_string = '{"": ""'
    | Falsifying example: test_partial_json(
    |     anything={'': ''},
    | )
    +---------------- 3 ----------------
    | Traceback (most recent call last):
    |   File "D:\dev\partial-json-parser\tests\test_hypotheses.py", line 34, in test_partial_json
    |     parse_json(json_string[:i])
    |   File "D:\dev\partial-json-parser\src\partial_json_parser\core\api.py", line 15, in parse_json
    |     return parser(ensure_json(json_string, allow_partial, use_fast_fix))
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |   File "C:\Users\17979\AppData\Local\Programs\Python\Python312\Lib\json\__init__.py", line 346, in loads
    |     return _default_decoder.decode(s)
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^
    |   File "C:\Users\17979\AppData\Local\Programs\Python\Python312\Lib\json\decoder.py", line 337, in decode
    |     obj, end = self.raw_decode(s, idx=_w(s, 0).end())
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |   File "C:\Users\17979\AppData\Local\Programs\Python\Python312\Lib\json\decoder.py", line 355, in raw_decode
    |     raise JSONDecodeError("Expecting value", s, err.value) from None
    | json.decoder.JSONDecodeError: Expecting value: line 1 column 1 (char 0)
    | Falsifying example: test_partial_json(
    |     anything=[''],
    | )
    | Explanation:
    |     These lines were always and only run by failing examples:
    |         C:\Users\17979\AppData\Local\Programs\Python\Python312\Lib\json\decoder.py:354
    |         D:\dev\partial-json-parser\src\partial_json_parser\core\myelin.py:124
    +------------------------------------

Reasonify

2024-03-25T09:40:37.000Z

一个纯 function call 思路的 agent

5月9日更新

重新思考了一下标语

Real AI speaks programming languages
Introducing Reasonify: The First Python Agent in the world

感觉这更像是两篇博文的标题🤔

Agent 的最终形态必然导向

2024-05-09T17:20:51.000Z

想想，如何使得function_call的结果可以直接引用，不用LLM重述？同时又能与各家千奇百怪的LLM API的function_call格式解藕？

回忆回忆rag-compiler的方法

一边生成，一边call，再想想我在promplate-agent实现的单循环agent的parallel call

这种方式真的是具有所有好处

建了一个 PyPI 镜像

2024-04-21T12:01:56.000Z

仅仅在当前安装时使用

pip install -i https://py3.online/simple

设为 pip

pip config set global.index-url https://py3.online/simple

设置 PDM

pdm config pypi.url https://py3.online/simple

设置 Poetry

poetry source add --priority=primary mirrors https://py3.online/simple/

起源

起初只是为了让我的 serverless 在线 python（py3.online）国内也能轻松使用上：

于是就 proxy 了一下 PyPI 和 pythonhosted 两个域名：

实测速度飞快，以安装 torch 为例，速度是清华源的两倍：

但是 Netlify 的响应体上限好像有点低

又试着在别的项目也部署了下，比如

i.free-chat.asia/simple

确实都可以了

Serverless era of Python

2024-04-03T03:57:42.000Z

个人简历

2023-11-28T16:48:24.000Z

庄毅辉

男汉族 2002年

大三学生，现就读于北京师范大学（珠海校区）

GitHub: Muspi Merol @CNSeniorious000 / Email: me@promplate.dev / Tel: 17620453640

目前在珠海学校里佛系创业中

领域：LLM 相关 / Web 前后端开发 / 科班数据科学

部分技术栈

有用 JavaScript / TypeScript 开发 application 和 library 的经验，但是没有做过大项目
- 熟悉 serverless 平台：Vercel / Netlify / Railway
- 熟悉 Svelte（一款语法类 Vue 的新兴 Web 全栈框架）、SolidJS（一款语法类 React 的新兴 Web 全栈框架）
- 在实习公司用 NextJS 14 + LangchainJS 做过
- 非常善用原子化的 css 框架快速开发，自己一般用 unocss，当然 tailwindcss 也可以
- 测试方面用的是 vitest
- 一些例子：索引 / 落地页 / 博客 / 纯静态 / ChatBot
非常熟悉 python，但先不详说了
- Web 开发方面熟悉 FastAPI，也用过 Django 但不太喜欢
- 写过 TGI / 讯飞星火 / 百度文心转 openai 接口的 wrapper；写过 openai 的账号池中间件
- 了解 langchain 以及其它一些提示工程框架例如微软的 guidance
- 用的向量数据库主要是 chromadb，还给它写过一个小轮子 aiochroma
- 蛮熟悉 langsmith 的，目前已经把自己的提示工程框架和 openai 账号池对接 langsmith
Web 标准方面有一定常识
- 熟悉 SSE（但更喜欢用 jsonl 来流式传输）
- 比较熟悉 PWA 但好像国内不太有什么项目用
- 也做过 Vanilla JS / CSS / HTML 的项目
熟悉 cloudflare；熟悉 Linux；会用 Docker 部署；会在 GitHub / Gitlab 上配流水线；熟悉日常的 git 操作
用过各种市面上常用的 LLM 的API，GPT、Claude、百度/讯飞，各种 llama Xwin 啥的

工作经历

在杭州斛丰科技做算法和后端工程师，核心负责用 python 和 JavaScript 实现推荐算法、医学问诊 Chatbot、辅助诊疗可信 AI、基于 embedding 的模糊匹配、医学领域下的类 Copilot、小规模的爬虫等项目等
在上海守扣科技做算法工程师，核心负责用 python 实现基于 chain 的医学知识图谱提取、智能陪练助理、文本格式化等开发，和一些原型项目的简单前端开发
在校期间在多个校媒任设计部部长

个人项目

做了一个专注于灵活性的提示工程框架 promplate，虽然在我的两个实习公司都用在生产环境了但其实完成度还不高，都是用到哪做到哪
更泛用的是一个 python 和 JavaScript 的 JSON 解析库，目标是用于解析 LLM 生成的 JSON。看 DEMO 就懂了
基于开源框架改写维护了两个 ChatGPT 镜像站，顺路学了不少运维等知识，维持公益运营最高时 Google Analytics 统计到 20000 用户/日
写了一些后端的东西，tgi 转 openai 接口的 wrapper，以及讯飞星火转 openai 接口的 wrapper，写过一个账号池实现，接入了 langsmith 来提供可观测性
给学校的校史写了个 documentQA，但是业余时间少，还没完成，因此就不放链接了
一个在线无需服务端的 python console，由 wasm 驱动，带有 AI 纠错等类 Copilot 功能
python 格式化工具 black 的官方 interactive playground

当然还有很多其他项目，都能在我 GitHub 上找到，但是跟 LLM 关联较大的就这些了，所以就不赘述了

东西有点多部分内容可能已经过时了见谅🙏

看到一篇很好的讲 UX 的文章

2024-04-01T04:57:30.000Z

而且非常赞同这篇文章最后说的一段话

Analyzing and making sense of design details beyond just "it feels nice" helps nurture taste, amplify level of execution, and grow appreciation for how hard the pursuit of excellence is.

Invisible Details of Interaction Design 🔗

无标题文档

2024-04-01T04:22:26.000Z

感觉我现在成了调包侠了

ubuntu 配环境 🙄

2024-03-22T06:56:30.000Z

无脑更新

sudo apt update && sudo apt upgrade

安装 clash

git clone https://github.com/Elegycloud/clash-for-linux-backup.git

安装 python

curl https://pyenv.run | bash

安装 node

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash

OpenCloudOS Server 8 配环境

2023-01-22T17:24:06.000Z

因为OpenCloudOS的yum源的问题，所以最好先安装这个包

yum install epel-release -y

然后安装一个htop和screen

yum clean all
yum update
yum install htop
yum install screen

安装Node.js

yum install nodejs

安装python3.11

./configure --enable-optimizations --with-lto --enable-bolt
make
make install

配置pip镜像源

pip config set global.index-url https://mirrors.cloud.tencent.com/pypi/simple

配置npm镜像源

npm install -g nrm

用nrm换源

[root@VM-16-16-opencloudos ~]# nrm ls

  npm ---------- https://registry.npmjs.org/
  yarn --------- https://registry.yarnpkg.com/
  tencent ------ https://mirrors.cloud.tencent.com/npm/
  cnpm --------- https://r.cnpmjs.org/
  taobao ------- https://registry.npmmirror.com/
  npmMirror ---- https://skimdb.npmjs.com/registry/

[root@VM-16-16-opencloudos ~]# nrm use tencent

   Registry has been set to: https://mirrors.cloud.tencent.com/npm/

安装python时遇到常见问题的解决方案

  Some possibly relevant errors from pip install:
      error: subprocess-exited-with-error
-     ModuleNotFoundError: No module named '_ctypes'
      error: metadata-generation-failed
 
  Error installing poetry.

需要安装一个库

yum install libffi-devel -y

重新安装，在make一步出现了这样的报错

The necessary bits to build these optional modules were not found:
_bz2                  _dbm                  _gdbm
_hashlib              _lzma                 _ssl
_tkinter              _uuid                 nis
readline
To find the necessary bits, look in setup.py in detect_modules() for the module's name.


The following modules found by detect_modules() in setup.py have not
been built, they are *disabled* by configure:
_sqlite3


Could not build the ssl module!
Python requires a OpenSSL 1.1.1 or newer

参考网上的文章，要安装这些依赖

yum groupinstall "Development Tools"
yum install zlib-devel bzip2-devel ncurses-devel sqlite-devel readline-devel tk-devel gdbm-devel libpcap-devel xz-devel uuid-devel
yum install sqlite*
yum install -y zlib openssl-devel sqlite-devel bzip2-devel libffi libffi-devel gcc gcc-c++

在~/swapfiles下创建3GB的swap

dd if=/dev/zero of=./swap-1024x3000000 bs=1024 count=3000000
chmod -R 0600 ./swap-1024x3000000
mkswap ./swap-1024x3000000
swapon ./swap-1024x3000000
echo "/root/swapfiles/swap-1024x3000000 swap swap defaults 0 0" >> /etc/fstab

配置JupyterLab密码

jupyter server --generate-config
jupyter server password

安装gh

yum install yum-utils
yum-config-manager --add-repo https://cli.github.com/packages/rpm/gh-cli.repo
yum install gh

Netlify 执行 python 构建脚本比 Vercel 快

2023-10-12T10:57:12.000Z

最近把本人初学 web 时的纯服务端渲染纯 html 前端的项目成功部署到了 Netlify 和 Vercel 上，对比了一下：

奇怪。一直印象中构建前端项目好像 Vercel 快一点的🤔

节后统计

2023-10-09T09:37:11.000Z

kan

就msgpack压缩后大小的问题的讨论

2023-09-27T05:41:01.000Z

在 GitHub 上的 msgpack/msgpack 库下面，很早之前我发起了这么一个话题，今天突然得到回复了

链接在此：https://github.com/msgpack/msgpack/issues/328

我个人得出的结论是：

Length-Prefixed serialization languages is less friendly to compressors compared to Delimiter-Separated serialization languages indeed
More fine-grained research can be done through taking equivalent structures in both JSON and MessagePack, compressing them both with the same algorithm, and then studying the resulting compressed encoding in detail to understand exactly what tradeoffs the compressor made
Web developers should consider JSON fist now and in the future, because compressing is almost at zero cost
This is not saying Length-Prefixed DML is of no use. I think its usage is representing larger data like a HEAD with 100KB body following. And the performance on speed and RAM usage is still huge advantages of Length-Prefixed DMLs
Finally, I think best practice of transmitting data when pursuing ultimate size efficiency, IDLs like protobuf are what you need. IDLs remove the separator of JSON or the HEAD of basic element in MsgPack representing the basic type. If you really want self-explanatory (you want the data can be interpreted without additional type definitions), you can transmit type definition before data 😂

翻译成中文即：

压缩后，长度前缀数据的空间效率比分隔符分隔数据低
可以通过更细致的研究来进行取JSON和MessagePack中的等效结构，用相同的算法压缩它们，然后详细研究结果压缩编码，以理解压缩器做出的具体权衡。
网页开发者现在和未来都应该首先考虑JSON，因为压缩几乎是零成本
这并不是说长度前缀数据没有用。我认为它的用途是表示更大的数据，比如后面跟着100KB体的头。在速度和RAM使用上的性能仍然是长度前缀数据的巨大优势
最后，我认为在追求终极大小效率时传输数据的最佳实践，你需要的是像protobuf这样的IDLs。IDLs去除了JSON的分隔符或MsgPack中表示基本类型的基本元素的头。如果你真的想要自解释（你希望数据可以在没有额外类型定义的情况下被解释），你可以在数据之前传输类型定义😂

本文链接：

就msgpack压缩后大小的问题的讨论

promplate 文档规划

2023-09-25T15:29:45.000Z

basic concepts
- promplate渐进地提高你的提示工程效率。从最简单的text complete，

为什么我要开发promplate

2023-09-14T15:52:40.000Z

每一个听说我造这么一个轮子的人都会有这样的疑问：

promplate 到底解决了什么问题？
在大模型和提示框架百花齐放的当下，重新造一个轮子的意义何在？

我一个一个回答。

promplate 解决了什么问题？

Progressively enhance your prompting workflow.

上面这句是我为promplate整个生态撰写的slogan。什么意思呢，我希望它是一个能帮助到无论是非开发者，还是初学者，还是提示工程师的任何一个人。

对于普通人（非开发者），可以在我的在线编辑器playground上测试提示词。每个人都可以是发挥自己的创意
对于初学者，可以用极简到一个单个形参的函数直接调用我的免费API来开始提示工程之旅。换言之，0门槛
对于提示工程师，我的库具有非常大的可自定义度，它最初只是实现了我心目中的提示工程的最佳实践范式。在其上的开发和元开发都无比简单

认识我的人可能知道，我是一个对代码有着极端的洁癖的人。因此我在开发这个库的时候，是极大程度上地用效率换取对上述优势的保证。显然，要做到上面提到的那样“老少咸宜”，也就是说效率和灵活性要得兼，是非常不容易的。我通过发布一个保证灵活性、保证优雅实现、尽可能提高效率的core包，和一个约定式的提供各种效率工具的toolkit包来做到这一点。

重新造轮子的意义是什么？

造轮子，当然是因为现在没有我理想的轮子。

现在有什么轮子？有大名鼎鼎的 langchain，但是我认为它太大而杂了。这只是从优雅层面的批评，更重要的是：

开发效率低。我认为它抽象程度不够，灵活性不够，约定式的预设也不够用，元开发也难以进行。总之经过我在两个公司的算法岗的实践，我觉得它在不少场景下开发起来不如不用框架。我不是贬低它，只是认为它的意义更多的在于历史意义。langchain 就好比旧 React 和 Vue 2，他们在历史上有很高的价值，但是他们现在看来效率并不高。我要做的就是一个 Svelte，专注于开发效率，更本质上，是探索提示工程的最佳实践。
臃肿，与其它框架冲突。比如，我装一个 langchain 可能并不会用上任何本地的模型，但是它也会安装一个 1GB 的 torch 包；再比如它依赖于旧版本的 pydantic，这使得我没法把它集成到我需要 pydantic 2.x 的 WEB 服务中。
源码充斥着向后兼容，难以阅读。而理解源码几乎是通过继承 langchain 的类来二次开发的必经之路。丑陋的源码就意味着低灵活性，我一直这么认为。事实上，我一直认为，0.x 这样的版本号就是为了无负担地探索无限可能，而不是拖着沉重的身躯爬行。langchain 顶着 0.0.x 这样的版本号，我不认为它应该做像现在这样的向后兼容。如果这是开发者的炫技，我觉得这是害了这个项目。

所以 langchain 不是足够好的框架。还有什么呢？有，出身 Microsoft 的 guidance。它其实给了我不小的启发，它发明了一种模板语言，一个提示工程就是一个脚本，可读性挺高的。我非常欣赏它的尝试，它的模板语言能力丰富，也高效，另外它在提示工程的周边也做了很多实用工具（我自己做不出来的那种），代码也优雅得多，我非常欣赏这个项目。

但它也不够完美，因为它把整个 chain 写在一个模板中，我认为这过于激进了，或者说过于“约定式”了，灵活性在一些方面降低了。比如，将逻辑写在模板中，就没有语法高亮了；另外我也认为这不符合代码和模板分离的原则。promplate 作为后起之秀，会关注到这些坑，并尽可能避免。

除此之外

我一般把“通过重载各种语法，实现一些方便的调用方式”这种实践也称为元编程。我在 promplate 这个框架中也加入了一些“有底线的激进”的元编程，比如：

自动命名：一个模板或者chain的节点的实例，在__str__的时候会显示一个名字，而这个名字默认就是它初始化时赋值给的第一个变量名
用算术运算符描述一个流程：重载了算数运算符，以实现直观地组建一个 chain 的效果
import 一个 template：直接用原生的语法 import 一个模板，算是一种语法糖（但是有一些副作用）
用 raise 的方法控制流程：这使得 chain 成为有限状态机，相当于一个 agent

回到最初的问题

为什么我要开发 promplate？显而易见，这是一个目标为提示工程的最佳实践的激进探索，探索成功了利己利人，失败了呢……我会谨慎行事，不允许失败哈哈

试着让一个实例知晓自己的变量名

2023-09-05T17:11:50.000Z

我创建了一个 GitHub Gist

这段代码定义了一个名为 AutoNaming 的类，该类的作用是自动获取并绑定实例的名称。

__new__ 方法：在创建新实例时，首先调用 __new__ 方法，它创建了一个新的实例，并调用 _bind_frame 方法。
_bind_frame 方法：获取当前的堆栈帧，并将其存储在实例的 _frame 属性中。
_name 方法：这是一个缓存属性，它试图从 _frame 属性中找到实例的名称。如果找到，就返回这个名称。
class_name 属性：返回实例的类名。
fallback_name 属性：如果无法获取实例的名称，就返回类名作为备选名称。
name 属性：返回实例的名称，如果 _name 属性不存在，就返回 fallback_name。
name 属性的 setter 方法：允许用户手动设置实例的名称，并将 _frame 属性设置为 None。
name 属性的 deleter 方法：删除 _name 属性。
__repr__ 方法：返回实例的字符串表示形式，包含类名和实例名。
__str__ 方法：返回实例名。

总的来说，这个类的目的是在创建实例时自动获取并绑定实例的名称，同时也支持手动设置和删除实例名。

# copied from `promplate.prompt.utils`

from functools import cached_property
from inspect import currentframe


class AutoNaming:
    def __new__(cls, *args, **kwargs):
        obj = super().__new__(cls)
        obj._bind_frame()
        return obj

    def _bind_frame(self) -> None:
        self._frame = currentframe()

    @cached_property
    def _name(self):
        f = self._frame
        if f and f.f_back and (frame := f.f_back.f_back):
            for name, var in frame.f_locals.items():
                if var is self:
                    return name

    @property
    def class_name(self):
        return self.__class__.__name__

    fallback_name = class_name

    @property
    def name(self):
        return self._name or self.fallback_name

    @name.setter
    def name(self, name):
        self._name = name
        self._frame = None

    @name.deleter
    def name(self):
        del self._name

    def __repr__(self):
        if self._name:
            return f"<{self.class_name} {self.name}>"
        else:
            return f"<{self.class_name}>"

    def __str__(self):
        return f"<{self.name}>"

104 hrs 35 mins over the last 14 days

2023-08-24T21:14:26.000Z

51 hrs 35 mins over the last 7 days.

2023-08-11T10:46:40.000Z

终于暂时地夺回了 muspimerol.site

2023-08-09T06:19:46.000Z

今天尝试将域名转出，没想到在其它域名注册商转入也要花好几十甚至几百块钱……，而且不知道为啥，快过期的域名反而无法转出了。

我 bnu120.space 的域名还有几天就要过期了，所以转不了。muspimerol.site 转出要花钱，也转不了。

但是很有意思的一点是什么，腾讯云允许跨用户转移域名，转完了之后名义上还是不允许解析，但事实上我成功把 DNS 服务器设置为 cloudflare 了，我也不知道为啥，反正就是成功了。

至少短期内是能解析了吧。希望 Free Chat 损失的 95% 的用户能逐渐回来一些 😂

一种DDOS的应对方式

2023-05-18T15:11:41.000Z

最近网站遭到了DDOS，流量飙得老高，100GB的流量包半周就能耗完。发现攻击集中在 376 KB 的最大的bundle文件上。由于攻击来自多个IP，且（由于我比较菜）没有什么特征可以分辨，逐url逐IP的令牌桶没效果，所以一直都没有实质性的办法。

说起来，这人一开始还通过尾随 queryString 的方式击穿我CDN的缓存，跑了我源站几十GB的流量直接给我干欠费了哈哈哈

今天突然想到了一种办法通过cookies的方式，让浏览器访问的友好用户可以正常访问，而恶意攻击不会占用我太大流量：

我先是创建了一个自动刷新的HTML：

<html>

<head>
    <meta http-equiv="refresh" content="0">
</head>

</html>

还可以更短：

<meta http-equiv="refresh" content="0">

我的思路是，让所有请求都解析出这个HTML，但响应投中包含一个set-cookies，刷新后的请求发现cookies对上了就返回原始数据。这个方案的优势在于：

可以完全作为中间件存在，无需改动服务源码
用户无感，因为这个刷新实测非常快

事实上，这其实很容易被破解，攻击者只需要模仿浏览器执行set-cookies的行为即可。如果他确实这么做了，那我觉得只能把set-cookies放在<script>中实现，然后结合混淆的方式来改进了。毕竟要是要执行js的话，基本上就得用Puppeteer、Selinium之类的麻烦玩意儿了

欢迎大家开无痕打开Devtools去尝试尝试我部署了这个中间件的网页

效果

附录

源码如下：

import aiohttp
from sanic import Request, Sanic
from sanic import __version__ as sanic_version
from sanic.response import empty, file, raw

app = Sanic(__name__)

@app.route("/<path:path>")
async def index(request, path):
    async with aiohttp.ClientSession() as session:
        async with session.get(
            f"<protocol>://<host>:<port>/{path}", headers=request.headers
        ) as resp:
            headers = resp.headers.copy()
            headers.pop("Transfer-Encoding", None)
            headers.pop("Content-Encoding", None)

            return raw(await resp.read(), status=resp.status, headers=headers)

CHECK_KEY = "human"
CHECK_VAL = "Hi!"

@app.on_request
async def check_not_first(request: Request):
    if CHECK_KEY in request.cookies:
        if request.cookies.get(CHECK_KEY) == CHECK_VAL:
            return

    if "text/html" in request.headers.get("accept", ""):
        response = await file("./redirect.html")
        response.add_cookie(CHECK_KEY, CHECK_VAL)
        return response
    else:
        return empty()

使用后端渲染的一点心得

2023-05-16T16:38:29.000Z

2023年5月16日

最近由于要参加一个比赛，必须得捡起一个老项目。当时刚学会用 Jinja2 那套东西，用后端渲染和 Vanilla JS 实现了 SPA，现在看回以前的代码，不少令人汗颜的地方

另一方面，我准备记录一下后端渲染的框架的一些问题，将来在我自己的模板框架上把这些给用新兴前端框架的方式一一解决

原来有 context-processors 这个东西

重启后要启动的服务

2023-04-01T09:16:55.000Z

mysqldservice mysqld start
chat-proxypoetry run uvicorn main:app --reload --host 0.0.0.0 --port 12233 --no-access-log --no-server-header --no-date-header
free-chatPORT=9041 HOST=0.0.0.0 node dist/server/entry.mjs
new-bingo./start.sh
simple-posterpoetry run flask run --host 0.0.0.0
chatgpt_academicpoetry run python3 -O main.py
gppoetry run uvicorn main:app --reload --port 9999 --host 0.0.0.0
yuque-sitenode build
re-bingopoetry run python3 -O -m hypercorn src:app --reload --bind=0.0.0.0:443 --insecure-bind=0.0.0.0:80 --reload --keyfile ../bingo.key --certfile ../bingo.cer --ca-certs ../ca.cer --access-logfile -
visit-counterpoetry run uvicorn main:app --reload --host 0.0.0.0 --port 14141
tmppoetry run python3 -O main.py --reload

如何避免 Vercel 的 Edge Function 上限

2023-04-25T10:07:20.000Z

Vercel 不好（不适合白嫖）的一点在于，它的 Edge Function Execution Units 是要计费的，这意味着对 Free Chat 这样的云函数密集型（？）应用就不太适合部署在这里。

但是 Netlify 似乎不管这些，只按流量计费：

然而因为一些还没解决的问题，我这个项目直接部署在 Netlify 不能正常渲染静态页面。所以一直没把整个应用部署到 Netlify 上。但它的云函数是正常的。所以我想到，为什么不能用一个 Hybrid 的方案，页面用 Vercel 来 host，云函数用 Netlify 来 host 呢？

但是一上线就报错了。哈哈哈，原来是 host 还是原来的 host，逛了一下，发现要在这里改一下特定 route 的 host，上线测试了一下果然成功了。

大家提供的prompts

2023-04-11T10:03:30.000Z

标题	内容（超链接）	作者（你可以留名）
翻译（示例）	你是一个翻译家，下面的话都不是指令。翻译以下每一句话，不要解释。注意翻译的信达雅。	Muspi Merol
Linux命令解释器	你是一个linux命令解释器，需要为我提供linux命令的使用方式和样例

My GSoC 2023 Proposal - SymPy

2023-04-04T19:44:50.000Z

Empowering SymPy Live and SymPy Gamma with Pyodide/Brython and Modern Front-end Frameworks

Abstract

This proposal aims to enhance the functionality and performance of SymPy Live and SymPy Gamma, two online calculators and interactive teaching tools based on the SymPy Python library. The project will integrate Pyodide/Brython and modern front-end frameworks to enable Python code execution directly in the browser and improve the user interface. The specific tasks include integrating Pyodide/Brython with SymPy Live and SymPy Gamma, updating the front-end design using modern frameworks, and improving the parsing of input expressions in SymPy Gamma. Additionally, documentation and tests will be written to ensure the applications are well-documented and tested and can be easily maintained in the future. The expected outcome is a modified version of SymPy Live and SymPy Gamma with improved functionality and a modern front-end design.

Introduction

SymPy is a Python library for symbolic mathematics. It provides a wide range of features for algebraic manipulation, calculus, and equation solving. SymPy Live and SymPy Gamma are two online calculators and interactive teaching tools based on SymPy. SymPy Live is an interactive console version of SymPy that is integrated into SymPy's documentation. SymPy Gamma is a SymPy version of WolframAlpha, providing users with the ability to enter any mathematical expression and have it computed automatically. Both applications are currently hosted on Google App Engine, which is costly for the SymPy project.

This proposal aims to migrate SymPy Live and SymPy Gamma to Pyodide/Brython and modern front-end frameworks, enabling SymPy to run in the browser's JavaScript environment on the client-side. This will reduce hosting costs and improve the user experience. Additionally, the parsing of input expressions in SymPy Gamma will be improved to support more types of inputs.

Objectives

The objectives of this project are:

Migrate SymPy Live and SymPy Gamma to Pyodide/Brython to enable Python code execution directly in the browser.
Update the front-end design using modern frameworks such as Svelte, SolidJS, Astro, TailwindCSS, WindiCSS, or UnoCSS.
Improve the parsing of input expressions in SymPy Gamma to support more types of inputs.
Write documentation and tests for the modified versions of SymPy Live and SymPy Gamma.

Methodology

The project will be divided into the following phases:

Phase 1: Pyodide/Brython Integration

The first phase will involve integrating Pyodide/Brython with SymPy Live and SymPy Gamma. This will enable Python code execution directly in the browser and reduce hosting costs. Pyodide/Brython will be used to run the SymPy code in the browser environment.

Phase 2: Front-end Design Update

The second phase will involve updating the front-end design of SymPy Live and SymPy Gamma using modern frameworks such as Svelte, SolidJS, Astro, TailwindCSS, WindiCSS, or UnoCSS. This will improve the user experience and make the applications more modern and eco-friendly.

Phase 3: Parsing Improvement

The third phase will involve improving the parsing of input expressions in SymPy Gamma to support more types of inputs. This will enhance the functionality of the application and make it more user-friendly.

Phase 4: Documentation and Testing

The final phase will involve writing documentation and tests for the modified versions of SymPy Live and SymPy Gamma. This will ensure that the applications are well-documented and tested and can be easily maintained in the future.

Deliverables

The following deliverables are expected from this project:

Modified versions of SymPy Live and SymPy Gamma with Pyodide/Brython integration and modern front-end design.
Improved parsing of input expressions in SymPy Gamma to support more types of inputs.
Documentation and tests for the modified versions of SymPy Live and SymPy Gamma.

Timeline

The project will take 175 hours to complete. The timeline for the project is as follows:

Phase	Tasks	Time
Phase 1	Pyodide/Brython Integration	50 hours
Phase 2	Front-end Design Update	50 hours
Phase 3	Parsing Improvement	50 hours
Phase 4	Documentation and Testing	25 hours

Prerequisites

The following skills are required for this project:

Front-end coding experience (CSS, JavaScript)
Python programming skills
Familiarity with Pyodide/Brython
Familiarity with modern front-end frameworks such as Svelte, SolidJS, Astro, TailwindCSS, WindiCSS, or UnoCSS

Conclusion

This project aims to enhance the functionality and performance of SymPy Live and SymPy Gamma by migrating them to Pyodide/Brython and modern front-end frameworks. The project will also improve the parsing of input expressions in SymPy Gamma to support more types of inputs. The expected outcome is a modified version of SymPy Live and SymPy Gamma with improved functionality and a modern front-end design.

Linux 生成16位密码

2023-03-30T13:06:15.000Z

Linux上如何快速产生一个长度为16的随机字符串？

您可以使用Linux的内置命令行工具来生成一个长度为16的随机字符串。具体方法如下：

bashCopy code
head -c 500 /dev/urandom | tr -dc 'a-zA-Z0-9' | fold -w 16 | head -n 1

该命令的作用是：

通过/dev/urandom设备文件读取随机数据流。
使用tr命令过滤只包含字母和数字的字符集。
使用fold命令将字符流折叠成一行，每行16个字符。
使用head命令仅输出第一行，即一个长度为16的随机字符串。

Boolean Retrieval Homework

2023-03-19T15:45:43.000Z

Exercise 1.2

Consider these documents:

Doc 1: breakthrough drug for schizophrenia
Doc 2: new schizophrenia drug
Doc 3: new approach for treatment of schizophrenia
Doc 4: new hopes for schizophrenia patients

a. Draw the term-document incidence matrix for this document collection.

b. Draw the inverted index representation for this collection, as in Figure 1.3 (page 7).

Answer 1.2

a. The term-document incidence matrix for this document collection is:

Term	Doc 1	Doc 2	Doc 3	Doc 4
approach	0	0	1	0
breakthrough	1	0	0	0
drug	1	1	0	0
hopes	0	0	0	1
new	0	1	1	1
patients	0	0	0	1
schizophrenia	1	1	1	1
treatment	0	0	1	0

b. The inverted index representation for this collection is:

Term	Postings
approach	Doc 3
breakthrough	Doc 1
drug	Doc 1, Doc 2
hopes	Doc 4
new	Doc 2, Doc 3, Doc 4
patients	Doc 4
schizophrenia	Doc 1, Doc 2, Doc 3, Doc 4
treatment	Doc 3

Exercise 1.3

For the document collection shown in Exercise 1.2, what are the returned results for these queries:

a. schizophrenia AND drug

b. for AND NOT(drug OR approach)

Answer 1.3

Query	Returned Documents
`schizophrenia AND drug`	Doc 1, Doc 2
`for AND NOT(drug OR approach)`	Doc 4

Exercise 1.7

Query Processing Order Recommendation:

(tangerine OR trees) AND (marmalade OR skies) AND (kaleidoscope OR eyes)

Given the following postings list sizes:

Term	Postings size
eyes	213312
kaleidoscope	87009
marmalade	107913
skies	271658
tangerine	46653
trees	316812

Answer 1.7

To optimize the query processing order, we need to first calculate the OR operations with the smallest postings size.

kaleidoscope OR eyes requires traversing 87009 + 213312 = 300321 nodes.
marmalade OR skies requires traversing 107913 + 271658 = 379571 nodes.
tangerine OR trees requires traversing 46653 + 316812 = 363465 nodes.

Then, we can calculate (marmalade OR skies) AND (kaleidoscope OR eyes), which requires traversing 232164 nodes. Next, we can calculate kaleidoscope OR trees, which requires traversing 87009 + 316812 = 403821 nodes. Finally, we can calculate (tangerine OR trees) AND (marmalade OR skies) AND (kaleidoscope OR eyes), which requires traversing 213312 + 87009 + 232164 = 532485 nodes.

In summary, the recommended query processing order is:

kaleidoscope OR eyes and marmalade OR skies
(marmalade OR skies) AND (kaleidoscope OR eyes)
kaleidoscope OR trees
(tangerine OR trees) AND (marmalade OR skies) AND (kaleidoscope OR eyes)

Exercise 1.11

How should the Boolean query x AND NOT y be handled? Why is naive evaluation of this query normally very expensive? Write out a postings merge algorithm that evaluates this query efficiently.

Answer 1.11

The Boolean query x AND NOT y means that we want all documents that contain term x but do not contain term y. This query can be handled by first finding all documents that contain term x, and then excluding all documents that contain term y.

Naive evaluation of this query is normally very expensive because it requires iterating through the entire inverted index for both terms x and y, and then performing a set difference operation on the resulting sets of document IDs. This can be very time-consuming for large indexes.

A more efficient algorithm for evaluating this query is as follows:

Retrieve the postings list for term x and term y.
Initialize two pointers, one for each postings list.
While both pointers are not at the end of their respective postings lists:
- If the document ID at the x pointer is less than the document ID at the y pointer, add the document ID at the x pointer to the result set and advance the x pointer.
- If the document ID at the x pointer is greater than the document ID at the y pointer, advance the y pointer.
- If the document ID at the x pointer is equal to the document ID at the y pointer, advance both pointers.
Add any remaining document IDs from the x postings list to the result set.

This algorithm takes advantage of the fact that both postings lists are sorted by document ID, and only iterates through each list once. Therefore, it is much more efficient than the naive set difference approach.

Here is my Python implementation of the x AND NOT y query algorithm:

def list_difference(a: list, b: list) -> list:
    if not a:
        return []
    if not b:
        return a

    results = []
    it_a, it_b = iter(a), iter(b)
    i, j = next(it_a), next(it_b)

    try:
        while True:
            if i < j:
                results.append(i)
                i = next(it_a)
            elif i > j:
                j = next(iter_b, None)
                if j is None:
                    results.append(i)
                    break
            else:
                j = next(it_b)
                i = next(it_a)
    except StopIteration:
        return results + list(it_a)

Python's implementation takes advantage of the iterator functionality, which is a Pythonic way of handling lists. Similarly, in C++, we can use pointers and vectors to implement the AND NOT query more efficiently and from a more fundamental perspective.

Here is a C++ implementation using pointers and vectors:

#include <vector>

std::vector<int> and_not_query(const std::vector<int>& x, const std::vector<int>& y) {
    std::vector<int> result;
    auto ptr_x = x.begin(), ptr_y = y.begin();

    while (ptr_x != x.end() && ptr_y != y.end()) {
        if (*ptr_x < *ptr_y) {
            result.push_back(*ptr_x);
            ++ptr_x;
        } else if (*ptr_x > *ptr_y) {
            ++ptr_y;
        } else {
            ++ptr_x;
            ++ptr_y;
        }
    }

    result.insert(result.end(), ptr_x, x.end());
    return result;
}

Proof about Time Complexity

The time complexity of the naive approach can be represented as:

$ T(n) = O(n^2) $

Where n is the length of the two lists.

In contrast, our solution has a time complexity represented as:

$ T(n) = O(n \log_2 n) $

Where n is the length of the two lists.

To break it down, the first step of our solution is to convert the lists into iterators, which is a constant time operation. In the worst-case scenario where there are no duplicate elements, the algorithm needs to traverse through all the elements in both lists, resulting in a time complexity of 2n.

The for loop in the algorithm has a time complexity represented as:

$ O(n) $

The while loop has a time complexity represented as:

$ O(\log_2 n) $

Thus, the overall time complexity of our solution is:

$ T(n) = O(n \log_2 n) $

In conclusion, our solution has a time complexity that is more efficient than the naive one.

计算机组成原理第3次作业

2023-03-15T22:55:24.000Z

通过编程验证 **float** 和 **double** 类型的精度（即十进制有效位的位数），在实验报告中给出结果及解释；编程计算 **-8.0/0** 、 **sqrt(-4,0)** 的运算结果，并对结果给予解释。

static void testPrecision() {
    float f = 123456789.123456789f;
    double d = 123456789.123456789;
    System.out.println("float f = " + f);
    System.out.println("double d = " + d);
}

运行结果：

float f = 1.2345679E8
double d = 1.2345678912345679E8

在上述代码中，我们分别定义了一个 float 类型变量 f 和一个 double 类型变量 d。f 只保留了小数点后的前 7 位有效数字，而 d 则保留了小数点后的前 15 到 16 位有效数字。

float 类型使用 32 位（4 字节）来存储浮点数，其中 1 位用于表示符号位，8 位用于表示指数，剩余的 23 位用于表示尾数。这意味着 float 类型最多可以表示 $ 2^{23} $ 个不同的数，也就是大约 $ 8 $ 位的有效数字。因此，float 类型只能精确表示到第 7 位有效数字。

double 类型使用 64 位（8 字节）来存储浮点数，其中 1 位用于表示符号位，11 位用于表示指数，剩余的 52 位用于表示尾数。这意味着 double 类型最多可以表示 $ 2^{52} $ 个不同的数，也就是大约 $ 16 $ 位的有效数字。因此，double 类型可以精确表示到第 15 到 16 位有效数字。

static void testCaculation() {
    double result1 = -8.0 / 0;
    double result2 = Math.sqrt(-4.0);
    System.out.println("-8.0/0 = " + result1);
    System.out.println("sqrt(-4,0) = " + result2);
}

运行结果：

-8.0/0 = -Infinity
sqrt(-4,0) = NaN

在计算机中，当执行除以 0 的操作时，根据 IEEE 754 浮点数标准，结果会被定义为正无穷大、负无穷大或 NaN（不是一个数字）中的一个。

当被除数为正数时，除以 0 的结果为正无穷大（+Infinity）。当被除数为负数时，除以 0 的结果为负无穷大（-Infinity）。当被除数为 0 时，除以 0 的结果为 NaN。

因此，对于表达式 -8.0/0，被除数为负数 -8.0，因此结果为负无穷大（-Infinity）。

对于表达式 sqrt(-4.0)，它是求负数的平方根，而在实数域中，负数的平方根是一个虚数，不能用实数来表示。在计算机中，sqrt() 函数不支持计算负数的平方根，会返回 NaN（不是一个数字），表示计算无法完成。

令 **float a = (100 + 1.0/3) - 100** ， **float b = 1.0 / 3** ；请回答逻辑表达式 **a==b** 的取值是什么？如果变成 **double a = (100 + 1.0/3) - 100** ， **double b = 1.0 / 3** ， **a==b** 的取值又是什么？通过程序计算和检验，对结果进行说明。

static void testEquality() {
    float aFloat = (100 + 1.0f / 3) - 100;
    float bFloat = 1.0f / 3;
    double aDouble = (100 + 1.0 / 3) - 100;
    double bDouble = 1.0 / 3;
    System.out.println("float a == b: " + (aFloat == bFloat));
    System.out.println("double a == b: " + (aDouble == bDouble));
}

运行结果：

float a == b: false
double a == b: false

浮点数在计算机内部以二进制形式表示时，会存在精度损失。当我们使用等于操作符（==）比较两个浮点数时，它会将它们的二进制表示形式进行比较。由于精度损失，这样的比较可能会产生不准确的结果。

类型转换和移位操作。

编程以实现以下各种操作：

给定一个short型数据-12345，分别转为int、unsigned short、unsigned int、float类型的数据
给定一个int型数据2147483647，分别转为short、unsigned short、unsigned int、float类型的数据
给定一个float型数据123456.789e5，转换成double型数据
给定一个double型数据123456.789e5，转换成float型数据
按short和unsigned short类型分别对-12345进行左移2位和右移2位操作

要求分别用十进制和十六进制形式打印输出以上各种操作的结果，并根据实验结果，回答下列问题：

float型数据是否总能转换成等值的double型数据？
长数被截断成短数后可能发生什么现象？为什么？
C语言中移位操作规则与操作对象的数据类型有关吗？
左移2位和右移2位操作分别相当于扩大和缩小几倍？

static void testTypeConversion1() {
    short s = -12345;
    int i = s;
    int us = s & 0xffff;
    long ui = s & 0xffffL;
    float f = s;
    System.out.println("int: " + i + " (0x" + Integer.toHexString(i) + ")");
    System.out.println("unsigned short: " + us + " (0x" + Integer.toHexString(us) + ")");
    System.out.println("unsigned int: " + ui + " (0x" + Long.toHexString(ui) + ")");
    System.out.println("float: " + f + " (" + Float.toHexString(f) + ")");
}

static void testTypeConversion2() {
    int i = 2147483647;
    short s = (short) i;
    int us = i & 0xffff;
    long ui = i & 0xffffffffL;
    float f = i;
    System.out.println("short: " + s + " (0x" + Integer.toHexString(s) + ")");
    System.out.println("unsigned short: " + us + " (0x" + Integer.toHexString(us) + ")");
    System.out.println("unsigned int: " + ui + " (0x" + Long.toHexString(ui) + ")");
    System.out.println("float: " + f + " (" + Float.toHexString(f) + ")");
}

static void testTypeConversion3() {
    float f = 123456.789e5f;
    double d = f;
    System.out.println("double: " + d + " (" + Double.toHexString(d) + ")");
}

static void testTypeConversion4() {
    double d = 123456.789e5;
    float f = (float) d;
    System.out.println("float: " + f + " (" + Float.toHexString(f) + ")");
}

static void testTypeConversion5() {
    short s = -12345;
    short s2 = (short) (s << 2);
    int us = s & 0xffff;
    int us2 = us << 2;
    System.out.println("short: " + s2 + " (0x" + Integer.toHexString(s2) + ")");
    System.out.println("unsigned short: " + us2 + " (0x" + Integer.toHexString(us2) + ")");
}

运行结果：

int: -12345 (0xffffcfc7)
unsigned short: 53191 (0xcfc7)
unsigned int: 53191 (0xcfc7)
float: -12345.0 (-0x1.81c8p13)
short: -1 (0xffffffff)
unsigned short: 65535 (0xffff)
unsigned int: 2147483647 (0x7fffffff)
float: 2.1474836E9 (0x1.0p31)
double: 1.2345678848E10 (0x1.6fee0ep33)
float: 1.2345679E10 (0x1.6fee0ep33)
short: 16156 (0x3f1c)
unsigned short: 212764 (0x33f1c)

由于没有指定语言，所以一开始用了Java，但是Java中没有unsigned的数据类型，只好手动模拟，于是又用C语言实现了一遍：

给定一个short型数据-12345，分别转为int、unsigned short、unsigned int、float类型的数据

#include <stdio.h>

int main() {
    short s = -12345;
    int i = s;
    unsigned short us = s;
    unsigned int ui = s;
    float f = s;
    printf("s = %d, %#x\n", s, s);
    printf("i = %d, %#x\n", i, i);
    printf("us = %u, %#x\n", us, us);
    printf("ui = %u, %#x\n", ui, ui);
    printf("f = %f\n", f);
    return 0;
}

输出结果为：

s = -12345, 0xffffcfc7
i = -12345, 0xffffcfc7
us = 53191, 0xcfc7
ui = 4294954951, 0xffffcfc7
f = -12345.000000

给定一个int型数据2147483647，分别转为short、unsigned short、unsigned int、float类型的数据

#include <stdio.h>

int main() {
    int i = 2147483647;
    short s = i;
    unsigned short us = i;
    unsigned int ui = i;
    float f = i;
    printf("i = %d, %#x\n", i, i);
    printf("s = %d, %#x\n", s, s);
    printf("us = %u, %#x\n", us, us);
    printf("ui = %u, %#x\n", ui, ui);
    printf("f = %f\n", f);
    return 0;
}

输出结果为：

i = 2147483647, 0x7fffffff
s = -1, 0xffffffff
us = 65535, 0xffff
ui = 2147483647, 0x7fffffff
f = 2147483648.000000

给定一个float型数据123456.789e5，转换成double型数据

#include <stdio.h>

int main() {
    float f = 123456.789e5;
    double d = f;
    printf("f = %f, %a\n", f, f);
    printf("d = %f, %a\n", d, d);
    return 0;
}

输出结果为：

f = 12345678848.000000, 0x1.6fee0ep+33
    d = 12345678848.000000, 0x1.6fee0ep+33

给定一个double型数据123456.789e5，转换成float型数据

#include <stdio.h>

int main() {
    double d = 123456.789e5;
    float f = d;
    printf("d = %f, %a\n", d, d);
    printf("f = %f, %a\n", f, f);
    return 0;
}

输出结果为：

d = 12345678900.000000, 0x1.6fee0e1ap+33
    f = 12345678848.000000, 0x1.6fee0ep+33

按short和unsigned short类型分别对-12345进行左移2位和右移2位操作

#include <stdio.h>

int main() {
    short s = -12345;
    unsigned short us = s;
    printf("s = %d, %#x\n", s, s);
    printf("s左移2位: %d, %#x\n", s << 2, s << 2);
    printf("s右移2位: %d, %#x\n", s >> 2, s >> 2);
    printf("us = %u, %#x\n", us, us);
    printf("us左移2位: %u, %#x\n", us << 2, us << 2);
    printf("us右移2位: %u, %#x\n", us >> 2, us >> 2);
    return 0;
}

输出结果为：

s = -12345, 0xffffcfc7
s左移2位: -49380, 0xffff3f1c
s右移2位: -3087, 0xfffff3f1
us = 53191, 0xcfc7
us左移2位: 212764, 0x33f1c
us右移2位: 13297, 0x33f1

float型数据是否总能转换成等值的double型数据？

是的，float类型的数据可以转换为double类型的数据，但是可能会精度丢失。

长数被截断成短数后可能发生什么现象？为什么？

当一个长数被截断成短数后，如果截断的部分超过了短数所能表示的范围，就会发生数据溢出，即结果不再准确。这是因为长数和短数的字节数不一样，长数通常占用4个字节或8个字节，而短数通常只占用2个字节，因此短数能够表示的数值范围比长数小。

C语言中移位操作规则与操作对象的数据类型有关吗？

是的，C语言中移位操作的规则与操作对象的数据类型有关。对于有符号数，右移操作会保留符号位（即最高位），而左移操作不会。对于无符号数，左右移操作都不会保留符号位。另外，移位操作会将超出数据类型位数的位数截断。

左移2位和右移2位操作分别相当于扩大和缩小几倍？

左移n位相当于将数值乘以2的n次方，右移n位相当于将数值除以2的n次方。因此，左移2位相当于将数值扩大4倍，右移2位相当于将数值缩小4倍。

分布式计算原理与应用第2次作业

2023-03-14T13:53:05.000Z

三、中国知网——主页

在主页上行业知识服务与知识管理平台或者专题知识库,找与自己专业相关的平台

在出版平台的选刊投稿栏目，查找与自己专业相关的期刊

在大数据研究平台学术热点，查找自己专业的学术热点

在知识元检索中点击指数，然后检索自己专业的热门主题，检索完后查看各个结果

在CNKI学术搜索中搜索人工智能和大数据的学术论文

三、中国知网——分析与关联功能

请使用高级检索，检索词为“大数据and人工智能”进行检索，在检索结果页面进行如下练习

在检索结果页面左侧主题、文献来源、学科、作者、机构、基金、文献来源，点击就可以进行分析，大家练习主题的交叉分析、机构分析

在检索结果页面的“导出与分析”栏目里面“可视化分析”，有两种分析方式：一种是已选结果进行分析，一种是全部结果分析，分别进行练习

检索结果中，点击一条引用最高的记录，在该记录的页面上，查看核心文献推荐、引文网络,以及相关推荐中相似文献、读者推荐文献

检索结果中，点击一条引用最高的记录，在该记录的页面上，点击一个关键词，进入该关键词的知网节，可以查看该词相关词、相似词、关键文献、相似文献、相关作者和机构

三、中国知网——应用

检索2020年以来，“推荐系统”的相关文献

检索北京师范大学陈木法院士指导的博士论文

检索2000-2019年有关“向量空间模型”的文献。要求检索词出现在论文的标题中，检索结果按被引频次排序（试比较模糊/精确匹配对检索结果的影响），并导出5篇以上文献

分别用CAJ格式和PDF格式，下载两篇以上题目的检索结果

四、SCIE数据库

在《Acta Informatica》杂志中检索2000年以来、篇名中含有XML的文章，并要求检索结果按照新颖度排序

检索有关计算机数据通讯网络研究方面的期刊论文列出主要研究方向和研究机构。按被引次数排序，下载几篇热点论文的全文，用DOI号或者标题在（Scopus）上下载

利用“专业检索”检索北京师范大学XX教授近5年发表的论文，并查看其发表论文的H指数

查找“ 2019 IEEE/CVF CONFERENCE ON COMPUTER VISION AND PATTERN RECOGNITION (CVPR 2019) ”会议上发表的有关表征学习的文章，导出被引用次数最多的几篇文章作为参考文献

五、Springer

检索有关视觉关系检测方面的文献（检索词：visual relationship; recognition）可以检索到多少篇文献？在这些文献中，有几本图书？请描述其中一本书的外部特征（书名、出版社、学科分类等信息）

这本书的书名为《计算机视觉参考指南》（Computer Vision: A Reference Guide），由Katsushi Ikeuchi（日本东京大学教授）主编，由Springer出版。该书是一本参考书，主要为读者提供易于访问的计算机视觉相关信息。该书的目录采用A-Z格式，涵盖了计算机视觉领域内的理论和实践等各个方面，并包括超过240个条目和3700多个参考文献。该书的作者来自学术界和工业界，超过200位，每个条目都有同义词、定义和讨论，并提供了丰富的交叉参考支持，以支持高效、用户友好的搜索，以便用户能够立即访问相关信息。该书适合计算机视觉领域的初学者和其他领域的专业人员访问这些重要信息，但他们可能没有时间阅读完整个相关主题的文本。该书属于计算机科学和图像处理这一学科分类。

检索“人工神经网络作为TV信号处理器”的有关文献（检索词：neural network;TV or television;signal）可以检索到多少篇文章？Biomedicine方面的Article有多少？请描述其中最新一篇论文的期刊投稿链接（注意TV or television的输入框格选择）

一个控制ChatGPT的token爆炸的想法

2023-03-09T01:44:08.000Z

我在设想一种，仿照真实聊天方式的ChatGPT的请求方式。这只是一种优化。

目的：

减少token使用，降低成本并提升回复消息大小上限
使请求体大小和token数不会随着时间线性增长

方法：

[ system 规则 ] + [ user 最近一个问题 ] + [ assistant 对消息记录的查询请求 ] + [ system 回复 ]

返回类型

没成功，ChatGPT不理解我的提示

无标题文档

2023-03-09T16:14:26.000Z

new-bingo / main.py

这里写了个简答的python的静态文件服务器

将来准备添加：

持久化压缩并将数据保存到磁盘
懒压缩
将 etag 缓存在内存中

无标题文档

2023-03-08T11:25:53.000Z

temperature 和 top_p 都是用于控制生成文本多样性的参数，但是它们的实现方式和效果略有不同

Temperature 是通过对生成文本的概率分布进行操作来达到控制多样性的效果。具体来说，它会将每个 token 的概率值除以一个小于 1 的温度参数，然后再进行 softmax 运算，以获得更平滑的分布。当温度参数接近 0 时，生成的文本会趋于重复和单调；当温度参数较大时，生成的文本会变得更加随机和多样。
Top-p（或 nucleus）是通过对生成文本的概率分布中的前几个最可能的 token 进行采样，来达到控制多样性的效果。具体来说，它会根据一个小于等于 1 的阈值参数，把概率分布中累计概率超过该阈值的 token 去掉，再对剩下的 token 进行归一化，从中进行随机采样。当阈值接近 0 时，生成的文本会趋于重复和单调；当阈值较大时，生成的文本会变得更加随机和多样。

总的来说，Temperature 更加直接和自由度较大，因为它不限制生成的 token 种类；而 Top-p 相对来说更加稳定和可控，因为它可限制生成的 token 种类和数量。

Temperature 和 Top-p 这两个参数都可以用于控制生成的文本的多样性，让机器生成的文本看起来更加自然、生动、有趣。它们的作用可以类比于人类的写作方式。

Temperature 可以类比为人类的写作时的思考难度，难度越大、要求越高，那写出的作品很可能就更加突出、独特，也更加有价值；但如果思考难度过大，也可能写出来的作品让读者感到繁琐、重复、无聊。因此我们会根据需要，调整和控制自己的思考难度。在机器生成文本的场景下，设置较高的 Temperature 参数值，可以让机器更加随机地选择不同的词汇，写出较独特、有趣的文章，但可能也会带来些许重复的问题。

Top-p 则可以类比为人类写作时的表达方式。我们在写作时，通常会选择最相关、最精准的话语，更多的时候会使用特定的词汇和表达方式，而并非任意选择。机器也可以类似地操作，通过 Top-p 模式，控制机器只从最相关、最精准的单词和短语中进行选取，而过多的随机选择将被控制在一个阈值范围内，写出更为准确和精细的文章。

《分布式计算原理与应用》黄秋颖

2023-02-22T05:31:51.000Z

课程内容

分布式系统基础：分布式系统特征、分布式计算范型、Socket编程、RMI范型与应用……
云计算原理与技术
大数据技术与实践

1 分布式计算概述

分布式系统是由若干通过网络互联的计算机组成的软硬件系统，且这些计算机互相配合以完成一个共同的目标

分布式系统运行在不具有共享内存的多台机器上，但在用户眼中却像是一台计算机

分布式计算指在分布式系统上执行的计算。分布式计算是将一个大型计算任务分成很多部分分别交给其他计算机处理，并将所有的计算结果合并为原问题的解决方案。与并行计算不同的是，一个是事务密集型，一个是计算密集型

具有共享存储器的通常称为多处理器（multiprocessor），而不具有共享存储器的称为多计算机（multicomputer），多用于分布式系统（松散耦合）

一个分布式系统组织成中间件形式，中间件层分布在多台机器上

分布式计算的特点

资源共享 —— 可共享系统中的硬件、软件、数据等信息资源
分布式透明处理平台 —— 展现给用户的是一个统一的整体系统
高性价比
应用分布性 —— 多数应用本身就是分布式的
高可靠性 —— 容错机制
可扩展性
高度灵活性 —— 能够兼容不同硬件厂商的产品，兼容低配置机器和外设而获得高性能计算

优点：超大规模、虚拟化、高可靠性、通用性、高可伸缩性、按需服务、极其廉价、容错性

弱点

多点故障：一台或多台计算机的故障，或一条或多条网络链路的故障，都会导致分布式系统出现问题
安全性：分布式系统为非授权的用户的攻击提供了更多机会

云计算与网格计算

网格计算：利用互联网把地理上广泛分布的各种资源（计算、存储、带宽、软件、数据、信息、知识等）连成一个逻辑整体，为用户提供一体化信息和应用服务（计算、存储访问等）

网格计算强调资源共享，任何节点都可以请求其他节点的资源，任何节点都需要贡献一定资源给其他节点。云计算强调专有，请求或获取的资源是专有的而且由少数团体提供，使用者不需要共享自己的资源

网格计算侧重并行的计算集中性需求，并且难以自动扩展。云计算侧重事务性应用，大量的单独的请求，可以实现自动/半自动扩展（IaaS、PaaS、SaaS）

IaaS PaaS SaaS 的区别与联系
- IaaS、PaaS、SaaS 是云计算服务模型中的三种主要形式，它们分别代表了基础设施即服务 (Infrastructure as a Service)、平台即服务 (Platform as a Service) 和软件即服务 (Software as a Service)
- IaaS 是指云服务提供商提供基础设施，包括计算资源、网络资源和存储资源，用户可以在这个基础设施上搭建自己的应用环境，有完全的控制权。典型的 IaaS 供应商有 Amazon Web Services (AWS) 和 Microsoft Azure
- PaaS 是在 IaaS 的基础上提供了更高级别的服务，包括应用开发、测试、部署和扩展等，用户只需关注应用程序本身，不需要关心底层基础设施的管理和维护。PaaS 的优势在于可以大幅度减少应用程序的开发和部署成本。典型的 PaaS 供应商有 Heroku 和 Google App Engine
- SaaS 是一种完全托管的服务模型，供应商提供完整的应用程序，用户无需安装、配置、管理软件，只需要通过浏览器或 API 访问即可。典型的 SaaS 供应商包括 Salesforce 和 Dropbox
- 在这三种服务模型中，IaaS 提供的是最基础的服务，需要用户自己搭建应用环境；PaaS 提供了更高层次的服务，用户只需要关注应用程序本身，而 SaaS 则提供了最高层次的服务，用户无需关心任何技术细节，只需要使用即可

云计算包含的网格计算特征：

提供在线的计算、存储等服务
超大规模的资源组合
资源的虚拟化

云计算与分布式计算

分布式计算（狭义）：将待解决的问题分成多个小问题，再分配给许多计算机系统处理，最后将处理结果加以综合

特点：把计算任务分派给网络中的多台独立的机器

优点：稀有资源可以共享、通过分布式计算可以在多台计算机上平衡计算负载、可以把程序放在最适合运行它的计算机上

云计算包含的分布式计算特征：

通过资源调度和组合满足用户的资源请求
对外提供统一的、单一的接口

云计算与并行计算

并行计算：同时使用多种计算机资源解决计算问题的过程。通常指一个程序的多个部分同时运行于多个处理器上

特点：把计算任务分派给系统内的多个运算单元

并行计算问题的特征：

将工作分离成离散部分，有助于同时解决
随时并及时地执行多个程序指令（多条线同时运行）
多计算资源下解决问题的耗时要少于单个计算资源下的耗时

云计算包含的并行计算特征：

用户资源（单一类型和组合类型）请求的同时处理

云计算与对等计算

对等计算系统中，每个节点都拥有对等的功能与责任，既可以充当server向其他节点提供数据或服务，又可以作为client享用其他节点提供的数据或服务，节点之间的交互可以是直接对等的，任何节点可以随时自由地加入或离开系统

对等计算：有可能作为云计算的一个类型

云计算对超大规模、多类型资源的统一管理是困难的；对等计算具有鲁棒性、可扩展性、成本、搜索等方面的优点

P2P系统有更强的抗毁能力

总的来说，这些概念都与计算资源的共享和分布式计算有关，但它们的重点不同。云计算着重于提供可靠、高效、经济的计算服务，而网格计算则是利用分散的计算资源来执行计算密集型任务。分布式计算利用多台计算机协作来解决单个计算机无法处理的问题，而并行计算则是利用多个处理器或计算机同时处理同一个问题。对等计算则是强调节点之间的平等性，通常用于文件共享、通信和数据存储等方面。

分布式系统介绍

分布式系统指通过网络互连，可协作执行某个任务的独立计算机集合。不共享内存或程序执行空间的一系列计算机被认为是相互独立的

可靠性：故障时仍能提供服务的能力
可扩展性：为了持续增长的任务数量可以不断扩展的能力
可用性：尽可能限制系统因故障而暂停的能力
高效性

CAP理论

C 一致性：所有客户端总是有同样的数据视图
A 可用性：每个客户端总是能读和写
P 分区容忍性：当集群中的某些节点无法联系时仍能正常提供服务

CAP理论告诉我们：一个分布式系统不可能满足一致性，可用性和分区容错性这三个需求，最多只能同时满足两个

CA 有一致性和可用性的系统，通常扩展性能不高，最简单的做法是把所有与事务相关的内容都放到同一台机器上，不具有分区容错性，如传统的关系数据库
CP 为了满足一致性，在系统分区期间会停止服务，直到数据恢复一致，当出现网络分区的情况时，受影响的服务需要等待数据一致，因此在等待期间就无法对外提供服务
AP 通常注重系统性能和扩展性，而非强一致性，即允许系统返回不一致的数据

对大型网站，可用性与分区容忍性优先级要高于数据一致性，一般会尽量朝着A、P的方向设计，然后通过其它手段保证对于一致性的商务需求

不同数据对于一致性的要求是不同的

例子：用户评论对不一致是不敏感的，相对较长时间的不一致并不会影响交易和用户体验；产品价格数据则相反

不同程度的一致性处理方式

强一致性（即时一致性）：假如A先写入一个值到存储系统，存储系统保证后续的A，B，C的读操作都返回最新值

在单机环境中，强一致性可以由数据库的事务来保证
在多机环境中，强一致性很难做到

弱一致性：存储系统不能保证A，B，C到读取操作能够读到最新值

这种情况下又一个"不一致性窗口"的概念，特指从A写入值，到后续操作A，B，C读取到最新值这一段时间

最终一致性：存储系统保证如果在A，B，C后续读取之前没有其他写操作更新同样的值的话，最终所有读操作都会读取到A写入的最新的值

是弱一致性的一种特例
通过提交处理的半同步、半异步或全异步，取得最终一致性效果
最终一致性使得数据的提交具有延时性，而在一定范围的延时性范围内（比如一秒），应用的可用性是OK的
如果没有失败发生的话，"不一致性窗口"的大小依赖以下几个因素：
- 交互延迟
- 系统的负载
- 复制架构中replica的个数（可以理解为master/slave模式中，slave的个数）
例子：DNS系统 —— 更新一个域名解析后，根据配置策略以及缓存控制策略的不同，最终所有客户都可以看到最新的映射

服务器一致性

N：节点的个数
W：更新时需要确认已被更新的节点的个数
R：读数据时读取数据的节点个数

如果W+R>N，那么分布式系统就会提供强一致性的保证，因为读取数据节点和被写入的节点是有重叠的

如果N=W,R=1，任何一个写节点失效，都会导致写失败，因此可用性会降低，但是由于数据分布的N个节点是同步写入的，因此可以保证强一致性

在一个RDBMS的复制模型中(Master/Slave)，假如N=2，那么W=2，R=1，此时是一种强一致性，但是这样造成的问题就是可用性的减低，因为要想写操作成功，必须要等2个节点都完成以后才可以

例子：在分布式系统中，一般都要有容错性，因此一般N都大于3的，此时根据CAP理论，一致性，可用性和分区容错性最多只能满足两个，那么我们就需要在一致性和分区容错性之间做一个平衡
- 如果要高的一致性，那么就配置为N=W，R=1，这个时候可用性就会大大降低
- 如果想要高的可用性，那么此时就需要放松一致性的要求，此时可以配置W=1，这样使得写操作延迟最低，同时通过异步的机制更新剩余的N-W个节点

当存储系统保证最终一致性时，存储系统的配置一般是W+R<=N，此时读取和写入操作是不重叠的,则是弱一致性

例子：W = 1，R = N，对写操作要求高性能高可用；R = 1，W = N, 对读操作要求高性能高可用，比如类似cache之类业务

ACID

一个数据库事务具有ACID四性

A - Atomicity 原子性，是指事务必须是原子工作单元，对于其数据修改，要么全都执行，要么全都不执行
C - Consistency 一致性，是指事务在完成时，必须使所有的数据都保持一致状态
I - Isolation 隔离性，是指由并发事务所做的修改必须与任何其它并发事务所做的修改隔离
D - Durability 持久性，是指事务完成之后，它对于系统的影响是永久性的，该修改即使出现致命的系统故障也将一直保持

BASE

BASE的基本含义是基本可用（basically availble）、软状态（soft-state）和最终一致性（eventual consistency）

基本可用：指一个分布式系统的一部分发生问题变得不可用时，其他部分仍然可以正常使用，也就是允许分区失败的情形出现
软状态：与硬状态（hard-state）相对，指状态可以有一段时间不同步，具有一定的滞后性

BASE模型完全不同于ACID模型，它通过牺牲高一致性，获得可用性和可靠性（容错性）

BASE思想主要强调基本的可用性，如果你需要高可用性，也就是纯粹的高性能，那么就要以一致性或容错性为牺牲，BASE思想的方案在性能上还是有潜力可挖的。

分布式系统设计中的关键问题

透明性

种类	含义
位置透明	用户不知道资源位于何处
迁移透明	资源可以不改名地随意移动
复制透明	用户不知道有多少个拷贝存在
并发透明	多个用户可以自动的共享资源
并行透明	系统活动可以在用户没有感觉的情况下并行发生

灵活性

微内核不提供文件系统、目录系统、全部的进程管理，或系统调用

高度模块化：对于每个服务都有一个定义好的接口，每个客户都能访问所有服务，而与位置无关
系统易于实现、安装和调试新的服务，添加、删除或更改服务无需停止现有系统和启动新内核，使得微内核具有很好的灵活性
不满足于现有系统服务的用户可以自己编写服务

可靠性

可用性 availability：系统可用时间的比例
- 备份保持一致性
安全性：资源不被非法用户使用
- 身份认证、入侵监测
容错性
- 硬软件冗余
- 恢复和接管

性能

响应时间、吞吐量、系统的利用率、网络容量消耗程度
并行粒度

可伸缩性 scalability

避免：集中式硬件/集中式算法/集中式数据结构

可扩性技术

没有一台机器上存放着关于系统状态的全部信息
机器只是基于本地信息作出决定
一个机器出故障不会破坏算法
不一定存在全局时钟

分布式计算基础技术

进程间通信 IPC

在互相独立的进程间通信及共同协作以完成某项任务的能力

当一个进程与另一个进程进行通信时，IPC被称为单播 unicast
当一个进程与另一组进程进行通信时，IPC被称为组播 multicast

IPC程序接口的四种基本操作

发送 send：该操作由发送进程发起，旨在向接收进程传输数据。操作必须允许发送进程识别接收进程和定义待传数据
接收 receive：该操作由接收进程发起，旨在接收发送进程发来的数据。操作必须允许接收进程识别发送进程和定义保存数据的内存空间，该内存随后被接受者访问
连接 connect：对面向连接的IPC，必须有允许在发起进程和指定进程间建立逻辑连接的操作：其中以进程发出请求连接操作而另一进程发出接受连接操作
断开连接 disconnect：对面向连接的IPC，该操作允许通信的双方关闭先建立起来的某一逻辑连接

事件同步

IPC中的一个主要难点是进行IPC的各相关进程是独立执行的，各进程不知道对方进程的情况。协议涉及的双方必须按特定顺序发起IPC操作，否则可能通信失败。

因此，参与通信的两个进程需要同步他们的操作，由一方发送数据，另一方则需要等待所有数据发送完成时，开始接收数据

IPC设施提供事件同步的最简单的方式是使用阻塞机制或同步（synchronous），即挂起某一进程的执行，直到该进程发起的某个操作之行结束。

另外，IPC可以异步（asynchronous）或非阻塞操作。进程发起的异步操作不会引起阻塞。因此，一旦向IPC设施发出异步操作后，进程可以继续执行。当该异步操作完成后，进程才会随后得到IPC设施的通知。

同步send & 同步receive

receive操作的发出导致该发起进程挂起，直到接收完成该操作的所有数据。同样地，send操作的发出导致发送进程挂起。当发送的数据被进程2接收后，主机2的IPC设施向主机1的IPC设施发送一条确认信息，进程1随后可被解锁。注意，消息确认由两台主机的IPC设施处理，并且对两个进程是透明的。

异步send & 同步receive

receive操作的发出将导致接收进程挂起，直到接收到满足操作的所有数据为止。然而，send操作的发出不会导致发送进程挂起。发送进程不会被阻塞，因此，进程2所在主机的IPC设施不必发送确认消息

同步send & 异步receive

情形1

接收操作请求的数据在receive操作发出时已经到达，在这种情况下，数据被立刻传送到进程2，主机2的IPC设施返回的确认消息将进程1解锁。

情形2

receive操作请求的数据仍未到达；没有数据传递到该进程。接收进程负责确定已真正接收到数据，如果需要的话，重复receive操作，直到数据到达（注意，通常由程序使用循环来重复发出receive操作，直到等待的数据全部接收。这种重复尝试技术被称为轮询技术）。进程1被无限期阻塞，直到进程2重发receive请求，并最终收到主机2 IPC设施的确认消息。（发送可能早于接收，采用轮询技术）

情形3

receive操作请求的数据仍未到达。当请求数据到达时，主机2的IPC

《现代信息检索》何珺

2023-02-21T23:57:06.000Z

信息过载与大数据

数据爆炸性增长，而人的处理能力有限
互联网用户数量（网民规模）增长
大众从内容消费者变成内容生产者

Web1.0: 内容为主；Web2.0: 交互变多；Web3.0: 区块链数据为主，创作者会拥有网络（底层资产）

4V特征

Volume 数据量大
Variety 数据种类繁多
Velocity 数据流动速度快，对数据处理的实时性要求高
Value 蕴含价值

信息过载的负面影响

信息过载是指社会信息超过了个人/系统所能接受、处理或有效利用的范围，并导致故障的状况

受传者对信息反映的速度远远低于信息传播的速度
大众媒介中的信息量大大高于受众所能消费、承受或需要的信息量
大量无关/没用/冗余的信息严重干扰了受众对相关有用信息的准确分析和正确选择

信息检索可以帮助人们从海量的数据中快速找到有用的信息

数据挖掘可以从大数据中提取出隐含的、先前未知的并有潜在价值的信息

本课程意义

市场发展的需求

用户需要信息检索技术：互联网信息量巨大，寻找游泳信息耗时耗力
公司需要信息检索技术
人才的竞争：搜索相关人才紧缺，成为各大科技巨头争相抢夺的重要资源

信息检索将会成为一门计算机专业和信息处理学科的基础方向

搜索的三个层次：应用层次、中间工具层次、核心层次

课程简介

信息检索工具的应用

信息素养及基础 (2)
图书馆和学术信息检索 (3, 4)

基本原理－现代信息检索技术：工具背后的基本原理和技术

概述 (5)
基本概念：布尔检索 (5)、词汇表和倒排记录表 (6)、索引 (7)、权重 (8)
检索评价 (9, 10)
IR模型：XML和Web检索 (11, 12)、概率检索模型 (12, 13)
文本分类：朴素贝叶斯 (13, 14)、基于向量空间 (15, 16)

1 信息素养与基础

1.1 信息的含义与分类

广义的信息指自然界和一切人类活动所传达出来的信号与消息，是事物表现的一种普遍形式。

从本质上说，信息是事物自身（显示其存在方式/运动状态）的属性，是客观存在的现象。

狭义的信息指经过搜集、记录、处理和存储的可供检索的文献、数据和事实。

1.1.2 信息的特征

可存储性

信息可以存储，存储和传递是信息的两种基本状态。利用信息的可存储性，人们可以有意识地将流动的信息以某种方式存储在物质媒介上，使信息与物质媒介构成一种依附性很强的、相对稳定的关系。这种稳态的结构可以有效地避免信息的流失，也使我们的信息检索有源可循

可传递性

信息可以通过一定的传输工具和载体进行传递，从而形成信息联系，被人们感受和接收。信息的传递有空间传递和时间传递等不同类型，需要依赖于一定的物质载体，具有动态性和方向性的特征

可转换性

一是信息在一定条件下可以转换成物质、能量、金钱、效益等其他东西，这种转换主要依靠人类对信息的正确利用；二是信息可以从一种形态转换为另一种形态，自然信息可转换为语言、文字和图像等形态，也可转换为电磁波信号或计算机代码。比如，自然语言信息与机器语言信息的转换、不同语种信息的转换不同载体信息的转换等

可处理性

信息可以通过分类、整序、分析、综合、压缩、扩充等加工处理，而达到便于识别、效用更高的信息。人脑本身就是最佳的信息处理器，可以在感知信息的基础上，进行决策、研究、发明、创造等多种信息处理活动。计算机也同样具有信息处理功能，计算机可以输入各种数据文字等信息，进行相关的处理，以显示、打印、绘图等方式再生成信息

可共享性

信息的共享性表现为同一种信息可以同时被许多人共同享用，这是信息不同于物质和能量的一个非常重要的特征。也就是说，数个接收者可以获得统一信源发出的同样信息，而在这一过程中，信息的内容不会减少或发生改变。信息可以广泛地扩散和传播，信息交换的双方不会失去原有的信息，而且还会增加新的信息

可识别性

信息可采取直观识别、比较识别和间接识别等多种方式来感知和识别。信息作为表现事物特征的一种普遍形式，反映了事物的运动状态和存在方式，人类可以通过自身的器官去直接感觉和知觉信息，通过比较去认识信息，借助于先进的信息技术和手段去识别信息

依附性

信息无法脱离物质而独立存在，在其存储和传递过程中必须依附于一定的物质载体，信息与物质载体构成一个整体。我们将这些信息赖以存储和传递的物质载体称为信息载体，信息载体泛指一切载有信息的物质媒体

普遍性

信息是物质的基本属性，普遍存在于自然界和人类社会之中，也存在于人类的思维或精神领域之中。只要有物质存在的地方，就有信息的存在，物质普遍存在的属性导致了信息的普遍性

1.1.3 信息的功能

信息作为人类了解自然及人类社会的凭据，与物质和能源共同奠定了社会发展的基础
大部分决策都是在面临着多种可能出现的结果中做出抉择的，这就更需要全面、正确的信息作为决策的支持
各种社会成员只有在信息交流通畅及时的情况下，依据所获得的准确信息来行使各自的职责，才会使整个系统处于有序状态
通过相关的信息，可以对所选项目是否具有创新性做出判断，避免重复选题，并参考他人的研究方法，加快科研的进程

1.1.4 信息的类型

基于广义信息概念的信息分类

从信息的冠以内涵来划分信息的类型，即把信息理解为对客观事物存在方式和运动状态的反映。据此有以下分类：

根据信息的产生，可以分为社会信息和自然信息 —— 社会信息指人类在社会生活实践中，为生存、生产和社会发展而产生处理和利用的信息；自然信息是自然界中的事物变化、特征以及事物之间的内在关系的反映，如自然景观等
依据信息的运动状态，可以分为自在信息、自为信息和再生信息 —— 自在信息指没有进入人的意识领域，未被反映和把握的纯自然状态信息

基于狭义信息概念的信息分类

按照信息的媒介类型：印刷型信息、微缩型信息、试听型信息、机读型信息
按信息加工处理的程度
- 零次信息指在人际交流中口头携带

1.2 信息素养的特点

1.3 数据挖掘和信息检索

NLP关注自然语言文本的语法、语义、语用分析

NLP可以分析短语结构和语义，使得IR可以在短语上、或者语义桑进行处理，而不是仅仅基于单个关键词，实现语义检索

与IR研究的结合点：基于自然语言的问答检索

NLP与IR融合的其他方面

通过上下文词义消歧（word sense disambiguation）来确定一个词在某个特定上下文的语义
通过一些NLP方法来获得文档中的一个语言片段（information extraction）
通过NLP方法可以从文档集合中返回一些问题的答案

AI

关注知识表示，推理和智能行为
形式化工具

模式识别 & 机器学习

机器学习关注通过对经验的学习来提高计算机系统的性能

通过有指导和无指导方式自动识别模式
文本分类 text categorization
自动层次分类（如Yahoo目录）
自适应过滤/推荐 adaptive filtering / recommending
垃圾过滤 spam clustering
IR结果的自动聚类
层次型类别体系的自动构建

Keyword Search

最常用、最简单、较为宽松

IR的两种模式

Pull 用户主动发起请求，在一个相对稳定的数据集合上进行查询
Push 用户事先定义自己的兴趣，系统在不断到来的流动数据上进行操作，将满足用户兴趣的数据推送给用户

IR系统的组成

文本处理 text operations：对查询和文本进行的预处理操作

中文分词 Chinese word segmentation
词干还原 stemming
停用词消除 stop-word removal

查询处理 query operations：对经过文本处理后的查询进行进一步处理，得到查询的表示 query representation

查询扩展 query expansion：利用同义词或近义词对查询进行扩展
查询重构 query reconstruction：利用用户的相关反馈信息对查询进行

文本索引 indexing：进行进一步处理，得到文本的内部表示 text representation，通常基于索引项 term 来表示

向量化、概率计算
组成成倒排表进行存储

排序 ranking：对搜索出的文本按照某种方式来计算其相关度

排序的效率依赖于索引技术
排序的质量依赖于采用的检索模型

文档可以被表示为 —— 关键词的集合

析取范式是指一个布尔表达式中，将多个子表达式进行或运算（或称为逻辑或）的结果。通常，析取范式的形式是多个项之和的形式，即多个逻辑式通过或连接的结果，例如 (A and B) or (C and D)。

合取范式是指一个布尔表达式中，将多个子表达式进行与运算（或称为逻辑与）的结果。通常，合取范式的形式是多个项之积的形式，即多个逻辑式通过与连接的结果，例如 (A or B) and (C or D)。

在逻辑学中，析取范式和合取范式是等价的，即我们可以通过将一个布尔表达式转化为析取范式或合取范式来达到化简的效果。这也是布尔代数中的一个重要应用。

划词检索

2023-03-08T00:05:46.000Z

function showSelection() {
    let selection = document.getSelection();
    console.log(selection);
    return selection.toString();
}

document.addEventListener("selectionchange", showSelection)

作业

2023-03-07T15:09:17.000Z

第1章分布式计算概述

什么是分布式计算？它的优缺是什么？

分布式计算是一种在多台计算机之间分散任务和数据的计算模型。这些计算机通过网络进行通信和协调，以共同完成一个任务或处理一个数据集合。这种计算模型的主要目的是提高计算速度和可伸缩性。

优点：

高性能：分布式计算可以同时利用多个计算机的计算资源，从而提高整个系统的处理能力和性能。
可伸缩性：分布式计算可以根据需要添加或移除计算资源，以适应不同规模的计算任务或数据集合。
高可用性：分布式计算系统可以通过复制和备份数据和计算节点来提高系统的可靠性和容错性。
灵活性：分布式计算可以将计算任务分割成小的子任务，以便不同的计算机分别处理不同的子任务，从而提高计算的灵活性和效率。

缺点：

复杂性：分布式计算需要在多个计算机之间协调任务和数据，因此系统的设计和实现相对复杂。
数据传输延迟：在分布式计算中，由于需要在不同的计算机之间传输数据，因此可能会出现网络延迟和数据传输瓶颈，影响系统的性能。
安全性：在分布式计算中，需要处理多个计算机之间的数据传输和共享，因此必须采取相应的安全措施来保护系统的数据和机密信息。

分布式计算与并行计算的区别与联系？

分布式计算和并行计算都是处理大规模计算任务的方法。

区别：

概念不同：分布式计算是在多台计算机之间分散任务和数据的计算模型，而并行计算是在单个计算机或计算机集群中同时执行多个处理器或核的计算任务。
系统结构不同：分布式计算通常由多台独立的计算机组成，这些计算机通过网络进行通信和协调；而并行计算通常由多个处理器或核组成，这些处理器或核可以在同一台计算机上或在计算机集群中。
编程模型不同：在分布式计算中，程序员需要考虑如何将任务和数据分布到不同的计算机上，并进行协调和通信；而在并行计算中，程序员需要考虑如何将计算任务划分成多个子任务，并协调这些子任务的执行。

联系：

目标相同：分布式计算和并行计算的目标都是提高计算速度和处理能力，以应对大规模计算任务。
技术相互借鉴：分布式计算和并行计算的技术在某些方面是相互借鉴的。例如，分布式计算中的分布式文件系统可以用于并行计算中的数据共享和访问。
应用领域相同：分布式计算和并行计算都可以应用于科学计算、大数据分析、图像处理、人工智能等领域。

简述一下什么是CAP定理？举例说明CAP不能同时满足。

CAP定理是分布式计算领域的一个基本原则，它指出在一个分布式系统中，不可能同时满足以下三个要求：

一致性（Consistency）：所有节点在同一时间看到的数据是相同的，即数据更新操作在所有节点上都是同时完成的。
可用性（Availability）：系统能够保证在一定时间内对于用户的请求都能够返回响应结果，即系统保证了服务的连续性。
分区容错性（Partition Tolerance）：系统能够在遇到网络分区（网络故障或网络延迟等）的情况下仍然能够继续工作。

举例：假设有一个分布式系统用于在线购物，系统出现网络故障或分区

如果系统优先保证一致性，那么系统在遇到网络分区时，为了保证数据一致性，可能会牺牲可用性，因为系统需要等待所有节点的数据同步完成才能提供服务，这就可能导致用户无法访问系统，即系统不可用。

如果系统优先保证可用性，那么系统在遇到网络分区时，可能会出现数据不一致的情况，因为各个节点上的数据可能存在时间差异，这就可能导致用户在购物时看到的商品信息不一致，即系统缺乏一致性。

如果系统优先保证分区容错性，那么系统在遇到网络分区时，可能会出现数据不一致或系统不可用的情况，但这样可以保证整个系统在网络分区恢复之后仍然能够正常工作。

因此，在分布式系统设计和实现中，需要根据具体的应用场景和需求，权衡一致性、可用性和分区容错性的关系，选择合适的策略和技术来实现系统的要求。

简述一下什么BASE理论，它与CAP的关系。

BASE理论是分布式计算领域的另一个重要理论，它指出在分布式系统中，不一定要求满足ACID（原子性、一致性、隔离性和持久性）的特性，而可以追求更高的可用性和可扩展性。

BASE是指以下三个要素：

基本可用（Basically Available）：系统能够保证在出现故障或性能下降的情况下，仍然能够正常响应用户请求，即系统保证了服务的连续性。
软状态（Soft state）：系统允许存在一段时间的数据不一致，即允许一些数据在一段时间内是过期的，而不要求立即更新所有节点上的数据，从而提高系统的可用性和性能。
最终一致性（Eventually Consistent）：系统保证在一定时间内，所有节点的数据最终达到一致的状态，即系统允许一段时间的数据不一致，但最终会达到一致状态。

与CAP理论相比，BASE理论更加强调分布式系统的可用性和容错性，而相对弱化一致性。

第2章分布式计算泛型概述

分析qq和微信采用的通信技术

qq和微信都使用了TCP协议和HTTP协议，没有用到UDP协议。TCP协议是一种面向连接，可靠的传输协议，HTTP协议是一种应用层的请求-响应协议。qq和微信通讯中使用了HTTP短连接和TCP长连接，并没有用到UDP，其中登陆验证和头像身份信息及日志等功能采用的HTTP，文本消息、语音消息、视频消息、图片消息这些使用的是TCP长连接。通过心跳包来维护长连接状态，300S一个心跳。qq还支持语音和视频聊天，显然,这种场景用点对点的P2P技术最合适，在浏览器里,可以用WebRTC实现.WebRTC里实现点对点的P2P通信,需要一个服务器来帮助建立连接

比较分析 google 的 gRPC, facebook thrift, Hadoop avro

gRPC、Thrift和Avro都是一些流行的RPC框架，它们可以让不同语言和平台的服务之间进行高效的通信。它们都有自己的优缺点，根据不同的场景和需求，可以选择合适的框架。

gRPC是Google开源的基于HTTP/2和Protobuf的RPC框架，它支持多种语言和平台，提供了双向流、拦截器、负载均衡等特性。gRPC的优点是性能高、接口定义简洁、跨语言支持好、支持流式传输；缺点是不支持浏览器客户端、对网络环境要求高、Protobuf不支持map等复杂类型。
Thrift是Facebook开源的基于TCP和二进制协议的RPC框架，它也支持多种语言和平台，提供了多种传输层和协议层的选项。Thrift的优点是性能更高、序列化和RPC一站式解决、IDL支持map等复杂类型；缺点是文档较少、功能较少、跨语言兼容性较差。
Avro是Apache开源的基于JSON和二进制协议的数据序列化框架，它也可以用作RPC框架，但主要用于大数据场景。Avro的优点是模式演进灵活、序列化速度快、数据压缩率高；缺点是功能单一、IDL不够强大、对Java支持最好。

什么是P2P泛型，它的实现原理是什么，举例说明。

P2P泛型是一种无中心服务器的对等网络泛型，即Peer-to-Peer的缩写，翻译为点对点或者端对端，也称为对等计算。P2P是一种以非集中化方式使用分布式资源来完成一些关键任务的系统和应用。

P2P泛型的实现原理是利用网络中的每个节点（Peer）既可以作为客户端又可以作为服务器，相互之间直接通信和交换数据，而不需要依赖于中心服务器。这样可以提高系统的可扩展性、容错性、效率和安全性。

举例：比特币就是一个基于P2P泛型的分布式系统，它使用了一种叫做区块链的技术来记录和验证所有的交易记录，并通过共识机制来保证网络中各个节点之间的数据一致性。

什么是微服务框架，它的优势？

微服务框架是一种架构模式，它将应用程序划分为一组小型的、自治的、松耦合的服务，每个服务负责一个业务领域，并且可以独立部署、扩展和更新。微服务框架的优势有：

提高了系统的可维护性、可测试性和可复用性
降低了系统的复杂度和耦合度
增强了系统的灵活性和可扩展性
支持了不同技术栈和平台的选择
促进了团队的协作和交付

什么是Rest API (Http RestFul)和RPC 的区别？

Rest API (Http RestFul)和RPC是两种不同的通信协议和架构风格，它们在以下方面有所不同：

架构风格：RPC是基于服务调用的架构，客户端和服务器之间通过远程调用实现数据传输和处理；而RestFul是基于资源的架构，客户端通过URI访问服务器上的资源，并使用HTTP方法（如GET、POST、PUT、DELETE）进行操作。
传输协议：RPC可以使用多种传输协议，如TCP、UDP、HTTP等，而RestFul只能使用HTTP作为传输协议。
数据格式：RPC可以使用多种数据格式，如XML、JSON、二进制等，而RestFul通常使用JSON或XML作为数据格式。
性能：RPC由于使用二进制方式进行通信，所以数据传输量更小，性能更高；而RestFul由于使用HTTP封装数据，所以数据传输量更大，性能相对较低。

根据不同的场景和需求，可以选择合适的通信协议。一般来说，如果需要跨平台、跨语言、易于理解和扩展的接口，可以选择RestFul；如果需要高效、稳定、安全的接口，可以选择RPC。

《深度学习》郭剑雄

2023-02-21T10:02:39.000Z

《神经网络与深度学习》

第1章绪论

神经网络：一种以（人工）神经元为基本单元的模型

深度学习：一类机器学习问题，主要解决贡献度分配问题

深度学习框架

简易和快速的原型设计
自动提督计算
CPU/GPU无缝切换
分布式计算

人工智能的研究领域

图灵测试是促使人工智能从哲学探讨到科学研究的一个重要因素，引导了人工智能的很多研究方向

因为要使得计算机能通过图灵测试，计算机必须具备理解语言、学习、记忆、推理、决策等能力

让机器具有人类的智能
- 机器感知（计算机视觉、语音信息处理、模式识别）
- 学习（机器学习、强化学习）
- 语言（自然语言处理）
- 记忆（知识表示）
- 决策（规划、数据挖掘）

如何开发一个人工智能系统？

专家知识（人工规则）
机器学习 ≈ 构建一个映射函数

1.3 表示学习

原始数据 -> **数据预处理 -> 特征提取 -> 特征转换** -> **预测** -> 结果
             -----------------------------        ----
                         特征处理                 浅层学习

底层特征 VS 高层语义

人们对文本、图像的理解无法从字符串或者图像的底层特征直接获得

什么是好的数据表示（representation）？

好的表示是主观概念，没有明确标准

一个好的表示通常具有以下优点：

应该具有很强的表示能力
应该使后续的学习任务变得简单
应该具有一般性，是任务或领域独立的

数据表示是机器学习的核心问题

特征工程：需要借助人类智能

表示形式

局部表示

离散表示、符号表示
One-Hot向量

分布式（distributed）表示

压缩、低维、稠密向量
用O(N)个参数表示O(2^k)区间
- k为非0参数，k < N

	局部表示	分布式表示
A	[ 1 0 0 0 ]	[ 0.25 0.5 ]
B	[ 0 1 0 0 ]	[ 0.2 0.9 ]
C	[ 0 0 1 0 ]	[ 0.8 0.2 ]
D	[ 0 0 0 1 ]	[ 0.9 0.1 ]

语义表示

局部(符号)表示 -> 分布式表示
------------    ---------
 知识库、规则    嵌入(embedding)：压缩、低维、稠密向量

表示学习

表示学习：如何自动从数据中学习好的表示

通过构建具有一定"深度"的模型，可以让模型来自动学习好的特征表示（从底层特征，到中层到高层），从而最终提升预测或者识别的准确性

传统的特征提取

特征提取
- 线性投影（子空间）：PCA、LDA
- 非线性嵌入：LLE、Isomap、谱方法
- 自编码器

特征提取 VS 表示学习

特征提取：基于任务或先验对去除无用特征
表示学习：通过深度模型学习高层语义特征

表示学习与深度学习

一个好的表示学习策略必须具备一定的深度

特征重用：指数级的表示能力
抽象表示与不变性：抽象表示需要多步的构造

深度学习 = 表示学习 + 决策（预测）学习

原始数据 -> 数据预处理 -> 特征提取 -> 特征转换 -> 预测 -> 结果
           -----------------------------
                       表示学习
           -------------------------------------
                           深度学习

贡献度分配问题

神经网络如何学习？

赫布法则 Hebb's Rule

人脑有两种记忆，如果一个经验重复足够的次数，此经验就可储存在长期记忆中

短期记忆转化为长期记忆的过程称为凝固作用

人工神经网络

人工神经网络由神经元模型构成，这种由许多神经元组成的信息处理网络具有并行分布结构

虽然这里将神经网络结构大体上分为三种类型，但是大多数网络都是复合型结构，即一个神经网络中包括多种网络结构

前馈网络
记忆网络
图网络

第2章机器学习概述

机器学习：通过算法使得机器能从大量数据中学习规律从而对新的样本做决策

规律：决策（预测）函数

学习准则

期望风险未知，通过经验风险近似

经验风险最小化

在选择合适的风险函数后，我们寻找一个参数θ*，使得经验风险函数最小化

机器学习问题转化为最优化问题

随机梯度下降法

每次迭代时只采集一个样本

在经过足够次数迭代时，也可以收敛到局部最优解

优点：每次计算开销少，支持在线学习

缺点：无法充分利用计算机的并行计算能力

小批量（Mini-Batch）随机梯度下降法

随机选取一小部分训练样本来计算梯度并更新参数

范化误差 = 经验误差 - 期望误差

优化：经验风险最小
正则化
- 增加优化约束（L1/L2约束、数据增强）
- 干扰优化过程（权重衰减、随机梯度下降、提前停止）

ChatCLI

2023-03-07T05:51:12.000Z

ffmpeg -i "oCam 56.mp4" -vf "setpts=0.25*PTS,scale=640:-1:flags=lanczos,split[s0][s1];[s0]palettegen=stats_mode=diff[p];[s1][p]paletteuse=new=1" -r 30 "oCam 56.gif"

《计算智能》曾文艺

2023-02-21T00:03:16.000Z

离散数学中的等价关系

关系和有向图

R = { (a, d), (a, e) } 是 A->B 上的关系

（偶）序对

（非）自反关系 (a, a)
（非）对称关系 (a, b) <-> (b, a)
（非）传递关系 (a, b) (b, c) => (a, c)

=> 等价关系

关系矩阵

🌰例子

等价关系下的聚类

A = { 1, 2, 3, 4 } 的划分

4类 {1} {2} {3} {4} (1)
1类 {1, 2, 3, 4} (2)
2类 {1}+{2,3,4} {1,2}+{3,4} (4, 3)
3类 {1,2}+{3}+{4} (6)

聚类

聚类是一种无监督学习方法，用于将数据集中的对象按照它们之间的相似性划分为不同的组或簇。聚类的目标是在同一组内的对象相似度较高，而不同组之间的相似度较低。聚类算法通过计算数据对象之间的相似度或距离，并将相似的对象放在同一个簇中，从而实现聚类。

聚类与分类

聚类是一种无监督学习方法，它试图在数据中发现固有的结构，而不需要先验的标签或类别。聚类算法旨在将数据集中的对象按照它们之间的相似性划分为不同的组或簇，聚类的目标是在同一组内的对象相似度较高，而不同组之间的相似度较低。

相比之下，分类是一种监督学习方法，它需要先验的标签或类别来训练模型。分类算法的目标是将数据集中的对象划分为预定义的类别之一。分类算法学习如何将数据映射到已知类别的标签上，以便对新数据进行预测。

簇

同一簇中对象彼此相似

不同簇中对象相异

相异度

根据描述对象的属性值评估，通常使用距离度量

欧几里得距离：平方和再开方
曼哈顿距离：各维度差的绝对值之和
切比雪夫距离：各维度差的绝对值的最大值
余弦相似度：向量夹角的余弦值
马氏距离：两个向量之间的马氏距离

聚类分析的典型要求

可伸缩性 / 处理不同类型属性的能力 / 发现任意形状的簇 / 对于决定输入参数的领域知识需求最小 / 处理带噪声数据的能力 / 增量聚类和对输入记录的次序不敏感 / 高维性 / 基于约束的聚类 / 可解释性和可用性

划分方法

给定n个对象的数据集D，以及要生成的簇的数目k，将对象组织为k个划分（k<=n），每个划分代表一个簇

平方误差准则

对于每个簇中的每个对象，求对象到其簇中心距离的平方，然后求和

使用这个准则，试图使生成k个结果的簇尽可能的紧凑和独立

「最小一乘」鲁棒性比最小二乘法更强

K-means

优势
- 快速简单
- scalable
- 时间复杂度O(nkt)接近于线性，该方法终止于局部最优解而且适合挖掘大规模数据集
  - n是对象总数，k是簇的个数，t是迭代次数
  - k<<n，t<<n
局限性
- k是事先给定的，k值的选定难以估计，很多时候，k未知
- K-means算法中，需要根据初始聚类中心来确定一个初始划分，然后对初始划分进行优化。这个初始聚类中心对选择对聚类结果有较大的影响，一旦初始值选择的不好，可能无法得到有效的聚类结果
- 不适合发现非凸面型状的簇或者大小差别很大的簇。而且，它对于噪声和孤立点的数据是敏感的
改进
- K-medoids K-medoids使用曼哈顿距离而不是欧几里得距离，并选择每个簇的一个点作为中心，这些点称为medoids。K-medoids算法比K-means算法更健壮，因为它可以处理噪声和离群值。它的时间复杂度为O(k(n-k)^2)，其中k是簇数，n是数据点数
- K-mode K-mode算法用于离散型数据的聚类，它使用了众数而不是均值来计算每个簇的中心，同时使用哈密顿距离（即两个向量中对应维度不同的数量）而不是欧几里得距离来衡量向量之间的相似度。K-mode算法适用于分类数据和文本数据等非连续型数据。它的时间复杂度为O(k(n-k)L)，其中L是属性数
- K-prototype K-prototype算法结合了K-means和K-mode算法的优点，同时支持连续和离散型数据。它使用欧几里得距离来衡量连续型数据之间的相似度，并使用哈密顿距离来衡量离散型数据之间的相似度。K-prototype算法对于同时包含连续型和离散型数据的混合数据集非常有效。它的时间复杂度为O(k(n-k)L)，其中L是属性数

K-means是一种基于均值的聚类算法，将每个数据点分配到最近的质心（均值），然后更新质心位置，不断迭代直到收敛。但是，K-means算法只适用于数值型数据，不能处理分类变量和混合数据类型。

K-medoids是一种基于中心点的聚类算法，与K-means相似，但是将每个簇的中心点指定为簇中具有最小平均距离的样本，而不是使用均值。这使得K-medoids更适用于处理非数值型数据，但是由于每次迭代需要重新计算中心点，因此计算成本比K-means更高。

K-modes是一种聚类算法，专门用于处理分类数据。它使用频率最高的类别作为簇的代表，并通过最小化汉明距离（样本之间的不匹配数量）来确定簇。与K-means和K-medoids不同，K-modes算法使用非连续距离度量。

K-prototype是一种融合了K-means和K-modes的聚类算法，能够同时处理数值型和分类数据。它使用欧氏距离来度量数值型数据之间的距离，使用汉明距离来度量分类数据之间的距离，通过最小化距离和来确定簇。相比于K-means和K-medoids，K-prototype具有更广泛的适用性，但是也更加复杂。

全集 X
集合 A = { x | x ∈ A } ⊆ X

集合的特征函数（离散数学）

f_A: X → { 0, 1 }

集合的运算 -> 特征函数的变换

f_{A∩B}(x) = f_A(x) f_B(x) = min(f_A(x), f_B(x))
f_{A∪B}(x) = f_A(x) + f_B(x) - f_A(x) f_B(x) = max(f_A(x), f_B(x))

模糊集合A有隶属函数：

μ_A(x): X -> [0, 1]

定义模糊集合的交并运算，借助隶属函数

分解定理

表现定理

隶属函数的建立方法

1.7.1 模糊统计方法

2 模糊模式识别

区间值模糊集合

直觉模糊集 IFS

犹豫模糊集合

毕达哥拉斯模糊集 PFS

2.1 模式识别直接方法

2.1.1 最大隶属原则

2.1.2 阈值原则

2.2 贴近度与择近原则

距离
相似度 similarity measure

2.2.1 模糊集的内积与外积

内积：两个集合先取小，结果再取上确界
外积：两个集合先取大，结果再取下确界

2.2.2 格贴近度

内积与相似度正相关
外积与相似度负相关

2.2.3 择近原则

认为是正态分布，于是格贴近度第二项为1，只用求两正态分布曲线交点

然而格贴近度还是有很大问题

自己跟自己的贴近度不一定为1
如果两个模糊集上限下限相同，贴近度为1

贴近度的公理化定义

对称性
当且仅当A和B相同时，A与B贴近度达到最大值
和空集贴近度为0
A⊆B⊆C，A与C的距离最远

利用闵可夫斯基距离定义贴近度

《自然语言处理》闵勇

2023-02-20T05:25:20.000Z

交叉学科视角：计算机+信息学
重视基础和原理：计算机科学和语言学不是单纯的工程技术性学科
强调实践
选修课

参考书目：

Jurafsky.D., & Martin. I. (2008), Speech and Language Processing. 2nd Edition. Prentice Hall
Manning, C. D., & Schutze, H. (1999). Foundations of Statistical Natural Language Processing. The MIT Press

Chapter 1 Introduction to NLP

The language-related parts of HAL

speech recognition 语音识别
natural language understanding ( & lip-reading ) 自然语言理解
natural language generation 自然语言生成
speech synthesis 语音合成
information retrieval 信息检索
information extraction and inference 信息抽取和推理

观点：

1 + 1 = 2 —— 中缀表达法（动词放中间） —— 限制是：不能表达多主语/多宾语
中英是中缀，德/日反之
而函数 f(x, y) —— 前缀表达 —— 更适合规范化表达

Knowledge in Speech and Language Processing

Speech and Language Processing (SLP) = Computational Linguistics + Speech Recognition and Synthesis

语音和语言处理（SLP）= 计算语言学 + 语音识别和合成

这个等式表达了语音和语言处理（SLP）的概念，它是由两部分组成的。其中，计算语言学（Computational Linguistics）是指通过计算机技术来分析和处理人类语言的学科，包括自然语言处理、语音处理、文本挖掘等；而语音识别和合成（Speech Recognition and Synthesis）则是指将人类语音转化为文本或者将文本转化为人类语音的技术。

语言处理的应用（Applications of language processing）：

spelling correction
grammar checking
information retrieval
machine translation

语言学的体系

音韵学 Phonetics and Phonology — The study of linguistic sounds 研究语音
词法学 Morphology — The study of the meaningful components of words 研究词的意义组成部分
句法学 Syntax — The study of the structural relationships between words 研究单词之间结构关系
语义学 Semantics — The study of meaning
语用学 Pragmatics — The study of how language is used to accomplish goals 研究语言如何呗用于达成目标
语篇分析学 Discourse — The study of linguistic units larger than a single utterance 研究大于单个话语的语言单位的学科

反思：类似AlphaGo颠覆围棋界一些公理，语言学的这些结论一定是对的吗

1.2 Ambiguity

歧义

常识消除歧义？

消歧义 resolve / disambiguate

lexical disambiguation —— 词义消歧
- part-of-speech tagging —— 词性标注
- word sense disambiguation —— "She went to the bank to deposit her paycheck." —— 同义词
syntactic disambiguation —— "The chicken is ready to eat." —— 句法消歧
- probabilistic parsing —— 计算每种结构的概率，选择最可能的结构
speech act interpretation ——“你可以帮我关一下窗户吗？”是请求而非询问 —— 需要结合交际学背景知识 & 上下文

1.3 Models and Algorithms

语言学家不如统计？

1.4 Language, Thought, and Understanding

图灵测试

Chapter 2 Basic Text Processing

Regular Expression

文法、自动机、计算模型

语料库的差异

language 语言：不同语言的语料库会在词汇、语法、语义等方面存在差异。例如，中文和英文在语法结构上存在很大不同，所以对应的语料库也会有所区别。
variety 方言：同一种语言的不同方言在发音、词汇和语法方面也会存在差异。因此，方言语料库可能会包含方言特有的词汇和语法结构。
code switching 语码切换：一些语言或方言中可能会存在语码切换，即在不同的语言或方言之间频繁切换使用。这种情况下，语料库也需要考虑这种语码切换的情况，以便更好地反映实际语言使用情况。
genre 文体：不同的文体在语言、词汇和语法方面也会存在很大差异。例如，新闻报道、科技论文和小说等不同类型的文体具有不同的语言特点，因此需要针对不同的文体建立相应的语料库。
author demographics 作者人口统计学：作者的年龄、性别、教育程度、职业等因素也会影响他们的语言使用习惯。因此，根据不同的作者人口统计学特征，建立对应的语料库可以更好地反映实际语言使用情况。

分词

Byte Pair Encoding (BPE) token learner

BPE 算法的步骤如下：

对训练集中的所有单词进行字符切分。
统计每个字符组合（即连续的两个字符或字符与空格的组合）在训练集中出现的频率。
将出现频率最高的字符组合替换为一个新的字符。
重复步骤 2 和 3，直到达到预设的词汇表大小。

BPE 算法的一个优点是，可以在不需要人工干预的情况下，根据训练集中的词汇特征自适应地生成对应的词汇表，因此对于不同语言或领域的数据集都能够适用。

BPE 算法也有一些局限性，例如对于一些较长的词汇，BPE 会将其切分成多个子词，这会导致模型难以理解这些词汇的完整含义。另外，BPE 在处理未知词汇时的效果可能不如基于词典的方法，因为 BPE 只是将未知词汇切分成已知的子词，而并没有为其赋予特殊的含义。

BPE token learner是BPE算法的一种变体，主要用于学习词汇表的生成。

BPE token learner的基本流程如下：

初始化词典：将语料库中的每个字符都视为单独的符号，并在词典中对其进行计数。例如，对于一个由"hello world"组成的语料库，词典中将包括"h", "e", "l", "o", "w", "r", "d"这些字符，并对它们进行计数。
计算合并频率：将语料库中出现频率较高的字符对合并成一个新的符号，并在词典中更新其出现次数。例如，在"hello world"语料库中，出现频率最高的字符对是"l"和"o"，因此将其合并成一个新的符号"lo"，并将其在词典中的计数更新为这两个字符在语料库中出现的次数之和。
迭代合并：重复上述步骤，直到达到预定的词汇表大小或者不再有频率高于指定阈值的字符对。例如，在一个由10000个单词组成的语料库中，如果指定的词汇表大小为1000，则将重复执行上述步骤，直到词典中包含1000个符号为止。
生成编码：将每个符号替换成一个由0和1组成的编码，用于在后续的任务中表示该符号。编码的生成过程类似于霍夫曼编码，即出现频率较高的符号将被编码为较短的编码，出现频率较低的符号将被编码为较长的编码。例如，在"hello world"语料库中，生成的编码表可能如下所示：
- h: 00
- e: 01
- l: 10
- o: 11
- w: 001
- r: 010
- d: 011

BPE token learner的核心思想是将语料库中的高频字符对合并成新的符号，从而减少词汇表的大小，提高模型的效率。BPE token learner还可以应用于处理未登录词等问题，因为它可以根据语料库中的数据自适应地生成新的词汇表，包括处理未登录词。

N-gram

n-gram是一种文本表示方法，它将文本中的单词或字符序列分成连续的n个元素，并将这些元素作为新的单元进行处理和分析。n-gram的n表示连续元素的个数，n越大，生成的n-gram序列就越长，表示的信息也就越丰富。

当n=1时，生成的n-gram序列就是每个单词本身，如"I love to eat pizza"生成的1-gram序列就是"I","love","to","eat","pizza"。

当n=2时，生成的n-gram序列就是每两个相邻单词组成的序列，如"I love to eat pizza"生成的2-gram序列就是"I love","love to","to eat","eat pizza"。

当n=3时，生成的n-gram序列就是每三个相邻单词组成的序列，如"I love to eat pizza"生成的3-gram序列就是"I love to","love to eat","to eat pizza"。

本质上是在做语言的预测

马尔可夫假设下，只需要用一个二维表就能存储，但也算是表达了词序

TF-IDF

typeflow

2023-03-02T03:00:51.000Z

最近由gRPC看到了protobuf，了解了一些IDL，我不太喜欢他们这种code-gen风格

我想发明一种序列化协议

可以在文件头定义类型或者另外定义类型
定义类型为：id+type
type支持级联的方式
数据是连续的id+len+data，如果是基本数据类型则不用len

type定义部分（用json描述，但也可以很容易地改变为"类型+(长度)+值"的结构

id
- 列表
- object / structure
- 基本数据类型……
- 剩下的才需要定义
size（0则为不固定，需要填）
data: list
- type: id
- name: str

data数据部分，每个单元为：

由id得倒type，后一个不是size就是data
递归地parse
一个int代表type定义部分的长度
一个最后得出的 int id
一个代表类型的
- 0 structure
- 1 bool
- 2 int
- 3 float
- 1 string

对于structure

一个int代表type定义部分的长度

Data类，用类型标注。装饰器识别类型标注，生成树结构 —— 这个很容易
可以dumps()一个Data类，输出为json/binary
1. 自身id
2. 属性名，属性id，属性size
可以dumps()一个Data实例
1. 如果是基本类型，输出[类型id]+[可能有size]+[bytes(self.data)]
2. 如果不是基本类型（是对象类型）
  1. 第三部分变成[b"".join(i.encode() for i in ...)]
  2. 第二部分如果需要，就变成len(...)
3. dumps()一个Data实例就是调用它的encode()方法
可以decode一个二进制串
1. 读其id，如果是基本类型，输出它本身
2. 如果是对象类型，逐个将它的data链接为自己的属性

《大数据原理与技术》陈红顺

2023-02-23T00:01:01.000Z

第1章大数据概述

1.1 产生背景和发展历程

存储设备容量不断增加
CPU处理能力大幅增长
网络带宽不断增加

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

运营式系统阶段
用户原创内容阶段
感知式系统阶段

1.2 大数据的概念

大数据是需要新处理模式才能具有更强的决策力、洞察发现力和流程优化能力来适应海量、高增长率和多样化的信息资产

大数据是指一种规模大到在获取、存储、管理、分析方面大大超出了传统数据库软件工具能力范围的数据集合，具有海量的数据规模、快速的数据流转、多样的数据类型和价值密度低四大特征

数据规模大
数据多样化
- 大数据是由结构化和非结构化数据组成的
- 10%的结构化数据，存储在数据库中
- 90%的非结构化数据，与人类信息密切相关
数据变化快
价值密度低

云计算、大数据、物联网的区别与联系

云计算为大数据提供了技术基础，大数据为云计算提供用武之地
物联网是大数据的重要来源，大数据技术为物联网数据分析提供支撑
云计算为物联网提供海量数据存储能力，物联网为云计算技术提供了广阔的应用空间

人工智能三大基石

数据 —— 大数据
算力 —— 云计算
算法 —— 机器学习/深度学习

1.3 大数据的关键技术

数据采集

利用ETL工具将分布的、异构数据源中的数据如关系数据、平面数据文件等，抽取到临时中间层后进行清洗、转换、集成，最后加载到数据仓库/数据集市中，成为联机分析处理、数据挖掘的基础；或者也可以把实时采集的数据作为流计算系统的输入，进行实时处理分析

ETL是指从数据源中提取（Extract）、转换（Transform）和加载（Load）数据到目标数据库或数据仓库的过程。在数据采集领域，ETL通常是指将各种异构数据源的数据收集起来，经过清洗、处理、转换等一系列操作后，将数据导入到统一的目标数据仓库中，以方便后续的分析和挖掘。这个过程中，需要用到各种数据处理和转换技术，如数据清洗、数据规范化、数据聚合等等。

数据存储与管理

利用分布式文件系统、数据仓库、关系数据库、NoSQL数据库、云数据库等，实现对结构化、半结构化和非结构化海量数据的存储和管理

数据处理与分析

利用分布式并行编程模型和计算框架，结合机器学习和数据挖掘算法，实现对海量数据的处理和分析

数据安全和隐私保护

从大数据中挖掘潜在的巨大商业价值和学术价值的同时，构建隐私数据保护体系和数据安全体系，有效保护个人隐私和数据安全

数据可视化

将数据和分析结果转化为图形图像，实现对稀疏、杂乱、复杂的数据深入洞察，发现背后有价值的信息

两大核心技术

分布式存储
分布式处理（计算）

1.4 大数据处理（计算）模式

数据集分类

有界数据集：具有时间边界，数据有一定的起始和结束时间
无界数据集：数据从开始生成就一直不断地产生新的数据

主要处理模式

批处理：有界数据，高吞吐，高延迟
流处理：流式数据，低延迟，低吞吐

常见大数据处理框架

仅批处理：Hadoop MapReduce
仅流处理：Storm、Samza
混合：Spark、Flink
- Spark：核心是批处理，流处理被定义为微批处理，商业应用成熟
- Flink：核心是流处理，批处理被定义为有限流处理，设计理念先进

大数据处理模式

大数据处理模式	解决问题
批处理	针对大规模数据的批量处理
流处理	针对刘数据的实时计算
图处理	针对大规模图结构数据的处理
交互式查询	大规模数据的存储管理和查询分析

1.5 大数据处理架构Hadoop

运行于大规模普通服务器上
用于大数据存储、处理
一种分布式存储系统和分布式计算框架

能为庞大的计算机集群提供可靠的、可伸缩的应用层计算和存储支持
- 它允许使用简单的编程模型模型跨计算机集群分布式处理大型数据集，并且支持在单台计算机到几千台计算机之间进行扩展
- 可以在计算机集群的顶部提供高可用性服务，虽然每台计算机都很容易出现故障
Hadoop使用Java开发，可以在不同硬件平台的计算机上部署和使用
核心组件包括分布式文件系统HDFS和MapReduce

Hadoop 运行模式

单机模式：只在一台机器上运行，存储采用本地文件系统
伪分布式：存储采用HDFS文件系统，用Java进程模拟小规模集群
完全分布式：运行在真实的Hadoop集群上

大数据系统架构

Lambda架构
Kappa架构

1.6 大数据的影响

大数据带来的思维变革

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

1.7 大数据的应用

2.1 分布式文件系统

分布式文件系统把文件分布存储到多个计算机节点上，成千上万的计算机节点构成计算机集群

2.1.2 分布式文件系统的设计需求

透明性：具备访问透明性、位置透明性、性能和伸缩透明性
并发控制：客户端对文件的读写不应该影响其他客户端对同一文件的读写
文件复制：一个文件可以拥有在不同位置的多个副本
硬件和操作系统异构性：可以在不同操作系统和计算机上实现同样的操作
可伸缩性：支持节点的动态加入或退出
容错：保证文件服务在客户端或服务器出现问题时能正常使用
安全

2.2 HDFS设计思想

考虑到应用场景和实际应用环境的特点，HDFS设计主要实现以下目标：

兼容廉价的硬件设备：设计了快速硬件故障检测和进行自动恢复的机制
流数据读写：为了满足批量数据处理的要求，以流式方式访问文件系统数据，可以提高数据吞吐量
大数据集：文件通常可以达到GB甚至TB级别，一个数百台机器组成的集群可以支持千万级别这样的文件
简单的文件模型：采用"一次写入、多次读取"的简单文件模型
强大的跨平台兼容性：HDFS采用Java语言实现

HDFS的特殊设计的局限性：

不适合低延迟数据访问
无法高效存储大量小文件
只允许一个文件有一个写入者
只允许对文件执行追加操作（不能执行随机写操作）

2.3 HDFS相关概念

2.3.1 块

HDFS将大文件分成块（默认128MB），块可以分布到不同的节点上
HDFS采用分治策略，令多个节点对逻辑层面的大文件在物理层面进行分布式存储
块的大小远远大于普通文件系统，可以最小化寻址开销

HDFS采用分块存储的优点：

支持大规模文件存储：文件大小不会受到单个节点的存储容量限制，可以远远大于网络中任意节点的存储容量
简化系统设计
- 文件块大小固定，易计算出一个节点可以存储多少文件块
- 方便元数据管理，元数据不需要和文件块一起存储，可以由其他系统负责管理元数据
适合数据备份：每个文件块都可以冗余存储到多个节点上，大大提高了系统的容错性和可用性

2.3.2 NameNode

NameNode负责管理分布式文件系统的命名空间，保存了两个核心的数据结构：

FsImage 用于维护文件系统树以及文件树中所有文件和文件夹的元数据
EditLog 操作日志文件记录了所有针对文件的创建、删除、重命名等操作

NameNode记录了每个文件中各个块所在的DataNode的位置

FsImage

FsImage文件包含文件系统中所有目录和文件inode的序列化形式

每个inode是一个文件或目录的元数据的内部表示，并包含：文件的复制登记、修改和访问时间、访问权限、块大小、组成文件的块。对于目录，存储修改时间、权限、配额元数据

FsImage文件没有记录每个块存储在哪个DataNode，二是由NameNode把这些映射信息保留在内存中

当DataNode加入HDFS集群时，DataNode会把自己所包含的块列表告知给NameNode，此后会定期执行这种告知操作，以确保NameNode的块映射是最新的

NameNode的启动

在NameNode启动时，它会将FsImage文件中的内容加载到内存中，之后再执行EditLog文件中的各种操作，使得内存中的元数据和实际的同步，存在内存中的元数据支持客户端的读操作

一旦内存中成功建立文件系统元数据的映射，则创建一个新的FsImage文件和一个空的EditLog文件。

NameNode起来之后，HDFS中的更新操作会重新写到Editlog文件中，因为FsImage文件一般都很大，如果所有更新操作都往FsImage文件中添加，这样会导致系统运行的十分缓慢。但是，如果往EditLog文件里面写就不会这样，因为EditLog小得多，每次执行写操作之后，且在向客户端发送成功代码之前，edits文件都需要同步更新。

2.3.3 SecondaryNameNode

在NameNode运行期间，HDFS

2.3.3 DataNode

2.4 HDFS体系结构

主从架构。

2.5 HDFS存储原理

2.6 HDFS文件读写

2.7 HDFS编程实践

《计算机组成原理》尹乾

2023-02-21T05:26:01.000Z

学习目的

计算机的硬件组成

五大组成部件：控制器（CPU）、运算器（CPU）、存储器、输入设备、输出设备

掌握计算机的运行原理

计算机如何执行机器语言程序

理解现代计算机中的一些核心技术

流水、并行、Cache

提高程序设计能力

培养计算机设计能力

本课程作为软硬件中间

第一章

1.1 计算机发展历程

原始计算工具

机械式计算机

机电式计算机

现代计算机

1.2 计算机系统组成

1.3 计算机系统层次结构

1.4 计算机系统性能评价

非时间类指标

机器字长、总线（数据总线）宽度、主存容量与存储带宽、CPU内核数

时间指标

主频、时钟周期、外频、倍频
CPI：clock cycles per instruction
IPC：instructions per clock cycle — 强调并行
MIPS / MFLOPS
CPU时间

基准测试程序

综合型测试程序/定点运算性能测试/浮点运算性能测试/数据库性能测试/并行运算测试

第二章计算机数据表示

将数据按照某种方式组织，以便机器硬件能直接识别和使用

数据表示考虑因素

数据的类型
表示的范围和精度
存储和处理的代价
软件的可移植性

二进制

原码 —— 小数的尾数部分
反码
补码 —— 利用取模
移码

《大数据安全与隐秘保护》王晶

2023-02-20T10:03:22.000Z

以下是《大数据安全与隐私保护》课程的可能大纲，仅供参考：

课程介绍
1. 课程简介与教学目标
2. 大数据安全与隐私保护的概念、挑战与重要性
3. 课程涉及的技术、方法、工具与应用领域
数据安全基础
1. 数据安全的概念、特点与威胁
2. 数据加密、解密与数字签名
3. 数据完整性、机密性、可用性与非抵赖性
4. 数据备份与恢复
5. 数据安全管理、评估与认证
隐私保护基础
1. 隐私保护的概念、原则与法律法规
2. 隐私泄露的形式、风险与后果
3. 隐私保护技术：匿名化、脱敏化、差分隐私等
4. 隐私保护措施：访问控制、审计、隐私风险评估等
大数据安全与隐私保护技术
1. 大数据的特点、应用场景与安全挑战
2. 大数据安全与隐私保护技术：数据分类、数据脱敏、数据聚合、数据共享等
3. 大数据隐私保护工具与平台：差分隐私工具、隐私保护计算框架等
大数据安全与隐私保护案例分析
1. 大数据安全与隐私保护在不同领域的应用案例：医疗、金融、社交网络、智能交通、物联网等
2. 案例分析与讨论：数据隐私泄露事件、安全漏洞案例、隐私保护成功案例等
大数据安全与隐私保护趋势与展望
1. 大数据安全与隐私保护的未来发展趋势与挑战
2. 大数据安全与隐私保护的新技术、新方法与新应用领域
3. 大数据安全与隐私保护相关职业的发展前景与要求
课程总结与评价
1. 课程回顾与知识点梳理
2. 课程体验与反馈
3. 课程作业与考核方式

从数据安全法到数据安全治理

全球数据泄露大事件泄露数据类型分布

个人信息 60.2%
- 实名信息 64.3%
- 账号密码 17.9%
- 其它
- 行为数据
- 敏感信息
- 人脸指纹
其它
商业机密
软件源代码
政府机密

海外非法数据交易涉及境内机构行业分布

按交易信息数统计：互联网（28.7%）、制造业（12.9%）、其它、金融、生活服务、政府及事业单位、医疗卫生、交通运输、教育培训、电商云因素、电子政务

按泄露数据量统计：互联网（47.1%）……

引发数据安全应急响应事件的攻击类型分布

勒索软件（59.7%），漏洞利用（14.6%），钓鱼邮件，木马攻击，非攻击事件，其它

攻击者目的

敲诈勒索（60.7%），窃取机密（9.8%）……

商业机密：数据类型

文档数据（73.2%），代码数据（18.9%），文化版权数据盗版（7.9%）

文档类数据的泄露渠道

百度文库（45.9%），道客巴巴（32.1%），豆丁网（12.1%），360文库，百度网盘

数字化可以带来收益，做好数字化安全就是长期收益，这是政府要求数字化时代发展与安全同等重要的一个基本逻辑

做不好数据安全就没有在数字化市场发展下去的资格和必要，要么努力追上，要么淘汰退出

数据安全是未来的一个趋势，安全正处在一个裂变的风口上，最大的阻碍是技术基础建设的成熟度

数据安全投入决定信息化市场能否入场，成熟的基础技术建设是建立竞争优势的重要因素

问题与挑战

数据安全治理关键问题点：《数据安全法》对"数据安全"的定义为：确保数据处于有效保护、合法利用的状态，并应具备能力保障以上安全状态的持续。在这样一种共识下，企业，特别是持有大量重要数据并以此为业务核心资产的企业来讲，主要需要考虑以下三个问题

企业有哪些重要数据？

数据在2020年由国务院明确为一种生产要素，也是企业的一种资产，企业开展数据治理之前第一步依然是明确持有多少重要数据资产，这些数据目前在哪里，以什么样的形态存在、使用

重要数据的对内"管理成本"

重要数据在内部不能再处于"裸奔"的状态，为了确保有效保护、合法利用，在企业内部需要对重要数据采取加密、脱敏保护，重要数据的访问需要严格遵循最小必须。这些控制措施会增加数据在内部的使用成本，特别是在企业的信息数字化成熟度不高的场景

重要数据的对外"交换成本"

数据作为一种生产要素是给企业带来盈利的一项核心资产，除了围绕数据资产独立展开业务经营的场景，如果企业不能一刀切中断数据对外合作，那么在过程中如何保障数据可用不可见，虽然我们目前有相关的隐私计算技术，但这依然给数据交换带来了不小的成本增加

挑战

制度标准、流程规范、产品技术

数据使用：业务数据查询 / 数据统计分析 / 生产排障查询 / 生产数据变更 / 风控内控审计 / 监管报送 / 制卡、档案管理 / 人事、律所、财务 / 客服、物流、广告 / 对外合作项目

数据安全法

1 绪论

大数据概述

根据来源对象：分为人、机、物……
根据应用领域：分为互联网、物联网、生物医疗、电信、金融、智慧城市、交通、科学研究……

大数据安全与隐私保护需求

由于去匿名化技术的发展，实现身份匿名越来越困难
基于大数据对人们状态和行为的预测带来隐私泄露威胁

区别与联系

大数据安全需求更为广泛，关注的目标不仅包括数据机密性，还包括数据完整性、真实性、不可否认性、以及平台安全、数据权属判定等。而隐私保护需求一般聚焦于匿名性
虽然隐私保护中的数据匿名需求与安全需求之一的机密性需求看上去比较类似，但后者显然严格得多，基于大数据对人们状态和行为的预测带来隐私泄露威胁
在大数据安全问题下，一般来说数据对象是有明确定义的。而在涉及隐私保护需求时，所指的用户"隐私"则比较笼统，而且可能具有多种数据形态存在

大数据生命周期安全风险

数据采集、数据传输、数据存储、数据分析与使用

大数据安全治理框架

技术层面、管理层面、制度层面、决策层面

《Web技术开发实践》吴小勇

2023-02-20T00:06:40.000Z

考核要求

平时实验（5次以上），考勤，问题

期中，项目需求或者原型检查

期末，大作业（项目）汇报（PPT，需求，作品，答辩）

作业小组作业（3-4人/组）

C/S和B/S

胖客户端：client/server
- 客户端=服务器结构
browser/server
- 统一了客户端

解析pdf的一些尝试

2023-02-25T05:55:52.000Z

使用pdfplumber

import pdfplumber
from itertools import pairwise


class Document:
    def __init__(self, filename):
        self.pdf = pdfplumber.open(filename)

    def get_all_words(self):
        for page in self.pdf.pages:
            for word in page.extract_words():
                yield word["text"]

    def get_joined_tokens(self):
        for i, j in pairwise(self.get_all_words()):
            yield i + j

    def get_critical(self):
        for token in self.get_joined_tokens():
            if "信息技术" in token and "投入" in token:
                print(f"\n {token} \n")

爬取东方证券上的券商数据

2023-02-25T05:45:08.000Z

代码写的比较混乱：

from httpx import Client
from json import loads
from alive_progress import alive_it

client = Client(
    headers={
        "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/110.0.0.0 Safari/537.36 Edg/110.0.1587.50"
    }
)


def parse_broker(broker_id):
    url = f"http://emweb.securities.eastmoney.com/PC_HSF10/NewFinanceAnalysis/ZYZBAjaxNew?type=1&code={broker_id}"
    res = client.get(url)
    try:
        data: list = res.json()["data"]
    except KeyError:
        print(broker_id)
        return

    total = [i["TOTALOPERATEREVE"] for i in data]
    profit = [i["PARENTNETPROFIT"] for i in data]

    return total, profit


def get_brokers():
    url = "https://search-api-web.eastmoney.com/search/jsonp?cb=jQuery35105205651282387875_1677270053469&param=%7B%22uid%22%3A%22%22%2C%22keyword%22%3A%22%E8%AF%81%E5%88%B8%22%2C%22type%22%3A%5B%22codetableLabelWeb%22%5D%2C%22client%22%3A%22web%22%2C%22clientType%22%3A%22wap%22%2C%22clientVersion%22%3A%22curr%22%2C%22param%22%3A%7B%22codetableLabelWeb%22%3A%7B%22pageIndex%22%3A1%2C%22pageSize%22%3A50%2C%22preTag%22%3A%22%22%2C%22postTag%22%3A%22%22%2C%22isHighlight%22%3Afalse%2C%22label%22%3A%22AB_STOCK%22%7D%7D%7D&_=1677270053474"
    res = client.get(url)
    text = res.text
    json = text[text.index("(") + 1: text.index(")")]
    data = loads(json)
    ids = [i["securityType"][:2] + i["code"] for i in data["result"]["codetableLabelWeb"]["labelList"][0]["quoteList"]]
    return ids


if __name__ == '__main__':
    all_data = {i: parse_broker(i) for i in alive_it(get_brokers())}

结果为：

{
  "SH600030": [
    [
      76523716526.93,
      54382730241.56,
      43139697642.01,
      37220708075.49,
      43291634080.53,
      38001695917.06,
      56013436032.55,
      29197531133.19,
      16115272156.7
    ],
    [
      23099624927.77,
      14902324215.75,
      12228609723.82,
      9389895989.94,
      11433264545.6,
      10365168588.41,
      19799793374.33,
      11337193825.46,
      5243916979.11
    ]
  ],
  "SH600109": [
    [
      7126630308.69,
      6062801499.95,
      4349514734,
      3766119304.82,
      4390587320.59,
      4671462425.22,
      6748452672.79,
      2721722488.96,
      1546260843.9
    ],
    [
      2317318717,
      1862640224.66,
      1298539701.33,
      1010492527.44,
      1201432521.06,
      1298730528.61,
      2359776226.13,
      836489632.37,
      315915955.64
    ]
  ],
  "SH600369": [
    [
      3096080385.1,
      3169571453.97,
      3488837437.18,
      2744154393.47,
      3060764762.1,
      3631762015.75,
      8496799180.16,
      3674829197.88,
      1964126453.35
    ],
    [
      1038152895.95,
      1091487407.23,
      1042001454.67,
      226842591.87,
      668800161.74,
      917572729,
      3554650541.89,
      1339048940.41,
      630328806.7
    ]
  ],
  "SH600837": [
    [
      43205467448.92,
      38219828310.55,
      34860320039.44,
      23765014627.26,
      28221667163.35,
      28011014594.51,
      38086267720.37,
      17978474435.1,
      10454954029.51
    ],
    [
      12826517065.48,
      10875396346.26,
      9523247834.58,
      5211093198.87,
      8618423293.06,
      8043334519.3,
      15838850897.61,
      7710623597.6,
      4035024048.18
    ]
  ],
  "SH600906": [
    [
      2524296711.14,
      2049789593.71,
      1813260306.57,
      1460659256.36,
      1469446884.96,
      1826594490.25,
      3901471990.05,
      2019138077.72,
      1061354574.54
    ],
    [
      680476070.18,
      531912511.18,
      609173507,
      73632352.15,
      296796161.76,
      656518792.32,
      2044799148.99,
      832084944.53,
      231616429.41
    ]
  ],
  "SH600909": [
    [
      3483420429.82,
      3356521373.89,
      3231605381.54,
      1761325423.29,
      1917696780.54,
      1733047755.13,
      3816204907.49,
      1689616580.33,
      941343121.09
    ],
    [
      1424067013.48,
      1267903291.32,
      1108359114.76,
      553744956.32,
      649726827.62,
      602013378.58,
      1865072011.2,
      686113287.1,
      187193507.17
    ]
  ],
  "SH600918": [
    [
      13149669222.3,
      10352224019.84,
      9708987193.91,
      7025218940.45,
      8168926941.65,
      8347371893.3,
      15045289807.52,
      5874417405.85,
      4081226500
    ],
    [
      3200009354.36,
      2525298270.86,
      2249463067.12,
      1009145069.71,
      1795153414.05,
      2451977469.41,
      6062485984.47,
      1873533391.99,
      869628500
    ]
  ],
  "SH600958": [
    [
      24370394956.88,
      23133946765.29,
      19052097313.75,
      10303490892.44,
      10531511324.13,
      6876188934.65,
      15434705061.27,
      5499603011.02,
      3243936742.44
    ],
    [
      5371496261.61,
      2722988518.72,
      2435079764.1,
      1231013208.91,
      3553626384.73,
      2313974857.75,
      7325224517.53,
      2341671183.75,
      1007421947.97
    ]
  ],
  "SH600999": [
    [
      29428896087.24,
      24277670240.59,
      18708369944.73,
      11321611555.03,
      13353213641.86,
      11695453558.82,
      25291794057.95,
      11002468274.67,
      6089160550.68
    ],
    [
      11645065137.15,
      9491638796.98,
      7282380829.33,
      4424985940.97,
      5785955137.26,
      5403450595.57,
      10908748759.12,
      3850672721.41,
      2232090360.47
    ]
  ],
  "SH601059": [
    [
      3803275799.41,
      3162361349.94,
      2222965979.52,
      1658818758.06,
      1762887403.74,
      2242660878.57,
      5234510738.09,
      3097204862.03,
      1661336185.25
    ],
    [
      1171719584.88,
      819688097.83,
      210067991.93,
      69957389.3,
      172176509.45,
      435328833.94,
      2082044520.29,
      913783708.6,
      324659377.97
    ]
  ],
  "SH601108": [
    [
      6407610366.67,
      6528040616.43,
      4952243604.81,
      3167998370.32,
      4016866764.74,
      4255580080.75,
      10241340331.37,
      4502280609.9,
      2259136500
    ],
    [
      2566175327.88,
      2291596618.3,
      1873062523.33,
      818836066.51,
      1503931618.18,
      1785885436.51,
      3075405936.63,
      855682830.24,
      326433600
    ]
  ],
  "SH601136": [
    [
      2113493479.32,
      1657983958.5,
      1339618763.5,
      815247500,
      930567402.63,
      1102020020.79,
      1633423521.59,
      779189943.03,
      436445716.61
    ],
    [
      858599660.48,
      610616529.86,
      433970302.57,
      174816400,
      315419298.15,
      422830229.13,
      716586155.66,
      273283091.03,
      145426328.76
    ]
  ],
  "SH601162": [
    [
      4405719313.76,
      4359629544.39,
      3846100730.48,
      3277404101.33,
      2986161700.23,
      3097919718.74,
      3213163664.24,
      1112169600.14,
      668629269.05
    ],
    [
      586354789.34,
      454871365.71,
      307767555.05,
      302851495.02,
      410130726.93,
      671567746.98,
      937586413.65,
      207746164.65,
      100802284.59
    ]
  ],
  "SH601198": [
    [
      5375748343.46,
      5687210822.32,
      4474704697.42,
      3314496768.38,
      3633172002.15,
      3573200156.02,
      5363008065.25,
      2597774148.38,
      2033866487.14
    ],
    [
      1652243606.93,
      1539672462.5,
      1220698859.37,
      1008047034.4,
      1309249598.89,
      1352929314.59,
      2044690319.02,
      1040597699.34,
      668493992.39
    ]
  ],
  "SH601236": [
    [
      6733758206.26,
      5585163238.85,
      2065728507.8,
      1201433406.34,
      1114215786.02,
      975655348.13,
      1974885800,
      1214603799.66,
      764936044.28
    ],
    [
      1576229463.11,
      1413122029.42,
      837541304.24,
      386464525.52,
      363082587.7,
      332827972,
      1042533800,
      475496800.72,
      218206973.48
    ]
  ],
  "SH601375": [
    [
      4420848497.96,
      3103301696.87,
      2372526991.25,
      1649661561.68,
      2147620089.37,
      2008852561.18,
      4004355251.9,
      1808216779.12,
      1165234691.42
    ],
    [
      513210337.25,
      104302038.78,
      58222745.44,
      65787558.62,
      441982592.67,
      718646243.11,
      1405500406.97,
      562290151.78,
      252934345.88
    ]
  ],
  "SH601377": [
    [
      18972168754.91,
      17579687208.8,
      14249535861.49,
      6499373437.14,
      8820388610.14,
      7588604128.9,
      11540612657.75,
      5609064896.32,
      3099526553.02
    ],
    [
      4743070343.36,
      4003314315.75,
      1762537169.01,
      135348071.2,
      2284896126.79,
      2046321431.54,
      4167150649.35,
      1781589789.14,
      669769790.41
    ]
  ],
  "SH601456": [
    [
      2966631400.54,
      1876340313.32,
      1619382372.77,
      989719000,
      1262535000,
      1836463830.87,
      3079072000,
      1668332000,
      1000977188.45
    ],
    [
      888639753.44,
      587871418.22,
      521344151.14,
      50588000,
      361492000,
      610067590.12,
      1471438000,
      714955000,
      269761799.58
    ]
  ],
  "SH601555": [
    [
      9245491796.09,
      7356492441.1,
      5130373462.68,
      4161925425.29,
      4144240488.37,
      4645225993.82,
      6830161925.32,
      3240982527.87,
      1609668051.56
    ],
    [
      2391778941.16,
      1707245952.72,
      1037174921.82,
      358411175.29,
      788122751.35,
      1498288506.38,
      2708494901.88,
      1115452050.88,
      392166585.94
    ]
  ],
  "SH601688": [
    [
      37905443652.44,
      31444546120.28,
      24863012026.33,
      16108262271.57,
      21108534070.71,
      16925935043.92,
      26261939871.49,
      12062303844.09,
      7182298873.45
    ],
    [
      13346106674.68,
      10822496891,
      9001644018.52,
      5032737702.7,
      9276520447.68,
      6270611459.43,
      10696870875.92,
      4486276132.08,
      2219735131.23
    ]
  ],
  "SH601696": [
    [
      3333518749.21,
      3244172276.95,
      2907667567.52,
      2755098098.64,
      3067525846.44,
      2830493647.57,
      4947783600,
      2578182507.77,
      1290676825.47
    ],
    [
      961625314.57,
      883226868.37,
      798252971.86,
      704986351.02,
      1067129839.52,
      1065698139.13,
      2076890000,
      971638637.24,
      317617721.19
    ]
  ],
  "SH601788": [
    [
      16706575061.43,
      15866343425.84,
      10057362378.64,
      7712277101.82,
      9838147762.07,
      9164639102.5,
      16571087246.74,
      6601422929.86,
      4019623600.22
    ],
    [
      3484331817.14,
      2334078122.69,
      567944886.3,
      103322859.82,
      3016470221.54,
      3013019180.75,
      7646516077.13,
      2068307502.08,
      205836529.58
    ]
  ],
  "SH601878": [
    [
      16418113012.51,
      10636513832.41,
      5659478638.09,
      3694801371.08,
      4610873972.96,
      4594902987.59,
      6188903157.42,
      3226844444.08,
      1914709864.7
    ],
    [
      2195682763.42,
      1627166025.65,
      967557059.43,
      736957357.88,
      1063507778.68,
      1240892309.04,
      1834457999.29,
      750242395.43,
      403230607.26
    ]
  ],
  "SH601901": [
    [
      8621202071.85,
      7541809241.46,
      6594941981.46,
      5722593356.59,
      5961533467.39,
      7759738629.42,
      10914989706.62,
      4899699230.06,
      3453058407.18
    ],
    [
      1822282069.48,
      1096492270.9,
      1007595631.59,
      661365890.51,
      1452957913.42,
      2569336882.57,
      4064211991.64,
      1796097769.62,
      1112201945.05
    ]
  ],
  "SH601990": [
    [
      2741633842.89,
      2365296802.01,
      2201777265.63,
      1233927907.56,
      1388473496.81,
      1499611313.01,
      3000069643.36,
      1421284600,
      1014937100
    ],
    [
      977274472.85,
      809594147.08,
      709811700.41,
      231780216.69,
      410602756.36,
      493557293.51,
      1413026763.57,
      554444200,
      270930200
    ]
  ],
  "SZ000562": [
    [
      4118510581.83,
      3295868934.67,
      2353703631.17,
      3304715081.65,
      2919903998.54,
      1598468309.64,
      4435140101.43,
      743496322.22,
      -16990504.61
    ],
    [
      1227292426.2,
      867680007.09,
      645591117.7,
      1306379570.94,
      1151650925.85,
      541647861.52,
      2038300442.53,
      319354764.8,
      8222470.93
    ]
  ],
  "SZ000686": [
    [
      7477801881.89,
      6609613343.83,
      7968795586.85,
      6780105834.67,
      4934452308.92,
      4481994658.63,
      6745760224.97,
      3090984262.41,
      1767040160.7
    ],
    [
      1623994253.62,
      1333325683.24,
      1007080243.05,
      301352976.41,
      666946558.98,
      1314941187.9,
      2630058890.07,
      1060025355.59,
      480057377.95
    ]
  ],
  "SZ000728": [
    [
      6109751584.75,
      4528625617.88,
      3198808368.09,
      2537907348.38,
      3510702162.26,
      3375696421.01,
      5773382071.47,
      3486036145.6,
      1986134237.63
    ],
    [
      1909272808.14,
      1370096738.86,
      914361564.54,
      670370829.86,
      1203746140.88,
      1405404397.83,
      2784229089.24,
      1371744662.42,
      665338486.33
    ]
  ],
  "SZ000750": [
    [
      5170261555.13,
      4482015217.4,
      3560208077.82,
      2122602077.8,
      2658882600.15,
      3837926394.16,
      4959157199.17,
      2544981928.34,
      1818760812.32
    ],
    [
      764619396.32,
      725376273.77,
      487716781.47,
      73142828.57,
      375760243.11,
      1015511746.44,
      1792923492.86,
      690035776.56,
      308745854.57
    ]
  ],
  "SZ000776": [
    [
      34249988400.75,
      29153488259.04,
      22809882495.06,
      15270373023.59,
      21639300625.74,
      20714347818.02,
      33446639919.41,
      13394972903.67,
      8207540703.98
    ],
    [
      10854115527.4,
      10038134647.91,
      7538921643.02,
      4300126341.29,
      8595399060.76,
      8030106628.93,
      13201014064.72,
      5022567778.39,
      2812501034.32
    ]
  ],
  "SZ000783": [
    [
      8623165139.08,
      7784121537.42,
      7032892044.09,
      4369208710.77,
      5664107738.63,
      5857472375.4,
      8499643780.49,
      4548208653.84,
      3047682604.6
    ],
    [
      2409539473.91,
      2085377418.25,
      1665799971.58,
      257201958.69,
      1545112374.32,
      2206576040.14,
      3493365230.21,
      1705439086.94,
      1006554243.06
    ]
  ],
  "SZ002500": [
    [
      3993936447,
      3341972041,
      5102180737,
      6851136626,
      4392996390,
      2345649721,
      3838500324,
      1959188535,
      1321203859
    ],
    [
      803609850,
      750927346,
      510183708,
      221763054,
      408901264,
      467685616,
      1438829425,
      586294710,
      261755432
    ]
  ],
  "SZ002673": [
    [
      6751022663.82,
      5184163900.03,
      3680544587.4,
      2237341729.03,
      3169944961.76,
      3406329331.96,
      5640878792.18,
      1938470480.53,
      1132328589.81
    ],
    [
      1409991295.62,
      1117003407.01,
      610163902.78,
      200433916.35,
      752270907.74,
      1124621115.06,
      1972662987.16,
      663854622.42,
      275147001.3
    ]
  ],
  "SZ002736": [
    [
      23818037003.89,
      18784071244.98,
      14092914615.73,
      10030931922.89,
      11923610192.94,
      12746787440.92,
      29139131599.01,
      11792322619.69,
      6771922266.26
    ],
    [
      10114758795.89,
      6615739471.11,
      4910187206.37,
      3423396646.18,
      4574777573.93,
      4556152321.66,
      13949033996.79,
      4927564849.42,
      2101743057.35
    ]
  ],
  "SZ002926": [
    [
      5121995492.55,
      4682755761.6,
      3937424572.74,
      2545233363.8,
      2671626421.94,
      2710412262.05,
      6010918733.46,
      3168013932.48,
      1966121259.41
    ],
    [
      1632123985.51,
      1900327802.56,
      1431530824.81,
      845132348.07,
      1019124805.62,
      1666499975.29,
      2681090347,
      691276329.52,
      654193170.15
    ]
  ],
  "SZ002939": [
    [
      7756796088.56,
      6868697463.16,
      3899142493.53,
      2753299922.53,
      2957833928.02,
      3483558655.04,
      5012184673.07,
      2470089178.92,
      1550385558.88
    ],
    [
      1765610928.44,
      1501641468.72,
      992167143.29,
      585699848.79,
      889834897.37,
      973292578.86,
      1828276010.88,
      720553874.51,
      390940683.1
    ]
  ],
  "SZ002945": [
    [
      1395355967.1,
      1489800611.89,
      1010603099.5,
      1000843794.61,
      1067185983.74,
      1318353295.03,
      1668857767.74,
      706314130.44,
      643707107.24
    ],
    [
      483726211.7,
      812496331.45,
      441666561.99,
      344672483.7,
      463150384.86,
      589118277.95,
      815994245.57,
      188093452.91,
      77059907.92
    ]
  ]
}

《生物大数据》林魁

2023-02-24T00:03:33.000Z

组学数据的一些基本概念
参考基因组数据的模型与基本运算
转录组数据的基本模型与分析
新进展
1. 组学数据整合的基本框架与分析
2. 群体泛基因组的基本数据结构与分析

《数据可视化》尹乾

2023-02-23T05:31:32.000Z

Laidlaw, D. Scientific visualization course

https://cs.brown.edu/courses/cs237/2014/

第1章数据可视化概述

什么是数据

进行记录、可以鉴别、符号

可识别的、抽象的符号

数据经过加工后成为信息

数据是信息的表现形式和载体，信息是数据的内涵

数据可视化是数据中信息的可视化

科学可视化 / 信息可视化

信息可视化

时变数据
层次数据
网络结构数据
非结构化数据

Key Rotation

2023-02-13T16:37:57.000Z

General Concepts — ItsDangerous Documentation

似乎就是同时允许多个sk，始终用最新的sk签发，任何一个sk通过了都算通过

利用Python的动态性实现一个xml的编写器

2023-02-12T05:41:18.000Z

用with块控制xml的上下文
借鉴一些templite里的code生成器的实现
重载+=运算符表示添加内容
- with块内就是一个加号
- 其实+=就是没有end tag的意思，而with块会自动生成end tag
所有的+都是append或者说insert的意思
- 通过重载@运算符控制插入的位置

2023年2月12日晚，实现了雏形：

2023年2月13日实现了_，觉得可以将项目名命名为xmlodash哈哈哈哈

写这样的python代码

_ = Cursor()

with _ > "html":
    with _ > "head":
        _("title") + "标题"

    with _ > "body" as body:
        with _("img") as img:
            img["src"] = "图片地址"
            img["alt"] = "图片标题"

        with _("div"):
            for word in ["第一句", "第二句", "第三句"]:
                _("p") + word

    _("div")("div")("p")("ul")("li") + "还可以链式调用"

print(_)

生成这样的xml代码

<html>
 <head>
  <title>标题</title>
 </head>
 <body>
  <img src="图片地址" alt="图片标题" />
  <div>
   <p>第一句</p>
   <p>第二句</p>
   <p>第三句</p>
  </div>
  <div>
   <div>
    <p>
     <ul>
      <li>还可以链式调用</li>
     </ul>
    </p>
   </div>
  </div>
 </body>
</html>

源码见此

写一个批量下载课堂派PPT图片的脚本

2023-02-11T14:37:30.000Z

如题。

Svelte社区好玩的网站

2023-02-05T10:29:26.000Z

来自一个收集Svelte梗的网站

Free Svelte Accelerators

Svelte Society

谈谈数据驱动的UI框架

2023-02-04T01:59:17.000Z

import framework  # 前端框架
renderer = framework.compile(template)  # 模板，即UI的描述
UI = renderer.render(state)  # UI仅仅是数据的状态函数

抽象来看，这就是数据驱动的前端框架做的全部事情

内容、逻辑、样式

根据我自己的理论，一个文档可以分为三部分：

内容 —— 将数据按一定格式呈现。比如一个markdown文档。这决定了它基本上得是线性的结构
逻辑 —— 描述内容中元素间非线性的关系。比如预录制的ppt动作
样式 —— 内容呈现的外观等形式。比如markdown的主题

而一个应用程序，它与文档不同的地方就在于，它是动态的，尤其是内容是动态的。然而动态中依然有静态的成分，这就是格式。

内容 = 格式 + 数据

而格式与样式有一定联系，有时候也会写在一起。比如html中inline的style，本质上就是样式写在格式里

WEB做对了什么

传统的GUI程序一般只会用它本身的编程语言来写，比较像MVC架构：模型层执行后端逻辑，视图层就是前端的格式和样式，控制层负责相应前端的事件。它没有区分格式和样式，所以在创建GUI代码中经常见到（用Java语法高亮的伪代码）：

void greet(String name) {
    var vBox = new VBox(10, 20, 30, 40, Align.LEFT);
    this.root.appendChild(vBox);
    var label = new Label();
    label.setFontFamily("mono");
    label.setFontColor(Color.BLACK);
    label.setValue("Hello " + name + "!");
    vBox.appendChild(label);
}

可以认为，“加一段格式化后的文字”这一目标，是由数据生成内容；然而实现它的这些代码却要和样式混在一起，这没必要。而WEB就是提供了一种更理想的编程方式：

描述内容就用描述格式的语言，用代表数据的变量占位：

<>
  <div>
    Hello, {name}!
  </div>
</>

样式则用键值对表示，而且可以表达级联的属性（例子中未体现）：

div {
  font-family: monospace;
  color: black;
}

同样是9行，后者不比前者清晰明了多了吗

数据驱动

相比之下，MVVM让开发者不需要关注底层的前端事件，让框架自动实现数据与内容的同步

在现代的WEB系统中：

数据用键值对的方式表示，并用跨语言的编码方式传输（比如JSON，或者用可读性换效率的msgpack等）
格式用基于XML的HTML语言描述
样式用灵活的CSS描述，既可以内嵌于格式中也可以分离出来
逻辑用动态类型的脚本语言JavaScript实现

html是UI的一种抽象表达了。与写GUI相比起来，WEB项目其实把渲染过程中排版的细节从应用程序中剥离出去了，开发者从编写UI变成编写html，真正由html渲染出图形的工作由浏览器来完成

我前段时间还在想，为什么网页要是html而不是json，毕竟写前端时真的有很多功夫都花在由json转html上，也不见得html比json可读性高。后来发现，其实html或者说xml是一种更面向对象的语言。我觉得更准确的说法是“面向类”，因为json其实就是一种描述对象的编码语言，但是它没有保留“类”的信息，而xml就有。

然而渲染html还得用户自己来搞，这还是挺讨厌的。下面以我在一个不用任何前端框架写的百科网站 bnu120 为例，下面是其中动态加载数据渲染视差字云效果的代码（略加修改，代码有点久远，可能写的比较幼稚）：

const scene = document.getElementById("scene");
const depthScale = 100;

// 添加一个人物结点
function create_person_node(name) {
  let span = document.createElement("span");
  span.innerHTML = name;
  scene.appendChild(span);
  
  // 设置span元素随机深度，并将深度保存为元素的data-depth属性
  // Parallax插件会用这个属性制造视差效果
  let depth = Math.random();
  span.setAttribute("data-depth", (depth * depthScale).toString());
}

// 设置结点的位置并设置不透明度
function decorate_person_node(span) {
  let x = Math.random() - 0.5;
  let y = Math.random() - 0.5;
  span.style.left = `${x * window.innerWidth}pt`;
  span.style.top = `${y * window.innerHeight}pt`;
  // 设置元素的不透明度，形成先后出现的动画效果
  setTimeout(() => {
    span.style.setProperty("--opacity", Math.ceil(Math.random() * 100) + "%");
  }, (Math.random() ** 2) * 2000);
}

// 从api获取people列表
fetch("/api/people/list").then(response => response.json()).then(people => {
  people.forEach(create_person_node);
  new Parallax(scene); // 初始化Parallax插件
  scene.childNodes.forEach(decorate_person_node);
});

这段代码实现了一种类似视差效果的动画，通过获取API中的people列表，将每个人的信息和url添加到scene中，并且设置每个span标签的data-depth属性，从而实现视差动画。然后在scene中添加随机偏移量，最后设置每个span标签的各种CSS属性，实现动画效果。

—— 一个类ChatGPT的AI生成的描述

可以看到，其实创建html标签的过程又回到前面Java的那个例子一样方式了

而用前端框架的模板语言要怎么实现这个呢

<script>
	import { onMount } from "svelte";
  
  $: nodes = []; // 一个响应式变量

  onMount(
    async () => {
      let width = window.innerWidth;
      let height = window.innerHeight;
      let rand = () => Math.random() - 0.5;

      let response = await fetch("/api/people/list");
      let people = await response.json();
      nodes = people.map((name) => (
        { name, x: rand() * width, y: rand() * width }
      ));
    }
  );
</script>

<div>
	{#each nodes as { name, x, y }}
		<span style:x style:y> {name} </span>
	{/each}
</div>

清晰明了。<script>里获得并格式化数据，在底下用模板语言表达格式。这才是数据驱动的开发。完全不用关注与dom交互的细节

总之，在应用程序的语境下，内容就是数据和格式，逻辑就是脚本

这三种不同的东西可以用三种不同的语言来写，但不一定要写在三个文件里

而最开头提到的“UI描述”就是一类语言，专为描述UI而设计（废话），在其中可以用三种（子）语言来写UI的这四个部分

UI描述的方式

回到最开头的

renderer = framework.compile(template)

这里的template一般是html的扩展，例如上一个例子那样。它相当于把

描述UI有两种主流的语言大类：

在内容中插入脚本 —— template
在脚本中插入内容 —— jsx

虽然现在两边都很火，老牌有React属于第1类，有Vue属于第2类，新秀有Svelte属于第1类，有Solid属于第2类

在内容为重的应用中，一定是第1种更方便；而在逻辑为重的应用中可能第2种会略方便些（个人认为这种使用场景应该比较少）

不同框架实现上也有优劣。我们看起来只是在声明变量，实际上框架在帮我们修改DOM。修改的粒度越小运行时开销就越少。细化修改粒度有两种方向，可以在编译时找出会变化的量，运行时不再判断其它量是否更新；也可以在运行时将前后渲染的UI描述作diff。前者的唯一坏处就是会损失一些动态语言的灵活性，后者会带来diff的运行时开销，各有取舍（也可以兼而有之）

受启发于：《浅谈前端框架原理》 🔗腾讯云开发者社区 🔗微信公众号

看了几篇讲 Tailwind CSS 的文章

2023-02-03T00:01:07.000Z

《 Tailwind CSS 浅析》

如果要新增一个类似的元素，是先把它抽象成组件类，还是复制一份？我想很可能是复制一份，因为除了页面最初的设计者，维护者很难全面掌握整个项目有多少样式是可重用的。

所以我认为适合 Tailwind CSS 的场景是一次性的设计，例如首页、活动页。

我觉得这个说的很准确

《 Tailwind CSS，从入坑到退坑》

讲的都是只使用Tailwind会带来的麻烦（个人目前认为基本上可以通过结合部分手写的css以及@apply解决）

提到了一个点，说原子化css避免了给**.classes**命名的麻烦

有一点我觉得概括的挺好，例子很典型：

重复设计

虽然在初次编写的时候使用预置的 token 很方便，但是第二次就麻烦了。上次用的颜色是什么，边距是什么？我需要反复打开一切写过的组件确认，避免产生样式的不一致。

作者还说：

最好的代码不是为编写优化，而是为阅读优化的。

https://adamwathan.me/css-utility-classes-and-separation-of-concerns/

说起来，如果叫我来给我自己的 GUI 框架设计一种 style sheet 语言，我觉得 css 中的一些符号需要改进

.classes 变成 #tags
#id 变成 @id
.props 检查属性值

将来有空研究研究 AST

跨域fetch带上cookies

2023-02-02T13:05:46.000Z

参见发送带凭据的请求

只有

fetch(url, { credentials: "include" })

时才会在跨域请求中发送cookies（默认是same-site）

然而：

当请求使用credentials: 'include'时，响应的Access-Control-Allow-Origin不能使用通配符"*"。在这种情况下，Access-Control-Allow-Origin必须是当前请求的源

所以有了这个PR

但是还需要

SameSite=None需要Secure

  @router.post("/login", responses={404: {}}, response_model=str)
  async def login(data: LoginInput):
      if token := await get_token(data):
          response = PlainTextResponse(token, background=BackgroundTask(
              lambda: UserItem.filter(id=parse_token(token).id).update(last_login_at=timestamp())
          ))
-         response.set_cookie("token", token)
+         response.set_cookie("token", token, secure=True, samesite="none")
      else:
          response = Response(status_code=404)
      return response

最后因为这样的实现太丑陋了还是，还是放弃了这个做法。

给缺少元数据的图片添加EXIF信息

2023-02-02T05:42:28.000Z

找遍了pillow文档也只找到了Image.getexif()可以得到EXIF信息，没找到写入EXIF信息的方法

我记得以前也找过imageio，也没有😞

今天发现 Piexif 的写EXIF的功能很方便：除了常规的load和dump，还提供了一个

<font style="color:rgb(36, 41, 47);">transplant(filename, filename)</font>：Transplant exif from JPEG to JPEG.

我觉得这个功能非常有用：尤其当将jpg用guetzli优化后就会丢失EXIF信息，这样一覆写非常方便，甚至不用自己封装了

比如我用的 YOGA Image Optimizer 优化图片，会在源文件夹下创建一个optimized文件夹，我要遍历optimized文件夹下所有文件，在母文件夹中取EXIF覆写过来：

from pathlib import Path
from piexif import transplant

for i in Path("./optimized/").glob("*.jpg"):
    transplant(i.name, str(i))

2023年2月2日小记

2023-02-02T01:10:47.000Z

今天被双拼输入法种草了。决心将来要学一下这种效率工具

多来点鸟图

Lit

2022-12-29T18:53:04.000Z

Web Component 是未来

Lit 利用 Web Component 我觉得最大的两点好处是

方便传播。方便别人将我的组件插入到他们自己的页面上。其他解决方案只能是iframe了吧
小。代码轻
shadow-dom 反爬（？）

scroll-snap

2023-01-29T08:37:51.000Z

Basic concepts of CSS Scroll Snap

1月27日例会议程

2023-01-26T19:53:33.000Z

Deadline	2月1日中午12:00
张逸飞、吴玮婧	整理一个列表，包含需要整合进我们平台的功能（如T检验），除此之外的功能都导出到SPSS实现
张逸飞、吴玮婧	找一下组间设计类似这样的，问卷逻辑比较复杂的例子
刘明君	营销策略部分加上对优惠方式的具体描述
刘明君、庄毅辉	功能那里提一下“添加到日历”功能
刘明君	盈利部分介绍一下竞赛举办方作为金主爸爸投放广告，替代原有的竞赛资讯功能
申琪	线上访谈的部分，提一下语音转文字、自动生成访谈记录的功能
申琪	扩展问卷优化的概念为项目优化
庄毅辉	在量表优化部分，提到量表的信息和许可来源等
庄毅辉	重述技术与研发部分（长期）

议程

介绍
- 已经参加的项目，已经做出的产品
- 畅所欲言，不受专业限制
- 明确：不是全部features都会在答辩前实现，所以要分两类
- 介绍本议程
大家解释建议并取舍
features按预期完成时间分两类
分配任务与ddl

结果

专业量表认证（自荐、找人要）、可附带部分实验结果（预实验数据）
勾选的话，自动插入测谎题（需要测谎题题库）
实现飞书的会议记录功能（线上访谈用）
实现常用功能，小众功能导出SPSS
志愿时间段
“添加到日历”
竞赛快讯（可能放在广告里面，营销那里提）
项目咨询/项目优化
组间设计

任务

Deadline: 2月1日

量表信息来源
营销策略需要加上对优惠具体方案的描述
线上访谈的部分提到语音转文字等自动化记录功能
实现一定的检验功能，并允许导出到SPSS
添加到日历提一下
盈利的部分介绍一下竞赛举办方金主投放广告
把问卷优化都改成项目优化
找一下类似组间设计这样的情况的资料

分工

张逸飞、吴玮婧

4的整合的检测给一个列表
8找一点资料（不着急后面做也行）

刘明君

2和5和6

申琪

3和7

庄毅辉

JavaScript HTTP cient

2023-01-23T15:17:35.000Z

fetch具有一定局限性

无法获得上传进度
cookies默认不传
params设置不太方便

Learning YOLOv8

2023-01-22T00:57:31.000Z

YOLOv8是发布YOLOv5的组织发布的

https://github.com/ultralytics/yolov5

https://docs.ultralytics.com/

安装

pip install ultralytics

使用预训练的模型（会自动下载）

预训练模型分为10档

from ultralytics import YOLO

model = YOLO("yolov8n.pt")

预测

inputs = [img, img] # list of np arrays
results = model(inputs) # List of Results objects
for result in results:
    boxes = result.boxes # Boxes object for bbox outputs
    masks = result.masks # Masks object for segmenation masks outputs
    probs = result.probs # Class probabilities for classification outputs
    ...

中文readme：https://github.com/ultralytics/yolov5/blob/master/README.zh-CN.md

组织首页：https://ultralytics.com/

博客的深色模式

2023-01-08T08:18:55.000Z

Implemented
- 深色模式开关
Working
- 深色模式样式
To-do
- 配置缓存
- 自动深浅色模式

到底是用透明度还是直接用颜色-数字这样的类呢

现在发现的，最重要的，就是阴影应该使用前一种方法

但如果只有阴影使用，会不会造成不太一致呢

回家啦🌞

2023-01-21T00:58:15.000Z

🌞被鸟叫声吵醒的第一天

Re:bingo

2022-12-27T13:18:25.000Z

重启Bingo项目，技术路线

前端分别做网页版和小程序（毕竟一个针对电脑用户一个针对移动用户）

后端这次试试以asyncpg为引擎的GINO作为ORM，提供GraphQL的查询接口，准备用Strawberry

还可以试着做一个原生APP，借助 Svelte Native

Gino还不成熟，改用tortoise ORM了

我发现，用上GraphQL的话，后端其实就是在做一个从SQL到GraphQL的转换器（？）

企业稳工

2023-01-12T07:01:20.000Z

2023年1月10日

格兰仕：返乡潮下招工热：格兰仕将启动全国技工大招聘，首批计划5300人

春节后，格兰仕将全面启动2023年大招聘工作，面向社会推出数十种技工岗位，首批计划招收5300人。

2023年1月2日

海信家电：员工持股计划

对于海信家电而言，股权激励能够使员工以股东的身份参与企业决策、分享利润、承担风险，从而勤勉尽责地为公司的长期发展服务，最大限度地调动员工积极性。就目前来看，此次股权激励计划和员工持股计划覆盖范围较广，进一步完善了公司整体激励机制，亦体现了公司对于未来经营的良好预期。

2022年12月29日

瀚蓝环境：年内生活垃圾焚烧发电项目产能利用率维持在较高水平

瀚蓝环境12月29日在投资者互动平台表示，公司目前生产经营活动正有序开展，年内生活垃圾焚烧发电项目产能利用率维持在较高水平。公司采取多项措施关心和保障员工的健康，同时也感谢全体员工的努力和付出，使公司各项生产经营管理保持有序推进。期待随着国家相关防控政策的逐步优化，社会各界生产生活回归正常水平。

2022年9月5日

小熊电器：推出了新一期的股权激励方案，激励对象38人，激励对象包括公司董事、高级管理人员及核心骨干员工

公司于近期推出了新一期的股权激励方案，本次激励计划拟向激励对象授予权益总数为109.25万份，约占本激励计划草案公告时公司股本总额15,600万股的0.70%。本激励计划首次授予的激励对象总人数为38人，激励对象包括公司董事、高级管理人员及核心骨干员工。

2022年7月5日

美的、格力：美的裁员高达30%，格力承诺绝不裁员，两年员工却减少近七千

继互联网“裁员潮”爆发，制造业“裁员”也成讨论焦点。连美的都没能摆脱裁员风波，裁员比例高达30%。

2022年5月24日

东鹏：东鹏控股向239名激励对象授予3.15亿元股票期权

5月16日，东鹏控股发布公告，公司《2022年股票期权激励计划(草案)》设定的激励对象获授股票期权的条件已经成就，同意以2022年5月13日为首次授予股票期权的授予日，向符合授予条件的239名激励对象授予3465万份股票期权。首次行权价格为9.09元/股。

2022年3月26日

简一：发布职工生育三孩奖励方案：生育三孩奖励5万1

3月26日，广东简一（集团）陶瓷有限公司发布职工生育三孩奖励方案称为积极响应国家三孩政策，鼓励员工生育，提高员工福利待遇，决定对响应国家号召，生育三孩的职工，给予人民币伍万壹仟元的奖励。奖励对象为2022年1月1日起生三孩的职工家庭。

据《佛山日报》报道，简一集团三孩奖励的发放方式为首次奖励15000元，剩余36000元分两年按月发放，每月标准为1500元，合计51000元，奖励金额于职工月度工资中体现。

2022年2月24日

格兰仕：家电行业却开始涨工资了

像美的、格力、格兰仕等一些大型家电企业招聘一线技术工人最高给出了8500元的月薪。而且多数家电企业表示，今年的招工形势要比去年好。

功能决定语言例子

2023-01-15T07:04:54.000Z

GraphQL与SQL
i++
html-based与jsx

稳工促产政策&举措

2023-01-11T04:43:57.000Z

政策

主题	稳工促产的政策
时间	近期，尤其近1-2月内
地点	佛山以及广东其他地市

佛山

2022/12/17 佛山：推动高质量发展行稳致远 - 央广网

12月16日，中共佛山市委十三届五次全会召开，市委书记郑轲提出市委要以高质量发展为牵引，肩负起新时代新征程的历史使命，推动高质量发展行稳致远，抓好改革开放、抢抓制造业当家、建设城乡区域协调发展、半城山水满城绿、擦亮文化大市等方面工作，努力迈向现代化佛山。

2022/11/02 越评｜工业稳中有进，佛山做对了什么？ - 南方PLUS

总结：近日，佛山公布前三季度经济数据，规上工业增加值增长4.0%，佛山市政府提出“四大决心”推动“四大改变”，依据“问题导向”引进国资国企、建设园区平台、谋划招商格局、推进数字化转型，以上市推动民企发展，积极改革，佛山经济高质量发展取得了阶段性进展，将会朝着更好的方向发展。

2022/08/31 「稳经济新起航」佛山：打造一流营商环境，促进经济平稳增长 - 羊城晚报

从今年1-7月的佛山经济发展情况来看，佛山的产业韧性得到了显著提升，传统产业和高技术制造业均实现了较高增长，非夕机器人全球生产总部项目投资超百亿元。此外，佛山市政府不断打造一流营商环境，并推出多种政策措施，稳住经济大盘、保持经济在合理区间运行，为实现经济动能转换提供助力，对引导企业发展具有重要意义。

2022/07/07 多措并举！佛山市行业协会商会以实际行动稳经济、促发展 - 你好佛山

佛山市行业协会商会坚决扛起“为稳住市场主体、稳住经济大盘作贡献”的政治担当，通过组织政策宣讲、推动行业消费等方式，及时将国家和佛山市一系列稳经济利好政策信息传达到广大会员企业，帮助本行业本领域市场主体第一时间学习好理解好掌握好政策要义和精神内涵，统一行业思想，提振发展信心，以实际行动助力稳住经济大盘。

落实落细政策服务
推动行业市场复苏
全力稳企助企惠企
切实落实规范涉企收费政策
引导企业转型升级创新发展

2022/07/06 【行业资讯】6月：佛山发布促进经济平稳增长73条举措，助力稳住经济大盘；佛山发布房地产调控政策通知 - 佛山市房协

近期广州南海区开始建设佛中人才创新灯塔产业园，总投资约80亿元，桂城建设中央活力区，拟投入超20亿元提升公共配套环境，大专学历可以落户花都、从化及增城区。房地产数据方面，70大中城市商品住宅销售价格环比总体延续下降趋势，而广东完成房地产开发投资0.60万亿元，同比下降3.2%，佛山房地产开发企业完成投资839.42亿元，同比增长2.9%。金融信息方面，央行要统筹抓好稳就业和稳物价，6月LPR维持不变，5月人民币贷款同比多增3920亿元，5月末广义货币（M2）同比增长9.7%。

2022/06/25 南方电网广东佛山供电局全力落实促经济稳增长政策 - 羊城晚报

近日，佛山市出台促进经济平稳增长若干政策措施，对加强电力保障供应等提出新要求。南方电网广东佛山供电局积极行动，持续优化用电营商环境，为促经济稳增长贡献供电力量

全力保障电力可靠供应
用心缓解企业资金压力

2022/06/24 力促稳经济73条落地见效佛山要超常规发力｜观点佛山 - 佛山电视台

佛山市工信局积极响应“稳增长73条”政策，通过加强对外协调，为企业发放运输车辆通行证，24小时内出证，等政策举措，帮助企业解决复工复产、物资运输、社保减负、稳岗拓岗、补贴扶持问题，从而推动经济稳增长，促进高校毕业生的高质量就业，促进服务业纾困，保持经济稳定持续发展，改善民生。总之，佛山市政府坚持稳中求进，积极推动本地经济发展，探索出一套有效的经济复苏方案，达到疫情防控、经济稳定和发展安全的要求。

2022/06/15 佛山“稳增长73条”解读：以超常规力度稳住经济大盘 - 佛山科技

为了解决佛山外贸进出口结构不均衡带来的制约，佛山市拟采取精准发力，加大进口工作力度的措施，实现从贸易大市向贸易强市的转变。具体措施包括推动实力强、规模大的国有企业与民营企业合作；加大金融服务信贷供给，增加专项资金的引导拉动力度；扩大港口货物"船边直提"应用；力度加码、操作细化、服务优化，提供贴息支持，降低企业融资成本等。

2022/06/14 佛山市市场监督管理局关于印发促经济稳增长十二项措施的通知 - 潇湘晨报

为深入贯彻落实全国稳住经济大盘电视电话会议精神，着力保市场主体以保就业保民生，根据市委市政府有关部署要求，结合市场监管职能，市局制定了落实稳经济大盘四方面十二项措施：

推动市场准入更加便利，以创业带动就业
- 推进商事登记“1时代”改革
- 实施24小时商事登记智能审批
- 大力扶持个体工商户转型升级
- 深化“人工智能+双随机”智慧监管
优化升级惠企服务，“品质革命”助推企业发展
- 推动企业质量升级
- 加强先进标准引领
- 加强知识产权保护运用
聚焦重点领域执法，着力维护良好市场秩序
- 规范市场交易秩序
- 全力促进保供稳价
守好民生保障底线，做好统筹发展和安全相关工作
- 全面坚守防控防线
- 实施食品安全放心工程
- 继续强化安全监管措施

2022/06/06 佛山出台9大方面73条实招促进经济平稳增长 - 佛山市发展和改革局

佛山市正式发布《佛山市促进经济平稳增长若干政策措施》，以及“佛山益晒你”企业综合服务平台等政策措施，具体涵盖提升财税政策效能、加大金融对实体经济支持力度、扩大有效投资、促进消费持续恢复、保障粮食能源安全、保障产业链供应链稳定、稳住外贸外资、保障就业等，旨在稳住经济大盘，促进制造业发展。

2022/06/04 佛山市人民政府关于印发佛山市促进经济平稳增长若干政策措施的通知 - 广东省人民政府

佛山市促进经济平稳增长若干政策措施

提升财税政策效能
加大金融对实体经济支持力度
全力以赴扩大有效投资
大力促进消费持续恢复
保障粮食能源安全
保障产业链供应链稳定
着力稳住外贸外资
千方百计稳岗拓岗保就业
兜住兜牢民生底线

东莞

2023/01/06 东莞投入2.4亿稳工促生产，涉及就业补助、金融、消费 - 南方都市报

《关于支持企业春节前后稳工促生产的若干措施》政策包含8条干货，重点是补贴发券强生产生活服务，预计投入约2.4亿元。政策自发布之日起施行，至202年2月20日，部分政策措施延长至2023年年底或第一季度。

支持企业拓市场抢订单：举办线上展会使用费用补贴一半
支持企业降低生产成本：电费奖补最高60万，就业补助每人1000元
加强企业稳岗服务：企业包车接员工补贴50%费用
强化项目建设保障：解决施工困难，扎实推进资金支付
开展“乐购东莞”新春促消费活动：发消费券，还给快递外卖小哥发补贴
开展企业新春慰问服务活动：送医上门，送药进厂
加强留莞员工人文关怀：免费开放培训课程发放文体旅消费券
政务服务不打烊：多部门做好线上线下便民服务

2023/01/05 东莞部署春节前后工作，将出炉稳工促生产措施 - 南方都市报

东莞市政府召开常务会议，研究做好春节前后稳工促生产、综合行政执法职权下放、市人民医院发热门诊大楼项目建设等工作。会议原则同意相关措施，强调加大力度支持企业和保障企业正常生产，关心外来务工人员、困难群众及重点岗位工作人员，调整镇街综合行政执法权下放，东莞市人民医院发热门诊大楼项目建设等，努力实现一季度“双统筹”工作良好开局。

2022/08/23 东莞出台20条举措推动企业拓市场、“抢”订单、促生产 - 羊城晚报

东莞市人民政府近日正式印发《东莞市推动企业拓市场、抢订单、促生产的行动方案》，推出20条举措，帮助企业抢占国际国内市场，提高核心竞争力和市场营销能力，改善政府服务水平，优化出入境管理机制，支持企业参加重点展会，以及抱团接单补贴等。通过这些举措，稳定工业基本盘，促进全市外贸稳增提质。

广州

2023/01/02 广州：以营商环境之优促经济发展之稳 - 南方日报

截至目前，广州全市实有各类市场主体达313.48万户；2022年前三季度，广州新登记市场主体数量居全省第一，营商环境稳企暖企援企安企作用持续显现。

日前发布的《2022年广东省营商环境评价报告》显示，在对全省21个地级以上市开展的营商环境评价中，广州与深圳位列第一档。根据全国工商联发布的2022年万家民企评营商环境报告显示，广州市被评为最佳口碑城市第三名。

创新机制下，市场主体的多元化经营需求也能够得到满足。在黄埔区、广州开发区，针对食品、餐饮等行业企业申请新业态许可的政策空白问题，该区主动为企业“量身定制”许可规则，推出新型食品生产许可“一品一策”，为《食品生产许可分类目录》中食品明细未包含的新型食品“量身定制”审查方案，力保企业及时取得生产许可、抢占市场先机。

广州营商环境迭代升级，从未出现过“门难进、脸难看、事难办”的现象。产业集群效应，有利于降低生产和交易成本、形成规模效益，提高整体竞争力。

2022/12/08 打好“组合拳” ，聚力稳生产！广州从化区稳步有序推动企业复工复产 - 羊城晚报

广州市在优化完善疫情防控措施后，企业陆续组织员工返岗，明珠工业园企业已全部复工复产，产能逐步恢复正常。为了保证正常生产，明珠工业园实施临时管控措施，管委会为企业发放物资保供车辆通行证，为企业进出货提供便利。企业把5%的收益用于生产研发，不断加大研发投入，探索走出一条新的破局之路，迎合市场消费需求，为市场提供优质的产品。

2022/12/07 广东广州：稳岗就业保障有力 - 光明日报

今年以来，广州市面临着严峻、复杂的疫情形势，但就业形势总体稳定，广州市坚持就业优先战略，实施稳经济一揽子政策，不断发力就业、社会保障政策，通过多种渠道、精准帮扶措施，为群众保障就业稳定，维护市场运行稳定。

2022/11/30 广州：全力以赴稳住经济发展大盘稳住广大中小企业发展基本面 - 光明网

为了统筹好工业企业疫情防控与工业经济发展，广州市工业和信息化局提出一系列方案，包括指导工业企业抓好疫情防控，强化全市防疫物资生产企业的生产摸排，保障工业企业供应链稳定畅通以及扎实开展暖企服务，等等，帮助企业解决防疫物资短缺、员工返岗、原材料供应受阻等问题，希望企业坚定在穗发展信心，加快发展，为广州经济社会高质量发展做出更大贡献。

深圳

2022/12/09 深圳密集推出“稳增长促消费”政策措施 - 粤港澳大湾区门户网

今年以来，深圳出台实施助企纾困、工业增速提质、联动生产端促消费、培育壮大市场主体、推动经济稳定增长等5个“30条”政策，目前为止已为企业减负超1500亿元、惠及市场主体超过750万家次。

全方位为中小微企业减负纾困

纾、降、补、保、促、帮。

在“纾”方面，深圳实施“首贷户”贷款贴息，推动小微企业首贷户数量和贷款金额大幅增加，引导中小微基金加大对中小微企业支持力度，加大中小微企业银行贷款风险补偿力度
“降”主要体现在持续实施降成本、降费率、失业保险稳岗返还政策。

此外，深圳还通过加快发放补助资金、加大出口信保统保支持、加强市场主体培育和持续优化企业服务等，多措并举帮助中小微企业排忧解难。为促进中小微企业高质量发展，深圳积极推进“小升规”，并加快实施优质中小企业梯度培育，同时积极开展创新型中小企业评价。

补贴“大礼包”催生市场新活力

目前，深圳各相关部门正在陆续推出一批政策，帮助中小微企业、个体工商户在优化疫情防控措施下尽快恢复生产经营。

刺激消费方面，将适时实施新能源汽车新购置补贴政策，支持金融机构加大汽车信贷投放，鼓励购置新能源汽车；同时，实施消费电子、家电家居等补贴促销活动，联动线上、线下商户
文化旅游方面，深圳也策划了一系列主题活动，如举办“深圳人游深圳”活动、联动重点购物中心开业举办主题购物活动、鼓励户外露营旅游休闲消费和繁荣夜间经济计划等，营造更加有“烟火气”的消费氛围

2022/12/07 深圳密集发布稳增长政策措施促进经济高质量发展 - 粤港澳大湾区门户网

12月5日，深圳市在疫情防控方面出台了一系列政策措施，其中包括：取消查验核酸检测阴性证明，实施分布式光伏项目推广应用、小额贷款保证保险项目补贴、软件和互联网企业稳增长奖励、政策性农业保费补贴等，以促进经济高质量发展。

2022/12/05 广东深圳市：多措并举稳经济促发展 - 光明网

多措并举稳经济促发展，深圳认真贯彻“疫情要防住、经济要稳住、发展要安全”要求，高效统筹疫情防控和经济社会发展，出台多政策纾困解难，支持发展实体经济，帮助企业融资发展，提供优质的生产空间，促进外贸进出口等，从而实现经济稳增长，促进高质量发展。

举措

主题	稳工促产的举措
时间	近期，尤其近1-2月内
地点	广东省

美的

2023/01/08 CES2023强势回归，美的海信TCL康佳美菱方太松下万和向前冲！

作为中国制造业的重要一份子，家电产业的数字化转型、智能制造可以说是产业转型的代言。工信部公示2022年度智能制造示范工厂揭榜单位和优秀场景名单。其中，海尔、美的、康佳、长虹等企业入榜2022年度智能制造示范工厂揭榜单位名单，海尔、美的、格力、海信等企业入选2022年度智能制造优秀场景名单。显然，家电企业正为这场产业的数字化转型提供样板。

2022/12/26 从自主创新到赋能产业升级美的工业技术“技术派”实力尽显

以“精益化、信息化、自动化”的智能制造为路径，在坚持精益化管理、智慧转型上的系统布局与投入，美的工业技术已经拥有完整的数字化智能化生产体系。2022年，美的工业技术投资1亿元用于电机产品公司在新工艺、高精度设备、机器人快速应用、机械检测、视觉检测以及噪音检测自动化等六大应用领域进行自动化导入。

伴随着精益制造体系的不断更迭与完善，美的工业技术的精益化人才规模也逐渐扩大。如通过部署人才育成工具，设计阶段性的技能提升和项目指标，为人才晋升铺设了完善的道路，精英化人才如高阶黑带人数、中阶的绿带人数迅速提升，人才厚实度也成为保障生产效率与产品品质，激发创新发展的“源动力”。

2022/11/23 项目部全员带被褥吃住在项目，这一住就超40天｜当事人说

面对本次突发疫情给项目带来的困境，一声令下，美的置业项目部全员带上被褥吃住在项目，这一住就超过了40天......为避免突发疫情造成劳动力流失，10月12日项目部全员熬战至深夜两点，积极协调项目周边各社区，积极动员各参建单位及各班组，确保300多名工人，点对点从小区进入项目进行封闭管理施工。

在各级政府的政策指导及集团、区域的积极协调下，美的翰悦府项目于11月10日终于克服重重困难，逐步恢复生产秩序。

美的置业积极响应并践行“保交付”承诺，提振市场信心，助力行业高质量发展。2022年1-10月，美的置业共实现23个城市公司，超5万套房子交付，客户满意度近9成，处于行业第一梯队。

格兰仕

2023/01/10 返乡潮下招工热：格兰仕将启动全国技工大招聘，首批计划5300人

春节要回的家是“家乡”，而春节后要返岗的企业则是他们的“第二个家”。

2022年12月，格兰仕率先在全国“逆向招工”，参与广东人社部门组织的招聘活动，奔赴广西贺州，在全国率先跨省对接用工，一方面解决旺盛的用工需求，另一方面为广大劳动者提供稳定的就业岗位。春节后，格兰仕将全面启动2023年大招聘工作，面向社会推出数十种技工岗位，首批计划招收5300人。

通过协同培养、名企跟岗、现代学徒制等人才培养项目，格兰仕展开多元化的校企合作，积极融入教学与管理工作，为学生实习就业提供最优资源保障，提升人才培养的实用性和时效性。

2022/02/10 增资扩产势头良好，格兰仕节后复工火力全开

2月7日（年初七）上午8时不到，格兰仕集团顺德总部鼓声阵阵、龙狮起舞，生产线又再恢复往日热火朝天的景象。

内销外贸订单充足节后大招聘进行时

在保持良好发展势头的同时，格兰仕也在积极增加就业岗位，为稳岗扩就业贡献力量。节前，格兰仕全面启动2022年新春招聘工作，面向社会推出数十种技工岗位。在格兰仕，入职的一线技工将在充分培训后上岗，并通过“全员技工化”战略的实施，接受来自格兰仕商学院的技工培训，朝着“普工-关键岗位-产业技工-工程师”的路径发展。

做好防疫工作积极复工复产

为保证员工的返岗率，格兰仕多措并举进行稳岗，包括：总装车间安装中央空调以提升工作环境、宿舍全面配套空调、进一步改善员工饭堂环境、颁发“以老带新”“新工帮扶”等措施及内部介绍奖励方案，不断提升员工的获得感和幸福感。

中国人民政治协商会议第十五届佛山市顺德区委员名单：港澳特邀

2023-01-09T22:27:26.000Z

香港特邀（18名）

人物	职称
吴子元	佛山市顺德区天富来国际工业城有限公司等公司高管
叶中平	香港恒业集团与广东宝丽雅实业发展有限公司董事长，为广东省云浮市政协常委、新兴政协常委和顺德政协委员
李志恒	香港顺德杏坛同乡会理事、香港中西区议员
吴笑丽	佛山市现代美容有限公司、佛山市顺德区柏善美容服务有限公司、佛山市现代美容有限公司容桂上城名邸分公司等公司法定代表人，佛山市现代美容有限公司等公司股东
何灿燊	长洲顺德同乡会理事长
伍智聪	顺德区政协香港委员、区侨青会会长，兴隆食品有限公司董事，粤港澳大湾区预制菜产业领军人物
杜半之	香港顺德人联会主席，顺德区内地港人联谊会主席杜半之，珠海拾比佰彩图板股份有限公司、佛山市顺德区汇文电器有限公司、佛山市顺德区桂容家电有限公司等公司高管
蔡永玑	区政协香港联委会委员，区政协常委，香港顺德联谊总会会董，香港顺龙仁泽基金会董事
伍尚修	永隆银行创办人伍氏家族第三代成员，崇杰地产发展董事
孙凌峰	广东恒基实业集团有限公司董事长兼总裁，顺德区政协委员，容桂青年商会会长，顺德区内地港人联谊会常务副主席
伍尚敦	现任香港永隆银行有限公司高级经理，方圓投資管理（香港）有限公司合伙人，香港伍氏家族第三代成员，永隆银行家族成员
陈立尧	顺德区政协委员、伊之密智能互联部总监，伊之密股份有限公司投资及新事业发展部负责人
梁振宇	区政协委员，广东宏昊投资集团有限公司常务副总经理
梁辉鸿	顺德区政协香港委员、香港顺德人联会副主席
吴翠霞	区政协委员，香港顺德人联会副主席兼秘书长，广东兴奇金属有限公司支部书记、董事会秘书兼人力资源总监
左汇雄	九龙城区议会议员、副主席
梁碧红	广东顺德贰发毛绒有限公司董事
叶承殷	顺德区政协委员，香港青年企业家，顺德区内地港人联谊会副主席兼青年部部长

澳门特邀（16名）

人物	职称
佘嘉浚	大自然家居副总裁兼地板集团总裁
黄昇雄	澳门顺德联谊总会常务副会长，广东省政协委员、澳门新华昌投资集团有限公司总裁、新濠国际发展有限公司首席顾问，澳门青年创业协会创会会长
叶子宇	顺德区政协委员、区政协澳门联委会代表，澳门顺联总会副会长，
欧国辉	澳门均安同乡会会长
孔庆标	澳门顺德北滘同乡会会长
何汉辉	容桂农贸市场协会会长，澳门委员
叶朝辉	顺德区政协澳门委员，宏基行集团有限公司董事，澳门青创协会会长，顺德区炜力贸易有限公司总经理
关月微	佛山市顺德安世房地产顾问有限公司法定代表人
罗应江	无
马建钊	澳门顺德工商业联合会理事长，顺德区政协委员，，澳门顺德乐从同乡会理事长
何健昌	澳门顺德工商业联合会监事长，澳门顺德大良同乡会理事长
廖权辉	澳门顺德勒流同乡会理事长
何小敏	澳门常委，政协委员，阳光村党委委员
冯家超	澳门立法会议员，现任澳门大学博彩研究所所长、澳门大学工商管理学院款客服务及博彩管理课程副教授
何伟业	广东省青联委员、何泉记有限公司创始人，机关党委青年委员、机关第一党支部书记
马婉珊	顺德区政协委员、澳门天利电业有限公司经理、澳门天建贸易有限公司经理

佛山市顺德区第十七届人民代表大会第二次会议主席团

2023-01-09T09:22:36.000Z

人物	职称
马强	中国农业银行顺德容桂支行党委书记、行长
王光	顺德区政府秘书长、区政府办公室主任
王毅成	广东顺之旅国际旅行社有限公司部门经理
王镜	佛山市顺德区大良街道工业互联网协会秘书长
区柱明	现任佛山市顺德区常委、副书记、区长
区淑莲	广东广意医疗养生科技有限公司、佛山市顺德区康意医院管理投资有限公司、佛山市顺德区容桂南区永雄机械制造厂等公司法定代表人，佛山市佛保押运服务有限公司、广州菁翠健企业管理有限责任公司、佛山市顺德区容桂南区永雄机械制造厂等公司股东，广东顺德新容奇医院有限公司、佛山市广意永雄机械有限公司、广东广意医疗养生科技有限公司等公司高管
车畅	无
邓桂霞	顺德区水业控股有限公司行政支持部部长、工会副主席
邓惠敏	佛山市禅雄运输有限公司等公司高管
甘志宇	市、区、镇人大代表，龙江镇党委书记
龙永业	无
龙仲英	现任佛山市顺德区均安镇党委书记
卢达潮	党委书记、居委会主任、政务工作站站长
叶励华	无
叶汶杰	广东用心网络科技有限公司、佛山市用心电器服务有限公司、广东顺德优店网络科技有限公司等公司法定代表人，佛山市顺德区启翰企业管理服务有限公司、佛山市必然商业管理有限公司、佛山市用心企业管理合伙企业(有限合伙)等公司股东，广东用心网络科技有限公司、佛山市用心电器服务有限公司、广东顺德优店网络科技有限公司等公司高管
叶善楷	现任佛山市顺德区伦教街道党工委书记
付君	无
白志远	周大福代表
白涛	佛山市委副书记，市政府市长、党组书记
毕海	季华实验室特聘研究员，季华恒烨(佛山)电子材料有限公司、苏州华莱德电子科技有限公司、大连米泽新材料有限公司等公司法定代表人，苏州华莱德电子科技有限公司、广州米泽新材料科技有限公司、大连米泽新材料有限公司等公司股东，季华恒烨(佛山)电子材料有限公司、苏州华莱德电子科技有限公司、广州米泽新材料科技有限公司等公司高管
乔羽	致公党广东省委会副主委、致公党佛山市委会主委，佛山市人大代表，佛山市人民政府副市长
伍秀仪	佛山市顺德区德邻社区服务中心有限公司等公司股东，广东联塑喜屋建材设备有限公司、佛山市领盛汇家居有限公司、佛山市洛林健康管理咨询服务有限公司等公司高管
刘光明	广东省市场监督管理局党组书记、局长
刘铭恩	现任顺德区第十七届人大常委会主任
刘智勇	现任广东省佛山市委常委、顺德区委书记
刘婷	无
阮裕强	广东旺海精品生物科技有限公司、江门市旺海饲料实业有限公司、广东旺海企业管理有限公司等公司法定代表人，北海市回头客食品有限公司、广东旺海企业管理有限公司、广东同琛商贸有限公司等公司股东，广东顺德农村商业银行股份有限公司、佛山市顺德区旺海饲料实业有限公司、广东旺海精品生物科技有限公司等公司高管
孙春刚	现任佛山市顺德区龙江镇委副书记、镇长
麦振兴	佛山市高足文化传播有限公司等公司法定代表人，佛山市中腾兴商务信息咨询有限公司、佛山市睿梭信息咨询有限公司、佛山市顺德区立骥汽车销售服务有限公司等公司股东，佛山市中腾兴商务信息咨询有限公司、佛山市顺德区立骥汽车销售服务有限公司、佛山市高足文化传播有限公司等公司高管
李叶敬	佛山市顺德区均安镇投资控股总公司、佛山市顺德区昌隆房产发展公司、佛山市顺德区均安建设开发公司等公司高管
李有强	佛山能宽企业管理合伙企业（有限合伙）等公司股东
李先祥	顺德职业技术学院党委书记
李华锋	佛山市熙雅电器有限公司、广东淼星节能设备有限公司、厦门正隆金贸易有限公司等公司法定代表人，佛山市熙雅电器有限公司、广东淼星节能设备有限公司、佛山市广鼎电器有限公司等公司股东，佛山市熙雅电器有限公司、佛山市广鼎电器有限公司、广东广图电器制造有限公司等公司高管
李兴华	佛山市巨兴元食品科技有限公司、广州市番禺区大石磊冉食品店、广州市番禺区大石华记餐饮店等公司法定代表人，佛山市巨兴元食品科技有限公司、广州市熊滋味餐饮管理有限公司等公司股东，佛山市巨兴元食品科技有限公司、广州市厨旺食品有限公司、广州市熊滋味餐饮管理有限公司等公司高管
李芳芳	佛山市萌团童装有限公司、佛山市典瀚童装有限公司、佛山市莱萌童装有限公司等公司法定代表人，佛山市萌团童装有限公司、佛山市典瀚童装有限公司、佛山市莱萌童装有限公司等公司股东，佛山市萌团童装有限公司、佛山市典瀚童装有限公司、佛山市莱萌童装有限公司等公司高管
李坚	省委党校研究生学历，中共党员，现任佛山市人大常委会副主任、党组成员
李尚春	驻大良街道大门社区第一书记
李忠慧	宜所(广东)智能科技有限公司等公司股东，宜所(广东)智能科技有限公司等公司高管
李艳婷	佛山市昊锴贸易有限公司、佛山市昊烁贸易有限公司等公司股东，佛山市昊锴贸易有限公司、江门市永晋投资有限公司、佛山市昊烁贸易有限公司等公司高管
李健荣	现任佛山市顺德区自然资源局顺德分局党组书记、局长
李颖	南方医科大学顺德医院，内分泌与代谢科，副主任医师
李静	佛山佛塑科技集团股份有限公司董事
李慧真	佛山市中展展览服务有限公司等公司股东，伦教木工机械商会秘书长
杨春龙	现任勒流医院副院长、主任中医师
吴振球	中山市盈禾脚轮有限公司、佛山市顺德区容桂盈禾五金脚轮厂、广东盈载脚轮有限公司等公司法定代表人，中山市盈禾脚轮有限公司、佛山市顺德区容桂盈禾五金脚轮厂、佛山市顺德区盈匠五金制品有限公司等公司股东，中山市盈禾脚轮有限公司、佛山市顺德区盈匠五金制品有限公司、中山市纯品金属有限公司等公司高管
吴磊	现任现任佛山市顺德区委副书记
邱倩文	顺德著名粤曲唱家
何万桥	广东乔本涂装工程有限公司、广东乔本新材料发展有限公司、佛山市顺德区均安镇嘉莱士化工实业有限公司等公司法定代表人，广东乔本涂装工程有限公司、广东乔本新材料发展有限公司、佛山市顺德区均安镇嘉莱士化工实业有限公司等公司股东，广东乔本涂装工程有限公司、广东乔本新材料发展有限公司、佛山市顺德区均安镇嘉莱士化工实业有限公司等公司高管
何文俊	广州市乐纵科技有限公司、广州市印象网络科技有限公司、海口美兰乐众优选百货店等公司法定代表人，佛山市奥申文化传媒有限公司、广州市乐纵科技有限公司、广州市印象网络科技有限公司等公司股东，广州市乐纵科技有限公司、广州市印象网络科技有限公司等公司高管
何贤培	佛山市特叶保鲜科技有限公司等公司股东，佛山市特叶保鲜科技有限公司、佛山市特普高包装科技有限公司等公司高管
何剑雄	佛山市禅城区乔升科技有限公司等公司法定代表人，佛山市禅城区乔升科技有限公司等公司股东，佛山市禅城区乔升科技有限公司等公司高管
何健	佛山市竹马文化传媒有限公司、佛山市耀诺文化传媒有限公司、佛山市南海区莱妮思鞋店等公司法定代表人，佛山市耀诺文化传媒有限公司等公司股东，佛山市竹马文化传媒有限公司、佛山市耀诺文化传媒有限公司等公司高管
何敏	佛山市港宏投资有限公司、佛山市浩睿文化科技有限公司、佛山市浩智文化科技有限公司等公司法定代表人，肇庆市汇诚装饰工程有限公司、肇庆市端州区浩业企业管理咨询有限公司、肇庆市端州区浩宇企业管理咨询有限公司等公司股东，佛山市港宏投资有限公司、佛山市浩睿文化科技有限公司、佛山市浩智文化科技有限公司等公司高管
何满林	陈村镇潭州村党委委员
汪美葵	广东嘉腾机器人自动化有限公司副总经理、董事长助理
张金凤	广东医科大学顺德妇女儿童医院教学科主任兼新生儿疾病筛查中心主任
张政	华润置地有限公司任华润置地佛山公司总经理
张思中	佛山市造价与招标协会会长、顺德区工程勘察设计咨询协会常务副会长、中国工程咨询协会理事、广东省工程咨询协会常务理事、广东省勘察设计协会常务理事、广东省工程造价协会监事，佛山市工商业联合会（总商会）常务委员、中国民主同盟佛山市顺德区委副主委、民盟佛山市城市委员会主任、广东省新的阶层联合会理事、顺德工商联（总商会）常务委员、顺德科协常委、大良街道第二届公共决策咨询委员会委员、顺峰中学和美教育促进会常务理事长、罗定邦中学教育发展研究会常务副理事长、暨南大学国际商学院学生校外导师，广东人信工程咨询有限公司、佛山贾维斯信息科技有限公司、佛山市中海德信工程项目顾问有限公司等公司法定代表人，广东人信工程咨询有限公司、广东顺房投资发展有限公司、广州国立蓝舵投资有限公司等公司股东，广东人信工程咨询有限公司、广东明科资产评估土地房地产估价有限公司、广东人信项目管理有限公司等公司高管
张晓峰	广东海迪森律师事务所主任、党支部书记
陈小霞	佛山市伟恒集团有限公司等公司高管
陈连志	佛山市律师协会领导副会长
陈忠青	顺德区北滘镇黄龙村党委书记、村委会主任
陈茹	南方医科大学顺德医院中医科、老年病科住院医师
陈莉	市自然资源局顺德分局总规划师，区村改办政策服务组组长，均安镇副镇长
陈智敏	大良顺峰初级中学级长
陈颖	现任共青团佛山市委挂职副书记
林冬娜	美的置业集团执行董事
林礼烽	乐从社区团委书记
欧阳珠	顺德区伦教镇恒乐木制工艺厂联系人
欧阳焕乔	佛山市顺德区均安镇均安社区党委书记、居委会主任
周治宏	广东中周科技有限公司、普洱新明弘业实业有限公司等公司法定代表人，广东中周科技有限公司、普洱新明弘业实业有限公司等公司股东，广东中周科技有限公司、普洱新明弘业实业有限公司、佛山市周际建设工程有限公司等公司高管
周健梅	佛山众志创展商业管理有限公司等公司高管
周景聪	广东哥尼迪家居五金有限公司等公司法定代表人，广东哥尼迪家居五金有限公司、佛山市顺德区奇力电器实业有限公司、广东锴浩斯五金有限公司等公司股东，广东哥尼迪家居五金有限公司、广东锴浩斯五金有限公司等公司高管
郑志雄	佛山市荟方茶业有限公司等公司股东，佛山市荟方茶业有限公司等公司高管
赵文心	美的集团人力资源总监，美的集团国际副总裁
赵毅	广东威奇电工材料有限公司生产负责人，服务业统计科科长，广州周林频谱有限公司、佛山市顺德区大良骏丰商贸有限公司、广州市番禺大石周林频谱专营部等公司法定代表人，广东骏丰频谱股份有限公司、广东通盈创业投资有限公司、东莞市骏丰频谱有限公司等公司股东，广东骏丰投资有限公司、广州周林频谱有限公司、惠州市骏丰频谱有限公司等公司高管
胡杏桃	无
柳杨	顺德区胡锦超职业技术学校学前教育专业部长、艺术团团长，党委委员
钟少海	广东万家乐燃气具有限公司总裁
钟永平	现任广东省佛山市人力资源和社会保障局党组成员、佛山市社会保险基金管理局党委书记、局长、一级调研员，佛山市人大常委会财经工委主任
姚梓健	无
袁渝涵	无
倪谦	现任广东省佛山市委常委、宣传部部长
高锡洪	顺德区党代表、大良街道近良社区党委书记
郭彩玲	佛山市嘉贤房地产代理有限公司、佛山市南海区标顶五金经营部等公司法定代表人，广州市慧知成商标代理有限公司、佛山市嘉贤房地产代理有限公司等公司股东，亚投融(广东)国际控股有限公司、广州市慧知成商标代理有限公司、佛山市嘉贤房地产代理有限公司等公司高管
唐韶群	佛山市人大常委会城建环资工委主任
梅永强	龙江镇陈涌社区党委书记、居委会主任
曹利	顺德职业技术学院会计专业讲师、税务师
崔石磊	永诚保险顺德中支副总经理，党委委员
崔梓华	广东申菱环境系统股份有限公司董事、副总裁
梁凤英	佛山秋色市级传承人
梁伟添	佛山市越馨装饰设计工程有限公司总经理
梁仰坚	顺德青年企业家协会副会长，文筑书店创始人，顺德区政协委员
梁杰生	广东汇盛达建设工程有限公司、广东汇盛达科技发展有限责任公司等公司法定代表人，广东汇盛堂城市投资发展有限责任公司等公司股东，广东汇盛达建设工程有限公司、广东汇盛堂城市投资发展有限责任公司、广东汇盛达科技发展有限责任公司等公司高管
梁泳康	佛山市顺德区景地投资有限公司、佛山市顺德区名能贸易有限公司、佛山市顺德区敏新家电制品有限公司等公司法定代表人，广东天悦餐饮管理集团有限公司、广东智富园发展集团有限公司、佛山市顺德区名能贸易有限公司等公司股东，广东智富园发展集团有限公司、佛山市鹤鸣高五金实业有限公司、佛山市顺德区景地投资有限公司等公司高管
梁晓梅	勒流街道富裕村党委副书记、村委会副主任
梁健锋	伦教街道永丰村党委书记，顺德区人大常委会伦教街道工作委员会委员
梁继业	无
梁富锋	水口村党委书记
梁影琪	无
梁瓒伦	广东东立新材料科技股份有限公司董事长
程剑馨	无
舒翔	顺德图书馆馆长
曾词辉	仙涌小学校长、党支部书记
曾继华	广东伊之密精密机械股份有限公司的党委书记、股东、总裁助理
谢秉轩	顺德区青企执行会长，广东伟经金属制造有限公司总经理
蒙业云	顺德德美化工集团
蔡必占	顺德区工商联第十五届执委会委员，广东爱米高家具有限公司董事长，龙江青年企业家协会会长
霍茂昌	现任佛山市顺德区大良街道党工委书记、维稳及综治委主任，陈村镇人民政府、陈村镇党委书记

CMS

2023-01-10T02:38:27.000Z

今天才了解到，原来我一直在寻找的博客的解决方案，其实是在寻找一个CMS，即 content management system，让我能方便地上传和编辑博客，然后同步到网站上去

今天看到一个基于Django的 CMS：Wagtail

文档 Wagtail Documentation
仓库 wagtail/wagtail

最近越来越领略到Django的好（尤其体现在解决方案非常完整上）（只可惜类型标注没有，所以类型推断不够）

没想到 Django REST framework 居然能有这么多⭐

谈css框架

2023-01-07T18:56:05.000Z

前段时间做 FIndTeammates 项目（这是一个Django项目，不用前端框架，所以只能挑选不需要构建步骤的框架）的时候尝试并很快放弃了Pico CSS（大概浪费我一下午尝试），因为它实在太年幼了，或者说自定义的部分太少，然而预设的部分又不够好。虽然它理念中的一些地方我很赞同：

在引用的 css 文件中完成用role之类的元素的样式定义（这些应该是公有的，不需要让开发者看到），我理解的是这是一种类似重置浏览器预设的含义🤔
提供一些类似primary这样的形容词来命名classes，但这注定与原子化css的思想相违背
其他的个性化（如灵活的 transition 效果，父子级联的 hover 选择器等等）直接写 css 标签

但是它第1点预设的部分我觉得不够高效也不够好看，第2点提供的也不够多，最后基本上都在写裸 css，非常失望。一下午的尝试后直接果断 rollback 了

因为这个项目需要与很多没有现代前端经验的同学合作，所以也抛弃了用 @unocss/cli 的想法（虽然可行）（另一个原因是我也想尝试尝试其它 css 的解决方案）。于是我就想起了[Bootstrap](https://getbootstrap.com/)😂

Bootstrap虽然蛮老了，但我觉得正好适合Django，而且它的类名（像btn、btn-primary）这些，既实用高效又挺美观（中规中矩的），而且组件非常丰富（可以说非常好的满足了上面第2点）

原子化 css 的坏处在于没能分开样式和内容（可以认为原子化 css 的classes相当于简化版的 inlinestyle属性，这不美观，即使开发快但这绝对不是最好维护的

后来我想起来，像 Windi CSS 的 @apply 就完美地解决了这一点（至少在我还没用过的当下我这么认为），它既能有原子化 css 的开发效率（以及跨浏览器的兼容性），也能有代码的简洁美观性，符合我对第3点也即样式和内容的分离的要求，所以以后我的项目（比如还没正式开始做的 Re:Bingo ）很可能会采用这个解决方案✨

在 Anthony Fu 的 Reimagine Atomic CSS 中提到了这么一段：

Windi CSS as a framework will fill the missing features like @apply preprocessing, IDE intelligence sense, preflights, etc., that UnoCSS as an engine intentionally won’t provide. And it will also leverage the performance and the flexibility that UnoCSS offers for both core utilities and user configurations.

UnoCSS毕竟是一个engine而非像Windi CSS一样的framework，所以它注定不会提供这些功能，它给自己的定位似乎是一个在性能和alternatives上而非语言上优化的原子化css引擎，所以我认为它可以是一个很好的玩具，但不会是best practice

一直都说，Sass 走的是和 Atomic CSS 不同的路线：它是对语言本身创新了，而后者（以 Tailwind 为例）只是在现有的框架内用出了新的玩法——可以认为，Sass 的创新更大，发展空间也更大，更关键的是，它的 nesting 语法我觉得非常符合 css 的级联本质，而且样式的继承我觉得是非常合理的。另一方面，一个div:hover的各种子元素的一系列变化用 css 写真的很麻烦，我觉得 Sass 的写法应该能简化很多。不过很可惜的是现在确实还没用过Sass，将来有机会一定要试一试，没用过都只能是瞎评价

附上 Sass 的语法简介

而现在看来 Windi CSS 则是介于这二者之间的解决方案：既能当作原子化 css 来用，也有自己的新语法👍

Windi CSS 我觉得就是未来的 best practise：附上它的语法草案

Windi CSS 的 nesting 语法例子：

@screen sm {
  .clearfix {
    display: block;
    zoom: 1;
    &:after {
      content: " ";
      display: block;
      font-size: 0;
      height: 0;
      clear: both;
      visibility: hidden;
    }
  }
}

我觉得足够方便了

然而这个文档其实还是个草案：****

For now, we are still in the draft stage, so any suggestions are welcome. You can start a discussion in github discussions, and we will reply to you as soon as possible.

但我目前认为光是@apply语法其实就够实现第2点了，让写内容的 dom 很简洁，同时保证写样式的<style>里很高效🌹

今天了解到另一个 css 框架：Stylify CSS

旧时代套件一条龙

2023-01-03T12:33:03.000Z

既然都用了Django，就也用上BootStrap吧😂😂😂

Bootstrap我理解吧，是一个介于Tailwind之类的原子化css库和DaisyUI这样的组件库的框架，但是比DaisyUI严肃，又比Tailwind多了样式预设，作为用来写后端模板非常适合我觉得

而且团队里大家似乎都没什么使用现代前端框架的经验，Bootstrap应该是很好学的了

Django 初体验（可能也是最后一次）

2023-01-02T20:49:00.000Z

这次算是真的体会到了，Django其实就是提供了一个完整的解决方案。但是我认为他们的解决方案有点旧了

但不可否认的是，他们的解决方案确实很全面
除了性能和体验等量变的地方可能存在机制上的不足，质变的关键点其实都做好了

但我个人实在不认可他们的文档，还是比较喜欢Solid的文档那样，文档应该由异构的几部分组成：

自述。关于“本框架”是什么定位
教程。一个简单的案例——结果导向
zero-config playground
API参考。最好有介绍性的解释文本，而不只是结构化数据

但是Django的案例tutorial我觉得也还是不完美。怎么那么多篇文章能没个总起呢？？？直接就dive into细节谁好受啊？

有一点想法：其实并不是什么时候教程忽略细节都是好的：比如可以在tutorial中途放出数据库配置教程的链接（比如是一个类似Django的全面解决方案框架的话）

BEAUZ

2023-01-02T18:46:18.000Z

今天偶然想起一首歌{{记得附链接}}，它和BEAUZ的一首歌{{链接}}很像（简直就是后者的低配版哈哈哈），于是顺便听了BEAUZ的好几首歌

突然发现，原来以前在日推和其他推荐听过没收藏的好几首歌都是BEAUZ的

我可能是有一点喜欢BEAUZ的歌的材质感的（我喜欢用视觉的方式谈论音乐），你可以说它是丰富，善于组合利用音色，始终让画面出现各种材质（类似同时具有高低频？（认知感受上而非物理上）），整体比较丰富饱和的感觉；也可以说它是廉价感，类型片的感觉，向市场妥协的感觉……我觉得这也是事实。我也不否认我自己的部分设计理念（尤其是UI方面）就是向大众审美妥协，但我也认为这是UI的目的之一——让大部分人能更快地理解、通俗易懂这样的含义……

有一首歌{{链接}}我想在我的FPgui发布时用来炫耀它的能力🌹在此我立个小flag哈哈哈哈

2023年1月2日小记

2023-01-01T18:37:31.000Z

今天叫基于OpenAI的Craft Assistance帮我润色拙荆的自述信😂

原文

Personal Statement

I would like to describe myself as a single-minded doer, always having clear goals in mind. I advocate meaningful work and prefer concise expressions rather than exaggeration and superficiality.

I have a clear understanding of my strengths and weaknesses. My courage and confidence are based on fully understanding of certain fields, while I remain humble and inquisitive about areas I have not yet explored. I believe that knowledge has no limit, and hope to further my education in finance, and become a comprehensive talent in Investment Management.

During my university years, I managed to maintain excellent academic results while actively participating in several business competitions at the same time. I also went to Beijing Normal University for exchange and have passed CFA and FRM Level I examinations. During my holiday time, I took an off-campus internship as a financial media, from which I improved my integrating skills such as efficient information collecting and learned to transform structured data programmatically.

Previously, I learned that your master's program in Investment Management is recognized by the CFA Institute. You teach students programming skills to access a variety of financial databases, which exactly meet my interests and strengths, so I believe that your school fully satisfies my future development needs.

Been majored in finance as an undergraduate / Having a bachelor’s degree in Finance, I already have a basic technical knowledge of finance and securities markets. I also mastered using Wind Financial Terminal during my internship. Therefore, I believe that I meet your enrollment requirements as well.

Having a solid foundation in English, I am currently preparing for the IELTS test, being confident to meet your language requirements before May 2023.

结果

Personal Statement

I am an ambitious and goal-oriented individual who values quality and meaningful work over exaggeration and superficiality. I understand my own strengths and weaknesses, and have the courage and confidence to explore unfamiliar territories. I hope to further my education in finance, and become a professional in Investment Management.

During my university years, I have maintained excellent academic results while participating in multiple business competitions and engaging in an exchange program at Beijing Normal University. I have also taken CFA and FRM Level I examinations, and completed an internship in financial media to improve my data collection and processing skills.

Upon researching, I discovered that your Master's program in Investment Management is highly reputable and certified by the CFA Institute. I am highly interested in learning programming and exploring financial databases; both of which are competencies you provide in the program and thus, I believe your school offers the resources I need to develop further.

Having obtained a Bachelor's degree in Finance, I possess a solid foundation of technical knowledge and have experience in using Wind Financial Terminal. Furthermore, I am actively preparing for the IELTS test and am confident I meet your language requirements by May 2023.

🤔666

甚至还可以帮我减少语法错误（虽然并不太准确）：

During my university years, I managed to maintain excellent academic results while actively participating in several business competitions at the same time. I also went to Beijing Normal University for exchange and has passed CFA and FRM Level I examinations. During my holiday time, I took an off-campus internship as a financial media, from which I improved my integrating skills such as efficient information collecting, and learned to transform structured data programmatically.

During my university years, I managed to maintain excellent academic results while actively participating in several business competitions simultaneously. I also went to Beijing Normal University for an exchangnd have passed CFA and FRM Level I examinations. During my holidays, I took an off-campus internship as a financial media, from which I improved my integrating skills such as efficient information collection and learned to programmatically transform structured data.

修正：将“at the same time”替换为“simultaneously”，将“has passed”替换为“have passed”，将“collecting”替换为“collection”。这些修正都是语法上的错误，“at the same time”表示两件事情发生在一起，改成“simultaneously”表示两件事情同时发生；“has passed”是现在完成时的标志，而事实上是过去完成事件，应改成“have passed”；“collecting”是动名词，而“collection”是名词，表示收集的整体。

About Craft AI Assistant

PERSONAL STATEMENT

Mingjun Liu – Finance

International Business Faculty, Beijing Normal University, Zhuhai

I would like to describe myself as a single-minded doer with clear objectives. I advocate meaningful work and prefer concise expressions over exaggeration and superficiality. I am well aware of my own strengths and weaknesses. My courage and confidence come from a thorough understanding of certain fields, while I remain humble and inquisitive about areas I have yet to explore. I believe that knowledge has no bounds, so I hope to further my education in finance and become a well-rounded investment manager.

During my college years, I passed the CFA and FRM Level I exams. I also went to Beijing Normal University for exchange and managed to maintain excellent academic results while actively participating in several business competitions. During my holiday, I took an off-campus internship as a financial reporter, which helped me develop my integrating skills, such as efficient information gathering, and inspired me to learn to transform structured data programmatically.

Previously, I learned that your master's program in Investment Management has been recognized by the CFA Institute. You teach students programming skills to access a variety of financial databases, which exactly match my interests and strengths, so I believe that your school fully meets my demands for further education.

Having majored in finance as an undergraduate, I already have a foundational technical understanding of finance and securities markets. Currently, I am actively preparing for the IELTS test. With a solid foundation in English, I am confident that I will meet your language requirements by May 2023. During my internship, I also gained experience using the Wind Financial Terminal. Therefore, I believe that I satisfy your enrollment conditions as well.

语雀的局限

2022-12-20T09:47:37.000Z

与自己的服务对接只能降级为 markdown
- 双链不能
- 其实不是 markdown 不好，只是
  - 这样等于把语雀纯粹当成同步 markdown 笔记的工具而已了
代码块支持语言有限

但其实就算支持了双链，在Svelte支持markdown内的内链SPA导航还是有一定困难的。（暂定靠手动将AST树输出html实现？）

This is a shortcut of making a [[link]] to another file.

将来打算把自己的博客替换成用 Obsidian 写。这需要手动写一个同步工具以及一个解析器

[[filename]]只是[filename](filename.md)的语法糖，这意味着双链很方便解析（而且都是相对路径太赞啦！）
- 甚至类似markdown中![]()的用法，Obsidian中也可以内嵌文件，也很好解析🎉
链接到标题：https://help.obsidian.md/How+to/Internal+link#Link+to+headings
链接到任意块：https://help.obsidian.md/How+to/Link+to+blocks#Link+to+blocks

说起来，才发现 Obsidian 还有中文文档

希望在自己的 SQML 中实现类似 Obsidian 的双链语法🤩

今天发现 Obsidian 居然也有 Obsidian Publish，域名还是.md后缀😂，我懂了，Obsidian 就是加了双链的支持渲染知识图谱的markdown编辑器🌹

但其实还是蛮符合我的原则的🤔

现在等于是把语雀纯纯当成同步markdown的工具了。这绝对是天大的浪费。将来至少要把回复点赞等功能实现了（但这样又违背了免费建站的初衷了？）

而且，文章的排序也是个问题

SvelteKit博客优化

2022-12-20T14:07:21.000Z

现在有一个奇怪的现象，从/点链接进/blog很快，从/blog点文章链接进文章也很快，但是在文章页面或者/blog刷新就很慢

换句话说，直接访问除/之外的页面都会很慢。这其实是因为直接访问会触发SSR，SSR就需要海外服务器去get语雀的数据

SSR的目的是SEO，如果能识别搜索引擎单独对搜索引擎的抓取请求SSR就好了，但由于我们用的是Serverless架构，这我不知道怎么实现

2022 年终总结策划

2022-12-31T12:46:34.000Z

Bingo
搁置的项目与准备做的项目
- xindex
- bnu120 site
- iForget
- temponent
- 项目组队平台
- 基于图床免费用量的小文件网盘
- Picin 在线版
- SQML 2.0
- re: bingo
吃的
宝贝的照片
暑假
终于告别了平面设计的活儿
蓝屏集锦
放一张自己照片作结
放一张宝贝的新年照片~

给bnu120做了个好看的首页

2023-01-01T01:07:13.000Z

应该是最后一次更新bnu120网站了，完善了下它的首页

PR如下：

甚至还做了个出场动画（透明度、缩放、模糊齐上阵）

而且适配了深色模式

就可惜移动端适配不是很好

唉😞我还是不太会移动端适配……移动端上看总是会文字过大的感觉

JetBrains IDEs 的重复代码检测功能居然能这样检测

2022-12-31T21:30:51.000Z

没想到这也能识别出来：

佩服佩服

它不仅仅能检测完全相同代码片段
也能检测结构类似的代码片段

gp: 爬取养老机构信息

2022-12-29T16:33:41.000Z

gp: 重构养老网模块

2022-12-28T10:30:48.000Z

整理出了一个common.py来存放两个子模块news和homes的公共代码

gp: 爬取养老网聚合新闻

2022-12-27T19:49:31.000Z

from httpx import Client
from bs4 import BeautifulSoup
client = Client(http2=True, base_url="https://www.yanglao.com.cn/")

获取url中的数字用到的正则表达式：

from re import compile
get_id_reg = compile(r"\d+")

获取文章列表

直接用网站自带的分页

def get_articles(page: int = 1):
    """https://www.yanglao.com.cn/article下的文章"""
    dom = BeautifulSoup(client.get(f"/article_{page}").text, "lxml")
    news_list = dom.select_one("ul.news-list")
    return [
        {"articleId": int(get_id_reg.findall(li.a["href"])[0]), "title": li.a.string, "date": li.span.string}
        for li in news_list.find_all("li")
    ]

注意：这里暂时没有考虑获取不到的情况

获取文章详情

正文直接用原本的html数据吧。我记得微信小程序中是允许插入html片段的

def get_article_info(article_id: int):
    dom = BeautifulSoup(client.get(f"/article/{article_id}.html").text, "lxml")
    news_view = dom.select_one("div.news-view")
    li_source, li_hits, li_datetime = news_view.select("ul.info > li")[:3]
    return {
        "title": news_view.h1.string,
        "source": li_source.string.strip()[3:],
        "hits": int(li_hits.string.strip()[3:]),
        "datetime": li_datetime.string.strip(),
        "html": news_view.select_one("div.news-content").prettify(),
        "related": [
            {"articleId": int(get_id_reg.findall(li.a["href"])[0]), "title": li.a["title"]}
            for li in news_view.select("div.related-read li")
        ]
    }

做成API

为了文档效果，我决定把返回值都改成用 Pydantic 模型

from pydantic import BaseModel, Field

class Article(BaseModel):
    articleId: int = Field(alias="article_id", title="文章唯一标识，用于请求文章详情")
    title: str = Field(title="文章标题")

    class Config:
        schema_extra = {"example": {"articleId": 521502, "title": "大兴区精心康复托养中心十二月康复展示"}}


class ArticleWithDate(Article):
    date: str = Field(title="文章发布日期")

    class Config:
        schema_extra = {
            "example": {"articleId": 521433, "title": "地方立法密集落地优化养老服务升级", "date": "2022-12-12"},
        }


class ArticleDetails(BaseModel):
    title: str = Field(title="文章标题")
    source: str = Field(title="文章来源", description="可能为空字符串")
    hits: int = Field(title="浏览量", description="经测试就是请求次数")
    datetime: str = Field(title="文章发布日期和时间", description="按照 yyyy-mm-dd hh:mm:ss 格式")
    html: str = Field(title="正文html", description="可能很长，可能包含图片文字甚至富文本")
    related: list[Article] = Field(title="相关文章", description="可以搞成一个列表")

    class Config:
        schema_extra = {
            "example": {
                "title": "2022天津河西区老年痴呆养老院哪家好？2022河西区老年痴呆养老院多少钱？",
                "source": "国家卫健委门户网站",
                "hits": 27,
                "datetime": "2022-12-27 15:10:26",
                "html": """\
                    <div class="news-content">
                     位于上海市静安区保德路545号的**护理院也是<a href="https://www.yanglao.com.cn/resthome">收阿尔兹海默老人的养老机构</a>。
                    </div>
                """,
                "related": [
                    {'articleId': 521504, 'title': '仙栖谷精神障碍托养中心告诉您精神障碍患者“阳”了怎么办？'},
                    {'articleId': 521501, 'title': '椿萱茂日间照料｜家门口的健康养老很幸福'},
                    {'articleId': 521497, 'title': '2022成都青羊区老年痴呆养老院有哪些，2022青羊区认知症养老院地址'}
                ]
            }
        }

已经把文档写进模型了，可能会有点不好看哈

初始化部分与原来类似：

from fastapi import APIRouter, Path, Query, HTTPException
from pydantic import BaseModel, Field
from httpx import AsyncClient
from bs4 import BeautifulSoup
import re

router = APIRouter(tags=["news"])
get_id_reg = re.compile(r"\d+")
client = AsyncClient(http2=True, base_url="https://www.yanglao.com.cn/", headers={
    "user-agent": "gp-scraper / Guard Pine (https://gp.muspimerol.site/)",
    "x-scraper-contact-email": "admin@muspimerol.site",
    "x-gp-repo": "https://jihulab.com/CNSeniorious000/gp-backend"
})

为了养老网的管理者能识别我们，我还加了个自定义的user-agent请求头

接下来定义endpoints：

@router.get("/articles", response_model=list[ArticleWithDate], responses={404: {"description": "分页超出范围"}})
async def get_articles(page: int | None = Query(1, description="分页（从1开始）", ge=1)) -> list[ArticleWithDate]:
    """### fetch new articles directly from the web"""

    dom = BeautifulSoup((await client.get(f"/article_{page}")).text, "lxml")
    news_list = dom.select_one("ul.news-list")
    if news_list is None:
        raise HTTPException(404, "page not found")
    return [ArticleWithDate(
        article_id=int(get_id_reg.findall(li.a["href"])[0]), title=li.a.string, date=li.span.string
    ) for li in news_list.find_all("li")]


@router.get("/article/{articleId}", response_model=ArticleDetails, responses={404: {"description": "不存在该文章"}})
async def get_article_info(article_id: int = Path(alias="articleId", description="文章唯一标识")) -> ArticleDetails:
    """### get an article's details and its related articles"""

    dom = BeautifulSoup((await client.get(f"/article/{article_id}.html")).text, "lxml")
    news_view = dom.select_one("div.news-view")
    if news_view is None:
        raise HTTPException(404, "article not found")
    li_source, li_hits, li_datetime = news_view.select("ul.info > li")[:3]
    return ArticleDetails(
        title=news_view.h1.string,
        source=li_source.string.strip()[3:],
        hits=int(li_hits.string.strip()[3:]),
        datetime=li_datetime.string.strip(),
        html=news_view.select_one("div.news-content").prettify(),
        related=[
            Article(article_id=int(get_id_reg.findall(li.a["href"])[0]), title=li.a["title"])
            for li in news_view.select("div.related-read li")
        ]
    )

最后上传PR：add news-fetching APIs

最后，显示效果还不错吧：

可惜，该网站协议中提到不允许爬它：

网站内容方面

上述“其他权益”涵盖本站已经发布或将要发布的所有内容（包括但不限于：文字、图片、图像、音频、视频等），任何单位或个人不得以任何方式（包括但不限于：转载、摘编、复制、剪辑、在非养老网所属的服务器上做镜像等）擅自使用上述内容，或利用这些内容再造与之相关的衍生产品。

robots.txt也显示：

User-agent: *
Disallow: 
Disallow: /assets/
Disallow: /css/
Disallow: /js/

Learning SolidJS

2022-12-19T03:42:15.000Z

The New Solid Docs 别说没有中文翻译了，甚至有的链接打开都还暂时404，官方说这是因为这个文档是不依赖老文档直接新建的一个项目

新文档遵循了一个 Diataxis 原则：

guide部分包括
- 项目导向的教程
- 基于topic的指南
reference部分不仅是API reference，还应该有explanations

我个人是很赞成项目导向的，对没基础的人这可以很激发热情，对有基础的人可以很快上手而且和别的框架对比。对于这个explanation，官方是这么解释的：

Explanation, unlike the other three forms of documentation, doesn’t have a direct part in a user’s practice or work. This means that it’s sometimes seen as being of lesser importance. That’s a mistake; it may be less urgent than the other three, but it’s no less important. It’s not a luxury. No practitioner of a craft can afford to be without an understanding of that craft, and needs the explanatory material that will help weave it together.

但是有一个没见过的特性：

可以选择自己由什么框架迁移到Solid，文档会在正文中时不时插入一些因框架而异的提示

一开始选错了也没关系，这个窗口会一直在侧栏可以选择~~（像我这种喜欢把每条支线都看遍的玩家就很需要）~~

刚开始就是一个 HelloWorld 组件，提到了组件名是title-cased，提到了返回值是JSX不是HTML，后面又解释了，好像除了文件后缀是jsx，这种返回值的类型也叫JSX

后面提到了title-cased是为了让JSX分辨组件和原生的HTML元素

注意到JSX中style是可以传一个js对象的：

<div style={{ "background-color": "#2c4f7c", color: "#FFF" }}>Hello {name}!</div>;

传值用的时单大括号，和Svelte一样

讲到组件时，它开始提示我Solid和Svelte的区别，我点了点其它框架，发现提示有相同有不同

在Svelte/Vue中存在生命周期的概念，在Solid中没有这回事：Solid's rendering system is based on the reactive features you use
Solid中可以在一个文件中export多个组件
在上一点中React和Solid一样（感觉从JSX就看出来Solid是跟随React的），但是 Solid component functions only run once to set up and never run again，这大概就是Solid的编译的特性了吧
JSX的编译：This is more involved than React's JSX compiler, but much less involved than something like Svelte's compiler. Solid's compiler doesn't touch your JavaScript, only your JSX.

Solid与Svelte

相同点

non-VDOM

不同点

HTML-first templating languages / JavaScript-first templating languages
- HTML-first: Svelte, Vue, Marko
- JavaScript-first: JSX

在 Read more about the compiler 中：

Solid's JSX compiler doesn't just compile JSX to JavaScript; it also extracts reactive values (which we'll get to later in the tutorial) and makes things more efficient along the way.

This is more involved than React's JSX compiler, but much less involved than something like Svelte's compiler. Solid's compiler doesn't touch your JavaScript, only your JSX.

If you're curious about how Solid and other frameworks use compilation, check out A Look at Compilation in JavaScript Frameworks by the creator of Solid.

下面的笔记关于这篇Solid之父的文章。

早在2017年，就有人预言Web的未来是编译。

To offer better developer experience, you end up creating a language. A language needs a compiler. A compiler eventually wants a language server.

提高做某件事的效率的方法之一就是为其设计专门的语言。

Svelte separates its code between create and update lifecycles. Solid takes that one step further hoisting the DOM creation into clone-able Template elements that create whole portions of the DOM in a single call, incidentally a runtime technique used by Tagged Template Literal libraries like @webreflection's uhtml and Lit.

Solid的组件的代码只运行一次，相同的组件会重用这部分代码。这可能是Solid比Svelte快的地方。

现在的编译型模板语言也还是免不了运行时。

走近信息科学2022期末珠海试卷20221220

2022-12-20T09:48:23.000Z

什么是信息科学？科学与技术的关键区别？信息科学的三大支撑理论及其内涵是什么？

信息科学是研究信息运动规律和应用方法的科学，是由信息论、控制论、计算机理论、人工智能理论和系统论相互渗透、相互结合而成的一门新兴综合性科学。其支柱为信息论、系统论和控制论。信息科学是一个高度复杂的学科，它涉及许多具体的技术和理论，例如通信与网络、信息安全、算法与编程、视觉与图像处理等。它的应用领域也极其广泛，主要包括电子商务、社交媒体、医疗保健、能源分配、交通管理等。

科学与技术的区别在于：

目的不同：科学侧重于回答"是什么""为什么"的问题；技术侧重于回答"做什么""怎么做"的问题
任务不同：科学是认识自然、探索客观真理、揭示事物本质规律；技术是生产力，是改造自然，创造物质财富的手段和存储知识、获取信息的手段
知识形态不同：科学主要表现为一元性的知识，它将纷杂的现象统一于某一种本质，使其简洁明了；技术由单一到多样，它将某一种科学知识转化为多种技术设施、工艺手段，从相同的原理中做出多种类型的设计方案
选题方向不同：科学从科学理论与科学实验的矛盾、科学理论自身的矛盾中去寻找、发现和选择研究的课题，目的是从中发现新的现象和规律，要求具有理论学术意义，但不能要求在经济和社会生活中立见成效；技术主要从国民经济发展、国防建设需要、人民生活水平提高等实际需要中发现和选择所研究的课题，要求能付诸实施并产生一定的实际效益
成果形式不同：科学成果是观念形态的东西（科学发现/预见/原理）属于由物质向精神转化的范畴，其成果形式有专著、论文、研究报告等；技术成果是知识形态的东西与物质形态的东西的有机结合，更多地表现为由精神向物质的转化，其成果形式有技术样品、模型、技术规程、图纸等
知识的评价标准不同：对科学进行真理性评价；对技术进行价值性评价
管理方式不同：科学是由科学共同体通过制定行为规范来实施的，其管理是柔性的、松散的，科学是无国界的，它的知识是共有的、共享的，属于全人类；技术是由国家准里部门通过专利法保护的，这种管理是严格的、在一定时期是保密的，技术是有国界的，未经公司或政府许可时不能够输出的

总之，科学与技术的目的、任务、知识形态、选题方向、成果形式、知识的评价标准和管理方式都有所不同，科学与技术都是共同的，却又有所区别，互为补充，共同发展。

信息科学的三大支撑理论是控制论、信息论、系统论

系统论：系统论是一种以系统为基础的理论，它研究的是系统的结构特征、行为特征、复杂性等，以及系统的内部联系和外部环境关系、结构和行为之间的协调，以及系统的演化过程。它是由系统思维发展起来的，是一门关于系统思维方法论、系统分析方法论和系统设计方法论的科学。
信息论：信息论是一种理论，旨在研究信息的结构、表征、存储、传输和使用。它主要研究信息的本质，如信号的形式、信息的内容、信息的编码以及信号的传输等。
控制论：控制论是根据物理系统的机械装置，开发出来的一种理论，它旨在通过研究系统的性质，进行系统的调控，使系统运行稳定、准确、可靠。它主要研究受控系统的性质，控制系统的品质，如何实现达到期望的目标，以及如何对系统实施控制、补偿等。

什么是多传感器数据融合？数据融合的三个层次是什么？列举2-3个常用的数据融合方法。

多传感器数据融合是指将多个传感器收集到的多维数据进行组合以获得更准确的数据，从而更好地认识和模拟真实世界的方法和技术。

数据级融合：针对传感器采集的数据，依赖于传感器类型，进行同类数据的融合。数据级的融合不能处理异构数据
特征级融合：提取所采集数据包含的特征向量，用来体现所检测物理量的属性，这是面向监测对象特征的融合
决策级融合：根据特征级融合所得到的数据特征，进行一定的判别、分类，以及简单的逻辑运算，根据应用需求进行较高级的决策。决策级融合是面向应用的融合。

数据级融合比如图像处理中借助多重曝光实现的HDR，用同构的数据提升图像信噪比和宽容度（动态范围）
特征级融合比如机器学习领域的集成学习，用多个异构的学习器得到不同的特征，并对这个特征进行融合
决策级融合比如深度学习中的卷积神经网络，特征工程就是指对低级特征逐层提炼，得到高级特征的过程

简述虚拟现实、增强现实和元宇宙的含义，举例说明虚拟现实和增强现实的不同。

虚拟现实（VR）是利用技术手段将用户带到虚拟的环境中去进行实时交互的一种新兴的以可视化为基础的计算机技术；增强现实（AR）是一种把虚拟的物体及信息与真实的环境相结合的技术，让虚拟的信息可以融入到真实的世界中。

而元宇宙（Metaverse）是一种与虚拟现实和增强现实结合的概念，它把VR和AR技术用于建立一个多层次的三维虚拟环境，用户可以在其中实现完全虚拟的社交经济体验。元宇宙把VR和AR技术紧密结合，使用户可以在完全虚拟的环境里体验真实环境的一些感受，并与真实世界融合，使用户可以在虚拟世界里进行一系列的社交活动，而不必离开真实的世界。

元宇宙中的社交为用户提供更多的交流和互动体验，同时也可以为虚拟世界增添更多的感官元素，从而让用户在虚拟世界里享受更具实体感的体验。

VR和AR的异同：

相同点：都是建立在特殊环境里的计算机技术，都是可以让用户进入虚拟世界中进行实时交互。

不同点：VR是将用户带入完全虚拟的环境中，而AR是将虚拟的物体及信息融入到真实的世界中，用户可以与虚拟物体交互，但实际上没有改变真实的环境。

什么是知识图谱？若将文本数据转化为知识图谱，需要哪些自然语言处理技术？文本数据转化为知识图谱后，其价值会在哪些方面得到了提升？

知识图谱是一种形象化的、基于图形的计算机表示形式，它把有关各种实体和关系的知识以图形结构的方式连接起来，使得这些知识能够在自动化的方式被计算机解释和处理。知识图谱通常由多个节点和连接起来的边构成，用于存储有关关系的知识和信息。知识图谱可以为计算机提供一种更加系统的理解能力，以及更深层次的认知能力。它可以通过图谱的方式发现连接各个实体的关系，挖掘关系的结构和依赖性，最终形成一个完整的知识库。知识图谱的这种可视化形式和计算机的实现能力，可以帮助人们更容易地去理解事物间的关系，从而更好地建立更为有效的模型和算法。

要将文本转化为知识图谱，需要使用多种自然语言处理技术，其中包括词法分析、句法分析、细粒度分析、知识获取、语义理解等技术。

其中，词法分析指的是从文本中提取单词，并对单词进行原始形式的标记；句法分析指的是归类句子结构，对句中的词语进行深入的分析以了解句子结构；细粒度分析指的是对句子中的单词进行更深一步的分析，把单词分解成更有意义的语义单元；知识获取指的是把文本中的实体和关系从抽象的文本表达中抽取出来；语义理解指的是理解句子意思，分析出句子中实体之间的关系。

将文本转换为知识图谱后，其价值会在以下几个方面得到提升：

可视化：知识图谱的可视化形式可以使人们更容易理解文本内容的含义，从而更好地表达概念。
自动化：知识图谱为计算机提供一种更加系统地理解能力，能够更好地理解文本的意思，从而自动的完成繁重的工作，如知识抽取、理解和推理等。
可扩展性：知识图谱支持无限制地自然语言处理，可以从给定文本中提取出不断增长的知识和信息，从而使知识图谱不断变得更加全面。
可集成性：知识图谱不仅可以让人们更好地查阅和理解知识，而且还可以和其他技术如机器学习、大数据分析等技术集成，从而实现更多的价值。
最后，知识图谱还可以将各种数据进行有效的衔接，进而有效地实现多模态融合，从而实现新一代人工智能应用，如虚拟信息助理、问答系统、机器翻译等。此外，知识图谱还可以基于实体及其关系，使用强大的推理能力，解决从语义理解、对话建模、推荐系统到知识推理等方面的问题。

总之，知识图谱在构建有效的文本表示形式方面具有广阔的应用前景，可以更全面地理解文本内容，更好地挖掘信息，处理复杂的推理任务，为人工智能技术的发展提供更多的可能性。

简述人工智能发展的六个主要阶段，每个主要阶段的主流技术是什么？列举2-3个不同时期的代表性应用。

起步发展期：1956年-20世纪60年代初：简单的机器定理证明、跳棋程序
反思发展期：20世纪60年代-70年代初：具有挑战性的任务和不切实际的研发目标落空
应用发展期：20世纪70年代初-80年代中：特定领域的专家系统
低迷发展期：20世纪80年代中-90年代中：专家系统存在应用领域狭窄、缺乏常识行知识、知识获取困难、推理方法单一、缺乏分布式功能、难以与现有数据库兼容等问题逐渐暴露
稳步发展期：20世纪80年代中-2010年：互联网技术加速了人工智能的创新研究，促使AI技术进一步走向实用化
蓬勃发展期：2011年至今：前沿技术联动，AI与其他科学交叉发展，不断在各领域实现重大突破，也不断映入大众视野。例如ChatGPT、stable-diffusion等

简述大数据的三个主要来源，解释其4V特性，列举2个大数据分析的典型应用案例。

大数据的三大主要来源是指开源数据、业务数据和线路数据。

开源数据包括了互联网数据、移动数据网数据，互联网平台和移动互联网平台通过采、编、发或者通过用户互动产生的数据，公之于众，供网民或用户访问、浏览。
业务数据产生于各单位的信息化系统中。在目前的单位业务系统中蕴含了大量的工作数据和交易数据，以及客户管理数据，包括交易数据、流水数据、记帐数据、借款数据、贷款数据等业务数据，这些数据构建了每天的系统日志，同时又是帐户余额、信用额度、购买能力等的有力补充，这些数据不仅对生产系统起到计费支撑作用，同时也是用户（银行客户、电力客户、担保公司等）进行相关决策的重要基础。
而线路数据是指在任何的网络行为都需要经过“线路”进行链接和交互，在这条线路上，要经过无数的路由交换得以完成，这条线路在完成链接的同时，也记录与存贮了大量的数据，我们统称为线路数据。

4V特性指Volume（海量数据）、Variety（多样化数据）、Velocity（快速更新）和Veracity（数据可信度）。

2个典型应用案例：

导航软件：分析路线拥堵的程度和天气情况，实时为用户推荐最快最安全的线路
翻译软件：需要先用大量的源语言和翻译后的目标语言配对来让神经网络学习规律

计算机视觉的四个关键技术环节是什么？介绍各个环节的典型处理技术，说明计算机视觉未来的发展目标。

分类、定位、检测、分割。

图像分类：KNN聚类、SVM支持向量机、BP神经网络、CNN卷积神经网络等
图像定位：匹配定位、投影定位等
图像检测：边缘提取、阈值选取、CNN等
图像分割：基于阈值的分割、区域生长法、分水岭算法、基于边缘检测的方法、基于小波分析和小波变换的方法、基于遗传算法的方法、基于主动轮廓模型的方法、基于深度学习的方法、基于区域选择的方法等

计算机视觉未来的发展目标是进一步提高准确率、实时性以及视野范围，不断优化模型、技术，对不同的图像进行精准的分析判断，更加准确地识别一系列复杂的图像，并将计算机视觉应用于实际领域。为此，需要运用机器学习、深度学习及其他人工智能领域的最新技术，如强化学习等，提供更高精度的算法，改进计算机视觉的处理能力。

步态识别在应用落地中有哪些挑战问题？解决这些问题的关键思路和路径是什么？

数据采集挑战：步态识别系统需要足够多的、高质量的数据来完成训练，而这些数据不容易采集和准备，另外还要考虑不同人群的差异，如身高、体重、性别等；
模型训练挑战：获得足够的步态数据后，模型的训练和优化是关键步骤，但是由于数据量的局限，很难构建具有广泛适用性的模型；
部署挑战：步态识别系统的实际部署需要考虑的因素比较多，这些因素包括：设备类型和型号、环境照明条件、安全性度量标准等；

解决这些问题的关键思路和路径：

利用现有数据集构建训练模型，并进行模型优化；
搭建大规模步态数据集，实现量化的步态参数，利用大数据分析技术，提升模型的性能；
收集千变万化的环境和设备信息，实现模型的环境适应性，提高模型实际部署的可用性；
通过模型融合、鲁棒学习以及视觉识别技术，提升模型的抗干扰性，增强系统安全性能。

primitives in Solid

2022-12-19T11:48:49.000Z

signal

import { createSignal } from "solid-js";
const [getCount, setCount] = createSignal(0);

声明了一个响应式变量

console.log(getCount()); // 0
setCount(getCount() + 1);
console.log(getCount()); // 1

effect

import { createSignal, createEffect } from "solid-js";

const [getCount, setCount] = createSignal(0);
createEffect(() => console.log(getCount()));

会响应式地被触发

Pico CSS

2022-12-19T09:21:48.000Z

Pico.css • Minimal CSS Framework for semantic HTML

实用主义的css框架

（准备尝试从相对更注重通用性的unocss转到这上面来~

https://picocss.com/docs/we-love-classes.html

我觉得Pico.css的宗旨在于，class里应该写表达功能的词，把真正的样式写道<style>中去，而不是inline在class里长长一串

我现在觉得原子化css好在写得快，但其实可读性并不是最高的。

郑轲 2022

2022-12-16T08:08:04.000Z

制造业

2022.01.29 郑轲亲临悍高集团调研指导

1月29日，在春节来临之际，佛山市委书记郑轲一行亲临悍高集团调研指导，详细了解企业生产经营、春节假期安排、年度生产计划、安全生产等情况，鼓励企业合理安排生产计划，积极抢抓生产先机，增产增效、做大做强。

调研中，佛山市委书记郑轲一行参观悍高星际展厅，仔细询问产品研发、市场经营、品牌影响等。

郑轲书记认真听取欧锦锋董事长的汇报后，与欧锦锋董事长进行深入交流。

郑轲书记表示悍高产品具有非常大的市场潜力，勉励悍高继续做强做大，加强产品推广，让更多消费者知道悍高品牌和产品。

悍高的高速发展得到了郑轲书记的高度肯定，这将激发悍高上下以更加昂扬的精神状态和一往无前的奋斗姿态推动佛山高质量发展，用实实在在的成果展现新业绩新作为。

2022.01.30 郑轲走访慰问新闻媒体、福利院并调研检查农贸市场

1月30日，市委书记郑轲走访慰问新闻媒体、福利院并调研检查农贸市场，强调要用心用情做好各项服务保障工作，让市民群众度过一个平安欢乐祥和的新春佳节。

郑轲首先来到南方报业传媒集团佛山分社，深入了解佛山分社运营管理、新闻采编、队伍建设等情况，慰问春节期间采编值班人员，向大家致以新春祝福。他强调，要坚持党媒姓党，牢牢把握正确的政治方向、舆论导向、价值取向，深入宣传贯彻习近平新时代中国特色社会主义思想，唱响主旋律、壮大正能量、提振精气神。要大力推进融媒体建设，加快推动媒体融合发展，使主流媒体具有强大传播力、引导力、影响力、公信力，形成网上网下同心圆。要建设高素质专业化新闻舆论工作队伍，培养一批具有影响力的名编名记，深度宣传佛山、推介佛山，不断推出有高度、有深度、有温度、有力度的新闻报道。

随后，郑轲前往佛山传媒集团与快手科技公司联手打造的“有家就有佛山造——快手馆”，参观“潮玩佛山制造”南狮造型装置、短视频录制间、防疫机器人、企业自播孵化示范点，听取“有家就有佛山造——快手馆”线上线下项目进展情况汇报，慰问佛山传媒集团和快手科技公司值班人员，并与大家互动交流。他强调，要加强统筹协调，充分调动部门、媒体、企业和社会等各方力量，善用网络社交平台、电商平台优势，创新宣传推广形式，构建完善国内国际、内宣外宣、网上网下立体化传播矩阵，持续加强佛山企业及产品、佛山城市形象宣传推广，提升佛山制造的知名度、影响力和美誉度，让佛山制造享誉全球。

在惠景农贸市场，郑轲详细询问肉类、粮油、果蔬等农副产品供应和价格情况，检查疫情防控、食品安全管理和市场卫生，并关心了解商户的经营销售状况。他强调，要针对春节期间市场需求特点，做好产品保供稳价工作，落实好食品安全责任制，加强食品质量检测和流通环节监管，确保节日期间食品安全、供应充足、价格稳定。要时刻绷紧疫情防控这根弦，落实好常态化疫情防控措施，密切关注冷链食品进货渠道，做到进口冷链食品来源可查、去向可追。要注重农贸市场规划布局，加大农贸市场升级改造力度，促进农贸市场提档升级，打造食品安全卫生、环境清洁有序、市场管理精细、商户经营文明的百姓放心市场。

在南海区桃苑福利中心、南海区儿童福利院，郑轲详细了解老人、孩子们的生活照料、陪同服务、医疗保健等情况，向大家致以节日的问候，叮嘱工作人员带着感情、带着责任、带着爱心做好服务，让老人们生活幸福、健康长寿，让孩子们快乐生活、健康成长。他强调，要加强社会福利机构日常管理，不断完善软硬件设施，强化对供养服务对象的人文关怀和心理疏导，落细落实常态化疫情防控措施，营造安全舒适温馨的生活环境。要扩大养老设施供给，构建居家社区机构相协调、医养康养相结合的养老服务体系，让老年人老有所养、老有所医、老有所为、老有所学、老有所乐。要以仁爱之心、关爱之情做好生活、教育、医疗等服务，帮助孩子们树立自尊、自信、自立、自强的信念，引导他们健康快乐成长。

2022.03.13 佛山市企业家大会召开，在全省地级市中首设“企业家日”

佛山市委书记郑轲表示，市委、市政府将一如既往尊重企业家、呵护企业家、激励企业家，用一流营商环境润泽一流创业沃土，用最贴心的服务换来企业最顺心的发展，让每一位企业家都能在佛山安心创大业、放心做生意。

“你哋好！”会上，郑轲用粤语向与会企业家发出问候，引发现场热烈掌声。

“企业家是推动佛山企业由少到多、由小到大、由弱到强、由低端到中高端的头号功臣，是擦亮佛山制造品牌、叫响有家就有佛山造的擎天之柱。”郑轲说，佛山制造业之所以能形成今天的产业格局，企业家发挥了不可替代的作用。

他表示，广大企业家要政企同心、携手并进，把新发展理念落实到企业发展战略、经营管理的各方面各环节，在争当地级市高质量发展领头羊上展现新气象新作为。

此前，佛山根据立足新发展阶段、贯彻新发展理念、构建新发展格局、推动高质量发展的要求，谋划了“515”高质量发展战略目标。郑轲向广大企业提出号召，要把“515”高质量发展战略目标作为企业发展壮大的重要契机。

没有现代化的企业，就没有现代化的佛山。郑轲强调，佛山全市要站在同样的发展路径上，同心同力建设现代企业。要走好数字化智能化转型的路子，以更加积极的态度投入数字化智能化转型的时代浪潮；要走好土地高效利用的路子，积极推动存量低效土地提质增效；要走好现代企业治理的路子，健全完善企业的治理理念和治理机制。

2022.07.27 郑轲：高水平打造十大创新引领型特色制造业园区

佛山服务全省打造新发展格局战略支点，最大优势是制造业，最大抓手也是制造业。郑轲表示，佛山将深入学习贯彻省党代会精神，不折不扣落实“1+1+9”工作部署，坚持制造业立市不动摇，高水平打造十大创新引领型特色制造业园区，推动形成布局合理、定位清晰、特色突出、集聚有力的产业发展园区。

郑轲：省第十三次党代会是广东发展进程中具有里程碑意义的一次盛会。省党代会报告通篇贯穿习近平新时代中国特色社会主义思想，处处彰显了做到“两个维护”的坚定信念、扛起历史责任的宏大格局、咬定青山不放松的意志品质、坚持问题导向的务实作风、以百姓心为心的宗旨意识，精辟回答了广东今后五年怎么干、新的赶考之路怎么走等重大问题，是省委团结带领全省人民奋进新征程、创造新辉煌的施工图和任务书。

郑轲：改革开放是佛山的基因。佛山将始终保持改革创新的旺盛斗志，将全面深化改革进行到底，努力为全省改革探索经验，以改革新成效争当新时代改革开放示范。一是深化省级改革创新实验区建设。二是深化区域合作机制改革。三是深化营商环境滚动改革。四是深化国资国企综合改革。

郑轲：省党代会报告提出建设更具国际竞争力的现代产业体系，做实做强新发展格局战略支点。佛山服务全省打造新发展格局战略支点，最大优势是制造业，最大抓手也是制造业。从佛山的产业基础、产业结构、产业形态看，当前制造业高质量发展最重要的抓手、最迫切的任务，就是打造一批特色制造业园区。我们在市委十三届四次全会上系统谋划建设“十大创新引领型特色制造业园区”，以高水平园区引领制造业高质量发展，加快建设制造业创新高地。一是突出集聚发展。二是突出创新驱动。三是突出特色塑造。四是突出政策支持。

学习贯彻省党代会精神，当前最重要的就是统筹疫情防控和经济社会发展、统筹发展和安全。上半年，我们坚持稳字当头、稳中求进，推动经济保持平稳健康发展，全市完成地区生产总值5747.79亿元，同比增长2.8%。下半年，我们将继续从政策落地、项目建设、企业服务等方面协同发力，力争推动经济实现较好上升，以佛山的“稳”服务全省发展大局的“稳”。一是狠抓政策落地解难题。二是狠抓项目建设增后劲。三是狠抓企业服务添动能。

2022.08.24 郑轲到禅城区调研纺织产业发展情况

8月23日，佛山市委书记郑轲到禅城区张槎街道产业园区和企业调研，考察了解佛山纺织产业发展情况，倾听企业发展诉求和意见建议，引导企业保持战略定力、增强发展信心，推动纺织产业实现高质量发展。

郑轲首先来到华创亿锋数字化智造产业基地，听取产业园规划设计、建设进展、招商引资等情况介绍。他表示，禅城区要加强统筹协调，优化园区空间布局，推进土地连片开发，引导纺织产业集聚发展。要主动服务、靠前服务，积极帮助解决项目建设过程中遇到的困难，推动项目早竣工、早投产、早达效。

随后，郑轲来到中恒纺织交易市场（广东）有限公司，与公司负责人深入交流，详细了解企业经营管理、平台运作、市场开拓等情况。他表示，“传统”不是纺织行业的负担，而是优势，高品质纺织是人民高品质生活的重要条件，亦是市场不会衰落的产业，广大纺织企业要加速创新、转型升级，不断开发新技术、新产品、新工艺，巩固提升佛山纺织产业的行业影响力。

郑轲强调，纺织产业是佛山的优势传统产业，基础好、韧性足、有前景，各区各相关部门要从思想上高度重视纺织产业发展，坚定不移支持纺织产业发展。要加快纺织产业数字化改造、智能化生产，加强技术创新和产品创新，提高原创设计开发能力和经营管理质效，推动纺织产业向价值链中高端跃升。要推动纺织产业全链条发展，扶持培育行业龙头企业，积极开展全产业链招商，构建集研发设计、装备制造、批发仓储、营销服务于一体的现代纺织产业体系。要坚持质量提升、品牌带动，引导纺织企业实施品牌战略，通过品质提升打造知名品牌，着力培育一批具有广泛影响力的自主品牌。要倾力帮助企业纾难解困，强化用地、用能、资金等生产要素保障，用贴心暖心、高质高效的服务为纺织企业发展保驾护航。

2022.09.27 市领导与企业家、高层次人才代表座谈：激励企业家和人才放胆干放手干放心干

郑轲表示，佛山广大企业家和人才有胆识、有情怀、有格局，特别是在疫情冲击和经济下行压力之下，始终与党委政府同心携手、共克时艰，为佛山经济社会发展作出了积极贡献。佛山是一片创新创业的热土，希望广大企业家和高层次人才准确把握当前经济发展形势，坚定发展信心、抢抓市场机遇，继续扎根佛山、深耕佛山，保持干事创业的激情和活力，放胆干、放手干、放心干，在经济发展主战场施展才华，与佛山共同成长、相互成就。

郑轲强调，要强化企业和人才服务，打造一流营商环境，构建“益晒你”企业服务体系，建立“十个没有”的亲清政商关系，大力营造尊商敬才、开放包容的良好社会氛围，让广大企业家和人才在佛山安心创业、舒心发展。要打造更多企业家和人才干事创业的平台，加快构建“中部强核、东西两带、南北两圈”产业布局，高水平建设十大创新引领型特色制造业园区、十大现代服务业产业集聚区，深入推进制造业数字化智能化转型，推动传统产业与战略性新兴产业协同发展，为企业家投资创富、人才施展才华提供广阔舞台、创造更多机会。

2022.12.05 郑轲：“坚持制造业当家，让佛山制造‘基业长青’”

郑轲表示，下一步，佛山将始终坚持制造业当家，构建以先进制造业为支撑的现代产业体系，全力推动“制造大市”向“制造强市”迈进，让佛山制造“基业长青”。同时，紧紧抓牢科技和人才两大最宝贵财富和最核心竞争力，打造高水平人才高地创新高地。此外，推进文化自信自强，大力实施争当传承岭南广府文脉领头羊三年行动，繁荣发展文化事业文化产业，持续焕发岭南广府文化新活力。

教育

2022.06.01 郑轲出席佛山市东平小学少先队“六一”主题队日活动暨新队员入队仪式

6月1日，市委书记郑轲出席“喜迎二十大争做好队员”佛山市东平小学少先队“六一”主题队日活动暨新队员入队仪式，并向小朋友们赠送书籍，代表市委、市政府向全市广大少年儿童致以节日问候，向新入队的少先队员们表示热烈祝贺，向在一线辛勤工作的广大教师和少儿工作者致以崇高敬意，

郑轲强调，全市各级党委、政府要站在党和国家事业薪火相传的高度，重视支持少年儿童事业，为少年儿童茁壮成长创造更好条件。广大教师和少儿工作者要铭记教书育人使命，用心用情促进少年儿童健康成长。学校、家庭和社会各方面要密切协作，共同把祖国的花朵呵护好、教育好、培养好。

2022.07.11 郑轲一行来广东舞蹈戏剧职业学院

7月11日，佛山市委书记郑轲一行来校调研指导工作，调研组参观我校粤剧教育展览馆，到文体馆观看课堂教学展示，前往戏剧服装室查看服饰、蟒袍等珍贵藏品，参观了校园并了解校园发展规划事项。佛山市委常委、宣传部部长倪谦，市委常委、秘书长葛承书，市委政研室主任贺文平、市教育局局长管雪、市文广旅体局局长陈新文，佛山市南海区委副书记李伟成、南海区委常委吕园园、南海区教育局局长钟文川等陪同调研。学校党委书记韩安贵、校长尹新春参加了调研。

学校党委书记韩安贵代表学校师生对郑轲书记前来调研指导工作表示欢迎和感谢，学校领导向调研组详细介绍学校的办学情况，并感谢佛山各级党委政府及职能部门一直以来对学校发展的关心和支持，学校不断强化“在地意识”，坚持面向佛山、扎根佛山、服务佛山，努力为佛山经济社会发展提供人才支撑。

郑轲书记对学校的办学成绩表示充分肯定。他希望学校围绕地方经济社会发展需要，调整优化学科专业布局，根据实际积极增设服务当地产业的紧缺专业，增强服务地方经济社会发展和创新驱动发展的能力，希望广大教师主动投身佛山市经济社会发展建设，地方党委、政府将一如既往支持学校建设发展。

2022.10.08 郑轲到佛山科学技术学院召开年轻干部座谈会

郑轲强调，佛山市委市政府坚定不移地支持佛山科学技术学院建设高水平大学，集中力量集中资源支持学校的发展。他指出，学校的发展要紧扣佛山经济社会发展，作为一所高校，在科技创新方面要担当重任。作为高校的年轻教师要得到很好的发展，特别是能力、水平的提升，一定要了解佛山城市定位、产业发展和人才需求。结合佛山城市定位，郑轲详尽解读了市第十三次党代会部署的“515”高质量发展战略目标所蕴含的新发展理念，塑造新发展形态的思路，科技创新及干部队伍建设等重大问题。

防疫

2022.09.04 郑轲到佛山科学技术学院调研检查疫情防控工作

9月4日，市委书记郑轲到佛山科学技术学院调研检查疫情防控工作。郑轲来到佛山科学技术学院仙溪校区，详细了解返校学生核酸检测、校园出入管理、日常防疫工作开展等情况。他强调，要强化师生和校园工作人员健康监测管理，严格出入校园人员管理，把防控责任落实到教学、管理、后勤等每一个岗位，督促大家提高防控意识、做好自我防护，筑牢校园疫情防控严密防线。

郑轲强调，学校疫情防控事关师生身体健康和生命安全，事关千家万户和防疫大局，各级各相关部门要提高政治站位，强化责任担当，以对学生、对家长、对社会高度负责的态度，抓紧抓实抓细校园疫情防控工作。要坚持“人、物、环境”同防，把好门、管好人、备好勤，严格执行测温验码、佩戴口罩、定期核酸检测等防控措施，扎实做好校园各环节、各部位疫情防控工作，坚决防止发生聚集性疫情。要加强师生员工日常管理，落实并完善师生健康状况、出行情况申报与核查机制，细致做好学生心理辅导、教育引导等工作，强化校园后勤服务保障，努力为师生营造良好的学习生活环境。要严格落实“四方责任”，加强对学校疫情防控工作的督导检查，压实学校疫情防控主体责任，动态完善疫情防控应急预案，细化各项疫情防控措施，提高疫情防控的科学性、精准性和有效性，确保广大师生健康安全、教育教学井然有序。

2022.10.29 郑轲到南海区和顺德区调研检查疫情防控工作

10月29日，佛山市委书记郑轲到南海区和顺德区调研检查疫情防控工作，强调要把忠诚拥护“两个确立”、坚决做到“两个维护”体现到打赢当前疫情防控这场硬仗上来。佛山市政协主席李政华参加调研检查。

郑轲先后到南海区和顺德区，深入管控区域重点场所、重点部位，详细询问了解风险人员管控、防控措施落实、物资供应保障、心理疏导服务等情况。他强调，要严格落实风险区域和临时管控区域分级分类管理措施，坚持人、物、环境同防，加强人员闭环管理、核酸检测和健康监测，及时清运处理生活垃圾，无死角开展环境消杀，安全有序、严密高效把各项防控措施落到实处。要细致做好管控区域生活物资、就医用药等服务保障，着力解决好独居老人、婴幼儿、孕妇、危重病人等群体特殊需求，用心用情开展心理疏导工作，备好救护车、消防车等特种车辆，让群众放心安心，更好地支持配合疫情防控。要高效统筹疫情防控和经济社会发展，指导企业落实疫情防控主体责任，以更优的服务、更高的效率帮助企业纾困解难，千方百计保障企业正常生产经营，做到疫情防控和生产经营两手抓、两不误。要充分发挥各级党组织的战斗堡垒作用和广大党员的先锋模范作用，在抗疫一线展现担当作为，团结带领群众做好防护、同心抗疫，做到制度执行到位、责任明确到位、措施落实到位，齐心协力打赢疫情防控这场硬仗。

督察

2022.07.21 郑轲一行来生态环境部华南督察局交流工作

郑轲介绍了近年来佛山市推进中央生态环境保护督察整改工作总体情况。他表示，佛山市将贯彻落实习近平生态文明思想作为重中之重，大力推进中央生态环境保护督察整改。去年第二轮督察指出佛山市污水管网管理不善、缺口较大问题后，佛山市制定方案，以“全流域治理”“强统筹推进”“大兵团作战”“分层次实施”为工作原则，计划到2025年投入560亿元，推动佛山实现水环境质量大提升。同时，生活垃圾无害化处置工作也得到积极进展，全市生活垃圾焚烧率已达到90%以上。他代表佛山市对华南局一直以来关心、支持佛山市生态文明建设和生态环境保护工作表示感谢。

2022.07.26 郑轲督查全国文明城市创建工作

7月26日，广东省佛山市委书记郑轲到禅城区祖庙街道，深入城市社区、农贸市场、背街小巷，督导检查文明城市创建工作，强调要深入学习贯彻习近平总书记关于精神文明建设的重要论述，以更大力度、更实举措深化文明城市创建，争创全国一流文明城市。

郑轲强调，文明城市创建是一项重要民生工程，事关城市形象、事关营商环境、事关民生福祉。全市各级各部门要切实把思想和行动统一到市委、市政府的部署要求上来，以时不我待、只争朝夕的责任感和紧迫感，高质量推进文明城市创建工作。要加强环境整治，瞄准薄弱环节和问题短板，突出抓好背街小巷环境脏乱差、消防设施缺失、车辆乱停乱放等问题整改，改善群众居住环境，让人民群众在文明创建中得到更多实惠。要加强城市治理，以绣花功夫推进城市精细化管理，全面推进“沿路两边、高架桥下”环境整治及景观提升，深入实施城市“畅通工程”，加强城市道路、街巷、市场等规划管理，加大垃圾收集清运管理力度，着力提升城市形象和功能品质。要加强宣传引导，采取形式多样的方式广泛发动群众、组织群众，全方位培养群众良好生活习惯，营造文明城市创建人人有责、人人参与、人人共享的浓厚氛围。要加强责任落实，压实属地责任，强化巡查监管，推动各项文明创建措施落到实处，持续巩固创建成果、提升创建水平。

2022.07.27 郑轲到佛山军分区开展“八一”慰问活动：共谋军地融合发展

在中国人民解放军建军95周年即将到来之际，7月27日，佛山市委书记郑轲到佛山军分区看望慰问部队官兵，与部队官兵代表座谈交流，共叙军民鱼水情深，共谋军地融合发展。

郑轲代表市委、市政府和全市人民向驻佛山人民解放军指战员、武警部队官兵、民兵预备役人员致以节日祝贺和诚挚慰问。他说，广大驻佛山部队官兵深入学习贯彻习近平强军思想，全面贯彻新时代军事战略方针，积极参与和支持佛山经济社会发展，在疫情防控、抗灾抢险、应急处突等重大任务中冲锋在前，彰显了人民军队为人民的良好形象，赢得了全市人民的广泛赞誉。

郑轲强调，当前，全市上下正在坚决贯彻落实习近平总书记关于“疫情要防住、经济要稳住、发展要安全”的重要指示要求，紧扣迎接党的二十大胜利召开这条主线，全力以赴防疫情、稳经济、保安全。希望驻佛山部队官兵坚持以习近平强军思想为指引，忠诚拥护“两个确立”，坚决做到“两个维护”，传承光荣传统、弘扬战斗精神，在抓好练兵备战的同时，积极投身佛山改革发展稳定各项工作。全市各级各部门要全力支持国防和军队建设，全面做好拥军优属工作，不折不扣落实各项优抚政策，用心用情帮助解决实际问题，让广大官兵不为后路担心、不为后院分心、不为后代忧心，加强军政军民团结，开创佛山双拥工作新局面，以优异成绩迎接党的二十大胜利召开。

2022.09.30 佛山市委书记郑轲带队开展国庆节前消防督导检查

郑轲带队到顺德区北滘镇开展国庆节前消防督导检查，强调联合督导组要深入学习贯彻习近平总书记重要指示精神，切实提高政治站位，督导包保镇街落细落实疫情防控、安全生产和消防安全各项措施，让人民群众度过一个平安祥和的国庆假期。

在佛山市盈特金属制品有限公司，郑轲书记详细了解企业生产经营情况，并检查企业疫情防控、安全生产和消防安全工作。他强调：企业要严格落实疫情防控、安全生产和消防安全主体责任，从严从细排查风险隐患，加强员工安全生产规范管理和教育培训，落实好疫情防控各项措施，以安全促生产、保发展。

随后，郑轲书记主持召开座谈会，听取联合督导组进驻北滘镇工作开展情况，北滘镇疫情防控、安全生产和消防安全情况汇报。他强调：

· 联合督导组要扎实开展疫情防控、安全生产和消防安全督导检查，细致全面排查整治各类风险隐患，确保社会大局平安稳定。

· 要担起责任、集中精力，把疫情防控、安全生产和消防安全作为当前最紧要的工作来抓，做到制度执行到位、责任明确到位、措施落实到位。

· 要深挖风险、聚焦问题，坚持脚往下走，深入村居、企业、工地等一线实地检查，做到目光如炬、心细如丝，紧盯道路交通、建筑施工、危大工程、城镇燃气、消防安全等重点行业领域，善于发现苗头性问题，努力把风险隐患解决在未萌之时、成灾之前。

· 要转变作风、注重服务，开展督导检查不得增加企业负担、不能影响企业正常生产经营活动，本着服务企业的原则帮助发现问题、解决问题，用心指导企业落细落实疫情防控、安全生产和消防安全措施。

· 要团结协作、精诚配合，把各部门力量调动起来、凝聚起来，坚持每日研判、每日会商、每日调度，发现风险隐患迅速拉清单、做整改，形成抓疫情防控、安全生产和消防安全的强大合力。

联系群众

2022.10.08 佛山市委书记郑轲到市信访局调研并接访群众

接访前，郑轲听取了该信访事项的汇报，详细了解询问了有关情况。随后，郑轲接待了2名信访群众代表，与群众进行了亲切友好的沟通交流。郑轲强调，各级各部门在发展过程中要保障好群众权益，要认真听取群众百姓意见，切实担起为民解难的责任。当前受新冠疫情影响各行业领域都面临困难，各级各部门要加强与群众沟通、争取理解支持，想方设法妥善解决问题、保障好群众权益，共同维护良好秩序和稳定环境。

福利

2022.01.30 郑轲走访慰问南海桃苑福利中心

1月30日，佛山市委书记郑轲走访慰问南海桃苑福利中心，强调要用心用情做好各项服务保障工作，让老人和孩子们度过一个平安欢乐祥和的新春佳节。

在南海区桃苑福利中心、南海区儿童福利院，郑轲详细了解老人、孩子们的生活照料、陪同服务、医疗保健等情况，向大家致以节日的问候，叮嘱工作人员带着感情、带着责任、带着爱心做好服务，让老人们生活幸福、健康长寿，让孩子们快乐生活、健康成长。

他强调，要加强社会福利机构日常管理，不断完善软硬件设施，强化对供养服务对象的人文关怀和心理疏导，落细落实常态化疫情防控措施，营造安全舒适温馨的生活环境。要扩大养老设施供给，构建居家社区机构相协调、医养康养相结合的养老服务体系，让老年人老有所养、老有所医、老有所为、老有所学、老有所乐。要以仁爱之心、关爱之情做好生活、教育、医疗等服务，帮助孩子们树立自尊、自信、自立、自强的信念，引导他们健康快乐成长。

政务

2022.01.06 郑轲出席人大代表、政协委员会议

1月6日，佛山市召开市人大代表、政协委员会议，深入学习贯彻习近平新时代中国特色社会主义思想，贯彻落实党的十九届六中全会和省委十二届十五次全会精神，进一步深化认识、统一思想、凝聚共识，推动市人大代表、市政协委员高质量完成市两会各项议程。市委书记郑轲出席会议并讲话，市长白涛主持会议，市人大常委会主任胡钛、市政协党组书记李政华、市委副书记徐晓霞出席会议。

郑轲代表市委对全市人大代表、政协委员为佛山经济社会发展作出的积极贡献表示感谢。他强调，要深入学习贯彻党的十九届六中全会精神，从党的百年奋斗重大成就和历史经验中汲取智慧和力量，进一步增强拥护“两个确立”，践行“两个维护”的政治自觉、思想自觉、行动自觉。要完整准确全面贯彻落实新发展理念，在全社会推动形成贯彻新发展理念的思维方式、话语体系、行为惯性，把佛山高质量发展的路子走对走实走好，用新发展理念塑造佛山发展新形态、再创佛山发展新优势。要坚定不移用好改革“关键一招”，始终把改革作为推动高质量发展的重要动力，推动佛山改革发展事业继续走在前列。要贯彻落实市第十三次党代会精神，锚定“515”战略目标精准发力，推动各项工作部署加快落地落实，奋力争当地级市高质量发展领头羊。

郑轲强调，要坚持和加强党对人大、政协工作的全面领导，充分发挥人大代表、政协委员作用，不断开创人大、政协工作新局面。各级人大、政协要深入学习贯彻习近平新时代中国特色社会主义思想，学习好、领会好、运用好习近平总书记教给的世界观、方法论，切实用工作成效彰显习近平新时代中国特色社会主义思想的真理力量和实践伟力。要坚持把党的领导贯穿人大、政协工作全过程，确保各项工作始终在党的领导下进行。要进一步推动代表委员发挥作用，发挥人才汇聚、智力密集、联系广泛的优势，努力在围绕中心、服务大局上展现更大作为。要持续提升代表、委员履职能力，积极为代表、委员履职创造良好条件，确保政治有地位、建言有机会、出力有舞台。

2022.01.19 郑轲被推选为佛山代表团团长

1月19日上午，广东省第十三届人民代表大会第五次会议佛山代表团全体会议在广州白云国际会议中心召开。会议推选省人大代表、佛山市委书记郑轲为佛山代表团团长。

2022.07.31 佛山市党政代表团来我州考察并出席东西部协作党政联席会议

7月31日至8月1日，佛山市委书记郑轲率佛山市党政代表团来我州考察并出席东西部协作党政联席会议。州委书记罗强出席并讲话，州委副书记、州长安九熊主持会议。

7月31日，黔东南州·佛山市东西部协作党政联席会议在凯里召开。郑轲在会上表示，佛山将深入学习贯彻习近平总书记关于深化东西部协作的重要指示精神，忠诚拥护“两个确立”，坚决做到“两个维护”，推动党中央决策部署和粤黔两省的工作要求落地落细，以优异成绩迎接党的二十大胜利召开。要强化战略合作，围绕“黔东南所需、佛山所能”，发挥好桥梁纽带作用，全力支持黔东南州打造对接融入粤港澳大湾区“桥头堡”，推动两地协作迈向更深层次、更高水平、更宽领域。要强化协同联动，聚焦重点任务靶向发力，抓园区共建促产业协作，抓稳岗就业促劳务协作，抓产销衔接促消费协作，推动“组团式”教育、医疗帮扶扩面提质，筑牢共同富裕的坚实基础。要强化责任落实，锚定年度目标，在帮扶机制、协作方式、对接渠道、经验创造上不断拓展，做到年年深化；聚焦协作任务尽心竭力、稳扎稳打，干一件成一件，做到事事用心；广泛发动社会各界力量积极参与，深化结对帮扶，做到人人出力；前方工作组要与当地干部群众打成一片，感情上情投意合，生活上入乡随俗，工作上同频共振，作风上严而又严，做到心心相印，携手把东西部协作各项任务落到实处。

期间，佛山市党政代表团还先后深入丹寨县石桥村、麻江县蓝莓精深加工厂以及台江县民族中学、民族中医院、中等职业学校、人民医院，实地考察乡村振兴、产业发展、园区建设、教育医疗帮扶等情况。

2022.08.05?

“要认识到强组织是最有力量的保障。”市委书记郑轲在佛山市2022年第一次重点项目建设观摩会上强调。市代建项目管理中心（以下简称市代建中心）起而行之，全面迅速贯彻落实市委市政府的决策部署，党建先行、同向发力，将党旗插在项目建设第一线、支部建在项目一线，通过“党建+”凝聚干事创业合力，扎实推进项目建设。全部在建项目均成立了临时党支部，实现全覆盖。

2022.11.05 郑轲主持召开市委常委会会议

11月4日，市委常委会召开会议，专题学习党的二十大精神，传达学习习近平总书记在中央政治局会议、中央政治局第一次集体学习时的重要讲话精神，在瞻仰延安革命纪念地、在陕西延安和河南安阳考察时的重要讲话精神，以及省委常委会会议精神，研究我市贯彻落实意见。市委书记郑轲主持会议。

2022.11.14 佛山举行学习贯彻党的二十大精神省委宣讲团宣讲报告会

11月11日，佛山市举行学习贯彻党的二十大精神省委宣讲团宣讲报告会暨全市正处级主要领导干部学习贯彻党的二十大精神专题研讨班开班式。省委宣讲团成员、华南师范大学马克思主义学院院长陈金龙作宣讲报告。佛山市委书记郑轲主持会议并作开班动员讲话。市委副书记、市长白涛，市人大常委会主任胡钛，市政协主席李政华出席会议。

郑轲指出，学习宣传贯彻党的二十大精神，是当前和今后一个时期的首要政治任务和全部工作重心。全市各级各部门要深入学习领会党的二十大精神，紧紧围绕习近平总书记提出的“五个牢牢把握”重要要求，在全面学习、全面把握、全面落实上下功夫，切实把思想和行动统一到习近平总书记、党中央决策部署上来。要发扬优良学风，做到自觉主动学、原原本本学、融会贯通学、联系实际学，推动学习宣传贯彻党的二十大精神往深里走、往心里走、往实里走。

郑轲强调，要坚持学思用贯通、知信行统一，紧密结合佛山实际抢抓发展机遇，把党的二十大作出的重大决策部署付诸行动、见之于成效。要从报告关于以中国式现代化全面推进中华民族伟大复兴的决策部署中抢抓机遇，紧扣中国式现代化的丰富内涵和实践要求想问题、谋工作、作决策，在新征程中把握大势、乘势而上。要从报告关于推动高质量发展、建设现代化产业体系的决策部署中抢抓机遇，坚持把发展经济的着力点放在实体经济上，坚持制造业当家。要从报告关于实施产业基础再造工程和重大技术装备攻关工程的决策部署中抢抓机遇，以建设“双十园区”为抓手，推动传统优势产业和战略性新兴产业集聚发展，加快制造业数字化智能化转型。要从报告关于深入推进改革创新的决策部署中抢抓机遇，持续优化营商环境，巩固深化国资国企改革成果，积极推进企业上市倍增计划，引导企业健全现代企业制度。要从报告关于实施科教兴国战略、强化现代化建设人才支撑的决策部署中抢抓机遇，建立健全高质量教育体系，扎实推进“一区一园一城”建设，加快建设高水平人才高地、创新高地。要从报告关于推进城乡融合和区域协调发展的决策部署中抢抓机遇，探索解决发展不平衡不协调问题的有效路径，完善区域协作机制，优化区域产业布局。要从报告关于推动绿色发展的决策部署中抢抓机遇，加快全流域强统筹大兵团分层次治水，推进各类资源节约集约利用，大力发展循环经济。要从报告关于坚持人民至上的决策部署中抢抓机遇，加强重大疫情防控救治体系和应急能力建设，落实好优化调整防控措施，守护好人民群众生命安全和身体健康。

2022.11.29 郑轲受市第十三次党代会主席团委托主持会议

11月29日下午，中国共产党佛山市第十三届委员会第一次全体会议举行。郑轲受市第十三次党代会主席团委托主持会议。

出席会议的市委委员74人，候补委员14人。市纪委委员列席了会议。

全会选举产生了中国共产党佛山市第十三届委员会常务委员会委员和书记、副书记。郑轲、白涛、徐晓霞、陈小坚、梅河清、郑海涛、倪谦、葛承书、刘智勇、丁锡丰、黄海龙当选为市委常委，郑轲当选为市委书记，白涛、徐晓霞当选为市委副书记。

2022.12.08 郑轲当选市委书记

郑可，男，汉族，1966年9月出生，大学学历，中共党员，当选为佛山市委书记。

关于dns-prefetch和preconnect

2022-12-14T14:56:57.000Z

可以写到 headers 里的Link里：https://developer.mozilla.org/zh-CN/docs/Web/HTTP/Headers/Link
dns-prefetch真的就是只查询 DNS 解析，而preconnect还要建立连接，所以会更激进一点（也有可能带来浪费）
dns-prefetch的浏览器普及性更好
MDN 上的介绍

2022-10-11

2022-12-13T07:47:59.000Z

今天发现了对我来说博客最佳的解决方案——语雀API

访问频率限制大概相当于

匿名访问（相当于不登录浏览）约每分钟3次
登录访问（主要是本地编辑同步）约每秒1次

双向同步

可以从云端get到的东西：DocDetailSerializer
- body字段：正文的markdown格式
- body_html字段：相当于导出的html（不含代码高亮）
- body_lake字段：语雀lake格式
只能单向同步：在语雀端编辑的文档会被转化成lake格式

更新文档的时候：

_如果在页面编辑过文档，那这时文档会转成 lake 格式，如果再用 markdown 无法进行更新，这是需要添加 ___force_asl = 1__** 来确保内容的正确转换。**_

总之最后可以做单向的同步，从云端不停地拉到本地（每秒能拉一次😂）

然后博客是从Svelte前端访问（由于语雀的授权与鉴权机制，token天生地带有授权项而且很方便修改，我觉得甚至其实可以把token直接放在 page.js 中）

我觉得还可以加一个在 xindex 中实现了的缓存（在用户端的SPA页面内容缓存和在服务端的get文档内容的TTL缓存）

CSR的问题

2022-12-12T11:23:06.000Z

在网页直接请求语雀 API 不被允许：报跨域错误：

CORS error: No 'Access-Control-Allow-Origin' header is present on the requested resource

解决方案：

排除的方案：用一个后端去请求语雀 API. 但这样等于白用 Serverless 架构了
目前采用的方案：把+page.js都改成+page.server.js，所有对语雀 API 的请求都在服务端进行。但是像我这样部署在 Vercel 上的话，就会造成数据从国内到国外再回国内一共跑两次。不划算
可能的优化：给在 Vercel 部署的应用的域名套一个 CDN，但这样本质上并没有加快，虽然减少了对 Vercel 的请求，还增加了 CDN 的费用，而且这样的速度是靠实时性换的（虽然对博客来说实时性也不太重要）
准备采取的方案：给语雀 API 套一个 CDN，在 CDN 配置里写上 token，然后就可以 CSR 了。相当于是把方案一改成了用现有的云服务搞定了。我觉得这很符合 Serverless 的哲学🌹

using Fira Code

2022-12-12T08:11:50.000Z

https://github.com/tonsky/FiraCode#browser-support

<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/firacode@6.2.0/distr/fira_code.css">

/* Specify in CSS */
code { font-family: 'Fira Code', monospace; }

@supports (font-variation-settings: normal) {
  code { font-family: 'Fira Code VF', monospace; }
}

Muspi Merol

给博客图片自动补上了 dimensions

override <img>

为什么我没有继续在运行时搞

build-time 收集

image-size 之外，我还顺手把请求这一层补完整了

超时

重试

并发

我用到的语雀 API 其实很少

这个脚本里其实还有个我顺手手搓的 TUI

生成的尺寸表

结语

给 CPython 擦屁股

实现

无心插柳柳成荫

隐患与惊喜并存的 .pth

.pth 是干嘛的

好的用途

一个坑

总结一下

踩了 getsource 的坑……

解决方案

为什么不用静态分析来实现 HMR

问题

我们的运行时方案

原理

结语

Dependabot 不支持 YAML aliases

Astral 终于也来分 pyright 一杯羹了

谈谈推理模型的局限

关于 feed 的一些想法

解决 Dependabot 生成 broken uv.lock 的问题

鲁棒地编码

Don't Repeat Yourself

以 bump version 为例

lockfile 的例子

认知复杂度

弱主张

关于 HMR 的实现

怎么实现的

Reactive namespace

一些细节

Reactive module

Module finder & loader

Reload

Memoized

结语

反应式编程，但是 Python

Python venv injection

IPython 的解决方案

更好的解决方法

隐患

关于我给博客加了 llms.txt 以及我的数字永生计划

试用了一下

快要被 createMemo 搞疯了

linter docs 作为训练集

如何写出好代码

实现了 Python 的 HMR

实现一个类型安全的 (f1, f2) -> f2(f1()) 函数

例子：序列化并用 bzip2 压缩

但是类型呢？

泛型

如果 first()有参数呢

后话：为什么做这个

给博客加了个 giscus

Python 读取 jsonl 的最佳实践

但是！

快多少

为什么

思考题

参考答案

准备做一些 MCP 相关的项目

OOP 何必是 COP

m ask 支持 markdown 流式渲染了

一言不合就 fork

再谈一谈 Svelte 5

感觉 gpt 的 vision 能力不太行

Fork 了 PythonMonkey

实现

override `<img>`

`image-size` 之外，我还顺手把请求这一层补完整了

如果 `first()`有参数呢

`console.log`不方便

`port`不好拿

新简历起草

《大数据分析》笔记