精华内容
下载资源
问答
  • Hot Restart & Hot Reload

    2021-08-14 13:08:16
    什么是Hot Restart 和 Hot Reload   Hot Reload是通过将更新的源代码文件注入到正在运行的Dart虚拟机(DVM)中,在DVM使用新的源文件替换掉原来的源文件后,Flutter就会自动地重建Widget Tree,从而达到快速查看我们...

    什么是Hot Restart 和 Hot Reload

      Hot Reload是通过将更新的源代码文件注入到正在运行的Dart虚拟机(DVM)中,在DVM使用新的源文件替换掉原来的源文件后,Flutter就会自动地重建Widget Tree,从而达到快速查看我们修改后的效果的目的

    Hot Restart & Hot Reload应该用哪种?

      根据上面提到的,这种技术会重构Widget Tree,所以,具体选择哪种方式,取决于我们对代码的修改和需求

    1. Hot Reload
      • 当我们需要将新的代码加载进Application,又不想改变当前的state,就可以用Hot Reload
      • 简而言之,就是当我们的修改在最顶层build函数内时,用Hot Reload即可达到目的

    例如:

    import 'package:flutter/material.dart';
    void main() {
      runApp(MyApp());
    }
    
    class MyApp extends StatelessWidget {
      @override
      Widget build(BuildContext context) {
        return MaterialApp(
          home: Center(
            //当我们把'hot reload' 修改了,由于是在build之内修改的,widget Tree重构的时候,
            //可以检测到,所以直接hot reload即可
            child: Text('hot reload'),
          ),
        );
      }
    }
    
    1. Hot Restart
      • Hot Restart会把改变后的代码文件重新加载到Dart VM中,并且重启整个应用
      • 因此,只有当你修改了有关Application的state时,就需要用到Hot Restart了,因此重构Widget Tree的过程,是无法知道我们修改的state的,也就无法将我们的修改加载出来
      • 简而言之,就是当在最顶层build方法外做出的修改时,就需要用Hot Restart才可以把改变加载出来了

    例如:

    import 'package:flutter/material.dart';
    void main() {
      runApp(MyApp());
    }
    
    class MyApp extends StatelessWidget {
    //如果把这里的text的文本改变了,由于是在build方法之外的改变,widget Tree重构无法检测到,所以需要用Hot Restart才行
      final String text = 'hot restart';
      @override
      Widget build(BuildContext context) {
        return MaterialApp(
          home: Center(
            child: Text(text),
          ),
        );
      }
    }
    
    展开全文
  • 最近工作实在有点忙,前阵子关于梯度和导数的事情把人折腾的够呛,数学学不好,搞机器学习和神经网络真是头疼;想转到应用层面轻松一下,想到了自然语言处理,one hot模型是基础也是入门,看起来...

    最近工作实在有点忙,前阵子关于梯度和导数的事情把人折腾的够呛,数学学不好,搞机器学习和神经网络真是头疼;想转到应用层面轻松一下,想到了自然语言处理,one hot模型是基础也是入门,看起来很简单的一个列表转矩阵、词典的功能,想着手工实现一下,结果看了一下CountVectorizer,发现不是那么回事儿,还是放弃了。

    顾名思义,单热表示从一个零向量开始,如果单词出现在句子或文档中,则将向量中的相应条目设置为 1。

    对句子进行标记,忽略标点符号,并将所有的单词都用小写字母表示,就会得到一个大小为 8 的词汇表: {time, fruit, flies, like, a, an, arrow, banana} 。所以,我们可以用一个八维的单热向量来表示每个单词。在本书中,我们使用 1[w] 表示标记/单词 w 的单热表示。

    对于短语、句子或文档,压缩的单热表示仅仅是其组成词的逻辑或的单热表示。短语 like a banana 的单热表示将是一个 3×8 矩阵,其中的列是 8 维的单热向量。通常还会看到“折叠”或二进制编码,其中文本/短语由词汇表长度的向量表示,用 0 和 1 表示单词的缺失或存在。like a banana 的二进制编码是: [0,0,0,1,1,0,0,1] 。

    from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer
    import seaborn as sns
    import matplotlib.pyplot as plt
    import jieba
    import jieba.analyse
    
    # 单热表示从一个零向量开始,如果单词出现在句子或文档中,则将向量中的相应条目设置为 1。
    # 英文的处理和展示
    corpus = ['Time flies flies like an arrow.', 'Fruit flies like a banana.']
    one_hot_vectorizer = CountVectorizer(binary=True)
    one_hot = one_hot_vectorizer.fit_transform(corpus).toarray()
    sns.heatmap(one_hot, annot=True, cbar=False, yticklabels=['Sentence 1', 'Sentence 2'])
    plt.show()
    
    

    # 中文的处理和展示
    # 获取停用词列表
    def get_stopwords_list(stopwordfile):
        stopwords = [line.strip() for line in open(stopwordfile, encoding='UTF-8').readlines()]
        return stopwords
    
    # 移除停用词
    def movestopwords(sentence):
        stopwords = get_stopwords_list('stopwords.txt')  # 这里加载停用词的路径
        santi_words = [x for x in sentence if len(x) > 1 and x not in stopwords]
        return santi_words
    
    # 语料
    corpus = ["小明硕士毕业于中国科学院计算所,后在日本京都大学深造。",
              "小王本科在清华大学,后在南京计算所工作和深造,后在日本早稻田大学深造",
              "小李本科在清华大学,硕士毕业于中国科学院计算所,博士在南京大学"]
    newcorpus = []
    for str in corpus:
        orgwordlist = jieba.lcut(str)  # jieba分词
        wordlist = movestopwords(orgwordlist)  # 移除停用词
        newword = " ".join(wordlist)  # 按照语料库要求进行空格分隔
        newcorpus.append(newword)  # 按照语料库要求转换成列表
    # newcorpus
    # ['小明 硕士 毕业 中国科学院 计算所 日本京都大学 深造',
    # '小王 本科 清华大学 南京 计算所 工作 深造 日本早稻田大学 深造',
    # '小李 本科 清华大学 硕士 毕业 中国科学院 计算所 博士 南京大学']
    one_hot_vectorizer = CountVectorizer(binary=True)  # 创建词袋数据结构
    one_hot = one_hot_vectorizer.fit_transform(newcorpus).toarray()  # 转换语料,并矩阵化
    # 下面为热词的输出结果
    # one_hot_vectorizer.vocabulary_
    # {'小明': 4, '硕士': 14, '毕业': 11, '中国科学院': 0, '计算所': 15, '日本京都大学': 8, '深造': 12, '小王': 6, '本科': 10, '清华大学': 13, '南京': 1, '工作': 7, '日本早稻田大学': 9, '小李': 5, '博士': 3, '南京大学': 2}
    # one_hot_vectorizer.get_feature_names()
    # ['中国科学院', '南京', '南京大学', '博士', '小明', '小李', '小王', '工作', '日本京都大学', '日本早稻田大学', '本科', '毕业', '深造', '清华大学', '硕士', '计算所']
    # one_hot
    # [[1 0 0 0 1 0 0 0 1 0 0 1 1 0 1 1]
    #  [0 1 0 0 0 0 1 1 0 1 1 0 1 1 0 1]
    #  [1 0 1 1 0 1 0 0 0 0 1 1 0 1 1 1]]
    sns.set_style({'font.sans-serif': ['SimHei', 'Arial']})
    sns.heatmap(one_hot, annot=True, cbar=False, xticklabels=one_hot_vectorizer.get_feature_names(),
                yticklabels=['语句1', '语句2', '语句3'])
    plt.show()
    
    
    

    IDF 表示惩罚常见的符号,并奖励向量表示中的罕见符号。符号 w 的 IDF(w) 对语料库的定义为其中 n[w] 是包含单词 w 的文档数量, N 是文档总数。TF-IDF 分数就是 TF(w) * IDF(w) 的乘积。首先,请注意在所有文档(例如, n[w] = N ), IDF(w) 为 0, TF-IDF 得分为 0,完全惩罚了这一项。其次,如果一个术语很少出现(可能只出现在一个文档中),那么 IDF 就是 log n 的最大值

    tfidf_vectorizer = TfidfVectorizer()  # 创建词袋数据结构
    tfidf = tfidf_vectorizer.fit_transform(newcorpus).toarray()  # 转换语料,并矩阵化
    # 下面为热词的输出结果
    # tfidf_vectorizer.vocabulary_
    # '小明': 4, '硕士': 14, '毕业': 11, '中国科学院': 0, '计算所': 15, '日本京都大学': 8, '深造': 12, '小王': 6, '本科': 10, '清华大学': 13, '南京': 1, '工作': 7, '日本早稻田大学': 9, '小李': 5, '博士': 3, '南京大学': 2}
    # tfidf_vectorizer.get_feature_names()
    # ['中国科学院', '南京', '南京大学', '博士', '小明', '小李', '小王', '工作', '日本京都大学', '日本早稻田大学', '本科', '毕业', '深造', '清华大学', '硕士', '计算所']
    # tfidf
    # [[0.35221512 0.         0.         0.         0.46312056 0.  0.         0.         0.46312056 0.         0.        0.35221512  0.35221512 0.         0.35221512 0.27352646]
    #  [0.         0.35761701 0.         0.         0.         0.  0.35761701 0.35761701 0.         0.35761701 0.27197695 0.  0.54395391 0.27197695 0.         0.21121437]
    #  [0.30443385 0.         0.40029393 0.40029393 0.         0.40029393  0.         0.         0.         0.         0.30443385 0.30443385  0.         0.30443385 0.30443385 0.23642005]]
    sns.heatmap(tfidf, annot=True, cbar=False, xticklabels=tfidf_vectorizer.get_feature_names(),
                yticklabels=['语句1', '语句2', '语句3'], vmin=0, vmax=1, cmap="YlGnBu")
    plt.show()

    展开全文
  • 这篇博客将介绍Python,Keras深度学习中非连续的字母文本怎么处理为one-hot编码。

    Python,Keras深度学习中非连续的字母怎么处理为one-hot编码

    写这篇博客源于博友的提问,将介绍Python,Keras深度学习中非连续的字母文本怎么处理为one-hot编码。

    初始值是

    1. 效果图

    首先对字母转数字,然后字母计算相对应的one-hot对应的值,不一定是 A-Z所有的字母都有,转换one-hot,效果图如下:

    原始数据为 (66,11)66行,每行11个字母(字母从A-Y),最小值为A,最大值为Y,唯一的字母总数为20个。
    转换为(66,11,20)

    在这里插入图片描述

    2. 源码

    # python 将字母A-Z 转数字,并且转换为one-hot编码
    import numpy as np
    import pandas as pd  # pd.read_excel()方法读取excel文件
    
    
    # 预处理数据【找到所有的字母类型并对应0~ len(字母数)-1,然后进行转换】
    # 按照此关系对应:{'A': 0, 'C': 1, 'D': 2, 'E': 3, 'F': 4, 'G': 5, 'H': 6, 'I': 7, 'K': 8, 'L': 9, 'M': 10, 'N': 11, 'P': 12, 'Q': 13, 'R': 14, 'S': 15, 'T': 16, 'V': 17, 'W': 18, 'Y': 19}
    # 字母转数字  如 Y G Q E M Y V F R S E  转成 [19, 5, 13, 3, 10, 19, 17, 4, 14, 15, 3]
    # 并转换为one-hot编码 (60,11) 转成 (60,11,20)
    # 如     [[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 1.]  第一行代表的Y值
    #         [0. 0. 0. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
    #         [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0. 0. 0. 0.]
    #         [0. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
    #         [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
    #         [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 1.]
    #         [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0.]
    #         [0. 0. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
    #         [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0. 0. 0.]
    #         [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0. 0.]
    #         [0. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]]
    def preprocess_test_data(df_train):
        print(type(df_train['文本']))
        # 转换pd dataframe为 numpy,并获取x值
        np_df_train = np.array(df_train['文本'])
        print('origin: ', np_df_train[0])
    
        # 找到所有字母的分类及从0开始对应的字母标签值
        # {'A': 0, 'C': 1, 'D': 2, 'E': 3, 'F': 4, 'G': 5, 'H': 6, 'I': 7, 'K': 8, 'L': 9, 'M': 10, 'N': 11, 'P': 12, 'Q': 13, 'R': 14, 'S': 15, 'T': 16, 'V': 17, 'W': 18, 'Y': 19}
        # 注意 如果按照 A: 0  B:1 则转换的时候需要 A~Y 转成 24个字符表示,但此处需要表示为20个字符
        # 所以需要计算一个差值
        data_labels = sorted(
            set(np.array(sum([[j for j in list(str(i).replace(" ", ''))] for i in np_df_train], [])).flatten()))
        dict_lables = {}
        dict_labels_subtract = {}
        for index, j in enumerate(data_labels):
            dict_lables[j] = index
            dict_labels_subtract[j] = ord(j) - ord('A') - index
        print('data_labels: ', data_labels)
        print('dict_labels: ', dict_lables)
        print('dict_labels_subtract: ', dict_labels_subtract, len(dict_labels_subtract.keys()))
        
        print('min,max,count',min(dict_lables.keys()),max(dict_lables.keys()),len(dict_lables.keys()))
    
        # x = [[ord(j) - ord('A') for j in list(str(i).replace(" ", ''))] for i in np_df_train]
        # 转换每一个字母为 数字,按照A对应0  C对应1  D对应2 E对应3 Y对应19
        x = [[ord(j) - ord('A') - dict_labels_subtract[j] for j in list(str(i).replace(" ", ''))] for i in np_df_train]
        print('x[0]: ', x[0], type(x))
    
        # list转array
        labels = np.array(x)
        # 记录下数据原始的维度,方便进行one-hot编码后转回去
        labels_width, labels_height = labels.shape
        print('labels shape: ', labels.shape)
        set_n = sorted(set(labels.flatten()))
        print('sorted set_n: ', sorted(set_n), len(set_n), min(set_n), max(set_n))
    
        # 进行one-hot编码
        res = np.eye(len(set_n))[labels.flatten()]
        print("labels转成one-hot形式的结果:\n", res[0], "\n")
        print("labels转化成one-hot后的大小:", res.shape)
    
        # 成功实现one-hot编码 (60, 11)  -->  (60, 11, 20)
        train_data = res.reshape(labels_width, labels_height, len(set_n))
        print('转回原始数据的形式:', train_data[0], train_data.shape)
        return train_data
    
    
    # 构建原始数据
    test_dict = {'文本': ['Y G Q E M Y V F R S E', 'A K E W G Y A D H N G', 'S E P K Y Y S Q P I L', 'A L A K N Y P G K K V',
                        'S P Y S D Y G G R K D', 'A K V K S Y K R Q A E', 'Q L P H D Y C T T P G', 'A T D S R Y G Q K E S',
                        'K I K Q Y Y Q K F T W', 'D E T E T Y Q E K V H', 'L E V T A Y S P L G S', 'Q G Y H S Y A V R T A',
                        'T A K G D Y P L E A V', 'S E G S E Y E E I P K', 'S S G S P Y G G G Y G', 'S L G E E Y T E D Y G',
                        'K S M S V Y C T P N K', 'P K S Q R Y S G A Y G', 'A N Y S S Y L A K A D', 'K R I H E Y K P F K T',
                        'K D L F D Y S P P L H', 'S Y P E V Y Q E R F P', 'A P S P V Y G S S A K', 'V W L R R Y L E F A G',
                        'A Y F G V Y D T A K G', 'V N P E Q Y S K R F N', 'E M L F I Y S H Y K Q', 'Y R A Y D Y H E E T R',
                        'S L D R G Y T S D S E', 'L C M H K Y L L I Q S', 'R V G N E Y V T K G Q', 'P R A E W Y R D D V L',
                        'P R L S I Y G R S P D', 'V K E L T Y Q T E E D', 'V L A M P Y D T P V P', 'I K E L T Y Q T E E D',
                        'K V K N A Y E E S L D', 'T R L G I Y T V L F E', 'D S Y D P Y D F S D T', 'V L R A D Y V K E M L',
                        'N G C I N Y E A F V K', 'E E C L A Y F G V S E', 'A V G H G Y Y M A A G', 'P A A H L Y F S Q S C',
                        'S P P G P Y G Q E M Y', 'T K I A L Y E T P T G', 'N Q E D I Y I T T E S', 'T L D N A Y M E K C D',
                        'P E G Q N Y S S E L H', 'K V Q V E Y K G E T K', 'Y G K S L Y H D I T G', 'N S D S I Y S S T P E',
                        'S S V P E Y V Y N L H', 'N T K T S Y H T P G D', 'K N R P G Y V S E E E', 'E E P S E Y T D E E D',
                        'I M D N A Y F C E A D', 'G D R S G Y S S P G S', 'L S E D E Y Y S E E E', 'N I F F D Y S G R D L'],
                 '标签': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
                        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]}
    
    # 手动构建pandas.DataFrame
    # 方法1:直接写入赋值
    df_train = pd.DataFrame(test_dict)
    
    # 方法2:字典型赋值
    # df_train = pd.DataFrame(data=test_dict)
    print(type(df_train), df_train[:1])
    
    # 预处理数据【找到所有的字母类型并对应0~ len(字母数)-1,然后进行转换】
    # 按照此关系对应:{'A': 0, 'C': 1, 'D': 2, 'E': 3, 'F': 4, 'G': 5, 'H': 6, 'I': 7, 'K': 8, 'L': 9, 'M': 10, 'N': 11, 'P': 12, 'Q': 13, 'R': 14, 'S': 15, 'T': 16, 'V': 17, 'W': 18, 'Y': 19}
    # 字母转数字  如 Y G Q E M Y V F R S E  转成 [19, 5, 13, 3, 10, 19, 17, 4, 14, 15, 3]
    # 并转换为one-hot编码 (60,11) 转成 (60,11,20)
    # 如     [[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 1.]  第一行代表的Y值
    #         [0. 0. 0. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
    #         [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0. 0. 0. 0.]
    #         [0. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
    #         [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
    #         [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 1.]
    #         [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0.]
    #         [0. 0. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
    #         [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0. 0. 0.]
    #         [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0. 0.]
    #         [0. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]]
    train_data = preprocess_test_data(df_train)
    print('Shape of data train:', train_data.shape)
    

    参考

    展开全文
  • 一文搞懂one-hot和embedding

    千次阅读 2021-03-02 16:03:56
    接下来说说 传统的 one-hot 编码开始,阐述其优劣,并延伸至 word embedding 技术和其优点 人类可以很轻易地理解一个单词、词组或者字母,比如「LOVE」,但机器是理解不了的。想要让机器理解单词,就必须要把它变成...

    在 NLP领域,word embedding 已经成为了众所周知的技术。在现实生活中 word embedding 已经拥有非常广泛的应用:语音助手、机器翻译、情感分析… 因为 word embedding 的特殊性,它几乎覆盖了所有 NLP 的应用。接下来说说  传统的 one-hot 编码开始,阐述其优劣,并延伸至 word embedding 技术和其优点

    人类可以很轻易地理解一个单词、词组或者字母,比如「LOVE」,但机器是理解不了的。想要让机器理解单词,就必须要把它变成一串数字(向量)。下面介绍的 One-Hot Encoding(One-Hot 编码)和 Word Embedding (词嵌入)和就是把单词变成向量的两类方法

    一、One-Hot Encoding (词汇表->稀疏向量)

    1.首先one-hot是什么?为什么用one-hot?

    一般来说,机器学习教程会推荐你或要求你,在开始拟合模型之前,先以特定的方式准备好数据;其中,一个很好的例子就是对类别数据(Categorical data)进行 One-Hot 编码

    那么,什么是类别数据?类别数据是一种只有标签值而没有数值的变量。它的值通常属于一个大小固定且有限的集合。类别变量也常被称为标称值(nominal)。
    下面举例说明:

    • 宠物(pet)变量包含以下几种值:狗(dog)、猫(cat)。
    • 颜色(color)变量包含以下几种值:红(red)、绿(green)、蓝(blue)。
    • 位次(place)变量包含以下几种值:第一(first)、第二(second)和第三(third)。

    以上例子中的每个值都代表着一个不同的类别。有些类别彼此间存在一定的自然关系,比如自然的排序关系。上述例子中,位次(place)变量的值就有这种自然的排序关系。这种变量被称为序数变量(ordinal variable)。

    2.类别数据有什么问题?

    有些算法可以直接应用于类别数据。比如,你可以不进行任何数据转换,将决策树算法直接应用于类别数据上(取决于具体实现方式)。但还有许多机器学习算法并不能直接操作标签数据。这些算法要求所有的输入输出变量都是数值(numeric)。通常来说,这种限制主要是因为这些机器学习算法的高效实现造成的,而不是算法本身的限制。
    但这也意味着我们需要把类别数据转换成数值形式。如果输出变量是类别变量,那你可能还得将模型的预测值转换回类别形式,以便在一些应用中展示或使用
    如何将类别数据转换成数值数据:

    两个方法:1.整数编码                          2.One-Hot 编码

    a.整数编码:第一步,先要给每个类别值都分配一个整数值。
    比如,用 1 表示红色(red),2 表示绿色(green),3 表示蓝色(blue)。这种方式被称为标签编码或者整数编码,可以很轻松地将它还原回类别值。整数之间存在自然的排序关系,机器学习算法也许可以理解并利用这种关系。比如,前面的位次(place)例子中的序数变量就是一个很好的例子。对于它我们只需要进行标签编码就够了。

    b.One-Hot 编码

    但对于不存在次序关系的类别变量,仅使用上述的整数编码是不够的。实际上,使用整数编码会让模型假设类别间存在自然的次序关系,从而导致结果不佳或得到意外的结果(预测值落在两个类别的中间)。这种情况下,就要对整数表示使用 One-Hot 编码了。One-Hot 编码会去除整数编码,并为每个整数值都创建一个二值变量。

    再通俗一点:

    将离散型特征使用one-hot编码,确实会让特征之间的距离计算更加合理。比如,有一个离散型特征,代表工作类型,该离散型特征,共有三个取值,不使用one-hot编码,其表示分别是x_1 = (1), x_2 = (2), x_3 = (3)。两个工作之间的距离是,(x_1, x_2) = 1, d(x_2, x_3) = 1, d(x_1, x_3) = 2。那么x_1和x_3工作之间就越不相似吗?显然这样的表示,计算出来的特征的距离是不合理。那如果使用one-hot编码,则得到x_1 = (1, 0, 0), x_2 = (0, 1, 0), x_3 = (0, 0, 1),那么两个工作之间的距离就都是sqrt(2).即每两个工作之间的距离是一样的,显得更合理。

    在颜色(color)的示例中,有 3 种类别,因此需要 3 个二值变量进行编码。对应的颜色位置上将被标为“1”,其它颜色位置上会被标为“0”。

    red, green, blue
    1,      0,   0
    0,      1,   0
    0,      0,   1

    二、word embedding - 让计算机学会爱(词间的关系)

    深度学习应用在自然语言处理当中的时候,基本都会通过词向量的方式将one-hot编码的向量,转换为词向量。至于为什么这么做,

    一个原因是因为深度学习对稀疏输入效果不好,

    第二个最主要原因是,那种one-hot方式的编码,对于每一个不同的单词或者中文的词语,之间关系没有办法表达出来,也即,对于不同的单词,两个单词的one-hot编码的向量的相似度永远为0, 也即cos(Vi, Vj) = 0。那么问题来了,怎样表示出单词之间的内在联系呢?embedding来了

     

    要了解 embedding 的优点,我们可以对应 One-hot 编码来观察。One-hot 编码是一种最普通常见的表示离散数据的表示,首先我们计算出需要表示的离散或类别变量的总个数 N,然后对于每个变量,我们就可以用 N-1 个 0 和单个 1 组成的 vector 来表示每个类别。这样做有两个很明显的缺点:

    • 对于具有非常多类型的类别变量,变换后的向量维数过于巨大,且过于稀疏。
    • 映射之间完全独立,并不能表示出不同类别之间的关系。

    因此,考虑到这两个问题,表示类别变量的理想解决方案则是我们是否可以通过较少的维度表示出每个类别,并且还可以一定的表现出不同类别变量之间的关系,这也就是 embedding 出现的目的。

    Embedding 是一个将离散变量转为连续向量表示的一个方式。在神经网络中,embedding 是非常有用的,因为它不光可以减少离散变量的空间维数,同时还可以有意义的表示该变量。

    我们可以总结一下,embedding 有以下 3 个主要目的:

    • 在 embedding 空间中查找最近邻,这可以很好的用于根据用户的兴趣来进行推荐。
    • 作为监督性学习任务的输入。
    • 用于可视化不同离散变量之间的关系。

    这也就意味对于维基百科书籍表示而言,使用 Neural Network Embedding,我们可以在维基百科上获取到的所有 37,000 本书,对于每一篇,仅仅用一个包含 50 个数字的向量即可表示。此外,因为 embedding 是可学习的,因此在不断的训练过程中,更相似的书籍的表示在 embedding space 中将彼此更接近。
    One-hot 编码的最大问题在于其转换不依赖于任何的内在关系,而通过一个监督性学习任务的网络,我们可以通过优化网络的参数和权重来减少 loss 以改善我们的 embedding 表示,loss 越小,则表示最终的向量表示中,越相关的类别,它们的表示越相近

    Embedding 可视化,可以看出词与词之间的相似性

    底下这个图是我用tensorflow训练人民的名义的embedding的结果

    三、总结

    最后我们来做一个总结,自然语言的向量化表示方法主要有两类:one-hot encoding 和 word embedding。它们的优缺点如下:
    在这里插入图片描述

    四、应用

    Embedding 的基本内容如前面介绍所示,然而我想说的是它的价值并不仅仅在于 word embedding 或者 entity embedding,这种将类别数据用低维表示且可自学习的思想更存在价值。通过这种方式,我们可以将神经网络,深度学习用于更广泛的领域,Embedding 可以表示更多的东西,而这其中的关键在于要想清楚我们需要解决的问题和应用 Embedding 表示我们得到的是什么。

    说到embedding就不得不说说word2vector了,word2vector做法即为embedding的过程,这个可以扩展到推荐中的item2vector 。顺便提一嘴word2vec:

    1.可以看作是多分类任务

    2.浅层神经网络

    3.数据构造模式:cbow、skip-gram模式

    完结!

    以下加一点用tensorflow模拟embedding的一点代码做个记录

    import tensorflow as tf 
    import numpy as np
    
    #类似语料库
    embedding_dict = tf.convert_to_tensor(np.random.random(size=(30,4)))
    #输入的词索引
    input_train = tf.convert_to_tensor([1,2,4,5])
    
    检索得到对应词的embedding权重
    embed = tf.nn.embedding_lookup(embedding_dict,input_train)
    
    #由于我的tensorflow的版本较高,session开启方式不同
    sess = tf.compat.v1.Session()
    sess.run(tf.compat.v1.global_variables_initializer())
    
    print(sess.run(embedding_dict))
    print("====================================")
    print(sess.run(embed))
    
    sess.close()
    展开全文
  • 将标签转为onehot形式

    2021-03-25 11:14:43
    对于给定具体标签,如何将其转为one-hot形式?比如标签集合体育', '娱乐', '家居', '房产', '教育', '时尚', '时政', '游戏', '科技', '财经',对于multiclass任务,如何将训练数据集中的样本的标签转为one-hot形式?...
  • leetcode HOT100总结

    2021-05-09 09:46:59
    本人菜鸡一枚,历时两个月时间把HOT100题做完(Ctrl C-V)了,做完之后还是感觉到很虚,很多中等题还是不会做,于是乎花几天时间把这100题给总结一下。一方面,对自己的知识梳理;另一方面,便于后续回顾。(完成度99,...
  • Windows——AutoHotKey初次了解AutoHotKey,是在Win下最爱效率神器: AutoHotKey | 晚晴幽草轩这篇博客中,博主有对AutoHotKey作详细介绍,这里不在赘余。当时打字很慢,更苦于写代码时需要经常按方向键、Home/End等...
  • 详解one-hot编码

    2021-01-17 12:32:04
    博主原创文章,转载请注明出处一、什么是one-hot编码?One-Hot编码,又称为一位有效编码,主要是采用N位状态寄存器来对N个状态进行编码,每个状态都由他独立的寄存器位,并且在任意时候只有一位有效。One-Hot编码是...
  • 在上一篇文章当中我们介绍了对dataframe进行排序以及计算排名的一些方法,在今天的文章当中我们来了解一下dataframe两个非常重要的功能——离散化和one-hot。离散化离散对应的反面是连续,离散化也就是将连续性的...
  • hot_standby

    2021-12-09 18:51:42
    hot_standby PostgreSQL数据库是通过在数据目录下建一个特殊的文件来指示数据库启动在主库模式还是在备库模式,在PostgreSQL 12版本之前是通过文件“recovery.conf”来指示数据库启动在备库模式的(当然需要在...
  • 热重载 (Hot reload)

    千次阅读 2020-12-30 06:04:32
    Flutter 的热重载功能可帮助您在无需重新启动应用程序的情况下快速、轻松地测试、构建用户界面、添加功能以及修复错误。通过将更新的源代码文件注入到正在运行的Dart ...Flutter’s hot reload feature helps you q...
  • AutoHotKey是最好的Windows自动化程序之一,可以执行最简单的操作到最艰巨的任务。AutoHotKey是一个免费的开源程序,通过这种脚本语言您的任何Windows日常任务。即使“脚本语言”听起来令人生畏,实际它非常易于使用...
  • An image transform to ...本文贡献2.HOT算法2.1.基本思路2.2.问题3.对云和气溶胶类型的敏感性 1.BackGround 1.1.存在问题 即使在陆地卫星场景地理覆盖范围有限的情况下(例如185-185公里),感兴趣的时间窗口也
  • one-hot实现的几种方式 方式一:最简单的方式,可以一行代码搞定 import numpy as np import torch 'one-hot使用方法:最简单' num_classes = 10 arr = [1, 3, 4, 5] one_hots = np.eye(num_classes)[arr] print...
  • Embedding的数学本质,就是以one hot为输入的单层全连接。 也就是说,世界上本没什么Embedding,有的只是one hot。 这里再从三个角度去理解一下 第一,Embedding 就是以one hot为输入的单层全连接 Embedding 矩阵...
  • OneHot数据Embedding 之前看的一些推荐模型都是将数据oneHot然后在通过Dense层或者Embedding层将数据稠密化,但一直不太理解具体如何实现。 注意:接下来讲的,不是直接将oneHot转为Embedding,而是将转为oneHot前的...
  • 也就是说,要实现类的热替换(Hotswap)。这一点,在Java Web应用中体现的更为明显,每次更新配置,更新class,都需要重新启动服务器,重新加载这些改动,这一过程相当耗时。那为什么不在应用服务器运行时,或者说Java...
  • 在 sklearn 包中,OneHotEncoder 函数非常实用,它可以实现将分类特征的每个元素转化为一个可以用来计算的值。本篇详细讲解该函数的用法,也可以参考官网sklearn.preprocessing.OneHotEncoder。
  • One-hot encoding of words or characters 单词和字符的 one-hot 编码 one-hot 编码是将标记转换为向量的最常用、最基本的方法。在第 3 章的 IMDB 和路透社两 个例子中,你已经用过这种方法(都是处理单词)。它将...
  • 实现one hot encode的两种方法Approach 1: You can use get_dummies on pandas dataframe.# transform a given column into one hot. Use prefix to have multiple dummies>>> import pandas as pd>>...
  • 为方便程式开发时比对代码或者参考写作,需要将参考的窗口设置一定的透明度以不影响下面的窗口查看。当然,你也可用来摸鱼。WinGet取得目标窗口的标识A及透明度T,透明度为空或者透明度减少到100时重新设置透明度,...
  • 数据预处理之One-Hot(独热编码)编码 为什么使用One-Hot编码 对于机器学习任务中,特征并不总是连续值,很多是分类值。这些分类值本身没有大小的意义。为了将数据集中一个分类变量替换为一个或多个新特征,我们使用...
  • 方法一: 解决的第一个方法自然是尝试找到该功能对应的配置项位置并尝试直接修改该配置来实现这功能的开启和关闭操作,然后尝试使用autohotkey来实现自动化的操作并最终映射到一个快捷键上来完成目标。 经过一番...
  • pytorch将标签转为onehot

    2020-12-20 19:02:45
    由于想多分类中使用Diceloss,所以需要将[0,1,2,..N]类型的标签转化为onehot类型。1、在cpu上处理input数据类型: torch.LongTensor()数据形状:[bs, 1, *] 可为2D或3D数据def make_one_hot(input, num_classes):""...
  • pytorch one-hot编码

    2021-08-29 11:30:32
    使用scatter_将标签转换为one-hot import torch num_class = 5 label = torch.tensor([0, 2, 1, 4, 1, 3]) one_hot = torch.zeros((len(label), num_class)).scatter_(1, label.long().reshape(-1, 1), 1) print...
  • ####方法1 之前写使用sklearn进行数据挖掘-房价预测(4)—数据预处理一文中处理标签类特征时候已经提到过,使用sklearn中提供的LabelEncoder和OneHotEncoder方法a = ['A','B','A','C']from sklearn.preprocessing ...
  • one-hot vector(独热编码)

    千次阅读 2021-01-17 14:08:26
    One-Hot编码,又称为一位有效编码,主要是采用N位状态寄存器来对N个状态进行编码,每个状态都由他独立的寄存器位,并且在任意时候只有一位有效。 One-Hot编码是分类变量作为二进制向量的表示。这首先要求将分类值...
  • 生成张量 y = torch.empty(3, dtype=torch.long).random_(5) y = torch.Tensor(2,3).random_(10) y = torch.randn(3,4).random_(10) 查看类型 ...One_hot编码表示 def one_hot(y): ''' y: (N)的一
  • TORCH.NN.FUNCTIONAL.ONE_HOT

    2021-10-28 19:32:08
    不带参数独热编码,仅只输入一个张量 one_hot2.1 代码2.2 输出结果3. 带参数独热编码,一个参数为输入张量,另外一个为类别数3.2 结果 1.独热编码 定义:torch.nn.functional.one_hot(tensor, num_classes=- 1) → ...
  • One-Hot 编码

    2021-01-05 15:29:08
    0. 前言 偶然间听到One-Hot编码这个概念,但是并不理解是怎么回事。所以经过学习与了解,写一篇博客来加深自己对此的理解。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 222,573
精华内容 89,029
关键字:

hot