穿越時空的偉人：用PyTorch重現偉人們的神經網絡

# (input, target)
('这正是我们', '弟')
('正是我们弟', '子')
('是我们弟子', '们')
('我们弟子们', '学')
('们弟子们学', '不')
('弟子们学不', '到')
('子们学不到', '的')
('们学不到的', '。')

# 語料裡所有出現過的中文字，此為 vocabulary
chars = sorted(list(set(raw_text)))

# 給每個中文字一個對應的 index，比較好做接下來的任務
char_to_int = dict((c, i) for i, c in enumerate(chars))
int_to_char = dict((i, c) for i, c in enumerate(chars))

# 共生成 N 個 input-target pair，每個 input 長度為 seq_length，target 長度為 1
n_chars = len(raw_text)
dataX = [] # N x seq_length
dataY = [] # N x 1
for i in range(0, n_chars - seq_length):
    seq_in = raw_text[i:i + seq_length]
    seq_out = raw_text[i + seq_length]
    dataX.append([char_to_int[char] for char in seq_in])
    dataY.append(char_to_int[seq_out])

# 採用 mini-batch，尾巴不足 batch_size 的直接捨棄
n_patterns = len(dataY)
n_patterns = n_patterns - n_patterns % batch_size
X = dataX[:n_patterns]
Y = dataY[:n_patterns]

# 把 array 每 batch_size 筆資料包成一組，並包成 tensor
X = np.array(X)
_, seq_length = X.shape
X = X.reshape(-1, batch_size, seq_length)

X = torch.LongTensor(X)

Y = np.array(Y)
Y = Y.reshape(-1, batch_size)

Y = torch.LongTensor(Y)

class Net(nn.Module):
    def __init__(self, n_vocab, embedding_dim, hidden_dim, dropout=0.2):
        super(Net, self).__init__()

        self.embedding_dim = embedding_dim
        self.hidden_dim = hidden_dim

        # nn.Embedding 可以幫我們建立好字典中每個字對應的 vector
        self.embeddings = nn.Embedding(n_vocab, embedding_dim)

        # LSTM layer，形狀為 (input_size, hidden_size, ...)
        self.lstm = nn.LSTM(embedding_dim, hidden_dim, dropout=dropout)

        # Fully-connected layer，把 hidden state 線性轉換成 output
        self.hidden2out = nn.Linear(hidden_dim, n_vocab)

    def forward(self, seq_in):
        # LSTM 接受的 input 形狀為 (timesteps, batch, features)，即 (seq_length, batch_size, embedding_dim)
        # 所以先把形狀為 (batch_size, seq_length) 的 input 轉置後，再把每個 value (char index) 轉成 embedding vector
        embeddings = self.embeddings(seq_in.t())

        # LSTM 層的 output (lstm_out) 有每個 timestep 出來的結果（也就是每個字進去都會輸出一個 hidden state）
        # 這邊我們取最後一層的結果，即最近一次的結果，來預測下一個字
        lstm_out, _ = self.lstm(embeddings)
        ht = lstm_out[-1]

        # 線性轉換至 output
        out = self.hidden2out(ht)

        return out

def train(model, optimizer, epoch, data, log_interval):
    # 設一下 flag
    model.train()

    # Mini-batch 訓練 
    for batch_i, (seq_in, target) in enumerate(data):
        seq_in, target = Variable(seq_in), Variable(target)
        optimizer.zero_grad()

        output = model(seq_in)                      # 取得預測
        loss = F.cross_entropy(output, target)      # 計算 loss
        loss.backward()                             # Backpropagation
        optimizer.step()                            # 更新參數

        # Log 訓練進度
        if batch_i % log_interval == 0:
            print('Train epoch: {} ({:2.0f}%)\tLoss: {:.6f}'.format(epoch, 100. * batch_i / len(data), loss.data[0]))

# 載入資料，建立模型
train_data, dataX, dataY, char_to_int, int_to_char, chars = load_data(args.corpus, seq_length=args.seq_length, batch_size=args.batch_size)
model = Net(len(chars), args.embedding_dim, args.hidden_dim, dropout=args.dropout)
optimizer = torch.optim.Adam(model.parameters(), lr=args.lr)

# 訓練
for epoch in range(args.epochs):
    train(model, optimizer, epoch, train_data, log_interval=args.log_interval)

    # 為避免不可抗力因素造成訓練中斷，或訓練太久失去耐心，每幾個 epoch 就儲存一次模型
    if (epoch + 1) % args.save_interval == 0:
        model.eval()
        torch.save(model, args.output)

数人民的政策，而不是为了这个人民的，是一个人民的工作，我们的工作是一个人的一个具体的工作，我们的工作是一个人，这是一个人的时候，我们就要使他们在革命中国的人民主要关系，不是要经过这种情况，在社会主义制度和国家政治工作作风，不能用正确的方法去解决。这是一个人民的政策，而是在全国的领导机关，不是为着我们的民主主义，是一个革命的政策，而是在全国的人民主要的，是在革命的政治上，在一个人民内部的矛盾，是一个人民的工作，我们的工作是一个人的一个具体的工作，我们的工作是一个人，这是一个人口作为一个革命的政策，而是在全国的领导机关，不是为着我们的民主主义，是一个革命的政策，而是在全国的人民主要的，是在革命的政治上，在一个人民内部的矛盾，是一个人民的工作，我们的工作是一个人的一个具体的工作，我们的工作是一个人，这是一个人口作为一个革命的政策...

# 隨機選擇一序列作為開端
start = np.random.randint(0, n_patterns - 1)
pattern = patterns[start]

# 共 n_sent 句子要生成
cnt = 0
while cnt < n_sent: 
    # 包一下 input
    seq_in = np.array(pattern)
    seq_in = seq_in.reshape(1, -1) # batch_size = 1

    seq_in = Variable(torch.LongTensor(seq_in))

    # 生成此序列下一個字
    pred = model(seq_in)
    pred = to_prob(F.softmax(pred).data[0].numpy()) # softmax 後轉成機率分佈
    char = np.random.choice(chars, p=pred)          # 依機率分佈選字
    char_idx = char_to_int[char]

    # 印出
    print(char, end='')

    # 將字附在原序列後並移除第一個字，作為下一個 input 序列
    pattern.append(char_idx)
    pattern = pattern[1:]

    # 若印出代表句子結尾的標點符號，則完成一個句子生成
    if is_end(char):
        # restart_seq 決定要不要重新挑選一個序列，或是完成一個完整段落
        if restart_seq:
            start = np.random.randint(0, n_patterns - 1)
            pattern = patterns[start]
            print()

        cnt += 1 

在战争中否坚决地实行和全体生活的形势是错误的，那一世界有特点的人们想不另一时，愿意的指导、非英时、半成大党的估计。按照这个人，若不重视显极，而是使他们取得胜利。我也一定要君子使国家吗？可以白有的大子加制，使使他服长。难道这怎么能短良呢？则我早上怎这么样？说得到太的觉多了没才会名季厌。恶—那样里来不会自六方），不奏怨恨，我敢不敬，言语他的推子。君子恭敬仁义。帝国主义已经：说多了，不可见变愿意十五，即后，一战不能打干，就自以只是在那类里的自线之养。

智的诸侯了，天下的交朝吗？有礼有制度，然后却是殷容易听了。马克思列宁主义者，要学习端木不是教别的方法，不可以说出发死的。了符合的主义形规定的就是无不理的，还有一问当，最简如见同同志同民族领导、干部、活化，相间工互来关头党的整风。但是还每一个整一个新干部，要看教育内部同统权力更等、干部其、活庭和巩固群众。这不是尊重那个问题，就要说弄个根据，不作任何由统一的斗争。但是在我国现在资本主义的剥削和共产党，不是很好地接受社会主义的工作方向。每一个基本作用外，结果有一个专于战役它。党的政治任务对于行动；（要有几先之礼，几然年，不允动地也会必要要使拒主观愿意。十岁伟大还有中国历史这种具体这要的。

争，我们会主义和平国，而没有把国的人和厌恶。这样的人不宽易。君子，却没有正确的思德，就是学会了一次来中这样的吗？一个有人一天要看到，一个同志也不可以认真，如果不任用所保留的人，去用仁德守住，就是孝从鬼神神，到这样微了。在练兵，都思考情齐智百了，就不说，该容易作等；学斗争取青，不给以那就不去，全年的才能。以发挥为杀王的不能不会得彻底，他来不可以做；不而不上与，拿着我们，也将他打民主观。一定要说是不安的；言论周别的人对亲下，不吃肉，不吃。当然而推举，拿受蒋介石的圣人。宰查回果是什么事了，可以让他自己高兴的事，小人批评。不说话，这是反而不是孝悌。

In 1918, I am the warfare. The struggle of civilization. The only answer to absolute liberty is the destruction of the nations.

In the wrong virtue of people, to control every point the intention of love is to demand the supremacy of the United States.

The British people will be sad with the progressing of the United States. Distrust the economy.