精华内容
下载资源
问答
  • 而是文章的作者与众不同,写文章的不是人,而是网络机器人,或者说是人工智能,是算法通过分析大量财经文章后,学会了人如何编写财经报道,然后根据相关模式,把各种财经数据组织起来,自动的生成一篇文章,当人...

    前几年,腾讯新闻曾发出一片具有爆炸性的文章。并不是文章的内容有什么新奇之处,而是文章的作者与众不同,写文章的不是人,而是网络机器人,或者说是人工智能,是算法通过分析大量财经文章后,学会了人如何编写财经报道,然后根据相关模式,把各种财经数据组织起来,自动化的生成一篇文章,当人阅读时,根本无法意识到文章不是人写,而是电脑生成的。

    从本节开始,如何使用神经网络构造出一个能阅读,理解人类文本含义的智能程序。就如同前一章讲述的图像识别网络,本质上并不是网络能像人一样看懂了图片内涵,而是网络通过读取大量图片数据,从数据中抽取出某种固定规律,我们本章要开发的神经网络也同理,它会从大量的文本数据中分析抽取出其潜在的固定模式或规律。

    要想让网络能够分析文本,我们首先要做的是将文本进行数据化。它主要包含几个方面的内容:一种方法是将文本分割成词组,并将词组转变为向量。一种方法是将文本分割成一系列字符的组合,然后用向量表示每个字符。第三种方法是把若干个词或字符组合成一个集合,然后将他们转换成向量。无论何种情况,我们都把被向量化的对象成为token,而把整篇文章分解成token的过程叫tokenization。

    举个具体例子,假设我们有一条英文句子”The cat jump over the dog”,如果我们采用第一种方法,那么我们把句子分解成多个单词:’The’,’cat’,’jump’,’over’,’the’,’dog’。然后通过算法为每个单词构造一个向量:
    ‘the’->[0.0, 0.0, 0.4,0.0,1.0,0.0]
    ‘cat’->[0.5, 1.0, 0.5, 0.2, 0.5, 0.5, 0.0]等,后面我们会研究单词是如何转换成向量的。

    有一种把单词向量化的简单方法叫one-hot-encoding,我们在前面章节看过这种向量,它所有元素都是0,只有某个位置是1,例如上面例句中总共有5个不同单词,于是我们可以用含有5个元素的向量来表示:
    ‘The’ -> [1,0,0,0,0], ‘cat’->[0,1,0,0,0], ‘jump’->[0,0,1,0,0]以此类推。

    我们看一段如何将单词进行one-hot-encoding的代码:

    import numpy as np
    samples = ['The cat jump over the dog', 'The dog ate my homework']
    
    #我们先将每个单词放置到一个哈希表中
    token_index = {}
    for sample in samples:
        #将一个句子分解成多个单词
        for word in sample.split():
            if word not in token_index:
                token_index[word] = len(token_index) + 1
    
    #设置句子的最大长度
    max_length = 10
    results = np.zeros((len(samples), max_length, max(token_index.values()) + 1))
    for i, sample in enumerate(samples):
        for j, word in list(enumerate(sample.split()))[: max_length]:
            index = token_index.get(word)
            results[i, j, index] = 1.
            print("{0} -> {1}".format(word, results[i, j]))
    

    上面代码运行后结果如下:

    屏幕快照 2018-08-02 下午4.19.33.png

    其实这种”脏活累活“不需要我们亲自动手,keras框架提供了一系列接口帮我们省却了这些麻烦,下面代码同样能实现相同内容:

    from keras.preprocessing.text import Tokenizer
    samples = ['The cat jump over the dog', 'The dog ate my homework']
    #只考虑最常使用的前1000个单词
    tokenizer = Tokenizer(num_words = 1000)
    tokenizer.fit_on_texts(samples)
    #把句子分解成单词数组
    sequences = tokenizer.texts_to_sequences(samples)
    print(sequences)
    one_hot_vecs = tokenizer.texts_to_matrix(samples, mode='binary')
    
    word_index = tokenizer.word_index
    print("当前总共有%s个不同单词"%len(word_index))

    上面代码运行后,结果如下:

    [[1, 3, 4, 5, 1, 2], [1, 2, 6, 7, 8]]
    当前总共有8个不同单词

    one_hot_vecs对应两个含有1000个元素的向量,第一个向量的第1,3,4,5个元素为1,其余全为0,第二个向量第1,2,6,7,8个元素为1,其余全为0.

    接下来我们要看自然语言处理中一个极为关键的概念叫word embedding,也就是用非零向量来表示每一个单词。one-hot-vector对单词进行编码有很多缺陷,一是冗余过多,一大堆0,然后只有一个1,二是向量的维度过高,有多少个单词,向量就有多少维度,这会给计算带来很多麻烦,word-embedding把原来高维度的冗余向量转换为低纬度的,信息量强的向量,转换后的向量,无论单词量多大,向量的维度一般只有256维到1024维。

    单词向量化的一个关键目标是,意思相近的单词,他们对应的向量之间的距离要接近,例如”good”,”fine”都表示“好”的意思,因此这两个单词对应的向量在空间上要比较接近的,也就是说意思相近的单词,他们对应的向量在空间上的距离应该比较小。假设给定4个单词:‘cat’, ‘dog’, ‘wolf’, ‘tiger’,其中前两个猫和狗相似性强,后两个狼和狗相似性强,因此当他们转换成向量时,在空间距离上会形成两个集合,例如下图:

    屏幕快照 2018-08-02 下午5.16.10.png

    给定一个单词,我们如何生成对应向量呢?我们可以构造一个网络来实现这个目标,假设有两个单词,”good”, “fine”,我们随机给他们赋值两个向量,然后不断的训练网络,让这两个向量之间的距离变得越来越小,好在我们不用从零开始开发这样的网络,keras框架给我们提供了现成可用的类似网络,我们看下面一段代码:

    from keras.layers import Embedding
    #Embedding对象接收两个参数,一个是单词量总数,另一个是单词向量的维度
    embedding_layer = Embedding(1000, 64) 

    上面代码创建一个叫Embedding的网络层,它接收的参数格式如(samples, sequence_length),假设我们现在有32条句子,每条句子最多包含10个单词,那么我们提交的输入参数就是(32, 10),Embedding一开始会给每个单词随意生成一个含有64个元素的向量,然后通过读入大量的数据,调整每个单词对应的向量,让意思相近的单词所对应的向量在空间上的距离越来越近。

    详细理论不多说,我们先跑起来一个例子,看看如何分析影评文本所展现的情绪,我们使用的还是以前见过的IMDB数据,我们只抽取每篇影评的前20个单词,然后为单词向量化,由于影评中只有两种情绪,好和坏,好影评中所用到的单词大多含有“好”的意思,因此对应的向量在空间上会聚合在一起形成一个集合,坏影评使用的单词大多都包含“坏”的意思,于是他们对应的向量就会聚合到一起形成另一个集合,当遇到新影评时,我们也把它的前20个单词向量化,然后看这些向量靠近哪一个集合,如果靠近第一个集合,我们就预测该影评包含正能量,如果靠近第二个集合,我们就认为影评包含负能量。我们看看代码的实现:

    from keras.models import Sequential
    from keras.layers import Flatten, Dense
    
    model = Sequential()
    #在网络中添加Embedding层,专门用于把单词转换成向量
    model.add(Embedding(10000, 8, input_length=maxlen))
    
    '''
    我们给Embeding层输入长度不超过maxlen的单词向量,它为每个单词构造长度为8的向量
    它会输出格式为(samples, maxlen, 8)的结果,然后我们把它转换为(samples, maxlen*8)的
    二维格式
    '''
    model.add(Flatten())
    
    #我们在顶部加一层只含有1个神经元的网络层,把Embedding层的输出结果对应成两个类别
    model.add(Dense(1, activation='sigmoid'))
    model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics = ['acc'])
    model.summary()
    
    history = model.fit(x_train, y_train, epochs = 10, batch_size = 32, validation_split=0.2)

    运行上面代码后,我们把结果绘制出来,看看网络对检验是数据集的识别准确率:

    import matplotlib.pyplot as plt
    
    acc = history.history['acc']
    val_acc = history.history['val_acc']
    loss = history.history['loss']
    val_loss = history.history['val_loss']
    
    epochs = range(1, len(acc) + 1)
    
    #绘制模型对训练数据和校验数据判断的准确率
    plt.plot(epochs, acc, 'bo', label = 'trainning acc')
    plt.plot(epochs, val_acc, 'b', label = 'validation acc')
    plt.title('Trainning and validation accuary')
    plt.legend()
    
    plt.show()
    plt.figure()
    
    #绘制模型对训练数据和校验数据判断的错误率
    plt.plot(epochs, loss, 'bo', label = 'Trainning loss')
    plt.plot(epochs, val_loss, 'b', label = 'Validation loss')
    plt.title('Trainning and validation loss')
    plt.legend()
    
    plt.show()

    上面代码运行后结果如下:

    屏幕快照 2018-08-03 上午8.28.29.png

    我们从上图可以看到蓝色实线看出,仅仅通过将影评的前20个单词向量化,在没使用任何调优手段的情况下,网络对校验是数据的识别准确率就达到75%左右。

    还记得前面我们使用预先训练好的网络大大提升图片识别率吗,单词向量化也一样,有人使用上面提到的Embedding网络层分析读取大量文本后,为常用的英文单词都建立了对应的向量。我们自己运用神经网络处理具体问题时,一大困难在于数据量太少,巧妇难为无米之炊,数据量太小,神经网络的精确度会受到极大的制约,如果我们手上的文本数量很少,那么为单词建立的向量就不会很准确,要弥补这些缺陷,我们可以使用别人训练好的结果。

    网络时代的一大优势就是,有人愿意把自己的劳动果实无偿分享出来。当前实现单词向量化的最好算法是由Google研究员Mikolov在2013年发明的Word2Vec算法,有人或组织就使用该算法分析大量英文文本后,为常用的单词建立向量,并把这些向量信息放在网上供人下载。另一个常用的单词向量数据库叫”GloVe”,是由斯坦福教授根据单词的统计特性开发的向量化算法对常用单词向量化后形成的数据库。

    在下一节我们将看看,如何使用预先训练的单词向量化数据”GloVe”实现原始文本的分割,量化并进行有效的分析。

    更详细的讲解和代码调试演示过程,请点击链接

    更多技术信息,包括操作系统,编译器,面试算法,机器学习,人工智能,请关照我的公众号:
    这里写图片描述

    展开全文
  • 本文为大家分享了Python文本特征抽取与向量化的具体代码,供大家参考,具体内容如下 假设我们刚看完诺兰的大片《星际穿越》,设想如何让机器来自动分析各位观众对电影的评价到底是“赞”(positive)还是“踩”...
  • 文本向量化的原理

    2021-03-05 11:35:31
    一、文本分词将需要进行分析的文本进行分词(英文直接按照空格分隔词汇,中文则需通过分词工具分隔之后,把词之间加上空格)二、去停用词在文本中可以发现类似”the”、”a”等词的词频很高,但是这些词并不能表达文本...

    一、文本分词

    将需要进行分析的文本进行分词(英文直接按照空格分隔词汇,中文则需通过分词工具分隔之后,把词之间加上空格)

    二、去停用词

    在文本中可以发现类似”the”、”a”等词的词频很高,但是这些词并不能表达文本的主题,我们称之为停用词。

    对文本预处理的过程中,我们希望能够尽可能提取到更多关键词去表达这句话或文本的中心思想,因此我们可以将这些停用词去掉后再编码。

    三、将词编号

    按照词频(次出现的频率)进行倒序编号,如英文中一篇文章出现最多的应该是“a”,“the”等词汇(假设‘a’出现次数大于‘the’),则把“a”编号为“1”,‘the’编号为“2”,以此类推。

    这样在文本中出现过的词都会有自己特有的编号。对每个词编码之后,每句话中的每个词就可以用对应的编码表示,即每条文本已经转变成一个向量了。

    四、文本长度统一

    对每个词编码之后,每条文本中的每个词就可以用对应的编码表示,即每条文本已经转变成一个向量。但是,由于文本的长度不唯一,需要将每条文本的长度设置一个固定值。

    假设每个句子的长度都固定为100,如果长度大于100,则将超过的部分截掉;如果小于100,则在最前面用0填充。

    五、将词编码转化为词向量

    在神经网络中一般要将文本转化成矩阵进行计算,单单将文本转化为向量还是不够,所以需要将每个词编码转化成词向量。

    此步骤一般先使用“one-hot”编码方式编码,这样就会将一条文本转化为一个n*n的矩阵(n表示文本中出现的不同的词个数)。然后通过神经网络的训练迭代更新得到一个合适的权重矩阵(具体实现过程可以参考skip-gram模型),行大小为n,列大小为词向量的维度(小于n)。

    至此已经将文本数据预处理完毕,将每个影评样本转换为一个数字矩阵,矩阵的每一行表示一个词向量。

    展开全文
  • ClickHouse在计算层做了非常细致的工作,竭尽所能榨干硬件能力,提升查询速度。它实现了单机多核并行、分布式计算、向量化执行与SIMD指令、代码生成等多种重要技术。多核并行ClickH...

    ClickHouse在计算层做了非常细致的工作,竭尽所能榨干硬件能力,提升查询速度。它实现了单机多核并行、分布式计算、向量化执行与SIMD指令、代码生成等多种重要技术。

    多核并行

    ClickHouse将数据划分为多个partition,每个partition再进一步划分为多个index granularity,然后通过多个CPU核心分别处理其中的一部分来实现并行数据处理。

    在这种设计下,单条Query就能利用整机所有CPU。极致的并行处理能力,极大的降低了查询延时。

    分布式计算

    除了优秀的单机并行处理能力,ClickHouse还提供了可线性拓展的分布式计算能力。ClickHouse会自动将查询拆解为多个task下发到集群中,然后进行多机并行处理,最后把结果汇聚到一起。

    向量化执行与SIMD

    ClickHouse不仅将数据按列存储,而且按列进行计算。传统OLTP数据库通常采用按行计算,原因是事务处理中以点查为主,SQL计算量小,实现这些技术的收益不够明显。但是在分析场景下,单个SQL所涉及计算量可能极大,将每行作为一个基本单元进行处理会带来严重的性能损耗:

    •对每一行数据都要调用相应的函数,函数调用开销占比高;

    •存储层按列存储数据,在内存中也按列组织,但是计算层按行处理,无法充分利用CPU cache的预读能力,造成CPU Cache miss严重;•按行处理,无法利用高效的SIMD指令;

    ClickHouse实现了向量执行引擎(Vectorized execution engine),对内存中的列式数据,一个batch调用一次SIMD指令(而非每一行调用一次),不仅减少了函数调用次数、降低了cache miss,而且可以充分发挥SIMD指令的并行能力,大幅缩短了计算耗时。向量执行引擎,通常能够带来数倍的性能提升。

    What IS SIMD ?

    SIMD

    即 single instruction multiple data 英文首字母缩写,单指令流多数据流,也就是说一次运算指令可以执行多个数据流,一个简单的例子就是向量的加减。

    SSE 与 SMID 关系

    SSE(为Streaming SIMD Extensions的缩写)是由 Intel公司在1999年推出Pentium III处理器时,同时推出的新指令集。如同其名称所表示的,SSE是一种SIMD指令集。SSE有8个128位寄存器,XMM0 ~XMM7。可以用来存放四个32位的单精确度浮点数。可以看出,SSE 是一套专门为 SIMD(单指令多数据)架构设计的指令集。通过它,用户可以同时在多个数据片段上执行运算,实现数据并行(aka:矢量处理)。

    SSE2是SSE指令的升级版,寄存器与指令格式都和SSE一致,不同之处在于其能够处理双精度浮点数等更多数据类。SSE3增加了13条新的指令。

    参考:https://www.cnblogs.com/xidian-wws/p/11023762.html

    C++使用SIMD编程的3种方法

    SIMD指令集的使用,有如下三种方式:

    编译器优化 即使用C/C++编写程序之后,带有SIMD优化选项编译,在CPU支持的情况下,编译器按照自己的规则去优化。•使用intrinsic指令 参考Intel手册,针对SIMD指令,可以在编程时直接使用其内置的某些库函数,编译的时候在cpu和编译器的支持下会生成对应的SIMD指令。比如:double _mm_cvtsd_f64 (__m128d a) 该函数编译时就会翻译成指令:movsd•嵌入式汇编 内联汇编直接在程序中嵌入对应的SIMD指令。

    Intrinsics头文件与SIMD指令集、Visual Studio版本对应表

    VS和GCC都支持SSE指令的Intrinsic,SSE有多个不同的版本,其对应的Intrinsic也包含在不同的头文件中,如果确定只使用某个版本的SSE指令则只包含相应的头文件即可。

    例如,要使用SSE3,则

    #include <tmmintrin.h>
    

    如果不关心使用那个版本的SSE指令,则可以包含所有

    #include <intrin.h>
    

    参考资料:https://www.cnblogs.com/huaping-audio/p/4115890.html

    简单运算的Intrinsic和SSE指令对比 使用Intrinsic函数的代码:

      __m128 a1, b2;
      __m128 c1;
     for (int i = 0; i < count; i++)
     {
          a1 = _mm_load_ps(a);
          b2 = _mm_load_ps(b);
          c1 = _mm_add_ps(a1,  b2);
      }
    

    对应汇编指令代码:

       for(int i = 0; i < count; i ++)
        _asm
        {
            movaps  xmm0, [a];
            movaps  xmm1, [b];
            addps  xmm0, xmm1;
        }
    

    简要说明其中一种操作:

    addps XMM,XMM/m128 源存储器内容按双字对齐,共4个单精度浮点数与目的寄存器相加,结果送入目的寄存器

    计算机硬件支持与编译器支持

    要能够使用 Intel 的 SIMD 指令集,不仅需要当前 Intel 处理器的硬件支持,还需要编译器的支持。

    $ grep -q sse4_2 /proc/cpuinfo && echo "SSE 4.2 supported" || echo "SSE 4.2 not supported"
    

    如果你的机器支持SSE4.2,那么,将打印:

    SSE 4.2 supported
    

    使用SIMD考量

    利用优点: 频繁调用的基础函数,大量的可并行计算•尽量避免: SSE指令集对分支处理能力非常的差,而且从128位的数据中提取某些元素数据的代价又非常的大,因此不适合有复杂逻辑的运算。

    How Clickhouse USE SIMD ?

    大家在搜索CLICKHOUSE为什么快的文章中,都提到了CH使用到的技术列式存储,压缩,向量引擎。

    CH在所有能够提高CPU计算效率的地方,都大量的使用了SIMD。

    本文以clickhouse其中的一个简单的LowerUpperImpl函数为例(这个函数完成大小写转换)。

    测试产出SIMD模式与非SIMD模式下benchmark的效率对比。

    code如下,关键节点已加注释:

      template <char not_case_lower_bound, char not_case_upper_bound>
    struct LowerUpperImpl
    {
    public:
       static void array( char * src, char * src_end, char * dst)
       {
           //32
           const auto flip_case_mask = 'A' ^ 'a';
    #ifdef __SSE2__
           const auto bytes_sse = sizeof(__m128i);
           const auto src_end_sse = src_end - (src_end - src) % bytes_sse;
           const auto v_not_case_lower_bound = _mm_set1_epi8(not_case_lower_bound - 1);
           const auto v_not_case_upper_bound = _mm_set1_epi8(not_case_upper_bound + 1);
           const auto v_flip_case_mask = _mm_set1_epi8(flip_case_mask);
           for (; src < src_end_sse; src += bytes_sse, dst += bytes_sse)
           {
               //_mm_loadu_si128表示:Loads 128-bit value;即加载128位值。
               //一次性加载16个连续的8-bit字符
               const auto chars = _mm_loadu_si128(reinterpret_cast<const __m128i *>(src));
               //_mm_and_si128(a,b)表示:将a和b进行与运算,即r=a&b
               //_mm_cmpgt_epi8(a,b)表示:分别比较a的每个8bits整数是否大于b的对应位置的8bits整数,若大于,则返回0xff,否则返回0x00。
               //_mm_cmplt_epi8(a,b)表示:分别比较a的每个8bits整数是否小于b的对应位置的8bits整数,若小于,则返回0xff,否则返回0x00。
               //下面的一行代码对这128位的寄存器并行操作了3遍,最后得到一个128位数,对应位置上是0xff的,表示
               //那个8-bit数在 [case_lower_bound, case_upper_bound]范围之内的,其余的被0占据的位置,是不在操作范围内的数。
               const auto is_not_case
                   = _mm_and_si128(_mm_cmpgt_epi8(chars, v_not_case_lower_bound), _mm_cmplt_epi8(chars, v_not_case_upper_bound));
               //每个0xff位置与32进行与操作,原来的oxff位置变成32,也就是说,每个在 [case_lower_bound, case_upper_bound]范围区间的数,现在变成了32,其他的位置是0
               const auto xor_mask = _mm_and_si128(v_flip_case_mask, is_not_case);
               //将源chars内容与xor_mask进行异或,符合条件的字节可能从uppercase转为lowercase,也可能从lowercase转为uppercase,不符合区间的仍保留原样。
               const auto cased_chars = _mm_xor_si128(chars, xor_mask);
               //将结果集存到dst中
               _mm_storeu_si128(reinterpret_cast<__m128i *>(dst), cased_chars);
           }
    #endif
    #ifndef __SSE2__
           for (; src < src_end; ++src, ++dst)
               if (*src >= not_case_lower_bound && *src <= not_case_upper_bound)
                   *dst = *src ^ flip_case_mask;
               else
                   *dst = *src;
    #endif
       }
    };
    

    完整代码参考 这里[1]

    测试结果如下:

    32位输入:

    root@2458d1317fc8:/var/tmp# g++ -std=c++11 -Wall -pedantic -pthread sse.cpp && ./a.out
    new des is abcdefghabcdefghabcdefghabcdefgh
    花费了6.8059秒
    root@2458d1317fc8:/var/tmp# g++ -std=c++11 -Wall -pedantic -pthread nosse.cpp && ./a.out
    new des is abcdefghabcdefghabcdefghabcdefgh
    花费了9.39051秒
    

    64位输入:

    root@2458d1317fc8:/var/tmp# g++ -std=c++11 -Wall -pedantic -pthread sse.cpp && ./a.out
    new des is abcdefghabcdefghabcdefghabcdefghabcdefghabcdefghabcdefghabcdefgh
    花费了9.26642秒
    root@2458d1317fc8:/var/tmp# g++ -std=c++11 -Wall -pedantic -pthread nosse.cpp && ./a.out
    new des is abcdefghabcdefghabcdefghabcdefghabcdefghabcdefghabcdefghabcdefgh
    花费了17.3588秒
    

    128位输入:

    root@2458d1317fc8:/var/tmp# g++ -std=c++11 -Wall  -pedantic -pthread sse.cpp && ./a.out
    new des is abcdefghabcdefghabcdefghabcdefghabcdefghabcdefghabcdefghabcdefghabcdefghabcdefghabcdefghabcdefghabcdefghabcdefghabcdefghabcdefgh
    花费了10.2672秒
    root@2458d1317fc8:/var/tmp# g++ -std=c++11 -Wall  -pedantic -pthread nosse.cpp && ./a.out
    new des is abcdefghabcdefghabcdefghabcdefghabcdefghabcdefghabcdefghabcdefghabcdefghabcdefghabcdefghabcdefghabcdefghabcdefghabcdefghabcdefgh
    花费了31.7568秒
    

    这只是其中一个简单的函数。但,为什么Clickhouse快?管中窥豹,可见一斑。

    Clickhouse 仅短短几年在OLAP领域横空出世,这和Clickhouse在设计和细节上追求极致密不可分。

    对于俄罗斯人,开源一款产品可是大事。但不开源还则罢了。一旦开源,必是行业大事。一如nginx。

    本文转载自:https://www.jianshu.com/p/fc384f18ff1a,作者:金科_

    引用链接

    [1] 这里: https://github.com/Johnny-Three/clickhousedive/blob/master/main.cpp

    展开全文
  • 因为字典数据无法运算、分析,此操作可将字典根据特征生成向量化数据 示例代码: def dictvec(): """ 字典数据特征抽取,向量化 :return: """ # 1 新建向量化器实例 dic = DictVectorizer(sparse=False) # ...

    希望与热爱编程的人多多交流,共同进步。

    字典数据向量化

    因为字典数据无法运算、分析,此操作可将字典根据特征生成向量化数据
    示例代码:

    def dictvec():
        """
        字典数据特征抽取,向量化
        :return:
        """
        # 1 新建向量化器实例
        dic = DictVectorizer(sparse=False)  # sparse是否稀疏
        # 2 调用fit_transform方法,执行向量化
        data = dic.fit_transform([
            {'city': '北京', 'pos': '北方', 'temperature': 100},
            {'city': '上海', 'pos': '东方', 'temperature': 60},
            {'city': '深圳', 'pos': '南方', 'temperature': 30},
            {'city': '重庆', 'pos': '南方', 'temperature': 70},
        ])
        print(dic.get_feature_names())
        print(data)
        # ps: 反向量化,恢复成原始数据形式
        print(dic.inverse_transform(data)[0])
    
    dictvec()
    

    文本特征值化

    以每个词出现次数形成向量化数据,示例代码:

    def countvec():
        """
        对文本进行特征值化,统计文本出现的次数
        :return:
        """
        cv = CountVectorizer()
        data = cv.fit_transform(['this is a test text', 'we have a test'])
        print(cv.get_feature_names())
        print(data.toarray())
    
    countvec()
    

    中文特征值化

    先结巴分词,才可以调用文本特征值化
    切词示例代码:

    import jieba
    
    def cutword():
        # 切词返回一个生成器
        con1 = jieba.cut('床前明月光,我要学python。')
        con2 = jieba.cut('床前明月光,疑是地上霜。')
        con3 = jieba.cut('生存或死亡,这是一个问题。')
        # 转换成列表
        content1 = list(con1)
        content2 = list(con2)
        content3 = list(con3)
        # 把列表转换成字符串,空格分开因为特征值化需要符合英文风格
        c1 = ' '.join(content1)
        c2 = ' '.join(content2)
        c3 = ' '.join(content3)
    
        return c1, c2, c3
    

    特征值化代码:

    def hanzivec():
        """
        中文特征值化,先用结巴分词
        :return:
        """
        # 调用切词方法得到切割后的字符串
        c1, c2, c3 = cutword()
        cv = CountVectorizer()
        print(c1, c2, c3)
        data = cv.fit_transform([c1, c2, c3])
        for f_name in cv.get_feature_names():
            print(f_name)
        print(data)
        print(data.toarray())
    
    hanzivec()
    

    归一化处理

    按比例缩放至指定的范围
    示例代码:

    def mm():
        """
        按列,一列表示一个特征
        归一化处理,指定范围缩放
        :return:
        """
        # feature_range 指定缩放后的值在2到3之间
        mm = MinMaxScaler(feature_range=(2, 3))
        data = mm.fit_transform([[90, 2, 10, 40],
                                 [60, 4, 15, 45],
                                 [75, 3, 13, 46]])
        print(data)
    
    mm()
    

    标准化处理

    各特征的值域差距过大,使用标准化缩放至符合N~(0,1)的空间
    示例代码:

    def stand():
        """
        按列,一列表示一个特征
        标准化缩放,化到均值为0,标准差为1的区间
        :return:
        """
        std = StandardScaler()
        data = std.fit_transform([[1., -1., 3.], [2., 4., 2.], [4., 6., -1.]])
        print(data)
    
    stand()
    
    展开全文
  • 1 #文本切分函数,用来对中文文本分词,包括除去数字字母以及停用词,得到一个分词用空格隔开的字符串,便于下面向量化(因为这个CountVouterizer()是针对英文分词的,英文之间直接用空格隔开的) 2 defcut_word...
  • 神经网络向量化

    千次阅读 2016-04-23 11:55:23
    神经网络向量化 在本节,我们将引入神经网络的向量化版本。在前面关于神经网络介绍的章节中,我们已经给出了一个部分向量化的实现,它在一次输入一个训练样本时是非常有效率的。下边我们看看如何实现同时处理多个...
  • 一、向量化操作概述Python内置一系列强大的字符串处理方法,但这些方法只能处理单个字符串,处理一个序列的字符串时,需要用到循环。那么,有没有办法,不用循环就能同时处理多个字符串呢,pa...
  • 之前讲过用商品协同过滤的方法来进行召回...这篇文章尝试了三种不同的词向量化方法,以及提出了一种自动化构建下游任务的方法,来评估词向量方法的优劣。 1. 词向量化方法 1.1
  • 总结一下文本向量化 文本分析是机器学习算法的一个主要应用领域。然而,原始数据的这些符号序列不能直接提供给算法进行训练,因为大多数算法期望的是固定大小的数字特征向量,而不是可变长度的原始文本。 为了解决这...
  • word2vec学习笔记之文本向量化概述

    千次阅读 2020-01-25 14:59:53
    文本向量化表示的发展历程1.1 one-hot 1. 文本向量化表示的发展历程 在NLP的处理中,我们需要讲文本输入到模型中处理,实现分类识别,文本生成或者翻译等工作。而模型是无法知道一个纯粹的文本是什么意思的,模型的...
  • 逻辑回归的向量化实现样例

    千次阅读 2016-04-23 11:50:16
    逻辑回归的向量化实现样例 我们想用批量梯度上升法对logistic回归分析模型进行训练,其模型如下: 让我们遵从公开课程视频与CS229教学讲义的符号规范,设 ,于是 ,, 为截距。假设我们有m个训练样本{...
  • word2vec词向量化算法

    2020-04-22 10:11:07
    word2vec就是一个将词向量化的工具,这里我们使用的是gensim的word2vec。 1、one-hot编码 在介绍Word2vec之前,我们先来看一下one-hot,它是指词向量维度大小为整个词汇表的大小,对于每个具体的词汇表中的词,将...
  • 学习目标    • 了解自然语言处理基本知识 ...• 文本向量化:将文本表示成一系列能够表达文本语义的向量。常用的向量化算法有:       • one-hot  &nb
  • 文本向量化 2.1 词集模型和词代模型 2.2 n-gram 2.3 TF-IDF 2.4 word2vec 2.5 主题词模型 3. 总结 1. 文本相似度计算-文本向量化 2. 文本相似度计算-距离的度量 3. 文本相似度计算-DSSM算法 4. ...
  • 神经网络向量化实现

    千次阅读 2017-04-06 23:16:45
    矢量编程 当使用学习算法时,一段更快的代码通常意味着项目进展更快。例如,如果你的学习算法需要花费20分钟运行完成,这意味着你每个小时能“尝试”3个新主意。但是假如你的程序需要20个小时来运行,这意味着...
  • 文本向量化的方法

    万次阅读 2017-02-10 16:54:40
    向量空间模型(Vector Space Model)[3],又称词袋...词向量化就是把每个词都用一个向量来表示,真是把计算机的最后一滴血榨干啊。但是不得不说这是个天才的做法。因为想到是容易的,我也想到了,但是做到这么好还真
  • 词语向量化-word2vec简介和使用

    万次阅读 多人点赞 2017-06-09 02:39:47
    一句话概括词向量用处:就是提供了一种数学的方法,把自然语言这种符号信息转化为向量形式的数字信息。这样就把自然语言问题要转化为机器学习问题。 最常用的词向量模型无非是 one-hot Representation模型和 ...
  • 文本处理-分词、向量化、TF-IDF理论和实现

    万次阅读 多人点赞 2018-06-28 18:00:18
    英文单词天然有空格隔开容易按照空格分词,但是也有时候需要把多个单词做为一个分词,比如一些名词如“New York”,需要做为一个词看待。而中文由于没有空格,分词就是一个需要专门去解决的问题了。无论是英文还是...
  • 本节主要讨论三种方法实现中文文本的向量化,编程环境python3.6. TF 词频的方法 TFIDF 词频-逆文档频率 Word2Vec 第一种TF方式,即是基于词频的方式,举一个最简单的例子: 1:今天天气不错! 2:今天天气很好。 ...
  • 词袋模型首先会进行分词,在分词之后,通过统计每个词在文本中出现的次数,我们就可以得到该文本基于词的特征,如果将各个文本样本的这些词与对应的词频放在一起,就是我们常说的向量化向量化完毕后一般也会使用TF...
  • 文本向量化 文本向量化 : 把文本转化为计算机认识的形式的过程. 一, 向量化的粒度分类: 1, 以字或单词为单位,中文就是单个字,英文可以是一个单词。 2, 以词为单位,就需要加入一个分词的过程。分词算法本身是一个...
  • Stanford UFLDL教程 神经网络向量化

    千次阅读 2015-12-05 19:01:38
    神经网络向量化 在本节,我们将引入神经网络的向量化版本。在前面关于神经网络介绍的章节中,我们已经给出了一个部分向量化的实现,它在一次输入一个训练样本时是非常有效率的。下边我们看看如何实现同时处理多个...
  • 注: 原文中使用的表示 大多是 “Word Embeddings”, 一般应当翻译做 “词嵌入”, 但是现在一般会将之等同于 “Word vectorization”, 也就是我们现在常听到的词向量化,为了方便理解和记忆,这里直接将其翻译为...
  • 词袋模型首先会进行分词,在分词之后,通过统计每个词在文本中出现的次数,我们就可以得到该文本基于词的特征,如果将各个文本样本的这些词与对应的词频放在一起,就是我们常说的向量化向量化完毕后一般也会使用TF...
  • text="深度学习(英文:deep learning)是机器学习的分支,是一种以人工神经网络为架构,对数据进行表征学习的算法" cuted=jieba.lcut(text) #获取到列表的格式 "假设为2_gram " "注意这里len(c
  • 用Python开始机器学习(5:文本特征抽取与向量化

    万次阅读 多人点赞 2014-11-26 22:09:23
    文本特征抽取与向量化 TF-IDF 词频-反转文档频率
  • 一句话概括词向量用处:就是提供了一种数学的方法,把自然语言这种符号信息转化为向量形式的数字信息。这样就把自然语言问题要转化为机器学习问题。 最常用的词向量模型无非是 one-hot Representation模型和 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 39,310
精华内容 15,724
关键字:

向量化英文