智能写作​

智能写作​

• • 现成工具：GPT - 3
  • 智能取名
  • • 恐龙起名哪家强？
  • 智能写诗
  • • 为啥林黛玉那么小就会写诗了？用诗词模板，你上你也行！
    • • 对仗 —— 词性相同，声调相反
      • 押韵和换韵
      • 音律结构 —— 平仄结构交替出现

 

---

智能写作，指人工智能模型自己能根据一定的条件或者是无任何条件下自由地生成内容。

因为很多文章的写作都需要投入不小的精力，但是阅读量却非常小，这样的内容投入产出效率就比较低。

这部分内容如果用机器来创作的话，成本就会比人来写小很多。

比如今日头条开发的写作机器人开始时是做奥运比赛的报道，把实时的比分、图片、热门比赛的文字直播结合起来生成对应文章，后来延伸到了包括更多的体育赛事、房产新闻以及国际热点新闻的报道。

我们让计算机写文章，可以直接用现成的工具 GPT-3，也可以自己训练模型来实现。
 

---

现成工具：GPT - 3

比如问 GPT-3：你对股票市场是怎么看的？

• What are your thoughts about the stock market?

GPT-3 自动生成的结果是这样的：

比如，让 GPT-3 根据命题 “上 Twitter 的重要性” 为题，做分析：

文章有观点、有立场、有理有据，符合逻辑，和真人写出来的没什么差异。

······

使用 GPT-3 前，必须要先取得Open AI 授与的 API Secret key。

可以用下面的连接申请，填完表以后，等待Open AI 的邀请（我等了三个月）。

• https://forms.office.com/Pages/ResponsePage.aspx?id=VsqMpNrmTkioFJyEllK8s0v5E5gdyQhOuZCXNuMR8i1UQjFWVTVUVEpGNkg3U1FNRDVVRFg3U0w4Vi4u

获邀以后，就可用下面的连接注册，然后取得你的API Secret key。

• https://beta.openai.com/

有了API Secret key就可用编程，比如给一个开头语：Once upon a time（很久以前），让 GPT-3说故事。

使用 GPT-3时，有两个变数可用：模式和温度。

• 模式有四种选择 ：ada、babbage、curie、davinci，通常davinci 是最好的选择。
• 温度是用来决定创意，数字越大表示文字的创造力越强。

温度 0.0

• Once upon a time, there was a little girl who was very sad. She was sad because she had no friends. She was sad because she had no one to play with. She was sad because she had no one to talk to. She was sad because she had no one to love.

温度 1.2

• Once upon a time, I moved from Ukraine to London. The journey is supposed to be a very difficult one: 24 hours of travelling in opposite direction and time changes of 2 hours. The border is different too: from Europe into the EFTA countries is like entering a different continent. All the signs, money and communication seemed to be in a new language. But, I actually managed to arrive on a new country calmly: 0 defeats, no panic attacks or anxiety. It all happened thanks to Orto (Arktan2) and his absolutely great methods.

······

其实，GPT-3 支持中文。

一个最好的参考网站就是 GPT-3 Demo：https://gpt3demo.com/。

人工智能文案（AI Copywriting）是目前人们在 GPT-3 上用的最多的一个商业应用，在 GPT-3 Demo 中就有 34 个产品。这些商业应用产品绝大部分是要付费的，但是它们也提供免费的试用期间。

在 34 个人工智能文案产品中，有三个产品强烈推荐：

• Jarvis：https://app.jarvis.ai/signup?fpr=early-bird

• CopyAI：https://www.copy.ai/?via=rajupp

• Shortly AI：https://shortlyai.com/?fp_ref=earlybird

比如，用上面的 CopyAI 给另一半写生日快乐的文稿：

• 你一直是我生命中快乐和欢笑的源泉。有你在我的生命中，我感到非常幸运。我想让你知道，我感谢你为我所做的一切。你是我生命中最耀眼的明星，生日快乐。

• 今天是你的生日。我真诚地祝愿你幸福和健康。希望你能得到生活中所有最好的东西。

• 我没有什么可说的了，只是说我爱你胜过一切！。愿你的生日充满一生的幸福。

• 你一直是我的力量支柱，在我需要你的支持时，你从未怀疑过我。没有你，我将一事无成。我祈祷上帝继续将他的祝福洒在你身上。生日快乐!
   

---

智能取名

恐龙起名哪家强？

实现一个为恐龙起名的程序，这个程序是一个字（母）级别的 RNN 模型，也就是 RNN 的每个时间步只输出一个字（母）。

训练模型前，我们需要爬取一些恐龙的名字，像霸王龙（Tyrannosaurus）、迅猛龙（Velociraptor）。

• 恐龙名字数据集：https://download.csdn.net/download/qq_41739364/29744801

直接秀代码吧 — 以下是项目完整代码（自定义工具模块 + 项目代码模块）。

自定义工具模块：

# utils.py
import numpy as np

def softmax(x):
    e_x = np.exp(x - np.max(x))
    return e_x / e_x.sum(axis=0)

def smooth(loss, cur_loss):
    return loss * 0.999 + cur_loss * 0.001

def print_sample(sample_ix, ix_to_char):
    txt = ''.join(ix_to_char[ix] for ix in sample_ix)
    txt = txt[0].upper() + txt[1:]   
    print ('%s' % (txt, ), end='')

def get_initial_loss(vocab_size, seq_length):
    return -np.log(1.0/vocab_size)*seq_length

def softmax(x):
    e_x = np.exp(x - np.max(x))
    return e_x / e_x.sum(axis=0)

def initialize_parameters(n_a, n_x, n_y):
    np.random.seed(1)
    Wax = np.random.randn(n_a, n_x)*0.01 
    Waa = np.random.randn(n_a, n_a)*0.01 
    Wya = np.random.randn(n_y, n_a)*0.01 
    b = np.zeros((n_a, 1)) 
    by = np.zeros((n_y, 1)) 
    
    parameters = {"Wax": Wax, "Waa": Waa, "Wya": Wya, "b": b,"by": by}
    
    return parameters

def rnn_step_forward(parameters, a_prev, x):
    Waa, Wax, Wya, by, b = parameters['Waa'], parameters['Wax'], parameters['Wya'], parameters['by'], parameters['b']
    a_next = np.tanh(np.dot(Wax, x) + np.dot(Waa, a_prev) + b) # hidden state
    p_t = softmax(np.dot(Wya, a_next) + by)
    
    return a_next, p_t

def rnn_step_backward(dy, gradients, parameters, x, a, a_prev):
    gradients['dWya'] += np.dot(dy, a.T)
    gradients['dby'] += dy
    da = np.dot(parameters['Wya'].T, dy) + gradients['da_next'] 
    daraw = (1 - a * a) * da 
    gradients['db'] += daraw
    gradients['dWax'] += np.dot(daraw, x.T)
    gradients['dWaa'] += np.dot(daraw, a_prev.T)
    gradients['da_next'] = np.dot(parameters['Waa'].T, daraw)
    return gradients

def update_parameters(parameters, gradients, lr):
    parameters['Wax'] += -lr * gradients['dWax']
    parameters['Waa'] += -lr * gradients['dWaa']
    parameters['Wya'] += -lr * gradients['dWya']
    parameters['b']  += -lr * gradients['db']
    parameters['by']  += -lr * gradients['dby']
    return parameters

def rnn_forward(X, Y, a0, parameters, vocab_size = 27):
    x, a, y_hat = {}, {}, {}
    a[-1] = np.copy(a0)
    loss = 0
    
    for t in range(len(X)):
        x[t] = np.zeros((vocab_size,1)) 
        if (X[t] != None):
            x[t][X[t]] = 1
        
        a[t], y_hat[t] = rnn_step_forward(parameters, a[t-1], x[t])
        
        loss -= np.log(y_hat[t][Y[t],0])
        
    cache = (y_hat, a, x)
        
    return loss, cache

def rnn_backward(X, Y, parameters, cache):
    gradients = {}
    
    (y_hat, a, x) = cache
    Waa, Wax, Wya, by, b = parameters['Waa'], parameters['Wax'], parameters['Wya'], parameters['by'], parameters['b']
    
    gradients['dWax'], gradients['dWaa'], gradients['dWya'] = np.zeros_like(Wax), np.zeros_like(Waa), np.zeros_like(Wya)
    gradients['db'], gradients['dby'] = np.zeros_like(b), np.zeros_like(by)
    gradients['da_next'] = np.zeros_like(a[0])
    
    for t in reversed(range(len(X))):
        dy = np.copy(y_hat[t])
        dy[Y[t]] -= 1
        gradients = rnn_step_backward(dy, gradients, parameters, x[t], a[t], a[t-1])
    
    return gradients, a
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

项目代码：

import numpy as np
from utils import *  
import random

data = open('dinos.txt', 'r').read() 
data = data.lower()
chars = list(set(data))
data_size, vocab_size = len(data), len(chars) 
char_to_ix = { ch:i for i,ch in enumerate(sorted(chars)) } 
ix_to_char = { i:ch for i,ch in enumerate(sorted(chars)) }  

# 梯度值裁剪函数
def clip(gradients, maxValue): 
    dWaa, dWax, dWya, db, dby = gradients['dWaa'], gradients['dWax'], gradients['dWya'], gradients['db'], gradients['dby']
    for gradient in [dWax, dWaa, dWya, db, dby]:
        np.clip(gradient, -maxValue, maxValue, out=gradient)   
    gradients = {"dWaa": dWaa, "dWax": dWax, "dWya": dWya, "db": db, "dby": dby}
    return gradients

np.random.seed(3)
dWax = np.random.randn(5,3)*10
dWaa = np.random.randn(5,5)*10
dWya = np.random.randn(2,5)*10
db = np.random.randn(5,1)*10
dby = np.random.randn(2,1)*10
gradients = {"dWax": dWax, "dWaa": dWaa, "dWya": dWya, "db": db, "dby": dby}
gradients = clip(gradients, 10)

# 采样函数
def sample(parameters, char_to_ix, seed):
    Waa, Wax, Wya, by, b = parameters['Waa'], parameters['Wax'], parameters['Wya'], parameters['by'], parameters['b']
    vocab_size = by.shape[0] 
    n_a = Waa.shape[1]
    x = np.zeros((vocab_size, 1))
    a_prev = np.zeros((n_a, 1))
    indices = []
    idx = -1 
    counter = 0
    newline_character = char_to_ix['\n'] 
    
    while (idx != newline_character and counter != 50):
        a = np.tanh(np.dot(Wax, x) + np.dot(Waa, a_prev) + b)
        z = np.dot(Wya, a) + by
        y = softmax(z)     
        np.random.seed(counter + seed) 
        idx = np.random.choice(list(range(vocab_size)), p=y.ravel())
        indices.append(idx)
        x = np.zeros((vocab_size, 1))
        x[idx] = 1  
        a_prev = a
        seed += 1
        counter +=1

    if (counter == 50):
        indices.append(char_to_ix['\n'])
    return indices

np.random.seed(2)
_, n_a = 20, 100
Wax, Waa, Wya = np.random.randn(n_a, vocab_size), np.random.randn(n_a, n_a), np.random.randn(vocab_size, n_a)
b, by = np.random.randn(n_a, 1), np.random.randn(vocab_size, 1)
parameters = {"Wax": Wax, "Waa": Waa, "Wya": Wya, "b": b, "by": by}
indices = sample(parameters, char_to_ix, 0)

# 优化函数
def optimize(X, Y, a_prev, parameters, learning_rate = 0.01):
    loss, cache = rnn_forward(X, Y, a_prev, parameters)
    gradients, a = rnn_backward(X, Y, parameters, cache)
    gradients = clip(gradients, 5)
    parameters = update_parameters(parameters, gradients, learning_rate)
    return loss, gradients, a[len(X)-1]

np.random.seed(1)
vocab_size, n_a = 27, 100
a_prev = np.random.randn(n_a, 1)
Wax, Waa, Wya = np.random.randn(n_a, vocab_size), np.random.randn(n_a, n_a), np.random.randn(vocab_size, n_a)
b, by = np.random.randn(n_a, 1), np.random.randn(vocab_size, 1)
parameters = {"Wax": Wax, "Waa": Waa, "Wya": Wya, "b": b, "by": by}
X = [None,3,5,11,22,3]
Y = [3,5,11,22,3,0]
loss, gradients, a_last = optimize(X, Y, a_prev, parameters, learning_rate = 0.01)

def model(ix_to_char, char_to_ix, num_iterations = 35000, n_a = 50, dino_names = 7, vocab_size = 27):
    n_x, n_y = vocab_size, vocab_size
    parameters = initialize_parameters(n_a, n_x, n_y)
    loss = get_initial_loss(vocab_size, dino_names)
    with open("dinos.txt") as f:
        examples = f.readlines()
        
    examples = [x.lower().strip() for x in examples]
    np.random.seed(0)
    np.random.shuffle(examples)
    a_prev = np.zeros((n_a, 1))
    
    for j in range(num_iterations):
        index = j % len(examples) 
        X = [None] + [char_to_ix[ch] for ch in examples[index]] 
        Y = X[1:] + [char_to_ix["\n"]] 
        
        curr_loss, gradients, a_prev = optimize(X, Y, a_prev, parameters)
        loss = smooth(loss, curr_loss)
        
        if j % 2000 == 0:
            print('Iteration: %d, Loss: %f' % (j, loss) + '\n')
            seed = 0
            for name in range(dino_names): 
                sampled_indices = sample(parameters, char_to_ix, seed)
                print_sample(sampled_indices, ix_to_char)
                seed += 1
            print('\n')
    return parameters

parameters = model(ix_to_char, char_to_ix)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

随着训练次数的增加，生成的字符串越来越像名字了。

Mawspichaniaekorocimamroberax
Inda
Itrus
Macaesis
Wrosaurus
Elaeosaurus
Stegngosaurus
1
2
3
4
5
6
7

如最后生成的名字 Elaeosaurus（埃莱奥龙），看起来智能取名效果还是很符合的。
 

---

智能写诗

智能写诗、智能起名其实大同小异。

智能起名的数据集是恐龙的名字，而智能写诗的数据集是一些莎士比亚的诗歌。

• 莎士比亚诗歌数据集：https://download.csdn.net/download/qq_41739364/29796311

在智能写诗的模型中，要使用了 LSTM 单元。

上面的智能取名因为名字很短，所以不需要 RNN 有很长的记忆，但是诗歌会很长，所以需要 LSTM 来增强 RNN 的记忆力。

大体步骤和智能取名差不多（使用了LSTM、2层神经网络），用 Keras 实现了即可。

完整项目代码 = 自定义工具模块 + 项目代码。

自定义工具模块：

from __future__ import print_function
from keras.callbacks import LambdaCallback
from keras.models import Model, load_model, Sequential
from keras.layers import Dense, Activation, Dropout, Input, Masking
from keras.layers import LSTM
from keras.utils.data_utils import get_file
from keras.preprocessing.sequence import pad_sequences
import numpy as np
import random
import sys
import io

def build_data(text, Tx = 40, stride = 3):
    X = []
    Y = []

    for i in range(0, len(text) - Tx, stride):
        X.append(text[i: i + Tx])
        Y.append(text[i + Tx])
    
    print('number of training examples:', len(X))
    
    return X, Y


def vectorization(X, Y, n_x, char_indices, Tx = 40):
    m = len(X)
    x = np.zeros((m, Tx, n_x), dtype=np.bool)
    y = np.zeros((m, n_x), dtype=np.bool)
    for i, sentence in enumerate(X):
        for t, char in enumerate(sentence):
            x[i, t, char_indices[char]] = 1
        y[i, char_indices[Y[i]]] = 1
        
    return x, y 

def sample(preds, temperature=1.0):
    preds = np.asarray(preds).astype('float64')
    preds = np.log(preds) / temperature
    exp_preds = np.exp(preds)
    preds = exp_preds / np.sum(exp_preds)
    probas = np.random.multinomial(1, preds, 1)
    out = np.random.choice(range(len(chars)), p = probas.ravel())
    return out
    
def on_epoch_end(epoch, logs):
    None
    
print("Loading text data...")
text = io.open('shakespeare.txt', encoding='utf-8').read().lower()

Tx = 40
chars = sorted(list(set(text)))
char_indices = dict((c, i) for i, c in enumerate(chars))
indices_char = dict((i, c) for i, c in enumerate(chars))

print("Creating training set...")
X, Y = build_data(text, Tx, stride = 3)
print("Vectorizing training set...")
x, y = vectorization(X, Y, n_x = len(chars), char_indices = char_indices) 
print("Loading model...")
model = load_model('models/model_shakespeare_kiank_350_epoch.h5')

def generate_output():
    generated = ''
    usr_input = input("Write the beginning of your poem, the Shakespeare machine will complete it. Your input is: ")
    sentence = ('{0:0>' + str(Tx) + '}').format(usr_input).lower()
    generated += usr_input 

    sys.stdout.write("\n\nHere is your poem: \n\n") 
    sys.stdout.write(usr_input)
    for i in range(400):
        x_pred = np.zeros((1, Tx, len(chars)))

        for t, char in enumerate(sentence):
            if char != '0':
                x_pred[0, t, char_indices[char]] = 1.

        preds = model.predict(x_pred, verbose=0)[0]
        next_index = sample(preds, temperature = 1.0)
        next_char = indices_char[next_index]

        generated += next_char
        sentence = sentence[1:] + next_char

        sys.stdout.write(next_char)
        sys.stdout.flush()

        if next_char == '\n':
            continue
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

项目代码：

from __future__ import print_function
from keras.callbacks import LambdaCallback
from keras.models import Model, load_model, Sequential
from keras.layers import Dense, Activation, Dropout, Input, Masking
from keras.layers import LSTM
from keras.utils.data_utils import get_file
from keras.preprocessing.sequence import pad_sequences
from shakespeare_utils import *
import sys
import io

print_callback = LambdaCallback(on_epoch_end=on_epoch_end)

model.fit(x, y, batch_size=128, epochs=1, callbacks=[print_callback])

generate_output()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

输出诗歌：

Write the beginning of your poem, the Shakespeare machine will complete it. Your input is: I love porn movie 

Here is your poem: 

I love porn movie so,
it well as atle, time minke westerst goon.

which i mat anthand home drechats, on the doars, filfing,
which ach a tissungoels not thine assu, not richains ever't noh,
that-igowedss nets-ow i tompline thou bet.

as twat thee someres, un flool time me,
if bore withtthed of hoth bate with glot,
and high not love, beaution of dony bind whice,
whose the latder laogeng nat threald my elose,
vide str
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

 

---

为啥林黛玉那么小就会写诗了？用诗词模板，你上你也行！

对仗 —— 词性相同，声调相反

现代汉语拼音声调分为四种：一声、二声、三声、四声。

其中一声、二声统称平声，三声、四声统称仄声。

写诗时，处于对仗关系的词，词性要相同，即名词对名词，动词对动词；声调要相反，平声对仄声，但不用每个字的平仄都相对，只要注意重音位置的字就好（每一句的偶数位置的字和最后一个字属于重音位置）。

比如：“风急天高猿啸哀，渚清沙白鸟飞回。”

押韵和换韵

古代的四声系统和今天并不一样。

从六朝到隋唐，四声分别是平声、上声、去声、入声。

其中平声可以分为阴平和阳平，对应着普通话里的一声和二声，上声和去声对应着普通话里的三声和四声，入声在普通话里消失了，原来读入声的字今天读什么声调的都有，所以古代诗词里边押入声韵的那些，在今天读起来经常让人感觉不押韵。

上声、去声、入声都算仄声，但是，只有上声字和去声字可以混用，入声字在不做韵脚的时候，一般可以和上声字、去声字混用，但用做韵脚的话，它就成为单独的一个系统，不再能和上声字、去声字混用了。

比如李白的诗《春日独坐寄郑明府》：

燕麦青青游子悲，河堤弱柳郁金枝。

长条一拂春风去，尽日飘扬无定时。

我在河南别离久，那堪坐此对窗牖。

情人道来竟不来，何人共醉新丰酒。

前四句里，第一、二、四句押韵，韵脚分别是悲、枝、时，这三个字在唐朝的读音里不但属于同一个韵母，还都是平声字。

接下来，第五、六、八句押韵，韵脚分别是久、牖、酒，不但换了韵脚，还换成仄声韵。这样的写法叫做换韵。

换韵一般以四句为一组，每组一换韵，每组里边只有第三句不押韵。如果还往下写，就继续遵循这个规则，在换韵的时候，一般都会平声韵和仄声韵不断交替，这样才好听。

当然，一韵到底也可以，但这样的话就要留意两点：一来单数位置的句子，除了第一句既可以押韵也可以不押韵之外，都不能押韵；二来韵脚要么都是平声字，要么都是仄声字，不能混着用。

音律结构 —— 平仄结构交替出现

在诗句的关系上，第二句和第一句的平仄结构相反，这叫“对”，第三句和第二句的平仄结构相同，这叫“粘（nián）”。

而后第四句和第三句“对”，第五句和第四句“粘”，以此类推，这就是近体诗最基本的音律结构。

用杜甫的《春望》来做例子：

国破山河在，城春草木深。

感时花溅泪，恨别鸟惊心。

烽火连三月，家书抵万金。

白头搔更短，浑欲不胜（shēng）簪。

• 第一句“国破山河在”，这是“仄仄平平仄”，“国”是仄声字，和今天不一样；
• 第二句“城春草木深”，这是“平平仄仄平”，和前一句的关系是“对”；
• 第三句“感时花溅泪”，前四个字“感时花溅”要和上一句的前四个字“城春草木”平仄结构相同，这是“粘”，但“泪”必须是仄声。
• 第四句 “恨别鸟惊心”，“仄仄仄平平”，与前一句关系是“对”。
• 第五句“烽火连三月”，“仄仄平平仄”，和第四句的关系是“粘”，但最后一个字需要仄声。
• 第六句“家书抵万金”，“平平仄仄平”，和上一句的关系是“对”；
• 第七句“白头搔更短”要和第六句“粘”；
• 第八句“浑欲不胜簪”和上一句“对”。

理解了这个模式，咱们就可以写格律诗了。