Luyu Cheng

Recently

Thu, 16 Sep 2021 15:30:36 GMT

I’ve been in Hong Kong for 20 days.

The beginning days are always painful, strenuous, but contended. I made many new friends. They come from a variety of places. I met my supervisor (in the flesh, finally). I started learning a dozen of things. Furthermore, I also spent a lot of money.

Purchasing

I bought Types and Programming Languages and started reading it regularly. In the beginning, I planned to read it every day. But soon I found it impossible, so I’m trying to review it thrice a week.

I purchased LG UltraFine 5K. It’s good, but not perfect as I’ve expected. If I could travel to the past, I will definitely advise myself not to buy.

I preordered iPad mini 6. It’s very intriguing that almost every student (even some teachers) have some mobile device (no matter iPad, Surface, or other tablet) that support stylus. So, I’d give it a try.

Reading

I haven’t started reading yet. I borrowed some books from the university library. The university library is richer than I’ve expected. When I was studying in my previous institution, I was once frustrated by the lack of original copy of books in the library. I wish I could start reading them at the earliest.

Listening

I’ve been rotating on my old playlists for a long time. Before I sleep, I listen to Sleep Sounds playlist from Apple Music. After I get up, I listen to FKJ’s live. The only new artist I discovered is Ghostly Kisses. I like her voice and the music video of Don’t Know Why. I could gain some inner peace when listening to her voice.

Photography

I almost did nothing because I feel no desire about photography recently. But I still took something worth posting here.

Watching

There is nothing to say about watching. I’ve been in a mood that I have no patience on watching any movies and videos. My YouTube history is full of music videos and lives. I don’t know why exactly this happens.

But I keep watching online courses produced by Keenan Crane. He is excellent at making beautiful compute science figures. Last year, he had been publishing his lecture videos of his computer graphics and discrete differential geometry courses.

See you next time.

A Tour of Implementing TAPL in Scala

Thu, 01 Jul 2021 14:40:44 GMT

Last week I implemented sub-type algorithms in Rust and put the source code on GitHub. In this week, I rewrite the project with Scala, because I am going to work in Scala. This post is not a step-by-step explanation of the project, but more like a topic-based notes during the implementation.

Singleton Object

A newly created Scala project has code like this.

object Main extends App {
  println("Hello, world!")
}

I have several questions in my first glance.

What the heck is Main? Is it an object, or a type (class)?
Why and how could Main extend App?
Why println can be placed in Main? Does Main works like a function?

Here are my answers.

Main is an object. It is categorized as a value. It is not a type. You can try this.
```
def test(main: Main) = 0 // not found: type Main
```
I think Main has a hidden and inaccessible type. Let’s call it T. So it actually means that T extends App. In this way, Main has everything in App.
This is syntax inherited from classes, I think. Each class declaration is actually a constructor declaration (I think Kotlin learned from this). In the primary class constructor, people can put method declarations, statements and expressions.

Another interesting yet familiar thing is companion object. It means you can create a singleton object called the same name of a class. I heard that static methods in Scala are mostly done in this way.

While Statements

I will make an REPL. So I need something like

while (true) {
  line = readLine()
  reply(line)
}

Soon I found Scala is a expression-based language, so while expressions are typed. And they are typed to Unit since the halt problem. That’s okay.

Then, how about break and continue? To my surprise, they are not included in the language. I read the Scala Book but I didn’t notice this point. I found scala.util.control.Breaks, but it seems be implemented with exceptions.

Scala Standard Library 2.13.3 - scala.util.control.Breaks

So I put the while expression in a method and use return instead. Here is the skeleton of the REPL.

object Main extends App {
  val context = new Context()

  def repl: Unit = while (true) {
    val command = readLine("> ")
    command match {
      case "exit" => return
      case command => println(command)
    }
  }

  println("Welcome to TAPL Scala!")
  repl
}

Deal with `Option`

I’m dealing with Option in Scala. There are few ways I know so far.

Pattern matching. x match { Some(y) => z None => a }.
Methods from Iterable. Because Option is actually a container of a single value, so what people can do with Iterable also works here.
Some specific methods. Like getOrElse, isEmpty, isDefined.

Derive with Exceptions

When type inference fails, we need to handle errors. In my Rust implementation, errors are contained by Result<TermType, String>. Rust offers some syntactic sugars dealing with them, for example, if the return type of surrounding function is also the same Result type, appending an ? to the expression will return the error part if it is an Err, just like the lift in Monad.

In Scala, we can use exception, just like how we do it in Java. Therefore, we need custom errors. I found a solution on StackOverflow: Custom Exception in scala.

Operator Overloading

Because I was learning the book Types and Programming Languages. I wanted to define <: as the “is subtype of” operator. Soon I found this is impossible because <: is reserved as the sub-type operator. Therefore, I chose <:: as the operator.

Operator overloading is easy in Scala. The syntax does not differ from defining functions.

trait Type {
  override def toString: String
  def <::(that: Type): Boolean
  def ==(other: Type): Boolean
}

But, I found another problem. When I test the expression if true then {} else { a: 0 }, the result type is Record { a: Int }. What the heck? I thought I messed up some order, for example, reversing the order of if branches or something like that. But the logs indicate that a <:: b is actually equivalent to b.<::(a). Hmm, interesting.

I started searching in Scala documentation and Scala Book, but they told me nothing. Soon I found the answer in Scala specifications. I like reading specifications, because they are mostly well-structured so I can locate what I want immediately. I remembered I read ECMA-262 for thousands times because it is the only document telling me what’s really happening in the execution context.

Okay, let’s back to the topic. Here is what I found from this page: Expressions.

The associativity of an operator is determined by the operator's last character. Operators ending in a colon `:' are right-associative. All other operators are left-associative.

Because I don’t want to change my code too much, I just rename the operator :<. It looks like an unhappy face. Just like my mood. (I’m just joking.) I have to manually rename the operator because Metals says it will break my code. Even if I had replace all occurrences of infix notations with member function notations.

Finally, everything about operator overloading is done.

Parsing Rules

In the Rust implementation, I use LALRPOP, which generates Rust code at the build time from a DSL. Because it uses LALR, it can inform me of ambiguity when there is a one. It even show you a nice diagram in case you don’t know what it is talking about.

Fastparse is handy. I can write a parser in less than 20 lines of code. But it is based on backtracking strategies, which means sometimes I find the problem at the runtime.

Here is my grammar without any modification.

term          -> apply
              |  project
              |  true
              |  false
              |  int
              |  if
              |  abstract
              |  variable
              |  record
              |  parenthesized
apply         -> term "(" term ")"
project       -> term "." ident
true          -> "true"
false         -> "false"
int           -> [0-9]+
if            -> "if" term "then" term "else" term
abstract      -> "(" ident ":" type ")" "=>" term
variable      -> ident
record        -> "{" entry ("," entry)* "}" where entry -> ident ":" term
parenthesized -> "(" term ")"

There are some obvious left-recursive rules: apply and project, so we can make them as a postfix rule. Replace the first 3 rules with these 4 rules.

term          -> term' (apply-tail | project-tail)*
term'         -> true
              |  false
              |  int
              |  if
              |  abstract
              |  variable
              |  record
              |  parenthesized
apply-tail    -> "(" term ")"
project-tail  -> "." ident

Then we will spot some “dangling-else” problems (not the else in the if rule because else clause is required). They are if and abstract. For example, (x: Int) => x.y can be interpreted into either ((x: Int) => x).y or (x: Int) => (x.y. The solution is to give apply-tail and project-tail higher binding weights than if and abstract have.

term    -> simple (apply-tail | project-tail)* | complex
simple  -> true | false | int | variable | record | parenthesized
complex -> if | abstract

In the new rules above, term is either a simple term (terms without “dangling-else” problems) with any number of tails, or a complex term with no tails. By far the parser is almost done. However, I stepped into other two rabbit holes.

Should cut (operator ~)at appropriate position, or the parser might fail even if your grammar is correct! To cut is to tell the parser never look back.
When using whitespace consumers, remember to parse tokens with repX rather than rep. For example, I spent a whole hour on debugging ident = CharIn("a-zA-Z").rep(1)!

Conclusion

Finally, I had finish the project and uploaded to GitHub. You can check it out here.

Besides, I also want to address some off-topic discoveries about language servers. I’m writing Scala with Visual Studio Code. I felt that the Scala language server is very stable and ergonomic. It could expand complicated macro in seconds. It made the development smoother than I had expected.

Before I write Scala in Visual Studio Code, I often use Rust and TypeScript.

The TypeScript language server works pretty well. But there are still bunch of times when it stuck because there are too many type assertions and sub-types, especially when I was writing a large tree visitor with Babel. Rust language server sometimes are lazy to check ownership so everything seems fine in the editor but you get bunch of errors when compiling. There are also times the language server failed to expanded macro from newly installed crates.

Anyway, I’m not complaining about the language servers of TypeScript and Rust. They are also very great.

Migrate My Blog to Cloudflare Workers

Mon, 22 Feb 2021 17:25:12 GMT

去年十一月，我想把自己拍的乱七八糟的照片放到公开的网站上，做一个作品集(portfolio)网站。我首先想到的是我 Creative Cloud 订阅里的 Adobe Portfolio，不过试了以后才发现这玩意儿的的访问速度实在是太慢了。程序员思维的我就蹦出来想：为什么不自己搭一个呢？当时正对 Cloudflare 非常上头，而我又懒的研究国内各种云平台的 CDN 服务，就脑子一热订阅了 Cloudflare Workers。但可惜，之后因为工作太忙，我就没怎么用它，只是把网站搭起来并且跑通了 GitHub Actions 后就不管了。

转眼已经到了 2021 年，并且已经过去了两个月，我想着也该翻新一下自己的博客。就在某个凌晨花了一个小时把整个站点用 TypeScript 重写了——打算以此当作新的开始。我心想：既然都重写了，不如尝试把博客也转移到 Cloudflare Workers 上呗？于是就此开始折腾。

在 Apple Silicon 上安装 Cloudflare Wrangler

如果你使用的不是基于 ARM 的计算机，可以跳过这部分，直接从下一节开始读起。

这是最简单的一步，也可能是最复杂的一步。

Cloudflare 已经把整套工具链做成一个 CLI 工具了，名叫 Wrangler。官方推荐的安装方法是 npm，但很不幸，你只会得到一行错误：Error: Unsupported platform: Darwin arm64。好在 Wrangler 是 Rust 实现的，所以我们可以用 cargo 来安装，执行 cargo install wrangler 后，Cargo 就会下载并且编译 Wrangler，这过程中并不会发生任何问题。难道这就结束了吗？并没有。当你随便想用 Wrangler 做点事儿的时候，就会遇到下面的错误。

$ wrangler init --site
⬇️  Installing cargo-generate v0.5.0...
Error: could not download `cargo-generate`
no prebuilt cargo-generate binaries are available for this platform

这种问题一看就不是那种「因为用了某些平台上的某种技术而导致无法在你的平台上运行」的错误。而且，因为 cargo generate 这个命令在几个月之前就支持 ARM 平台了，我感觉这个问题一定有 workaround。经过一番搜寻，我发现果然如此，引用相关 issue #1685里的一句话。

Which could potentially be that wrangler is a bit overeager in its convenience-added approach. Rather than expect to download a pre-built binary and fail otherwise, it could first check for an existing binary on the system, and fall back to attempting to download. Or, if cargo is installed, cargo install <wasm-pack|generate|etc> could be invoked to build these utils from source.

说白了就是 Wrangler 压根就没有考虑到这种情况，所以只会从某个地方下载预先编译好的 cargo-generate 和 wasm-pack，这就导致了：虽然 Wrangler 本身可以通过 cargo install 在 Apple Silicon 上运行，但下载这两个工具链的时候出错，因为 wrangler 的开发团队压根就没有考虑过 ARM 平台上的运行体验。

明明可以在我这里跑起来的东西，因为开发人员没有考虑过这种情况，我们难道就要因此放弃吗？不，于是我克隆了一份 Wrangler 的代码，全文搜索错误信息，找到报错的位置。从下面的代码我们可以看到，Wrangler 在运行生成命令时会执行 install::install_cargo_generate() 函数，这个函数会下载 cargo-generate 并返回路径，再把需要执行的命令行参数拼接起来。

pub fn run_generate(name: &str, template: &str) -> Result<(), failure::Error> {
	let binary_path = install::install_cargo_generate()?;

	let args = ["generate", "--git", template, "--name", name, "--force"];

	let command = command(binary_path, &args);
	let command_name = format!("{:?}", command);
	commands::run(command, &command_name)
}

我看了下 install::install_cargo_generate() 的实现，它会根据操作系统和平台请求 https://workers.cloudflare.com/get-binary/{0}/{1}/v{2}/{3}.tar.gz 上下载 cargo-generate 和 wasm-pack。这就令人哭笑不得了，因为它既不是从 Rust 相关的源下载，而且代码中本身也没有提供检测 ARM 平台的代码。我就没有时间贡献 PR 了，就直接把上面代码的 binary_path 替换为我本机的 Cargo 的路径。最后，构建一份 release，并把构建好的程序链接到我自己的 bin 文件夹下，Wrangler 就能正常使用了。

配置 Wrangler 项目

在 Wrangler 安装完后，我们就可以干正事了。其实只需要按照官方文档中的教程一步一步来就好。但我这里还是把每一步摘抄出来，因为这些步骤散布在很多篇文章里。

第一步，在 Gatsby 里用 Wrangler 新建项目。用 cd 进入项目，执行下面的命令。

$ wrangler init --site
🔧   Creating project called `workers-site`...
✨   Done! New project created ./blog/workers-site
✨  Successfully scaffolded workers site
✨  Succesfully created a `wrangler.toml`

第二步，编辑 wrangler.toml。把 account_id 改成执行 wrangler whoami 所得到的 Account ID。把 bucket 改成 "./public" 也就是 Gatsby 构建的目标文件夹。其余的字段不用改。

第三步，部署到 Workers 上。只要运行下面的命令就行了。

$ wrangler publish
✨  Built successfully, built project size is 13 KiB.
🌀  Created namespace for Workers Site "__blog-workers_sites_assets"
✨  Success
🌀  Uploading site files
✨  Successfully published your script to
 https://blog.luyu.workers.dev

给 Cloudflare Workers 添加域名

这可能是会坑到刚用 Cloudflare Workers 的一步，当你把域名添加到 Cloudflare 后，你可能以为只要把 Workers 指派到这个域名的路由下就行了，其实不然，你需要保证 Cloudflare 的 DNS 记录中你指派的路由是被 Cloudflare 代理的。

举个例子，在我的 wrangler.toml 中，route 字段的值是 "luyu.blog/*"，那我就需要保证在 Cloudflare 的 DNS 面板中，有 luyu.blog 的域名记录，并且开启了代理。如果你没有一个可以写进 DNS 记录的 IP 地址，可以参考这个官方社区的问答，使用 192.2.0.1 这个地址。

配置 GitHub Actions

要配置 GitHub Actions，我们需要先在 Cloudflare 上取得 API 令牌。为了保证安全性，创建令牌时，可以限制令牌的作用域和账户。我们可以在创建令牌的时候只选择和 Workers 有关的权限。

（未完待续）

Set Up Development on Apple Silicon MacBook Pro

Tue, 15 Dec 2020 18:43:47 GMT

The information in this post may be obsolete when you are reading it.

After days of waiting, I finally got my customized MacBook Pro with Apple M1 chip.

Package Manager

You need Homebrew or MacPorts to install system level packages. I think Sam's post summarized a good way to maintain both ARM-based Homebrew (experimental) and Intel-based Homebrew (running with Rosetta 2). Most importantly, don't forget to add them to your PATH and restart your shell sessions. Using a wrong version of Homebrew may cause errors.

Editor (or IDE)

I prefer Visual Studio Code. For now, only the insider preview of Visual Studio Code has a ARM version and its name is exploratory version.

Node.js Projects

The first project I want to develop on this laptop is my blog. My blog uses Gatsby and relies on sharp — a image conversion and compression package. Because there is no Apple Silicon on their CI platform, they don't provide any prebuilt binaries. I just build myself according to comments this issue.

brew install pkg-config glib zlib
brew install jpeg libtiff libheif libspng giflib libexif libjpeg-turbo libpng webp
PKG_CONFIG_PATH=/opt/homebrew/Cellar/zlib/1.2.11/lib/pkgconfig ./configure
make
sudo make install

After completed this, I can finally develop my blog.

Sign off commits with GPG keys

I just follow every steps in this tutorial. Important: you should install pinentry-mac with Intel-based Homebrew.

Develop Node.js Projects with WSL 2

Sat, 05 Dec 2020 02:28:19 GMT

I have a PC in my apartment. But I never use it as a development machine. Recently, I feel tired of bringing the Mac mini everyday. So I decided to set up a development environement on my PC. Here is what I've done for Node.js projects.

Network Issues

If you don't live in mainland China, you can just skip this section.

If you want to be a competent developer in mainland China, you must resolve some well-known network issues. But I just hadn't expected that these issues showed up so early.

First, find the IP address of Windows by running cat /etc/resolv.conf. You will get something like this.

# This file was automatically generated by WSL. To stop automatic generation of this file, add the following entry to /etc/wsl.conf:
# [network]
# generateResolvConf = false
nameserver 192.168.163.65

The IP address after nameserver is the host. Suppose your proxy runs at port 7890, you can set the HTTP and HTTPS proxy by following commands.

export https_proxy=http://192.168.163.65:7890
export http_proxy=http://192.168.163.65:7890

And, of course, proxy for git. This step is of two parts. First, you have to tell ssh that use SSH over HTTPS for github.com by adding following content to ~/.ssh/config.

Host github.com
  Hostname ssh.github.com
  Port 443

Second, let git use the proxy.

git config --global http.proxy http://192.168.163.65:7890

Remember to set the proxy in root user because apt runs at root.

Intall Node.js and Yarn

Install Node.js by following commands in NodeSource. For example, I like to use the latest (15).

# Using Debian, as root
curl -sL https://deb.nodesource.com/setup_15.x | sudo bash -
sudo apt-get install -y nodejs

Then, install Yarn according to its docs.

curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | sudo apt-key add -
echo "deb https://dl.yarnpkg.com/debian/ stable main" | sudo tee /etc/apt/sources.list.d/yarn.list
sudo apt update && sudo apt install yarn

Install Dependencies

Because WSL 2 is a barely naked install, i.e. without many necessary packages by default. In order to build some Gatsby dependencies, we must install some build tools first.

# For pngquant
sudo apt install libpng-devel automake libtool autoconf
# For mozjpeg
sudo apt install nasm pkg-config

Then, run yarn. Everything will be okay.

Signing Commits Using GPG

Just follow steps in this gist.

I encountered this error when I signed off commits.

$ git commit -S
error: gpg failed to sign the data
fatal: failed to write commit object

According to this post, just run export GPG_TTY=$(tty) before using GPG.

Some Old Posts about Haskell

Mon, 30 Nov 2020 04:51:48 GMT

In the last weekend, I moved some old posts about Haskell. Here is a list.

Why Monoid Everywhere
What are Functors
What are Applicative Functors
Rewrite foldl in foldr, Explained: This post was supposed to appear in SDU Lambda, but I didn't publish it there for some reasons. I also fixed some minor errors in this post.
Create New Types in Haskell
Bottom Type in Haskell

There are some older posts about functional programming in the old WordPress database dump. But they are too rudimentary. So I don't want to move them to here.

Guidelines for Writing Blog Posts

Fri, 09 Oct 2020 14:02:19 GMT

I’ve been disappeared from this blog for over three months. I didn’t go into hibernation or get addicted to unproductive things. I’m just busy at various of works: papers, projects, PhD applications, college errands, etc. The good news is: I do have many great topics for new posts and some of them has been drafted. But, as you can see, none of them gets published.

I reflected on why this recur and summarized some points about how to produce more posts even if I’m averagely busy. I use the word “averagely” because there is some really extremely busy time.

Try narrower topics. A wide title is a stumbling block: it prevents me from expressing what I really think. For example, I used to adopt title like Data Flow in SwiftUI, however I didn’t have the insight and knowledge to complete this topic so far.
Keep simple and concise. Nobody (including myself) want to read useless words. Also, as non-native English user, I should focus on how to accurately express my ideas rather than rhetorical things. In a word: just discuss things that matter.
Outline first, then fill in details. Every time an idea strike me, I can't get into the flow right away. But I know what points should be mentioned. So I can just put them down in my notes and complete them later.
I don’t really need a topic. Writing two or three paragraphs about my recent life and knowledge can also form good posts. Sharing what you learn is the topic. I learned this from Tom MacWright’s blog.

I will practice these points from now.

Thoughts on My Photography

Fri, 03 Jul 2020 15:06:49 GMT

Lately I’m pondering over my photography skills. It started few days ago, when I recovered my desktop computer and I found tons of old photos in my backup disk. I was inspecting these photos. Some early photos even trace back the first trip I carried with my uncle’s DSLR camera. However, when I compared these old photos with photos I took nowadays. I realized that I’ve had little improvements at all during past few years. So why?

I’d been reflecting like this for several times. I blamed it on many factors: the lack of technical knowledge, poor gears, and even the ordinary of my environment. I thought, if I know how to use gears properly, if I have some thousand-buck cameras and lenses, and if I go to somewhere splendid, I will definitely produce countless beautiful shots. However, in the last trip to Hangzhou, although I had all of them, what I took is still rubbish.

The problem is on me, I think. Photography is a subfield of art and I never attended any esthetics training and courses. Each time before I press the shutter, I consider less about esthetics about framing and color. When it comes to post-processing, I also have no idea about how to balance colors and contrasts.

Fortunately, it’s not late. I still have much time. Time to march on new world!

Photograph Partial Solar Eclipse

Sat, 27 Jun 2020 05:11:49 GMT

六天前我拍了一组日偏食的照片，这里简单记录一下我是怎么拍的以及反思。

准备

我在国家天文科学数据中心的网站上查询到了我所在地区的精确到秒的日食开始和结束时间。这里还可以查到未来的日食的覆盖范围和日期，但都不在中国境内。

器材方面，我用的相机是佳能的 EOS R，镜头是 RF 70-200 mm ƒ/2.8 L USM。我在日食的前两天从淘宝上下单了 NiSi 的 77 mm 的 ND 1000 滤镜。挑选这款滤镜的原因只是因为它便宜，我暂时还没有 77 mm 口径的大光圈镜头，所以可能这是我唯一一次用它。

拍摄

拍摄时使用 M 档，以保证每张照片都具有相同的曝光，我用的设置是 ISO 100、光圈 ƒ/32 （你没看错！这支大三元之一的镜头的最小光圈可以如此之小），快门速度是 1/4000 秒，焦距是 200 mm。

我并没有把相机一直对准太阳（原因后面会讲），而是在路边找了一个咖啡店，定了一个每隔四分钟就会响的闹钟，闹钟响的时候我就拿着相机出门拍两张（为了保证容错）。在等待拍摄的过程中，我会把照片导入到 Adobe Lightroom Classic 做一下必要的裁剪和后处理。

后处理

200 mm 的焦距虽然足够长，但是并不能把太阳充满整张照片，所以需要后期裁剪。同时，我应用了镜头配置文件对照片进行校正，以保证把太阳放在画面的不同位置都不会出现变形。最后得到了 53 张照片。

成片并不是多重曝光的结果，而是用 Adobe Photoshop 合成的。合成的方法也很简单：

把调整好的照片批量导出为 JPEG；
把照片全部拖入 Adobe Photoshop 中；
对所有照片图层应用「发光」处理效果；
画一条直线；
把照片按直线依次排放；
隐藏直线；
加上字；
导出。

这 8 个步骤大约花了一个小时的时间。

反思

整理来说，我对流程还是很不满意的，虽然也有很多朋友觉得我拍得不错。

器材方面并没有不满意。实际上我发现拍摄日食用一个 APS-C 甚至 M4/3 画幅的机器配合一个长焦镜头也足够了。重点是如何挑选合适的减光镜。

我使用的 ND 1000 是远远不够的，想要以常用的光圈范围拍摄日食，至少需要 ND 100,000 的滤镜。但 ND 镜并不能防止紫外线和红外线对相机 CMOS 的损伤，所以最好还是买太阳滤镜或者巴德膜(Baader filter)。这篇博文列出了一个改在何种情况下使用何种程度的减光镜：拍日食減光鏡到底該選多少？減光鏡快門換算表。

个人防护方面，我没有带防晒霜和墨镜。当天的阳光实在是太强烈了，天空中万里无云。起初我是在一个花圃架下拍摄，但待了二十分钟就感觉太晒了，眼睛也受不了，所以才转移到路边的咖啡厅。下次类似的拍摄一定要带好这两样东西。

A Brief History of My Blog

Sun, 19 Apr 2020 08:56:00 GMT

This post is aim to record all changes of my blog, which is inspired by Ji Luo's meta blog post. I am not affiliated with any organizations, companies, or brands mentioned in this post though most of they were hyperlinked.

2020

On Feb 19, I picked up the project I wanted to do last year. At the backend side, I chose Fastify and Sequelize. As for the frontend, I customized a webpack project that outputs pug templates can be used by the backend.

On Apr 11, I abandoned the idea to develop a blog system from scratch because there are abundant design choices and I don't have much time to evaluate them this year and next year according to my schedule. Then, I started to build with the help of Gatsby.

On Apr 15, New site was launched.

On June 27th, after months of heavy work on research, I began to revisit my blog and see what could I improve. I added RSS feed generation and a gallery page where I could place my photography.

2019

On May 12, I rebuilt the website with Hugo. Soon I found that Hugo is not so extensible in terms of frontend experience.

On Sep 26, I decided to make my own blog system, which would support Chinese emphasis marks, references between site posts, bibliography and reference management, and inline and block math equation. But I didn't take any actions because I was busy on my paper project at that time.

2018

On Aug 8, I thought shorter domain is easier to be memorized, so I bought the domain cly.wtf again on namesilo.

2017

On Jun 30, I bought the domain synthetic-dream.xyz on GoDaddy. I chose this domain because GoDaddy offered me a huge discount while the renewal fee of cly.wtf is a little bit expensive.

2015

On Sep 9, inspired by 無次元 the podcast, I bought the domain cly.wtf on GoDaddy.

2014

In this year, I attempted to build my blog by using Jekyll and Ghost. I hosted it on Heroku, AppFog (it'd been closed down now) and OpenShift successively. However, since I didn't have a credit card to pay at that time, my blog had no stable public addresses and data had been lost.

Meanwhile, I wrote some post (most of them are diaries) on Svbtle. Although the site is amazing, the connection was occasionaly poor in my location, so I didn't keep on it for a long time.

2013

On Jun 12, I made Hyde (not the famous one), which is a simple static blog system built on Express and Jade (now known as pug). However, since I'm not competent to implement features I wanted at that time, I didn't use it for a long time.

Thoughts on Visualization Authoring

Sun, 15 Mar 2020 13:33:08 GMT

这次工作我做了一个非常简单的疫情信息图表，从接到任务到定稿交接大概用了一天半的事件。

关于工作流(workflow)

整个工作流大致可以分为三步：设计、实现和微调。这个任务花了我大概 20 个小时的事件，听上去并不是很多。但因为我之前并没有做过这样可视化的项目，20 个小时里还是走了一些弯路的。下面是按部分的总结。

设计

在接到任务的一开始，我并没有很进入状态，我只是用 D3 抄了一个力引导图(force-directed graph)的例子并把数据套了进去。很快我意识到这样做事是不行的，我必须设计。于是我翻出了笔记本，把每行数据在纸上画一个圈；再把有关系的数据行用箭头连接。根据这些数据的来源，我觉得我可以用一种图(graph)加饼图(pie chart)的混合设计。我把画的图拍照发给导师和另一个合作的同学，他们也认可我的设计。

这一步里我觉得最重要的是动手，一定要在纸上画草图。我做的第一个版本是照着 D3 的例子写的，毫无疑问，这种完全没有经过思考的尝试就像无头苍蝇一样。所以一定要先用纸和笔打打草稿，然后再考虑如何用代码或工具实现。

实现

接下来就是漫长的开发过程，我花了大约八个小时做出了第一个版本。这一步的过程没有什么值得讲的，无非就是写代码、查文档和纸上演草这三件事的无序重复。但是也有一些经验可以分享。

对于普通的几何问题，一定要在纸上画图演算。在面对代码时，我们只会考虑到当前面临的这一种或几种情况。一开始，我遇到的若干 bug 都是因为没有考虑到所有情况（例如平行、垂直、角度为负数），之后我遇到这种几何问题的时候就会在纸上画图，遍历所有情况，然后再写进代码里。

因为整个图的布局是我手动计算的，所以随着开发的深入，自己要计算的情况就越来越多。中间在查资料时，我发现有现成的库可以实现这种布局。但我并没有立刻用它，我先列了一下我所需要布局，然后阅读了一下这个库的文档，发现对于数据中的一种情况，我需要魔改(hack)这个库的代码；但我现有的代码只要再多写一种情况的计算就能完成第一版了。所以最终我并没有使用这个库。

不要太强求通用性，受程序员思维的限制，我在一开始编码时总想让代码尽量通用。这次的输入数据是人为编写的 Excel 表格，数据正规性很差，于是我的数据分析代码就越写越长。这些代码非常琐碎，充满了各种边角情况，调试不仅费时还非常令人气馁。但在意识到自己这种对通用性的追求是无意义的之后，我开始手动编码数据，就省下了很多时间。

微调

做出第一个版本后就是漫长的微调。这一部分工作流非常简单

把当前的版本发给导师和同学并征求意见；
与他们讨论，确定需要采纳的意见；
修改代码使其符合采纳的意见；
重复步骤 1，直到可以交付。

在写这篇文章的时候，我回顾了一下聊天记录中发送的各种版本，除了布局以外的几乎所有东西都改变了，最终结果是显而易见得好于最初版本的。对于这一部分，我没有什么方法论上的总结。大部分都是关于人性的。

征求意见的过程中，要不厌其烦地给大家解释，我想保持耐心大概是最重要的。
要对意见保持开放的态度。关于如何做到这一点，我在播客UX Coffee 设计咖上听到过一个不错的说法：我的作品是他山之石，别人对于我的作品提出的意见其实都不是针对我的，而是让这个作品变得更加完美的。

关于信息图表(infographics)

我有段时间特别喜欢看各种各样的信息图表(infographics)，就是那种看上去花里胡哨的，又有图又有字的那种。我喜欢的原因之一是大多数的信息图表的目的都是讲故事(storytelling)，而相比之下纯粹的可视化可能只是为了表征信息(informative)。此外，作为排版爱好者，看精美的信息图表中文字的编排也是一种享受。

虽然这次的工作做的并非是我心目中的信息图表，但却让我想了关于信息图表制作(infographics authoring)的很多事情。因为我之前就在做一个编程语言和可视化结合的项目，所以我一直在思考：什么样的工具、软件、语言、或表达方式是适合信息图表的？我在 Behance 上看到过很多信息图表

信息图表无法用传统的基于分类学(anatomy)的制图工具完成。作者为了讲述特定的故事，常常会自定义符号(mark)和布局(layout)。在 The Visual Agency 制作的What Teachers Think中，作者使用了四个相邻的正方形的面积来表示每个国家内教师对工作满意程度的比例，这要求工具必须有自定义符号(mark)的功能，并且可以自定义数据行(row/tuple/datum)到自定义符号(mark)中的属性映射。而很多制图工具都欠缺这样的能力。从编程的角度看，这是定义了一种可以自由绑定数据到视觉属性的组件(component)。

信息图表背后的标准(specification)是模糊的。这给编程带来了很大困难，因为 D3、Vega、matplotlib 对可视化的描述都是定量且精确的标准。这也解释了为什么我在 Behance、Dribbble 和 Deviant Art 上见到的信息图表几乎都不是用程序语言直接生成的。

信息图表中常常有各种特殊情形(corner case)或者手动微调(hand tuning)。它们往往都来源于人的直观感受，但这种直观感受并非一定是基于美学的，有可能是最终的受众偏爱某一颜色或者布局。这就需要打破前面的标准化和组件化。

信息图表对排版的要求很高。与普通的可视化不一样，信息图表对文字布局有更高的要求，在信息图表中插入文字段落、同段不同样式、甚至插入数学公式都是有可能遇到的。这就一棍子打死了很多编程方法，因为至今 SVG 和 Canvas 上都没有好的段落排版算法，大多数信息图表作者都是在图表制作工具中导出到排版软件中操作的。

可视化库适合做信息图表吗？

使用传统的图像编辑软件（例如 Photoshop、Illustrator、Sketch、Figma 等）制作信息图表主要有以下问题。

没有内建的度量(scale)，设计师徐需要手动维护从真实数据到视觉属性(visual attribute)的映射。如果数据突然发生较大变化，设计师需要花费很多时间重新制图。
缺乏以组件化或标准化的控制符号的属性的方式。

但它们也并非一无是处。实际上，相当一部分艺术家都会使用这类软件来制作信息图表。因为这类工具提供了相当大的自由度，让设计师可以根据自己的意图来画图。

信息图表的银弹(silver bullet)究竟存不存在？

我想，我们之所以设计这些可视化制作工具(visualization authoring tool)，都是为了提升制作可视化的效率。但由于可视化制作的复杂性，并不存在所谓的终极工具箱(ultimate toolbox)，换句话说即银弹(silver bullet)。但众所周知，银弹并不存在。我在 Behance、Dribble 和 Deviant Art 上浏览的优秀可视化作品，它们的作者都同时用了多种工具。

毫无疑问，信息图表的制作是一个多步骤的流水线。艺术家可以在每个步骤选用不同的工具来完成。如果一个信息图表的成品是静态的，且以后不会变化，追求工具的选取对实际制作并没有太大的用处。

如果艺术家制作的并不仅仅是信息图表，而是一套可复用的模板(scheme)，甚至是可交互的程序，那么一个合适的制作流程就至关重要了。

Enable HiDPI on a 4K Sony TV in macOS

Tue, 21 Jan 2020 09:21:45 GMT

Today I got back to my hometown by train. The first thing I did after I had arrived to home is to connect my MacBook Pro to the SONY TV. This is important because I really need a external monitor to maximize my efficiency. However, although the TV is 4K, but macOS cannot automatically turn on HiDPI. After a while of searching on the Internet, I found the solution.

This solution is quite simple. Run the following command in your terminal.

sudo defaults write /Library/Preferences/com.apple.windowserver.plist DisplayResolutionEnabled -bool true

Then reboot and open the the monitor preference panel, click "scaled" when holding the option key, you'll find a 1080p (HiDPI) option in the list. This also works on macOS Catalina.

P.S. If you haven't made any similar changes before, this value should be unset. If you're curious about the value, you can examine it by following command.

defaults read /Library/Preferences/com.apple.windowserver.plist DisplayResolutionEnabled

Draw Text with WebGL

Fri, 17 Jan 2020 15:57:57 GMT

There are two main ways to render text with WebGL.

Character Bitmap

This method is quite straightforward. First, draw all characters you need on a canvas (of course in 2D context). Then use the image as a texture map. But if you’re going to render text under many font sizes. You need to store many character bitmaps of different font sizes. I found a package doing this job.

Vectorized Text

The second way is to convert outline (usually Bézier curves) of characters into triangle mesh. Then draw the mesh by WebGL. I also found a package called vectorize-text doing this job. It’s also based on canvas. I think its implementation is a little bit hack. First, it draw your text with your options on an invisible large canvas. Second, it fetch all pixels and use a package called surface-nets to find all contours and simplify it by simplify-planar-graph. Finally, it cleans all planar straight line graphs by the help of clean-pslg. Because we want triangle meshes. It uses cdt2d to convert contours to meshes.

It seems that the whole process is really costly, especially when you want to vectorize a large amount of texts. I will do a performance test later on.

An OpenType Way

Last night, I tried a new way with OpenType. The main idea is to get glyph outlines directly from font files. Then convert them into triangle meshes. I think it can be the most accurate and fast way to draw text because the outlines are rasterized only once. The good news is that opentype.js has already taken kerning, OpenType features and hinting into account. But the bad news is you have to handle position (such as baseline, anchor) or even word wrap by yourself.

Conclusion

Well, no conclusion is drawn in this post. This post is a like a summary of my adventures. But I will finish it in next few days.

Why I Switch from Sony to Canon

Mon, 16 Dec 2019 17:30:52 GMT

I made a seemingly unwise choice: switch from Sony a7R3 to Canon EOS R. I know many spec experts may say: “Are you crazy? Sony a7R3 has amazing eye-control focus, IBIS, higher resolution, better low-light performance, non-cropping 4K video recording, HLG support and so on. Why you switch to a system with such feeble camera body?”

Well, I do carefully deliberate before my decision. It’s not a whim. Here are my reasons.

Canon’s EF lenses are very cheap. You can get a high-speed lenses in a descent price. I know many Sony lenses of the same specification have better image quality, but I’m really not an extremist about sharpness. As long as the distortion and chromatic aberration is acceptable, the price always outweighs.
After several updates, many issues of EOS R had been resolved. The eye-tracking focus of EOS R become usable after the 1.4 version of according to DPReview’s test.
I rarely shoot videos. Or to say the least, I’m not a pro video user, therefore I won’t spend much time on. So features like non-cropping 4K video recording, HLG support is redundant to me. ~~Wait, did you say IBIS? Does it really work in videography?~~
Sony’s menu arrangement and almost useless touch-screen drive me crazy. I can’t remember how many times I dig the whole menu more than one time to find the item I want. I do customize my camera but as you know it doesn’t help when you want set something you seldom set before.
Sony’s screen is awful. I’m a hawk-eye about screens. Both color accuracy and the resolution (pixel-per-inch) of my a7R3’s screen doesn’t meet my standard of good screens. Besides, I wonder why don’t Sony offer touch interaction on menus. Because if I can navigate by touching, the previous point will be no longer a problem.

Nothing is perfect. To me, Canon’s system also has some unsatisfactory points. But unlike Sony, these points are totally bearable.

Canon’s body doesn’t have IBIS (in-body image stabilization) and there’s neither announcements nor rumors indicating they will release it.
Currently there’s no cheap lenses on RF lines, most lenses are of L lines. But I think Canon will release more RF lenses in 2020 because I’ve witnessed how fast Canon convert its patents to products. Besides, many rumors indicates they will release cheap RF lenses in 2020.

This is the end. I will post more review and thoughts in following days.

How Did I Set up a New Mac

Sat, 07 Dec 2019 13:39:41 GMT

Today I get a Mac mini in my lab. Here is how I set up it.

Resolve a national network issue.
Installed 1Password in Mac App Store. Actually this was ought to be the first step, but the campus network prevents me logging in (I don’t know why). So it became the second step.
Swapped the control and the command key in preference panel because I used to press the command key with side of my hand.
Bought an extra seat of Setapp. Download and install Setapp. Setapp start install apps in my favorites.
Switched region in Preferences to United States. This prevents many softwares and websites offering me a limited version based on my region.
Switched the default search engine of Safari to Google.
Opened Dictionary.app and turned on New Oxford American Dictionary, Oxford American Writer’s Thesaurus, Oxford Dictionary of English and Oxford Thesaurus of English.
Downloaded Things for Mac in Mac App Store.
Downloaded and installed Figma. To be honest, I’m not a designer. It’s not so important for me but I just did it.
Downloaded iTerm 2 and copied into my Application folder.
Initiated Xcode download.
Copied the install command of Homebrew to the terminal and press enter.
Downloaded Google Chrome and Firefox Developer Edition.
Downloaded Adobe Creative Cloud.
Open Mac App Store and installed WeChat, QQ and Microsoft Office.
Downloaded Visual Studio Code.
Found that the download of Visual Studio Code and Creative Cloud suffered unexpected termination. Open Folx and retry downloading.
Downloaded MonitorControl from GitHub.
During the time of waiting download, purchased an USB-C to Display Port cable from JD.com.
Found the download of Firefox and MonitorControl terminated. Retried with Folx.
Found the download of Xcode and Microsoft Office failed. Sighed.
Copied MonitorControl to my Applications folder.
Opened built-in softwares in the Dock to make sure that iCloud sync is on and removed them from the Dock.
Found that I hadn’t installed One Switch and Paste from Setapp. Installed them.

Found that brew installation failed. It gave me the following information. Seems another network connection problem. I had to retry with proxy on.

Cloning into '/usr/local/Homebrew/Library/Taps/homebrew/homebrew-core'...
remote: Enumerating objects: 5101, done.
remote: Counting objects: 100% (5101/5101), done.
remote: Compressing objects: 100% (4897/4897), done.
error: RPC failed; curl 56 LibreSSL SSL_read: SSL_ERROR_SYSCALL, errno 60
fatal: the remote end hung up unexpectedly
fatal: early EOF
fatal: index-pack failed
Error: Failure while executing; `git clone https://github.com/Homebrew/homebrew-core /usr/local/Homebrew/Library/Taps/homebrew/homebrew-core --depth=1` exited with 128.
Error: Failure while executing; `/usr/local/bin/brew tap homebrew/core` exited with 1.
Failed during: /usr/local/bin/brew update --force

Copied Visual Studio Code to my Applications folder.
Opened Bartender and granted privileges to it.
Installed Node.js, Yarn and fish shell by brew.
Set default shell to fish.
Downloaded iterm2-color-schemes and had them loaded in iTerm 2.
Installed these extensions in Visual Studio Code: ESLint, Prettier, Rainglow (a theme pack) and Settings Sync.
Created a SSH key with ssh-keygen and added it to my GitHub.
Copied Chrome and Firefox Developer Edition to Applications.
Logged in my Google account on Chrome and turned on sync.
Logged in my Mozilla account on Firefox and turned on sync.
Downloaded GPG Suite and restored my GPG keys. I do sign with GPG keys on every git commit.
Configure git's global settings: email, user name and GPG key.

After these 37 steps, the Mac mini is ready for production. It cost me around three hours. About 1/3 of time are wasted on resolving network-related problems.

Figma Announced Auto Layout

Fri, 06 Dec 2019 18:40:01 GMT

When I was browsing the slides of auto layout (yeah, just exactly in Figma), I suddenly realized that people hardly requires very odd and complex layouts. Most layouts can be broke into smaller and basic layouts, i.e. layout primitives. Then I searched the term with Google. Guess what did I found? I found three interesting things that I can review later.

Evergreen: a React UI framework. It seems very consistent, neat and clean. I’m gonna have a try.
Pylon: To be honest this is not the first time I check it. It’s a mock up HTMl framework of SwiftUI.
Every Layout: A set of e-Book that illustrates common layouts with respect to CSS. By the way, I like the minimalism design of this site.

OK, let’s get back to the topic. What’s Figma’s Auto Layout? In a programmer’s view, it’s a set of design tool that matches with CSS’s flex with flex-gap. It’s very easy and straightforward. I bet my dad can understand this in 5 minutes. But the most important thing is that this will be an end as they said in their developer blog.

In my opinion, the hardest part of introducing abstraction into a design tool is how you make the concepts be operated coherently and fluently rather than pursuing the completeness or the novelty of the concept.

The current auto layout in Sketch is a good counterexample. Most designers I know hardly know how to make good use of them because it acts counter-intuitively at most time. Figma did a good start. I guess Sketch will catch up later but maybe after a long period because they just announced that their focus in 2020 is collaboration.

Gear Doesn't Matter

Fri, 16 Aug 2019 05:53:41 GMT

Gear doesn’t matter.

I've heard this quote hundred of times. Many people who is new to photography reckon that photography is similar to cooking with recipes. They think you can produce decent photos by just following a specific procedure. So using great gears will truly prove your image quality.

However, some inner quality is ignored. So far, although I have some great and expensive gear, many good photos that I’m proud of is done by my iPhone. In fact, in most situation audiences can’t differentiate them. Because the transmission media, such as compression algorithm, eliminate what the great gear brings to you.

But I’m not saying you can produce all kinds of photos with any gear — this is incorrect. I’m emphasizing an inner quality of more importance — your creativity. With creativity as guidance, gear become insignificant — it’s actually the way that helps you reach the target — even if in some circumstance you don’t have good gear, you can take another shortcut to your destination.

So don’t be a gear-head and practice your imagination.

I Use These

Tue, 28 May 2019 06:09:21 GMT

Just two days ago I delivered 1/3 of a lecture in a small interest group in our university. This special lecture is aiming to encourage members to recommend their beloved tools and things. But I didn't present any "life matters" on that lecture because of shortage of time. In this post I will have a short brief introduction of what I'm currently using.

Root Devices

Since most of my work rely on computers and digital devices, many tools I'm using are softwares or attachments, which require a "root device" to run on. Here is my root devices:

My main device is a 13-inch MacBook Pro (Early 2015) with a replaced thrid-party SSD (I can't afford an original one).
A customize PC with i7-7700K CPU, 16 GiB RAM and GeForce GTX 1070 graphics card. I usually schedule computation intensive tasks on it.
SONY a7RIII mirrorless camera with SONY FE 24-70mm ƒ/2.8 GM lens. I like taking photographs and filming cutaway shots.
I use an iPhone XS Max as my main phone and an iPhone 6S as my backup phone because I enjoy the variety of apps on iOS ecosystem.

Intangible Tools

This section lists intangible tools that I use very frequently.

Work and Self-Help

Graphics authoring: Sketch
Photo post-processing: Adobe Photoshop and Adobe Lightroom Classic. Both of them are from the photography subscription.
Development: Visual Studio Code
Writing: Ulysses (for general writing), Typora (for writing involving simple math typesetting)
Information gaining: Reeder
Information management: DEVONthink (five-star recommendation)
Task management: 2Do (schedule my projects and tasks), Reminders on iOS (mostly for life routine memo)
Secrecy keeping: 1Password
Helpers: Macs Fan Control (help my poor latop extend its life), Timing (acquaint myself with how I work everyday), OneSwitch (a small tool helps me turn on/off settings quickly)

Entertainment

Music streaming service: Apple Music
Watching series and videos: Netflix, HBO and YouTube Premium (save my time from ads).
Games: I seldom play video games in the recent one year, but I have a Nintendo Switch with Nintendo member subscription. Dropping by the kingdom of Hyrule is one of my relaxations.

Tangible Objects

In the contrast of previous section, this secion lists my favorable objects that matters in my daily activities.

Digital Devices

AirPods: buy and you will fall in love with it
Incase City Compact: This is an endurable and versatile backpack. But the capacity is too limited. I plan to pick a larger one in next few months.
Logitech MX Master 2S: A very handy mouse for people holding multiple devices.
Dell P2415Q monitor: I bought it three years ago, because it is the cheapest monitor with 4K and 99% sRGB gamut. It does a great job.

Daily Matters

MUJI hand shredder: Helps me shatter papers carrying private information.
Well-designed mug cups at every workspace.

What Is Random Art Image

Tue, 14 May 2019 02:52:27 GMT

If you have done some DevOps works before, you must be familiar with the tool ssh-keygen. When a new key is generated, it will display a simple square ASCII art image called "random art image" (see following sample FYI). What's the purpose of it?

Generating public/private rsa key pair.
The key fingerprint is:
05:1e:1e:c1:ac:b9:d1:1c:6a:60:ce:0f:77:6c:78:47 you@i
The key's randomart image is:
+--[ RSA 2048]----+
|       o=.       |
|    o  o++E      |
|   + . Ooo.      |
|    + O B..      |
|     = *S.       |
|      o          |
|                 |
|                 |
|                 |
+-----------------+

People usually memorize images and patterns faster and firmlier than plain texts. And it's also useless to memorize the entire string because the goal is validation rather than memorization (who will recite their private key?). Therefore, converting them to pattern assists people in validating keys faster becasue a subtle alteration will cause a totally different pattern. That's why random art images present.

This technique is from a paper titled Hash Visualization: a New Technique to improve Real-World Security published in 2000.

My Todo List Rules

Tue, 23 Apr 2019 07:44:00 GMT

I've been using (to be specific, struggling with) todo list and GTD to manage my life for a long time. In this post, I summarize my thoughts on using todo list.

Why use Todo List

Because people do forget.
Because people are born to be lazy.
Because we can get everything right now.
Because things need many steps.
Because we don't know that should do first.

Toolkit Requirements

Don't use tools without sub-list.
Don't use tools without synchronization functionality.
Don't use tools that cannot archive projects (or lists).
In some circumstances, a pencil and a paper are better than an app.

Does Inbox Really Matters?

It depends on how complicated is your task hierarchy. If you are a student focusing on your study and one or two club, usually you can categorize your item when you add to them. But if you are involved in more than two cooperative projects, you do need an inbox preventing yourself from being troubled by overwhelming tasks.

Rules for Read-it-Later List

You really need a read-it-later list.
Put everything which inspires and interests you in it.
Pick items from it when you feel bored and nothing to do.
- If you feel sleepy, consider drop the item or pick another one.
- If you do really finish the reading, mark it item as resolved.

One more thing: exclude this list from all.

Rules for Writing a Todo Item

Don't use ambiguous action (e.g. "think about", "consider", "try"). Because these verbs are actually involves decision-making and struggling with opinions. Instead, your todo items should clearly indicate what to do next (e.g. "write", "buy", "tell", "chat").
Don't use repeated tasks as a habit tracker. Use special purpose app for tracking habits. Because that will mess up your todo list. How?
Don't put your ideas inside it. Write them down in your notes app. Create another workflow for picking, reflecting and realizing your ideas.
Don't write big goals like "finish my paper". Use small and certain goals.
Don't write guidelines as todo item. Guidelines are something like "be efficient", "keep quite". They didn't describe certain tasks, so avoid using them.
Describe expected outcome. If you only write what to do, you may hesitate when you mark it as completed.

Diffuse and Focus

Sometimes you get into the flow. In this case, you have no willing to spare time on writing down what you should do. In other word, you just want to do the work.

Rules for Tags

Most productivity tools have tags. But seldom people use it right. Tagging a task may satisfy your digitalization content — but that is useless.

Don't create a tag if you will never retrieve or filter it.
For tools which don't have priority, create several tags declaring tasks' priority.

Rules for Cleansing

You should take care of your task container.

Keep cleaning outdated tasks.
Keep removing ambiguous tasks.

Extra Tips for Recovering a Tool

If you leave your tool for a long time, and you decide to reuse it. How to recover?

If you leave it for so long that every tasks are outdated. Consider delete everything or create a new account.
If you leave it for just one or two weeks and some tasks are still valid. Removing those outdated tasks and projects then keep on!

Bottom Type in Haskell

Tue, 12 Mar 2019 00:00:00 GMT

今天偶然遇到了一个奇怪的符号 $\bot$ ，仔细查找了一下才发现这是 Haskell 中的一个特殊类型的值，其作用是用于表达发散项(divergent term)，也可以理解为不可计算的项。我之前在《类型与程序设计语言(Types and Programming Lanuages)》上见过这个词，感觉可以在这里解释，干脆就把原文引用过来。

Recall that a term that cannot take a step under the evaluation relation is called a normal form. Interestingly, some terms cannot be evaluated to a normal form. For example, the divergent combinator $\omega = (\lambda x. x x) (\lambda x. x x)$ contains just one redex, and reducing this redex yields exactly $\omega$ again! Terms with no normal form are said to diverge.

至于为什么不能表达，Haskell Wiki 上的解释是如果可以表达这样的项，那么编译器就可以解决停机问题了（我感觉这个证明应该会比较简单，改天水一篇博客文章）。下面是 $\bot$ 的一个常见定义。

bottom = bottom

因为它不断引用自身，所以在 GHCi 中打印 bottom 会进入死循环。手头有 GHCi 的读者可以试一下。同时， $\bot$ 是可以转换为任何类型的，这一点上和 undefined 类似。

Why Monoid Everywhere?

Mon, 24 Dec 2018 00:00:00 GMT

我在学 Haskell 时遇到最常见的问题就是你会看到某些名词在被你读了几十遍后，即使你去专门看了教程，也依旧没有很好地理解。没错，我说的就是幺半群(monoid)。这篇文章我们来讲一讲为什么幺半群在 Haskell 里也这么常见。

幺半群(monoid)在数学上的定义是：若 $S$ 是一个集合， $\circ$ 是二元运算 $S\times S \rightarrow S$ ，且满足下面两个条件，那么 $\langle S, \circ \rangle$ 被称为一个幺半群。

结合性 对于 $S$ 中的任意元素 $a$ 、 $b$ 和 $c$ ， $(a \circ b) \circ c = a \circ (b \circ c)$ 。
幺元存在 $S$ 中的一个元素 $e$ 使得对于任意 $S$ 中的元素 $a$ 等式 $e \circ a = a \circ e$ 成立。

在数学中，很多集合都属于幺半群。比如自然数集合 $\mathbb N = \{0, 1, 2, \cdots\}$ 和加法运算 $+$ 可以构成一个幺半群，正整数集合 $\mathbb N - \{0\}$ 和乘法运算 $\times$ 也可以构成一个幺半群。

回到计算机世界中，很多数据类型也都符合上面的定义。最常见的是数组类型和数组连接(concat)函数，在元素类型为 a 的数组类型中，幺元是 []，我们也可以保证连接函数的结合性。布尔值类型在逻辑或运算下也是幺半群。如果你拿常见数据结构和类型试一下的话，你会发现其实它们的大多数都可以和某个操作构成幺半群。

现在，问题的前半部分解决了——幺半群如此常见的原因是大多数类型确实都可以在某个运算下构成幺半群。后半个问题是：为什么 Monoid 在 Haskell 中如此常见？

答案就是因为幺半群的两个性质可以被很多新的抽象所用，并且很多抽象可以只基于幺半群实现。所以，把一个类型通过 Monoid 实例化后我们可以和其他类型类(type class)结合起来做很多有趣的事，而不用重写任何函数。举个例子，如果你想写一个把 Maybe String 连接起来的函数，如果你初学 Haskell，你可能会手写一个函数，但实际上通过 Haskell 自带的函数就能做到这一点。

mconcat [(Just "Hello, "), Nothing, (Just "world!")]

首先，mconcat 是 Haskell 中 Monoid 自带的一个默认实现，它做的事就是把一组元素通过幺半群的二元运算串联起来；其次，Maybe a 类型实现了 Monoid。所以上面的代码可以直接运行。

What are Applicative Functors?

Wed, 14 Nov 2018 00:00:00 GMT

上一篇文章我们讲了函子(functor)是什么，这一篇文章讲一个基于函子的概念——可应用函子(applicative functor)。

动机

我们知道，函子可以描述从元素类型的映射到容器类型之间的映射之间的转换。最常见的应用场景就是 Maybe，下面是 Maybe 的 Functor 实现。请读者熟悉一下，因为后面会用到。

instance Functor Maybe where
  fmap _ Nothing  = Nothing
  fmap f (Just a) = Just (f a)

假设我们有二元运算，叫做 op。我们不管它做了什么，只需要知道它是一个在整数上的二元运算就可以了。

op :: Float -> Float -> Float

因为 Haskell 中的函数都是高阶函数，所以我们 Haskell 程序员常用的一个技巧是用函数只用一半，后半部分留着，需要用的时候再用。

newop = op 0.0

但很多时候我们拿到的值的类型并非是 Float，很有可能是被某个容器类型(container type)包装起来的 Float，比如 Maybe Float。此时我们想把 op 变得在 Maybe Float 上也是可用的，该怎么做呢？如果直接重写一个 opForMaybe，代码大概是这样子的。

opForMaybe :: Maybe Float -> Maybe Float -> Maybe Float
opForMaybe Nothing  _        = Nothing
opForMaybe _        Nothing  = Nothing
opForMaybe (Just x) (Just y) = Just (op x y)

但别忘了我们是 Haskell 程序员，我们要从类型的角度思考问题！很自然地，我们会想到上面的 Functor，毕竟它的作用就是「描述从元素类型的映射到容器类型之间的映射之间的转换」。我们打开 GHCi 来试试。

Prelude> :t fmap op
fmap op :: Functor f => f Float -> f (Float -> Float)

诶？这和我们想的不太一样啊，我们想要的是一个 Maybe Float -> Maybe Float -> Maybe Float 的函数，用 fmap 操作后得到的反而是一个 Maybe Float -> Maybe (Float -> Float) 函数。这就说明 Functor 在此刻肯定不能满足我们的需求——把一个二元的操作映射到对容器类型的二元操作，我们要构造一个至少可以用于二元函数的 Functor。

构造

上面的小节展示了一种 Functor 不能满足需求的情况，下面我们就来想一下如何解决这个问题。如果我们仿照 Functor 的定义，去构建一个可以用于二元函数的 Functor，写出来的东西会是下面这个样子。

class BinaryFunctor f where
  bfmap :: (a -> b -> c) -> f a -> f b -> f c

二元还好，如果是三元、四元、甚至十元函数，那我们岂不是要一个一个写？作为喜欢抽象的 Haskell 程序员，肯定不能就此屈服，我们要实现更加通用的东西。为了看出哪里可以改进，我们随便把一个三元函数套用到上面的 BinaryFunctor 中。

Prelude> :t op3
op3 :: Float -> Float -> Float -> Float
Prelude> :t bfmap op3
bfmap op3 :: BinaryFunctor f => f Float -> f Float -> f (Float -> Float)

观察类型我们可以发现，和上一节 GHCi 的结果一样，得到的函数签名的最后一个类型都是 f (Float -> Float)，所以与其给 $n$ 元函数设计不同的 Functor，我们不如直接设计一个把 f (a -> b) 转换为 f a -> f b 的抽象。写出来大概就是这个样子的。

class Functor' f where
  fmap' :: f (a -> b) -> f a -> f b

我们手动给 Maybe 实现一下。

instance Functor' Maybe where
  fmap' Nothing  _        = Nothing
  fmap' _        Nothing  = Nothing
  fmap' (Just f) (Just x) = f x

这样就完美了！不过还有个问题：我们对第一个参数 Maybe a 做了过多的解构(destruct)，讨论了每一种情况，这样有点重复造轮子，通过重用 Functor 中的 fmap，我们可以实现得更加简洁。

class Functor f => Functor' f where
  fmap' :: f (a -> b) -> f a -> f b

instance Functor' Maybe where
  fmap' Nothing  _ = Nothing
  fmap' (Just f) x = fmap f x

登场

我们定义的 Functor' 其实就是 Applicative，来看看它的定义。

class Functor f => Applicative f where
    {-# MINIMAL pure, ((<*>) | liftA2) #-}

    pure :: a -> f a

    (<*>) :: f (a -> b) -> f a -> f b
    (<*>) = liftA2 id

    liftA2 :: (a -> b -> c) -> f a -> f b -> f c
    liftA2 f x = (<*>) (fmap f x)

    (*>) :: f a -> f b -> f b
    a1 *> a2 = (id <$ a1) <*> a2

    (<*) :: f a -> f b -> f a
    (<*) = liftA2 const

Applicative 中居然有五个成员，我们分别解读一下。

<*> 其实就是我们上面定义的 fmap' 函数，它们的类型签名一模一样。
我们发现了一个熟悉的成员 liftA2，它的函数签名和我们第一版的 Functor' 的一模一样！其实这二者之间是可以相互转换的，只不过我们之前没有发现。
除此之外，还有一个 pure 函数，它的作用我们现在暂且不提，因为要在引入新的概念后才能明白。
而 *> 和 <*，可以理解为是 Functor 中的 <$ 操作符，忽略其中的一个参数，直接给出定值。

What are Functors?

Fri, 12 Oct 2018 00:00:00 GMT

初学 Haskell 时，总是不太理解函子(functor)的概念。虽然看了很多文章，但还是感觉隔着一层迷雾。最近写了很多 TypeScript，和类型系统做了很多搏斗（笑），再回来看函子的概念，突然感觉比之前更清晰了。

很多数据结构，用范型(generic)描述起来大都是 Structure<T> 的形式，例如 LinkedList<T>、BinarySearchTree<T> 和 Optional<T> 等等。这类数据结构虽然对数据的组织各有差异，但都建构于某个类型之上，或者说「持有」某个类型的数据。在下文中，我们称之为容器类型(container types)。

对容器类型来说，一个常见的操作就是对容器中的元素进行遍历，以生成新的元素。在没有这个抽象的情况下，你可能会写很多种不同的遍历。有了函子后，这种重复工作可以被抽象成一个简单的 fmap 函数，你可以把某个在原始类型上的变换，转换为在容器类型上的变换。当然，这是最直观的理解，如果你去翻 Haskell 中 Functor 的定义，你会发现其中还有一个操作符 <$。

class Functor f where
  fmap :: (a -> b) -> f a -> f b

  (<$) :: a        -> f b -> f a
  (<$) = fmap . const

它是做什么用的？回忆一下 const 的定义。

const :: a -> b -> a
const x _ = x

带入到上面的函数，可以看出，它代表了一个最常见的操作——丢掉原来容器类型里的内容，把某个有价值的变量（用 $ 表示）输送（用 < 表示）到一个容器类型中，这么看 <$ 这个符号还是挺传神的。

什么是自函子(endofunctor)？

我相信大家都听过这句话了：「单子(monad)不就是自函子(endofunctor)范畴上的一个幺半群(monoid)吗？有什么难理解的？」自函子(endofunctor)的定义用一句话就能概括：它是一种特殊的函子，其变换的输入类型（定义域）和输出类型（值域）是同一个类型。

Haskell 中自带 Endo 类型，它的定义是参数和返回值都是相同类型的一元函数。

newtype Endo a = Endo { appEndo :: a -> a }

值得一提的是，endo 这个前缀来源于希腊语的 ἔνδον(endon)，含义是「在…里面，内部的，被…吸收或包含的(within, inner, absorbing, or containing)」。

有关 `fmap` 和 `map` 命名

最开始读《Real World Haskell》的时候，看着示例代码里成片的 fmap，我心里浮现出一个疑问：fmap 在数组类型上的实现明明和 map 相同，为什么不直接把 Functor 中的 fmap 改名为 map 呢？后来我在 Haskell 的 wiki 上看到了这个问题的解答。

Why not just do away with the current list-only map function, and rename fmap to map instead? Well, that’s a good question. The usual argument is that someone just learning Haskell, when using map incorrectly, would much rather see an error about lists than about Functors.

Rewrite foldl with foldr, explained

Sun, 26 Aug 2018 00:00:00 GMT

📣 本文修订于 2020 年 11 月 27 日。

问题

在《Real World Haskell》一书中，作者在 95 页中给出了一个神奇的实现：用 foldr 实现 foldl，并在下面附上了一段话。

Understanding foldl in terms of foldr

If you want to set yourself a solid challenge, try to follow our definition of foldl using foldr. Be warned: this is not trivial! You might want to have the following tools at hand: some headache pills and a glass of water, ghci (so that you can find out what the id function does), and a pencil and paper.

You will want to follow the same manual evaluation process as we just outlined to see what foldl and foldr were really doing. If you get stuck, you may find the task easier after reading “Partial Function Application and Currying” on page 100.

大意就是说：理解这个还是比较困难的，准备好笔和纸（以及头疼药）再来思考这个问题。作为爱思考的函数式编程爱好者我偏不信这个邪，本文就是在我苦苦思考后写出的一种容易理解的解释。

观察

如果你对 foldr 和 foldl 两个函数十分熟悉，知道它们是如何求值的，那就可以跳过这一节。

先来看看它们的定义：

foldr :: (b -> a -> a) -> a -> [b] -> a
foldr f z []     = z
foldr f z (x:xs) = x `f` foldr f z xs

foldl :: (a -> b -> a) -> a -> [b] -> a
foldl f z []     = z
foldl f z (x:xs) = foldl f (z `f` x) xs

为了搞清楚这两个函数究竟在做什么，我们分别在 folr 和 foldl 上应用函数 (+)、整数 0 和列表 [1, 2, 3, 4]。

  foldr (+) 0 [1, 2, 3, 4]
= 1 + (foldr (+) 0 [2, 3, 4])
= 1 + (2 + (foldr (+) 0 [3, 4]))
= 1 + (2 + (3 + (foldr (+) 0 [4])))
= 1 + (2 + (3 + (4 + (foldr (+) 0 []))))
= 1 + (2 + (3 + (4 + 0)))

  foldl (+)     0                     [1, 2, 3, 4]
= foldl (+)    (0 + 1)                [2, 3, 4]
= foldl (+)   ((0 + 1) + 2)           [3, 4]
= foldl (+)  (((0 + 1) + 2) + 3)      [4]
= foldl (+) ((((0 + 1) + 2) + 3) + 4) []
=			      ((((0 + 1) + 2) + 3) + 4)

仔细观察求值结果可以发现：foldr 把初始运算元 z 放在列表的最右边，每次取最右边的两个元素，应用二元函数 f 求出结果，并把结果放回最右边；而 foldl 做的事情恰好相反，它把初始运算元放在列表最左边，每次取最左边的两个元素，应用二元函数 f 求出结果，并把结果放回最左边。

你可能会问：两个表达式运算后的结果不是一样吗？这是因为我们用了 (+) 作为二元函数，而 (+) 满足交换律，如果选择一个没有交换律的二元函数，比如 (-) 那么结果就会大不相同了。

通过观察 foldl 和 foldr 的求值过程，我们可以发现，foldl 的运算顺序是一棵左偏树(leftist tree)，而 foldr 的运算顺序可以用一棵右偏树(rightist tree)表示，两个函数的差别主要在于运算顺序。所以用 foldr 重写 foldl，本质上就是要用 foldr 来模拟 foldl 的运算顺序。

函数和数据

在 Haskell 中，如果让你实现一个表示二维实数空间上的一个点，你会怎么表示？我们的第一想法就是去构造新的类型。

data Point = Point Float Float

point :: Float -> Float -> Point
point x y = Point x y

我们可以通过模式匹配(pattern matching)获得结构中的数据。

getX :: Point -> Float
getX (Point x _) = x

getY :: Point -> Float
getY (Point _ y) = y

在《计算机程序设计的构造和解释》的第二章里，作者介绍了数据抽象(data abstraction)的概念。作者演示了如何用函数去构造 cons、car 和 cdr 这三个基本函数。

(define (cons x y)
  (define (dispatch m)
    (cond ((= m 0) x)
          ((= m 1) y)
          (else (error "Argument not 0 or 1 -- CONS" m))))
  dispatch)
(define (car z) (z 0))
(define (cdr z) (z 1))

在这个例子里，cons 所返回的不是传统意义上的数据(data)，而是一个接受更多参数的函数。car 和 cdr 就是通过对这个函数进行进一步求值而得到所需的值的。

带着这个例子所给我们的启示，我们可以在不构造新类型的情况下定义一个点。

point :: Float -> Float -> Bool -> Float
point x y t = if t then x else y

getX :: (Bool -> Float) -> Float
getX pt = pt True

getY :: (Bool -> Float) -> Float
getY pt = pt False

你会发现，上面代码里的 point、getX 和 getY 的用法和最初的版本并没有什么差别。Bool -> Float 其实和 Point 无异，都是一个可以表示出两个坐标的类型。讲到这，你可能已经明白了这道题的做法。

构造

上一节的内容启发了我们，我们可以用 foldr 构造一个结构，再把这个结构按照 foldl 的方法展开并计算，就可以达到我们的目的了。

我们先对 foldr 进行拆分，把它分为两部分：构造右偏树(rightist tree)和对右偏树结构进行求值。我们定义出右偏树类型 FoldRight，它有两个类型构造器(type constructor)：

第一个是 Compute x y，其中 x 是列表中的元素，y 是嵌套的 FoldRight a，表示计算；
第二个是 Stop 表示已经到了尽头，不需要计算了。

data FoldRight a = Compute a (FoldRight a)
                 | Stop

我们可以轻松用 foldr 写出从数组中构建 FoldRight 的函数。

makeFold :: [a] -> FoldRight a
makeFold = foldr f Stop
    where f x y = Compute x y

有人可能会问，之所以没有把类型 b 写进去，是因为我们接下来要按照 foldl 的顺序执行计算，也就是 evalFold 函数。

evalFold :: (a -> b -> a) -> a -> FoldRight b -> a
evalFold f z Stop = z
evalFold f z (Compute x y) = evalFold f (f z x) y

evalFold 函数做的事其实很简单，就是把 FoldRight 结构按照 foldl 的顺序进行运算。有了这 makeFold 和 evalFold 我们就可以用 foldr 实现出 foldl。

foldl' :: (a -> b -> a) -> a -> [b] -> a
foldl' f z xs = evalFold f z (makeFold xs)

读者可能会问：虽然你实现出来了，但形式太复杂了，而且书中给出的答案并没有构造中间数据结构。别急，还记得上一节我们提到的可以用高阶函数来表示数据结构吗？我们可以重写 FoldRight 的定义，使之用起来一模一样，但本质上是个函数。

在开始之前，我们要调整一下 evalFold 函数的参数的顺序，把 FoldRight b 变成第一个参数。为了表达清楚，我干脆就把调整过后的函数写出来好了。

evalFold' :: FoldRight b -> (a -> b -> a) -> a -> a
evalFold' Stop f z = z
evalFold' (Compute x y) f z = evalFold' y f (f z x)

把 FoldRight b 调整到第一个后，evalFold' 函数其实是在对 FoldRight 的两种构造进行分情况讨论。如果我们用函数重写了 FoldRight 结构，那么其实可以把每种情况的构造和计算合并成一个函数。

第一步，重写 evalFold' Stop f z。我们可以直接抹掉 evalFold' 这个名字，把 Stop 改成小写。这样就得到了 stop 函数的定义。你可能会开始考虑类型，但这里不妨再等一下，等重写完后，我们再来看类型能不能说得通。

stop f z = z

第二步，重写 evalFold' (Compute x y) f z。同样，我们可以直接抹掉 evalFold 这个名字，把 Compute 改成小写，并去掉构造的括号，我们就得到了 compute 的定义。

compute x y f z = y $ f (f z x)

在检查类型前，我们发现 f 在整个过程中保持不变，不如把它当作类似全局变量的东西，所以我们可以直接从两个函数中删掉它。得到新版的 stop 和 compute 定义。

compute x y z = y (f z x)
stop z = z

这个定义就非常简洁了，stop 就是一个 id 函数，我们尝试写出它们的类型，发现完全可以跑得通。

compute :: b -> (a -> a) -> a -> a
stop :: a -> a

观察一下结构，其实 a -> a 就是用于代替 FoldRight 的类型。接下来，把我们新的实现带回到上面的实现中，经过下面的三步替换，就可以得到书中的版本了。

foldl'   f z xs = evalFold f z (makeFold xs) -- Step 1
foldl''  f z xs = evalFold' (makeFold xs) f z -- Step 2
foldl''' f z xs = foldr compute stop f z -- Step 3

作业

是不是很神奇？来尝试做一下下面的作业吧。

请尝试用类似的方法，用 foldl 实现 foldr。
完成 1 后，思考 foldl 和 foldr 之间的关联。

Create New Types in Haskell

Fri, 09 Mar 2018 00:00:00 GMT

在 Haskell 中，我们有几种方法定义新类型？

`data` 关键字

这是我学 Haskell 后第一个接触的类型定义方法，其类型声明体(body)有两种写法：类型构造器(type constructor)和记录(record)语法。

类型构造器(type constructor)由构造器名和跟在后面的类型组成，直觉上有点像一个具有名字的元组(tuple)类型。在没有太多字段的时候，或者字段不需要名字的时候，这种方法很好用。在模式匹配中，我们也可以直接用构造器的语法来解构(destruct)。

data Vector a = Vector a a

length :: Floating a => Vector a -> a
length (Vector x y) = sqrt (x * x + y * y)

记录(record)语法比较特别，看上去像是在 C 和 C++ 的 struct 一样定义结构体。但其中的字段其实并不能用 object.property 的形式来访问，字段名实际上是函数。

data Address = Address { city :: String, street :: String }

-- Run `:t city` and you will get
-- city :: Address -> String

最后一点，data 关键字可以快速声明联合类型(tagged union)，或者说和类型(sum type)。大家常用的 Maybe 就是这样声明出来的。

data Maybe a = Just a
             | Nothing

`type` 关键字

type 关键字的作用是定义类型别名。其用法就像 C 和 C++ 的 typedef 一样。但因为可以带有类型参数，在表达能力上更像 C++ 11 后的 using 关键字。

type Point a = (a, a)

origin :: Point Float
origin = (0.0, 0.0)

并且新的名字的类型和旧的类型仍然兼容，其可以用在为旧类型所写的函数中，也可以用旧类型的构造器进行解构。

zero = fst origin

-- Destructing like tuples
distance :: Floating a => Point a -> Point a -> a
distance (x1, y1) (x2, y2) =
    let dx = x1 - x2
        dy = y1 - y2
    in sqrt (dx * dx + dy * dy)

`newtype` 关键字

除了 data 和 type，Haskell 还有个叫做 newtype 的关键字。其用法和 data 相同，但有两个限制：

只能有一个构造器(constructor)，所以不能声明联合类型(tagged union)；
构造器中只能有且仅有一个字段(field)。

举个例子，下面两个声明，GHC 就会报错。

newtype Maybe a = Just a | Nothing
newtype Vector a = Vector a a

换言之，把你代码中的 newtype 都替换成 data 后代码也可以正常编译，但反过来，如果把 data 都替换成 newtype，就不能编译了。那么喜欢刨根问底的读者可能就会问了：为什么要设计这个 newtype 关键字呢？都用 data 关键字不就行了吗？

newtype 可以保证这个类型对类型检查器是零开销的。newtype 声明的类型构造器在编译时会直接被又划掉。我们知道 Haskell 在默认情况下是懒惰求值(lazy evaluation)的，所以大量的只有一个字段的类型构造器可能会消耗运行时大量的空间，特别是当这些类型嵌套后，可能会生成很多懒惰执行的代码。所以 Haskell 的一篇 wiki 文章中也推荐人们把只有一个构造器且构造器中只有一个字段的类型用 newtype 来声明。

A New Perspective into Fourier Transformation

Wed, 17 Jan 2018 07:32:59 GMT

昨天复习数字图像处理到很晚，最大的收获就是一不小心搞懂了离散傅立叶变换，原来这东西也没那么难。这里简单记录一下。

我们知道，数学中很经常把一种东西在另外一种表示方式中写出来，比如我们所常用的二维笛卡尔坐标中的点就可以转换成极坐标中的点，本质上就是给点换了一套「基」。傅立叶变换实际上也是做了一样的事，我们把在原有基上的数据用另外一种新的基表示了出来，只不过这里的数据不再是点了，而是函数，我们把原有的基构成的空间叫做时域（在数字图像处理中也叫做空间域），新的基构成的空间叫做频率域。

那么这个基是什么呢？就是我们在傅立叶变换中看到的指数项，比如在一维离散傅立叶变换

F(u)=\frac{1}{n}\sum_{x=0}^nf(x)\mathrm e^{-\mathrm i2\pi ux/n}

中，基是 $\mathrm e^{-\mathrm i2\pi ux}$ 。你可能会有疑问，这个基是与 $x$ 相关的，它不是一个常量啊，这里我们换一种表示方法，用点积重写上面的式子，得到 $F(u)=\boldsymbol y\cdot\mathbf e(u)$ ，其中 $\boldsymbol y=(f(x_0),f(x_1),\cdots,f(x_{n-1}))^T$ 、 $\mathbf e(u)={\left(\mathrm e^{-\mathrm i2\pi u/n},\mathrm e^{-\mathrm i2\pi u\times 2/n},\cdots,\mathrm e^{-\mathrm i2\pi u\times (n-1)/n}\right)}^T$ ——到这里已经很明显了，我们知道一个向量对基向量的点积是这个向量在这个基上的投影长度，也就是在这个基上的分量，所以我们也就知道了 $F(u)$ 的含义—— $F(u)$ 代表了 $f$ 在这个基上的分量，如果我们把 $F(i) \quad 0\le i< n$ 都求出来，我们就得到了 $f$ 在 $n$ 个基上的分量，也就是傅立叶变换的结果。

说到这里，我们会发现离散傅立叶变换的输入——离散函数 $f$ 实际上就像一个 $n$ 维空间中的点，而我们只是求了这个点在某个 $n$ 维空间中的坐标。如果你对矩阵很熟悉的话，你会发现整个过程可以写成一个矩阵乘法，我们令 $\boldsymbol y$ 保持上一段中的定义，令矩阵 $\boldsymbol{\mathscr F}=(\mathbf e(0), \mathbf e(1), \cdots, \mathbf e(n-1))$ ，傅立叶变换的结果就可以写成 $\boldsymbol F=\boldsymbol{\mathscr F y}$ 。很巧的是，矩阵 $\boldsymbol{\mathscr F}$ 的共轭转置乘上它自己的结果是 $n$ ，也就是说，我们有 $\boldsymbol{\mathscr F}^{-1}=\frac{1}{n}\boldsymbol{\mathscr F}^\ast$ ，我们以一种很自然的方式得出了傅立叶变换的逆变换。

Notes on Support Vector Machine

Tue, 19 Dec 2017 14:54:25 GMT

这篇文章是我在学习支持向量机时写的综述性质的笔记，简要介绍了支持向量机的理论推导以及如何实现（二次规划和 SMO 算法）。这篇文章综合了许多资料中的结果，在这里向这些资料的作者表示感谢，我在文章最后的参考一节列出来这些资料，并且注明了每篇资料所讲述的侧重点。如果看不懂我的文章，这些资料也是很好的入门点。

问题表述

支持向量机所要解决的问题表述起来非常简单：有一簇点被分为了互不相交的两类，我们要找一个界把这两类点恰好分开。在这一节，我们从二维形式中开始，把问题讲清楚。

二维空间中的表述

直线可以表示为 $y=kx+b$ ，然而这样是不够的，我们需要使用更一般的形式 $Ax+By+C=0$ ，其实就是把向量形式 $(A,B)\cdot(x,y)+C=0$ 拆开写。有了这个直线后，任意给空间中的一个点 $(x_0,y_0)$ ，把它带入直线方程，可以得到三种结果：

$Ax_0+By_0+C>0$ ：点在直线的某一侧。
$Ax_0+By_0+C=0$ ：点在直线上。
$Ax_0+By_0+C<0$ ：点在直线的另一侧。

不考虑在直线上的点，即第二种情况，我们的直线就是一个完美的分界标准，如果设 $f=Ax+By+C$ ，这样 $f$ 就是一个完美的分类器。

高维空间中的表述

好了，现在把它拓展到 $n$ 维空间上，我们就得改改叫法了——点还是原来的点，直线变成了超平面（hyper-plane）。直线的表示方法也不一样了，我们不把点的每一个分量都写出来，而是用向量的形式来表示： $\boldsymbol w^T\boldsymbol x+b=0$ ，其中 $\boldsymbol x$ 是点， $\boldsymbol w$ 是点的每个分量所乘的系数， $b$ 是一个数，它的作用类似于二维直线中截距的东西，没有它的话我们的超平面一定经过原点。

在本节（问题表述）中，我们混用「超平面」和「线」这两个术语，举例也在二维空间中举例（大于三维的我也举不出来啊）。

最优化目标

我们肯定不会找一条线就草草了事，我们要选一条最好的线，问题来了——什么叫最好的线？我们需要一个可以量化的标准，这时就很自然地想到了线的方程 $\boldsymbol w^T\boldsymbol x+b=0$ ，我们设 $f(\boldsymbol x)=\boldsymbol w^T\boldsymbol x+b$ ，我们可以很容易地验证，点到这条线的距离越远， $f$ 的值越大。但是用 $f$ 的值作为度量并不好，因为它是与 $\boldsymbol w$ 和 $b$ 的取值相关的，如果它们两个成比例增加， $f$ 的值会在直线不变的情况下增加。这并不好。但这个值也并非没有用，我们管它叫作函数间隔（functional margin）。

这时候就会考虑一下几何意义，我们可以选择点到直线的几何距离作为度量，设点为 $\boldsymbol x$ ，直线为 $\boldsymbol w^T\boldsymbol x+b=0$ ，点到直线的距离为 $\gamma$ ，令 $\boldsymbol x_0$ 为 $\boldsymbol x$ 在直线上的投影，我们可以写出它们之间的关系

\boldsymbol x-\boldsymbol x_0=\gamma\frac{\boldsymbol w}{\|\boldsymbol w\|}

要理解这个式子，首先要明白 $\boldsymbol w$ 是直线的法向量。现在对式子的两边都应用函数 $f$ ，会有

\begin{aligned} f(\boldsymbol x-\boldsymbol x_0)&=f\left(\gamma\frac{\boldsymbol w}{\|\boldsymbol w\|}\right)\\ \boldsymbol w^T\boldsymbol x-\boldsymbol w^T\boldsymbol x_0+b&=\boldsymbol w^T\gamma\frac{\boldsymbol w}{\|\boldsymbol w\|}+b\\ \boldsymbol w^T\boldsymbol x+b-\boldsymbol w^T\boldsymbol x_0-b&=\gamma\frac{\boldsymbol w^T\boldsymbol w}{\|\boldsymbol w\|}\\ \boldsymbol w^T\boldsymbol x+b-0&=\gamma\|\boldsymbol w\|\\ \frac{\boldsymbol w^T\boldsymbol x+b}{\|\boldsymbol w\|}&=\gamma \end{aligned}

这样我们就求出了这个距离 $\gamma$ ，很巧的是，它恰好是我们的函数间隔除以 $\|\boldsymbol w\|$ 。

To be done.

对偶问题到二次规划

我们的原始优化目标是

\min_\boldsymbol w \frac12 \|\boldsymbol w\|^2 \quad \text{subject to} \quad(\forall i)y_i(\boldsymbol w^T \boldsymbol x_i-b)\ge 1

但是解这个问题的话我们的算法就不能叫做支持向量了，因为解这个问题不会告诉我们有关支持向量的任何信息。这时候就要用到一个叫做拉格朗日对偶的东西，简而言之，就是把约束条件当作优化目标的一部分，把上面的优化目标里的函数改写成下面的形式

\mathscr L(\boldsymbol w, b, \boldsymbol \alpha)=\frac 12 \|\boldsymbol w\|^2-\sum_i\alpha_i\left[y_i\left(\boldsymbol w^T\boldsymbol x_i-b\right)-1\right] \quad (\forall i)\alpha_i\ge 0

注意！上面的式子并不是我们的优化目标，我们的优化目标实际上是

\min_{\boldsymbol w,b}\max_\boldsymbol\alpha\mathscr L(\boldsymbol w, b, \boldsymbol \alpha) \quad \text{subject to} \quad (\forall i) \alpha_i\ge 0

记住这一点，然后我们回来讨论上面的这个变换是什么意思。首先介绍这个 $\boldsymbol \alpha$ ，这些 $\alpha_i$ 有一个酷炫的名字「拉格朗日乘子」，它的目的是控制住原来的约束条件，使之保持成立。举个例子，假设存在某个 $i$ ，使得 $y_i(\boldsymbol w^T\boldsymbol x_i - b)<1$ ，我们的原约束条件肯定不会成立，而且在对偶问题的约束条件里，这个 $i$ 会使得 $\mathscr L(\boldsymbol w,b,\boldsymbol \alpha)$ 变成一个很大的值，这显然不是被优化目标中的 $\min$ 所取到，故优化目标实际上和原来的优化目标等价。

这个优化目标的另一个特性就是它满足 KKT 条件，故我们可以把这个问题变形成

\max_\boldsymbol\alpha\min_{\boldsymbol w,b}\mathscr L(\boldsymbol w, b, \boldsymbol \alpha) \quad \text{subject to} \quad (\forall i) \alpha_i\ge 0

的形式，也就是说，交换 $\min$ 和 $\max$ 的位置以后，问题仍然等价（注意只有满足 KKT 条件的问题才可以这样做）。上面这个式子非常方便我们求解，为什么呢？因为 $\min$ 被换到内部了，这样我们就可以求它们的极小值

\begin{aligned} \frac{\partial L}{\partial\boldsymbol w}=0&\Rightarrow\boldsymbol w=\sum_i \alpha_i y_i \boldsymbol x_i \\ \frac{\partial L}{\partial b}=0&\Rightarrow\sum_i\alpha_i y_i=0 \end{aligned}

这样我们就有了 $\boldsymbol w$ 和 $\boldsymbol\alpha$ 的关系了，而 $b$ 已经在我们的最优化目标中消失了。此时把 $\boldsymbol w$ 代回优化目标中。

\begin{aligned} \mathscr L(\boldsymbol w,b,\boldsymbol\alpha) &=\frac12\|\boldsymbol w\|^2-\sum_i\alpha_i[y_i(\boldsymbol w^T\boldsymbol x_i+b)-1]\\ &=\frac12\boldsymbol w^T\boldsymbol w-\sum_i\alpha_iy_i\boldsymbol w^T\boldsymbol x_i-\sum_i\alpha_i y_ib+\sum_i\alpha_i\\ &=\frac12\boldsymbol w^T\boldsymbol w-\boldsymbol w^T\sum_i\alpha_i y_i\boldsymbol x_i-0+\sum_i\alpha_i\\ &=\frac12\boldsymbol w^T\boldsymbol w-\boldsymbol w^T\boldsymbol w+\sum_i\alpha_i\\ &=-\frac12\boldsymbol w^T\boldsymbol w+\sum_i\alpha_i\\ &=-\frac12\left(\sum_i \alpha_i y_i \boldsymbol x_i\right)^T\left(\sum_i \alpha_i y_i \boldsymbol x_i\right)+\sum_i\alpha_i\\ &=-\frac12\left(\sum_i \alpha_i y_i \boldsymbol x_i^T\right)\left(\sum_i \alpha_i y_i \boldsymbol x_i\right)+\sum_i\alpha_i\\ &=-\frac12\sum_i\sum_j\alpha_i\alpha_jy_iy_j\boldsymbol x_i^T\boldsymbol x+\sum_i\alpha_i \end{aligned}

这样原来的优化目标 $\max_\boldsymbol\alpha\min_{\boldsymbol w,b}\mathscr L(\boldsymbol w,b,\boldsymbol \alpha)$ 就变成了

\max_\boldsymbol\alpha\left(-\frac12\sum_i\sum_j\alpha_i\alpha_jy_iy_j\boldsymbol x_i^T\boldsymbol x_j+\sum_i\alpha_i\right)

在前面加一个符号，把它变成一个最小化问题

\min_\boldsymbol\alpha\left(\frac12\sum_i\sum_j\alpha_i\alpha_jy_iy_j\boldsymbol x_i^T\boldsymbol x_j-\sum_i\alpha_i\right)

最后，别忘了限制条件

\min_\boldsymbol\alpha\left(\frac12\sum_i\sum_j\alpha_i\alpha_jy_iy_j\boldsymbol x_i^T\boldsymbol x_j-\sum_i\alpha_i\right) \\ \text{subject to} \quad (\forall i)\alpha_i\ge 0 \quad \text{and} \quad \sum_i\alpha_iy_i=0

这个问题是一个非常标准的二次规划（quadratic programming）。二次规划的问题描述如下

\min_\boldsymbol x \left( \frac12\boldsymbol x^TP\boldsymbol x+\boldsymbol q^T\boldsymbol x \right) \\ \text{subject to} \quad G\boldsymbol x\le\boldsymbol h \quad \text{and} \quad A\boldsymbol x=\boldsymbol b

我们设

$\boldsymbol x=\boldsymbol\alpha$
$P_{ij} = y_iy_j\boldsymbol x_i^T\boldsymbol x_j$
$\boldsymbol q=-\boldsymbol 1$
$G=-I$
$\boldsymbol h=\boldsymbol 0$
$A=\mathrm{diag}(\boldsymbol y)$
$\boldsymbol b=\boldsymbol 0$

就可以把我们的优化目标完美地套在了二次规划问题的模子上。有很多现成的库可以解二次规划问题，比如 Python 中的 CVXOPT，这个库在 Linux 和 macOS 上都可以直接使用 pip 安装，在 Windows 上可以使用这里的预编译包。代码如下：

def model(x, y):
    n_samples, n_features = x.shape
    yx = y[:, np.newaxis] * x
    P = cvxopt.matrix(np.dot(yx, yx.T))
    q = cvxopt.matrix(-np.ones(n_samples, 1))
    G = cvxopt.matrix(-np.eye(n_samples))
    h = cvxopt.matrix(np.zeros(n_samples))
    A = cvxopt.matrix(y.reshape(1, -1))
    b = cvxopt.matrix(np.zeros(1))
    solution = cvxopt.solvers.qp(P, q, G, h, A, b)
    return np.aligned(solution['x'])

这个函数中的 x 代表所有点的集合，y 代表值域为 $\{-1,1\}$ 的分类集合。

如果你不想用库，自己写一个也没什么问题，这篇文章简单介绍了如何手动求解二次规划问题。

解决噪音问题

我们现在的支持向量机解决不了什么实际问题，因为它能处理的情况实在是太理想了——数据必须线性可分而且不能容忍噪音。线性可分这个问题我们下一节再讲，这一节先来解决噪音的问题。

噪音会使我们现在的支持向量机直接崩溃，因为如果出现噪音我们的约束条件就不能被满足，二次规划问题也会变得不可解。怎么办呢？我们的目标实际上是「容忍」噪音，换句话说，我们允许有一定的噪音出现在数据集里。怎么去「容忍」呢？答案当然是修改我们的约束条件了。我们加入一个变量 $\boldsymbol\xi=(\xi_i)$ ，描述第 $i$ 个点最多偏离超平面的距离。原始问题就变成了

\min_{\boldsymbol w,\boldsymbol\xi}\left(\frac12\|\boldsymbol w\|^2+C\sum_i\xi_i\right) \\ \text{subject to} \quad (\forall i)y_i(\boldsymbol w^T\boldsymbol x+b)\ge 1-\xi_i

我们不能无限度地「容忍」，所以变量 $\boldsymbol\xi$ 就被加入了优化目标中，前面的常数 $C$ 起到了类似权重的作用，叫做惩罚参数或正则化参数。惩罚参数的值越小，代表我们对噪音的容忍度越小。

这样一来，模型就被改变了，故我们也需要重新推导其对偶问题了。首先用拉格朗日对偶重写，得到

\begin{aligned} \mathscr L(\boldsymbol w, b, \boldsymbol \xi,\boldsymbol \alpha, \boldsymbol \mu) &=\frac12\|\boldsymbol w\|^2+C\sum_i\xi_i\\ &-\sum_i\alpha_i[y_i(\boldsymbol w^T\boldsymbol x - b) - 1+\xi_i]-\sum_i\mu_i\xi_i \end{aligned}

我们现在要优化的目标函数就变成了

\min_{\boldsymbol w,b,\boldsymbol\xi}\max_{\alpha_i\ge 0,\mu\ge 0}\mathscr L(\boldsymbol w,b,\boldsymbol\xi,\boldsymbol\alpha,\boldsymbol\mu)

如我们所愿，这个问题也满足 KKT 条件（证明以后补充），还是同样的方法，它可以被转换成对偶问题

\max_{\alpha_i\ge 0,\mu\ge 0}\min_{\boldsymbol w,b,\boldsymbol\xi}\mathscr L(\boldsymbol w,b,\boldsymbol\xi,\boldsymbol\alpha,\boldsymbol\mu)

而保证问题的等价性。

\begin{aligned} \frac{\partial\mathscr L}{\partial\boldsymbol w}=0 &\Rightarrow\boldsymbol w=\sum_i\alpha_iy_i\boldsymbol x_i\\ \frac{\partial\mathscr L}{\partial b}=0 &\Rightarrow \sum_i\alpha_iy_i=0\\ \frac{\partial\mathscr L}{\partial\boldsymbol\xi}=0 &\Rightarrow C-\alpha_i-\mu_i=0 \end{aligned}

把得到的三个结果代回 $\mathscr L$ 中

\begin{aligned} &\mathscr L(\boldsymbol w, b, \boldsymbol \xi,\boldsymbol \alpha, \boldsymbol \mu)\\ &=\frac12\|\boldsymbol w\|^2+C\sum_i\xi_i-\sum_i\alpha_i[y_i(\boldsymbol w^T\boldsymbol x_i + b) - 1+\xi_i]-\sum_i\mu_i\xi_i\\ &=\frac12\boldsymbol w^T\boldsymbol w+C\sum_i\xi_i-\sum_i\alpha_iy_i\boldsymbol w^T\boldsymbol x_i-\sum_i\alpha_iy_ib+\sum_i\alpha_i-\sum_i\alpha_i\xi_i-\sum_i\mu_i\xi_i\\ &=\left(\frac12\boldsymbol w^T\boldsymbol w-\boldsymbol w^T\sum_i\alpha_iy_i\boldsymbol x_i\right)+\sum_i\alpha_iy_ib+\sum_i\xi_i\left(C-\alpha_i-\mu_i\right)+\sum_i\alpha_i\\ &=\left(\frac12\boldsymbol w^T\boldsymbol w-\boldsymbol w^T\boldsymbol w\right)+0+0+\sum_i\alpha_i\\ &=-\frac12\boldsymbol w^T\boldsymbol w+\sum_i\alpha_i\\ &=-\frac12\sum_i\sum_j\alpha_i\alpha_jy_iy_j\boldsymbol x_i\boldsymbol y_i+\sum_i\alpha_i \end{aligned}

我们会发现，得到的结果和不能容忍噪音时的是一样的。这样一来，不同的就只有约束条件了

\begin{aligned} \sum_i\alpha_iy_i&=0\\ C-\alpha_i-\mu_i&=0\\ \alpha_i&\ge0\\ \mu_i&\ge0 \end{aligned}

因为 $\mu_i$ 已经从我们的优化目标中消失了，并且 $C$ 是一个常量，所以我们可以把后三个条件合成一个 $0\le\alpha_i\le C$ 。这样对偶问题最后就可以被写成

\min_{\boldsymbol\alpha}\frac12\sum_i\sum_j\alpha_i\alpha_jy_iy_j\boldsymbol x_i\boldsymbol y_i-\sum_i\alpha_i\\ \text{subject to} \quad (\forall i)0\le\alpha_i\le C \quad \text{and} \quad (\forall i)\sum_i\alpha_iy_i=0

如果要用二次规划求解这个问题，我们需要把它映射到上一节提到的二次规划问题模型。 $P$ 和 $\boldsymbol q$ 不需要改变，需要改变的只有 $G$ 和 $\boldsymbol h$ ——因为我们加入了新的限制条件，即 $\alpha_i \le C$ 。

$G=\begin{pmatrix}I \\ -I\end{pmatrix}$
$\boldsymbol h=\begin{pmatrix}\boldsymbol 0 & \boldsymbol C\end{pmatrix}$

如果使用 CVXOPT 来解这个问题，只需要在上一节的代码上做一个小修改。

def model(x, y, C):
    n_samples, n_features = x.shape
    yx = y[:, np.newaxis] * x
    P = cvxopt.matrix(np.dot(yx, yx.T))
    q = cvxopt.matrix(-np.ones(n_samples, 1))
    G = cvxopt.matrix(np.vstack((-np.eye(n_samples), np.eye(n_samples))))
    h = cvxopt.matrix(np.vstack((np.zeros(n_samples), np.ones(n_samples) * C)))
    A = cvxopt.matrix(y.reshape(1, -1))
    b = cvxopt.matrix(np.zeros(1))
    solution = cvxopt.solvers.qp(P, q, G, h, A, b)
    return np.aligned(solution['x'])

从线性到非线性

上一节的开始我们提到我们的支持向量机无法处理线性不可分的情况，比如经典的同心圆数据集。我们从同心圆数据开始，讨论如何处理非线性可分的数据。

我们知道，在不变换坐标系到极坐标的情况下，我们是无法把二维空间中的椭圆用线性的形式表达出来的，我们只能用

Ax^2+Bxy+Cy^2+Dx+Ey+F=0

这样的二次方程去表示椭圆，这很明显不是线性的，但是如果我们设 $\boldsymbol x=(x,y,xy,x^2,y^2)$ ，即用额外的三个维度表示原来两个维度的平方和积的话，原来的方程就可以写作

Ax_4+Bx_3+Cx_5+Dx_1+Ex_2+F=0

了。这是一个非常完美的线性形式，在把数据用这种方式做过变换后，我们的数据就变成线性可分的（这里先不考虑噪音）了。

然而不要沉浸在喜悦中太久，问题的本质并没有变，我们的数据上并不是五维的，用增加维度的方式解决问题并不是什么好手段（别忘了隔壁做图像处理和神经网络的都在拼命想着怎么给数据降维呢）。如果我们原本的数据变成三维的，类似的处理就会把数据变成 19 维的（即 $T_3^1+T_3^2+T_3^3$ ，其中 $T_n^k$ 为可重组合数）。换句话说，就是维度灾难。

意识到这一点是不可行的，我们就要找一个妥协的办法，回头看我们的对偶问题的优化目标，我们就会发现，我们的数据只在做内积的时候被用到了，一个大胆的想法浮现出来：我们不必真刀真枪地把数据变换到高维空间上，而是只要在做内积的时候计算它们在高维空间的内积就行了。即用一个函数 $\kappa(\boldsymbol x_i,\boldsymbol x_j)$ 来代替内积 $\boldsymbol x_i^T\boldsymbol x_j$ 。我们既不需要更改模型，也不需要变换数据，就完成了线性到非线性的转换，并且之前提到的处理噪音的方法仍然适用。这一技巧被称之为「核技巧（kernel trick）」。

更快的算法

To be done.

参考资料

支持向量机系列文章 by pluskid——介绍支持向量机理论的系列文章，深入浅出。
支持向量机原理 by 刘建平 Pinard——介绍理论的系列文章，每个小的点都讲得很透，公式推导的细节也都写了出来。
Implementing and Visualizing SVM in Python with CVXOPT by Hardik Goel——讲了如何用 CVXOPT 实现一个最简单的支持向量机

First Attempt on Handwritten Digits Recogition

Sun, 26 Nov 2017 17:00:29 GMT

这是我模式识别课的一个实验。简而言之，就是识别手写在纸上的数字。

这个工作仔细分析还是比较简单的，我的实现方式是把整个过程分为许多 stage，每个 stage 只做一件单独的事，这样不仅方便调试（你可以看代码卡在了哪一步，或者单独显示哪一步的输出）而且写出来的代码也比较漂亮（不至于出现过了一段时间看不懂的情况）。

我把整个流程分为了以下的几个 stage：

loader - 加载图片
thresholding - 去噪声和二值化
scissor - 裁剪图片
normalizer - 处理裁剪后的单个数字
recognizer - 识别裁剪后的单个数字
marker - 把结果标注在原图片上

前三个步骤都可以直接调用 OpenCV 的函数完成。第四个稍稍费了些脑筋，为了提高准确率，我在裁剪出的每个数字周围添加了一圈补白，使之构成正方形图像（方便在下一个 stage 喂给神经网络）；然后用到了一个神奇的 deskew 函数来矫正倾斜；接着缩放成 28x28 的大小（神经网络是用 MNIST 训练的）；因为大的数字图片缩小后会出现笔画变得极细的问题，所以最后还需要做一个膨胀操作。

第五步就是最不必说的东西了……我偷了懒没用 TensorFlow，而是用了比较傻瓜的 Keras，不过好处就是构建起来快……可以把更多的时间花费在优化识别率上。

有一个值得一提的小插曲。我的最初版本在 9 的识别率上非常低，经常被误识别成 1 或 7。其原因是大家写 9 的时候会写的比较长，导致缩放成 28x28 后「9」上面的圈会变得极小无比，看起来就像是个 1 或者 7。解决这个问题的办法非常简单，就是在 MNIST 数据集上做了一个小手术：

def transform_nine(x_train, y_train):
    x_superset = []
    y_superset = []
    for x, y in zip(x_train, y_train):
        if y == 9 and random.random() < 0.5:
            upper = x[0:14,:]
            lower = x[14:,:]
            stretched = numpy.zeros(shape=(35, 28))
            stretched[0:14,:] = upper
            stretched[14:,:] = cv2.resize(lower, (28, 21), interpolation=cv2.INTER_AREA)
            stretched = cv2.erode(stretched, (7, 7))
            stretched = cv2.resize(stretched, (28, 28), interpolation=cv2.INTER_AREA)
            x_superset.append(stretched)
            y_superset.append(9)
        else:
            x_superset.append(x)
            y_superset.append(y)
    return numpy.array(x_superset), numpy.array(y_superset)

这段代码做的事情就是把数据集中一半的 9 的下半部分拉长了，使得它们变得像我们写的 9 缩放成 28x28 的样子。这个做法虽然简单暴力但是效果拔群。听老师讲这种手段还有一个高大上的名字叫 domain adaption 哈哈哈哈哈。最终的效果如下，这是我手写的一堆数字以及程序的识别结果。

代码在 GitHub 上。

Blog Feature Test

Sat, 01 Jan 2000 00:00:00 GMT

This post is intended to test features I developed. The publication date is not real.

Equation

Some centered equation made by $\KaTeX$ ¹.

x = \frac{-b\pm\sqrt{b^2 - 4ac}}{2a}

Blocks

Use as your own risk!

Equations in this post is not validated. For example, $n = n + 1$ .

This is a title!

The information in this post may be outdated.

Let’s quote something.

A math typesetting library for the web.
↩

Luyu Cheng

Recently

Purchasing

Reading

Listening

Photography

Watching

A Tour of Implementing TAPL in Scala

Singleton Object

While Statements

Deal with Option

Derive with Exceptions

Operator Overloading

Parsing Rules

Conclusion

Migrate My Blog to Cloudflare Workers

在 Apple Silicon 上安装 Cloudflare Wrangler

配置 Wrangler 项目

给 Cloudflare Workers 添加域名

配置 GitHub Actions

Set Up Development on Apple Silicon MacBook Pro

Package Manager

Editor (or IDE)

Node.js Projects

Sign off commits with GPG keys

Develop Node.js Projects with WSL 2

Network Issues

Intall Node.js and Yarn

Install Dependencies

Signing Commits Using GPG

Some Old Posts about Haskell

Guidelines for Writing Blog Posts

Thoughts on My Photography

Photograph Partial Solar Eclipse

准备

拍摄

后处理

反思

A Brief History of My Blog

2020

2019

2018

2017

2015

2014

2013

Thoughts on Visualization Authoring

关于工作流(workflow)

设计

实现

微调

关于信息图表(infographics)

可视化库适合做信息图表吗？

信息图表的银弹(silver bullet)究竟存不存在？

Enable HiDPI on a 4K Sony TV in macOS

Draw Text with WebGL

Character Bitmap

Vectorized Text

An OpenType Way

Conclusion

Why I Switch from Sony to Canon

How Did I Set up a New Mac

Figma Announced Auto Layout

Gear Doesn't Matter

I Use These

Root Devices

Intangible Tools

Work and Self-Help

Entertainment

Tangible Objects

Digital Devices

Daily Matters

What Is Random Art Image

My Todo List Rules

Why use Todo List

Toolkit Requirements

Does Inbox Really Matters?

Rules for Read-it-Later List

Rules for Writing a Todo Item

Diffuse and Focus

Deal with `Option`

有关 `fmap` 和 `map` 命名

`data` 关键字

`type` 关键字

`newtype` 关键字