• 词向量的运算与Emoji生成器

    本文参考参考，没有对框架内容进行学习，旨在学习思路和方法。

    1、词向量运算

           之前学习RNN和LSTM的时候，输入的语句都是一个向量，比如恐龙的名字那个例子就是将一个单词中的字母按顺序依次输入，这对于一个单词的预测是可行的。但是对于想让机器学习到一个句子的意思那就不行了，它需要知道每个单词的意思，而且还需要知道单词连起来的意思，这时候输入到网络中的单位就不是字母了，应该是按单词来输入。这时候问题就来了，单词该如何输入到网络之中。有人将很多单词训练成为了词嵌入数据，每个单词对应一个50维的向量。

           使用别人造好的轮子载入：可以看到单词hello对应的词向量。word_to_vec_map是单词到词向量的映射字典

    1. words, word_to_vec_map = w2v_utils.read_glove_vecs('data/glove.6B.50d.txt')
    2. print(word_to_vec_map['hello'])
    3.  
    4. """
    5. [-0.38497   0.80092   0.064106 -0.28355  -0.026759 -0.34532  -0.64253
    6.  -0.11729  -0.33257   0.55243  -0.087813  0.9035    0.47102   0.56657
    7.   0.6985   -0.35229  -0.86542   0.90573   0.03576  -0.071705 -0.12327
    8.   0.54923   0.47005   0.35572   1.2611   -0.67581  -0.94983   0.68666
    9.   0.3871   -1.3492    0.63512   0.46416  -0.48814   0.83827  -0.9246
    10.  -0.33722   0.53741  -1.0616   -0.081403 -0.67111   0.30923  -0.3923
    11.  -0.55002  -0.68827   0.58049  -0.11626   0.013139 -0.57654   0.048833
    12.   0.67204 ]
    13. """

           那该如何去对比两个单词的近似程度呢？这里就引入了余弦相似度。越相似，余弦值越接近1，否则越接近0

    1. def cosine_similarity(u, v):
    2.     """
    3.     u与v的余弦相似度反映了u与v的相似程度
    4.     
    5.     参数：
    6.         u -- 维度为(n,)的词向量
    7.         v -- 维度为(n,)的词向量
    8.         
    9.     返回：
    10.         cosine_similarity -- 由上面公式定义的u和v之间的余弦相似度。
    11.     """
    12.     distance = 0
    13.     
    14.     # 计算u与v的内积
    15.     dot = np.dot(u, v)
    16.     
    17.     #计算u的L2范数
    18.     norm_u = np.sqrt(np.sum(np.power(u, 2)))
    19.     
    20.     #计算v的L2范数
    21.     norm_v = np.sqrt(np.sum(np.power(v, 2)))
    22.     
    23.     # 根据公式1计算余弦相似度
    24.     cosine_similarity = np.divide(dot, norm_u * norm_v)
    25.     
    26.     return cosine_similarity
    1. father = word_to_vec_map["father"]
    2. mother = word_to_vec_map["mother"]
    3. ball = word_to_vec_map["ball"]
    4. crocodile = word_to_vec_map["crocodile"]
    5. france = word_to_vec_map["france"]
    6. italy = word_to_vec_map["italy"]
    7. paris = word_to_vec_map["paris"]
    8. rome = word_to_vec_map["rome"]
    9.  
    10. print("cosine_similarity(father, mother) = ", cosine_similarity(father, mother))
    11. print("cosine_similarity(ball, crocodile) = ",cosine_similarity(ball, crocodile))
    12. print("cosine_similarity(france - paris, rome - italy) = ",cosine_similarity(france - paris, rome - italy))
    13.  
    14. """
    15. cosine_similarity(father, mother) =  0.8909038442893615
    16. cosine_similarity(ball, crocodile) =  0.27439246261379424
    17. cosine_similarity(france - paris, rome - italy) =  -0.6751479308174202
    18. """

           上面是两个词之间的相似程度计算，那词类类比该如何计算。 形如A与B相比就类似于C与____相比一样，这里计算的就是差值之间的余弦相似度。这种类比需要去遍历词库来寻找最大的相似度。

    1. def complete_analogy(word_a, word_b, word_c,word_to_vec_map):
    2.     # 把单词转换为小写
    3.     word_a, word_b, word_c = word_a.lower(), word_b.lower(), word_c.lower()
    4.     # 获取对应单词的词向量
    5.     e_a, e_b, e_c = word_to_vec_map[word_a], word_to_vec_map[word_b], word_to_vec_map[word_c]
    6.     
    7.     # 获取全部的单词
    8.     words = word_to_vec_map.keys()
    9.     
    10.     # 将max_cosine_sim初始化为一个比较大的负数
    11.     max_cosine_sim = -100
    12.     best_word = None
    13.     
    14.     # 遍历整个数据集
    15.     for word in words:
    16.         # 要避免匹配到输入的数据
    17.         if word in [word_a, word_b, word_c]:
    18.             continue
    19.         # 计算余弦相似度
    20.         cosine_sim = cosine_similarity((e_b - e_a), (word_to_vec_map[word] - e_c))
    21.         
    22.         if cosine_sim > max_cosine_sim:
    23.             max_cosine_sim = cosine_sim
    24.             best_word = word
    25.             
    26.     return best_word
    1. triads_to_try = [('italy', 'italian', 'spain'), ('india', 'delhi', 'japan'), ('man', 'woman', 'boy'), ('small', 'smaller', 'large')]
    2. for triad in triads_to_try:
    3.     print ('{} -> {} <====> {} -> {}'.format( *triad, complete_analogy(*triad,word_to_vec_map)))
    4.  
    5. """
    6. italy -> italian <====> spain -> spanish
    7. india -> delhi <====> japan -> tokyo
    8. man -> woman <====> boy -> girl
    9. small -> smaller <====> large -> larger
    10. """

           消除与性别无关的词汇的偏差：有很多词是与性别没有关系的比如reception，但是在实际的比较中却给予了相关性，这就要求消除这种偏差。做法就是将需要计算的词向量向相关轴投影，然后减去该投影就消除了偏差

    1. def neutralize(word, g, word_to_vec_map):
    2.     """
    3.     通过将“word”投影到与偏置轴正交的空间上，消除了“word”的偏差。
    4.     该函数确保“word”在性别的子空间中的值为0
    5.     
    6.     参数：
    7.         word -- 待消除偏差的字符串
    8.         g -- 维度为(50,)，对应于偏置轴（如性别）
    9.         word_to_vec_map -- 字典类型，单词到GloVe向量的映射
    10.         
    11.     返回：
    12.         e_debiased -- 消除了偏差的向量。
    13.     """
    14.     
    15.     # 根据word选择对应的词向量
    16.     e = word_to_vec_map[word]
    17.     
    18.     # 根据公式2计算e_biascomponent
    19.     e_biascomponent = np.divide(np.dot(e, g), np.square(np.linalg.norm(g))) * g
    20.     
    21.     # 根据公式3计算e_debiased
    22.     e_debiased = e - e_biascomponent
    23.     
    24.     return e_debiased
    1. e = "receptionist"
    2. print("去偏差前{0}与g的余弦相似度为：{1}".format(e, cosine_similarity(word_to_vec_map["receptionist"], g)))
    3.  
    4. e_debiased = neutralize("receptionist", g, word_to_vec_map)
    5. print("去偏差后{0}与g的余弦相似度为：{1}".format(e, cosine_similarity(e_debiased, g)))
    6.  
    7. """
    8. e = "receptionist"
    9. print("去偏差前{0}与g的余弦相似度为：{1}".format(e, cosine_similarity(word_to_vec_map["receptionist"], g)))
    11. e_debiased = neutralize("receptionist", g, word_to_vec_map)
    12. print("去偏差后{0}与g的余弦相似度为：{1}".format(e, cosine_similarity(e_debiased, g)))
    13. """

    2、 表情生成器

           所谓表情生成器就是根据我们输入的语句来生成相对应的表情。比如：“Congratulations on the promotion! ? Lets get coffee and talk. ☕️ Love you! ❤️”。

           练习中构建的一个简单的分类器，数据集（X，Y），X是127条字符串类型的短句子，Y是对应的（0-4）5个标签。测试集总共有56条数据。

    1. X_train, Y_train = emo_utils.read_csv('data/train_emoji.csv')
    2. X_test, Y_test = emo_utils.read_csv('data/test.csv')
    3.  
    4. maxLen = len(max(X_train, key=len).split())
    5.  
    6. index  = 3
    7. print(X_train[index], emo_utils.label_to_emoji(Y_train[index]))
    8.  
    9. """
    10. Miss you so much ❤️
    11. """

            在模型上输入是将所有的单词的向量相加求均值然后作为输入输入到模型当中，然后将输入和权重相乘激活。

    1. def sentence_to_avg(sentence, word_to_vec_map):
    2.     """
    3.     将句子转换为单词列表，提取其GloVe向量，然后将其平均。
    4.     
    5.     参数：
    6.         sentence -- 字符串类型，从X中获取的样本。
    7.         word_to_vec_map -- 字典类型，单词映射到50维的向量的字典
    8.         
    9.     返回：
    10.         avg -- 对句子的均值编码，维度为(50,)
    11.     """
    12.     
    13.     # 第一步：分割句子，转换为列表。
    14.     words = sentence.lower().split()
    15.     
    16.     # 初始化均值词向量
    17.     avg = np.zeros(50,)
    18.     
    19.     # 第二步：对词向量取平均。
    20.     for w in words:
    21.         avg += word_to_vec_map[w]
    22.     avg = np.divide(avg, len(words))
    23.     
    24.     return avg

    要注意和权重相乘时是求的内积，所以维度会不匹配。

    1. def model(X, Y, word_to_vec_map, learning_rate=0.01, num_iterations=400):
    2.     """
    3.     在numpy中训练词向量模型。
    4.     
    5.     参数：
    6.         X -- 输入的字符串类型的数据，维度为(m, 1)。
    7.         Y -- 对应的标签，0-7的数组，维度为(m, 1)。
    8.         word_to_vec_map -- 字典类型的单词到50维词向量的映射。
    9.         learning_rate -- 学习率.
    10.         num_iterations -- 迭代次数。
    11.         
    12.     返回：
    13.         pred -- 预测的向量，维度为(m, 1)。
    14.         W -- 权重参数，维度为(n_y, n_h)。
    15.         b -- 偏置参数，维度为(n_y,)
    16.     """
    17.     np.random.seed(1)
    18.     
    19.     # 定义训练数量
    20.     m = Y.shape[0]
    21.     n_y = 5
    22.     n_h = 50
    23.     
    24.     # 使用Xavier初始化参数
    25.     W = np.random.randn(n_y, n_h) / np.sqrt(n_h)
    26.     b = np.zeros((n_y,))
    27.     
    28.     # 将Y转换成独热编码
    29.     Y_oh = emo_utils.convert_to_one_hot(Y, C=n_y)
    30.     
    31.     # 优化循环
    32.     for t in range(num_iterations):
    33.         for i in range(m):
    34.             # 获取第i个训练样本的均值
    35.             avg = sentence_to_avg(X[i], word_to_vec_map)
    36.             
    37.             # 前向传播
    38.             z = np.dot(W, avg) + b
    39.             a = emo_utils.softmax(z)
    40.             
    41.             # 计算第i个训练的损失
    42.             cost = -np.sum(Y_oh[i]*np.log(a))
    43.             
    44.             # 计算梯度
    45.             dz = a - Y_oh[i]
    46.             dW = np.dot(dz.reshape(n_y,1), avg.reshape(1, n_h))
    47.             db = dz
    48.             
    49.             # 更新参数
    50.             W = W - learning_rate * dW
    51.             b = b - learning_rate * db
    52.         if t % 100 == 0:
    53.             print("第{t}轮，损失为{cost}".format(t=t,cost=cost))
    54.             pred = emo_utils.predict(X, Y, W, b, word_to_vec_map)
    55.             
    56.     return pred, W, b
    1. pred, W, b = model(X_train, Y_train, word_to_vec_map)
    2.  
    3. """
    4. 第0轮，损失为1.9520498812810072
    5. Accuracy: 0.3484848484848485
    6. 第100轮，损失为0.07971818726014807
    7. Accuracy: 0.9318181818181818
    8. 第200轮，损失为0.04456369243681402
    9. Accuracy: 0.9545454545454546
    10. 第300轮，损失为0.03432267378786059
    11. Accuracy: 0.9696969696969697
    12. """
    1. X_my_sentences = np.array(["i adore you", "i love you", "funny lol", "lets play with a ball", "food is ready", "you are not happy"])
    2. Y_my_labels = np.array([[0], [0], [2], [1], [4],[3]])
    3.  
    4. pred = emo_utils.predict(X_my_sentences, Y_my_labels , W, b, word_to_vec_map)
    5. emo_utils.print_predictions(X_my_sentences, pred)
    6.  
    7. """
    8. Accuracy: 0.8333333333333334
    10. i adore you ❤️
    11. i love you ❤️
    12. funny lol ?
    13. lets play with a ball ⚾
    14. food is ready ?
    15. you are not happy ❤️
    16. """

    LSTM下的表情生成       

           可以看到上文中的最后一个结果预测是不正确的，这是因为没有做一个上下文的考虑 。对应上面的预测方法，这里是将单词转化成向量矩阵作为序列输入。这里的输入长度是固定的，设定一个最大长度，不足的补0，超过的截取。

    1. def sentences_to_indices(X, word_to_index, max_len):
    2.     """
    3.     输入的是X（字符串类型的句子的数组），再转化为对应的句子列表，
    4.     输出的是能够让Embedding()函数接受的列表或矩阵（参见图4）。
    5.     
    6.     参数：
    7.         X -- 句子数组，维度为(m, 1)
    8.         word_to_index -- 字典类型的单词到索引的映射
    9.         max_len -- 最大句子的长度，数据集中所有的句子的长度都不会超过它。
    10.         
    11.     返回：
    12.         X_indices -- 对应于X中的单词索引数组，维度为(m, max_len)
    13.     """
    14.     
    15.     m = X.shape[0]  # 训练集数量
    16.     # 使用0初始化X_indices
    17.     X_indices = np.zeros((m, max_len))
    18.     
    19.     for i in range(m):
    20.         # 将第i个居住转化为小写并按单词分开。
    21.         sentences_words = X[i].lower().split()
    22.         
    23.         # 初始化j为0
    24.         j = 0
    25.         
    26.         # 遍历这个单词列表
    27.         for w in sentences_words:
    28.             # 将X_indices的第(i, j)号元素为对应的单词索引
    29.             X_indices[i, j] = word_to_index[w]
    30.             
    31.             j += 1
    32.             
    33.     return X_indices
    1. X1 = np.array(["funny lol", "lets play baseball", "food is ready for you"])
    2. X1_indices = sentences_to_indices(X1,word_to_index, max_len = 5)
    3. print("X1 =", X1)
    4. print("X1_indices =", X1_indices)
    5.  
    6. """
    7. X1 = ['funny lol' 'lets play baseball' 'food is ready for you']
    8. X1_indices = [[155345. 225122.      0.      0.      0.]
    9.  [220930. 286375.  69714.      0.      0.]
    10.  [151204. 192973. 302254. 151349. 394475.]]
    11. """

  • 相关阅读:
    【Linux】——初识程序地址空间
    2022最新Web前端经典面试试题及答案-史上最全前端面试题(含答案)
    9D电影是怎样的？（+维度空间常识）
    iOS性能监控及自动化测试辅助工具对比-tidevice、py-ios-device（pyidevice）、sonic-ios-bridge（sib）
    关于芯片的名词
    WSL2-ubuntu18.04配置笔记5：基于vnc和xfce4实现远程桌面
    javaWeb基于SSM框架开发的社区医疗数据管理系统【项目源码+数据库脚本+报告】
    四川云汇优想教育咨询有限公司电商服务正规吗
    华为云云耀云服务器L实例评测|评测使用
    vue 验证码 图片点击
  • 原文地址：https://blog.csdn.net/qq_41828351/article/details/90573885