精华内容
下载资源
问答
  • 目录背景文本分词N-gram特征统计N-gram的概率计算N-gram的用途N-gramN的确定参考关于作者 背景 因为平时建模过程会碰到一些文本类的特征,所以整理了下该怎样处理文本特征,以及怎样做文本特征类的衍生,涉及...

    背景

    因为平时建模过程中会碰到一些文本类的特征,所以整理了下该怎样处理文本特征,以及怎样做文本特征类的衍生,涉及到NLP的内容很浅显。
    如果想深入学习NLP,请移步到大神微博…

    文本分词

    利用python中的jieba、中科院、清华、哈工大的一些分词工具来进行分词处理。在处理词类时一般关注词性、词与上下文之间是否有强联系之类的问题。统计分词word前后word的分布概率,通过P(pre_word|word)等合并成词概率高的词。

    N-gram特征统计

    N-gram模型是一种语言模型,语言模型是一个基于概率的判别模型,他的输入是一句话(单词的顺序序列),输出的是这句话的概率,即这些单词的联合概率
    在这里插入图片描述
    N-gram的特点:

    1. 某个词的出现依赖于其他若干个词
    2. 我们获得信息越多,预测越准确

    N-gram本身也指一个由N个单词组成的集合,各单词具有先后顺序,且不要求单词之间互不相同。常用的有 Bi-gram (N=2) 和 Tri-gram (N=3),一般已经够用了。例如在上面这句话里,我可以分解的 Bi-gram 和 Tri-gram :
    Bi-gram : {I, love}, {love, deep}, {love, deep}, {deep, learning}
    Tri-gram : {I, love, deep}, {love, deep, learning}

    N-gram中的概率计算

    假设我们有一个由n个词组成的句子S=(ω1,ω2,......,ωn)S=(\omega_1,\omega_2,......,\omega_n),如何衡量他的概率呢?假设每个单词ωi\omega_i都要依赖于从第一个单词ω1\omega_1到它之前一个单词ωi=1\omega_{i=1}的影响:
    p(S)=p(ω1ω2...ωn)=p(ω1)p(ω2ω1)...p(ωnωn1...ω2ω1)p(S)=p(\omega_1\omega_2...\omega_n) = p(\omega_1)p(\omega_2|\omega_1)...p(\omega_n|\omega_{n-1}...\omega_2\omega_1)
    这个衡量方法存在两个缺陷:

    • 参数空间过大:概率p(ωnωn1...ω2ω1)p(\omega_n|\omega_{n-1}...\omega_2\omega_1)的参数有O(n)个
    • 数据稀疏严重,词同时出现的情况可能没有,组合阶数高时尤其明显

    解决第一个问题–引入马尔科夫假设:一个词的出现仅与它之前若干个词有关

    • 如果一个词的出现仅依赖于他前面出现的一个词,就是Bi-gram
      p(S)=p(ω1ω2...ωn)=p(ω1)p(ω2ω1)...p(ωnωn1)p(S) = p(\omega_1\omega_2...\omega_n) = p(\omega_1)p(\omega_2|\omega_1)...p(\omega_n|\omega_{n-1})
    • 如果一个词的出现仅依赖于他前面出现的一个词,就是Tri-gram
      p(S)=p(ω1ω2...ωn)=p(ω1)p(ω2ω1)...p(ωnωn1ωn1)p(S) = p(\omega_1\omega_2...\omega_n) = p(\omega_1)p(\omega_2|\omega_1)...p(\omega_n|\omega_{n-1}\omega_{n-1})
      N-gram的N可以取很高,现实中一般Bi-gram和Tri-gram就够用了
      极大似然估计求P

    N-gram的用途

    • 词性标注
    • 垃圾短信分类
    • 分词器机器翻译和语音识别

    N-gram中N的确定

    为了确定N的取值,《Language Modeling with Ngrams》使用了 Perplexity 这一指标,该指标越小表示一个语言模型的效果越好。
    在这里插入图片描述

    参考

    https://blog.csdn.net/songbinxu/article/details/80209197

    关于作者

    知乎

    展开全文
  • 怎样把词向量从 Word2vec 模型中提取出来?Word2vec 对 Embedding 技术的奠基性意义Item2Vec:Word2vec 方法的推广Word2vec代码实现 提到 Embedding,就一定要深入讲解一下 Word2vec。它不仅让词向量在自然语言处理...


    提到 Embedding,就一定要深入讲解一下 Word2vec。它不仅让词向量在自然语言处理领域再度流行,更关键的 是,自从 2013 年谷歌提出 Word2vec 以来,Embedding 技术从自然语言处理领域推广到广告、搜索、图像、推 荐等几乎所有深度学习的领域,成了深度学习知识框架中不可或缺的技术点。Word2vec 作为经典的 Embedding 方法,熟悉它对于我们理解之后所有的 Embedding 相关技术和概念都是至关重要的。下面,我就给你详细讲一讲 Word2vec 的原理。

    什么是 Word2vec?

    Word2vec 是“word to vector”的简称,顾名思义,它是一个生成对“词”的向量表达的模型。 想要训练 Word2vec 模型,我们需要准备由一组句子组成的语料库。假设其中一个长度为 T 的句子包含的词有 w1,w2……wt,并且我们假定每个词都跟其相邻词的关系最密切。

    根据模型假设的不同,Word2vec 模型分为两种形式,CBOW 模型(图 3 左)和 Skip-gram 模型(图 3 右)。其 中,CBOW 模型假设句子中每个词的选取都由相邻的词决定,因此我们就看到 CBOW 模型的输入是 wt周边的词, 预测的输出是 wt。Skip-gram 模型则正好相反,它假设句子中的每个词都决定了相邻词的选取,所以你可以看到 Skip-gram 模型的输入是 wt,预测的输出是 wt周边的词。按照一般的经验,Skip-gram 模型的效果会更好一些, 所以我接下来也会以 Skip-gram 作为框架,来给你讲讲 Word2vec 的模型细节

    在这里插入图片描述

    Word2vec 的样本是怎么生成的?

    我们先来看看训练 Word2vec 的样本是怎么生成的。 作为一个自然语言处理的模型,训练 Word2vec 的样本当然 来自于语料库,比如我们想训练一个电商网站中关键词的 Embedding 模型,那么电商网站中所有物品的描述文字 就是很好的语料库。

    我们从语料库中抽取一个句子,选取一个长度为 2c+1(目标词前后各选 c 个词)的滑动窗口,将滑动窗口由左至 右滑动,每移动一次,窗口中的词组就形成了一个训练样本。根据 Skip-gram 模型的理念,中心词决定了它的相邻 词,我们就可以根据这个训练样本定义出 Word2vec 模型的输入和输出,输入是样本的中心词,输出是所有的相邻 词。

    为了方便你理解,我再举一个例子。这里我们选取了“Embedding 技术对深度学习推荐系统的重要性”作为句子样 本。首先,我们对它进行分词、去除停用词的过程,生成词序列,再选取大小为 3 的滑动窗口从头到尾依次滑动生 成训练样本,然后我们把中心词当输入,边缘词做输出,就得到了训练 Word2vec 模型可用的训练样本。

    Word2vec 模型的结构是什么样的?

    有了训练样本之后,我们最关心的当然是 Word2vec 这个模型的结构是什么样的。我相信,通过第 3 节课的学习, 你已经掌握了神经网络的基础知识,那再理解 Word2vec 的结构就容易多了,它的结构本质上就是一个三层的神经 网络(如图 5)。

    在这里插入图片描述
    它的输入层和输出层的维度都是 V,这个 V 其实就是语料库词典的大小。假设语料库一共使用了 10000 个词,那 么 V 就等于 10000。根据图 4 生成的训练样本,这里的输入向量自然就是由输入词转换而来的 One-hot 编码向 量,输出向量则是由多个输出词转换而来的 Multi-hot 编码向量,显然,基于 Skip-gram 框架的 Word2vec 模型解 决的是一个多分类问题。

    隐层的维度是 N,N 的选择就需要一定的调参能力了,我们需要对模型的效果和模型的复杂度进行权衡,来决定最 后 N 的取值,并且最终每个词的 Embedding 向量维度也由 N 来决定。

    最后是激活函数的问题,这里我们需要注意的是,隐层神经元是没有激活函数的,或者说采用了输入即输出的恒等 函数作为激活函数,而输出层神经元采用了 softmax 作为激活函数。

    你可能会问为什么要这样设置 Word2vec 的神经网络,以及我们为什么要这样选择激活函数呢?因为这个神经网络 其实是为了表达从输入向量到输出向量的这样的一个条件概率关系,我们看下面的式子:

    在这里插入图片描述
    这个由输入词 WI 预测输出词 WO 的条件概率,其实就是 Word2vec 神经网络要表达的东西。我们通过极大似然的 方法去最大化这个条件概率,就能够让相似的词的内积距离更接近,这就是我们希望 Word2vec 神经网络学到的。

    当然,如果你对数学和机器学习的底层理论没那么感兴趣的话,也不用太深入了解这个公式的由来,因为现在大多 数深度学习平台都把它们封装好了,你不需要去实现损失函数、梯度下降的细节,你只要大概清楚他们的概念就可 以了

    如果你是一个理论派,其实 Word2vec 还有很多值得挖掘的东西,比如,为了节约训练时间,Word2vec 经常会采 用负采样(Negative Sampling)或者分层 softmax(Hierarchical Softmax)的训练方法。

    怎样把词向量从 Word2vec 模型中提取出来?

    在训练完 Word2vec 的神经网络之后,可能你还会有疑问,我们不是想得到每个词对应的 Embedding 向量嘛,这 个 Embedding 在哪呢?其实,它就藏在输入层到隐层的权重矩阵 WVxN 中。我想看了下面的图你一下就明白了。

    在这里插入图片描述
    你可以看到,输入向量矩阵 WVxN 的每一个行向量对应的就是我们要找的“词向量”。比如我们要找词典里第 i 个词 对应的 Embedding,因为输入向量是采用 One-hot 编码的,所以输入向量的第 i 维就应该是 1,那么输入向量矩 阵 WVxN 中第 i 行的行向量自然就是该词的 Embedding

    细心的你可能也发现了,输出向量矩阵 W′ 也遵循这个道理,确实是这样的,但一般来说,我们还是习惯于使用输 入向量矩阵作为词向量矩阵。

    在实际的使用过程中,我们往往会把输入向量矩阵转换成词向量查找表(Lookup table,如图 7 所示)。例如,输 入向量是 10000 个词组成的 One-hot 向量,隐层维度是 300 维,那么输入层到隐层的权重矩阵为 10000x300 维。在转换为词向量 Lookup table 后,每行的权重即成了对应词的 Embedding 向量。如果我们把这个查找表存 储到线上的数据库中,就可以轻松地在推荐物品的过程中使用 Embedding 去计算相似性等重要的特征了。

    在这里插入图片描述

    Word2vec 对 Embedding 技术的奠基性意义

    Word2vec 是由谷歌于 2013 年正式提出的,其实它并不完全是原创性的,学术界对词向量的研究可以追溯到 2003 年,甚至更早的时期。但正是谷歌对 Word2vec 的成功应用,让词向量的技术得以在业界迅速推广,进而使 Embedding 这一研究话题成为热点。毫不夸张地说,Word2vec 对深度学习时代 Embedding 方向的研究具有奠基 性的意义。

    从另一个角度来看,Word2vec 的研究中提出的模型结构、目标函数、负采样方法、负采样中的目标函数在后续的 研究中被重复使用并被屡次优化。掌握 Word2vec 中的每一个细节成了研究 Embedding 的基础。从这个意义上 讲,熟练掌握本节课的内容是非常重要的。

    Item2Vec:Word2vec 方法的推广

    在 Word2vec 诞生之后,Embedding 的思想迅速从自然语言处理领域扩散到几乎所有机器学习领域,推荐系统也 不例外。既然 Word2vec 可以对词“序列”中的词进行 Embedding,那么对于用户购买“序列”中的一个商品,用户观 看“序列”中的一个电影,也应该存在相应的 Embedding 方法。

    在这里插入图片描述
    于是,微软于 2015 年提出了 Item2Vec 方法,它是对 Word2vec 方法的推广,使 Embedding 方法适用于几乎所 有的序列数据。Item2Vec 模型的技术细节几乎和 Word2vec 完全一致,只要能够用序列数据的形式把我们要表达 的对象表示出来,再把序列数据“喂”给 Word2vec 模型,我们就能够得到任意物品的 Embedding 了。

    Item2vec 的提出对于推荐系统来说当然是至关重要的,因为它使得“万物皆 Embedding”成为了可能。对于推荐系 统来说,Item2vec 可以利用物品的 Embedding 直接求得它们的相似性,或者作为重要的特征输入推荐模型进行 训练,这些都有助于提升推荐系统的效果

    Embedding 就是用一个数值向 量“表示”一个对象的方法。通过 Embedding,我们又引出了 Word2vec,Word2vec 是生成对“词”的向量表达的模 型。其中,Word2vec 的训练样本是通过滑动窗口一一截取词组生成的。在训练完成后,模型输入向量矩阵的行向 量,就是我们要提取的词向量。最后,我们还学习了 Item2vec,它是 Word2vec 在任意序列数据上的推广

    在这里插入图片描述

    Word2vec代码实现

    import itertools
    
    import joblib
    import numpy as np
    
    from word2vec.utils import distance, unitvec
    
    
    class WordVectors(object):
        def __init__(self, vocab, vectors, clusters=None):
            """
            Initialize a WordVectors class based on vocabulary and vectors
    
            This initializer precomputes the vectors of the vectors
    
            Parameters
            ----------
            vocab : np.array
                1d array with the vocabulary
            vectors : np.array
                2d array with the vectors calculated by word2vec
            clusters : word2vec.WordClusters (optional)
                1d array with the clusters calculated by word2vec
            """
            self.vocab = vocab
            self.vectors = vectors
            self.clusters = clusters
    
            # Used to make indexing faster
            self.vocab_hash = {}
            for i, word in enumerate(vocab):
                self.vocab_hash[word] = i
    
        def ix(self, word):
            """
            Returns the index on `self.vocab` and `self.vectors` for `word`
            """
            return self.vocab_hash[word]
    
        def word(self, ix):
            """Returns the word that corresponds to the index.
    
            Parameters
            -------
            ix : int
                The index of the word
    
            Returns
            -------
            str
                The word that corresponds to the index
            """
            return self.vocab[ix]
    
        def __getitem__(self, word):
            return self.get_vector(word)
    
        def __contains__(self, word):
            return word in self.vocab_hash
    
        def get_vector(self, word):
            """
            Returns the vector for a `word` in the vocabulary
            """
            return self.vectors[self.ix(word)]
    
        def distance(self, *args, **kwargs):
            """
            Compute the distance distance between two vectors or more (all combinations) of words
    
            Parameters
            ----------
            words : one or more words
            n : int (default 10)
                number of neighbors to return
            metric : string (default "cosine")
                What metric to use
            """
            metric = kwargs.get("metric", "cosine")  # Default is cosine
    
            combinations = list(itertools.combinations(args, r=2))
    
            ret = []
            for word1, word2 in combinations:
                dist = distance(self[word1], self[word2], metric=metric)
                ret.append((word1, word2, dist))
            return ret
    
        def closest(self, vector, n=10, metric="cosine"):
            """Returns the closest n words to a vector
    
            Parameters
            -------
            vector : numpy.array
            n : int (default 10)
    
            Returns
            -------
            Tuple of 2 numpy.array:
                1. position in self.vocab
                2. cosine similarity
            """
            distances = distance(self.vectors, vector, metric=metric)
            best = np.argsort(distances)[::-1][1 : n + 1]
            best_metrics = distances[best]
            return best, best_metrics
    
        def similar(self, word, n=10, metric="cosine"):
            """
            Return similar words based on a metric
    
            Parameters
            ----------
            word : string
            n : int (default 10)
    
            Returns
            -------
            Tuple of 2 numpy.array:
                1. position in self.vocab
                2. cosine similarity
            """
            return self.closest(self[word], n=n, metric=metric)
    
        def analogy(self, pos, neg, n=10, metric="cosine"):
            """
            Analogy similarity.
    
            Parameters
            ----------
            pos : list
            neg : list
    
            Returns
            -------
            Tuple of 2 numpy.array:
                1. position in self.vocab
                2. cosine similarity
    
            Example
            -------
                `king - man + woman = queen` will be: `pos=['king', 'woman'], neg=['man']`
            """
            exclude = pos + neg
            pos = [(word, 1.0) for word in pos]
            neg = [(word, -1.0) for word in neg]
    
            mean = []
            for word, direction in pos + neg:
                mean.append(direction * self[word])
            mean = np.array(mean).mean(axis=0)
    
            metrics = distance(self.vectors, mean, metric=metric)
            best = metrics.argsort()[::-1][: n + len(exclude)]
    
            exclude_idx = [
                np.where(best == self.ix(word)) for word in exclude if self.ix(word) in best
            ]
            new_best = np.delete(best, exclude_idx)
            best_metrics = metrics[new_best]
            return new_best[:n], best_metrics[:n]
    
        def generate_response(self, indexes, metrics, clusters=True):
            """
            Generates a pure python (no numpy) response based on numpy arrays
            returned by `self.cosine` and `self.analogy`
            """
            if self.clusters and clusters:
                return np.rec.fromarrays(
                    (self.vocab[indexes], metrics, self.clusters.clusters[indexes]),
                    names=("word", "metric", "cluster"),
                )
            else:
                return np.rec.fromarrays(
                    (self.vocab[indexes], metrics), names=("word", "metric")
                )
    
        def to_mmap(self, fname):
            joblib.dump(self, fname)
    
        @classmethod
        def from_binary(
            cls,
            fname,
            vocab_unicode_size=78,
            desired_vocab=None,
            encoding="utf-8",
            new_lines=True,
        ):
            """
            Create a WordVectors class based on a word2vec binary file
    
            Parameters
            ----------
            fname : path to file
            vocabUnicodeSize: the maximum string length (78, by default)
            desired_vocab: if set any words that don't fall into this vocab will be droped
    
            Returns
            -------
            WordVectors instance
            """
            with open(fname, "rb") as fin:
                # The first line has the vocab_size and the vector_size as text
                header = fin.readline()
                vocab_size, vector_size = list(map(int, header.split()))
    
                vocab = np.empty(vocab_size, dtype="<U%s" % vocab_unicode_size)
                vectors = np.empty((vocab_size, vector_size), dtype=np.float)
                binary_len = np.dtype(np.float32).itemsize * vector_size
                for i in range(vocab_size):
                    # read word
                    word = b""
                    while True:
                        ch = fin.read(1)
                        if ch == b" ":
                            break
                        word += ch
                    include = desired_vocab is None or word in desired_vocab
                    if include:
                        vocab[i] = word.decode(encoding)
    
                    # read vector
                    vector = np.fromstring(fin.read(binary_len), dtype=np.float32)
                    if include:
                        vectors[i] = unitvec(vector)
                    if new_lines:
                        fin.read(1)  # newline char
    
                if desired_vocab is not None:
                    vectors = vectors[vocab != "", :]
                    vocab = vocab[vocab != ""]
            return cls(vocab=vocab, vectors=vectors)
    
        @classmethod
        def from_text(
            cls, fname, vocabUnicodeSize=78, desired_vocab=None, encoding="utf-8"
        ):
            """
            Create a WordVectors class based on a word2vec text file
    
            Parameters
            ----------
            fname : path to file
            vocabUnicodeSize: the maximum string length (78, by default)
            desired_vocab: if set, this will ignore any word and vector that
                           doesn't fall inside desired_vocab.
    
            Returns
            -------
            WordVectors instance
            """
            with open(fname, "rb") as fin:
                header = fin.readline()
                vocab_size, vector_size = list(map(int, header.split()))
    
                vocab = np.empty(vocab_size, dtype="<U%s" % vocabUnicodeSize)
                vectors = np.empty((vocab_size, vector_size), dtype=np.float)
                for i, line in enumerate(fin):
                    line = line.decode(encoding).rstrip()
                    parts = line.split(" ")
                    word = parts[0]
                    include = desired_vocab is None or word in desired_vocab
                    if include:
                        vector = np.array(parts[1:], dtype=np.float)
                        vocab[i] = word
                        vectors[i] = unitvec(vector)
    
                if desired_vocab is not None:
                    vectors = vectors[vocab != "", :]
                    vocab = vocab[vocab != ""]
            return cls(vocab=vocab, vectors=vectors)
    
        @classmethod
        def from_mmap(cls, fname):
            """
            Create a WordVectors class from a memory map
    
            Parameters
            ----------
            fname : path to file
    
            Returns
            -------
            WordVectors instance
            """
            memmaped = joblib.load(fname, mmap_mode="r+")
            return cls(vocab=memmaped.vocab, vectors=memmaped.vectors)
    
    
    展开全文
  • 实例271 从SQL Server中提取Word文档 349 8.4 SQL Server服务器应用 350 实例272 和服务器时间同步 350 实例273 取得网络的SQL服务器名 351 8.5 数据库维护 352 实例274 数据库登录配置 352 实例275 ...
  • 实例2:多级人工序号怎样变自动多级符号 1 实例3:一步替换法对齐人工目录人名 2 实例4:对开头为第N章和第N节的段落进行设置 3 实例5:删除多余的半角空格 4 实例6:删除白色空格(空白区域) 4 实例7:删除空行和断...
  • python操作word,excel,pdf 提取码:wdkz Python编程-数据挖掘入门与实践(中文完整版)-图灵程序 提取码:jmoo Python编程入门经典 提取码:7uzb Python编程快速上手 让繁琐工作自动化 提取码:4q4o Python编程...
  • 实例213 提取指定文件夹目录 301 6.3 修改文件 302 实例214 更改文件名称 302 实例215 修改文件属性 303 实例216 修改文件及目录的名称 304 6.4 文件目录 305 实例217 获得临时文件目录 305 实例218 ...
  • 这里写目录标题1 从网络和硬盘访问文本1.1 电子书1.2处理的HTML1.3 处理搜索引擎的结果1.4 处理RSS订阅1.5 读取本地文件1.6 从 PDF、MS Word 及其他二进制格式中提取文本1.7 捕获用户的输入1.8 NLP的流.
    • 本章的目的是要回答下列问题:
    1. 我们怎样才能编写程序访问本地和网络上的文件,从而获得无限的语言材料?
    2. 我们如何把文档分割成单独的词和标点符号,这样我们就可以开始像前面章节中在文本语料上做的那样的分析?
    3. 我们怎样编程程序产生格式化的输出,并把结果保存在一个文件中?

    1 从网络和硬盘访问文本

    1.1 电子书

    1. NLTK语料库集合中有古腾堡项目的一小部分样例文本。然而,你可能对分析古腾堡项目的其它文本感兴趣。
    2. 你可以在http:/www.gutenberg.org/catalog/上浏览25,000本免费在线书籍的目录,获得ASCII码文本文件的URL。
    3. 虽然90%的古腾堡项目的文本是英语的,它还包括超过50种语言的材料,包括加泰罗尼亚语、中文、荷兰语、芬兰语、法语、德语、意大利语、葡萄牙语和西班牙语(每种语言都有超过100个文本)。
    """
    编号2554的文本是《罪与罚》的英文翻译,我们可以如下方式访问它。
    """
    import nltk
    from urllib.request import urlopen
    
    url = "http://www.gutenberg.org/files/2554/2554.txt"
    raw=urlopen(url).read()
     
    print(type(raw)) #文本的类型: str
    print(len(raw))  #文本长度,176831
    print(raw[:75])  #文本前75个字符,不要直接打印出raw,太长了
     
    #使用代理访问:
    #proxies={'http':'http://www.someproxy.com:3128'}
    #raw=urlopen(url,proxies=proxies).read()
    
    """
    分词:将字符串分解为词和标点符号;经过分词,产生一个词汇和标点符号的链表 str --> list 
    """
    
    # 将其str转为list
    tokens=nltk.word_tokenize(raw)  
    print(type(tokens))
    print(len(tokens))  # 225809
    print(tokens[:10])
    
    #从链表创建一个NLTK文本,对其进行操作
    text=nltk.Text(tokens)
    print(type(text))
    print(text[:10])     #text似乎同tokens没什么区别
    print (text.collocations())  # text.collocations() : 统计文本中频繁的双连词
    
    """
    古腾堡项目的每个文本:包含一个首部,涵盖了文本的名称、作者、扫描和校对文本的人的名字、许可证等信息。
    从原始文本中挑出内容之前,我们需要手工检查文件以发现标记内容开始和结尾的独特的字符串。
    """
    print(raw.find("PART I"))  # 寻找“PART I”的索引
    print(raw.rfind("End of Project Gutenberg's Crime"))   #逆向查找,从最后开始找索引
    
    #重新复制,将从"PART I"到"End of Project Gutenberg's Crime"部分截下来,赋给raw
    raw=raw[raw.find("PART I"):raw.rfind("End of Project Gutenberg's Crime")]  # 截取中间正文部分
    
    

    1.2处理的HTML

    • HTML全部内容包括:meta元标签、图像标签、map标签、JavaScript、表单和表格。
    • 提取文本:clean_html()将HTML字符串作为参数,返回原始文本,然后对原始文本进行分词,获得熟悉的文本结构
    # 书籍版本是python2 所以运行报错了,修正为
    import nltk  
    from urllib.request import urlopen  
    from bs4 import BeautifulSoup
    
    url = "http://news.bbc.co.uk/2/hi/health/2284783.stm"  
    html = urlopen(url).read()  
    print(html[:60]) 
    
    soup = BeautifulSoup(html)
    raw = soup.get_text()
    #print(nltk.word_tokenize(raw))
    tokens = nltk.word_tokenize(raw)  
    tokens=tokens[96:399]  
    
    text=nltk.Text(tokens)
    print(text.concordance('ok'))
    

    1.3 处理搜索引擎的结果

    • 优点
    1. 主要优势规模,具有庞大的文件集;
    2. 其次优势是非常容易使用。
    • 缺点
    1. 允许搜索的范围受到严格的限制;
    2. 搜索引擎给出的结果不一致;
    3. 搜索引擎返回的结果的标记可能会有不可预期的改变。

    1.4 处理RSS订阅

    博客圈是文本的重要来源,无论是正式的还是非正式的。在一个叫做Universal Feed Parser的第三方Python库(可从http:/lfeedparser.org/免费下载)的帮助下,我们可以访问个博客的内容,如下所示:

    import feedparser
    
    llog = feedparser.parse("http://languagelog.ldc.upenn.edu/nll/?feed=atom")
    llog['feed']['title']
    len(llog.entries)
    
    post = llog.entries[2]
    post.title
    
    print(post.content[0])
    content = post.content[0].value
    content[:70]
    
    
    nltk.word_tokenize(nltk.html_clean(content))
    nltk.word_tokenize(nltk.clean_html(llog.entries[2].content[ 0].value)) # 结果字符串有一个u前缀表示它们是 Unicode字符串
    

    1.5 读取本地文件

    python数据分析 | csv,json,xls文件读写

    1.6 从 PDF、MS Word 及其他二进制格式中提取文本

    打开PDF和MSWord,用第三方函数库如pypdf和pywin32

    • pdf提取文本参考学习
    1. 深入学习python解析并读取PDF文件内容的方法
    2. 如何用Python批量提取PDF文本内容?
    • Ms Word提取文本参考学习
    1. Python学习笔记(28)-Python读取word文本

    1.7 捕获用户的输入

    使用input函数+变量存储 获得用户输入

    1.8 NLP的流程

    在这里插入图片描述

    2 字符串:最底层的文本处理

    将详细探讨字符串,并展示字符串与词汇、文本和文件之间的联系

    2.1 字符串的基本操作

    1. 字符串中包含单引号,需要用""转义;
    2. 可用单引号,双引号,三重引号来指定字符串,其中双引号可以加在有单引号的句子中,代表句子结束,三重引号可以换行打印出来;
    3. 字符串跨好几行,a:使用反斜杠"",解释器就知道第一行的表达式不完整;b:使用括号,将两个字符串括起来,中间换行即可,不用加逗号;
    4. 对字符串操作,“+”加法:连接字符串;“*”乘法:多倍连接字符串;不能使用减法和除法

    2.2 输出字符串

    变量 = ‘字符串’
    print(变量)

    2.3 访问单个字符

    1. 从0开始,长度为1的字符串,用索引符号[]调用,
    2. 超出索引范围,出错
    3. 字符串的负数索引,-1为最后一个字符的索引,-2,-3,…对应着过去,
    4. 计数单个字符。将所有字符小写,忽略掉大小写,并过滤掉非字母字符
    import nltk
    from nltk.corpus import gutenberg
    
    raw=gutenberg.raw('melville-moby_dick.txt')
    fdist=nltk.FreqDist(ch.lower() for ch in raw if ch.isalpha())
    print(fdist.keys()) # 出现频率最高排在最先的顺序显示出英文字母
    print(fdist.values()) # fdist如同key-value一般,调用keys和values方法,能够显示对应的字符情况
    fdist.plot() # 可视化输出
    

    在这里插入图片描述

    2.4 访问子字符串

    1. 使用切片,开始于第一个索引,结束于最后一个索引的前一个。注意,最后索引的前一个
    2. 负数索引切片,-1为最后一个,-2,-3…推算过去
    3. 省略:第一个值,即从字符串开头开始;第二个值,切到字符结尾结束; 字符[:]
    4. in操作符:测试一个字符串是否包含一个特定的子字符串
    5. find()函数操作:子字符串在字符串内的位置;从开头到找到的第一个位置.(若是第二个怎么算?)
    6. rfind()函数,从末尾开始查找,同findd().只是开始位置相反而已。
      在这里插入图片描述
    monty='Monty Python'
    monty[6:10]
    monty[-12:-7]
    phrase = 'And now for something completely different'
    if 'thing' in phrase:
        print('''find "thing"''')
    

    2.5 更多的字符串操作

    help(str)可以找到所有的有关函数在这里插入图片描述

    2.6 链表(列表,list)与字符串(str)的区别

    1. 字符串和链表之间不能连接;
    2. 我们使用一个for 循环来处理读入文件(对应的文件内容对应一个字符串),所有我们可以挑选出的只是单个的字符——我们不能选择粒度链表中的元素可以很大也可以很小,它们可能是段落、句子、短语、单词、字符。链表的优势在于我们可以灵活的决定它包含的元素,相应的后续的处理也变得灵活
    3. 我们在一段NLP 代码中可能做的第一件事情就是将一个字符串分词放入一个字符,变成列表(nltk.word_tokenize(raw));当我们要将结果写入到一个文件或终端,我们通常会将它们格式化为一个字符串
    4. 字符串是不可改变的:一旦你创建了一个字符串,就不能改变它。链表是可变的,内容可以随时修改

    3 使用 Unicode 进行文字处理

    在本节中,我们将概述如何使用Unicode处理使用非ASCII字符集的文本。

    3.1 什么是Unicode

    1. Unicode支持超过一百万种字符。每个字符分配一个编号,称为编码点。在Python中,编码点写作\uXXXX的形式,其中XXXX是四位十六进制形式数。
    2. 当Unicode字符串被存储在文件或在终端上显示,他们必须为编码为字节流。一些编码(如 ASCII和Latin-2)中每个编码点使用单字节,所以它们可以只支持Unicode 的一个小的子集就足够一种语言使用了。其它的编码(如UTF-8)使用多个字节,可以表示全部的Unicode字符。
    3. 文件中的文本都是有特定编码的,所以我们需要一些机制来将文本翻译成Unicode,即解码(decode)。相对的,要将Unicode写入一个文件或终端,我们首先需要将Unicode,转化为合适的编码,即编码(encode)。
      [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eAPmimBu-1612941977208)(attachment:image.png)]

    3.2 从文件中提取已编码文本

    """
    nltk.data.find()函数:定位文件
    """
    import nltk
    path = nltk.data.find('corpora/unicode_samples/polish-lat2.txt')
    
    """
    - codecs模块:提供了将编码数据读入为Unicode 字符串和将Unicode 字符串以编码形式写出的函数。
    - codecs.open()函数:encoding 参数来指定被读取或写入的文件的编码。
    - unicode_escape编码:Python的一个虚拟的编码;把所有非ASCII 字符转换成它们的\uXXXX 形式
    """
    path = nltk.data.find('corpora/unicode_samples/polish-lat2.txt')
    f= codecs.open(path,encoding='latin2')  # 告诉文件的编码形式为latin2
    
    print(f)
    
    #文件对象f 读出的文本将以Unicode 返回
    for line in f.readlines():
        line=line.strip()
        print( line.encode('unicode_escape'))
    
    """
    Unicode 字符串常量:在字符串常量前面加一个u,
    ord()函数:查找一个字符的整数序列。如ord('a')
    """
    a=u'\u0061'  #对其进行转义
    print( a)
    
    """
    print 语句:假设Unicode 字符的默认编码是ASCII 码。
    repr()函数:转化的字符串,==输出utf-8转义序列(以\xXX的形式)==
    """
    nacute = u'\u0144'
    nacute_utf = nacute.encode('utf8')
    print( nacute)
    print (repr(nacute_utf))
    
    """
    unicodedata模块:检查Unicode 字符的属性。
    """
    import unicodedata
    
    path = nltk.data.find('corpora/unicode_samples/polish-lat2.txt')
    lines = codecs.open(path,encoding='latin2').readlines()  # 告诉文件的编码形式为latin2
    line = lines[2]
    print( line.encode('unicode_escape'))
    
    
    for c in line:
        if ord(c) >127:
        print ('%r U+%04x %s'% (c.encode('utf8'),ord(c),unicodedata.name(c)))
    
    

    3.3 在python中使用本地编码

    在这里插入图片描述

    4 使用正则表达式检测词组搭配

    # 导入词库
    import re
    wordlist = [w for w in nltk.corpus.words.words('en') if w.islower()]
    print(wordlist[:10])
    

    4.1 使用基本的元字符

    1. 美元符号$:用来匹配单词的末尾;
    2. 乘方符号*^:用来匹配单词的开始;
    3. 问号符号“?”:表示前面的一个字符可选;
    4. 通配符“.”:匹配任何单个字符。

    例子1:r’^e-?mail$'将匹配email 和e-mail

    例子2:查找以ed结尾的词汇,r’ed$’

    import re
     
    print ([w for w in wordlist if re.search(r'ed$',w)])
    print( [w for w in wordlist if re.search(r'^..j..t..$',w)])
    print( sum(1 for w in text if re.search(r'^e-? mail$',w)))
    #用IDLE运行有点慢,直接用命令窗口的话,更快。。。
    

    4.2 范围与闭包

    1. 闭包:+、*
    • “+”:前面的项目的一个或多个实例
    • “*”:前面的项目的零个或多个实例
    • “^”:出现在方括号内的第一个字符位置
    • 查找非元音字母组成的词汇:«[aeiouAEIOU]+$»
    1. “.”:匹配一个句号。
    2. 大括号表达:如{3,5},表示前面的项目重复指定次数。
    3. 管道字符[]:从其左边的内容和右边的内容中选择一个。
    4. 圆括号:表示一个操作符的范围,它们可以与管道(或叫析取)符号一起使用,如:r’w(i|e|ai|oo)t’,匹配wit、wet、wait 和woot。
    5. 原始字符串:前缀"r";例如:原始字符串r’\band\b’包含两个“\b”符号会被re 库解释为匹配词的边界而不是解释为退格字符。


    在这里插入图片描述

    [w for w in wordlist if re.search(r'^[ghi][mno][jlk][def]$',w)] # 以g或者h或者i开头,以d或者e或者f结尾的,并且第二个字符是m,n,o中的一个,第三个字符是j,l,k中的一个
    
    chat_words = sorted(set(w for w in nltk.corpus.nps_chat.words()))
    print( [w for w in chat_words if re.search(r'^m+i+n+e+$', w)] )#1个或者多个m,i,n,e,并且以m开头,e结尾
    print( [w for w in chat_words if re.search(r'^[ha]+$', w)] )#以ha开头,并且有1一个或者多个ha,
    
    

    5 正则表达式的有益应用

    5.1 提取字符块

    通过re.findall() (“find all”即找到所有)方法找出所有(无重叠的)匹配指定正则表达式的。

    # 找出一个词中的元音,再计数它们
    word = 'supercalifragilisticexpialidocious'
    len(re.findall(r'[aeiou]',word))
    
    # 看看一些文本中的两个或两个以上的元音序列,并确定它们的相对频率
    wsj = sorted(set(nltk.corpus.treebank.words()))
    fd = nltk.FreqDist(vs 
                       for word in wsj
                       for vs in re.findall(r'[aeiou]{2,}',word))
    fd.items()
    
    
    #将字符串'2009-12-31'转换为一 个整数链表[2009, 12, 31]:
    print([int(n) for n in re.findall(r'[0-9]+','2009-12-31')])
    

    5.2 在字符块上做更多事情

    """
    英文文本是高度冗余的,忽略掉词内部的元音仍然可以很容易的阅读,有些时候这很明显
    例如:declaration变成 dclrtn,inalienable变成 inlnble,保留所有词首或词尾的元音序列。
    正则表达式匹配词首元音序列,词尾元音序列和所有的辅音;其它的被忽略。
    使用 re.findall()提取所有匹配的词中的字符,然后使用''.join()将它们连接在一 起
    """
    regexp = r'^[AEIOUaeiou]+|[AEIOUaeiou]+$|[^AEIOUaeiou]'
    def compress(word):
        pieces = re.findall(regexp, word)
        return "".join(pieces)
     
    english_udhr = nltk.corpus.udhr.words("English-Latin1")
    print(nltk.tokenwrap(compress(w) for w in english_udhr[:75]))
    
    
    #将正则表达式与条件频率分布结合起来
    
    rotokas_words = nltk.corpus.toolbox.words("rotokas.dic")
    cvs = [cv for w in rotokas_words for cv in re.findall(r'[ptksvr][aeiou]', w)]
    cfd = nltk.ConditionalFreqDist(cvs)
    cfd.tabulate()
    

    5.3 查找词干

    1. 使用网络搜索引擎时,我们通常不介意(甚至没有注意到)文档中的词汇与我们的搜 索条件的后缀形式是否相同
    2. 对于一些语言处理任务,我们想忽略词语结尾,只是处理词干
    """
    抽出一个词的词干的方法
    """
    def stem(word):
        for suffix in ['ing', 'ly', 'ed', 'ious', 'ive', 'es', 's', 'ment']:
            if word.endswith(suffix):
                return word[:-len(suffix)]
            
    word = "interesting"
    print(stem(word))
    
    """
    运用正则表达式进行:
    print(re.findall(r'^(.*)(ing|ly|ed|ious|ies|ive|es|s|ment)$', 'processes'))
    匹配的结果式是processe,是贪婪模式
    所以表达式的“.*”部分试图尽可能多的匹配输入的字符串。如果我 们使用“非贪婪”版本的“*”操作符,写成“*?”,我们就得到我们想要的
    完整方法如下
    """
    def stem(word):
        regexp = r'^(.*?)(ing|ly|ed|ious|ies|es|s|ment)?$'
        stem, suffix = re.findall(regexp, word)[0]
        return stem
    
    raw = """DENNIS: Listen, strange women lying in ponds distributing swords
      is no basis for a system of government. Supreme executive power derives from
      a mandate from the masses, not from some farcical aquatic ceremony."""
    tokens = nltk.word_tokenize(raw)
    print([stem(t) for t in tokens][:5])
    

    5.4 搜索已分词文本

    1. 尖括号用于标记标识符 的边界,尖括号之间的所有空白都被忽略
    2. 我们使用<.*>,它将匹配所有单个标识符,将它括在括号里,
    # 只匹配词(例如:monied)而不匹配短语(例如:a monied man)
    
    from nltk.corpus import gutenberg, nps_chat
    moby = nltk.Text(gutenberg.words('melville-moby_dick.txt'))
    print(moby.findall(r'<a>(<.*>)<man>'))
    
    # 找出以词“br o”结尾的三个词组成的短语
    chat = nltk.Text(nps_chat.words())
    print(chat.findall(r'<.*><.*><bro>'))
    
    # 找出以字母“l”开始的三个或更多词组成的 序列
    print(chat.findall(r'<l.*>{3,}'))
    
    """
    # \w 表示单词字符
    #在大型文本语料库中搜索“x and other ys”形式 的表达式能让我们发现上位词
    """
    
    from nltk.corpus import brown
    hobbies_learned = nltk.Text(brown.words(categories=['hobbies', 'learned']))
    print(hobbies_learned.findall(r'<\w*><and><other><\w*s>'))
    
    """#查找模式“as x as y”的实例以发现实体及其属性信息"""
    
    from nltk.corpus import brown
    hobbies_learned = nltk.Text(brown.words(categories=['hobbies', 'learned']))
    print(hobbies_learned.findall(r'<as><\w*><as><\w*>'))
    

    6 规范化文本

    #首先,定义我们将在本节中使用的数据:
    raw = """DENNIS: Listen, strange women lying in ponds distributing swords 
        is no basis for a system of government. Supreme executive power derives from 
        a mandate from the masses, not from some farcical aquatic ceremony."""
    
    tokens = nltk.word_tokenize(raw)
    print(tokens)
    

    6.1 词干提取器

    #Porter 词干提取器正确处理了词 lying(将它映射为 lie),而 Lancaster 词干提取 器并没有处理好。
    porter = nltk.PorterStemmer()
    lancaster = nltk.LancasterStemmer()
    print([porter.stem(t) for t in tokens][:])
    print([lancaster.stem(t) for t in tokens][:])
    
    # 词干提取器过程没有明确定义,通常选择合适应用的词干提取器。
    # 如果要索引文本或者使搜索支持不同词汇形式的话,Porter词干提取器是一个很好的选择。
    # 介绍:nltk.Index 获得某个单词的索引
    # output = nltk.Index((word , i) for (i,word) in enumerate(['a','b','a']))  # 输出Index(list, {'a': [0, 2], 'b': [1]})
    # output['a']  # [0, 2]
    
    class IndexedText(object):
         # 初始化提取器和文本
        def __init__(self, stemmer, text):
            self._text = text  
            self._stemmer = stemmer
            self._index = nltk.Index((self._stem(word), i)
                                     for (i, word) in enumerate(text))  # 把text的文本统一成大小写,然后获得文本每个词的分布索引,
     
        def concordance(self, word, width=40):
            key = self._stem(word)  # lie
            wc = int(width/4)                # words of context
            for i in self._index[key]:   # 遍历出lie分布的索引, 如[3,6]
                lcontext = ' '.join(self._text[i-wc:i])  # 获得lie前后10个单词
                rcontext = ' '.join(self._text[i:i+wc])
                ldisplay = '{:>{width}}'.format(lcontext[-width:], width=width)
                rdisplay = '{:{width}}'.format(rcontext[:width], width=width)
                print(ldisplay, rdisplay)
     
        def _stem(self, word):
            return self._stemmer.stem(word).lower()  # lie
    
    
    
    porter = nltk.PorterStemmer()
    grail = nltk.corpus.webtext.words('grail.txt')
    text = IndexedText(porter,grail)
    text.concordance('lie')
    

    6.2 词形归并

    WordNet词形归并器删除词缀产生的词都是在它的字典中的词。这个额外的检查过程使 词形归并器比刚才提到的词干提取器要慢。

    #没有处理“lying”,但它将“women”转换为“woman”。
    wnl = nltk.WordNetLemmatizer()
    print([wnl.lemmatize(t) for t in tokens][:])
    #如果你想编译一些文本的词汇,或者想要一个有效词条(或中心词)列表,WordNet词形归并器是一个不错的选择。
    

    7 用正则表达式为文本分词

    分词是将字符串切割成可识别的构成一块语言数据的语言单元。

    7.1 分词的简单方法

    在这里插入图片描述

    raw = """'When I'M a Duchess,' she said to herself, (not in a very hopeful tone
          though), 'I won't have any pepper in my kitchen AT ALL. Soup does very
          well without--Maybe it's always pepper that makes people hot-tempered,'..."""
    
    #使用 raw.split()在空格符处分割原始文本。
    #使用正则表达式能做同样的事情,print(re.split(r' ', raw)匹配字符串中的所有空格符是不够的,
    #因为这将导致分词结果包含“\n”换行符;我们需 要匹配任何数量的空格符、制表符或换行符
    # 所以,用re.split(r'[ \t\n]+', raw
    print(re.split(r'[ \t\n]+', raw))
    print(re.findall(r'\w+|\S\w*', raw)) # 分离出I',M
    print(re.findall(r"\w+(?:[-']\w+)*|'[-.(]+|\S\w*",raw))  # 分离出I'M
    
    

    7.2 NLTK 的正则表达式分词器

    函数nltk.regexp_tokenize()与re.findall()类似(我们一直在使用它进行分词)。然而,nltk.regexp_tokenize()分词效率更高,且不需要特殊处理括号。为了增强可读性,我们将正则表达式分几行写,每行添加一个注释。特别的“(?x)”“verbose标志”告诉Python去掉嵌入的空白字符和注释。

    text = 'That U.S.A.poster-print costs $12.40...'
    
    pattern = r"""(?x)   # set flag to allow verbose regexps
        ([A-Z].)+   # abbreviations,e.g.U.S.A.
        | \w+(-\w+)*   # words with optional internal hyphens
         \$?\d+(\.\d+)?%?   # currency and percentages,e.g. $12.40,82%
        |\.\.\. # ellipsis
        |[][.,,""?():-_`]# these are separate tokens
    """
    
    nltk.regexp_tokenize(text,pattern)
    
    

    8 分割

    分词是一个更普遍的分割问题的一个实例。在本节中,我们将看到这个问题的另外两个实例,它们使用与到目前为止我们已经在本章看到的完全不同的技术。

    8.1 断句

    1. 在词级水平处理文本通常假定能够将文本划分成单个句子。正如我们已经看到,一些语 料库已经提供在句子级别的访问。
    #计算布朗语料库中每个句子的平均词数
    print(len(nltk.corpus.brown.words()) / len(nltk.corpus.brown.sents()))
    
    # 分句器
    sent_tokenizer=nltk.data.load('tokenizers/punkt/english.pickle')
    text = nltk.corpus.gutenberg.raw('chesterton-thursday.txt')
    sents = sent_tokenizer.tokenize(text)
    print(sents[171:181])  # 被分句了
    
    # 断句是困难的,因为句号会被用来标记缩写而另一些句号同时标记缩写和句子结束,就像发生在缩写如“U.S.A.”上的那样。
    # 断句的另一种方法见6.2节。
    
    

    8.2 分词

    在这里插入图片描述

    """
    例3-2.从分词表示字符串seg1和seg2中重建文本分词。
    seg1和seg2表示假设的一些儿童讲话的初始和最终分词。
    函数segment()可以使用它们重现分词的文本。
    """
    
    text = "doyouseethekittyseethedoggydoyoulikethekittylikethedoggy"
    seg1 = "0000000000000001000000000010000000000000000100000000000"
    seg2 = "0100100100100001001001000010100100010010000100010010000"
    def segment(text, segs):
        words = []
        last = 0
        for i in range(len(segs)):
            if segs[i] == '1':
                words.append(text[last:i+1])
                last = i + 1
        words.append(text[last:])
        return words
    
    print(segment(text, seg1))
    print(segment(text, seg2))
    
    
    
    """
    #现在分词的任务变成了一个搜索问题:找到将文本字符串正确分割成词汇的字位串
    #我们可以定义一个目标函数,一个打分函数,我们将基于词典的大小和从词典中重构源文本所需的信息量尽力优化它的值。
    #即模拟退火算法:https://baike.baidu.com/item/%E6%A8%A1%E6%8B%9F%E9%80%80%E7%81%AB%E7%AE%97%E6%B3%95/355508?fromtitle=%E9%80%80%E7%81%AB%E7%AE%97%E6%B3%95&fromid=6081525&fr=aladdin
    #例3-3. 计算存储词典和重构源文本的成本。
    """
    
    def evaluate(text, segs):
        words = segment(text, segs)
        text_size = len(words)
        lexicon_size = len(''.join((set(words))))
        return (text_size + lexicon_size)
    text = "doyouseethekittyseethedoggydoyoulikethekittylikethedoggy"
    seg1 = "0000000000000001000000000010000000000000000100000000000" 
    seg2 = "0100100100100001001001000010100100010010000100010010000"
    seg3 = "0000100100000011001000000110000100010000001100010000001"
    print(segment(text, seg1))
    print(segment(text, seg2))
    print(segment(text, seg3))
    print(evaluate(text, seg1))
    print(evaluate(text, seg2))
    print(evaluate(text, seg3))
    

    9 格式化:从链表到字符串

    9.1 从链表到字符串

    #我们用于文本处理的最简单的一种结构化对象是词链表。
    #当我们希望把这些输出到显示器或文件时,必须把这些词的链表转换成字符串。
    #在 Python 做这些,我们使用的 join()方 法,并指定作为“胶水”使用的字符串:
    silly = ['We', 'called', 'him', 'Tortoise', 'because', 'he', 'taught', 'us', '.']
    print(' '.join(silly))
    print(','.join(silly))
    #join()方法只适用于一个字符串的链表— —我们一直把它叫做一个文本——在 Python 中享有某些特权的一个复杂的类型。
    

    9.2 字符串与格式

    #格式化输出通常包含变量和预先指定的字符串的一个组合
    fdist = nltk.FreqDist(['dog', 'cat', 'dog', 'cat', 'dog', 'snake', 'dog', 'cat'])
    for word in fdist:
        print(word,'->', fdist[word],';')
        
    #除了不必要的空格符问题,输出包含变量和常量交替出现的表达式是难以阅读和维护的。
    #一个更好的解决办法是使用字符串格式化表达式。
    for word in fdist:
        print('%s->%d;'%(word, fdist[word]))
    #特殊符号%s 和%d 是字符串和整数(十进制数)的占位符。
    #我们可以将这些嵌入在一个字符串中,然后使用%操作符把它们组合起来。
     
     
    #我们还可以间接的提供占位符的值。下面是使用 for 循环的一个例子
    template = 'Lee wants a %s right now'
    menu = ['sandwich', 'spam fritter', 'pancake']
    for snack in menu:
        print(template % snack)
        
    # 符号%s和%d被称为转换说明符。它们以%字符开始,以一个转换字符如s(表示字符串)或d(十进制整数)结束。
    # 其中包含转换说明符的字符串被称为格式字符串。我们组合一个格式字符串和%操作符以及一个值的元组,来创建一个完整的字符串格式化表达式。
    
    

    9.3 排列

    #指定宽度,如%6s,产生一个宽度为 6 的字符串
    print('%6s'%'dog')
     
    #包括一个减号使它左对齐
    print('%-6s'%'dog')
     
    #事先不知道要显示的值应该有多宽时, 可以在格式化字符串中用*替换宽度值,然后指定一个变量。
    width = 6
    print('%-*s'%(width, 'dog'))
     
    #其他控制字符用于十进制整数和浮点数。
    #因为百分号%在格式化字符串中有特殊解释,我们要在它前面加另一个%才能输出它。
    count, total = 3205, 9375
    print("accuracy for %d words:%2.4f%%"%(total, 100 * count / total))
    

    9.4 将结果写入文件

    #打开可写文件 output.txt ,将程序的输出保存到文件。
    output_file = open('output.txt', 'w')
    words = set(nltk.corpus.genesis.words('english-kjv.txt'))
    for word in sorted(words):
        output_file.write(word + "\n")
        
    print(len(words))
    print(str(len(words)))
     
    output_file.write(str(len(words)) + "\n")
    output_file.close()
    #你应该避免文件名包含空格字符,例如:output file.txt
    #避免使用除了大小 写区别外其他都相同的文件名,例如:Output.txt 与 output.TXT。
    

    9.5 文本换行

    #可以在 Python 的 textwrap 模块的帮助下采取换行
    saying = ['After', 'all', 'is', 'said', 'and', 'done', ',', 'more', 'is', 'said', 'than', 'done', '.']
    from textwrap import fill
    
    format = '%s(%d),'
    pierces = [format % (word, len(word)) for word in saying]
    output = ' '.join(pierces)  # 不换行
    print(output)
    wrapped = fill(output)
    print(wrapped)   # 已换行
    

    10 小结

    1. 在本书中,我们将文本作为一个词链表。“原始文本”是一个潜在的长字符串,其中包 含文字和用于设置格式的空白字符,也是我们通常存储和可视化文本的原料。
    2. 在 Python 中指定一个字符串使用单引号或双引号:‘Monty Python’,“Monty Python”。
    3. 字符串中的字符是使用索引来访问的,索引从零计数:‘Monty Python’[0]的值是 M。 求字符串的长度可以使用 len()。
    4. 子字符串使用切片符号来访问: ‘Monty Python’[1:5]的值是 onty。如果省略起始 索引,子字符串从字符串的开始处开始;如果省略结尾索引,切片会一直到字符串的结 尾处结束。
    5. 字符串可以被分割成链表:‘Monty Python’.split()得到[‘Monty’, ‘Python’]。链表 可以连接成字符串:’/’.join([‘Monty’, ‘Python’])得到’Monty/Python’。
    6. 我们可以使用 text = open(f).read()从一个文件 f 读取文本。可以使用 text = urlpen(u).read()从一个 URL u 读取文本。我们可以使用 for line in open(f)遍历一个文本文件的每一行。
    7. 在网上找到的文本可能包含不需要的内容(如页眉、页脚和标记),在我们做任何语言处理之前需要去除它们。
    8. 分词是将文本分割成基本单位或标记,例如词和标点符号等。基于空格符的分词对于许多应用程序都是不够的,因为它会捆绑标点符号和词。NLTK 提供了一个现成的分词器nltk.word_tokenize()。
    9. 词形归并是一个过程,将一个词的各种形式(如:appeared,appears)映射到这个词标准的或引用的形式,也称为词位或词元(如:appear)。
    10. 正则表达式是用来指定模式的一种强大而灵活的方法。只要导入了 re 模块,我们就可以使用 re.findall()来找到一个字符串中匹配一个模式的所有子字符串。
    11. 如果一个正则表达式字符串包含一个反斜杠,你应该使用原始字符串与一个 r 前缀:r’regexp’,告诉 Python 不要预处理这个字符串。
    12. 当某些字符前使用了反斜杠时,例如:\n,处理时会有特殊的含义(换行符);然而,当反斜杠用于正则表达式通配符和操作符时,如:.,|,$,这些字符失去其特殊的含义,只按字面表示匹配。
    13. 一个字符串格式化表达式 template % arg_tuple 包含一个格式字符串 template,它由如%-6s 和%0.2d 这样的转换标识符符组成。

    11 习题

    https://www.cnblogs.com/junzhi1989/archive/2012/07/02/2573142.html

    展开全文
  • 贝叶斯网络实践

    2020-04-30 10:34:00
    文章目录主要内容小插曲形式化理解马尔科夫模型一点马尔科夫模型知识文本数据的处理流程TF-IDF模型Word2vec的使用 主要内容 利用库想去做分类时候,是怎样的一个现象。尤其关注分类的时间和效率怎么样 ,以及精度与...

    主要内容

    在这里插入图片描述
    利用库想去做分类时候,是怎样的一个现象。尤其关注分类的时间和效率怎么样 ,以及精度与logistic回归,SVM,岭回归可做一个比较。
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    即每个词出现的位置,即标注为1,未出现的词,即标注为0.
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    公式有时会有点差别,但是这是我们在自然语言中提取特征的办法,来算每一个词的权重是多少,就用TF-IDF来做。通过已有词典,或者从样本中得到长度为V的词典,维度仍然是V维的,但是元素不再是整型或者0-1向量了,而是浮点型了,将这个向量作为初始向量再给后面模型。可把这个IDF向量喂给贝叶斯,或主题模型LDA。

    小插曲形式化理解马尔科夫模型

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    一般做马尔科夫模型时,认为状态转移矩阵近似是稳定不变的。
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    一点马尔科夫模型知识

    文本数据的处理流程

    即拿到文本数据,我们怎么样生成一些他的特征,然后喂给某一个模型。

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    TF-IDF模型

    Word2vec的使用

    在这里插入图片描述
    在这里插入图片描述

    在这里插入图片描述
    在这里插入图片描述
    词嵌入:
    在这里插入图片描述
    当然有V个词的空间其实是很稀疏的,但是当两个词很接近时,映射的V空间的向量有不同时,即没有太多关联,如people与person即没有相似性了,我们可将V维空间不要做的那么稀疏,将V维度降下来,如100维度空间;即都映射成100维空间的一个向量了;即就做一个100或200维的词嵌入。
    我们希望两个相似词映射到100维空间后这两个词对应的向量也比较接近,可以使用这个词相邻的词。

    在这里插入图片描述

    具体做法

    可将A词先初始化为一个长度为100初始的向量,将其他词也随机初始化为初始向量,调节A词与其周围词之间的权值,使得得到合适权值的情况之下,能够使得我们将当前A词对应长度为100的向量带入进去,能够使得预测值是近似相等的,最后不要权值,只是关心A这个词映射为100维空间的向量是什么。因此我们可以使用当前词去预测相邻的词,也有可能利用周围词预测某一个词。
    在这里插入图片描述
    在这里插入图片描述

    实践

    实例1

    鸢尾花数据
    在这里插入图片描述
    在这里插入图片描述

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    使用高斯朴素贝叶斯
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    实例2

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    每50ms做一帧图像进行刷新在这里插入图片描述

    在这里插入图片描述

    实例3

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    即一个模型的训练时间。
    在这里插入图片描述

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    实例4

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    在这里插入图片描述
    将词做一些加加减减,如下:
    在这里插入图片描述
    在这里插入图片描述

    实例5

    要对样本数据做一些处理。
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • delphi 开发经验技巧宝典源码

    热门讨论 2010-08-12 16:47:23
    0235 如何读取Word中的文本 156 0236 通过身份证号获取年龄 157 0237 如何实现一个应用程序只能打开一个进程 158 7.4 其他数据处理技术 159 0238 对计算结果四舍五入 159 0239 获取一个字符的ASCII值 ...
  • 0235 如何读取Word中的文本 156 0236 通过身份证号获取年龄 157 0237 如何实现一个应用程序只能打开一个进程 158 7.4 其他数据处理技术 159 0238 对计算结果四舍五入 159 0239 获取一个字符的ASCII值 ...
  • 0235 如何读取Word中的文本 156 0236 通过身份证号获取年龄 157 0237 如何实现一个应用程序只能打开一个进程 158 7.4 其他数据处理技术 159 0238 对计算结果四舍五入 159 0239 获取一个字符的ASCII值 ...
  • 0235 如何读取Word中的文本 156 0236 通过身份证号获取年龄 157 0237 如何实现一个应用程序只能打开一个进程 158 7.4 其他数据处理技术 159 0238 对计算结果四舍五入 159 0239 获取一个字符的ASCII值 ...
  • 0235 如何读取Word中的文本 156 0236 通过身份证号获取年龄 157 0237 如何实现一个应用程序只能打开一个进程 158 7.4 其他数据处理技术 159 0238 对计算结果四舍五入 159 0239 获取一个字符的ASCII值 ...
  • 0235 如何读取Word中的文本 156 0236 通过身份证号获取年龄 157 0237 如何实现一个应用程序只能打开一个进程 158 7.4 其他数据处理技术 159 0238 对计算结果四舍五入 159 0239 获取一个字符的ASCII值 ...
  • python3.x Opencv Toturial

    2018-03-01 12:59:34
    而 Python 的悄 然兴起给他们带来的希望,如果说 C++ 是 tex 的话,那 Python 的易用性 相当于 word。他们可以很快的看懂本书的所有代码,并可以学着使用它们 来解决自己的问题,同时也能拓展自己的视野。别人经常说...
  • 实例191 在delphi控制word 249 实例192 带日志的程序 251 实例193 获取窗口文本 252 实例194 判断文件是否正在被使用 253 实例195 提取文件的图标资源 254 实例196 在程序调用.hlp文件 256 ...
  • 实例191 在delphi控制word 249 实例192 带日志的程序 251 实例193 获取窗口文本 252 实例194 判断文件是否正在被使用 253 实例195 提取文件的图标资源 254 实例196 在程序调用.hlp文件 256 ...
  • sql2005全文检索.doc

    2009-09-09 10:31:46
    例如,Microsoft 提供了 Microsoft Office 筛选器,此筛选器可以从 Word、Microsoft Excel 和 Microsoft PowerPoint 文件中提取文本和属性。其他筛选器用于处理 HTML 或电子邮件。还可以使用第三方筛选器。  ◆SQL...
  • C# winform典型系统开发模板

    热门讨论 2011-09-17 15:13:21
    第3章 SQL数据表提取器模块   3.1 概述 56  3.2 关键技术 56  3.2.1 如何备份数据库 56  3.2.2 如何还原数据库 57  3.2.3 如何附加数据库 58  3.2.4 如何分离数据库 59  3.2.5 设置...
  • 程序开发范例宝典>>

    2012-10-24 10:41:28
    实例213 提取指定文件夹目录 301 6.3 修改文件 302 实例214 更改文件名称 302 实例215 修改文件属性 303 实例216 修改文件及目录的名称 304 6.4 文件目录 305 实例217 获得临时文件目录 305 ...
  • 实例213 提取指定文件夹目录 301 6.3 修改文件 302 实例214 更改文件名称 302 实例215 修改文件属性 303 实例216 修改文件及目录的名称 304 6.4 文件目录 305 实例217 获得临时文件目录 305 实例218 ...
  • 实例213 提取指定文件夹目录 301 6.3 修改文件 302 实例214 更改文件名称 302 实例215 修改文件属性 303 实例216 修改文件及目录的名称 304 6.4 文件目录 305 实例217 获得临时文件目录 305 实例218 ...
  • 实例178 提取指定文件夹目录 261 6.3 修改文件 261 实例179 更改文件名称 262 实例180 修改文件属性 262 实例181 修改文件及目录的名字 264 6.4 文件目录 265 实例182 获得临时文件目录 265 实例183 ...
  • C#.net_经典编程例子400个

    热门讨论 2013-05-17 09:25:30
    256 实例175 清空回收站 257 6.2 查找文件 258 实例176 搜索文件 259 实例177 检查文件是否存在 260 实例178 提取指定文件夹目录 261 6.3 修改文件 261 实例179 更改文件名称 ...
  •  实例178 提取指定文件夹目录 261  6.3 修改文件 261  实例179 更改文件名称 262  实例180 修改文件属性 262  实例181 修改文件及目录的名字 264  6.4 文件目录 265  实例182 获得临时文件目录...
  • 实例213 提取指定文件夹目录 301 6.3 修改文件 302 实例214 更改文件名称 302 实例215 修改文件属性 303 实例216 修改文件及目录的名称 304 6.4 文件目录 305 实例217 获得临时文件目录 305 实例218 获取应用程序...
  • C#程序开发范例宝典(第2版).part02

    热门讨论 2012-11-12 07:55:11
    实例213 提取指定文件夹目录 301 6.3 修改文件 302 实例214 更改文件名称 302 实例215 修改文件属性 303 实例216 修改文件及目录的名称 304 6.4 文件目录 305 实例217 获得临时文件目录 305 实例218 获取应用...
  • C#程序开发范例宝典(第2版).part13

    热门讨论 2012-11-12 20:17:14
    实例213 提取指定文件夹目录 301 6.3 修改文件 302 实例214 更改文件名称 302 实例215 修改文件属性 303 实例216 修改文件及目录的名称 304 6.4 文件目录 305 实例217 获得临时文件目录 305 实例218 获取应用...
  • 实例213 提取指定文件夹目录 301 6.3 修改文件 302 实例214 更改文件名称 302 实例215 修改文件属性 303 实例216 修改文件及目录的名称 304 6.4 文件目录 305 实例217 获得临时文件目录 305 实例218 获取应用...
  • 实例213 提取指定文件夹目录 301 6.3 修改文件 302 实例214 更改文件名称 302 实例215 修改文件属性 303 实例216 修改文件及目录的名称 304 6.4 文件目录 305 实例217 获得临时文件目录 305 实例218 获取应用...

空空如也

空空如也

1 2 3
收藏数 49
精华内容 19
关键字:

word中怎样提取目录