翼之都

利用 GnuCash Python Bindings 將記帳資料寫入GnuCash 檔案

Sun, 30 Aug 2020 10:40:00 -0400

問題

一直以來都是使用 GnuCash 作為記帳工具，雖然有自動補完的功能，但各種紀錄還是得手動的輸入。消費的部份因為簡單所以每週偶爾記記還算可行，但券商、銀行裡的各種複雜交易如果都手動輸入感覺就相當花時間了。（其實一方面也是因為不會每週都記錄券商交易，而是累積起來一次輸入，所以心理上感覺比較繁雜。）所以最近研究了一下 GnuCash 的自動匯入功能，發現當中有許多不太彈性的地方，除此之外，匯入速度不知為何十分緩慢，讓人不禁覺得自己手動輸入搞不好還比較快。

為了解決這個問題，就來研究了一下 GnuCash 的 Python bindings 尋找能夠自動輸入大量交易的方法。最後在一番研究之後，參考了 GnuCash 裡頭的 example scripts，寫了一個簡單的 gnucash-importer。

GnuCash Importer

gnucash-importer 的功能是可以讀取 CSV 格式的記帳檔案，然後把裡頭的資料寫進 GnuCash 的檔案之中。使用這個工具作為輸入的手段的話，就能先將想插入的資料轉換成 CSV 格式，然後再透過 gnucash-importer 寫入 GnuCash 之中。

比如說如果先將股票帳戶的資料透過某種方法轉換成如下的格式：

date,description,commodity,memo,account,amount,value
09/24/2020,Purchase VTI,CURRENCY::USD,,Assets:Current Assets:Cash Account:TD Ameritrade,,-2500.00
,,,,Assets:Investments:Stock:VTI,10,2500.00
09/07/2020,BND Dividend,CURRENCY::USD,,Assets:Current Assets:Cash Account:TD Ameritrade,,70.00
,,,,Income:Dividend Income:Dividend Income USD:BND Dividend,,-100.00
,,,,Assets:Investments:Bond:BND,,
,,,W-8 Tax Withholding - BND,Expenses:Taxes:Federal:Taxes Withholding:Taxes Withholding USD:2020 Taxes Withholding USD,,30.00

然後再利用 gnucash-importer 來插入資料：

python -m gnucash_importer target.gnucash source.csv

就可以自動插入一筆購買 10 shares of VTI 的紀錄，和一筆得到 BND 的利息的紀錄。

所以說只要另外寫一些程式，把平常的帳戶資料先轉成這個格式的 CSV，就能簡單的匯入 GnuCash 之中了。

說穿了其實核心部份只是利用了簡單的 API：

import gnucash

DAY = 24
MONTH = 9
YEAR = 2020
DESCRIPTION = 'Purchase VTI'
ACCOUNT = 'Assets:Current Assets:Cash Account:TD Ameritrade'
VTI_ACCOUNT = 'Assets:Investments:Stock:VTI'

def lookup_account(root_account, account_path):
    names = account_path.split(':')
    account = root_account
    for name in names:
        account = account.lookup_by_name(name)
    return account

with gnucash.Session(
        gnucash_path,
        gnucash.SessionOpenMode.SESSION_NORMAL_OPEN) as session:
    book = session.book

    comm_table = book.get_table()
    commodity = comm_table.lookup('CURRENCY', 'USD')

    # 指定幣種和基本敘述
    trans = gnucash.Transaction(book)
    trans.BeginEdit()
    trans.SetDate(DAY, MONTH, YEAR)
    trans.SetCurrency(commodity)
    trans.SetDescription(DESCRIPTION)

    # 紀錄從現金帳戶花去 -2500
    split = gnucash.Split(book)
    split.SetValue(gnucash.GncNumeric(-2500))
    root_acct = book.get_root_account()
    acct = lookup_account(root_acct, ACCOUNT)
    split.SetAccount(acct)
    split.SetParent(trans)

    # 紀錄 VTI 持有增加 $2500 = 10 shares
    vti_split = gnucash.Split(book)
    vti_split.SetValue(gnucash.GncNumeric(2500))
    vti_split.SetAmount(gnucash.GncNumeric(10))
    vti_acct = lookup_account(root_acct, VTI_ACCOUNT)
    vti_split.SetAccount(vti_acct)
    vti_split.SetParent(trans)

    trans.CommitEdit()

其他可能性

其實之所以突然想來寫個 importer ，還有一個原因是先前看過別人用 beancount 記帳的心得，對於像那樣直接用純文字記帳的方法感到有點興趣。由於是純文字，很有彈性，要寫各種 importer 當然也不成問題。實際上官方好像就有提供各種 importers 來使用的樣子。

但因為太習慣 GnuCash 有各種自動完成，以及各種方便顯示的圖表了，所以目前還在觀望之中。乍看之下如果使用 fava 的話，雖然可以顯示一些基本的圖表，但跟 GnuCash 比起來還是有點距離。雖然因為很有彈性，所以理論上可以寫各種擴充套件，甚至搞不好早就有人寫好了強大的圖表套件。但一直還沒時間研究，所以只好暫時繼續使用 GnuCash 了。未來再看情形重新評估看看。

修復在加密硬碟裡安裝 Ubuntu 20.04 後無法開機的問題

Thu, 16 Jul 2020 20:40:00 -0400

問題

最近嘗試在不同的筆電上安裝 Ubuntu 20.04，發現如果選擇使用 LUKS 加密整個硬碟然後再把 Ubuntu 裝在裡頭的話，似乎有的時候會導致安裝好的 Ubuntu 無法開機。雖然不是很確定觸發的理由為何以及解法的原理為何，但也遇到了兩次了，於是便決定順手把解法紀錄下來以免之後又再遇到。

問題大概如下：在開機的時候，無法成功進入 Ubuntu，而會進入 BusyBox，並顯示類似下面的畫面：

BusyBox v1.18.5 (Ubuntu 1:1.18.5-1ubuntu4) built-in shell (ash)
Enter 'help' for a list of built-in commands.

(initramfs)

此時輸入 exit 之後就會顯示錯誤的理由，而理由是無法找到某個 /dev/mapper/MAPPED_NAME 檔案，或者是無法找到某個 UUID=LUKS_UUID 的磁區。具體的訊息忘了記錄下來。

解法

首先利用 Ubuntu 安裝 usb disk 或光碟開機。然後記得要連上網路才有辦法完成修復。

接著利用磁碟工具 gnome-disks 將加密磁區裡頭的 root filesystem 掛載起來，比如說如果掛載在 /media/ubuntu/disk 的話，那檢查這個加密檔案系統裡頭的 /media/ubuntu/disk/etc/fstab 和 /media/ubuntu/disk/etc/crypttab 兩個檔案。理論上 /media/ubuntu/disk/etc/fstab 裡頭應該要有以下一行：

/dev/mapper/MAPPED_NAME /               ext4    errors=remount-ro 0       1

而 /media/ubuntu/disk/etc/crypttab 裡頭應該要有下面這行：

MAPPED_NAME UUID=LUKS_UUID none luks,discard

其中，兩者的 MAPPED_NAME 應該要一樣，而 LUKS_UUID 應該要等於用來安裝 Ubuntu 的那個 LUKS 磁區的 UUID，也就是如果執行 sudo blkid 的話，應該會看到一行是：

/dev/LUKS_DEV: UUID="LUKS_UUID" TYPE="crypto_LUKS" PARTUUID="..."

而在這個 /dev/LUKS_DEV 的 LUKS 磁區底下有個用來安裝 Ubuntu 的 file system。

比如說有可能 /dev/LUKS_DEV 是 /dev/sda2 而 MAPPED_NAME 是 sda2_crypt。

筆者遇到的情況是， /media/ubuntu/disk/etc/crypttab 這個檔案不知為何並不存在，因此必須手動根據 sudo blkid 的輸出，或者直接用硬碟工具 gnome-disks 查出 LUKS_DEV 和 LUKS_UUID 自行製造出 /media/ubuntu/disk/etc/crypttab。

這麼做了以後，因為我們要參照 /media/ubuntu/disk/etc/crypttab,fsttab 裡的內容來重新掛載加密硬碟，所以先用磁碟工具把加密磁區卸除掛載。然後開始執行以下一連串指令：

# 手動掛載 LUKS 磁區，這裡的 `LUKS_DEV` 和 `MAPPED_NAME` 須跟 `.../etc/crypttab` 裡頭的一致。
sudo cryptsetup luksOpen /dev/LUKS_DEV MAPPED_NAME

sudo vgchange -ay

# 將安裝後系統的根目錄掛在 `/mnt` 底下，這裡的 `MAPPED_NAME` 要跟 `.../etc/fstab,crypttab` 裡頭的一致。
sudo mount /dev/mapper/MAPPED_NAME /mnt

# 這裡的 `BOOT_DEV` 要選安裝後的系統裡用來掛載 `/boot` 的磁區。
sudo mount /dev/BOOT_DEV /mnt/boot
sudo mount -t proc proc /mnt/proc
sudo mount -o bind /dev /mnt/dev

# 把這個複製進去，等等我們才能用網路
sudo cp /etc/resolv.conf /mnt/etc/resolv.conf

# 假裝我們的根目錄其實是 `/mnt`
sudo chroot /mnt

sudo apt install lvm2 cryptsetup-initramfs cryptsetup-run

sudo mount -t sysfs sys /sys
sudo update-initramfs -c -k all

假設上面的指令沒錯誤訊息的話，那重新開機應該就能成功進入系統裡了，但若有錯誤訊息，就得處理一下想辦法排除。

參考資料

在 PyTorch 中重新排序資料來使用 PackedSequence

Tue, 15 Jan 2019 18:10:00 -0500

前言

使用 PyTorch 的 PackedSequence 雖然可以較快速的處理長短不一的序列資料，但是用起來有個不方便的地方。就是同一個 batch 裡的資料，長度必須由長到短排列。但是如果是在做機器翻譯之類的 Seq2Seq 應用，同時有輸入字串和輸出字串，兩者的長度排序不見得會完全一樣。此時簡單的作法是照輸入排序，然後在 encoder 使用 PackedSequence，但是 decoder 就不要使用。但是其實也可以在 decoder 輸入時，先把資料排序，然後等 decoder 輸出後，再重新把資料轉換為原本的順序。本文就紀錄這種作法。

註：新版的 PyTorch 將會內建這種功能，就不用再使用本文的做法了。

排序資料

首先定義一個 sort_sequences 函式，將輸入的 inputs 照長度排序，並且回傳排好的 inputs, 排好的長度 lengths_sorted, 以及可以用來把序列轉回原始排序的 unsorted_idx。

def sort_sequences(inputs, lengths):
    """sort_sequences
    Sort sequences according to lengths descendingly.

    :param inputs (Tensor): input sequences, size [B, T, D]
    :param lengths (Tensor): length of each sequence, size [B]
    """
    lengths_sorted, sorted_idx = lengths.sort(descending=True)
    _, unsorted_idx = sorted_idx.sort()
    return inputs[sorted_idx], lengths_sorted, unsorted_idx

在 RNN 中的實際用法

在輸入 RNN 之前，先用 sort_sequences 把序列排好，然後再使用 pack_padded_sequence 將資料轉成 PackedSequence。

輸出之後，利用 unsorted_idx 把資料再轉回原本的排序即可。

class RNN(nn.Module):
  def forward(self, inputs, lengths=None, hidden=None):
      if lengths is not None:
          inputs, sorted_lengths, unsorted_idx = sort_sequences(
              inputs, lengths)
          inputs = torch.nn.utils.rnn.pack_padded_sequence(
              inputs, sorted_lengths, batch_first=True)

      outputs, (ht, ct) = self.lstm(inputs, hidden)

      if lengths is not None:
          outputs, _ = torch.nn.utils.rnn.pad_packed_sequence(
              outputs, batch_first=True)
          outputs = outputs.index_select(0, unsorted_idx)
          ht = ht.index_select(1, unsorted_idx)
          ct = ct.index_select(1, unsorted_idx)

這種寫法依然還是可以正常的進行 backpropagation，所以轉回原本序列的 tensors 可以直接傳出去，外頭也不會發現在這裡我們曾經重新排序了兩次。

使用 Go 撰寫 Plurk 噗浪偷偷說網路爬蟲

Fri, 11 Jan 2019 20:40:00 -0500

前言

記得剛開始學習 Go 好像是在 2013 年的時候，不過後來就一直沒太多機會使用。最近剛好想寫個爬蟲，於是就決定用 Go 來練習看看。

這次的目標是 Plurk 噗浪上的「偷偷說河道」。

本次的程式放在 shaform/experiments/plurk_crawler。

環境設定

這次只有用到 schollz/progressbar 來顯示進度，其他都是使用 Go 內建的函式庫，故只要安裝一個套件：

go get -u github.com/schollz/progressbar

撰寫爬蟲

分析網頁

首先透過觀察網路流量的方式分析噗浪的偷偷說到底是讀取什麼資料來顯示的，最後就會發現，主要透過兩組 endpoints。

第一個可以得到偷偷說河道的所有噗：

GET /Stats/getAnonymousPlurks?lang=<language>

第二個則可以用來讀取一個噗的回應：

POST /Responses/get2?plurk_id=<plurk_id>&from_response=<start_num>

得知兩組 endpoints 之後就能開始撰寫了。

主程式

主程式架構如下所示，首先利用 flag 來宣告參數，主要可以控制語言、存檔資料夾，以及要間隔多久送一次請求，防止被伺服器封鎖。

再來，則是實際呼叫第一個 endpoint 取得偷偷說河道。

最後則是解析河道取得所有的噗，再根據每個噗擷取回應並存檔。

func main() {
	const startUrl = "https://www.plurk.com/Stats/getAnonymousPlurks?lang=%s"

	// parse args
	var lang = flag.String("lang", "zh", "language of Plurks")
	var outputDir = flag.String("output-dir", "output", "directory for output")
	var file = flag.String("file", "", "read file instead of query URL")
	var delay = flag.Int("delay", 1000, "delay between each request in milliseconds")
	flag.Parse()

	// get plurks
	var result map[string]interface{}
	if *file != "" {
		result = GetPlurksFromFile(*file)
	} else {
		uri := fmt.Sprintf(startUrl, *lang)
		result = GetPlurks(uri)
	}

	plurks := ProcessPlurks(result)

	// start storing content...
	os.MkdirAll(*outputDir, 0700)
	FetchAndSavePlurks(*outputDir, plurks, *delay)
}

讀取噗浪河道

使用 HTTP GET 發送請求後，河道的 endpoint 會回傳一組 json 資料，所以我們用 json.Unmarshal 將其解譯成物件。因為 Go 是 static typing，所以不像 Python 那麼方便會根據 json 自動變成各種正確的物件。所以是用 interface{} 來暫時代表任意 type 的物件。

func ParseJson(inputs []byte) map[string]interface{} {
	var result map[string]interface{}
	json.Unmarshal(inputs, &result)

	return result
}

// GetPlurksFromFile queris uri
// to obtain plurk timeline.
func GetPlurks(uri string) map[string]interface{} {
	client := http.Client{Timeout: time.Second * 15}
	resp, err := client.Get(uri)
	if err != nil {
		log.Fatal(err)
	}
	defer resp.Body.Close()

	content, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		log.Fatal(err)
	}

	return ParseJson(content)
}

解析河道內容

這裡我們只拿出幾個我們關心的欄位，包含 id、內容、張貼時間、以及有幾個回應等等。

type Plurk struct {
	PlurkId       int
	Content       string
	Posted        string
	ResponseCount int
	Responses     []PlurkResponse
}

type PlurkResponse struct {
	Id      int
	Handle  string
	Content string
	Posted  string
}

// ProcessPlurks parses the timeline,
// and produces a list of plurks.
func ProcessPlurks(result map[string]interface{}) []Plurk {
	var plurks []Plurk
	for _, value := range result {
		// Each value is an interface{} type, that is type asserted as a string
		switch obj := value.(type) {
		case map[string]interface{}:
			plurk := Plurk{
				PlurkId:       int(obj["plurk_id"].(float64)),
				Content:       obj["content"].(string),
				Posted:        obj["posted"].(string),
				ResponseCount: int(obj["response_count"].(float64))}
			plurks = append(plurks, plurk)
		default:
		}
	}

	return plurks
}

抓取回應

由於之前已經知道每則噗浪有幾則回應，這裡只要針對有回應的噗浪抓取就行。如果遇到錯誤，可能是該噗浪已經被刪除，所以就把該噗一併捨去。最後再存檔。

// FetchAndSavePlurks queries plurk.com to
// obtain responsese from each plurk and
// save them to disk
func FetchAndSavePlurks(outputDir string, plurks []Plurk, delay int) {
	client := http.Client{Timeout: time.Second * 15}
	bar := progressbar.New(len(plurks))
	for _, plurk := range plurks {
		var responses []PlurkResponse
		var err error
		if plurk.ResponseCount > 0 {
			responses, err = FetchResponses(&client, plurk.PlurkId)
		}
		if err != nil {
			log.Printf("[WARN] Responses from %d cannot be fetched\n", plurk.PlurkId)
		} else {
			plurk.Responses = responses
			plurkJson, _ := json.Marshal(plurk)
			ioutil.WriteFile(fmt.Sprintf("%s/%d.json", outputDir, plurk.PlurkId), plurkJson, 0644)
		}
		bar.Add(1)
		if delay > 0 {
			time.Sleep(time.Millisecond * time.Duration(delay))
		}
	}
}

至於實際的抓取程式則設計成如下。感覺用 Go 寫起來比 Python 嚴謹不少，在用 Python 時，反正錯誤就習慣讓他丟 Exception 壞掉就算了。可是寫 Go 就強迫要想想錯誤時到底要幹麻。

// FetchResponses fetches responses of a given plurk
func FetchResponses(client *http.Client, plurkId int) ([]PlurkResponse, error) {
	const fetchUrl = "https://www.plurk.com/Responses/get2"

	data := url.Values{}
	data.Set("plurk_id", strconv.Itoa(plurkId))
	data.Set("from_response", "0")
	req, _ := http.NewRequest("POST", fetchUrl, strings.NewReader(data.Encode()))
	req.Header.Set("X-Requested-With", "XMLHttpRequest")
	req.Header.Set("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8")

	// fetch responses
	resp, err := client.Do(req)
	if err != nil || resp.StatusCode != 200 {
		return []PlurkResponse{}, errors.New("connot load")
	}
	defer resp.Body.Close()

	content, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return []PlurkResponse{}, errors.New("connot load")
	}

	result := ParseJson(content)
	var responses []PlurkResponse
	for _, value := range result["responses"].([]interface{}) {
		switch obj := value.(type) {
		case map[string]interface{}:
			response := PlurkResponse{
				Id:      int(obj["id"].(float64)),
				Handle:  obj["handle"].(string),
				Content: obj["content"].(string),
				Posted:  obj["posted"].(string),
			}
			responses = append(responses, response)
		default:
		}
	}
	return responses, nil
}

如此一來就完成了。

實際抓取

實際抓的時候感覺像這樣：

go run crawl.go
15% |██████                                  |  [13s:1m11s]

抓完則會像這樣：

.                      
├── crawl.go           
└── output             
    ├── 1398664726.json
    ├── ...

接著或許就能進行噗浪輿情分析之類等等的運用。

結語

感覺如果要快速的寫一些 scripts 還是 Python 比較好用，但 Go 寫起來已經算是很快了。本次的程式放在 shaform/experiments/plurk_crawler。

使用 gocryptfs 加密 Dropbox 等雲端硬碟的檔案

Sat, 08 Dec 2018 20:20:00 -0500

前言

當使用 Dropbox 等雲端硬碟儲存檔案的時候，有時難免會擔心資料的安全性問題而不敢上傳太過私人的資料。雖然也可以利用一些像是 VeraCrypt 之類的加密硬碟技術在 Dropbox 裡存放一個加密檔案空間，但由於整個加密空間視為一個檔案，如檔案太大則同步時可能會花上不少時間。

研究了一下後發現，其實也是有把加密空間表示成許多檔案的加密工具，例如像是 gocryptfs 就是一例。

本文便簡單紀錄 gocryptfs 的用法。

安裝

要在 Ubuntu 底下安裝 gocryptfs 相當容易，可以使用以下指令：

sudo apt install gocryptfs

建立加密資料夾

建立加密資料夾相當容易，首先進到和雲端同步的檔案夾，例如像是 $HOME/Dropbox，然後直接建立一個新資料夾，並用 gocryptfs -init 指令初始化:

mkdir ENCRYPTED_DIR
gocryptfs -init ENCRYPTED_DIR
Choose a password for protecting your files.
Password: 
Repeat: 
The gocryptfs filesystem has been created successfully.
You can now mount it using: gocryptfs ENCRYPTED_DIR MOUNTPOINT

裡頭大概會長這樣：

ENCRYPTED_DIR/
├── gocryptfs.conf
└── gocryptfs.diriv

掛載加密資料夾

緊接著，在其他非雲端同步的地方建立掛載點，並掛載加密資料夾：

mkdir MOUNT_DIR
gocryptfs $DROPBOX_DIR/ENCRYPTED_DIR MOUNT_DIR
Password:
Decrypting master key

Your master key is:

    ********-********-********-********-
    ********-********-********-********

If the gocryptfs.conf file becomes corrupted or you ever forget your password,
there is only one hope for recovery: The master key. Print it to a piece of
paper and store it in a drawer. Use "-q" to suppress this message.

Filesystem mounted and ready.

這樣就能在 MOUNT_DIR 資料夾裡頭存取檔案了。比如說我們可以隨便新增一個檔案：

echo test > MOUNT_DIR/test.txt

則就可以看到加密資料夾裡頭的加密檔也同步更新，並同步到雲端硬碟上：

ENCRYPTED_DIR/
├── 76h5Zq2yx76i5OP3HrrS3A
├── gocryptfs.conf
└── gocryptfs.diriv

卸載加密資料夾

最後要把資料夾關閉則可使用以下指令：

fusermount -u MOUNT_DIR

下次要打開加密資料夾存取，則再次使用 gocryptfs ENCRYPTED_DIR MOUNT_DIR 指令即可。

使用 Zarr 儲存資料集並用 PyTorch Dataset 讀取

Sun, 11 Nov 2018 11:40:00 -0500

前言

當使用大量的資料進行機器學習系統的訓練時，總是得花一些心力處理資料集的讀取。尤其如果有大量的圖片，則直接用檔案系統存放很多圖片不僅有些傳送和儲存的麻煩，也會讓讀檔變得沒有效率。

雖然也曾接觸過 HDF5 等資料格式，但不知為何存取起來相當緩慢。所以後來就都直接用 binary 檔案，自己寫資料格式的存取。然而，這樣每次不同的資料無法直接通用，且自己寫檔案格式也很難保證速度上達到最好的效果。

直到最近發現有個叫做 Zarr 的檔案存取格式，使用起來似乎相當快速。是以撰寫此文紀錄使用的方式。

本次的實驗程式放在 shaform/experiments/zarr-dataset。

環境設定

由於這次要使用 PyTorch，所以我將使用 Conda 來進行環境配置。首先安裝必要套件：

conda create -n zarr python=3.6
conda activate zarr # or source activate zarr or older version of conda
conda install zarr tqdm python-lmdb -c conda-forge

緊接著，我們下載 AnimeGAN 的動漫人臉資料集，將其解壓到目錄之下，所以目前的目錄看起來如下：

.
├── anime-faces
│   ├── 1boy
│   │   ├── danbooru_2637825_e3d8c4f9d55f25217cf5600874e664be.png
│   │   ├── danbooru_2637834_dceb8d822bd1326cb0865440d23d39b8.png
│   │   ├── ....
│   ├── 1girl
│   │   ├── danbooru_2635679_21741d5772cb3275165be0b68a286155.jpg
│   │   ├── ....

緊接著刪除一些奇怪的檔案：

rm -f anime-faces/aqua_eyes/._danbooru_2559693_dc628b766d7142f2d2d9c75559e36eb5.jpg
rm -f anime-faces/aqua_eyes/._danbooru_2560862_796530ab01cc7bfd8a03c8d05cc6953b.png

如此一來就準備好了。

資料處理

在動漫人臉資料集裡，每個資料夾代表一個分類，共有 126 個分類。而每個資料夾裡，有許多 96x96x3 的人臉。

現在我們要將檔案轉成 training set 和 validation set。首先利用 PyTorch 的 ImageFolder 將資料讀進來，他會自動依照資料夾給標籤。所以每個圖片會變成一對 (image, label)，其中 image 是一個 PIL.Image 而 label 則是一個數字。

我們利用 as_array 把 PIL.Image 轉成 unit8 的 numpy array，然後把 channels 改成第一個維度，好符合 PyTorch 的慣用格式。

接著就用 torch.utils.data.random_split 幫我們分開資料。

# convert_anime_faces.py

import numpy as np
from torchvision.datasets import ImageFolder
from torch.utils.data import random_split


def as_array(image):
    return np.asarray(image).swapaxes(2, 0)


def main():
    data_set = ImageFolder(root='anime-faces', transform=as_array)

    val_ratio = 0.1
    val_size = int(len(data_set) * val_ratio)
    train_size = len(data_set) - val_size

    train_set, val_set = random_split(data_set, [train_size, val_size])

    confs = [
        ('data/anime_faces/train.lmdb', train_set),
        ('data/anime_faces/val.lmdb', val_set),
    ]
    for path, data_set in confs:
        convert_data_set(path, data_set)

然後就可以開始把他轉成 zarr 資料集了。

Zarr 有支援各種不同的檔案儲存格式，這裡我們用 lmdb。注意到由於 lmdb 預設使用 sparse file，在 Linux 下你可能會看到 *.lmdb 資料夾足足佔了 1 TB 那麼大，但實際上使用 du -hs 檢查卻會發現其實沒有佔那麼大。這是正常的現象。

這邊主要注意的是因為 PyTorch 會任意存取不同 indices，所以 chunk 的第一個維度必須設為 1，這樣才能達到最高的速度。其他維度因為每次都是一次讀出來，所以就設成 None。chunk 的功用是，如果維度的數值是 n 的話，壓縮時就會把該維度的 n 個元素壓縮在一起，所以如果你常常一次讀 n 個元素的話，使用 chunk 就會比較快。設成 None 就表示把該維度所有資料都放在一起。

至於 u1 指的則是 1 byte 的 uint，也就是 uint8。

# convert_anime_faces.py

def convert_data_set(path, data_set, batch_size=1000):
    loader = DataLoader(
        data_set, batch_size=batch_size, shuffle=False, num_workers=4)

    num_examples = len(data_set)

    os.makedirs(path, exist_ok=True)
    with zarr.LMDBStore(path) as store:
        root = zarr.group(store=store, overwrite=True)
        images_set = root.zeros(
            'images',
            shape=(num_examples, 3, 96, 96),
            chunks=(1, None, None, None),
            dtype='u1')
        labels_set = root.zeros(
            'labels', shape=(num_examples, ), chunks=(1, ), dtype='u1')
        current_iter = 0
        for images, labels in tqdm(loader):
            size = images.shape[0]
            images_set[current_iter:current_iter + size] = images
            labels_set[current_iter:current_iter + size] = labels
            current_iter += size

資料讀取

那麼就可以讀取資料來進行訓練了。這裡我們讀出來的同時，也把檔案格式轉成範圍是 [0, 1] 的圖片，以及資料型態是 torch.long 的標籤。

注意到，如果要使用 num_works > 1 的話，必須要在 __getitem__ 裡頭再開啟資料集，否則會有問題。而因為 zarr 支援多個程式同時讀寫檔案，所以同時讀取是沒問題的。

# test_anime_faces.py

import os

import zarr
import torch
from torch.utils.data import Dataset


class FaceDataset(Dataset):
    def __init__(self, path, transforms=None):
        self.path = path
        self.keys = ('images', 'labels')
        assert os.path.exists(path), 'file `{}` not exists!'.format(path)

        with zarr.LMDBStore(path) as store:
            zarr_db = zarr.group(store=store)
            self.num_examples = zarr_db['labels'].shape[0]
        self.datasets = None

        if transforms is None:
            transforms = {
                'labels': lambda v: torch.tensor(v, dtype=torch.long),
                'images': lambda v: torch.tensor((v - 127.5)/127.5, dtype=torch.float32)
            }
        self.transforms = transforms

    def __len__(self):
        return self.num_examples

    def __getitem__(self, idx):
        if self.datasets is None:
            store = zarr.LMDBStore(self.path)
            zarr_db = zarr.group(store=store)
            self.datasets = {key: zarr_db[key] for key in self.keys}

        items = []
        for key in self.keys:
            item = self.datasets[key][idx]
            if key in self.transforms:
                item = self.transforms[key](item)
            items.append(item)
        return items

最後我們寫一個簡單的 CNN 來進行測試：

import torch.nn as nn
import torch.nn.functional as F
from torch.utils.data import DataLoader
from tqdm import tqdm, trange


class Model(nn.Module):
    def __init__(self, input_size=96 * 96 * 3, output_size=126,
                 hidden_size=25):
        super().__init__()

        self.layer1 = nn.Sequential(
            nn.Conv2d(3, 16, kernel_size=6, stride=2, padding=2),
            nn.BatchNorm2d(16), nn.ReLU(), nn.MaxPool2d(
                kernel_size=2, stride=2))
        self.layer2 = nn.Sequential(
            nn.Conv2d(16, 32, kernel_size=6, stride=2, padding=2),
            nn.BatchNorm2d(32), nn.ReLU(), nn.MaxPool2d(
                kernel_size=2, stride=2))
        self.fc = nn.Linear(6 * 6 * 32, output_size)
        self.criteria = nn.CrossEntropyLoss()

    def forward(self, inputs):
        outputs = self.layer1(inputs)
        outputs = self.layer2(outputs)
        outputs = outputs.reshape(outputs.size(0), -1)
        outputs = self.fc(outputs)
        return outputs


def main(batch_size=64, epochs=50):
    data_train = FaceDataset('data/anime_faces/train.lmdb')
    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

    loader = DataLoader(data_train, batch_size=batch_size, num_workers=10)
    model = Model()
    model.to(device)
    model.train()
    optim = torch.optim.Adam(model.parameters(), lr=0.001)
    for epoch in trange(epochs):
        t = tqdm(loader)
        for i, (images, labels) in enumerate(t):
            images = images.to(device)
            labels = labels.to(device)

            optim.zero_grad()
            logits = model(images)
            loss = model.criteria(logits, labels)
            loss.backward()
            optim.step()

            predicts = torch.argmax(F.softmax(logits, dim=1), dim=1)
            accuracy = (predicts == labels).to(torch.float32).mean()
            t.set_postfix(
                epoch=epoch, i=i, loss=loss.item(), accuracy=accuracy.item())

最後就可以測試訓練完的模型：

    data_val = FaceDataset('data/anime_faces/val.lmdb')
    val_loader = DataLoader(data_val, batch_size=batch_size, num_workers=0)
    total = len(data_val)
    total_correct = 0
    model.eval()
    for images, labels in val_loader:
        images = images.to(device)
        labels = labels.to(device)
        logits = model(images)
        predicts = torch.argmax(F.softmax(logits, dim=1), dim=1)
        correct = (predicts == labels).sum()
        total_correct += correct.item()
    print('Val accuracy = {}'.format(total_correct / total))

假設你真的照上述的程式跑的話，雖然訓練集的準確率可以達到 72% ，但測試集的結果準確率才 9.2 %，看來必須要做更好的處理來避免 over-fitting 才行。

結語

本次的實驗程式放在 shaform/experiments/zarr-dataset。

從 Pelican 及 WordPress 轉移到 Hugo

Sun, 22 Jul 2018 14:30:00 +0800

記得在 2014 年的時候把網誌搬到了 Pelican 上。當初會在各種靜態網頁生成器中選擇 Pelican，一方面是看到學姐的示範，另方面也是因為自己有在用 Python，所以用起以 Python 開發的 Pelican 感覺比較熟悉。

時過境遷，學姐當初採用 Pelican 網誌似乎也關閉了，而 Pelican 的開發活躍度也下降許多。加上隨著文章增加，Pelican 的速度也越來越慢，我也動了更換架構的念頭。

於是就看上了 Hugo，除了速度飛快以外，開發活躍度也非常值得期待。另外就是，他是用 Go 寫的，勉強也算的上是我有使用的語言之一。

從 Pelican 的轉移，因為想先保持佈景，所以主要的時間花在把佈景 Nest 改造成 Hugo 可用的 Den 上。Markdown 本身倒是不須太多的修改，主要是更動 Pelican 裡的 {filename} 路徑寫法，以及更動 code block 的表示方法。因為寫程式去解析 Markdown 有點麻煩，所以我主要是紀錄 Vim 指令來更動每個檔案。

從 WordPress 轉移過來的一座島就麻煩不少，雖然我直接採用了現成的佈景，還是寫了 wp2hugo 去下載我網誌用到的所有圖片，並且解析匯出的 XML 檔案轉成 Markdown 格式。並且還是花了一些手動的功夫去處理 WordPress Shortcodes 才完整轉移。

這次轉移時，順便更動了一些翼之都當初從 Blogger 搬移過來的 URL 架構。為了讓原本的網址仍然可以連上，我也用了 Hugo 的 Aliases 功能替每個文章轉址。另外也讓一座島和翼之都都變成雙語網誌了。

最後的結果如下：

使用 SSH ProxyCommand/ProxyJump 來連上內網主機

Sat, 28 Oct 2017 21:45:00 +0800

以前使用 NLG 實驗室工作站時常會需要記下每台機器的 port 要如何連，感覺很不方便，於是就向學長學習，寫了類似像下面的 nlg 程式：

#!/bin/bash
NLG_WKS_3F={NLG_WKS_3F_HOST}
NLG_WKS_2F={NLG_WKS_2F_HOST}
case $1 in
    [3-9])
        ssh $USER@$NLG_WKS_3F -p 2200$MACHINE
        ;;
    "a")
        ssh $USER@$NLG_WKS_2F
        ;;
    "b")
        ssh $USER@$NLG_WKS_2F -p 22002
        ;;
    *)
        ;;
esac

如此一來，要連線時，只要打以下指令就行了：

nlg b

後來才知道，其實可以使用 .ssh/config 來設定連線的 Hosts。於是修改 .ssh/config 如下：

Host nlg-wks-2
User {USER}
HostName {NLG_WKS_3F_HOST}
Port 22002

Host nlg-wks-b
User {USER}
HostName {NLG_WKS_2F_HOST}
Port 22002

如此一來，要連線時，只要打以下指令就行了：

ssh nlg-wks-b

然而，由於奇怪的 port 對應，使得這麼做必須在 .ssh/config 裡增加許多行數。後來才發現，其實可以用 ProxyCommand 來做到先自動連上其中一台機器，再自動從那台機器連到內網的其他機器。

在連外網連不到的機器時，用 ProxyCommand 而非自己連兩次 ssh 還有一個好處，就是可以把用來認證的 ssh private key 存在本機，而不存在 NLG-WKS 伺服器裡，避免被同學偷看 private key，但卻可以用這個 private key 在跳板過程裡，用來認證最後想連上的主機。

實際作法如下，首先在 .ssh/config 新增用來跳板的主機：

Host nlgs
Hostname {NLG_WKS_3F_HOST}
User {USER}

緊接著新增跳板項目：

Host nlg-wks-*
User {USER}
ProxyCommand ssh -q -W %h:%p nlgs

具體的意思是，在連 nlg-wks-* 機器時，會先連上 nlgs 機器，然後再從 nlgs 連 nlg-wks-* (因此 nlgs 機器本身，要看得懂 nlg-wks-* 才行，幸好之前在處理 LDAP 時已經順便把 DNS 紀錄都設了)。

如此一來，就能用以下指令，先跳到一個主機，再跳到其他主機了：

ssh nlg-wks-b

如果是使用較新的 ssh client，也能改用 ProxyJump：

Host nlg-wks-*
User {USER}
ProxyJump nlgs

如此一來，就能更方便的做實驗了。

用程式自動產生 Google Forms 調查問卷

Sat, 16 Sep 2017 16:42:00 +0800

前言

最近因為一些研究上的需要，需要進行問卷調查。雖然也可以用自己架的伺服器和網頁界面，可是難免擔心資安的疑慮。於是就想到可以使用 Google Forms，來進行問卷調查與回收。為了避免未來有需要時忘記作法，便記下筆記當作未來的參考。

這次將使用 Kaggle 的 Dogs vs. Cats 資料集作為示範，每題會給兩張圖片，要求使用者選出貓貓照片。

資料準備

首先下載 train.zip 並且解壓縮，緊接著我們撰寫一個程式來產生必要的檔案：

# prepare.py
def prepare(input_dir, output_dir, web_root, num_outputs, names, seed):
    random.seed(seed)
    image_dir = os.path.join(output_dir, 'images')
    os.makedirs(image_dir, exist_ok=True)

    # load choices for each question
    choices = []
    for name in names:
        named_images = []
        # write hashes of this name to a file
        # so we can analyse results later
        id_path = os.path.join(output_dir, name + '.txt')
        with open(id_path, 'w') as id_file:
            for i in range(1, num_outputs + 1):
                fname = os.path.join(input_dir, '{}.{}.jpg'.format(name, i))
                h = md5(fname)
                named_images.append(h)
                id_file.write(h + '\n')
                # put images to a separate directory
                outpath = os.path.join(image_dir, '{}.jpg'.format(h))
                shutil.copyfile(fname, outpath)

        choices.append(named_images)

    # output url for each image
    url_path = os.path.join(output_dir, 'urls.tsv')
    with open(url_path, 'w') as outfile:
        outfile.write('h\turl\n')
        for named_images in choices:
            for h in named_images:
                outfile.write('{}\t{}/images/{}.jpg\n'.format(h, web_root, h))

    # output survey file
    survey_path = os.path.join(output_dir, 'survey.tsv')
    with open(survey_path, 'w') as outfile:
        header = '\t'.join([str(n) for n in range(1, len(names) + 1)])
        outfile.write('num\t' + header + '\n')
        for n in range(num_outputs):
            options = [named_images[n] for named_images in choices]
            random.shuffle(options)
            outfile.write('{}\t{}\n'.format(n + 1, '\t'.join(options)))

這裡包含三個部份，第一個部份會把貓和狗指定題數 num_outputs 的圖片抓出，計算 hash，並且紀錄每一題要用哪個 hash。最後把 hash 寫進獨立的檔案，好讓未來可以知道每個 hash 對應到貓還是狗。

第二個部份則是根據指定的 web_root 來產生每個 hash 對應的網址，在產生問卷前要先將圖片上傳到這個位置，才能讓 script 抓取到對應的圖片。不過抓取完後，圖片就會存在 Google 裡，所以問卷本身不再需要原始的網址。

第三個部份則是產生實際的問卷檔案，別忘了隨機打亂選項的順序，好讓使用者看不出哪個選項是來自哪裡。

寫好後執行

python prepare.py train output --web-root http://WEB_ROOT

應該會產生下述檔案：

output/
├── cat.txt
├── dog.txt
├── images
│   ├── 00f1acf458ae561796d9abf10e384f31.jpg
│   ├── ......
├── survey.tsv
└── urls.tsv

首先先將 images 的所有檔案上傳到自己指定的 web_root 網頁空間。然後產生一個 Google Sheets，將 survey.tsv 和 urls.tsv 分別匯入成為 survey 和 urls 兩個 tabs。範例可參考：〈Dogs vs. Cats Survey〉。

撰寫問卷產生的程式

接下來進入該 Google Sheets，點擊 Tools -> Script editor...，編輯 Code.gs。

新增一個函式抓取問卷資料：

function getSurveyData(sheetName) {
  var arrayOfArrays = SpreadsheetApp.getActiveSpreadsheet().getSheetByName(sheetName || 'survey').getDataRange().getValues();
  var headers = arrayOfArrays.shift();
  return arrayOfArrays;
}

再新增一個函式抓取網址資料：

function getUrlData(sheetName) {
  var arrayOfArrays = SpreadsheetApp.getActiveSpreadsheet().getSheetByName(sheetName || 'urls').getDataRange().getValues();
  var headers = arrayOfArrays.shift();
  var mapOfUrls = {};
  for (var i=0; i<arrayOfArrays.length; i+=1) {
    var h = arrayOfArrays[i][0];
    var url = arrayOfArrays[i][1];
    mapOfUrls[h] = url;
  }
  return mapOfUrls;
}

最後就是問卷產生了，為了避免產生太多 requests，造成連線逾時，也加了等待和重試的機制。

function makeOurForm() {
  var title = 'Dogs vs. Cats Survey';
  var desc = 'Please select the picture that looks like a cat.';
  var mapOfUrls = getUrlData();
  var surveyData = getSurveyData();
  
  var form = FormApp.create(title)
  form.setDescription(desc);
  for (var i=0; i<surveyData.length; i++) {
    Utilities.sleep(10);
    var item = form.addMultipleChoiceItem();
    item.setTitle('Q' + surveyData[i][0] + ': Which one looks like a cat?')
    .setChoices([
      item.createChoice('1'),
      item.createChoice('2')
    ])
    .setRequired(true);
    
    for (var j=1; j<surveyData[i].length; j++) {
      var name = '(' + j + ')';
      var h = surveyData[i][j];
      var img = UrlFetchApp.fetch(mapOfUrls[h]);
      Utilities.sleep(100);
      var imgItem = form.addImageItem();
      try {
        imgItem.setTitle(name).setImage(img);
      } catch (e) {
        Utilities.sleep(500);
        imgItem.setTitle(name).setImage(img);
      }
    }
  }
}

點擊 Run -> makeOurForm 熱騰騰的問卷就產生好了，可參考下圖。

程式碼

照慣例，程式碼放在下述地方供參考：

https://github.com/shaform/experiments/tree/master/google-forms

密碼管理心得筆記

Sun, 28 May 2017 20:11:00 +0800

前言：逐步學習資訊安全

經過多年的學習，筆者的資訊安全管理方式也是有所進步。以檔案加密而言。從一開始完全不加密，到後來會把特定磁區使用 LUKS 加密，又到後來啟用了家目錄的 eCryptfs，並開始不太敢用沒加密的 Windows，只在 Ubuntu 上工作。其他還試過 TrueCrypt 來加密硬碟，還曾經因為忘記密鑰，忍痛把某個硬碟裡的檔案放棄了呢。最近也受擅長資訊安全的朋友的建議，想來研究也考慮開機磁區問題的全硬碟加密可能性。

另一方面，對密碼管理也是多有嘗試。一開始設密碼也是使用像是生日、人名、單字之類的簡易密碼。當然很快就被破解了。後來使用了更加複雜的密碼，可是不同網站還是設成一樣，這樣要是有的網站密碼沒加密，一被破解，全部網站的密碼也就被得知了。可是每個網站都用不同密碼實在太難記了，於是有段時期又改用某種神秘公式，配合不同網站性質，產生每個網站的獨特密碼。同樣的道理也能將每張金融卡的密碼都設成不一樣。一些不重要的網站則使用很長但好記的密碼。

只是公式的主意看似可行，但如果被歹徒看見足夠多的密碼，或許他也有機會猜出背後的公式。同時每次想換密碼，都要想個全新的公式，並且一次換掉所有密碼，否則根本記不起哪個網站是用哪個規則，感覺也很麻煩。

於是後來就用亂數密碼產生器，每個網站都隨機產生自己也完全記不住的密碼，然後把他們加密存在像是 LastPass 之類的雲端同步服務。可是這樣一來雖然就算歹徒得知一個密碼也猜不出其他密碼，但一旦歹徒攻進雲端儲存服務，並設法解開了加密，就一口氣得知了所有密碼了。

於是後來就不再使用雲端，而是用 KeepassX 放在本機。這樣就減少了存放密碼的地方以及連網的時間。可是這樣一來同步就非常麻煩，常常如果在不同的機器各自新增了密碼，就得手動同步差異，相當不方便。此外，由於打密碼時會輸入密鑰，使用這個密鑰就可以一口氣解開所有密碼的加密，假設歹徒侵入了我的電腦，偷聽我打入的密鑰，則即可趁著加密被解開的當下，把所有密碼都複製出來了。

就在最近的時候，偷聽大大們聊天，得知了像是 pass 這樣的密碼管理程式。同時配合像是 YubiKey、Nitrokey 等裝置，就能進一步提昇安全性。

原理大概如下：首先將密鑰放在外部的安全裝置，硬體本身設計無法將密鑰讀出，只能用來解密。如此一來，理論上即使駭客入侵電腦，或甚至闖空門偷走安全裝置也相當難以取得密鑰內容。而電腦裡的密碼則每條分開加密，在使用時透過外部裝置解開特定的密碼。如此一來，若要偷走所有密碼，則必須潛伏在電腦裡，不斷偷聽解開的密碼，直到所有密碼都被解開過一次才行，大幅拉長了被全面破解的時間。當然，若是歹徒使用某種方法控制了接上的安全裝置，強制解密所有密碼，就會被成功一次取走密碼了，不過這樣的風險可以用不要一直接上安全裝置來控制，終究已經比之前的方法小了。

OpenPGP

簡介

為了達成本文的設定，首先必須借助 OpenPGP 的力量，OpenPGP 實際上是一套加密標準，平常人其實是把他拿來做傳送加密郵件、檔案資料，或者數位簽章等等的運用。詳細介紹可參考：〈OpenPGP for Complete Beginners〉。

OpenPGP 是利用非對稱性加密來達成大部分的功能，簡單來說，這種加密有兩把鑰匙，一把是公開的，另一把是私密的。使用其中一把鑰匙加密的檔案只有用另外一把鑰匙才能解開。而擁有其中一把鑰匙在目前的計算能力下無法在合理的時間裡導出另外一把鑰匙。在這種情況下，只要用別人的公鑰加密，就只有擁有私鑰的他能夠解開，藉此達成加密傳輸的目的。另一方面，如果一個人用自己的私鑰加密某個東西，你就可以用公鑰驗證，該東西確實是擁有那把沒人知道的私鑰的人才能加密出來的東西，透過類似的原理就能達成數位簽章的目的了。

OpenPGP 通常是先創立一對 master key 平常收著不要用，但是創立一些 subkeys 來進行實際的加密簽章等等。要是遺失了 subkey 之類的，再把 master key 的密鑰拿出來簽章，宣告那些 subkeys 不能用了，然後創造新的 subkeys 等等，好讓管理上更方便。

建立 OpenPGP Master Key

這次我們會用 GnuPG 來管理我們的 OpenPGP keys，由於我們將要開始操作私鑰，一旦洩漏整個系統就會陷於危殆之境，建議用完全乾淨的系統，甚至不要連上網路來進行操作。當然，若無連網，則安裝的套件就要用其他方式放進去而不能直接打本文的指令了。

首先安裝相依套件：

sudo apt install gnupg2 gnupg-agent pinentry-curses

緊接著參考 YubiKey-Guide，更改 ~/.gnupg/gpg.conf 的內容加入以下片段：

# ~/.gnupg/gpg.conf
use-agent
personal-cipher-preferences AES256 AES192 AES CAST5
personal-digest-preferences SHA512 SHA384 SHA256 SHA224
default-preference-list SHA512 SHA384 SHA256 SHA224 AES256 AES192 AES CAST5 ZLIB BZIP2 ZIP Uncompressed
cert-digest-algo SHA512
s2k-digest-algo SHA512
s2k-cipher-algo AES256
charset utf-8
fixed-list-mode
no-comments
no-emit-version
keyid-format 0xlong
list-options show-uid-validity
verify-options show-uid-validity
with-fingerprint

然後就可以開始產生 master key：

gpg2 --full-gen-key --expert

由於我們不想直接使用 master key，所以選擇 8，好調整 master key 的功能：

gpg (GnuPG) 2.1.11; Copyright (C) 2016 Free Software Foundation, Inc.
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.

gpg: keybox '$GNUPGHOME/pubring.kbx' created
Please select what kind of key you want:
   (1) RSA and RSA (default)
   (2) DSA and Elgamal
   (3) DSA (sign only)
   (4) RSA (sign only)
   (7) DSA (set your own capabilities)
   (8) RSA (set your own capabilities)
   (9) ECC and ECC
  (10) ECC (sign only)
  (11) ECC (set your own capabilities)
Your selection? 8

調整讓 master key 剩下的 actions 只有 Certify：

Possible actions for a RSA key: Sign Certify Encrypt Authenticate
Current allowed actions: Certify

   (S) Toggle the sign capability
   (E) Toggle the encrypt capability
   (A) Toggle the authenticate capability
   (Q) Finished

Your selection? Q

鑰匙的長度選擇 4096，感覺似乎比較安全。注意如果最後要把某些 key 放到 YubiKey, Nitrokey 等等的話，有些版本不支援 4096 這麼長的長度，所以要先確認一下。

RSA keys may be between 1024 and 4096 bits long.
What keysize do you want? (2048) 4096
Requested keysize is 4096 bits

至於鑰匙的時限則可自行設定，理論上因為 master key 打算放在一個很安全的地方平常不拿來用，所以就算設成永遠不過期可能也還可以。不過如果要安全一點也可以設短一點，強迫自己常換新。

Please specify how long the key should be valid.
         0 = key does not expire
      <n>  = key expires in n days
      <n>w = key expires in n weeks
      <n>m = key expires in n months
      <n>y = key expires in n years
Key is valid for? (0) 0
Key does not expire at all
Is this correct? (y/N) y

輸入名字和電子郵件。

GnuPG needs to construct a user ID to identify your key.

Real name: <NAME>
Email address: <EMAIL>
Comment:
You selected this USER-ID:
    "<NAME> <EMAIL>"

Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? O

然後他會要你設定私鑰的密碼，未來要使用私鑰時就必須輸入密碼才能用。設定好之後就會開始產生公私鑰了。最後這裡要等很久，可以不斷滑鼠亂動，亂按鍵盤，亂存取檔案來加速。不過即使這樣還是可能會卡住很久就是。

We need to generate a lot of random bytes. It is a good idea to perform
some other action (type on the keyboard, move the mouse, utilize the
disks) during the prime generation; this gives the random number
generator a better chance to gain enough entropy.

最後終於成功產生：

gpg: $GNUPGHOME/trustdb.gpg: trustdb created
gpg: key <MASTER-KEY-ID> marked as ultimately trusted
gpg: directory '$GNUPGHOME/openpgp-revocs.d' created
gpg: revocation certificate stored as '$GNUPGHOME/openpgp-revocs.d/<KEY-FINGERPRINT>.rev'
public and secret key created and signed.

gpg: checking the trustdb
gpg: marginals needed: 3  completes needed: 1  trust model: PGP
gpg: depth: 0  valid:   1  signed:   0  trust: 0-, 0q, 0n, 0m, 0f, 1u
pub   rsa4096/<MASTER-KEY-ID> 2017-01-01 []
      Key fingerprint = <KEY-FINGERPRINT>
uid                   [ultimate] <NAME> <EMAIL>

除了一對公鑰私鑰以外，還順便產生了 revocation certificate，這是一個可以用來宣告這把 master key 失效的憑證，尤其是如果當初有效日期設得很長的話，若中途被人盜走了 master key，就可以用這個告訴別人不要再相信這把 key 了。

不過這一切都是如果你要真的拿 OpenPGP key 做正常的用途時才有用。如果你單純只是要用來管理密碼，而且也不打算讓別人知道有這把 key 的話其實就不太有用了。

除了讓 GnuPG 自行產生外，也可以用以下指令產生 revocation certificate，--armor 是要讓產生的檔案變成可印的純文字（因此你可以把他印出來備份，而不留下真正的數位檔案，防止被盜取。）

gpg2 --armor --gen-revoke <MASTER-KEY-ID>  > <REVOKE-FILE>

建立加密用 Subkey

接下來就正式增加加密用的 subkey 了：

gpg2 --edit-key <MASTER-KEY-ID>

使用 addkey 指令：

gpg (GnuPG) 2.1.11; Copyright (C) 2016 Free Software Foundation, Inc.
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.

Secret key is available.

sec  rsa4096/<MASTER-KEY-ID>
     created: 2017-01-01  expires: never       usage: C
     trust: ultimate      validity: ultimate
[ultimate] (1). <NAME> <EMAIL>

gpg> addkey

選擇加密：

Please select what kind of key you want:
   (3) DSA (sign only)
   (4) RSA (sign only)
   (5) Elgamal (encrypt only)
   (6) RSA (encrypt only)
Your selection? 6

繼續選 4096，而時間可以設短一點，強迫自己將來換 subkeys。

RSA keys may be between 1024 and 4096 bits long.
What keysize do you want? (2048) 4096
Requested keysize is 4096 bits
Please specify how long the key should be valid.
         0 = key does not expire
      <n>  = key expires in n days
      <n>w = key expires in n weeks
      <n>m = key expires in n months
      <n>y = key expires in n years
Key is valid for? (0) 10y

Key expires at Fri 01 Jan 2027 10:19:01 PM CST
Is this correct? (y/N) y
Really create? (y/N) y

如果他問你要設定什麼密碼的話，要打跟之前 master key 一樣的密碼。最後等很久就成功了：

We need to generate a lot of random bytes. It is a good idea to perform
some other action (type on the keyboard, move the mouse, utilize the
disks) during the prime generation; this gives the random number
generator a better chance to gain enough entropy.

sec  rsa4096/<MASTER-KEY-ID>
     created: 2017-01-01  expires: never       usage: C
     trust: ultimate      validity: ultimate
ssb  rsa4096/<ENCRYPT-KEY-ID>
     created: 2017-01-01  expires: 2027-01-01  usage: E
[ultimate] (1). <NAME> <EMAIL>

gpg> quit
Save changes? (y/N) y

做到這裡，先把鑰匙們備份下來，這裡頭會包含 master key 和 encryption subkey 的公鑰和私鑰，可以存放到安全的地方。最後我們將會銷毀電腦裡的 master key 和 encryption subkey 的私鑰，使得只剩安全地方的備份，以及 YubiKey 上的版本。

gpg2 --armor --export-secret-keys <MASTER-KEY-ID> > <MASTER-SECRECT-FILE>

YubiKey

簡介

YubiKey 比較知名的功能大概像是 U2F 或是 OTP 等等的二次驗證 (2FA)，不過這次主要是想借助他拿來當 OpenPGP 智慧卡的功能。簡單來說，我們可以把私鑰放在 YubiKey 上，然後請他執行解密簽章之類的功能。但因為硬體的安全性設計，理論上沒有人可以拿出裡頭的私鑰實際內容到底是什麼。

不過因為 YubiKey 4 開始不再使用開放原始碼的 OpenPGP，所以也可能會令人擔心裡頭其實藏有後門，可讓政府取出也說不定。，這也就是為什麼一些擅長安全的朋友建議改用 Nitrokey。

不過因為 YubiKey 目前還是比較多人在用，所以本文就以 YubiKey 4 作為示範，大家可以再自行調整。

設定 YubiKey 4 OpenPGP 功能

為了避免遺失 YubiKey 後會一時無法解密自己的檔案，所以最好同時設置兩把以上的 YubiKey 讓他們擁有同一把 encryption subkey，不過用來簽章和驗證的 signature subkey 和 authentication subkey 就不必共享了。事實上我們將會直接在 YubiKey 上產生這兩種 subkeys 的私鑰，並且不留任何備份。也就是說連我們自己都永遠無法從 YubiKeys 裡得到真正私鑰的樣子。

首先安裝相依套件：

sudo apt install scdaemon pcscd yubikey-personalization libusb-1.0-0-dev

接上 YubiKey 4 以後，執行編輯指令：

gpg2 --card-edit

首先更改管理密碼，和使用者密碼，未來在使用 YubiKey 時要先輸入使用者密碼才能使用，至於管理者密碼則只有在修改設定時才會用到。YubiKey 4 預設的管理密碼是 12345678，使用者密碼則是 123456。

gpg/card> admin
Admin commands are allowed

gpg/card> passwd
gpg: OpenPGP card no. <CARD-ID> detected

1 - change PIN
2 - unblock PIN
3 - change Admin PIN
4 - set the Reset Code
Q - quit

Your selection? 3
PIN changed.

1 - change PIN
2 - unblock PIN
3 - change Admin PIN
4 - set the Reset Code
Q - quit

Your selection? 1
PIN changed.

1 - change PIN
2 - unblock PIN
3 - change Admin PIN
4 - set the Reset Code
Q - quit

Your selection? Q

由於每次把 encryption subkey 移進 YubiKey 裡，本機上的私鑰就會消失，因此如果要設定第二個 YubiKey 時，就要用之前的備份檔重設本機的狀態：

gpg2 --delete-secret-key <MASTER-KEY-ID>
gpg2 --import < <MASTER-SECRECT-FILE>

緊接著，就可以移動 encryption subkey。

gpg2 --edit-key <MASTER-KEY-ID>

gpg> toggle
gpg> key 1

sec  rsa4096/<MASTER-KEY-ID>   created: 2017-01-01  expires: never
ssb* rsa4096/<ENCRYPT-KEY-ID>  created: 2017-01-01  expires: 2027-01-01
(1)  <NAME> <EMAIL>

gpg> keytocard
 Signature key ....: [none]
 Encryption key....: [none]
 Authentication key: [none]

Please select where to store the key:
   (2) Encryption key
Your selection? 2

然後產生 authentication 和 signature subkeys，不過這兩個主要是真的要拿來做正常的 OpenPGP 功能時才需要。

gpg> addcardkey

 Signature key ....: [none]
 Encryption key....: <ENCRYPT-KEY-ID>
 Authentication key: [none]

Please select the type of key to generate:
   (1) Signature key
   (2) Encryption key
   (3) Authentication key
Your selection? 1

gpg> addcardkey

 Signature key ....: <SIGNATURE-KEY-ID>
 Encryption key....: <ENCRYPT-KEY-ID>
 Authentication key: [none]

Please select the type of key to generate:
   (1) Signature key
   (2) Encryption key
   (3) Authentication key
Your selection? 3

過程跟之前產生 encryption subkey 時差不多。最後存檔。

gpg> save

由於我們擔心歹徒如果入侵電腦，取得了你的使用者密碼，就可以趁你不注意時，利用插上的 YubiKey 來解密檔案。因此我們還要打開只有按下 YubiKey 上的按鈕才能解密的功能。不過如果歹徒取得了管理密碼，則他也可以把這個功能關掉。幸好 YubiKey 4 還有個選項是強制固定一定要按下按鈕，只有重新產生新的私鑰以後才能解除。以下就把這功能針對 3 個 subkeys 開啟：

ykman openpgp touch enc fixed
ykman openpgp touch sig fixed
ykman openpgp touch aut fixed

做完這件事以後，把 <MASTER-SECRECT-FILE> 和 <REVOKE-FILE> 備份到一個平常不會插到電腦的地方，數年都不把他拿出來。然後把公鑰備份下來準備放到平常正常使用的電腦上。這個檔案會包含 master key，和之前產生的所有 subkeys 的公鑰。

gpg2 --export <MASTER-KEY-ID> > <MASTER-PUBLIC-FILE>

假設你要把這些 keys 拿來做正常的 OpenPGP 用途的話，你可能也會想要把這些公鑰發布到 key servers 上讓大家都能看到，不過如果只是要用來加密自己的密碼，或許就不用這麼做了。畢竟如果有人擁有超越目前時代，從公鑰推出私鑰的計算能力，那麼公開公鑰總是有一定風險。當然，如果他要破解你電腦裡的密碼檔，就意謂著他必須先擁有存取你電腦資料的能力。而一旦他有這個能力，其實他也能獲取放在電腦上的公鑰。因此對抗擁有超越目前時代計算能力的人，就算不公開公鑰，可能也只是拖延了一點時間。

gpg2 --keyserver hkps://hkps.pool.sks-keyservers.net --send-key <MASTER-KEY-ID>

最後就可以把乾淨電腦裡的 GnuPG 資料全數銷毀：

rm -rf ~/.gnupg

在平常的電腦上，先重新編輯 ~/.gnupg/gpg.conf 加入之前提到的設定，然後載入之前的公鑰。注意到，私鑰已經被放到安全的地方了，就不要再放進平常的電腦裡了。由於我們等等要用的 pass 主要是用 gpg 而不是 gpg2，所以也把公鑰載入到 gpg 裡。

gpg2 --import < <MASTER-PUBLIC-FILE>
gpg  --import < <MASTER-PUBLIC-FILE>

如此一來 OpenPGP 就設定完成！！

pass: the standard unix password manager

簡介

pass 是一個簡單的密碼管理系統，直接把密碼用 OpenPGP 加密的文字檔們來管理，每個密碼都是一個文字檔。因此也可以把整個密碼庫用 Git 追蹤，方便同步以及檢視修改紀錄。不過為了搜尋方便，檔案名稱裡通常含有網站位置或甚至使用者名稱，而檔案名稱本身是沒有加密的，這也讓一些使用者詬病。

因此我們同時使用 pass-tomb 來將 pass 的密碼庫整個加密，他會利用 Tomb 來產生 LUKS 加密檔，再把 pass 資料庫放在裡頭。

安裝

安裝最新版本的方法是分別到各自網站下載：

然後各自解壓縮，並執行：

sudo make install

同時安裝 pass 會用到的密碼產生器：

sudo apt install pwgen

設定

首先建立 pass-tomb：

pass tomb <MASTER-KEY-ID>

這裡要插入 YubiKey 並且按指示輸入使用者密碼。然後等很久，就能建立完成。

緊接著打開密碼庫，並建立 Git repository。

pass open
pass git init

要關閉時則執行：

pass close

使用

在 pass-tomb 打開的狀態下，可以使用一些指令管理密碼。

例如新增新的密碼，由於加密只需要公鑰，就算沒有 YubiKey 也能完成。如果想加入其他像是使用者名稱或是安全問題等筆記，可以加上 -m 參數，編輯多行，平常複製密碼預設只會複製第一行。或者也可以事後執行 pass edit，不過這就需要插入私鑰才能解密並編輯了。

pass insert social/facebook
Enter password for social/facebook: ************

也可以自動產生密碼：

# generate a password of length 15
pass generate social/facebook 15

其他指令，詳請可執行 man pass。

移除密碼： pass rm <PATH>
複製密碼： pass -c <PATH>
印出密碼： pass <PATH>

用 OpenPGP Key 充當 SSH Key 進行遠端登入

設定

感覺很多 keys 實在很麻煩，而既然已經有那麼安全的 OpenPGP keys 可用，我們也想直接用當初放在 YubiKey 上的 authentication subkey 來取代原本在用的 SSH key。首先編輯 ~/.gnupg/gpg-agent.conf：

# ~/.gnupg/gpg-agent.conf
enable-ssh-support
pinentry-program /usr/bin/pinentry-curses
default-cache-ttl 60
max-cache-ttl 120

緊接著，在 ~/.bashrc 裡加上下面幾行，以免要輸入使用者密碼時，界面無法在正確的 terminal 顯示：

export GPG_TTY=`tty`
gpg-connect-agent updatestartuptty /bye > /dev/null 2>&1
unset SSH_AGENT_PID
if [ "${gnupg_SSH_AUTH_SOCK_by:-0}" -ne $$ ]; then
  export SSH_AUTH_SOCK="${HOME}/.gnupg/S.gpg-agent.ssh"
fi

重新登入後，在 YubiKey 插入的情況下執行 ssh-add -L 應該就會看到 authentication subkeys 的 SSH public key 的長相，可以用來寫入 ~/.ssh/authorized_keys。這樣就可以用 OpenPGP keys 來登入 SSH 了。

讓遠端機器也能用這把 Key 登入其他機器

當然，如果你還記得的話，這把 authentication subkey 只在 YubiKey 上有，連我們自己都沒有私鑰的備份。因此遠端機器無法直接使用這把 SSH key。不過其實可以用 SSH agent forwarding 的功能讓遠端機器使用這把 key：

ssh -A <HOST>

注意不管從哪裡要啟用這把 key，都還是要按下 YubiKey 上的按鈕才行。不過像這樣做 SSH agent forwarding 的話，還是會有風險。畢竟如果有人能存取遠端電腦上你分享出去的 agent，就能使用你的 key 了。當然，這樣的風險已經比直接把 key 放在遠端電腦上小了。

其他 YubiKey 的功能

除此之外，YubiKey 還可以用來啟用 U2F 二次驗證，目前像是 Google、Facebook 之類的大網站都有支援。簡單說，啟用了以後，如果在新電腦登入的話，同時還要插入 YubiKey 才能登入，光有密碼是無法登入的。

但是不少網站目前並不支援 U2F，只支援 OATH TOTP，也就是平常大家可能會安裝 Google Authenticator 或者 Microsoft Authenticator，然後在新電腦登入時除了輸入密碼，還要輸入上面的隨時間會不一樣的數字。

YubiKey 同樣可以使用 Yubico Authenticator 來支援這個功能，不過能夠支援的網站數有所極限。

其他還有記憶一個密碼幫你輸入，以及其他更複雜的功能，不過就沒有研究了。詳情可以參考：〈Yubikey Handbook〉。

Scrapy Cloud + Scrapy 網路爬蟲

Sat, 13 May 2017 16:10:00 +0800

聲明

本文提到的 Scrapy Cloud 已經變成 Zyte，因此本文的 Scrapy Cloud 相關敘述已經不再有效。

前言：取得研究資料集

最近聽到不少擅長 Deep Learning 的朋友買了顯示卡準備自己做起研究，讓人也十分受到激勵。不過平常想自己做研究時，常常會因為沒有適當的資料集而窒礙難行。尤其不少學術資料集似乎需要由研究單位出面才能取得，使得默默無名的個人研究者深感惶恐，此時撰寫網路爬蟲蒐集資料便成為必要的麻煩。無怪乎本站的〈Scrapy 筆記〉似乎也一直很熱門。

只是平常在學校有龐大學術網路資源的支持，撰寫爬蟲還算可行。但自己一個人寫爬蟲就很辛苦了。總會擔心 IP 被阻擋要怎麼辦，還有電腦開太久，到處亂爬，會不會因此被駭客攻擊等問題。

就在最近，得知有 Scrapy Cloud 這樣方便的服務，可以用來架設自己的爬蟲，感覺相當方便。於是本文就以 PTT 為範例，紀錄利用 Scrapy Cloud 撰寫爬蟲的過程。

環境設置

這次同樣使用 pyvenv 創立虛擬環境，好安裝自己的 Python 套件：

python -m venv env
source env/bin/activate
pip install -U pip

此外，也安裝 Scrapy，以及本次實驗會用到的加密套件等等。

pip install Scrapy cryptography html2text

Scrapy Cloud

Scrapy Cloud 其實就是 Scrapy 背後的公司 Scrapinghub 所推出的線上爬蟲服務。可以把自己寫好的爬蟲上傳到遠端的機器執行。由於 IP 偶爾就會換一次，所以可以大幅降低被阻擋的風險。在筆者撰文的當下，每個人的帳號都有一個免費的 slot (1 GB RAM) 可以用來跑爬蟲，爬下來的資料可供存放一個星期，個人使用已經相當足夠了。如果有更高的需求，也可用 $9/month 的價格購買多的 slots，或者購買可以每個 request 都使用不同 IP，大幅降低被阻擋風險的強大 proxy 服務。

創建完帳號後，首先可以在 API Key 頁面取得自己的 SH_APIKEY，到時上傳爬蟲時會用到。然後可以建立一個 project，並在 project 網址裡取得 SHUB_PROJECT_ID:

https://app.scrapinghub.com/p/<SHUB_PROJECT_ID>/jobs

最後也安裝專用的 shub 部署工具。

pip install shub

Backblaze B2 Cloud Storage

Scrapy Cloud 雖然方便，不過並不支援像圖片一般大檔案的儲存。平常在學術或者企業的研究單位裡，可能有類似 S3 之類的儲存方案。不過一般小資女，小資男等等可能就沒有辦法負擔了。Backblaze B2 Cloud Storage 在筆者撰文的當下，有著 $0.005/GB/month 的低廉價格，而且上傳免費，又有 10 GB 的免費空間，而且如果只是要使用免費的部份，也不用提供付款資料，不怕被亂收錢。對於個人爬蟲的應用來說，已經相當足夠了。

註冊以後，可以在 Buckets 頁面取得 Endpoint 以及 Key Id 和 Application Key，以下稱為 B2_ENDPOINT, B2_KEY_ID 以及 B2_APPLICATION_KEY，此外同時也可以創立一個 bucket 來存放檔案，以下就把這個 bucket 稱作 storage-ptt。注意雖然網頁上沒特別寫，但以下的 B2_ENDPOINT 是以 https:// 開頭。

最後可以安裝 boto3 套件，測試檔案的操作。

pip install boto3

撰寫爬蟲

於是就開始撰寫爬蟲！

首先創立專案：

scrapy startproject ptt_crawler

啟用自動連線延遲：

# <root_dir>/ptt_crawler/settings.py
AUTOTHROTTLE_ENABLED = True
AUTOTHROTTLE_START_DELAY = 5
AUTOTHROTTLE_MAX_DELAY = 60
AUTOTHROTTLE_TARGET_CONCURRENCY = 1.0

像上次一樣定義一些想要抓取的項目，包含本文和推文等等，但多增加檔案的欄位 files 和 file_urls：

# <root_dir>/ptt_crawler/items.py
class PostItem(scrapy.Item):
    title = scrapy.Field()
    author = scrapy.Field()
    date '= scrapy.Field:()'
    content = scrapy.Field()
    comments = scrapy.Field()
    score = scrapy.Field()
    url = scrapy.Field()
    file_urls = scrapy.Field()
    files = scrapy.Field()

接著創立爬蟲：

scrapy genspider posts ptt.cc

接著就編輯 <root_dir>/ptt_crawler/spiders/posts.py 實際撰寫爬蟲程式了。

有了上次的經驗，這次寫起來相當順利。首先設定起始的網址：

# <root_dir>/ptt_crawler/spiders/posts.py
import scrapy


class PostsSpider(scrapy.Spider):
    name = "posts"
    allowed_domains = ["ptt.cc"]
    start_urls = ["http://ptt.cc/bbs/PC_Shopping/index.html"]

    def __init__(self, *args, board_names: str = None, max_pages: str = "5", **kwargs):
        super().__init__(*args, **kwargs)
        if board_names is not None:
            self.start_urls = [
                BOARD_URL_FORMAT.format(board_name=board_name)
                for board_name in board_names.split(",")
            ]
        self._max_pages = int(max_pages)
        self._pages = 0

然後照抄以前的程式，不過移除 18 歲的部份：

# <root_dir>/ptt_crawler/spiders/posts.py
from ptt_crawler.items import PostItem


class PostsSpider(scrapy.Spider):
    def parse(self, response):
        self._pages += 1
        for href in response.css(".r-ent > div.title > a::attr(href)"):
            url = response.urljoin(href.extract())
            yield scrapy.Request(url, callback=self.parse_post)

        if self._pages < self._max_pages:
            next_page = response.xpath(
                '//div[@id="action-bar-container"]//a[contains(text(), "上頁")]/@href'
            )
            if next_page:
                url = response.urljoin(next_page[0].extract())
                self.logger.warning("follow {}".format(url))
                yield scrapy.Request(url, self.parse)
            else:
                self.logger.warning("no next page")
        else:
            self.logger.warning("max pages reached")

    def parse_post(self, response):
        item = PostItem()
        item["title"] = response.xpath('//meta[@property="og:title"]/@content')[
            0
        ].extract()
        item["author"] = (
            response.xpath(
                '//div[@class="article-metaline"]/span[text()="作者"]/following-sibling::span[1]/text()'
            )[0]
            .extract()
            .split(" ")[0]
        )
        datetime_str = response.xpath(
            '//div[@class="article-metaline"]/span[text()="時間"]/following-sibling::span[1]/text()'
        )[0].extract()
        item["date"] = datetime.strptime(datetime_str, "%a %b %d %H:%M:%S %Y")

        converter = html2text.HTML2Text()
        converter.ignore_links = True
        item["content"] = converter.handle(
            response.xpath('//div[@id="main-content"]')[0].extract()
        )

        comments = []
        total_score = 0
        for comment in response.xpath('//div[@class="push"]'):
            push_tag = comment.css("span.push-tag::text")[0].extract()
            push_user = comment.css("span.push-userid::text")[0].extract()
            push_content = comment.css("span.push-content::text")[0].extract()

            if "推" in push_tag:
                score = 1
            elif "噓" in push_tag:
                score = -1
            else:
                score = 0

            total_score += score

            comments.append(
                {"user": push_user, "content": push_content, "score": score}
            )

        item["comments"] = comments
        item["score"] = total_score
        item["url"] = response.url

        yield item

在 <root_dir> 根目錄（有 scrapy.cfg 的目錄）執行：

scrapy crawl posts -o test.jl

測試確實可以抓到文章。

抓取圖片

這次的示範裡，我們只想要抓有圖片的文章，所以將程式改寫。同時為了方便起見，只抓 imgur.com 上的 .jpg & .png 圖片。

# <root_dir>/ptt_crawler/spiders/posts.py
class BeautyImagesSpider(scrapy.Spider):
    def parse_post(self, response):
        # ...
        file_urls = response.xpath('//a[contains(@href, "imgur.com")]/@href').extract()
        if file_urls:
            file_urls = [
                url for url in file_urls if url.endswith(".jpg") or url.endswith(".png")
            ]
        if file_urls:
            item["file_urls"] = file_urls

            yield item

然後先按照 Downloading and processing files and images 的教學啟用 Files Pipeline 做測試：

# <root_dir>/ptt_crawler/spiders/posts.py
ITEM_PIPELINES = {
   'scrapy.pipelines.files.FilesPipeline': 1
}
FILES_STORE = 'images'

再次在 <root_dir> 根目錄（有 scrapy.cfg 的目錄）執行：

scrapy crawl posts -o test.jl

應該會看到在 <root_dir>/images/full/ 底下出現不少圖片。

假設只是要在本機上抓圖，這樣就行了，不過我們想在 Scrapy Cloud 上，把圖傳到 B2 空間，因此還得進行一些修改。

上傳 B2

首先寫好上傳的串接程式，這裡因為我主要是想抓圖，所以如果 B2 連不上就乾脆用 CloseSpider 把整個爬蟲關掉了。同時因為上傳不用用錢，獲取檔案資訊卻有限制，所以乾脆 stat_file 就讓他永遠回傳空的，反正遇到相同檔案就重新上傳就好。

# <root_dir>/ptt_crawler/spiders/pipelines.py
import logging

import boto3
from botocore.config import Config
from scrapy.exceptions import CloseSpider
from twisted.internet import threads


logger = logging.getLogger(__name__)


def get_b2_resource(endpoint: str, key_id: str, application_key: str):
    b2 = boto3.resource(
        service_name="s3",
        endpoint_url=endpoint,  # Backblaze endpoint
        aws_access_key_id=key_id,  # Backblaze keyID
        aws_secret_access_key=application_key,  # Backblaze applicationKey
        config=Config(
            signature_version="s3v4",
        ),
    )
    return b2


class B2FilesStore(object):
    B2_ENDPOINT = None
    B2_KEY_ID = None
    B2_APPLICATION_KEY = None

    def __init__(self, uri: str) -> None:
        try:
            assert uri.startswith("b2://")
            buckets_and_prefix = uri[5:].split("/", 1)
            if len(buckets_and_prefix) > 1:
                self.bucket, self.prefix = buckets_and_prefix
            else:
                self.bucket = buckets_and_prefix[0]
                self.prefix = None

            self.b2 = get_b2_resource(
                endpoint=self.B2_ENDPOINT,
                key_id=self.B2_KEY_ID,
                application_key=self.B2_APPLICATION_KEY,
            )
            self.c = self._get_b2_bucket()
        except (AssertionError, Exception) as e:
            logger.exception(e)
            raise CloseSpider("could not initialize B2")

    def stat_file(self, path, info):
        return {}

    def _get_b2_bucket(self):
        return self.b2.Bucket(self.bucket)

    def _upload_file(self, buf, file_name):
        self.c.upload_fileobj(buf, file_name)

    def persist_file(self, path, buf, info, meta=None, headers=None):
        """Upload file to B2 storage"""
        if self.prefix:
            key_name = os.path.join(self.prefix, path)
        else:
            key_name = path
        buf.seek(0)

        return threads.deferToThread(self._upload_file, buf=buf, file_name=key_name)

緊接著我們修改原本 scrapy 的 FilesPipeline 變成 EncryptedFilesPipeline。目的是為了讓他支援加密以及我們的 B2FilesStore。

之所以要加密的原因是為了怕鄉民上傳一些奇怪的圖片導致我們抓到怪圖上傳，可能造成停權之類的奇怪後果。

# <root_dir>/ptt_crawler/spiders/pipelines.py
from cryptography.fernet import Fernet

from scrapy.pipelines.files import FilesPipeline
from scrapy.utils.misc import load_object


class EncryptedFilesPipeline(FilesPipeline):
    # ...
    def __init__(self, store_uri, download_func=None, settings=None):
        super().__init__(store_uri,
                         download_func=download_func,
                         settings=settings)

        cls_name = "EncryptedFilesPipeline"
        resolve = functools.partial(self._key_for_pipe,
                                    base_class_name=cls_name,
                                    settings=settings)

        encryption_key = settings.get(resolve('FILES_ENCRYPTION_KEY'))
        if encryption_key is not None:
            self.cipher = Fernet(encryption_key)
        else:
            self.cipher = None

    @classmethod
    def from_settings(cls, settings):
        cls.STORE_SCHEMES = cls._load_components(settings, 'FILES_STORES')
        b2store = cls.STORE_SCHEMES['b2']
        b2store.B2_ENDPOINT = settings["B2_ENDPOINT"]
        b2store.B2_KEY_ID = settings["B2_KEY_ID"]
        b2store.B2_APPLICATION_KEY = settings["B2_APPLICATION_KEY"]
        store_uri = settings['FILES_STORE']
        return cls(store_uri, settings=settings)

    @staticmethod
    def _load_components(settings, setting_prefix):
        conf = without_none_values(settings.getwithbase(setting_prefix))
        d = {}
        for k, v in conf.items():
            try:
                d[k] = load_object(v)
            except NotConfigured:
                pass
        return d

    def file_downloaded(self, response, request, info):
        path = self.file_path(request, response=response, info=info)
        if self.cipher is not None:
            buf = BytesIO(self.cipher.encrypt(response.body))
        else:
            buf = BytesIO(response.body)
        checksum = md5sum(buf)
        buf.seek(0)
        self.store.persist_file(path, buf, info)
        return checksum

接下來可以在 <root_dir>/ptt_crawler/settings.py 填入以下設定：

# <root_dir>/ptt_crawler/settings.py
ITEM_PIPELINES = {'ptt_crawler.pipelines.EncryptedFilesPipeline': 1}

FILES_STORES = {
    '': 'scrapy.pipelines.files.FSFilesStore',
    'file': 'scrapy.pipelines.files.FSFilesStore',
    's3': 'scrapy.pipelines.files.S3FilesStore',
    'b2': 'ptt_crawler.pipelines.B2FilesStore',
}

然後填入對應的密鑰做測試，不過測試完這些設定還是不要直接寫在檔案裡比較好。

# <root_dir>/ptt_crawler/settings.py
FILES_ENCRYPTION_KEY = '<YOUR_ENCRYPT_KEY>'
FILES_STORE = 'b2://storage-ptt/ptt-posts/images/'
B2_ENDPOINT = '<B2_ENDPOINT>'
B2_KEY_ID = '<B2_KEY_ID>'
B2_APPLICATION_KEY = '<B2_APPLICATION_KEY>'

其中 storage-ptt 是在 B2 上創建的 bucket 名稱，後面的 ptt-posts/images/ 則是自行指定要存放圖片的根目錄。

而檔案加密的密鑰 YOUR_ENCRYPT_KEY 可以這樣產生：

from cryptography.fernet import Fernet


Fernet.generate_key()

加密完的檔案可以這樣解密：

from cryptography.fernet import Fernet


cipher = Fernet('<YOUR_ENCRYPT_KEY>')

with open('<INPUT_PATH>', 'rb') as infile, open('<OUTPUT_PATH>', 'wb') as outfile:
    outfile.write(cipher.decrypt(infile.read()))

再次在 <root_dir> 根目錄（有 scrapy.cfg 的目錄）執行：

scrapy crawl posts -o test.jl

應該會看到在 B2 裡出現不少加密檔案。

部署到 Scrapy Cloud

最後的部署，首先新增相依檔案 requirements.txt：

boto3
cryptography
html2text

再新增設定檔 scrapinghub.yml：

projects:
  default: <PROjECT_ID>
stacks:
    default: scrapy:1.3-py3
requirements_file: requirements.txt

接著將整個資料夾的相關程式碼和設定檔都 commit 到 git repository 裡。然後在該資料夾執行：

shub login
shub deploy

輸入相應的 SH_APIKEY 即可上傳。

最後則在 project 的 spiders settings https://app.scrapinghub.com/p/<SHUB_PROJECT_ID>/job-settings/standard 裡，把各種密鑰輸進去：

FILES_ENCRYPTION_KEY = '...'
FILES_STORE = '...'
B2_ENDPOINT = '...'
B2_KEY_ID = '...'
B2_APPLICATION_KEY = '...'

如此就行了！可在 Dashboard 執行上傳的爬蟲。

定期上傳抓取文章到 B2

Scrapy Cloud 也支援排程執行，所以可以每天都到板上抓圖。然而雖然做完以上步驟就會把下載的圖片上傳到 B2，可是抓取的文章還是在 Scrapy Cloud 裡頭。幸好 Scrapy Cloud 也提供定期執行自訂 script 的功能。所以我們也可以另外寫個程式把抓好的文章上傳到 B2 上。

由於 script 不像 spider 會自動讀取 project settings，我們先自行寫一個讀取的函式，這樣就可以在 script 裡讀取在 Scrapy Cloud 上設定的參數：

# <root_dir>/ptt_crawler/utils.py

import json
import os

from scrapy.utils.project import get_project_settings


def get_shub_project_settings():
    settings = get_project_settings()
    shub_settings = json.loads(os.environ.get('SHUB_SETTINGS', '{}'))
    settings.setdict(
        shub_settings.get('project_settings', {}),
        priority='project')
    return settings

除此之外也順便新增一些方便處理 B2 上傳的函式：

# <root_dir>/ptt_crawler/utils.py
from io import BytesIO

def split_bucket_prefix(uri):
    return uri[5:].split('/', 1)


def upload_file(bucket, file_name, content):
    with BytesIO() as source:
        source.write(content)
        source.seek(0)
        bucket.upload_fileobj(source, file_name)

最後就可以實際實做抓取資料的程式了，首先定義執行參數。

新增的 project settings 包含：

<SH_APIKEY>: 就是之前提到的 Scrapy Cloud 的 API Key
<SHUB_PROJECT_ID>: 本次部屬到 Scrapy Cloud 的 project ID
<ITEMS_STORE>: 儲存文章的地點，例如 b2://storage-ptt/ptt-posts/items/

同樣在 project 的 spiders settings https://app.scrapinghub.com/p/<SHUB_PROJECT_ID>/job-settings/standard 裡，把他們輸進去。

另外可以指定要抓取的 spider 名稱，以本例來說，只有 posts 一種。--delete 參數則是指定抓取完後，是否要把 Scrapy Cloud 上對應的 job 順便刪除，以免下次重複上傳。

# <root_dir>/ptt_crawler/bin/upload_items.py

import argparse

from ptt_crawler.utils import get_shub_project_settings


def parse_args():
    settings = get_shub_project_settings()

    parser = argparse.ArgumentParser(description=__doc__)

    parser.add_argument("--api-key", default=settings.get("SHUB_APIKEY"))
    parser.add_argument(
        "--project-id", type=int, default=settings.get("SHUB_PROJECT_ID")
    )
    parser.add_argument("--b2-endpoint", default=settings.get("B2_ENDPOINT"))
    parser.add_argument("--b2-key-id", default=settings.get("B2_KEY_ID"))
    parser.add_argument(
        "--b2-application-key", default=settings.get("B2_APPLICATION_KEY")
    )
    parser.add_argument("--b2-path", default=settings.get("ITEMS_STORE"))
    parser.add_argument("--delete", action="store_true")
    parser.add_argument("spider_name", nargs="+", help="Spider name to get info from.")
    args = parser.parse_args()

    assert args.b2_path.startswith("b2://")
    return args


if "__main__" == __name__:
    main(**vars(parse_args()))

最後則是主程式，先用 ScrapinghubClient 列出需要處理的 jobs。

# <root_dir>/ptt_crawler/bin/upload_items.py

from scrapinghub import ScrapinghubClient


def main(api_key, project_id, spider_name, b2_account_id, b2_application_key,
         b2_path, delete):
    # ...

    client = ScrapinghubClient(api_key)
    project = client.get_project(project_id)
    for name in spider_name:
        spider = project.spiders.get(name)
        job_list = spider.jobs.list(state="finished")
        keys = []
        for job in job_list:
            if "items" in job and job["items"] > 0:
                keys.append(job["key"])

緊接著，把下載的文章用 gzip 壓縮後，上傳到指定的位置上，並順便刪除上傳完的 jobs：

# <root_dir>/ptt_crawler/bin/upload_items.py

import gzip
import io
import json
import logging
import os

from b2.api import B2Api
from ptt_crawler.utils import split_bucket_prefix
from ptt_crawler.utils import upload_file


def main(api_key, project_id, spider_name, b2_account_id, b2_application_key,
         b2_path, delete):
    bucket_name, root = split_bucket_prefix(b2_path)
    bucket = None

    for name in spider_name:
        # ...

        if keys:
            if bucket is None:
                b2 = get_b2_resource(b2_endpoint, b2_key_id, b2_application_key)
                bucket = b2.Bucket(bucket_name)
            for key in keys:
                job = spider.jobs.get(key)
                if job:
                    out = io.BytesIO()

                    with gzip.GzipFile(fileobj=out, mode="w") as outfile:
                        for item in job.items.iter():
                            line = json.dumps(item) + "\n"
                            outfile.write(line.encode("utf8"))
                    content = out.getvalue()
                    file_name = os.path.join(root, name,
                                             key.replace("/", "-") + ".jl.gz")
                    upload_file(bucket, file_name, content)

                    if delete:
                        job.delete()
                        logging.warning("job {} deleted".format(key))

然後在 setup.py 新增 script 的位置 bin/upload_items.py：

# <root_dir>/ptt_crawler/setup.py
# Automatically created by: shub deploy

from setuptools import setup, find_packages

setup(
    name         = "project",
    version      = "1.0",
    packages     = find_packages(),
    scripts      = ["bin/upload_items.py"],
    entry_points = {"scrapy": ["settings = ptt_crawler.settings"]},
)

新增相依檔案 requirements.txt 中的一行：

scrapinghub

緊接著上傳更新的程式：

shub deploy

最後就能在 Dashboard 上執行 script 了，記得在 Arguments 欄位填上 posts 等參數。

結語

如此一來就能順利的每天抓文章和圖了，其他像是偵測不要抓到同樣的文章等等的功能就請各位自行研究了。

這次實驗所用到的程式碼按照慣例放在 GitHub 上面供參考：https://github.com/shaform/ptt-crawler。

生成對抗網路 - Generative Adversarial Networks

Tue, 04 Apr 2017 15:37:00 +0800

前言

記得最早聽說 Generative Adversarial Networks 似乎是去年看到〈Image Completion with Deep Learning in TensorFlow〉這篇文章。這篇文章提到如何用 GAN 來對圖片進行腦補。比如說像是把人臉的中心遮起來，然後再用 GAN 補完幻想的人臉。效果如下所示。當時覺得感覺好酷阿，想像中可以腦補的東西真的很多，例如後來看到有人腦補眼鏡、腦補笑容和年紀，或者腦補動漫人物。而 GAN 作為其中一種生成模型，視覺效果是相當不錯的。

Superb tutorial on adversarial nets by @brandondamos
Bonus section: thoughts on Torch vs TFhttps://t.co/uwG8l2qytd pic.twitter.com/P0XpEmbiyZ
— Soumith Chintala (@soumithchintala) August 9, 2016

就在那附近的時候，也終於下定決心換新六年多沒更新的桌機，順便買了一張 GTX 1060 來練習 Deep Learning。只是後來因為生活忙碌，所以雖然偶爾有拿別人的程式來跑跑看看效果，但一直沒有真正的寫程式。

現在剛好遇到連假，想說練習一下 TensorFlow，決定模仿〈ご注文は機械学習ですか？〉網誌上的文章，做點簡單的實驗。

環境

這次我是用 TensorFlow 1.0 配合 GTX 1060 來做這次的實驗。Python 則是用 Anaconda 安裝 Python 3.6。

本次使用的程式碼可以在 DeepNetworks 找到。如有興趣可自行參考。將會用 Jupyter Notebook 來做實驗，可以在〈GAN - Mixture of Gaussians Experiment〉找到實驗的過程。

我將用個簡單的二維資料來測試 GAN 學會其分佈的能力。如下所示，每個白點都是一個資料點，希望 GAN 能成功學會他們主要分佈於七個地方。

生成實驗

這個實驗我先實做了三個模型，一個是基本的 GAN，不過我加上了 label smoothing 的修改，同時雖然是用 fully-connected layers 但 batch normalization 和 activation functions 有參考一些 DCGAN 的設計。第二個則是和〈Conditional Image Synthesis With Auxiliary Classifier GANs〉很像的 ACGAN，在訓練時會告知資料點是 0~6 哪一群的資料點。生成時也會 7 群可以條件式的分開產生。最後則是 WGAN。

GAN 和 ACGAN 都跑一樣多的 epochs，但是 WGAN 因為 discriminator 要多用很多資料訓練很多次，而且 learning rate 又比較小，所以要跑相對多很多的 epochs 才能得到結果。

結果如下所示，其中 ACGAN 每個顏色表示是在輸入要求生成不同群的資料。可以看到確實成功的學會不同群的資料位置。

Learning to Discover Cross-Domain Relations with Generative Adversarial Networks

同時，最近又恰好看見一個新的 DiscoGAN，相當神奇。只要將兩組沒有事先標記他們之間對應的資料丟進去，就可以自動學會兩組資料的對應。

也就是說，假設我改用有 8 群分佈的 Mixture of Gaussians 將其中 4 群當成第一份資料，另外 4 群當成第二份資料，應該可以期待 DiscoGAN 有可能會把兩邊的四群各自一對一對應。

實驗結果如下，六欄分別是：

原始的第一份資料，共有四群
透過 DiscoGAN 轉換成第二份資料，同樣顏色是從同樣的資料點轉換過來的，可以看見他確實大概的把四群一對一對應了。
透過 DiscoGAN 再轉回第一份資料。
原始的第二份資料，共有四群
透過 DiscoGAN 轉換成第一份資料。
透過 DiscoGAN 再轉回第二份資料。

結語

這次為了實做學到不少東西，像是 tf.contrib.layers.batch_norm 在 share weights 時要如何使用，同時雖然我還沒做完圖像的實驗，不過也學了不少 tensorflow 的 I/O。希望有空時能更新這篇文章，再加上圖像實驗以及更詳細的 GAN 介紹。

用 Ansible 和 yadm 來加速重灌流程

Sat, 25 Mar 2017 09:09:00 +0800

前言

還記得當年修計算機系統管理時曾經為了做 NFS + NIS 的作業自行開了三台虛擬機設定環境，同時灌三台電腦實在是煞費精力。在此之後雖然比較少遇到此情形，但還是得常常重灌電腦。像是研究所期間，自己的桌機、筆電，以及實驗室的桌機都是自己裝的 Ubuntu，而每次升級病發就會想重灌成新的版本，久了以後慢慢把安裝的東西寫成 Bash scripts，可是還是相當繁瑣。

就在最近的時候，偷聽大大們聊天，得知了 Ansible 這個方便的自動化部屬工具。由於它使用時目的端完全不須安裝任何套件，而是從本地端完全使用 SSH 進去目的端安裝設定軟體，感覺也挺適合個人重灌的需求。於是就花了一點時間研究了一下。在此同時，也得知了 yadm 這個 dotfiles 管理套件，也花了一點時間把原本用 Makefile 來安裝的 dotfiles 改成用 yadm 管理了。

Ansible 設定

實際上 Ansible 的功用是用來自動化部署而不是拿來重灌個人電腦的，所以尋找文件時常常看到許多複雜功能。這份文件只挑些用在重灌上有用的部份。

安裝 Ansible 的方法非常簡單，只要使用 pip install ansible 或者是 sudo apt install ansible 即可。

然後我建立一個資料夾放置設定檔，組織成如下所示：

.
├── ansible.cfg
├── hosts
├── anaconda.yml
├── desktop.yml
└── roles
    ├── anaconda
    │   └── tasks
    │       └── main.yml
    ├── base
    │   └── tasks
    │       └── main.yml
    └── desktop
        └── tasks
            └── main.yml

首先在 ansible.cfg 裡指定用來設定有哪些機器的 hostfile 的位置：

[defaults]
hostfile = hosts

然後在 hosts 裡設定機器位址，例如：

[host1]
192.168.1.2

[host2]
192.168.1.3 ansible_ssh_user=bob ansible_ssh_private_key_file=~/.ssh/bob.pem

[servers]
192.168.1.4
192.168.1.5
192.168.1.6

每個 group 可以設定多個機器，也可以指定使用者名稱和登入方法等等，見：〈Inventory〉。

deploy 則是一個簡單的 Bash script，用來方便執行。使用方法為：

./deploy HOST YML

利用 HOST 指定要設定的機器名稱，例如之前設定的 host1 或者 localhost，YML 則是要執行的 playbook 設定檔，例如最上層的 anaconda.yml 或者 desktop.yml。

#!/bin/bash
HOST=${1:-localhost}
YML=${2:-desktop.yml}
ansible-playbook --ask-become-pass --extra-vars="hosts=$HOST" $YML

desktop.yml 和 anaconda.yml 則是簡單的 Playbooks，用來指定要執行哪些 tasks。例如我在 desktop.yml 寫要用 root 權限執行 base 和 desktop 兩個 roles：

---

- hosts: '{{ hosts }}'
  become: true
  become_user: root
  roles:
    - base
    - desktop

anaconda.yml 則寫要用正常使用者權限執行 anaconda 這個 role：

---

- hosts: '{{ hosts }}'
  roles:
    - anaconda

Roles

最後的 roles 資料夾底下把相關的設定項目放在一起，這樣分開設定的好處是，可以根據不同機器的需求指定要執行哪些 roles，此外，也可以用 git submodule 之類的方法直接利用別人寫好的 roles。

先從 base.yml 開始，這個檔案裡我設置了一些基本的系統設定：

---

# 建立 sudoers.d 資料夾，以放置設定檔
- name: mkdir for configure files
  file:
    dest: '{{ item.dest }}'
    owner: root
    group: root
    mode: '{{ item.mode | default("0755") }}'
    state: directory

  with_items:
    - dest: /etc/sudoers.d

# 因為我自己的使用者 umask 設的比較嚴格，避免 sudo 受影響所以加上這個把 sudo 的 umask 轉回來
- name: set sudo umask
  copy:
    dest: '{{ item.dest }}'
    owner: root
    group: root
    mode: '{{ item.mode | default("0644") }}'
    content: '{{ item.content }}'

  with_items:
    - dest: /etc/sudoers.d/umask
      mode: '0400'
      content: |
        # This file is managed by Ansible. DO NOT EDIT.

        Defaults umask_override
        Defaults umask = 0002

# 更新系統
- name: upgrade packages
  apt:
    upgrade: dist
    update_cache: yes

# 安裝常用套件
- name: install core packages
  apt:
    name: '{{ item.name }}'
    state: '{{ item.state | default("present") }}'
    purge: yes

  with_items:
    - name: git-core
    - name: gufw
    - name: htop
    - name: p7zip-full
    - name: p7zip-rar
    - name: screen
    - name: tmux
    - name: yadm

desktop.yml 則用來放個人桌機常用的設定：

---

# 建立資料夾來放之後的設定檔
- name: mkdir for configure files
  file:
    dest: '{{ item.dest }}'
    owner: root
    group: root
    mode: '{{ item.mode | default("0755") }}'
    state: directory

  with_items:
    - dest: /usr/share/lightdm/lightdm.conf.d

# 取消訪客登入
- name: disable guest login
  copy:
    dest: '{{ item.dest }}'
    owner: root
    group: root
    mode: '{{ item.mode | default("0644") }}'
    content: '{{ item.content }}'

  with_items:
    - dest: /usr/share/lightdm/lightdm.conf.d/50-no-guest.conf
      mode: '0400'
      content: |
        # This file is managed by Ansible. DO NOT EDIT.

        [SeatDefaults]
        allow-guest=false

# 安裝一些我常用的軟體
- name: install desktop apps
  apt:
    name: '{{ item.name }}'
    state: '{{ item.state | default("present") }}'
    purge: yes
    update_cache: yes

  with_items:
    - name: ibus-chewing
    - name: keepassx
    - name: libappindicator1 # For Dropbox
    - name: python-gpgme # For Dropbox
    - name: nautilus-dropbox
    - name: workrave

# 安裝 Google Chrome
- name: install Google Chrome
  apt:
    deb: 'https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb'
    update_cache: yes


最後則是安裝 Anaconda 的部份，我會先安裝 Anaconda 2：

    :::yml
    ---

    - name: download Anaconda
      get_url:
        url: 'https://repo.continuum.io/archive/Anaconda2-4.3.1-Linux-x86_64.sh'
        dest: /tmp/Anaconda2-4.3.1-Linux-x86_64.sh
        mode: '0755'

    - name: install Anaconda
      command: bash /tmp/Anaconda2-4.3.1-Linux-x86_64.sh -b -p {{ ansible_env.HOME }}/anaconda2
      args:
        creates: '{{ ansible_env.HOME}}/anaconda2'

    - name: add Anaconda to PATH
      lineinfile:
        name: '{{ ansible_env.HOME }}/.bashrc'
        line: 'export PATH=$HOME/anaconda2/bin:${PATH}'

然後再進到目的機器額外安裝 Python 3 的環境：

conda create -n py3 python=3.6 anaconda

不過還不確定以上這件事怎麼寫成 Ansible playbook 比較好。

實際執行

假設新安裝的電腦是 host1 的話，那我就執行以下指令來安裝設定：

./deploy host1 desktop.yml

當然也可以直接登入該電腦，然後把 host1 改成 localhost 直接在本地執行。

yadm

至於 yadm 使用起來就非常簡單了。基本上就是一個可以把家目錄直接當成 git repository 的簡單套件。首先安裝：

sudo apt install yadm

然後剛開始可以直接：

yadm init
yadm add ~/.vimrc
yadm add ~/.tmux.conf
# ...
yadm commit -m 'first commit!'

如果要同步已經有的 repository 則是：

yadm clone <url>
# ...
yadm pull

跟正常的 git 一模一樣。

其他比較有用的功能大概是 Boostrap，可以取代我原本用 Makefile 手動打指令的部份。

結語

本次設定檔放在 shaform/experiments/ansible。其他還可以參考：

用 Sacred 追蹤實驗數據

Sat, 18 Mar 2017 15:33:00 +0800

前言

前陣子相當恰好的常有跑大量實驗的需求，跑著跑著就開始覺得管理實驗執行和整理數據實在相當繁瑣且容易產生錯誤。

以執行而言，由於處理的檔案龐大、計算時間冗長、使用機器繁多，如何最有效率的把實驗跑完，同時又盡可能避免重複計算浪費時間，就成了難題。尤其考慮有時會因為不可抗力因素導致部份實驗中斷，此時要如何從一半的結果繼續執行，同時又最節省時間也是值得思考的點。

管理實驗數據部份，也因為使用機器增多及實驗繁多而複雜了起來。看到有種作法是利用 bash script 或者 Makefile 紀錄參數，然後將不同參數輸出的 stdout 導進指定的檔案名字裡來產生不同條件的實驗數據。不過這樣做很容易就會不小心改了參數卻把輸出導進錯誤的地方，導致最後數據錯誤。同時如果有很多台機器，資料又存在本機，那就得進行不少手動處理而無法全自動重現實驗結果。

感覺如果每次開始新的實驗就在程式碼中使用大量的自訂程式來處理這些問題好像一不小心就會花去太多時間。可是如果在忙亂中持續用奇怪的作法做實驗，心中的不安全感產生的焦慮又與日俱增，實在相當痛苦。

之前問了友人：

「大大都怎麼跑實驗阿？」

「包成 Docker 先放著。或是用 Makefile + GitLab 做版本管控。用 Jenkins + ZooKeeper 管理，然後隨時打點 OpenTSDB 用 Grafana 監控。」

感覺好像相當有道理。像是可以把各種 jobs 交給 Jenkins 管理，藉此得知哪些已經跑完，哪些還要跑，然後選擇要在什麼機器跑，並且將結果回收到同一個地方。不過實際上到底要如何做到實在也找不到範例可抄襲。

由於每天實在過得很忙亂，只好苟且的一天過一天。好不容易有個週末無車無人的時刻，趕緊稍微做點小實驗來測試怎麼樣的作法較好。

這次要介紹的 Sacred 其實最早是去年讀到〈Show Your Work: A Month with Sacred〉這篇文章時所發現的。它是從遠在瑞士的 Istituto Dalle Molle di Studi sull’Intelligenza Artificiale (IDSIA) 發展出來的一套工具，據說就是企圖解決做實驗難題的一個嘗試。

環境設定

為了使用 Sacred，首先我裝了一套 MongoDB，為了方便起見我就參考教學直接裝在本機上。接著用 pip3 安裝 Sacred 相關套件，因為不知為何不指定版本會裝到舊的，所以這裡我就指定了 Sacred 的版本：

pip3 install sacred==0.7b3 pymongo

除此之外也安裝其他實驗會用到的套件：

pip3 install xgboost jupyter matplotlib numpy tensorflow-gpu scikit-learn sacredboard

實驗設計

這次我打算用知名的 MNIST 手寫辨識資料集來做實驗，不過我將把訓練資料集隨機取樣 500、1000 或 1500 個來訓練分類器，藉此測試他們在資料稀少時的效能。同時為了避免受到取樣偏差的影響，同樣大小的取樣我會各作十次，再將十次的結果取平均值。

這次測試的分類器則是預設參數的 xgboost、linear svm 和一個順便練習 TensorFlow 實作的 SoftmaxClassifier。

主程式

首先設定這次實驗所需的參數，我用最簡單的方法，使用 ex.config 來宣告實驗參數。其中亂數種子 seed 因為預設本來就有，就不特別列出了。

# mnist.py
from sacred import Experiment
ex = Experiment('mnist_sampled')

@ex.config
def my_config():
    sample_size = 500
    classifier = 'svc'

緊接著實作實驗程式，每次將資料進行取樣，並且利用特定的分類器去驗證效能。利用 ex.automain 來宣告實驗主程式`。

# mnist.py
from sklearn.metrics import accuracy_score
from tensorflow.examples.tutorials.mnist import input_data

@ex.automain
def run_experiments(data_dir='MNIST_data'):
    mnist = input_data.read_data_sets(data_dir, one_hot=False)
    X_test = mnist.test.images
    y_test = mnist.test.labels

    X_train, y_train = sample_data(mnist.train.images, mnist.train.labels)

    clf = get_classifier()
    clf.fit(X_train, y_train)
    y_train_pred = clf.predict(X_train)
    train_accuracy = accuracy_score(y_train, y_train_pred)

    y_test_pred = clf.predict(X_test)
    test_accuracy = accuracy_score(y_test, y_test_pred)

    return {'train_accuracy': train_accuracy, 'test_accuracy': test_accuracy}

接下來實作取樣和選擇分類器的函式。值得注意的是，實驗參數因為可以被 Sacred 透過 ex.capture 自動傳入，所以呼叫子函數時可以不直接傳進去也沒關係。此外，_rnd 是一個會根據 seed 來決定的亂數器，在每次實驗時，只要 seed 一樣，則同一個函式呼叫被呼叫特定次數時的 _rng 就會產生一樣的亂數，所以可以確保取樣出來的資料是一樣的。詳情可見：〈Controlling Randomness〉。

# mnist.py
import numpy as np
import xgboost as xgb

from sklearn.svm import LinearSVC

from softmax import SoftmaxClassifier

@ex.capture
def sample_data(X, y, sample_size, _rnd):
    indices = np.arange(X.shape[0])
    choice_indices = _rnd.choice(indices, sample_size)
    return X[choice_indices, :], y[choice_indices]


@ex.capture
def get_classifier(classifier):
    if classifier == 'svc':
        return LinearSVC()
    elif classifier == 'softmax':
        return SoftmaxClassifier()
    elif classifier == 'xgb':
        return xgb.XGBClassifier()
    else:
        return None

SoftmaxClassifier 的程式我放在 softmax.py。如有興趣可自行參考。

執行實驗

我寫了一個簡單的 bash script 來幫我執行所有想執行的實驗。當然這種作法會導致 MNIST 被不斷重複讀取，感覺不是很有效率，若想節省機器時間或許可以考慮用 ex.run 來執行程式。

#!/bin/bash

for clf in svc xgb softmax ;
do
  for sample_size in 500 1000 1500 ;
  do
    for seed in 1 2 3 4 5 6 7 8 9 10 ;
    do
      python mnist.py with classifier=$clf sample_size=$sample_size seed=$seed -m sacred || exit 1
    done
  done
done

使用 Sacred 的程式可以直接用 with 選項來傳入所有實驗參數。至於 -m 則是指定要寫入的 MongoDB 位址。由於我的資料庫直接裝在本機，所以這裡單純指定了資料集的名字。詳情可見：〈Command-Line Interface〉。至於 || exit 1 則是為了讓我如果手動中斷程式時，for loop 可以被中斷而不會繼續跑下去。

回收結果

一旦執行了以後 Sacred 就會自動將實驗參數、回傳結果以及一些像是執行時間、執行過程的 stdout 等等通通都寫進 MongoDB 當中。我們也可以執行 sacredboard 來觀察執行狀況。不過老實說這功能實在還有點陽春：

sacredboard -m sacred

是以，我們還是自己寫個程式來回收吧。還好 MongoDB 裡紀錄了所有實驗參數，因此要回收特定數據也是相當容易的。

這次我們還是會用 Jupyter Notebook 方便畫圖。首先連結到本機的 MongoDB：

from pymongo import MongoClient
mc = MongoClient()
db = mc['sacred']

緊接著把每個分類器在不同情形的十個數據都回收：

import numpy as np

sample_sizes = (500, 1000, 1500)
classifiers = ('svc', 'xgb', 'softmax')

results = []
for clf in classifiers:
    clf_mean = []
    clf_std = []
    for sample_size in sample_sizes:
        test_accuracy = []
        for seed in range(1, 11):
            result = db['runs'].find_one({'experiment.name': 'mnist_sampled',
                                 'config.classifier': clf,
                                 'config.sample_size': sample_size,
                                 'config.seed': seed,
                                 'status': 'COMPLETED'},
                                {'result': 1})
            test_accuracy.append(result['result']['test_accuracy'])
        clf_mean.append(np.mean(test_accuracy))
        clf_std.append(np.std(test_accuracy))
    results.append((clf_mean, clf_std))

最後則把結果畫出來：

import matplotlib.pyplot as plt

fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(8, 6))

ax.set_title('Test Accuracy of Different Classifiers on MNIST')
ax.set_xlabel('sample size')
ax.set_ylabel('test accuracy')

xticks = np.arange(len(sample_sizes))
ax.set_xticks(xticks)
ax.set_xticklabels(sample_sizes)

for i, clf in enumerate(classifiers):
    ax.errorbar(xticks, results[i][0], yerr=results[i][1], label=clf)
ax.legend(bbox_to_anchor=(1, -0.1))
    
plt.show()

完成！

結語

本次的實驗程式放在 shaform/experiments/sacred，最後的 notebook 同時也可以在 Sampled MNIST 上觀看。

用 TensorBox 製作簡易貓貓辨識器

Sat, 05 Nov 2016 13:40:00 +0800

最近恰好有個需求是要收集大量特定物體的圖片，直覺的想法就是訓練一個該物體的偵測器，然後再用這個偵測器從大量圖片中找出符合需求的區塊。經過一番搜尋，發現 TensorBox 似乎是個用來訓練單一物體偵測器的簡單套件，於是便利用貓咪來進行了簡單的嘗試。

本文使用的套件有的是只支援 Python 2，此時執行時將會以 python 程式執行。但筆者寫的 scripts 大多是 Python 3，本文中就以 python3 來表示。

本文將會用到不少套件，實際放置套件的資料夾結構如下：

./
./cats
./TensorBox
./labelImg
./labels
./data
./data/train
./data/test

實際的程式可在 shaform/experiments/cat 裡找到，本文只會顯示重點部份。

收集資料

首先我們使用 maxogden/cats 收集好的小規模貓貓照片來進行實驗，我們將利用 catmapper 資料夾中的照片做為訓練資料，最後再用 cat_photos 裡的照片來觀看結果。

值得注意的是，這樣的訓練資料只有大約三百多筆，而且每張照片裡幾乎都有貓。實際上若是真的要訓練高品質的偵測器，應當收集更多的訓練資料，而且應該要加入一些沒有貓，或者有跟貓很像但不是貓的物體，來加強模型的能力。不過本文純屬示範工具用法，未免麻煩就不做深入探討了。

由於 TensorBox 比較支援圖片大小為 32 倍數的照片，不符時須縮放或擷取。為了方便起見我就先把圖片都轉成適當大小。首先安裝 Pillow 套件：

pip3 install Pillow

緊接著寫一個程式可以將圖片裁成指定大小 608x608，然後轉成 png 檔案格式儲存：

import os

from PIL import Image

image_extensions = {'png', 'jpg', 'jpeg'}


def crop_center(img, width, height):
    x = img.size[0] // 2
    y = img.size[1] // 2

    x1 = x - (width // 2)
    x2 = x + (width - width // 2)

    y1 = y - (height // 2)
    y2 = y + (height - height // 2)

    try:
        return img.crop((x1, y1, x2, y2))
    except OSError as e:
        print(e)
        return None


def main(indir, outdir, width, height):
    for fname in os.listdir(indir):
        parts = fname.rsplit('.', 1)
        if len(parts) == 2 and parts[1] in image_extensions:
            name, ext = parts
            img = Image.open(os.path.join(indir, fname))

            if img.size[0] >= width and img.size[1] >= height:
                img = crop_center(img, width, height)
                if img:
                    img.save(os.path.join(outdir, name + '.png'))

並且將訓練和測試資料進行處理：

mkdir data/train data/test
python3 crop.py --indir cats/catmapper --outdir data/train
python3 crop.py --indir cats/cat_photos --outdir data/test

標記貓貓

緊接著，我們使用 labelImg 來針對訓練資料 cats/catmapper 做標記，並將標記存放在 labels 資料夾裡。

注意到 labelImg 只支援 Python 2，同時要先按照官方安裝步驟進行初始化：

cd labelImg
sudo apt-get install pyqt4-dev-tools
sudo pip install lxml
make all

./labelImg.py

可以利用 Ctrl-N, N, P 等快速鍵，建立框框來標記貓咪，以及切換上一張、下一張照片。

緊接著，撰寫一個程式將標記好的資料轉成 TensorBox 能夠讀取的格式：

import json
import os
import random
import xml.etree.ElementTree as ET


def main(indir, outdir, name, seed):
    random.seed(seed)
    if name is None:
        name = os.path.basename(indir)

    entries = []

    for path in sorted(os.listdir(indir)):
        if path.endswith('.xml'):
            tree = ET.parse(os.path.join(indir, path))
            root = tree.getroot()

            img_path = root.findtext('path')
            rects = []

            for obj in root.iter('object'):
                x1 = float(obj.find('bndbox').findtext('xmin'))
                y1 = float(obj.find('bndbox').findtext('ymin'))
                x2 = float(obj.find('bndbox').findtext('xmax'))
                y2 = float(obj.find('bndbox').findtext('ymax'))

                rects.append({'x1': x1, 'x2': x2, 'y1': y1, 'y2': y2})

            entry = {'image_path': img_path, 'rects': rects}
            entries.append(entry)

    random.shuffle(entries)

    train_offset = int(len(entries) * 0.8)

    train = entries[:train_offset]
    val = entries[train_offset:]

    datasets = [('train', train), ('val', val)]

    for prefix_name, dataset in datasets:
        with open(
                os.path.join(outdir, '{}_{}_boxes.json'.format(
                    name, prefix_name)), 'w') as f:
            json.dump(dataset, f, indent=4, separators=(',', ': '))

將標記轉換到 data 資料夾之下：

python3 extract_label.py --indir labels --outdir data

安裝 TensorBox 並進行訓練

TensorBox 似乎是只支援 Python 2，所以首先設定好 TensorFlow 的 Python 2 版本。接著還要安裝一些相依套件（因為 OpenCV 似乎比較難設定，所以我安裝系統套件）：

sudo apt install python-opencv
pip install Cython numpy scikit-image jupyter

接下來下載 TensorBox：

git clone http://github.com/russell91/Tensorbox
cd Tensorbox
./download_data.sh
cd utils && make && cd ..

緊接著修改 TensorBox/hypes/overfeat_rezoom.json 對應的項目：

注意到，train_idl 和 test_idl 須使用絕對路徑。

"train_idl": "/path/to/data/labels_train_boxes.json",
"test_idl": "/path/to/data/labels_val_boxes.json",
"image_width": 608, 
"image_height": 608,
"grid_height": 19, 
"grid_width": 19,

最後就是實際進行訓練了！這個會跑很久，並且把訓練的不同階段的模型存在 TensorBox/output/overfeat_rezoom_{DATETIME}/save.ckpt-{iteration}。由於訓練資料實在很少，所以不須訓練到太後面，可以拿前面的版本就好。

cd TensorBox
python train.py --hypes hypes/overfeat_rezoom.json --gpu 0 --logdir output

測試結果

最後就用 Jupyter Notebook 來檢視我們的結果，先把之前提到的 save.ckpt-10000 以及 save.ckpt-10000.meta 存到 project 根目錄。然後在根目錄用跟 TensorBox 一樣的 Python 2 環境執行：

jupyter notebook

進行初始化：

%matplotlib inline

import json
import os
import random

import tensorflow as tf

import matplotlib.pyplot as plt

from scipy.misc import imread

方便起見將 TensorBox 直接加到路徑，平時請勿模仿：

import sys
sys.path.append('./TensorBox')

from train import build_forward
from evaluate import add_rectangles

最後照抄 TensorBox 的示範程式碼，更改一些檔案路徑：

model_path = './save.ckpt-10000'
image_dir = './data/test'
hypes_file = './TensorBox/hypes/overfeat_rezoom.json'

with open(hypes_file, 'r') as f:
    H = json.load(f)

tf.reset_default_graph()
x_in = tf.placeholder(
    tf.float32, name='x_in', shape=[H['image_height'], H['image_width'], 3])

if H['use_rezoom']:
    pred_boxes, pred_logits, pred_confidences, pred_confs_deltas, pred_boxes_deltas = build_forward(
        H, tf.expand_dims(x_in, 0), 'test', reuse=None)
    grid_area = H['grid_height'] * H['grid_width']
    pred_confidences = tf.reshape(
        tf.nn.softmax(
            tf.reshape(pred_confs_deltas, [grid_area * H['rnn_len'], 2])),
        [grid_area, H['rnn_len'], 2])
    if H['reregress']:
        pred_boxes = pred_boxes + pred_boxes_deltas
else:
    pred_boxes, pred_logits, pred_confidences = build_forward(
        H, tf.expand_dims(x_in, 0), 'test', reuse=None)

saver = tf.train.Saver()
with tf.Session() as sess:
    sess.run(tf.initialize_all_variables())
    saver.restore(sess, model_path)

    images = os.listdir(image_dir)
    for i in range(5):
        fname = random.choice(images)
        path = os.path.join(image_dir, fname)
        img = imread(path)
        feed = {x_in: img}
        (np_pred_boxes, np_pred_confidences) = sess.run(
            [pred_boxes, pred_confidences], feed_dict=feed)
        new_img, rects = add_rectangles(
            H, [img],
            np_pred_confidences,
            np_pred_boxes,
            use_stitching=True,
            rnn_len=H['rnn_len'],
            min_conf=0.7,
            show_suppressed=False)

        fig = plt.figure(figsize=(12, 12))
        plt.imshow(new_img)

就可以在 Notebook 上看到成果了！！！

以下分別展示一張成功和一張失敗的照片，如果增加更多訓練資料或者使用更容易辨認的物體，效果應該可以更好才是。

在 Ubuntu 16.04 安裝 CUDA 8.0 和 TensorFlow 0.11 並使用內顯顯示畫面

Mon, 31 Oct 2016 21:28:00 +0800

本文紀錄了使用內顯來顯示畫面，而透過 Nvidia 顯卡來進行 CUDA 計算的安裝步驟。

顯卡設定

基礎設定

首先在 BIOS 裡設定內顯為主要顯卡，並且將螢幕接到內顯輸出上。

安裝 CUDA

接著到 CUDA 下載頁面下載對應的 deb 檔案。緊接著，重開 Ubuntu，並在登入畫面時按下 Ctrl-Alt-F1 進入命令列界面。

執行以下指令關閉 lightdm，據這裡的講法，這樣就可以達成將內顯和顯卡功能分開的目的。筆者測試如果沒執行這個指令，則最後安裝完 CUDA 重開機就會無法進入圖形登入畫面。

sudo service lightdm stop

接著實際安裝 CUDA，並重新開機，確認可以登入：

sudo dpkg -i cuda-repo-<distro>_<version>_<architecture>.deb
sudo apt update
sudo apt install cuda
sudo reboot

安裝 cuDNN

接著到 cuDNN 下載頁面下載 cuDNN v5，然後按照 TensorFlow 文件指示，將檔案複製到指定位置：

tar xvzf cudnn-8.0-linux-x64-v5.1-ga.tgz
sudo cp cuda/include/cudnn.h /usr/local/cuda/include
sudo cp cuda/lib64/libcudnn* /usr/local/cuda/lib64
sudo chmod a+r /usr/local/cuda/include/cudnn.h /usr/local/cuda/lib64/libcudnn*

設定環境變數

接下來在 .bashrc 或者其他開機時會載入的啟動檔案中加入：

export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/cuda/lib64:/usr/local/cuda/extras/CUPTI/lib64:/usr/lib/nvidia-367
export CUDA_HOME=/usr/local/cuda
export PATH=$PATH:/usr/local/cuda/bin

其中 /usr/lib/nvidia-367 可指到你實際安裝的顯卡驅動程式版本。

最後重新開機即可。

開機完可執行 nvidia-smi 確定顯卡真的有裝好。

安裝 TensorFlow

由於這部份跟官方文件一模一樣，沒有特別更改什麼。所以詳細安裝步驟就直接參考官方文件即可。

安裝 Caffe

由於安裝 Caffe 的步驟跟官方有些不一樣，故順便紀錄。

首先安裝需要的套件：

sudo apt install build-essential libprotobuf-dev libleveldb-dev libsnappy-dev libopencv-dev libhdf5-serial-dev protobuf-compiler libgflags-dev libgoogle-glog-dev liblmdb-dev
sudo apt install --no-install-recommends libboost-all-dev

這裡我用 OpenBLAS。

sudo apt install libopenblas-dev

接著修改 Makefile.config：

BLAS := open
USE_CUDNN := 1

INCLUDE_DIRS := $(PYTHON_INCLUDE) /usr/local/include /usr/include/hdf5/serial/
LIBRARY_DIRS := $(PYTHON_LIB) /usr/local/lib /usr/lib /usr/lib/x86_64-linux-gnu
WITH_PYTHON_LAYER := 1

並且修改 Makefile，加入 hdf5 相關程式庫：

LIBRARIES += glog gflags protobuf boost_system boost_filesystem m hdf5_serial_hl hdf5_serial

同時在想用的 Python 環境裡安裝必要套件，利用 Caffe 資料夾裡的 python/requirements.txt：

pip install -r requirements.txt

最後就可以編譯了：

make all
make pycaffe

找出 GitHub 上和 Python 3 不相容的 Python 專案

Sat, 10 Sep 2016 19:44:00 +0800

Porting to Python 3

Python 3 已經釋出近八年，原本一片慘紅的 Python 3 Readiness 和 PYTHON 3 WALL OF SUPERPOWERS 都已經接近全綠，真的可以看見社群逐漸朝向 Python 3 的努力。事實上，也開始有些專案漸漸要中止 Python 2 的支援了。

然而其實還是有不少常用的 packages 並不支援 Python 3，像是最近常會用到的 s3cmd 就是一例。到了他們的 Issues 頁面瞧瞧，發現其實很早以前就有想支援 Python 3 的聲音，只是一直沒有人力去做。

其實，雖然要完全支援的話工程有點浩大，但一小步一小步做起來就在可以處理的範圍之內。有些情況甚至用 2to3 就能有很大幫助了。於是忍不住就順手發了一個 pull request，結果很順利就被 merge 了。感覺是很低成本的讓自己感覺對世界有貢獻的方法之一。

找出可以幫忙的 repositories

於是想到，其實說不定 GitHub 上也還存在許多可以發 pull requests 的 repositories，於是就想寫個類似 Python 3 Readiness 的頁面，專門列出有在 GitHub 上但是卻不支援 Python 3 的專案，讓有強迫症的路人可以簡單找出可以去哪貢獻。

就這樣，py3tracker 誕生了。

主要的作法是先用 PyPI API 找出最多人下載的 projects，然後再透過 caniusepython3 檢查哪些不支援 Python 3，最後再偵測該 project 在 GitHub 上是否有公開原始碼。順便抓星星數用來排序。

本來想用 GitHub API 但是一下子就超過一天查詢限制，所以只好強抓網頁了。

最後的網頁樣板則是用 materializecss 快速做成。

希望對有強迫症的路人有所幫助。

bs2 公開板備份初探

Tue, 26 Jul 2016 22:30:00 +0800

前言

bs2.to 就要關閉了，雖然官方有提供個人板備份功能，可是公開板因為著作權問題無法備份，而若要自行轉寄信箱又太過操勞，於是我就想研究一下是否有自動備份的選擇。

經過一番搜尋，似乎有個古老的 bs2-crawler。雖然一開始無法成功跑起來，不過經過修改，似乎真的可以拿來備份 bs2 的看板了。

以下就是修改版本 bs2-crawler@shaform，的使用教學。

安裝

首先 clone 我們修改的版本：

git clone https://github.com/shaform/bs2-crawler

可以用 Python 3 執行，首先使用 pyvenv 創立虛擬環境，好安裝自己的套件：

cd bs2-crawler
pyvenv env

source env/bin/activate

緊接著，安裝所有這次會用到的套件：

pip3 install -r requirements.txt

下載看板資料

一些著名的看板像是書評板或選課板皆可使用，以下我們就用選課板做示範：

python3 crawler.py --board-name NCTU-Teacher

會出現要下載哪些文章的提示：

n - 14520 :

輸入 1 即可下載 1~14520 所有文章。

下載完後會出現在 articles/NCTU-Teacher 的路徑裡。

由於倉促修改，所以還有不少 bug，像是如果有加密文章，有時會無法處理，只好請大大們自行修改了。

價格追蹤：使用 gspread 自動更新 Google Sheets

Sat, 19 Mar 2016 09:02:00 +0800

前言

Google Sheets 和傳統試算表最大的差異或許在於他的資料存放在遠端，所以可以從任何地方存取，也很方便和別人共享編輯。因為這個特性，使得我偶爾會將一些實驗資料放到 Google Sheets 上面。

有的時候這些實驗數據是隨著時間固定產生的，此時如果總是自己剪剪貼貼，難免會覺得有些浪費時間。幸好，Google 提供了 Sheets API，所以我們可以透過程式自動將資料寫進試算表裡。

gspread 將底層的 API 又包裝成更方便好用的界面，是使用 Python 來存取 Google Sheets 很好的選擇。

本文便使用 Python 3 配合 gspread 來展示寫入 Google Sheets 的方法。確切的來說，我將寫一個程式每天去某個網站檢查目前的記憶體價格，然後把每天查到的價格寫入一個試算表裡，藉此追蹤價格變化。

環境設置

首先使用 pyvenv 創立虛擬環境，好安裝自己的套件：

pyvenv-3.5 my_env
source my_env/bin/activate

緊接著，安裝所有這次會用到的套件：

pip install beautifulsoup4 gspread oauth2client pyOpenSSL

申請 API 用帳號

於是就開始參考教學，先申請一個可以用來存取 Google Sheets 的帳號。步驟如下：

先到 Google Developers Console 建立一個 project。
啟動該 project 的 Drive API。
在 Credentials 頁面按下 Create credentials -> Service account key。
取好名字，選擇 JSON 作為 Key type。

下載好 JSON 檔案，把他取名為 auth.json，之後會用到，它大概會長這樣：

{
  "type": "service_account",
  "project_id": "cool-236196",
  "private_key_id": "ab18...24",
  "private_key": "-----BEGIN PRIVATE KEY-----...-----END PRIVATE KEY-----\n",
  "client_email": "name...@....gserviceaccount.com",
  "client_id": "21..6",
  "auth_uri": "https://accounts.google.com/o/oauth2/auth",
  "token_uri": "https://accounts.google.com/o/oauth2/token",
  "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
  "client_x509_cert_url": "https://www.googleapis.com/..."
}

建立試算表

接下來我們到 Google Sheets 建立一個試算表，同時將試算表分享給剛剛的 auth.json 裡 client_email 欄位提到的 email 帳號： name...@....gserviceaccount.com，並給予編輯的權限，這樣子才有辦法透過程式存取。

將試算表多餘的欄位刪除，只剩下 date, item, price 三欄，並留下新的一個空白行，好讓程式插入資料時，也能有白色背景。

最後我們把網址中 https://docs.google.com/spreadsheets/d/{key}/edit 的 {key} 複製到 spreadsheet_key 檔案裡，供之後程式要開啟試算表時存取。

抓取資料

這裡我們透過 BeautifulSoup 從某個價格看板挖出最便宜的記憶體價格當作指標指數。確切的來說，我們先搜尋「記憶體 RAM」關鍵字找出項目清單，然後一個一個搜尋價格，並紀錄最便宜的項目。

# update.py
import re

from urllib.request import urlopen

from bs4 import BeautifulSoup

def get_cheapest(url, text):
    with urlopen(url) as response:
        soup = BeautifulSoup(response.read(), 'lxml')

    cheapest_price = cheapest_item = None

    re_price = re.compile(r'\$(\d+)')
    root = soup.find('td', text=re.compile(text)).parent

    for option in root.find_all('option', text=re_price):
        item = option.text.strip()
        price = int(re_price.search(item).group(1))
        if cheapest_price is None or price < cheapest_price:
            cheapest_price = price
            cheapest_item = item

    return (cheapest_item, cheapest_price)

  coolpc_url = 'http://www.coolpc.com.tw/evaluate.php'
  ram_text = '記憶體 RAM'

  (cheapest_item, cheapest_price) = get_cheapest(coolpc_url, ram_text)

更新 Google Sheets

接下來先撰寫帳號登入的部份，利用 oauth2client 中的 ServiceAccountCredentials 來讀取之前的 auth.json。

import gspread

from oauth2client.service_account import ServiceAccountCredentials

def auth_gss_client(path, scopes):
    credentials = ServiceAccountCredentials.from_json_keyfile_name(path,
                                                                   scopes)
    return gspread.authorize(credentials)

auth_json_path = 'auth.json'
gss_scopes = ['https://spreadsheets.google.com/feeds']

gss_client = auth_gss_client(auth_json_path, gss_scopes)

接下來再用 open_by_key 打開試算表，用 sheet1 存取第一頁，再用 insert_row 插入更新的價格：

# update.py
import time

def update_sheet(gss_client, key, today, item, price):
    wks = gss_client.open_by_key(key)
    sheet = wks.sheet1
    sheet.insert_row([today, item, price], 2)

spreadsheet_key_path = 'spreadsheet_key'

if cheapest_price is not None:
    today = time.strftime("%c")
    with open(spreadsheet_key_path) as f:
        spreadsheet_key = f.read().strip()
    update_sheet(gss_client, spreadsheet_key, today, cheapest_item,
                 cheapest_price)

測試一下，應該可以看到資料被成功插入：

python update.py

設定 crontab

當然，每次都要手動執行程式一點也不自動。所以我們會用 crontab 來自動執行我們的程式。

由於我們使用到了 pyvenv，而且很多檔案路徑都是用相對路徑，因此我另外寫了一個 bash script 來幫忙設定好執行 Python 的步驟。

#!/usr/bin/env bash
# start_update.sh

# get directory of the script
curr_dir=`dirname "$BASH_SOURCE"`

cd $curr_dir ;
source my_env/bin/activate
python update.py

用 chmod +x start_update.sh 打開執行權限，最後執行 crontab -e 並增加下面一行：

@daily {path_to_script_directory}/start_update.sh

如此一來就會每天自動更新了！

參考文件

Scrapy + Python 3: PTT 資料抓取與分析

Sun, 28 Feb 2016 10:23:00 +0800

Scrapy 1.1 with Python 3 Support

很久很久以前，曾經想要學學網路爬蟲，爬一些 PTT 的資料來看看能幹嘛。當時找到了 Scrapy 這個程式庫，覺得很有潛力。只可惜當初他還不太支援 Python 3，於是就暫且放下學習的念頭，想說先等等看。

如今，Scrapy 1.1 釋出，除了一些功能的更新外，他也終於要支援基本的 Python 3 了！於是抱持著推廣 Python 3 的想法，重拾之前的目標，實際測試了一下網路爬蟲的撰寫。

環境設置

由於這次是要爬 PTT 的資料，為了避免一旦被鎖 IP，就會無法上 PTT，很不方便。所以我特地使用了 NTU CS 自己的機器，同時也設定高一點的連線延遲，避免同時產生太多連線。

如果你是用自己的主機而不是用系上工作站，可能還需要安裝額外套件：

sudo apt-get install python3-dev libxml2-dev libxslt1-dev zlib1g-dev libffi-dev libssl-dev

接下來就能使用 pyvenv 創立虛擬環境，好安裝自己的 Python 套件：

pyvenv-3.5 my_env
source my_env/bin/activate

pip install -U pip

緊接著，安裝所有這次會用到的套件：

# 不知為何在工作站上要用 `python /sbin/pip3.5` 來取代下述的 `pip` 才能跑
pip install Scrapy==1.1.0 numpy notebook scipy scikit-learn seaborn jieba

撰寫爬蟲

於是就開始參考教學撰寫我人生中第一個 Scrapy 爬蟲！

首先創立專案：

scrapy startproject ptt

設定連線延遲：

# <root_dir>/ptt/settings.py
DOWNLOAD_DELAY = 1.25

然後定義一些想要抓取的項目，包含本文和推文等等：

# <root_dir>/ptt/items.py
class PostItem(scrapy.Item):
    title = scrapy.Field()
    author = scrapy.Field()
    date = scrapy.Field()
    content = scrapy.Field()
    comments = scrapy.Field()
    score = scrapy.Field()
    url = scrapy.Field()

接著就編輯 <root_dir>/ptt/spiders/ptt.py 實際撰寫爬蟲程式了。

首先測試一下是否真的可以連上 PTT：

import scrapy

class PTTSpider(scrapy.Spider):
    name = 'ptt'
    allowed_domains = ['ptt.cc']
    start_urls = ('https://www.ptt.cc/bbs/Gossiping/index.html', )

    def parse(self, response):
        filename = response.url.split('/')[-2] + '.html'
        with open(filename, 'wb') as f:
            f.write(response.body)

然後在 <root_dir> 根目錄（有 scrapy.cfg 的目錄）執行：

scrapy crawl ptt

完成後應該會發現存下了一個詢問年紀是否已經大到可以觀看八卦版的網頁。為了能夠成功抓取八卦版文章，我們必須要自動回答這個問題才行。雖然也可以直接用 cookies 參數傳入回答紀錄，不過這裡為了盡量模擬人類的行為，所以決定真正的送出表單。（Scrapy 會自動記下送出表單後產生的 cookie。）

自動回答年齡問題

於是我們新增測試，利用 div.over18-notice 的存在來偵測是否進到年齡詢問的頁面。這裡使用到了 XPath 來指定物件的位置。記得當初在微軟寫測試程式時也有用到，現在再碰到一次感覺格外熟悉。

import logging

from scrapy.http import FormRequest

class PTTSpider(scrapy.Spider):
    # ...
    _retries = 0
    MAX_RETRY = 1

    def parse(self, response):
        if len(response.xpath('//div[@class="over18-notice"]')) > 0:
            if self._retries < PTTSpider.MAX_RETRY:
                self._retries += 1
                logging.warning('retry {} times...'.format(self._retries))
                yield FormRequest.from_response(response,
                                                formdata={'yes': 'yes'},
                                                callback=self.parse)
            else:
                logging.warning('you cannot pass')

        else:
          # ...

我們利用 FormRequest 在遇到詢問頁時自動送出表單，然後用 callback 在表單送出成功後重新回到原本的 parse 函式，繼續處理。為了避免表單傳送失敗會不斷嘗試卡住，所以用 MAX_RETRY 稍微限制表單傳送的次數。

自動翻頁，並打開每篇文章

接下來就是實際爬文的程式了，這裡也嘗試使用 CSS Selector，利用 css('.r-ent > div.title > a::attr(href)') 來抓出每個文章的連結。再使用 response.urljoin 把相對路徑轉成絕對路徑。然後把他送給 parse_post 做進一步處理。

class PTTSpider(scrapy.Spider):
    # ...

    _pages = 0
    MAX_PAGES = 2

    def parse(self, response):
        if len(response.xpath('//div[@class="over18-notice"]')) > 0:
            # ...
        else:
            self._pages += 1
            for href in response.css('.r-ent > div.title > a::attr(href)'):
                url = response.urljoin(href.extract())
                yield scrapy.Request(url, callback=self.parse_post)

            if self._pages < PTTSpider.MAX_PAGES:
                next_page = response.xpath(
                    '//div[@id="action-bar-container"]//a[contains(text(), "上頁")]/@href')
                if next_page:
                    url = response.urljoin(next_page[0].extract())
                    logging.warning('follow {}'.format(url))
                    yield scrapy.Request(url, self.parse)
                else:
                    logging.warning('no next page')
            else:
                logging.warning('max pages reached')

最後再用 XPath 找出上一頁的連結，自動翻頁。至於要翻幾頁，則用 MAX_PAGES 控制。

實際抓文

最後就是實際的抓文程式了，除了抓下標題、作者、本文等等，我也抓下每一則推文的作者和分數，以及整篇文章的分數。

import datetime

from ptt.items import PostItem

class PTTSpider(scrapy.Spider):
    # ...
    def parse_post(self, response):
        item = PostItem()
        item['title'] = response.xpath(
            '//meta[@property="og:title"]/@content')[0].extract()
        item['author'] = response.xpath(
            '//div[@class="article-metaline"]/span[text()="作者"]/following-sibling::span[1]/text()')[
                0].extract().split(' ')[0]
        datetime_str = response.xpath(
            '//div[@class="article-metaline"]/span[text()="時間"]/following-sibling::span[1]/text()')[
                0].extract()
        item['date'] = datetime.strptime(datetime_str, '%a %b %d %H:%M:%S %Y')

        item['content'] = response.xpath('//div[@id="main-content"]/text()')[
            0].extract()

        comments = []
        total_score = 0
        for comment in response.xpath('//div[@class="push"]'):
            push_tag = comment.css('span.push-tag::text')[0].extract()
            push_user = comment.css('span.push-userid::text')[0].extract()
            push_content = comment.css('span.push-content::text')[0].extract()

            if '推' in push_tag:
                score = 1
            elif '噓' in push_tag:
                score = -1
            else:
                score = 0

            total_score += score

            comments.append({'user': push_user,
                             'content': push_content,
                             'score': score})

        item['comments'] = comments
        item['score'] = total_score
        item['url'] = response.url

        yield item

最後執行以下指令，就可以把文章存成一個大 JSON 檔案：

scrapy crawl ptt -o gossip.json

在 IPython Notebook 裡做資料分析

爬完文之後就可以分析了，這次我一共爬了 1881 篇八卦版的文章。跟之前一樣是用 IPython Notebook 來進行分析，可以直接在 PTT Analysis @ nbviewer 上閱讀。

因為之前看 CS 109 時發現 Seaborn 畫的圖好像比較漂亮，這次也決定試試。共會用到以下套件：

首先載入所有會用到的套件：

%matplotlib notebook

import json

from collections import defaultdict

import jieba
import matplotlib.pyplot as plt
import numpy as np
import seaborn as sns

from sklearn.feature_extraction import DictVectorizer
from sklearn.feature_extraction.text import TfidfTransformer
from sklearn.svm import LinearSVC

sns.set(style='whitegrid')

然後載入所有文章：

# load ptt posts

path = 'gossip.json'

with open(path) as f:
    posts = json.load(f)

推文分析

我決定先來看看大家都推了多少文，或許可以當作宅度量表之類的。不過為了隱私問題，這裡就不列出實際的 ID 了。先載入每個人的推噓文數目：

# get pushes

total_comments = defaultdict(int)
total_pushes = defaultdict(int)
total_hates = defaultdict(int)

for post in posts:
    for comment in post['comments']:
        user = comment['user']
        total_comments[user] += 1

        if comment['score'] > 0:
            total_pushes[user] += 1

        elif comment['score'] < 0:
            total_hates[user] += 1

然後就可以畫出排名最高一百名的推文者到底推了多少文。

def show_distributions(counts, pushes, hates):
    sorted_cnts = [t[0] for t in sorted(counts.items(), key=lambda x: -x[1])][:100]
    y = [counts[u] for u in sorted_cnts]
    y_pushes = [pushes[u] for u in sorted_cnts]
    y_hates = [hates[u] for u in sorted_cnts]
    x = range(len(y))

    f, ax = plt.subplots(figsize=(10, 6))

    sns.set_color_codes('pastel')
    sns.plt.plot(x, y, label='Total {}'.format('comments'), color='blue')
    sns.plt.plot(x, y_pushes, label='Total {}'.format('pushes'), color='green')
    sns.plt.plot(x, y_hates, label='Total {}'.format('hates'), color='red')

    ax.legend(ncol=2, loc='upper right', frameon=True)
    ax.set(ylabel='counts',
           xlabel='',
           title='Total comments')
    sns.despine(left=True, bottom=True)

    plt.show(f)

# display pushes
show_distributions(total_comments, total_pushes, total_hates)

可以看到，大部分都是推文比較多，不過也有人幾乎都在噓文呢！

每個推文者的推噓文次數

用語分析

接下來我們來看看文章裡出現哪些字比較容易被推或噓，以及網友推噓文時都用什麼用詞吧。

首先利用結巴分詞，把每篇文章的詞收集起來，順便紀錄文章分數：

# grap post
words = []
scores = []

for post in posts:
    d = defaultdict(int)
    content = post['content']
    if post['score'] != 0:
        for l in content.split('\n'):
            if l:
                for w in jieba.cut(l):
                    d[w] += 1
        if len(d) > 0:
            words.append(d)
            scores.append(1 if post['score'] > 0 else 0)

推文們也比照辦理：

# grap comments
c_words = []
c_scores = []

for post in posts:
    for comment in post['comments']:
        l = comment['content'].strip()
        if l and comment['score'] != 0:
            d = defaultdict(int)
            for w in jieba.cut(l):
                d[w] += 1
            if len(d) > 0:
                c_scores.append(1 if comment['score'] > 0 else 0)
                c_words.append(d)

最後用 TfidfTransformer 做出特徵向量，配合 LinearSVC 進行預測訓練：

# convert to vectors
dvec = DictVectorizer()
tfidf = TfidfTransformer()
X = tfidf.fit_transform(dvec.fit_transform(words))

c_dvec = DictVectorizer()
c_tfidf = TfidfTransformer()
c_X = c_tfidf.fit_transform(c_dvec.fit_transform(c_words))

svc = LinearSVC()
svc.fit(X, scores)

c_svc = LinearSVC()
c_svc.fit(c_X, c_scores)

然後就可以畫圖了：

def display_top_features(weights, names, top_n, select=abs):
    top_features = sorted(zip(weights, names), key=lambda x: select(x[0]), reverse=True)[:top_n]
    top_weights = [x[0] for x in top_features]
    top_names = [x[1] for x in top_features]

    fig, ax = plt.subplots(figsize=(10,8))
    ind = np.arange(top_n)
    bars = ax.bar(ind, top_weights, color='blue', edgecolor='black')
    for bar, w in zip(bars, top_weights):
        if w < 0:
            bar.set_facecolor('red')

    width = 0.30
    ax.set_xticks(ind + width)
    ax.set_xticklabels(top_names, rotation=45, fontsize=12, fontdict={'fontname': 'Droid Sans Fallback', 'fontsize':12})

    plt.show(fig)

原本我想同時列出正向和負向詞彙，但後來發現似乎負向詞彙都比較強，所以只好分開列出了。

首先是貼文的負向詞彙，不知為何，如果文中出現「妹妹」似乎就很容易被噓呢！

# top features for posts
display_top_features(svc.coef_[0], dvec.get_feature_names(), 30)

貼文負向詞彙

然後是貼文的正向詞彙，看不出什麼 QQ。

# top positive features for posts
display_top_features(svc.coef_[0], dvec.get_feature_names(), 30, select=lambda x: x)

貼文正向詞彙

推文的正負向詞彙倒是滿有趣，最強的特徵是「紅明顯」和「給推」，哈哈。

# top features for comments
display_top_features(c_svc.coef_[0], c_dvec.get_feature_names(), 30)
# top positive features for comments
display_top_features(c_svc.coef_[0], c_dvec.get_feature_names(), 30, select=lambda x: x)

推文負向詞彙

推文正向詞彙

結語

雖然已經過了那麼多年，Python 3 的使用率還是沒能上升到理想的境界，不過已經是漸入佳境了。希望更多人一起來寫 Python 3。

做完分析感覺 PTT 實在是一個寶庫，尤其各種特殊看板似乎很適合拿來測風向。不知還能做出什麼分析應用呢？

這次實驗所用到的程式碼按照慣例放在 GitHub 上面供參考：https://github.com/shaform/experiments/tree/master/scrapy。

連結

若您喜歡這篇文章，或許你也會對下一篇：〈Scrapy Cloud + Scrapy 網路爬蟲〉感興趣。

Caffe 程式閱讀筆記

Fri, 26 Feb 2016 07:12:00 +0800

前陣子有機會研究了一下 Caffe framework 的程式碼，於是把內容記下來避免忘記。由於自己對該程式庫也不是很熟悉，加上一直拖稿導致 Caffe 在撰寫期間也已經有不少變動，以致可能有許多不正確的地方，還請各位大大不吝指教。

主要分成四個部份來講。首先是整個 Caffe 的大架構，以及一些重要的元件。其次，我也研究了如何自己新增一個 layer。接下來，再重新回到 Caffe 做更深入的解析。

架構

那麼，就從大架構開始講起。 Caffe 的 command line 工具有幾個功能，他可以讓你 train 一個 model，也可以讓你用 train 好的 model 來進行效能的檢驗。當他在做 training 時，他會建立一個 Solver 物件，他的主要功能就是協調類神經網路的運作來進行訓練。

我們可以用一個設定檔來指定 Solver 的參數，像是 learning rate 或者是 Solver 的種類，例如 SGD Solver 等等。在設定檔中，可以指定一個 training net 的參數， testing nets 則有可能有多個。例如如果要用不同的 data set 同時驗證 model 的效能時就可以用到。雖然也可以直接把網路定義寫在 Solver 的設定檔裡，不過範例程式碼通常把他寫在獨立的設定檔中。

Solver 會根據這些設定檔，建立相對應的 training 和 testing 的 Net 物件。而 Net，就會根據整個網路的定義，建立每個 Layer，同時也會建立很多的 Blobs 來放置 Layer 跟 Layer 間的輸出入資料，並把他們都接起來。其中，一個 layer 的輸入被稱為 bottom blobs，輸出則為 top blobs。 Blob 基本上是一個多維陣列，不過他除了用來放 Data 外，也同時包含一組對應的 Diff，可以用來放 Gradient 的計算結果。這些 Blobs 提供了簡易的界面，可以讓 Layer 透過 GPU 或 CPU 來存取裡頭的資料。

而這些 Layers 除了有計算的功能以外，也有一些特別的 data layers 可以把資料從檔案中讀進來，或者把輸出的結果寫到特定的檔案。此外，也有一些 loss layer 是用來計算最後預測結果的分數，並藉此資訊讓 solver 得以最佳化所有的參數。每個 layer 會建立額外的 blobs 來放置這些可訓練的參數，而 Net 在建立 layer 時，會把這些 blobs 也收集起來，方便 Solver 根據 learning rate 來計算每個參數的更新值。當 Solver 呼叫了 Net 的 Forward 和 Backward 之後，資料就會沿著一層一層的 layer 進行計算。

新增 Layer

講完大略的架構後。我們就可以把焦點放在新增 layers 上。

要新增一個 layer，官方其實有提供簡單的指引。但除了單純的看文件之外，我們其實也可以參考看看以前的人是怎麼做的。

沒有錯，理論上應該有不同的人、在不同的時間點。分別新增了不同的 layers。只要找出這些 commits 並且觀察裡頭的內容，應該就可以推測出要如何新增了。

所以，我選了兩個 pull requests: #1940, #303，並且對照他們修改的檔案。

很快的，就可以看出其中的規律。他們都修改了一個叫做 caffe.proto 的檔案，用來定義 layer 可以設定的參數。 HingeLoss 的修改還改動了 layer factory，不過看起來是因為以前在新增 layer 時，要修改一個選擇 layer 的函數。現在的 layer 都被放進一個 dictionary 裡，透過名稱取出，所以就不需要這種修改了。只有一些有 cuDNN 實作的 layers 會在這裡放一個特別的函數來選擇實作的引擎。

接下來 src/caffe/layers/*, include/caffe/* 等檔案，則是 layer 實際的宣告以及實作。以前 layer 的宣告依照分類被放置在不同的地方。比如說 neuron_layers.hpp 通常是放進行 element-wise operations 的 layers。 vision_layers.hpp 則是放跟影像比較相關的 layers。不過後來不同的 layers 就被搬到獨立的檔案了。

最後 src/caffe/test/* 則是一些測試。

於是我就實際的修改看看，我要加入一個很簡單的 layer，他會把所有的輸入乘上一個事先指定的參數。我在 caffe.proto 修改了三個地方，包含下個可用的 ID、放置參數的變數，和實際的 layer 參數，也就是要乘上的那個常數。

// src/caffe/proto/caffe.proto
// LayerParameter next available layer-specific ID: 144 (last added: zzz_param)
message LayerParameter {
  // ...
  optional ZZZParameter zzz_param = 143;
}
 
// Message that stores parameters used by ZZZLayer
message ZZZParameter {
  // Whether or not slope paramters are shared across channels.
  optional int32 mul = 1 [default = 2];
}

然後，我複製了一些簡單的宣告。其中主要的修改只有新增了一個 mul 參數，用來存放要乘的常數。

// include/caffe/layers/zzz_layer.hpp
template <typename Dtype>
class ZZZLayer : public NeuronLayer<Dtype> {
 public:
  explicit ZZZLayer(const LayerParameter& param)
      : NeuronLayer<Dtype>(param) {}
  virtual void LayerSetUp(const vector<Blob<Dtype>*>& bottom,
      const vector<Blob<Dtype>*>& top);

  virtual inline const char* type() const { return "ZZZ"; }

 protected:
  virtual void Forward_cpu(const vector<Blob<Dtype>*>& bottom,
      const vector<Blob<Dtype>*>& top);
  virtual void Forward_gpu(const vector<Blob<Dtype>*>& bottom,
      const vector<Blob<Dtype>*>& top);

  virtual void Backward_cpu(const vector<Blob<Dtype>*>& top,
      const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom);
  virtual void Backward_gpu(const vector<Blob<Dtype>*>& top,
      const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom);
  Dtype mul_;
};

實作的部份因為初始化很簡單，只有讀取將來要乘的常數，所以主要的實作只有 Forward 和 Backward。不過一些複雜的 layers 可能就會需要實作一些複雜的初始化，和計算輸出維度大小的函數。 Neuron layer 因為是 element-wise ，所以輸出的維度大小就跟輸入一樣。

Forward的部份，是先把 bottom_data 複製到 top，然後再將整個 top scale 指定的常數。

// src/caffe/layers/zzz_layer.cpp
template <typename Dtype>
void ZZZLayer<Dtype>::Forward_cpu(const vector<Blob<Dtype> *> &bottom,
                                     const vector<Blob<Dtype> *> &top) {
  const int count = bottom[0]->count();
  const Dtype* bottom_data = bottom[0]->cpu_data();
  Dtype* top_data = top[0]->mutable_cpu_data();
  caffe_copy(count, bottom_data, top_data);
  if (mul_ != Dtype(1)) {
    caffe_scal(count, mul_, top_data);
  }
}

Backward 也很類似，確定需要計算後，先把 top_diff 複製到 bottom_diff 再 scale 指定的常數。

// src/caffe/layers/zzz_layer.cpp
template <typename Dtype>
void ZZZLayer<Dtype>::Backward_cpu(const vector<Blob<Dtype> *> &top,
                                      const vector<bool> &propagate_down,
                                      const vector<Blob<Dtype> *> &bottom) {
  if (propagate_down[0]) {
    const int count = top[0]->count();
    const Dtype *top_diff = top[0]->cpu_diff();
    Dtype *bottom_diff = bottom[0]->mutable_cpu_diff();
    caffe_copy(count, top_diff, bottom_diff);
    caffe_scal(count, mul_, bottom_diff);
  }
}

CUDA 的版本也很類似，只是從 blob 要取出 gpu data ，然後 scale 時要選 GPU 的版本。

// src/caffe/layers/zzz_layer.cu
template <typename Dtype>
void ZZZLayer<Dtype>::Forward_gpu(
    const vector<Blob<Dtype>*>& bottom, const vector<Blob<Dtype>*>& top) {
  const int count = bottom[0]->count();
  const Dtype* bottom_data = bottom[0]->gpu_data();
  Dtype* top_data = top[0]->mutable_gpu_data();
  caffe_copy(count, bottom_data, top_data);
  if (mul_ != Dtype(1)) {
    caffe_gpu_scal(count, mul_, top_data);
  }
}

template <typename Dtype>
void ZZZLayer<Dtype>::Backward_gpu(const vector<Blob<Dtype>*>& top,
    const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom) {
  if (propagate_down[0]) {
    const int count = top[0]->count();
    const Dtype *top_diff = top[0]->gpu_diff();
    Dtype *bottom_diff = bottom[0]->mutable_gpu_diff();
    caffe_copy(count, top_diff, bottom_diff);
    caffe_gpu_scal(count, mul_, bottom_diff);
  }
}

最後我們再加一些 test，檢查 forward 確實成功乘上參數。

// src/caffe/test/test_zzz_layer.cpp
TYPED_TEST(NeuronLayerTest, TestZZZForward) {
  typedef typename TypeParam::Dtype Dtype;
  LayerParameter layer_param;
  ZZZLayer<Dtype> layer(layer_param);
  layer.SetUp(this->blob_bottom_vec_, this->blob_top_vec_);
  layer.Forward(this->blob_bottom_vec_, this->blob_top_vec_);
  const Dtype* bottom_data = this->blob_bottom_->cpu_data();
  const Dtype* top_data    = this->blob_top_->cpu_data();
  const int count = this->blob_bottom_->count();
  const int mul = layer_param.zzz_param().mul();
  for (int i = 0; i < count; ++i) {
    EXPECT_FLOAT_EQ(top_data[i], bottom_data[i]*mul);
  }
}

同時也檢查用數值方法計算出來的 gradient 跟我們算的是否一樣。

// src/caffe/test/test_zzz_layer.cpp
TYPED_TEST(NeuronLayerTest, TestZZZBackward) {
  typedef typename TypeParam::Dtype Dtype;
  LayerParameter layer_param;
  ZZZLayer<Dtype> layer(layer_param);
  GradientChecker<Dtype> checker(1e-2, 1e-3, 1701, 0., 0.01);
  checker.CheckGradientEltwise(&layer, this->blob_bottom_vec_,
      this->blob_top_vec_);
}

最後就可以實際測試看看。並看到測試的結果了。以上就是新增 layer 的部份。

[----------] 2 tests from ZZZLayerTest/1, where TypeParam = caffe::CPUDevice<double>
[ RUN      ] ZZZLayerTest/1.TestZZZBackward
[       OK ] ZZZLayerTest/1.TestZZZBackward (2 ms)
[ RUN      ] ZZZLayerTest/1.TestZZZForward
[       OK ] ZZZLayerTest/1.TestZZZForward (0 ms)
[----------] 2 tests from ZZZLayerTest/1 (2 ms total)

Dive into Caffe

好，講完新增 layer 之後，這次可以更深入的研究 Caffe 的內部架構。

一開始我先到網路上搜尋了一下教學文件，包含官方的內容、課程的教學、或者是網友在問要怎麼讀 Caffe，以及各種網友的分享。最後再直接開始讀程式碼。

剛剛已經講過 Caffe 的大致架構，不過實際上每個部件是怎麼互動的呢？我們先從程式流程講起，之後再特別介紹 layers 的功能。

Training

以 training 的部份來說，程式實際上做的事大致如下：首先，載入參數，設定 GPU 等初始化。接著，利用這些參數初始化一個 Solver 物件。接下來，如果是要載入 train 好的 weights 來 fine-tune 的話，就會直接把這些 weights 讀進 solver 裡頭的 Net 物件裡。如果是要繼續進行到一半的 training 的話，則會把 snapshot 檔案當作參數傳給 Solver 的 solve。否則就直接呼叫 Solve 開始 training 了。

而根據 Solver 種類的不同，會初始化一些不同的參數。但他們都會根據設定檔建立 training nets 以及 testing nets 等物件。

Initialize Net

每個 Net 被建立時會經過下列流程：

首先根據一些條件過濾掉參數中指定的 layers，比如說你可以把 testing 和 training 的 net 寫在一起，然後 input layer 分成兩個，一個只有在 training 時才有效，另一個則在 testing 才有效，這樣在建立 Net 物件時依據不同階段，就會過濾掉不要的 input layer，達成載入不同的 data set 的目的。

接下來則是在參數中插入 split layers。也就是在一些 output blob 被接到多個 layer 作為 input 的時候，在中間多加入一個 split layer ,把 blob 複製成多份作為其他層的輸入。

這麼做大概有兩個目的，首先是收集從多個方向計算的 gradient ，其次則是因為有些 layer 會做 in-place 的計算，也就是他 input 和 output 使用同一個 blob，所以在這裡把 blob 分成多個，可以避免這種情形下的計算錯誤。

把 net 的參數經過之前的處理後，就會實際初始化 Net 物件。首先是建好網路最底層 input blobs。再來則是按照順序一層一層的建立，並初始化每個 layers。

實際的流程是先建立 layer 物件後，先從之前的底層 input blobs 或者其他 layer 的 top blobs 中找到該 layer 的 bottom blob，也就是他的 input，然後呢，再視情況建立他的 top blob，也就是 output。

最後再用這些 input / output blobs 作為參數，完成 layer 的初始化。每個不同的 layer 會根據自己的需要分別實作不同的初始化程式。然後 net 再把該 layer 可以訓練的參數紀錄下來。

像這樣一層一層的初始化每個 layer 時，同時也找出哪些 layer 實際上需要 backward 的計算。這樣訓練時就可以節省不必要的計算。最後則是收集最後剩下來的 output blobs ，當作整個類神經網路的 output。同時也收集所有設定的 learning rate 和 weight decay。

像這樣初始化完畢後，就進到真正的 trainning 了。

Solver->Solve()

在 training 時所作的，其實就是先做一次 forward 和 backward 的計算，再更新網路中的 weight，重複循環。計算 forward 的方法就是按照 layer 的順序，呼叫每個 layer 的 forward 函數。而 backward 就是用相反的順序呼叫每個 layer 的 backward 函數。每計算完一次就會得到更新的 gradients，然後就可以更新參數。

詳細流程是這樣的，收集完這些 gradients 後 Solver 會依照 learning rates 和 weight decay 算出每個參數應該更新的實際數字。然後再把有共用參數的 layer 的更新值加在一起，最後再一次更新所有的數值。

Testing

testing 時跟 training 也很類似，不過這次不需要建立 Solver ，而是直接建立 test net，並且讀取訓練好的 weight，最後執行 forward，就可以得到最後的輸出值了。

Layers 簡介

整個程式其實最重要的計算還是在 Layers 的部份。因此，我現在就來簡單介紹到底有哪些 layers 可供使用。

Data Layers

DataLayer: 可以載入 leveldb 和 lmdb 的檔案。
DummyDataLayer: 用來產生一些亂數或其他預先定義的資料。
HDF5DataLayer: 可以讀取 HDF5 的檔案格式。
HDF5OutputLayer: 可以寫入 HDF5 的檔案格式。
ImageDataLayer: 直接載入圖片。
MemoryDataLayer: 可以透過程式，直接將記憶體中的資料放進 layer 中。
WindowDataLayer: 可以指定從一些圖片中擷取一些 windows 來當作輸入，比如說同一張圖裡幾個 windows 可能標記成貓。其他地方則有狗和沒有東西的標記。

Common Layers

在 common layers 的分類中則有：

ArgMaxLayer: 找出輸入中最大的 k 個值的 indices 或者 value。
ConcatLayer: 連接多個 bottom blobs。
EltwiseLayer: 他可以把多個 blobs 彼此 element-wise 進行加總，相乘，取最大等運算。
FlattenLayer: 把輸入的 blob 變成單維陣列。
InnerProductLayer: 其實就是輸出入全部接滿的 layers。
MVNLayer: 指的是 mean variance normalization，可以針對輸入做整體的 normalization。
SilenceLayer: 有點像垃圾桶，沒有輸出，只有輸入，被接到這裡的東西就會被丟掉，不會成為最後的輸出。
SplitLayer: 把輸出複製成多份。
SliceLayer: 把輸入切割成多分輸出。
SoftmaxLayer: 把一組輸出，轉換成機率輸出，也就是讓他們的和 normalize 成 1。

Neuron Layers

neuron layers 主要是直接對每個元素運算。

AbsValLayer: 取絕對值。
DropoutLayer: 隨機丟掉某些 input。
ExpLayer
PowerLayer
TanHLayer
ThresholdLayer: 若輸入大於門檻則為 1，否則為0。
BNLLLayer: 將輸入轉換成 binomial normal log likelihood。
ReLULayerReLu: 則是強制輸出不能小於零。
PReLULayerPReLU: 則多加了一個可以訓練的參數。接在後面。
SigmoidLayer: Sigmoid 可以把輸出限制在 0~1 之間，不過現在大家好像比較常用 ReLU 就是。

Vision Layers

再來是 visions layers，其實這些 layers 都跟 CNN 有關。

ConvolutionLayer: convolution 做的運算基本上是用數個 filter，或者說 feature detector，在原始輸入的局部小範圍中，進行一個內積運算，得到一個結果。平移這個小範圍做同樣的運算後，每個 filter 都可以得到一個個數比輸入稍微少一些的輸出。一般每個 feature detector 是用來偵測圖片中某些特定的特徵是否出現。
DeconvolutionLayer: 反過來，把一個輸入乘上一個矩陣。比如說右邊的 4 ，乘上一個 3x3 的矩陣，然後把他加回去左邊的輸出。
LRNLayer: LRN 則是一種 normalization 的方法，據論文上寫的，他似乎主要是用來 normalize 不同 filter 輸出的結果，讓訊號間彼此競爭，只留下一些勝利者。
PoolingLayer: 至於最後的 pooling ，則是選一塊輸入的範圍，進行取最大值或者平均的運算。得出個數較少的輸出。

結語

感覺光是對一些運算做操作性的了解，似乎還是不能真正理解 Caffe 是如何被使用的。未來應該要針對深度學習的理論上做更多研究才行。

IPython Notebook 初探

Sat, 26 Dec 2015 18:46:00 +0800

為什麼是 IPython Notebook?

還記得第一次認識到 IPython Notebook 是在 Taipei.py 吧。當時我還十分懷疑到底使用瀏覽器界面寫 Python 能有什麼好處。尤其，這樣根本無法使用 Vim 的強大指令。雖然有安裝並嘗試了一下，但最後還是沒有繼續使用 IPython Notebook。不過 IPython interactive shell 倒確實是比原本的指令列好用許多，於是我慢慢也開始用它來取代原本的 Python 指令列了。

第二次遇到 IPython Notebook 則是在寫 CS231n 作業時。在那堂課裡，每份作業都是用 IPython Notebook 來呈現。同學可以在 Notebook 上及其他 Python 檔案裡編輯，並在 Notebook 裡直接驗證結果。我這才發現這真的是一個跟別人分享與教學的強大方法。尤其又有 nbviewer 可以用，簡直太方便了。甚至不用安裝 Python 就能看到別人之前執行 Python 的結果。

後來對使用 Python 處理資料更有經驗後，更是體會到為何科學社群的人很喜歡 IPython Notebook 可能的原因了。其中一個重要原因一定是因為它可以極其方便的紀錄實驗步驟吧。

最近在資料科學領域學習，最讓我感覺震驚的不是技術，反而是 science != engineering 的感覺，跟寫 code 做產品完全不一樣的思維和工作模式。打開 ipython 或 rstudio 就像打開實驗記錄簿，不斷假設、驗證、預測。這跟做軟體工程，差別真的蠻大的。
— i͛ho͌ͯͦ̉͑we̍̃̏ͣr̆̽̓ (@ihower) August 31, 2015

像是在做資料分析時，除了要管理程式碼以外，管理資料常常是更複雜的問題。像是在做資料前處理或是特徵擷取時，經常會把資料做不同的轉換。有時候會因為覺得某些轉換只會做一次，就沒有把轉換的步驟記錄下來。但是如果未來想要更改某個轉換步驟，而要重跑實驗時，這種作法就會造成極大的麻煩。

另一方面，若是直接寫一個大程式，每次都從資料源頭進行各種轉換與分析。則撰寫程式的時間會拉長，且如果資料量太大，也會使得每次執行程式都跑的太久。

這時就是 IPython Notebook 方便的地方了。它真的就是一個筆記本，讓你紀錄實驗過程。本篇文章就是想好好分享一下 IPython Notebook，希望不要像我一樣錯過它了。為了當作練習，本篇文章的程式碼也同樣用 IPython Notebook 呈現，可以在 The First Tour of the IPython Notebook 直接閱讀。

在 IPython 裡做資料分析

於是就讓我們開始吧。我們將會用到以下程式庫：

其中，matplotlib 是一個非常實用的圖表工具。想當初也是朋友來問問題才發現它的存在。想不到現在竟然也開始學習了。由於 IPython Notebook 可以直接顯示並存下它產生的圖，所以非常方便。

不過首先，要使用 %matplotlib inline magic command 設定讓圖表直接顯示在筆記本上：

%matplotlib inline

找出最重要的特徵

通常要對模型有一些理解，找出權重最大的特徵可以有些幫助。所以我們用 polarity dataset 來示範這個概念：

wget http://www.cs.cornell.edu/people/pabo/movie-review-data/review_polarity.tar.gz
tar xzf review_polarity.tar.gz

然後，載入必要的套件：

import numpy as np
import matplotlib.pyplot as plt

from sklearn.datasets import load_files
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.svm import LinearSVC

我們用 TfidfVectorizer 來得到每個句子的特徵向量：

sent_data = load_files('txt_sentoken')

tfidf_vec = TfidfVectorizer()

sent_X = tfidf_vec.fit_transform(sent_data.data)
sent_y = sent_data.target

最後再用 LinearSVC 訓練正負向的分類器：

lsvc = LinearSVC()
lsvc.fit(sent_X, sent_y)

接下來就可以找出權重最重的特徵了：

def display_top_features(weights, names, top_n):
    top_features = sorted(zip(weights, names), key=lambda x: abs(x[0]), reverse=True)[:top_n]
    top_weights = [x[0] for x in top_features]
    top_names = [x[1] for x in top_features]

    fig, ax = plt.subplots(figsize=(16,8))
    ind = np.arange(top_n)
    bars = ax.bar(ind, top_weights, color='blue', edgecolor='black')
    for bar, w in zip(bars, top_weights):
        if w < 0:
            bar.set_facecolor('red')

    width = 0.30
    ax.set_xticks(ind + width)
    ax.set_xticklabels(top_names, rotation=45, fontsize=12)

    plt.show(fig)

display_top_features(lsvc.coef_[0], tfidf_vec.get_feature_names(), 20)

記得也曾在學長的論文上看過文字雲的呈現方式：

from wordcloud import WordCloud

def generate_word_cloud(weights, names):
    return WordCloud(width=350, height=250).generate_from_frequencies(zip(names, weights))

def display_word_cloud(weights, names):
    fig, ax = plt.subplots(1, 2, figsize=(28, 10))

    pos_weights = weights[weights > 0]
    pos_names = np.array(names)[weights > 0]

    neg_weights = np.abs(weights[weights < 0])
    neg_names = np.array(names)[weights < 0]

    lst = [('Positive', pos_weights, pos_names), ('Negative', neg_weights, neg_names)]

    for i, (label, weights, names) in enumerate(lst):
        wc = generate_word_cloud(weights, names)
        ax[i].imshow(wc)
        ax[i].set_axis_off()
        ax[i].set_title('{} words'.format(label), fontsize=24)

    plt.show(fig)

display_word_cloud(lsvc.coef_[0], tfidf_vec.get_feature_names())

用降維來做資料視覺化

通常太高維度的資料對我們來說不太易懂。所以也常使用降維的方式來做資料視覺化。這裡我們會用 t-SNE 來視覺化 Iris flower data set。同時，我們也用 MPLD3 來建立可以動態縮放的圖表。

from sklearn.datasets import load_iris
from sklearn.manifold import TSNE
import mpld3

iris = load_iris()

def display_iris(data):
    X_tsne = TSNE(n_components=2, perplexity=20, learning_rate=50).fit_transform(data.data)

    fig, ax = plt.subplots(1, 2, figsize=(10, 5))
    ax[0].scatter(X_tsne[:, 0], X_tsne[:, 1])
    ax[0].set_title('All instances', fontsize=14)
    ax[1].scatter(X_tsne[:, 0], X_tsne[:, 1], c=data.target)
    ax[1].set_title('All instances labeled with color', fontsize=14)

    return mpld3.display(fig)

display_iris(iris)

可以看到，即使不知道資料的標記，t-SNE 還是能把不同種類的資料點分開的很好。我們再試試 MNIST dataset of handwritten digits 這個複雜一點的資料集。同時也嘗試使用 PointLabelTooltip，好讓滑鼠移過時能顯示每個資料點的數字。

from sklearn.datasets import fetch_mldata
from sklearn.decomposition import PCA

mnist = fetch_mldata('MNIST original')

def display_mnist(data, n_samples):
    X, y = data.data / 255.0, data.target

    # downsample as the scikit-learn implementation of t-SNE is unable to handle too much data
    indices = np.arange(X.shape[0])
    np.random.shuffle(indices)
    X_train, y_train = X[indices[:n_samples]], y[indices[:n_samples]]


    X_tsne = TSNE(n_components=2, perplexity=30).fit_transform(X_train)
    X_pca = PCA(n_components=2).fit_transform(X_train)

    fig, ax = plt.subplots(1, 2, figsize=(12, 6))


    points = ax[0].scatter(X_tsne[:,0], X_tsne[:,1], c=y_train)
    tooltip = mpld3.plugins.PointLabelTooltip(points, labels=y_train.tolist())
    mpld3.plugins.connect(fig, tooltip)
    ax[0].set_title('t-SNE')

    points = ax[1].scatter(X_pca[:,0], X_pca[:,1], c=y_train)
    tooltip = mpld3.plugins.PointLabelTooltip(points, labels=y_train.tolist())
    mpld3.plugins.connect(fig, tooltip)
    ax[1].set_title('PCA')


    return mpld3.display(fig)

display_mnist(mnist, 1000)

如果你想在有訓練資料的標記的情況下盡可能學到較好的投影向量的話，也可以試試 LDA。

from mpl_toolkits.mplot3d import Axes3D
from sklearn.lda import LDA

def display_mnist_3d(data, n_samples):
    X, y = data.data / 255.0, data.target

    # downsample as the scikit-learn implementation of t-SNE is unable to handle too much data
    indices = np.arange(X.shape[0])
    np.random.shuffle(indices)
    X_train, y_train = X[indices[:n_samples]], y[indices[:n_samples]]

    X_lda = LDA(n_components=3).fit_transform(X_train, y_train)


    fig, ax = plt.subplots(figsize=(10,10), subplot_kw={'projection':'3d'})

    points = ax.scatter(X_lda[:,0], X_lda[:,1], X_lda[:,2] , c=y_train)
    ax.set_title('LDA')
    ax.set_xlim((-6, 6))
    ax.set_ylim((-6, 6))


    plt.show(fig)

display_mnist_3d(mnist, 1000)

使用 Pandas 分析資料

Pandas 用來分析資料聽說也是非常方便。我們就用 Meta Kaggle 來看看 Kaggle 上的使用者都在做什麼吧。

import pandas as pd
import sqlite3

手動下載完資料並解壓縮後應該會看到一個 output 資料夾存放所有的檔案：

con = sqlite3.connect('output/database.sqlite')
kaggle_df = pd.read_sql_query('''
SELECT * FROM Submissions''', con)

先看看裡頭有什麼內容：

kaggle_df.head()

然後來試著分析上傳結果的時間分佈，先取得上傳時間在一週裡的日期或小時：

print('There is {} submissions'.format(kaggle_df.shape[0]))

# convert time strings to DatetimeIndex
kaggle_df['timestamp'] = pd.to_datetime(kaggle_df['DateSubmitted'])

print('The earliest and latest submissions are on {} and {}'.format(kaggle_df['timestamp'].min(), kaggle_df['timestamp'].max()))

kaggle_df['weekday'] = kaggle_df['timestamp'].dt.weekday
kaggle_df['weekhr'] = kaggle_df['weekday'] * 24 + kaggle_df['timestamp'].dt.hour

import calendar

def display_kaggle(df):
    fig, ax = plt.subplots(1, 2, figsize=(16, 8))

    ax[0].set_title('submissions per weekday')
    df['weekday'].value_counts().sort_index().rename_axis(lambda x: calendar.day_name[x]).plot.bar(ax=ax[0])

    ax[1].set_title('submissions per hour of week')
    ax[1].set_xticks(np.linspace(0, 24*7, 8))
    df['weekhr'].value_counts().sort_index().plot(color='red', ax=ax[1])
    plt.show(fig)

display_kaggle(kaggle_df)

然後我們試著把使用者分群，看看他們上傳時間的分佈是否有所不同。

from collections import defaultdict
from sklearn.cluster import KMeans

def display_hr(df, n_clusters):
    hrs_per_user = df[['SubmittedUserId', 'weekhr', 'Id']].groupby(['SubmittedUserId', 'weekhr']).count()
    total_per_user = hrs_per_user.sum(axis=0, level=0)
    user_patterns = (hrs_per_user / total_per_user)['Id']

    vectors = defaultdict(lambda: np.zeros(24*7))
    for (u, hr), r in user_patterns.items():
        vectors[u][hr] = r
    X_hr = np.array(list(vectors.values()))

    y = KMeans(n_clusters=n_clusters, random_state=3).fit_predict(X_hr)

    for i in range(n_clusters):
        fig, ax = plt.subplots(figsize=(6, 6))
        indices = y == i
        X = X_hr[indices]
        ax.plot(np.arange(24*7), X.mean(axis=0))
        ax.set_xticks(np.linspace(0, 24*7, 8))
        ax.set_xlim((0, 24*7))
        ax.set_title('Cluster #{}, n = {}'.format(i, len(X)), fontsize=14)
        plt.show(fig)

display_hr(kaggle_df, 9)

這裡我們只展示兩張圖，看起來第 1 群和第 8 群使用者似乎活動時間有點差別，不知是否是時區不同的關係呢？

XKCD

最後我們用 XKCD 風格來畫張圖吧。為了能畫這張圖，我們得先安裝 Humor Sans 並且清除 matplotlib 的字型 cache。他的路徑可用以下指令找到：

import matplotlib
matplotlib.get_cachedir()

同時如果是 Python 3 的話，可能還需安裝額外的套件：

sudo apt-get install libffi-dev
pip3 install cairocffi

安裝完就可以開始畫了：

def xkcd():
    with plt.xkcd():
        fig, ax = plt.subplots()
        ax.spines['right'].set_color('none')
        ax.spines['top'].set_color('none')
        ax.set_xticks([])
        ax.set_yticks([])
        ax.set_ylim([-1, 10])

        data = np.zeros(100)
        data[:60] += np.linspace(-1, 0, 60)
        data[60:75] += np.arange(15)
        data[75:] -= np.ones(25)


        ax.annotate(
            'DEADLINE',
            xy=(71, 7), arrowprops=dict(arrowstyle='->'), xytext=(30, 2))

        ax.plot(data)
        ax.plot([72, 72], [-1, 15], 'k-', color='red')


        ax.set_xlabel('time')
        ax.set_ylabel('productivity')
        ax.set_title('productivity under a deadline')

        plt.show(fig)
xkcd()

結語

感覺還有好多需要學習的，目前也才剛剛起步。不過希望這篇文章有吸引到你想嘗試看看 IPython Notebook。最近也聽說 CS109 Data Science 似乎是個不錯的課程，如果想繼續練習或許可以試試看 0.0/

參考資料

用 Apache Spark 來訓練 Word2vec 詞向量 Skip-gram Word Embeddings

Sun, 30 Aug 2015 17:15:00 +0800

先前曾提過 word2vec 可以把語料中的詞轉換成詞向量。雖然原本提供的 word2vec 工具速度已經很快，但是如果要訓練更大規模的語料還是需要不少時間。例如之前在處理 ClueWeb09 時，以實驗室的機器來說，就算只處理中文部份，也要一個月以上才能跑完。此時除了購買更強大的機器外，如果已經有不少機器，或許可以利用平行運算的方式來加速。

最近剛好接觸到了 Apache Spark，他是一個開源的運算平台，可以運用多台電腦進行平行運算。且因為把很多資料直接放在記憶體中處理，又比 Apache Hadoop 單純的 MapReduce 更快一些。更重要的是，他的機器學習函式庫 MLlib 已經實作了 word2vec 當中的 skip-gram 模型，正好可以直接拿來訓練詞向量。

安裝

關於如何將 Spark 安裝在一個 cluster 上，可以參考官方文件。這裡我們只簡單的安裝單機版的 Spark 方便快速的實驗。我們將會使用 Ubuntu 14.04 作為實驗平台。

安裝 Java 8

首先安裝 Java 8，如果你已經有裝了則可以跳過。

sudo add-apt-repository ppa:webupd8team/java
sudo apt-get update
sudo apt-get install oracle-java8-installer
sudo apt-get install oracle-java8-set-default

安裝 Apache Spark

接下來，到下載頁面下載 Spark，我是選擇 Spark 1.4.1 Pre-built for Hadoop 2.6 and later 的 binary。不過如果有新版應該變化也不大。直接解壓縮就可以用囉：

tar -xzf spark-1.4.1-bin-hadoop2.6.tgz

安裝 sbt

因為我打算用 Scala 所以我們還得安裝 sbt 這個 build tool。於是依照 sbt 的下載頁面的說明安裝 sbt：

echo "deb https://dl.bintray.com/sbt/debian /" | sudo tee -a /etc/apt/sources.list.d/sbt.list
sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv 642AC823
sudo apt-get update
sudo apt-get install sbt

下載資料集

為了簡單起見，使用 100MB 的 Wikipedia dump：

wget http://mattmahoney.net/dc/text8.zip -O text8.gz
gzip -d text8.gz -f

由於是單機，所以可以放在任意資料夾，如果是在 cluster 的話，需要放在每台機器都能存取的同一位置。

編寫 Spark 程式

首先建立專案資料夾：

mkdir -p sparkw2v/src/main/scala/

然後編輯 sparkw2v/sparkw2v.sbt 檔案，程式版本參考官方文件：

name := "Spark Word2Vec"

version := "1.0"

scalaVersion := "2.10.4"

libraryDependencies ++= Seq(
    "org.apache.spark" %% "spark-core" % "1.4.1" % "provided",
    "org.apache.spark" %% "spark-mllib" % "1.4.1"
)

最後則是程式碼 sparkw2v/src/main/scala/SparkW2V.scala 本身，注意要設定輸出入 {input directory} 和 {output directory}的路徑。同樣的如果是在 cluster 的話，需要放在每台機器都能存取的同一位置。 Word2Vec 參數設定則可參考 API 文件。

import org.apache.spark._
import org.apache.spark.rdd._
import org.apache.spark.SparkContext
import org.apache.spark.SparkContext._
import org.apache.spark.SparkConf

import org.apache.spark.mllib.feature.Word2Vec

object SparkW2V {
  def main(args: Array[String]) {
    val text8 = "{input directory}/text8"
    val output = "{output directory}/model"
    val conf = new SparkConf().setAppName("Spark Word2Vec")
    val sc = new SparkContext(conf)

    val input = sc.textFile(text8).map(line => line.split(" ").toSeq)
    val word2vec = new Word2Vec()

    val model = word2vec.fit(input)
    model.save(sc, output)
  }
}

Build

使用 sbt 進行 package：

cd sparkw2v
sbt package

根據版本不同，產生的檔案名稱也不同，我的輸出是 sparkw2v/target/scala-2.10/spark-word2vec_2.10-1.0.jar。

執行

接下來就可以回到根目錄，利用 spark-submit 執行程式。筆者不確定記憶體的需求為何，所以開的大了些：

cd ..
spark-1.4.1-bin-hadoop2.6/bin/spark-submit --class SparkW2V --master local[*] --executor-memory 20G --driver-memory 10G sparkw2v/target/scala-2.10/spark-word2vec_2.10-1.0.jar

輸出的向量會放在 {output directory}/model/data/ 底下，而且是存成 Parquet 的格式，不太方便。所以我們使用 spark-shell 快速的將檔案轉成文字檔：

# 執行 Spark Shell
./spark-1.4.1-bin-hadoop2.6/bin/spark-shell

# 從這裡開始是 Spark Shell
#
# Welcome to
#       ____              __
#      / __/__  ___ _____/ /__
#     _\ \/ _ \/ _ `/ __/  '_/
#    /___/ .__/\_,_/_/ /_/\_\   version 1.4.1
#       /_/
#

# 讀取檔案
scala> val d = sqlContext.read.parquet("{output directory}/model/data")
d: org.apache.spark.sql.DataFrame = [word: string, vector: array<float>]

# 檢查格式
scala> d.first
res2: org.apache.spark.sql.Row = [latifolia,ArrayBuffer(-0.08103186, 0.14688604, -0.060668133, -0.25648367, -0.06855837, -0...

# 輸出到 output directory/vectors/
scala> d.map{r => r.getString(0) + " " + r.getSeq(1).mkString(" ")}.saveAsTextFile("{output directory}/vectors")

如此便完成了！

原始碼

相關程式碼放在 shaform/experiments/spark_word2vec。

一起聚餐去，金流系統

Mon, 20 Apr 2015 08:34:00 +0800

在交大時因為地處偏僻又經濟拮据，很少有機會出去校外吃飯。來了台北以後，開始有機會和朋友出去聚餐。有次一大群人一起去吃飯，結帳時大家七手八腳的把錢擺在桌上，最後結帳的人拿了錢去付時，才發現短少了一些，但也無法釐清是誰少付了。自己也曾有次雖然只是三四人的聚餐，不過付完找錢完事後才發現虧了兩三百元呢。

確實這種朋友聚餐若不能分開結帳，付起帳來總讓人心慌慌。有許多的風險容易浮現：（1）在蒐集錢時可能有所短缺（2）可能會出現偽鈔（3）其實也可能店家會找錯、算錯（4）然而有些同學會在店家找錢時迅速的先拿走自己該找的部份，以致主付者難以確認店家是否找錯錢。

雖然想說可以透過每次聚餐前都事先準備好所有零錢，讓自己可以恰好付出自己的部份，不過有時還是會忘記。這時就會想如果有個金流系統可以幫忙解決這種情形該有多好。

運作的方法大約是這樣。聚餐後，可以用這金流系統建立一個聚餐事件，然後把所有人加進來。大家輸入自己該付的錢後，系統就會確認儲值的錢足夠，並自動扣款，事後交給主事人。程式還會幫妳計算總和的錢數，讓你可以較易跟店家確認他是否算錯錢。

可以用手機拍照紀錄菜單，這樣如果跟店家確認發現金額不符後，還可根據紀錄查出到底是哪位同學少付了，並溝通得到更正。

由於透過金流平台溝通，所有的對話都會讓所有聚餐的同學都看到。因此可以形成輿論壓力，讓有理的一方能順利得到金額的更正。

如果真的無法解決爭端，還可以評價對方的壞行為。這樣他下次跟其他人聚餐時，不好的評價就會顯示出來，讓大家事前得知要小心注意呢！

當然，如果可以直接付給店家或許更好！

這樣的金流平台，或許可以用同儕壓力來形成病毒行銷的作用，把所有的人都拉到平台之上，自然就可透過別的方法營利賺錢了！

用 rnnlm, liblinear 和 word2vec 做中文情感分析測試

Fri, 27 Mar 2015 21:45:00 +0800

最近在研究一些 NLP 工具的使用方法，所以稍微紀錄一下心得。這次的實驗主要是參考 Tomas Mikolov 在 word2vec 論壇上發表的文章，以及 Ensemble of Generative and Discriminative Techniques for Sentiment Analysis of Movie Reviews 的程式碼。不過改運用在中文上，並且用簡單的 TF-IDF 取代 Naive Bayes Support Vector Machine。

資料集是使用 2014 年 NTU NLP 課程的旅館評論資料 207884_hotel_training.txt，然後稍微進行一些處理。將資料修改成以下格式：

LABEL TOKENS

每行有一則資料，先是正負向標記：1 表示正、2 表示負。其後接上斷詞後的評論（以空白分隔每個詞）。過濾掉斷詞失敗的句子後，共剩下 1124 句正向評論和 1217 句負向評論。

接下來我寫了一個 split.py 把資料分成測試集和訓練集：

python3 split.py --input data/data.txt --train_pos data/train_pos.txt --train_neg data/train_neg.txt --test_pos data/test_pos.txt --test_neg data/test_neg.txt

我分別取了十分之一當作測試資料：有 112 句正向、121 句負向。

RNNLM

首先，我參考了 mesnilgr/iclr15 的做法，使用 rnnlm 來建造語言模型，並預測測試資料的正負。rnnlm 是一個可以用來建立 Recurrent Neural Network Language Models 的方便工具。

首先分別挑出 200 則訓練資料當作幫助調整參數的 validation set，分別訓練出正向與負向語言模型：

cd rnnlm

# construct positive language model
head -n 200 ../data/train_pos.txt > val.txt
cat ../data/train_pos.txt | sed '1,200d' > train.txt
./rnnlm -rnnlm pos.model -train train.txt -valid val.txt -hidden 50 -direct-order 3 -direct 200 -class 100 -debug 2 -bptt 4 -bptt-block 10 -binary

# construct negative language model
head -n 200 ../data/train_neg.txt > val.txt
cat ../data/train_neg.txt | sed '1,200d' > train.txt
./rnnlm -rnnlm neg.model -train train.txt -valid val.txt -hidden 50 -direct-order 3 -direct 200 -class 100 -debug 2 -bptt 4 -bptt-block 10 -binary

緊接著，把測試資料串在一起，並標記 ID 以符合 rnnlm 的輸入格式：

cat ../data/test_pos.txt ../data/test_neg.txt | nl -v0 -s' ' -w1 > test.txt

最後再用正向與負向模型預測每個句子個可能性，並將其比值輸出到檔案中：

./rnnlm -rnnlm pos.model -test test.txt -debug 0 -nbest > model_pos_score.txt
./rnnlm -rnnlm neg.model -test test.txt -debug 0 -nbest > model_neg_score.txt
mkdir ../scores
paste model_pos_score.txt model_neg_score.txt | awk '{print $1/$2;}' > ../scores/RNNLM

再稍微用 normalize.py 調整數據的範圍，就可以用 evaluate.py 來檢查最後的正確率了。

cd ..
python3 normalize.py --input scores/RNNLM --output scores/RNNLM --type rnnlm
python3 evaluate.py --test_pos data/test_pos.txt --scores scores/RNNLM
#
# RNNLM accuracy: 87.9828%

Word2Vec: Paragraph Vectors + Logistic Regression

接下來我們要用具有將整個句子轉成 vector 能力的修改版 word2vec 來處理句子。值得注意的是，iclr15 中的 word2vec 版本，在句子數目太多時，會因為 vocabulary 數量太大，而造成許多句子被丟棄而無法正確轉成 embedding。

為了解決這個問題，我修改了程式碼 word2vec@shaform，讓我們可以用 @@SE 為開頭標示用來訓練 word embeddings 而不需要產生 paragraph vectors 的句子；以 @@SS 為開頭來標示需要產生 paragraph vectors 的句子。這樣一來就可以同時擁有大量的訓練資料，又可以完整產生所有指定的 paragraph vectors。不過在這個實驗中，為了方便，我們就不額外引進大量訓練資料，所以所有句子都會以 @@SS 開頭。

cd word2vec
cat ../data/train_pos.txt ../data/train_neg.txt ../data/test_pos.txt ../data/test_neg.txt | nl -v0 -s' ' -w1 | sed 's/^/@@SS-/' | shuf > all.txt
time ./word2vec -train all.txt -output vectors.txt -cbow 0 -size 400 -window 10 -negative 5 -hs 1 -sample 1e-3 -threads 24 -binary 0 -iter 20 -min-count 1 -sentence-vectors 1
grep '@@SS-' vectors.txt | sed -e 's/^@@SS-//' | sort -n > sentence_vectors.txt

緊接著用 transform.py 和 train.py 來產生訓練資料，並用 liblinear 的 logistic regression 來訓練：

python3 ../transform.py --input sentence_vectors.txt --output sentence_features.txt
python3 ../train.py --features sentence_features.txt --train_pos ../data/train_pos.txt --train_neg ../data/train_neg.txt --test_pos ../data/test_pos.txt --output_train train.txt --output_test test.txt
../liblinear/train -s 0 train.txt model.logreg
../liblinear/predict -b 1 test.txt model.logreg out.logreg

再稍微用 normalize.py 調整數據的範圍，就可以用 evaluate.py 來檢查最後的正確率了。

sed '1d' out.logreg | cut -d' ' -f3 > ../scores/DOC2VEC
cd ..
python3 normalize.py --input scores/DOC2VEC --output scores/DOC2VEC --type logreg
python3 evaluate.py --test_pos data/test_pos.txt --scores scores/DOC2VEC
#
# DOC2VEC accuracy: 84.5494%

TF-IDF

最後則是簡單的 TF-IDF，我使用 tfidf.py 來產生 unigrams 和 bigrams，並用之前的 train.py 來產生訓練資料。

cd tfidf
cat ../data/train_pos.txt ../data/train_neg.txt ../data/test_pos.txt ../data/test_neg.txt > all.txt
python3 ../tfidf.py --input all.txt --output features.txt
python3 ../train.py --features features.txt --train_pos ../data/train_pos.txt --train_neg ../data/train_neg.txt --test_pos ../data/test_pos.txt --output_train train.txt --output_test test.txt

緊接著用 liblinear 的 logistic regression 來訓練：

../liblinear/train -s 0 train.txt model.logreg
../liblinear/predict -b 1 test.txt model.logreg out.logreg

再稍微用 normalize.py 調整數據的範圍，就可以用 evaluate.py 來檢查最後的正確率了。

sed '1d' out.logreg | cut -d' ' -f3 > ../scores/TFIDF
cd ..
python3 normalize.py --input scores/TFIDF --output scores/TFIDF --type logreg

python3 evaluate.py --test_pos data/test_pos.txt --scores scores/TFIDF

# TFIDF accuracy: 90.9817%

整合

最後用簡單的算術平均整合 3 個模型，效能倒是沒有顯著上升：

paste scores/RNNLM scores/DOC2VEC scores/TFIDF | awk '{print ($1+$2+$3)/3;}' > scores/TOTAL
python3 evaluate.py --test_pos data/test_pos.txt --scores scores/TOTAL


# RNNLM accuracy: 87.9828%
# DOC2VEC accuracy: 84.5494%
# TFIDF accuracy: 90.9817%
# TOTAL accuracy: 90.1288%

程式碼

我把相關的程式碼放在 GitHub 上面供參考：shaform/sentiment_analysis。

建立 LDAP 鏡像、及日常管理指令集

Sun, 14 Dec 2014 17:42:00 +0800

建立鏡像

假設只有一台 LDAP server，則一旦 crash 大家都無法登入了，故可以建立一個鏡像 server，不斷同步資料內容。這篇假設你已經建好前篇的 ldap.lab.csie.ntu.edu.tw，而想再建一個 ldapm.lab.csie.ntu.edu.tw。則在 clients 的設定可設為：

# /etc/ldap/ldap.conf
URI     ldaps://ldap.lab.csie.ntu.edu.tw ldaps://ldapm.lab.csie.ntu.edu.tw
TLS_CACERT      /etc/ssl/certs/ca-certificates.crt

# /etc/nslcd.conf
uri ldaps://ldap.lab.csie.ntu.edu.tw
uri ldaps://ldapm.lab.csie.ntu.edu.tw
#ssl off
tls_reqcert demand
tls_cacertfile /etc/ssl/certs/ca-certificates.crt

初始安裝 Mirror Server

首先透過前一篇文章的作法安裝 ldapm.lab.csie.ntu.edu.tw 但跳過「轉移 NIS 資料」的部份。此外，需使用同一個 my_root 但卻須產生新的 server 憑證，並對應到新的網域名稱（注意 -set_serial 號碼與之前不同）：

openssl genrsa -out ldapm_key.pem 1024
openssl req -new -key ldapm_key.pem -out ldapm_csr.pem
openssl x509 -req -days 36500 -in ldapm_csr.pem -CA my_root_crt.pem -CAkey my_root_key.pem -out ldapm_crt.pem -set_serial 2

同時設定 Master 和 Mirror Server

接下來，我們要在兩邊分別建立一個帳戶供 mirror 之用，首先建立一個密碼，比如說 1234：

slappasswd -h {SSHA}
New password: 
Re-enter new password: 
{SSHA}oQ1Lw12oTHhdL9NwHQe2FoypBZX90QKx

echo -n {SSHA}oQ1Lw12oTHhdL9NwHQe2FoypBZX90QKx | base64
e1NTSEF9b1ExTHcxMm9USGhkTDlOd0hRZTJGb3lwQlpYOTBRS3g=

緊接著，分別在兩台 server 上建立 mirror.ldif 檔案：

dn: cn=mirrormode,dc=lab,dc=csie,dc=ntu,dc=edu,dc=tw
changetype: add 
objectClass: simpleSecurityObject
objectClass: organizationalRole
cn: mirrormode
description: Syncrepl user for mirrormode operation
userPassword:: e1NTSEF9b1ExTHcxMm9USGhkTDlOd0hRZTJGb3lwQlpYOTBRS3g=

執行

ldapmodify -D "cn=admin,dc=lab,dc=csie,dc=ntu,dc=edu,dc=tw" -W -f mirror.ldif

緊接著，分別在兩台 server 上建立 mirror_config.ldif 檔案：

dn: cn=module{0},cn=config
changetype: modify
add: olcModuleLoad
olcModuleLoad: syncprov

dn: olcDatabase={1}hdb,cn=config
changetype: modify
delete: olcAccess
olcAccess: {0}to attrs=userPassword,shadowLastChange by self write by anonymous auth by dn="cn=admin,dc=lab,dc=csie,dc=ntu,dc=edu,dc=tw" write by * none
-
add: olcAccess
olcAccess: {0}to attrs=userPassword,shadowLastChange by self write by anonymous auth by dn="cn=admin,dc=lab,dc=csie,dc=ntu,dc=edu,dc=tw" write by dn="cn=mirrormode,dc=lab,dc=csie,dc=ntu,dc=edu,dc=tw" read by * none
-

dn: olcOverlay=syncprov,olcDatabase={1}hdb,cn=config
changeType: add 
objectClass: olcOverlayConfig
objectClass: olcSyncProvConfig
olcOverlay: syncprov
olcSpCheckpoint: 100 10
olcSpSessionLog: 100 

dn: olcDatabase={1}hdb,cn=config
changeType: modify
delete: olcDbIndex
olcDbIndex: objectClass eq
-
add: olcDbIndex
olcDbIndex: objectClass,entryCSN,entryUUID eq
-

執行

ldapmodify -Y EXTERNAL -H ldapi:/// -f mirror_config.ldif

最後在兩台機器上建立不同的兩個檔案 ldap.ldif, ldapm.ldif：

ldap.lab.csie.ntu.edu.tw：

dn: cn=config
changeType: modify
add: olcServerID
olcServerID: 0
-

dn: olcDatabase={1}hdb,cn=config
changeType: modify
add: olcSyncrepl
olcSyncrepl: rid=001 provider=ldaps://ldapm.lab.csie.ntu.edu.tw bindmethod=simple binddn="cn=mirrormode,dc=lab,dc=csie,dc=ntu,dc=edu,dc=tw" credentials=1234 searchbase="dc=lab,dc=csie,dc=ntu,dc=edu,dc=tw" schemachecking=on type=refreshAndPersist retry="60 +"
-
add: olcMirrorMode
olcMirrorMode: TRUE
-

執行

ldapmodify -Y EXTERNAL -H ldapi:/// -f ldap.ldif

ldapm.lab.csie.ntu.edu.tw：

dn: cn=config
changeType: modify
add: olcServerID
olcServerID: 1
-

dn: olcDatabase={1}hdb,cn=config
changeType: modify
add: olcSyncrepl
olcSyncrepl: rid=001 provider=ldaps://ldap.lab.csie.ntu.edu.tw bindmethod=simple binddn="cn=mirrormode,dc=lab,dc=csie,dc=ntu,dc=edu,dc=tw" credentials=1234 searchbase="dc=lab,dc=csie,dc=ntu,dc=edu,dc=tw" schemachecking=on type=refreshAndPersist retry="60 +"
-
add: olcMirrorMode
olcMirrorMode: TRUE
-

執行

ldapmodify -Y EXTERNAL -H ldapi:/// -f ldapm.ldif

注意 olcServerID 要用不同的編號，而 provider 要設成對方，credentials 則是剛剛選擇的密碼。

最後測試看看是否已經同步：

ldapsearch -x -h localhost

日常管理

建立使用者

ldapadd -x -W -D "cn=admin,dc=lab,dc=csie,dc=ntu,dc=edu,dc=tw" <<EOF
dn: cn=$username,ou=Group,dc=lab,dc=csie,dc=ntu,dc=edu,dc=tw
objectClass: posixGroup
objectClass: top
cn: $username
userPassword: {crypt}x
gidNumber: $userid
EOF

ldapadd -x -W -D "cn=admin,dc=lab,dc=csie,dc=ntu,dc=edu,dc=tw" <<EOF
dn: uid=$username,ou=People,dc=lab,dc=csie,dc=ntu,dc=edu,dc=tw
uid: $username
cn: $realname
objectClass: account
objectClass: posixAccount
objectClass: top
objectClass: shadowAccount
shadowMax: 99999
shadowWarning: 7
loginShell: /bin/bash
uidNumber: $userid
gidNumber: $userid
homeDirectory: /home/$username
gecos: ,,,
EOF

ldappasswd -x -W -D "cn=admin,dc=lab,dc=csie,dc=ntu,dc=edu,dc=tw" -S uid=$username,ou=People,dc=lab,dc=csie,dc=ntu,dc=edu,dc=tw

刪除使用者

ldapdelete -x -W -D "cn=admin,dc=lab,dc=csie,dc=ntu,dc=edu,dc=tw" "cn=$username,ou=Group,dc=lab,dc=csie,dc=ntu,dc=edu,dc=tw"
ldapdelete -x -W -D "cn=admin,dc=lab,dc=csie,dc=ntu,dc=edu,dc=tw" "uid=$username,ou=People,dc=lab,dc=csie,dc=ntu,dc=edu,dc=tw"

修改使用者的群組

# add
ldapmodify -D "cn=admin,dc=lab,dc=csie,dc=ntu,dc=edu,dc=tw" -W <<EOF
dn: cn=$groupname,ou=Group,dc=lab,dc=csie,dc=ntu,dc=edu,dc=tw
changetype: modify
add: memberUid
memberUid: $username
EOF

# remove
ldapmodify -D "cn=admin,dc=lab,dc=csie,dc=ntu,dc=edu,dc=tw" -W <<EOF
dn: cn=$groupname,ou=Group,dc=lab,dc=csie,dc=ntu,dc=edu,dc=tw
changetype: modify
delete: memberUid
memberUid: $username
EOF

備份與還原

如果只有一個鏡像壞掉，只要再用這篇的方法建立一個鏡像就可以備份到另一個。否則可以用以下兩個指令，注意不同的鏡像設定也會被備份，所以不同台 server 可能不能直接用同一個備份檔還原：

slapcat > bak.ldif

slapadd -l bak.ldif

在 Debian 7.7 系統中轉移 NIS 到 LDAP

Sat, 13 Dec 2014 17:42:00 +0800

本文件紀錄了基本的 LDAP 設置。

設定 LDAP Master

基本設置

首先編輯 /etc/ldap/ldap.conf 填上適當的網域名稱。例如：

BASE    dc=lab,dc=csie,dc=ntu,dc=edu,dc=tw
URI     ldap://ldap.lab.csie.ntu.edu.tw

其中 URI 必須是可以連上 Master server 的 IP 或網域名稱。

緊接著，安裝 OpenLDAP：

sudo apt-get install slapd ldap-utils

此時它只會要你設定一個 admin 密碼，如果希望看到完整設定，可以事先執行以下指令，並設定 Dialog 為不高於 Medium 的層級。不過我偏好不改動這個設定，而是事後再重新執行設定程式。

sudo dpkg-reconfigure debconf

事後重新設定的指令則是：

sudo dpkg-reconfigure slapd

可按照喜好自行設定，但 domain name 要跟 /etc/lapd/lapd.conf 一致：

Omit OpenLDAP server configuration? No
DNS domain name: lab.csie.ntu.edu.tw
Organization name: lab.csie.ntu.edu.tw
Administrator password: <PASSWORD>
Confirm password: <PASSWORD>
Database backend to use: HDB
Do you want the database to be removed when slapd is purged? No
Move old database? Yes
Allow LDAPv2 protocol? No

以後如果想重設 LDAP 也可重新執行上述指令。他會將 old database 移動到 /var/backups 資料夾，不過如果已經移動過一次則指令會失敗，此時可先手動砍除舊的 /var/backups/<ldap directory>。

可以執行以下兩個指令來確認設置成功：

ldapsearch -x
slapcat

轉移 NIS 資料

首先安裝轉移工具組：

sudo apt-get install migrationtools

接著編輯設定檔 /usr/share/migrationtools/migrate_common.ph：

# Default DNS domain
$DEFAULT_MAIL_DOMAIN = "lab.csie.ntu.edu.tw";
# Default base
$DEFAULT_BASE = "dc=lab,dc=csie,dc=ntu,dc=edu,dc=tw";
...
# Uncomment these to exclude Debian-managed system users and groups
$IGNORE_UID_BELOW = 1000;
# Don't uncomment this if you want to be able to add users to system groups
# $IGNORE_GID_BELOW = 1000;
# And here's the opposite for completeness
$IGNORE_UID_ABOVE = 29999;
$IGNORE_GID_ABOVE = 29999;

由於 Debian 的 LDAP 預設並沒有載入 misc.schema，所以如果要讀入 alias 資料就會出錯。因此我們只手動載入需要的部份，而不使用自動載入全部資料的方法。進入 /usr/share/migrationtools/ 資料夾後執行以下指令：

# create basic data
./migrate_base.pl | ldapadd -x -W -h localhost -D "cn=admin,dc=lab,dc=csie,dc=ntu,dc=edu,dc=tw" -c

# migrate passwd
./migrate_passwd.pl /etc/passwd | ldapadd -x -W -h localhost -D "cn=admin,dc=lab,dc=csie,dc=ntu,dc=edu,dc=tw" -c

# migrate group
./migrate_group.pl /etc/group | ldapadd -x -W -h localhost -D "cn=admin,dc=lab,dc=csie,dc=ntu,dc=edu,dc=tw" -c

執行 migrate_base.pl 會有部份內容無法處理是正常的。

設定 LDAP Client

在要透過 LDAP 登入的主機上進行以下步驟，若 LDAP Master server 本身也想透過 LDAP 登入的話，也是採用相同辦法。首先安裝相關程式

sudo apt-get install libpam-ldapd libnss-ldapd nslcd

並回答相關問題：

LDAP server URI: <this answer is the same as what you put in '/etc/ldap/ldap.conf'>
ldap://ldap.lab.csie.ntu.edu.tw/

LDAP server search base:
dc=lab,dc=csie,dc=ntu,dc=edu,dc=tw

Name services to configure:
group, password, shadow

接著如果要讓 root 可以在不輸入 LDAP 密碼的情況下修改別人密碼，則可修改 /etc/nslcd.conf，其中 rootpwmodpw 設為之前選擇的 LDAP 密碼：

ldap_version 3
rootpwmoddn cn=admin,dc=lab,dc=csie,dc=ntu,dc=edu,dc=tw
rootpwmodpw <PASSWORD>

如果要讓 client 也能執行 ldapsearch 等指令，也可依 master 的方法修改 /etc/lapd/lapd.conf。

可重新開機測試是否成功。

TLS 加密連線

以上的作法，在連線時不夠安全，因此我們可以啟用 TLS 加密連線。

建立憑證

假設你有可供使用的憑證當然很好，但是一般人除了等待 Let’s Encrypt 以外，可能也只能自己的憑證自己建了。

在某個資料夾內建立相關憑證：

openssl genrsa -out my_root_key.pem 1024
openssl req -new -key my_root_key.pem -out my_root_csr.pem
openssl x509 -req -days 36500 -in my_root_csr.pem -signkey my_root_key.pem -out my_root_crt.pem

openssl genrsa -out ldap_key.pem 1024
openssl req -new -key ldap_key.pem -out ldap_csr.pem

openssl x509 -req -days 36500 -in ldap_csr.pem -CA my_root_crt.pem -CAkey my_root_key.pem -out ldap_crt.pem -set_serial 1

其中的資訊可以隨意填，但在建立 ldap_csr.pem 時，Common Name 一定要填 client 可以連到的，LDAP master server 的 domain name：

Country Name (2 letter code) [AU]:TW
State or Province Name (full name) [Some-State]:Taiwan
Locality Name (eg, city) []:Taipei
Organization Name (eg, company) [Internet Widgits Pty Ltd]:NTU Lab
Organizational Unit Name (eg, section) []:
Common Name (e.g. server FQDN or YOUR name) []:ldap.lab.csie.ntu.edu.tw
Email Address []:

Please enter the following 'extra' attributes
to be sent with your certificate request
A challenge password []:
An optional company name []:

然後在 master 上建立一個資料夾，並將相關檔案複製，設定適當的權限：

sudo mkdir /etc/ldap/ssl
sudo cp ldap_key.pem ldap_crt.pem /etc/ldap/ssl
sudo mkdir /usr/share/ca-certificates/my/
sudo cp my_root_crt.pem /usr/share/ca-certificates/my/my_root.crt
sudo chmod 644 /usr/share/ca-certificates/my/my_root.crt
sudo dpkg-reconfigure ca-certificates # choose to add my/my_root.crt
sudo update-ca-certificates

sudo chown -R root:openldap /etc/ldap/ssl
sudo chmod -R o-rwx /etc/ldap/ssl

然後在所有 client 上也可以複製 my_root_crt.pem：

sudo cp my_root_crt.pem /usr/share/ca-certificates/my/my_root.crt
sudo chmod 644 /usr/share/ca-certificates/my/my_root.crt
sudo dpkg-reconfigure ca-certificates # choose to add my/my_root.crt
sudo update-ca-certificates

小心收藏剩餘的 key.pem，不要讓別人看到囉。

設定 LDAP Master Server

注意，這裡的設定若一不小心可能導致 LDAP server 無法運作，故設定時最好先備份所有檔案。

首先在 master 上更改 /etc/default/slapd，將 LAPD_SERVICES 改成以下內容，也就是只允許本機不透過 TLS 連線：

SLAPD_SERVICES="ldap://127.0.0.1:389/ ldaps:/// ldapi:///"

緊接著建立一個 tls.ldif 檔案：

dn: cn=config
add: olcTLSCACertificateFile
olcTLSCACertificateFile: /etc/ssl/certs/ca-certificates.crt
-
add: olcTLSCertificateFile
olcTLSCertificateFile: /etc/ldap/ssl/ldap_crt.pem
-
add: olcTLSCertificateKeyFile
olcTLSCertificateKeyFile: /etc/ldap/ssl/ldap_key.pem

並套用設定：

ldapmodify -Y EXTERNAL -H ldapi:/// -f tls.ldif

同時更改 /etc/ldap/ldap.conf：

URI     ldaps://ldap.lab.csie.ntu.edu.tw
TLS_CACERT      /etc/ssl/certs/ca-certificates.crt

最後重新啟動 ldap：

sudo service slapd restart

設定 LDAP Client

修改 /etc/nslcd.conf：

uri ldaps://ldap.lab.csie.ntu.edu.tw
#ssl off
tls_reqcert demand
tls_cacertfile /etc/ssl/certs/ca-certificates.crt

重啟服務：

sudo service nslcd restart

可測試是否可以登入。

連結兩個私有內網

Wed, 12 Nov 2014 09:20:00 +0800

實驗室的工作站先生們待在兩個不同的內網，各自透過一台工作站當 gateway 和外面的世界溝通。因此，要連結彼此時，常需要透過 gateway 的特定 port 來轉送到 sshd。這樣每台機器的其他不同 services 也都要額外開個 port，感覺非常不方便。

記得學長大大離開實驗室前，總是不能忘懷他們無法在一起的困難。於是晚輩們就決定試圖解決這個問題了！

機器配置

假設現在有兩群工作站：

bob     eth0: 192.168.13.1/24  eth1: 140.112.13.5
jack    eth0: 192.168.13.2/24

ted     eth0: 192.168.14.1/24  eth1: 140.112.14.20
nick    eth0: 192.168.14.2/24

其中，bob 和 ted 有接上 Internet，而 jack 接到 bob，nick 接到 ted，並透過他們連結外網。我們希望讓 jack 和 nick 可以直接連結。

作法

Bob 的設定

我們將會在 bob 和 ted 之間建立一個 tunnel，然後修改 routing table 將送往另一個內網的流量導進 tunnel 之中。

首先，在 bob 的 /etc/network/interface 中，修改 eth0 的設置（或者修改 eth1 也可以，不過考慮到如果 eth1 改錯可能就無法用 ssh 連進來，所以先改 eth0）：

auto eth0
iface eth0 inet static
        address 192.168.13.1
        netmask 255.255.255.0
        network 192.168.13.0
        broadcast 192.168.13.255
        pre-up ip tunnel add mytunnel mode ipip remote 140.112.14.20
        up ip addr add 192.168.15.5/24 dev mytunnel
        up ip link set dev mytunnel up
        up ip route add 192.168.14.0/24 via 192.168.15.20
        down ip route del 192.168.14.0/24 via 192.168.15.20
        post-down ip tunnel del mytunnel

主要是要讓 bob 連結內網時，自動建立起 tunnel，而切斷連線時自動取消，在實際修改檔案前，也可以先用指令列測試其中的指令：

首先是建立一個虛擬的 tunnel 界面，並連結到 ted 的外部 IP：

sudo ip tunnel add mytunnel mode ipip remote 140.112.14.20

緊接著，隨意為 bob 在此界面指定一個 IP：

sudo up ip addr add 192.168.15.5/24 dev mytunnel

再來，把界面啟動連結：

sudo up ip link set dev mytunnel up

最後再設定把連到另一個內網的流量都導到 ted 在此 tunnel 的 IP：

sudo up ip route add 192.168.14.0/24 via 192.168.15.20

Ted 的設定

同樣的道理，在 ted 的 /etc/network/interface 中，修改 eth0 的設置，加入以下項目：

pre-up ip tunnel add mytunnel mode ipip remote 140.112.13.5
up ip addr add 192.168.15.20/24 dev mytunnel
up ip link set dev mytunnel up
up ip route add 192.168.13.0/24 via 192.168.15.5
down ip route del 192.168.13.0/24 via 192.168.15.5
post-down ip tunnel del mytunnel

啟用 IP Forwarding

理論上原本工作站的內網設置應該就有啟用 IP forwarding 的功能，不過為求完整，在這裡記載啟用的方法。可以在 bob 和 ted 上執行以下指令：

sudo sysctl -w net.ipv4.ip_forward=1

此外，若要讓此設定開機後仍然維持，則需修改 /etc/sysctl.conf，並取消註解以下的項目：

#net.ipv4.ip_forward=1

啟用新網路設定

接下來就可以在 bob 和 ted 上執行以下指令使新設定生效了：

sudo ifdown eth0 && ifup eth0

注意由於一開始 down 和 post-down 的指令可能會失敗，所以如果直接執行以上指令有可能會有問題，這時也可以重新開機。或者稍微修改一下指令執行及檔案修改的順序來達成想要的效果。

測試

可以在 bob 和 jack 上測試以下指令：

ping 192.168.14.2

在 ted 和 nick 上測試以下指令：

ping 192.168.13.2

參考

Linux Networking routing to virtual ip addresses from a different subnet

如果想要把兩組機器都放進同個內網，也可以參考更進階的：

Site-to-Site Layer 2 Bridging Using OpenVPN Access Server and a Linux Gateway Client

用中文資料測試 word2vec

Tue, 04 Nov 2014 17:20:00 +0800

最近因為一些學習上的需要接觸了 word2vec，覺得好像是有點神秘的東西。一般初學自然語言處理的時候，處理文字最簡單的模型就是把每個詞當作一個單位，比如說用個 id 來表示他。然後再去算詞與詞之間的統計關係。或者是利用句子的文法結構來進行其他處理。如果把每個詞出現的次數當作一個維度的話，也可以把句子或文件用一個向量來表示。

不過 word2vec 是把每個詞本身用一個多維向量來表示，把詞投影到一個向量空間裡。而且不知道為什麼投影出來的空間有些特殊的性質，比如說相同屬性的詞可能會靠得很近，甚至部份的向量有邏輯上的線性關係等等：

vector('King') - vector('Man') + vector('Woman') ~= vector('Queen')

這份筆記紀錄了使用 word2vec 處理中文資料的小小實驗。

語料

不太確定有什麼開放的中文語料可供使用，於是決定先用萌典來做實驗，可按照教學，下載萌典資料：

git clone --depth 1 https://github.com/g0v/moedict-data.git
git clone --depth 1 https://github.com/g0v/moedict-epub.git
cp -v moedict-data/dict-revised.json moedict-epub/
cd moedict-epub
perl json2unicode.pl > dict-revised.unicode.json

緊接著我自己寫了一個 extract_json.py 把當中可供訓練的句子抽出來：

python3 extract_json.py < dict-revised.unicode.json > sentences.txt

斷詞

因為 word2vec 的輸入必須是以空白隔開的詞，這樣得出來的句子還不能直接使用。於是我用了結巴斷詞，寫了一個 cut.py 來處理這些句子。

python cut.py < sentences.txt > sentences.segged.txt

斷出來的結果大約像是：

紅樓夢 ． 第十七回 ： 「 一 槅 一 槅 ， 或 有 貯書處 ， 或 有 設鼎處 ， 或 安置 筆硯 處 ， 或供 設瓶花 、 或 安放 盆景 處 。 」

感覺雖不是很理想，但尚可接受。

使用 word2vec 訓練詞向量

接著我就用工作站把詞全部丟給 word2vec 訓練：

./word2vec -train sentences.segged.txt -output vectors.bin -cbow 0 -size 200 -window 10 -negative 5 -hs 0 -sample 1e-4 -threads 24 -binary 1 -iter 20 -min-count 1

因為萌典抽出來的資料不算多，所以訓練起來滿快的，只是當然效果就不太好了：

測試

首先測試距離相近的字：

./distance vectors.bin

雖然效果差強人意，不過還是可以看到相同屬性的字確實有些群聚效應：

Enter word or sentence (EXIT to break): 法國

Word: 法國  Position in vocabulary: 992

                                            Word         Cosine distance
------------------------------------------------------------------------
                                            英國         0.763948
                                            德國         0.727664
                                          義大利         0.724732
                                            瑞士         0.724247
                                          西班牙         0.715528
                                          奧地利         0.696855
                                          蘇格蘭         0.689557

接著測試線性關係，A 比 B 就好像 C 比什麼？：

./word-analogy vectors.bin

對於國家與都市的推理，也稍有效果：

Enter three words (EXIT to break): 法國 巴黎 英國

Word: 法國  Position in vocabulary: 992

Word: 巴黎  Position in vocabulary: 6379

Word: 英國  Position in vocabulary: 822

                                            Word         Distance
------------------------------------------------------------------------
                                            倫敦         0.583572
                                          七二年         0.576999
                                          莫斯科         0.566673
                                          四四年         0.566332
                                      一九四一年         0.562817
                                          芝加哥         0.559529
                                      一九六二年         0.556010
                                          羅浮宮         0.555593
                                          油畫院         0.554334

訓練出來的詞向量或許可以供進一步利用，只是在實際使用之前無法確定是否適用於特定的應用。

程式碼

我把相關的程式碼放在 GitHub 上面供參考：https://github.com/shaform/experiments/tree/master/word2vec_tw

參考資料

在工作站上使用自己的 Python 並安裝自訂套件

Sun, 22 Jun 2014 10:30:00 +0800

使用工作站時常會遇到想要自行安裝 Python 套件，結果卻沒有管理權限的問題。雖然可以自行在 local 安裝套件，或者是乾脆自行安裝 local 版的 Python，但設置的程序稍微有點麻煩，而且遇到想要同時使用多種版本的 Python 時，設置就更複雜了。

遇到這種情形的時候，建立 Python 的 virtual environment 就可以方便的使用多個不同版本與環境的 Python。

pyvenv

pyvenv 是在 Python 3.3 後新加入官方 Python 發行版的一個 module，可以讓使用者建立自己的 virtual environment。雖然很可惜的，Debian 系的 OS 因為 bug 732703 所以暫時無法使用。不過還是介紹一下他的用法：

在 ENV_DIR 建立 virtual environment，--system-site-packages 參數則是讓系統安裝的套件也能被這個環境使用，3.4 則可選擇不同版本：
```
pyvenv-3.4 [--system-site-packages] ENV_DIR
```
啟用特定的 virtual environment：
```
source ENV_DIR/bin/activate
```
這時你就會發現在 prompt 前多了個名字，然後直接用 pip 安裝套件就會裝到這個 local 的 environment 了：
```
(name)$
```
以後要啟用某個 environment 時都要重新用 2 提到的方法啟用。

virtualenv

如果工作站上有安裝 virtualenv 的話，也可以用這個套件達到相同功能，好處是 Python 2 也可以用。

在 ENV_DIR 建立 virtual environment，--system-site-packages 參數則是讓系統安裝的套件也能被這個環境使用，python3.4 則可選擇不同版本（包含 python2）：
```
virtualenv [--system-site-packages] -p python3.4 ENV_DIR
```
啟用特定的 virtual environment：
```
source ENV_DIR/bin/activate
```
這時你就會發現在 prompt 前多了個名字，然後直接用 pip 安裝套件就會裝到這個 local 的 environment 了：
```
(name)$
```
使用 which 可以看到 python 路徑：
```
which python
ENV_DIR/bin/python

which pip
ENV_DIR/bin/pip
```
注意到如果當初指定用 python3.4 的話，這裡雖然下的是 python，其實也是 3.4 版。以後要啟用某個 environment 時都要重新用 2 提到的方法啟用。

如果有裝 virtualenvwrapper 的話其實還有更方便的方法，可以自行參考文件。

Local Packages

如果實在是無法建立 virtual environment 的話，只能使用舊方法來安裝 local 套件了，首先在 .bashrc 加入對應的參數，使得執行 Python 時會載入 local 套件：

alias python3="PYTHONPATH=$PYTHONPATH:$HOME/.local/lib/python3.4/site-packages python3"
alias python="PYTHONPATH=$PYTHONPATH:$HOME/.local/lib/python2.7/site-packages python"

其中各版本的路徑可自行調整。

接下來安裝套件時都加上 –user 參數即可，例如：

pip3 install --user flask
python3.4 setup.py install --user

pip2 install --user flask
python2 setup.py install --user

解決 Ubuntu 加密 Home 目錄後無法遠端用 public key 登入的問題

Sat, 21 Jun 2014 09:00:00 +0800

通常啟用 SSH 登入會遇到一個大問題：經常會有奇怪的人想要暴力破解密碼，取得登入權限。最早我都是限制只能從校內 IP 來源登入來減輕這個問題，然而最近的電腦是在 NAT 背後，透過一個 port 連結 SSH，所以似乎看不到真正的來源 IP，因此無法輕易過濾。

我最後決定停用密碼登入的功能，改成只能用 public key 登入，這樣子可能比較難以猜中正確的密鑰。不過實際用起來偶爾會發現登入失敗搞不清楚理由，後來才發現是因為我的 Ubuntu 啟用了家目錄加密的功能，因此尚未登入之前根本讀不到 authorized_keys 設定檔。為了解決這個問題，必須移動設定檔的位置才行。

Generate SSH Keys

首先如果沒有自己的 SSH keys 的話可以參考〈Generating SSH Keys〉建立自己的 SSH keys。大致上是使用如下指令：

ssh-keygen -t rsa -C "your_email@example.com"

預設會把產生的 private key 存在 /home/$USER/.ssh/id_rsa，public key 存在 /home/$USER/.ssh/id_rsa.pub，不過也可以改位置。passphrase 則是用來加密 private key，建議要使用，這樣子每次要解開 private key 時都需要使用密碼，所以就算一不小心 private key 被別人取得，對方也要花上一段時間才能解開。

更改 sshd_config 設定

sudoedit /etc/ssh/sshd_config

首先取消密碼登入，將

#PasswordAuthentication yes

改成：

PasswordAuthentication no

再來更動 authorized_keys 的位置，將

#AuthorizedKeysFile     %h/.ssh/authorized_keys

改成：

AuthorizedKeysFile     /etc/ssh/keys/%u/authorized_keys

建立 authorized_keys 檔案

然後根據你的 $USER 名字建立資料夾，並修改權限：

sudo mkdir -p /etc/ssh/keys/$USER
sudo chmod 755 /etc/ssh/keys
sudo chmod 700 /etc/ssh/$USER
sudo chown $USER:$USER /etc/ssh/$USER

最後再將 id_rsa.pub 拷貝到 server 上，並複製到 authorized_keys：

# copy id_rsa.pub to server, then ->
cat id_rsa.pub >> /etc/ssh/keys/$USER/authorized_keys
chmod 400 /etc/ssh/ssh/keys/$USER/authorized_keys

重新讀取設定

重新讀取設定檔並測試一下登入就大功告成：

sudo service ssh reload

在 UEFI 模式下同時安裝 Windows 8.1 和 Ubuntu 14.04

Thu, 19 Jun 2014 16:05:00 +0800

總是喜歡在自己的電腦上裝 Linux。小時候安裝還很麻煩，要燒光碟。後來研究了從硬碟安裝的方法，可又需要額外的磁區。一直到 USB 隨身碟普及了以後，重灌才成為一件比較方便的事。尤其 Ubuntu 的安裝界面做的還不錯，後來就一直用到今天。

雖然習慣使用 Linux，可是有時候還是會遇到要在 Windows 上才能寫的作業，所以每次都把電腦灌成雙系統，也慢慢熟悉了這個過程，一直以來不太有改變。不過最近拿到一台有 UEFI 開機的 Lenovo ThinkPad X1 Carbon 筆電，又想在啟用 Secure Boot 的情況下同時裝雙系統，設置上就比較麻煩了。本文就是記載這個過程。

安裝 Windows 8

原本如果是在正常的電腦上安裝 Windows 8，可以透過 Windows USB/DVD download tool 來製作安裝用隨身碟，但在 UEFI 啟用的情況下就不行了。這時參考〈How to create Windows 8 installation bootable USB for UEFI〉，首先在 Windows 環境下使用管理員權限執行 cmd.exe，用 diskpart.exe 找出隨身碟的代號：

diskpart.exe
list disk

再把隨身碟格式化成 FAT32，並設成可開機。注意，disk 1 的這個 1 要選擇隨身碟代號，否則可能會把其他硬碟的內容給刪除。partition 1 則指的是隨身碟上的第一個 partition：

select disk 1
clean
create partition primary
select partition 1
active
format quick fs=fat32
assign
exit

理論上用其他工具格式化隨身碟可能也可以，不過沒有嘗試過。

接下來，先 mount Windows 8 的安裝光碟，然後把內容全部拷貝到隨身碟上，比如說如果安裝光碟 mount 在 H:，而隨身碟在 F: 的話：

xcopy H:\* F:\ /s /e

然後先用 BIOS 停用 UEFI Secure Boot，才能用隨身碟開機。首先開始安裝 Windows 8。參考〈The complete guide to a Windows 8 clean installation〉進行安裝，但自行設定硬碟磁區大小，空出給 Ubuntu 的空間。此時安裝程式也會自動幫你建立 Recovery, System (Reserved), MSR (EFI 磁區) 等三個磁區，看起來很醜，不過可能有用，就保留吧。

裝完後不知為什麼時間設定有錯，而且也無法更新，於是參考〈Change Time Servers in Windows 8〉，將 time server 改成台大的 ntp2.ntu.edu.tw。

最後重開機，在 BIOS 中啟用 UEFI Secure Boot 就大功告成了。

安裝 Windows 8.1

假設直接用 Windows 8.1 安裝光碟，到這裡就結束了。可是因為學校只有升級版的 Windows 8.1，所以緊接著馬上從 Windows 8 升級到 Windows 8.1。

首先用 Windows Update 更新系統，然後 mount Windows 8.1 光碟，並執行他。開始一步步安裝，安裝的選項跟 Windows 8 差不多，我選擇不要保留任何設定，把 Windows 8 的紀錄都洗掉。安裝完硬碟又會多一個 Recovery 磁區，雖然很醜，可是可能有用所以保留他。

安裝完後再重新設定一次 time server 就大功告成了！

安裝 Ubuntu 14.04 64-bit

只有 64-bit 版本對 UEFI 有較好的支援，所以首先參考〈How to create a bootable USB stick on Ubuntu〉製作一個 Ubuntu 14.04 安裝隨身碟，然後參考〈Ubuntu Community Wiki: UEFI〉來安裝，基本上安裝過程跟一般情形一樣，只是我選擇自訂磁碟分割，所以要自己找出 EFI 磁區，然後指定 mount 到 /boot/efi。

最後裝完會遇到一個 bug：〈Unable to chainload Windows 8 with Secure Boot enabled 〉，使得無法直接用 grub2 來啟動 Windows 8.1，不過 ThinkPad X1 Carbon 可以透過 BIOS 來多重開機，因此還是可以使用，對於很少使用 Windows 8.1 的我來說並不造成困擾。

簡單的 PTT BBS 掛站設定

Tue, 27 May 2014 13:21:00 +0800

很久以前看到了 othree 的〈掛站系統設定篇〉，學會了如何在工作站上掛著 BBS。在那以後就很少使用桌面軟體來連 PTT 等 BBS。使用工作站掛站的優點主要是不用一直重新登入很方便，另外在一些公共區域上網時，避免直接使用明文帳密連結 telnet 而透過 ssh 感覺比較安心一點。（不過其實我建議 BBS 還是使用不同的密碼比較好呀。）

後來我發現其實掛一些我平常在逛的站如 PTT or PTT2 其實很少會遇到逾時被登出的狀況，所以就省去了使用 expect 來不斷送出空白訊號的麻煩。就用這篇文章來紀錄這個簡化的掛站方法。

Tmux

筆者原本使用 screen，不過後來換成 tmux 之後又改了新版的 PTT 掛站指令，感覺更方便了。如下所示，只要放進 ~/.bashrc 之中，則只要打 ptt 或 ptt2 就可以連上掛站的 BBS 們了。

同時也支援在已經打開 tmux 的情況下切換到對應的 session。

function ptt() {
  if [ -n "$TMUX" ]; then
    TMUX= tmux new-session -d -s P1 "tmux set status off; ssh bbsu@ptt.cc" &>/dev/null
    tmux switch-client -t P1
  else
    tmux new-session -A -s P1 "tmux set status off; ssh bbsu@ptt.cc" 
  fi
}

function ptt2() {
  if [ -n "$TMUX" ]; then
    TMUX= tmux new-session -d -s P2 "tmux set status off; ssh bbsu@ptt2.cc" &>/dev/null
    tmux switch-client -t P2
  else
    tmux new-session -A -s P2 "tmux set status off; ssh bbsu@ptt2.cc" 
  fi
}

Screen

首先在 $HOME 目錄建一個叫做 screenrc-bbs 的資料夾，接下來在資料夾裡根據想逛的 bbs 建立 screenrc 檔案。

比如說 screenrc-bbs/ptt：

vbell off 
screen -t 'ptt' ssh bbsu@ptt.cc

screenrc-bbs/ptt2：

vbell off 
screen -t 'ptt2' ssh bbsu@ptt2.cc

screenrc-bbs/ptt3：

vbell off
defencoding big5
screen -t 'ptt3' telnet ptt3.cc
defencoding big5

screenrc-bbs/bs2：

vbell off 
defencoding big5 
screen -t 'bs2' telnet -8 bs2.to 
defencoding big5

最後在 .bashrc 加入 alias 就大功完成啦：

alias bs2="if ! screen -rD BS2 >& /dev/null ; then LANG='zh_TW.UTF-8' screen -S BS2 -c $HOME/screenrc-bbs/bs2 ; fi"
alias ptt="if ! screen -rD PTT1 >& /dev/null ; then LANG='zh_TW.UTF-8' screen -S PTT1 -c $HOME/screenrc-bbs/ptt ; fi"
alias ptt2="if ! screen -rD PTT2 >& /dev/null ; then LANG='zh_TW.UTF-8' screen -S PTT2 -c $HOME/screenrc-bbs/ptt2 ; fi"
alias ptt3="if ! screen -rD PTT3 >& /dev/null ; then LANG='zh_TW.UTF-8' screen -S PTT3 -c $HOME/screenrc-bbs/ptt3 ; fi"

如此一來，下次登入時只要直接打 ptt 就可以開始逛版了，要離開則按 Ctrl-A Ctrl-D，只要沒有被斷線的話隨時登入工作站都可以下 ptt 指令重回之前的進度。

從 Pixnet 轉移到 Pelican

Sat, 17 May 2014 07:25:00 +0800

「翼之都」這個技術部落格其實早在 2006 年就成立了，一直放在 Blogger 上，但很少新增文章。最近好不容易開始打算多寫一些技術文，卻突然發現在 Blogger 上實在是有點麻煩：它對於一些程式碼的的支援有點不直覺，而文章的寫作方式也有許多不符我的需求。最後索性就把這個網誌改用 Pelican 建立了。而因為文章只有一點點，所以是用手動搬的。

搬完以後覺得這種靜態網頁在管理和備份文章上實在是很方便。想到「浮光」這個文章集散處，其實完全是由很少 HTML 的靜態文章所組成，實在是很適合放到 Pelican 上，再者 Pixnet 的後台界面自己一直不是很喜歡，所以就乾脆一起搬了。

以下記載完成這件事的流程，使用的環境是 Ubuntu 14.04 64-bit。

安裝 Pelican

詳細安裝方法可見 Getting started 文件，我自己選的方法是用 virtualenvwrapper，並從 source code 直接安裝最新版的 Pelican（其實這是因為我想要讓文章的發布時間可以支援用不同時區的表示格式，舊版的 Pelican 似乎尚未支援）。

1. 安裝 virtualenvwrapper

首先輸入以下指令：

sudo apt-get install python-pip virtualenvwrapper

然後新增 pelican 環境

mkvirtualenv pelican

這樣以後如果要進入 pelican 環境的話只要下：

workon pelican

而安裝的套件也不會跟系統混在一起。

2. 安裝 pelican

在 pelican 環境下隨意找個位置，下載 pelican 原始碼，並安裝相關套件：

git clone https://github.com/getpelican/pelican.git
cd pelican
python setup.py install
pip install Markdown

最後選個資料夾放置網誌檔案，並下以下指令，就可以建立簡單的設定擋了：

pelican-quickstart

匯出

Pixnet 的匯出格式是 Movable Type，恰巧 pelican-import 尚未支援。同時，浮光上的文章常有大量空行，我希望對轉換的格式有更多控制，所以乾脆自己寫了一個 Python script 來進行轉換：

# -*- coding: utf-8 -*-
# python convert.py < blog-export.txt
import fileinput
import os
import os.path
import re
import sys

import pelican.utils

def p_transform(lines):
    new_lines = []
    empty = 0
    for l in lines:
        if l == '':
            empty += 1
        else:
            if empty > 0:
                if empty == 1:
                    new_lines.append('')
                else:
                    num = ((empty-1) / 3) + 1
                    new_lines.extend([''] + [u'&nbsp;', ''] * num)
                empty = 0
            new_lines.append(l)
    return '\n'.join(new_lines)


rData = re.compile(r'(\d{2})/(\d{2})/(\d{4}) (\d{2}):(\d{2}):(\d{2}) (PM|AM)')
while True:
    article = {}
    for l in sys.stdin:
        l = l.decode('utf-8')
        if l.startswith(u'TITLE: '):
            article['title'] = l[7:-1]
        elif l.startswith(u'DATE: '):
            m = rData.search(l)
            if m is None:
                raise Exception(u'wrong with {}'.format(l))
            else:
                gs = m.groups()
                t = int(gs[3])
                if gs[6] == u'PM' and t != 12:
                    t += 12
                article['date'] = u'{}-{}-{} {}:{}:{}+0800'.format(
                        gs[2], gs[0], gs[1],
                        t, gs[4], gs[5])
        elif l.startswith(u'PRIMARY CATEGORY: '):
            cat = l[18:l.find(u'STATUS')]
            if cat in [u'雪山', u'海岸', u'城市', u'？？']:
                article['category'] = u'天予'
                article['tags'] = {u'天予：' + cat, u'系列', u'奇幻'}
            elif cat in [u'我的世界', u'記憶']:
                article['category'] = cat
                article['tags'] = {u'系列'}
            else:
                article['category'] = cat
        elif l == u'BODY:\n':
            lines = []
            for l in sys.stdin:
                l = l.decode('utf-8')
                if l != '-----\n':
                    if l.find(u'nbsp') != -1:
                        lines.extend([u'',u''])
                    else:
                        space = False
                        if l.find(u'</p>') != -1:
                            space = True
                        l = l.strip().replace(u'<p>', u'').replace(u'</p>', '')
                        l = l.replace(u'<!-- more -->', '')
                        lines.append(l)
                        if space:
                            lines.append(u'')
                else:
                    break
            article['body'] = p_transform(lines)

            for l in sys.stdin:
                l = l.decode('utf-8')
                if l == u'--------\n':
                    break
        if 'body' in article:
            break

    if len(article) == 0:
        break
    else:
        path = 'content/' + article['category']
        if not os.path.exists(path):
            os.makedirs(path)
        with open(path + '/' + pelican.utils.slugify(article['title']) + '.md', 'w') as f:
            f.write(u'Title: {}\n'.format(article['title']).encode('utf-8'))
            f.write(u'Date: {}\n'.format(article['date']).encode('utf-8'))
            f.write(u'Category: {}\n'.format(article['category']).encode('utf-8'))
            if 'tags' in article:
                f.write(u'Tags: {}\n'.format(', '.join(article['tags'])).encode('utf-8'))
            f.write(u'Authors: Shaform\n')
            f.write(u'\n'.encode('utf-8'))
            f.write(article['body'].encode('utf-8') + '\n')

這個 script 會將結果輸出到 content/{category}/{title}.md 檔案，自動轉換適當的空行、分類、日期格式等等。分類的處理是依據浮光的架構，所以只有浮光能用。

發布到 Google App Engine

在這過程中，我短暫的嘗試用 Google App Engine 作為發布平台，不過因為太麻煩，所以最後還是採用 GitHub Pages。

實際的作法是先申請個帳號，然後安裝 SDK：

curl sdk.cloud.google.com | bash
# restart the Terminal, then
gcloud auth login

緊接著在網誌目錄中新增 app.yaml 檔案，設定讓伺服器顯示靜態網頁：

application: APP-NAME
version: 1
runtime: python27
api_version: 1
threadsafe: yes
module: default

handlers:
- url: /
    static_files: output/index.html
      upload: output/index.html

      - url: /
          static_dir: output

然後修改 Makefile 新增如下指令，自動將檔案複製到指定位置：

gcloud: publish
    mkdir -p gcloud/output
    cp -r $(OUTPUTDIR)/* gcloud/output
    mv gcloud $(OUTPUTDIR)
    cp app.yaml $(OUTPUTDIR)/gcloud
    appcfg.py update $(OUTPUTDIR)/gcloud

這樣的話只要在網誌的目錄下執行以下指令，就可以把網頁發布到 Google App Engine 上了：

make gcloud

發布到 GitHub Pages

雖然 Pelican 原本就有支援 GitHub Pages 的發布，不過我比較希望在 local 端的 master branch 紀錄網誌的原始 Markdown 檔案，在 gh-pages branch 上紀錄產生的網頁，因此我在 Makefile 做了以下修改：

GITHUB_PAGES_BRANCH=gh-pages
github: publish
        echo "DOMAIN-NAME" > $(OUTPUTDIR)/CNAME
        ghp-import -r gh-pages -b $(GITHUB_PAGES_BRANCH) $(OUTPUTDIR) -m "$(MSG)"
        git push gh-pages $(GITHUB_PAGES_BRANCH):master

其中 DOMAIN-NAME 那行是自訂 domain 用的，若沒有可以刪除。而 -m $(MSG) 則是為了讓我可以用 MSG="new update" make github 來自訂 commit 訊息。最後一行的 master，如果是用 username.github.io 的話就保留 master，如果是一般 projects 的話就改成 gh-pages。

緊接著安裝 ghp-import：

pip install ghp-import

然後按照 GitHub Pages 的說明，建立一個 repository，並把整個網誌的目錄當成這個 repository。（我其實是先 git clone 然後把 .git 資料夾直接搬到網誌目錄中。）

結果

最後再調整一些佈景和版面的設定，就成了最後的結果。初步感覺還滿令我滿意的。以後再慢慢調整浮光以及翼之都的版面吧。

在 Ubuntu 12.04 安裝 HDFS 及 HBase 筆記

Sun, 13 Apr 2014 15:56:00 +0800

這篇是假設 master, slave-1, slave-2 的 domain name/ip 分別為： master-dn, slave-1-dn, slave-2-dn。

一、HDFS

安裝 JDK 7

sudo apt-get update && apt-get upgrade # 更新套件庫
sudo apt-get install software-properties-common python-software-properties  # 取得 add-apt-repository
sudo add-apt-repository ppa:webupd8team/java  # 新增有 oracle-java7-installer 的 ppa
sudo apt-get update
sudo apt-get install oracle-java7-installer

設定 SSH

ssh-keygen -b 2048 -t rsa:q  # 產生 RSA key pair
cp ~/.ssh/id_rsa.pub ~/.ssh/authorized_keys  # 讓自己可以不用密碼登入自己

在 NameNode 上：

ssh-copy-id -i $HOME/.ssh/id_rsa.pub user@slave-1-dn  # 讓 NameNode 可不用密碼登入 DataNode
ssh-copy-id -i $HOME/.ssh/id_rsa.pub user@slave-2-dn  # 讓 NameNode 可不用密碼登入 DataNode

安裝 Hadoop

先在 $HOME/.bashrc 加上 export PATH=$PATH:$HOME/hadoop-1.2.1/bin，然後進入家目錄：
```
wget http://ftp.tc.edu.tw/pub/Apache/hadoop/common/hadoop-1.2.1/hadoop-1.2.1-bin.tar.gz
tar -xvf hadoop-1.2.1-bin.tar.gz
cd hadoop-1.2.1/conf
```
修改 hadoop-env.sh 加上 export JAVA_HOME=/usr/lib/jvm/java-7-oracle。

進階設定

在下列檔案中的內新增如下內容：

core-site.xml

<property>
<name>fs.default.name</name>
<value>hdfs://master-dn:54310</value>
</property>

mapred-site.xml

<property>
<name>mapred.job.tracker</name>
<value>master-dn:54311</value>
</property>

hdfs-site.xml

<property>
<name>dfs.replication</name>
<value>3</value>
</property>

然後在 NameNode 上修改將以下檔案修改成如下內容：

masters
```
master-dn
```
slaves
```
master-dn
slave-1-dn
slave-2-dn
```

開啟伺服器最後在 NameNode 上執行以下指令將 cluster 啟動（可能需要重新登入讓 PATH 設定生效）：
```
hadoop namenode -format  # 格式化檔案系統
start-all.sh  # 啟動所有服務（包含 HDFS）
```

二、HBase

首先進入每台的家目錄，下載並解壓縮 HBase：

wget http://ftp.twaren.net/Unix/Web/apache/hbase/stable/hbase-0.94.14.tar.gz
tar -xvf hbase-0.94.14.tar.gz

編輯 hbase-0.94.14/conf/hbase-env.sh，新增數行：

export JAVA_HOME=/usr/lib/jvm/java-7-oracle
export HADOOP_CONF_DIR=$HOME/hadoop-1.2.1/conf
export HBASE_HOME=$HOME/hbase-0.94.14
export HBASE_LOG_DIR=$HOME/logs/hbase-logs
export HBASE_PID_DIR=$HOME/logs/hbase-pids
export HBASE_CLASSPATH=$HBASE_CLASSPATH:$HOME/hadoop-1.2.1/conf
export HBASE_MANAGES_ZK=true

編輯 hbase-0.94.14/conf/hbase-site.xml，在內新增如下內容：

<property>
    <name>hbase.rootdir</name>
    <value>hdfs://master-dn:54310/hbase</value>
</property>
<property>
    <name>hbase.tmp.dir</name> 
    <value>/home/hbase-${user.name}</value>
</property>
<property>
    <name>hbase.cluster.distributed</name>
    <value>true</value>
</property>       
<property> 
    <name>hbase.zookeeper.quorum</name>
    <value>master-dn,slave-1-dn,slave-2-dn</value>
</property>
<property>
    <name>hbase.zookeeper.property.dataDir</name>
    <value>/home/hbase-data</value> 
</property>

然後編輯 hbase-0.94.14/conf/regionservers 將內容改為如下：

master-dn
slave-1-dn
slave-2-dn

最後就可以在 master 執行 HBase 了：

./hbase-0.94.14/bin/start-hbase.sh

qwerty 轉換到 dvorak 筆記

Fri, 12 Jul 2013 18:53:00 +0800

Windows

Windows 是透過新增輸入法的方式增加 dvoark 鍵盤，如果是新的版本，登入畫面也可以選擇不同的鍵盤使用，如果一開始安裝就選擇 dvorak 的話，就會成為預設值。如果是 XP 或者想要把像是注音輸入法的符號對應也改成 dvorak 的話，可以參考我以前寫的文章：〈Dvorak: 另一種鍵盤排列〉。

Linux

最近的 Linux distributions 只要在安裝時就選擇 dvorak 鍵盤的話，大致上就會設定完成，通常 GUI 頁面也會有鍵盤設定。Linux 上輸入法和鍵盤設定通常是分開的兩個東西。如果你使用像是自由行列輸入法等等原本就有支援 dvorak 的輸入法，則符號對應只要設定一下就可以了。

如果因為某些原因無法更動設定檔，使用以下指令可以在鍵盤間切換：

setxkbmap dvorak # 更動成 dvorak
setxkbmap us     # 還原成 us 標準鍵盤

Xrdp

如果使用 rdp 的方式遠端連上 linux 的話，他的鍵盤對應是由自己的設定檔所控制，檔案位置在 /etc/xrdp/km-\*\*\*\*.ini，其中 \*\*\*\* 為不同語言設定的檔案，其編號可參考 rfc1766。通常我們需要修改的是 km-0409.ini (en-US) 這個檔案。

在正常登入的情況下，使用以下指令可以在當前目錄產生目前鍵盤對應的 xrdp 設定檔：

xrdp-genkeymap km-now.ini

接著我們把它搬移取代 xrdp 參照的檔案：

sudo mv km-now.ini /etc/xrdp/km-0409.ini

或許我們會想在覆蓋之前先備份原本的設定檔：

sudo mv /etc/xrdp/km-0409.ini /etc/xrdp/km-0409.ini.old

最後重新啟動 xrdp 伺服器就可以了：

sudo /etc/init.d/xrdp restart

但如果因為某些原因只能用 rdp 連上主機，而無法接觸正常的桌面的話，則根本無法得到 dvorak 的鍵盤對應，因此也無法產生設定檔，在這種情況下，只好直接修改原本的 km-0409.ini。而也有人說用 xrdp-genkeymap 產生的檔案有時會有問題，這時也只能直接修改了。我寫了一個程式用來做這個轉換：

#!/usr/bin/env python3
# xrdpkeymap_qwerty_to_dvorak.py
"""
Usage: python xrdpkeymap_qwerty_to_dvorak.py km-input.ini > km-output.ini
"""
import fileinput
import re

# keycodes
# $ xmodmap -pk for current mapping
# ref: http://forums.fedoraforum.org/showthread.php?t=265100
QWERTY = (20, 21, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 38, 39, 40,
          41, 42, 43, 44, 45, 46, 47, 48, 52, 53, 54, 55, 56, 57, 58, 59, 60,
          61)

DVORAK = (34, 35, 48, 59, 60, 33, 29, 41, 42, 54, 27, 46, 61, 21, 38, 32, 26,
          30, 31, 40, 43, 28, 57, 39, 20, 47, 24, 44, 45, 53, 56, 58, 25, 55,
          52)

TRANS_DICT = dict(list(zip(QWERTY, DVORAK)))


def main():
    re_title = re.compile(r'\[.*\]\n')
    re_keydef = re.compile(r'Key(\d+)=(.*)\n')
    buf = []
    buf_dict = {}

    def output_keydefs():
        for k in buf:
            if k in TRANS_DICT:
                print('Key%d=%s' % (k, buf_dict[TRANS_DICT[k]]))
            else:
                print('Key%d=%s' % (k, buf_dict[k]))
        return [], {}

    for line in fileinput.input():
        if re_title.match(line) is not None:
            buf, buf_dict = output_keydefs()
            print(line, end='')
        elif re_keydef.match(line) is not None:
            m = re_keydef.match(line)
            buf.append(int(m.group(1)))
            buf_dict[int(m.group(1))] = m.group(2)
        else:
            print(line, end='')

    # output remaining keys
    output_keydefs()


if __name__ == '__main__':
    main()

Vim

有的時候我們甚至無法重新啟動 xrdp server，或者根本沒有管理員權限，這時只好有限度的在 Vim 裡頭使用 dvoark。

set keymap=dvorak
set langmap=-=qwertyuiop[]sdfghjkl\\;'zxcvbn\\,./_+QWERTYUIOP{}SDFGHJKL:\"ZXCVBN<>?;[]'\\,.pyfgcrl/=oeuidhtns-\\;qjkxbwvz{}\"<>PYFGCRL?+OEUIDHTNS_:QJKXBWVZ

keymap 可以修改輸入模式的對應，langmap 則是一般及 visual 模式等指令的按鍵，後面那串其格式可參考 :help ’langmap’，基本上是先打 qwerty 的按鍵，加個分號，再打上轉換成的 dvorak 按鍵，不過 , 和 ; 需要在前面補上 \，" 則是要補上 \。這設定唯一無法轉換的部份是 “:” 開頭的指令模式。此外，如果 set keymap 沒有作用的話，或許是系統缺少 dvorak 的 keymap，此時建立 ~/.vim/keymap/dvorak.vim 檔案，插入 dvorak.vim 的內容即可。

GCIN

有的輸入法沒有直接支援 dvoark，不只是符號對應沒有支援，連正常輸入都整個亂掉了。這時可能要搜尋一下看有沒有現成的修改版檔案，例如我曾經修改過 GCIN 的行列輸入法表格。如果沒有的話，可能就得自行轉換了。

我寫了一個轉換 GCIN .cin 檔的程式：

#!/usr/bin/env python3
# gcin_qwerty_to_dvorak.py
"""
Usage: python gcin_qwerty_to_dvorak.py input.cin > output.cin
"""
import fileinput
import re

QWERTY = '''-=qwertyuiop[]sdfghjkl;'zxcvbn,./_+QWERTYUIOP{}SDFGHJKL:"ZXCVBN<>?'''
DVORAK = '''[]',.pyfgcrl/=oeuidhtns-;qjkxbwvz{}"<>PYFGCRL?+OEUIDHTNS_:QJKXBWVZ'''
TRANS = str.maketrans(QWERTY, DVORAK)


def main():
    re_option = re.compile(r'%(selkey|endkey)\s+(\S+)')
    re_begin = re.compile(r'%\S+\s+begin')
    re_keydef = re.compile(r'^([^#]\S*)(\s+\S+)')
    re_end = re.compile(r'%\S+\s+end')

    begin = False
    for line in fileinput.input():
        # process key definitions
        if begin:
            if re_end.match(line):
                begin = False
            else:
                new_def = re_keydef.subn(
                    lambda x: x.group(1).translate(TRANS) + x.group(2), line)
                # print transformed line
                if new_def[1] != 0:
                    print(new_def[0], end='')
                    continue
            # print comment/end lines
            print(line, end='')
            continue

        m = re_option.match(line)
        if m is not None:
            print('%%%s %s' % (m.group(1), m.group(2).translate(TRANS)))
            continue
        elif re_begin.match(line):
            begin = True
        print(line, end='')


if __name__ == '__main__':
    main()

轉換完後再用 gcin2tab 產生 GCIN 能用的 .gtab 檔。

使用此程式轉換檔案的話，可能還是會需要手動調整，因為有些像是「,」 ->「，」的符號對應應該還是保留會比較好。

下載

相關程式可在 shaform/dvorak-tools 下載。

最低成本的程式協作: CoProgramming

Tue, 05 Mar 2013 08:03:00 +0800

緣起

在程式課堂，團隊合作常常是件頭痛的事，若是每個人各自工作，常會產生許多難以整合的版本。即使是一起到電腦教室討論，也常是一個人寫程式，其他人在旁邊看。雖然有版本控制系統等等合作工具，然而我從來沒有成功在一堂課中讓隊友學會其運作(應該說是幾乎，僅有在雙方都早已會使用，或者是由我做所有merge時才曾使用)，事實上，像 git, hg 等等複雜的系統，是否真的適合這種小型專案也尚有可懷疑的地方，尤其，有些作業所有的程式碼都在同一個檔案中，使得版本控制系統用起來十分不順手。

我突然想起在《Here Comes Everybody》書裡看過的說法：Wikipedia 的貢獻者中，絕大多數可能只有編輯過一兩行的文章。一家公司如果大部分的員工都只做一點工作，則這家公司多半無法生存。可是在 Wikipedia 的例子裡，合作的成本被降的很低，所以原來不可能利用的小量付出，也能被整合成一個共同成果。

這確實就是我們遇到的情況，有時在課堂中的程式作業規模是如此的小，任何的合作成本都太過高昂。而且，這種只存在一學期的臨時團隊，根本難以形成向心力。而要求任何人為了一學期的作業學會複雜的版本控制系統更是完全不實際的想法。

如果要成功整合大家一起完成這種小型的合作、如果要在每個人只寫幾行程式的情況下依然可以合作，唯一的可能性就是要將合作成本壓到極端的低。可是，要怎麼做呢？我的腦中浮現起從前透過 EtherPad 或者是 Google Docs 教人寫程式時的場景，這就是了。像這樣即時同步的作法在專業的程式開發中或許會因為無法預期其他人的修改而造成不少問題，但對於小型合作而言，這就是最簡單的協作形式。

沒有錯，只要在 Google Docs 上協作程式，然後再加上即時編譯執行的功能，免去不斷在 IDE 與 Docs 間不斷複製貼上的成本，就足夠了。這個非常簡單的專案將目標鎖定在程式新手的小型合作，最好的使用情境其實就是兩人互相坐在電腦教室裡，同時使用兩台電腦，邊討論邊寫程式。再也不會有一個人寫程式，其他人在旁邊看的情形了！腦中有了想法後，我就開始試著把他實做出來。

經過

理論上這應該是個非常簡單的專案，而我其實也只是抱著展示想法的心情，所以是以快速開發作為原則，然而最後卻花了不少時間。問題出在 Google Drive SDK 並沒有支援 C/C++，所以一開始選擇語言時我走了些歧路，原本想採用 Python，可是開發到一半才覺得我不太熟悉用 Tkinter 製作圖形界面，且效果也不是很好，再考慮到一般 Windows 使用者並沒有安裝 Python 函式庫，py2exe 好像也有些 .dll 的問題，所以就放棄了。

雖然知道 Java 是個不錯的選擇，可是印象中 Java 簡單的程式總要寫一大堆程式碼，實在提不起勁來。這時，我發現 Go 是個很有趣的語言，雖然他主要是用在系統開發，可是也有人開發圖形界面的函式庫，加上是個編譯語言，很符合我希望使用者能簡單使用這個軟體的需求，於是就決定來學一下 Go 了！這確實是個很簡單易學的語言，我花了一天的時間就讀完基本的教學，準備開始開發。只是突然發現那個圖形函式庫其實根本編譯不起來，而且功能也有限，所以最後我還是決定改用 Java 了。為了使用者的方便，我也打算採用 launch4j 來製作可執行檔，並包入 TDM-GCC 以及 Code::Blocks 的 cb_console_runner，讓使用者測試程式結束時視窗不會立即結束。

目前程式碼可在 coprogramming@github 觀看。

本來想製作包裝好的執行檔，但因為不知為何有時編譯出來的程式會被測出木馬（雖然可能是誤判），為了避免真的把木馬包進去，所以我決定只放上主程式，想參考研究的朋友可自行下載 TDM-GCC 安裝到 MinGW 子資料夾即可使用，另外如果把 JRE 安裝到 jre7 子資料夾，則可在未安裝 JRE 的電腦上直接執行主程式。

包好的壓縮檔目前可在 download page 下載。

已知問題

由於專案本身只是想要展示想法，所以目前有不少問題：

由於直接下載編譯執行程式，所以可能有安全性問題。
目前需要要求存取 Drive 所有檔案的權限，否則無法列出別人分享的程式碼。
程式碼的標題在 Drive 中有特殊限制，會自動以 coprg 做為結尾，雖然在程式中看不出來。
需要自行在 Drive 中選取 Tools -> Preferences… 取消 smart quotes 的設定，以免分號被轉換，造成程式無法編譯。
只支援單檔案編譯。
只支援 C++。
…

結語

其實早就有線上編譯的服務，理論上要做到線上協作、編譯、測試程式應該也可以，且對於使用者而言或許會更加方便。或者可以做一個本機端的伺服器程式，專門接收程式碼與編譯，而將界面寫成 Google Chrome 的擴充套件，這樣就可以使用該套件開啟特定文件，解決目前必須要求存取所有檔案的問題了！（因為本機程式沒有辦法讓使用者針對特定檔案給予權限，我猜測寫成擴充套件應該就可以實做在 Drive 界面裡，在檔案上按右鍵以該套件開啟的功能了吧。）

這個想法是因為他專門針對新手的小型專案而特別，可是這種合作方式真的只適合新手嗎？即使在專業的環境中，若是在任何檔案上按下右鍵，就能即時同步分享於 Drive 之上，然後在請教同事時，他也能即時在檔案中編輯，而在他編輯的同時，本地端程式碼即時同步，隨時可用原本的方法編譯，這或許也有方便之處？

稍微整理了一下自由行列的原始碼

Tue, 26 Feb 2013 14:17:00 +0800

停擺多年

還記得數年前完成了「自由行列輸入法」的測試版本，雖然一開始還有斷斷續續修正一些 bugs，但到後來這個專案就完全停擺了。當然其中一個重要理由是突然發現 gcin 原本就有支援智慧選詞的行列輸入法，覺得花那麼多力氣重造輪子有點不值得。但其實也是沒有特別的新功能可以開發，而且程式本身寫的太亂不太好維護，加上課業繁忙，所以就沒有投注太多關心。

gcin 的版本雖然很好，但對 Dvorak 和「行列定符」的支援總是差了那麼一點，而且不知為何總是無法習慣使用 gcin，所以後來就沒有繼續使用。而隨著作業系統的更新，之前的自由行列輸入法也不知為何無法編譯了，於是我就重回注音輸入法的懷抱，和行列輸入法疏離了許久。

後來剛好又看到行列以及 dvorak 的討論串，加上最近剛好比較有空，就想把之前的程式碼翻修一下，看看能不能動，也順便把原始碼轉到現在比較習慣的 GitHub。雖然只花了幾天時間，不過其實遇到的問題也不少，甚至有些問題的根源還很難弄明白。

問題

首先遇到的問題是不知為何編譯時所連結的外部函式庫，包含 sqlite3, ibus, freearray 等等，都無法順利連結，使用到的函式都變成了 undefined reference。花了一段時間才發現似乎是一定要透過 libtool 才能順利連結，在 configure.ac 裡加上 AM_PROG_LIBTOOL 以後情況才有所改善。

但是很奇怪的是，原本我的編譯程序是先將一部分的 object 檔製成暫時的函式庫 libfaft.a，最後再連結在一起，但這個函式庫指向的外部連結也都變成是 undefined reference。除此之外，也遇到 libtool 在連結 c++, c 檔案時無法順利找到 libstdc++ 的問題。最後只有取消中繼函式庫，直接將所有 object 檔連在一起才能解決。

除此之外，automake 和 autoconf 等等的行為似乎跟以前比起來也有微妙的改變，因此我參考其他專案修改了 autogen.sh，新增 libtoolize 和 autoheader 等指令，讓編譯流程順利進行，雖然其實我也不太清楚這些微妙的改變實際上有什麼作用就是。

接下來則是 ibus 新版的 ibus_config_set_value, ibus_config_get_value, ibus_config_new 等等的行為已經有所不同，還有許多函式不知為何開始要求傳進去的參數要先經過 g_object_ref_sink 的處理。這些也透過觀察類似專案得到了解法，雖然還沒有時間深入研究。

最後則是 64bit 環境下 libchewing 的 TreeType 大小會有問題，暫時用強制的型別解決了。

結語

幾番修正後終於成功啟動了 ibus-freearray，說起來行列輸入法真是不錯，雖然那麼久沒用可是我卻還記得怎麼打字。抱著學習的心態，這次也順便嘗試製作了 .deb 檔案，雖然一開始遇到一些問題，不過也順利解決了。

雖說如此，這樣匆促的修復應該會隱藏著不少 bugs，而且目前實在也是沒有投入太多心力持續開發這個專案的打算，所以它還是會繼續以測試版的姿態存在下去吧。

有興趣測試的朋友，所有的檔案都可在 freearray download page 下載，若你是使用 64bit Ubuntu，可直接安裝 libfreearray0 和 ibus-freearray 等 .deb 檔。否則的話就參考從前的文件下載 .tar 檔編譯安裝。

原始碼已經搬移到 Github：

ibus-faft 開發日誌

Sat, 20 Feb 2010 19:46:00 +0800

FreeArray for Test for the Input Bus 是基於 ibus 輸入法架構所製作之行列輸入法引擎，其結合來自 libchewing 的斷詞模組實作智慧選字功能，並利用「行列定符」改進原行列的符號輸入。此外，對 dvorak 鍵盤具有完整支援。

在開發過程中，除了引用大量 libchewing 的程式碼外，也參考了 ibus-array, ibus-chewing 的程式碼才得以完成。

時間大約是在 2010 年 2 月初直到 2 月中，連續而密集的開發。

libchewing

研究 libchewing 其實已經頗久了，直到現在對它的了解也才只是剛好得以把斷詞模組和一部分的輸入處理拿來用而已。為了配合 faft，而對 libchewing 做了些改動，主要是把 Phone 換成 ArrayCode，但也對一部分行為做了小修改，程式碼的改動應該都有用 #ifndef FAFT_CHEWING / #ifdef FAFT_CHEWING 包了起來，所以應該頗好追蹤的。

詞樹資料的創建是用了一系列工具轉換出來的，不過因為寫的時候是基於 C++ 版的 libfreearray，而且很亂沒整理，所以並沒有放在 ibus-faft 之中。檔案很大的一部分原因是同一個字有很多行列碼的表示方法，並且文字編碼長度比原新酷音長，另外，不小心把特別碼也轉進去了，不過一直提不起勁來重新轉換 XD。

資料處理

行列碼和中文字以及鍵盤排列轉換的處理，是從 libfreearray 中 C++ 的版本改過來的，處理中文字、行列定符、詞彙輸入的詞庫、特別碼及簡碼，都是由這部分負責，透過 SQLite 來存取資料。而斷詞用的詞庫，以及簡易符號輸入，則是用 libchewing 的檔案格式，詞彙輸入的詞庫和斷詞的詞庫我並沒有統一資料。另外，我把 libchewing 中使用者詞庫的功能移除以降低開發的複雜度。

對於 SQLite 其實還不是很熟悉，設了一些 index 也不知是否有必要。主要的參考書藉是《The Definitive Guide to SQLite》，以及官方文件《SQLite Documents》。

核心輸入模組

其實原本我想把輸入處理全寫到 ibus-faft-engine 中的 process_key_event()，然後呼叫一些 libchewing 的，或自己寫的函式。想不到後來慢慢把很多東西都移進 faft 中，再由 ibus-faft-engine 來呼叫 faft 裡的函式，所以 ibus-faft 就不用呼叫 libchewing 的函式了。事實上是，現在要把 faft 拿出來，放進 scim 或其它輸入法架構，都變成一件有可能的事。我也因此得以寫了一支 faft-test 程式，配合 gdb 偵錯，對 ibus-faft 的開發有很大幫助。

對於輸入法資料 FAFTContext 其實改動很多次，本來還另外寫了 FAFTData, FAFTOutput，再試圖引進 libchewing 之中，但最後變得非常複雜，所以還是直接改動 ChewingData, ChewingOutput，再把它們引進 faft 之中。faft 的介面曾改動過非常多次才變成現在的樣子，所以其實在某些地方可能會有一些功能重複或沒有用到的遺跡。另外就是一些狀態變數設了很多，最後好像也不見得有用。

與 ibus 的介面程式，絕大多數都是參考 ibus-chewing 所做，一部分則是從 ibus-array 而來。

關於 Settings

在製作 Settings 介面時，我選擇和 ibus-array 一樣，透過 Python 來做，一方面是因為覺得可能比較簡單，二方面是正想學 Python，不能放過每一個機會。過程中比較有趣的是，正值沒有網路的寒假，我又沒有用過 GTK+，在電腦裡只找到一份以前想學 GTK+ 時下載的文件，只是那份寫的是 C，所以跟 Python 又有點不一樣，所以其實很多地方都得「猜猜看」，還得常常用 dir() 之類的。原本製作時是想拿 ibus-array 的來改一下即可，不過最後似乎重寫了絕大部分，順便也是在練習 Python，並一邊閱讀著《Python documentation》。

Autotools

在初期，是自己寫 Makefile 來編譯 ibus-faft 的，直到末期才把 Autotools 的部分補了上去。主要是參考 ibus-tmpl 的檔案，以及《Autotools: a practitioner’s guide to Autoconf, Automake and Libtool》，才得以完成。

簡介自由行列專案

Mon, 15 Feb 2010 15:46:00 +0800

本持自由軟體，Release Early, Release Often 之精神，我實在應該趕快把自由行列的程式碼公開出來。不過覺得程式碼實在太醜，而且其實根本也還沒寫出什麼，再者我現在其實是一邊寫一邊學 OOP，因此程式碼常有大幅改動，再者又覺 SVN 操作好麻煩，所以遲遲未發。

不過為了避免自由行列的想法消失在歷史之中。於是決定，先把自由行列專案的簡介發出。

簡易使用

行列輸入法雖然是用字根組字的輸入法，然而由於其字根的特性，需要花的記憶心力其實是比較小的，只是為了求快或者避免選字，時常必須記憶特別碼或簡碼。並且因為有些組字必須選字，而有些則不用，使得要時常注意螢幕或者把它的行為強記下來。

引入智慧選字的功能之後，自由行列的新特性將是簡易。也許不再追求最快的輸入法，但是卻有機會成為組字輸入法中最易上手，選字機會最低的輸入法。每次出字時，不會再有依是否要選字而有的不一致行為，同時我也想將加上特定字尾才能輸出難字的功能去掉，而藏在「w」中的符號表，也被拿到「`」之下。如此一來，輸入的一致性將大為提高。

符號輸入

符號輸入是自由行列要改進的核心事項之一。除了符號表之外，還有從透過從行列字根發展出的「符根」輸出符號的「行列定符」，以及透過英文鍵盤，輸出全形中文符號的簡易符號輸入。

使用過行列輸入法的人，即使不用特別說明，只要看到以下符號表，就會明白行列定符的意義。由於和字根非常相似，幾乎不用什麼記憶。

按鍵	符號	按鍵	符號	按鍵	符號
1^	＝	5^	」	8-	＼
1-	─	5^5^	』	8v	‘
2^	「	5-	〉	8v8v	“
2^2^	『	5-5-	》	9^	※
2-	〈	5v	）	9-	／
2-2-	《	5v	）	9v	’
2v	（	5v5v	〕	9v9v	”
2v2v	〔	5v5v5v	】	0^	：
2v2v2v	【	6-	、	0-	。
3-	！	7^	？	0-0-	·
4-	＋	7-	，	0-0-0-	…
4-4-	＃	0v	；

在輸入完符碼後，按下 Shift+「詞彙鍵」即可輸出符號。

簡易符號輸入則是像新注音或新酷音那樣，在全型模式下，可輸入英文符號而輸出中文符號。此外，各種符號都可在緩衝區中再按下選字鍵選擇類似的符號。關於簡易符號輸入其實還是有很多改進的方法，有待開發。

事實上，對於符號輸入的改進，一部分的原因是要完全解決 Jedi 在他文章中所提出的跨 qwerty/dvorak 鍵盤時會遇到的問題。透過行列定符，使用者可以在完全不知道英文鍵盤的符號在哪的情況下輸出符號，讓行列自成一體系。而特意加強的簡易符號輸入，則是可依不同鍵盤輸出對應的中/英文符號。

繁簡分離

行列輸入法的字根除了可以用來拆繁體字外，其實也可以輸人簡體字。原本的設計是在輸入特定字尾時輸出簡體，但我想將簡體輸入獨立出來做為簡體模式。也就是說，我想嘗試讓自由行列具有做為一個簡體中文輸入法的可能性。

不只是輸入法

在製作 libfreearray 時，我所考慮的其實不只是輸入法而已，而是要將其發展成自由行列的通用函式庫。例如 typing tutor 或查碼程式，或其他更多的應用，都可基於其上發展。特別是一個可以在 Linux 平台上執行的 typing tutor，更是我將來有機會想實行的方向。覺得行列輸入法實在是一個很好的輸入法，現在似乎不太多人學，實為可惜。

手機輸入法

行列輸入法做為一個用數字排列字根的輸入法，自然具有成為手機輸入法的潛力，甚至要做到只有十鍵輸入，且不看螢幕都有可能。libfreearray 既然想成為行列的通用函式庫，最後很可能會希望建立起一個具有原始拆字字根，而非減縮後的 30 字根，的文字資料庫。屆時，當可研究如何製作手機輸入法。想來，要把行列字根轉到手機上其實有很多種做法，優缺點也不一，有心人可細細研究。

也許後來手機的鍵盤將不再有十鍵的限制，但行列做作手機輸入法的可能性還是令人憧憬。