精华内容
下载资源
问答
  • word自动生成摘要
    千次阅读
    2018-01-04 00:11:20

    本文主要利用lstm实现英文摘要的自动生成,他的主要步骤如下:
    (1) 首先是我们把训练数据的每个单词对应一个数值,构建一个word to int的字典,得到单词和数值的一个一一对应的关系后,我们就可以把整个训练数据集把所有单词转化为数值的序列,也就是数值型的数列,
    (2) 训练数据处理好了以后,我们就应该构造batch,建立一个生成batch_size的生成器
    (3) 然后开始构建lstm网络,同时开始训练
    (4) 训练完了以后就可以开始给定初始单词,让模型生成一个序列,再把序列转化为对应的单词
    这个方法适用很多,比如生成周杰伦的歌词,自动生成古诗,自动生成剧本等等都是可以的,方法其实都是一样。

    接下来,我们就开始写代码:
    导入相关库:

    import tensorflow as tf
    from tensorflow.contrib import rnn,seq2seq
    import numpy as np

    数据读取:

    with open(file,'r') as f:
        txt = f.read()
    txt = txt.lower()  # 将所有单词都变为小写,这样可以使得不同单词的大小写同一

    构建标点符号的字典

    tokenize_dict = {}
    tokenize_dict['!'] =  "Exclamation_Mark"
    tokenize_dict['.'] =  "PERIOD"
    tokenize_dict[','] =  "COMMA"
    tokenize_dict['"'] =  "QUOTATION_MARK"
    tokenize_dict[','] =  "QUOTATION_MARK"
    tokenize_dict[';'] =  "SEMICOLON"
    tokenize_dict['?'] =  "QUESTION_MARK"
    tokenize_dict['('] =  "LEFT_PARENTHESES"
    tokenize_dict[')'] =  "RIGHT_PARENTHESES"
    tokenize_dict['--'] =  "DASH"
    tokenize_dict['\n'] =  "RETURN"

    替换训练数据中的标点

    for key,value in tokenize_dict.items():
        txt = txt.replace(key,' {} '.format(value)) # 此处使用format是为了保证替换后的标点和前后单词留出一个空格 

    然后开始构建单词和数值型序列的映射关系

    text = txt.split()
    words = set(text)
    vocab_size = len(words)
    # 以下是将词转化为对应的数字
    word_to_int = {word:num for num,word in enumerate(words)}
    int_to_word = {value:key for key,value in word_to_int.items()}
    # 这一步就是将我们的输入序列,转化为对应的数值型的序列
    int_word_data = [word_to_int[word] for word in text]

    然后开始构建生成器,生成batch_size

    def get_batch(int_word_data,batch_size,len_seq,n_batch):
        # 该函数是为了构建batch_size
    
        int_word_data = int_word_data[:n_batch*batch_size*len_seq]
        int_word_data_y = int_word_data[1:]
        int_word_data_y.append(int_word_data[0])
    
        int_word_data = np.array(int_word_data).reshape([-1,n_batch*len_seq])
        int_word_data_y = np.array(int_word_data_y).reshape([-1,n_batch*len_seq])
    
        for i in range(n_batch):
            batch_x = np.zeros([batch_size,len_seq])
            batch_y = np.zeros([batch_size,len_seq])
            for j in range(batch_size):
                batch_x[j,:] = int_word_data[j,i*len_seq:(i+1)*len_seq]
                batch_y[j,:] = int_word_data_y[j,i*len_seq:(i+1)*len_seq]
            yield batch_x,batch_y

    然后开始构建rnn模型

    def init_rnn(hidden_size,layers,batch_size):
        # layers 表示lstm的层数
        # hidden_size lstm里面隐藏的大小,这个和记忆有关
    
        cells = []
        for _ in range(layers):
            cells.append(rnn.BasicLSTMCell(hidden_size))
    
        cell = rnn.MultiRNNCell(cells,state_is_tuple=True)
        # 以下是lstm的初始化,初始时,设置全部为0
        in_state = cell.zero_state(batch_size,tf.float32)
        # 这一步是给init_state取了个名字
        in_state = tf.identity(in_state,'in_state')
        return cell , in_state
    
    def bulid_rnn(hidden_size,layers,inputs,vocab_size,embed_dim,batch_size):
        # word2vec 的维度大小
        input_shape = tf.shape(inputs)
        cell,state = init_rnn(hidden_size,layers,input_shape[0])
        # 此处使用词向量编码
        embed = tf.contrib.layers.embed_sequence(inputs,vocab_size,embed_dim)
    
        output,out_state = tf.nn.dynamic_rnn(cell=cell,inputs=embed,dtype=tf.float32)
        out_state = tf.identity(out_state,name='out_state')
        # 以下是一个全连接层,输出大小为vocab_size,因为我们总共有vocab_size个单词,所以相当于需要得到每个词输出的概率,
        #就是softmax需要用到
        output = tf.contrib.layers.fully_connected(output,vocab_size,activation_fn=None)
        probability = tf.nn.softmax(output,name='probability')
    
        return output,out_state

    定义我们需要用到的参数

    # 参数的定义
    learing_rate = 0.01
    hidden_size = 512
    layers = 1
    embed_dim = 200
    batch_size = 64
    len_seq = 20
    vocab_size = len(words)
    num_epochs = 10
    n_batch = len(int_word_data) // (batch_size*len_seq)
    epochs = 100

    然后定义loss,optimizer等

    # 定义输入,input是我们输入的数据,y是相当于label
    inputs = tf.placeholder(tf.int32,[None,None],name='inputs')
    y = tf.placeholder(tf.int32,[None,None],name='target')
    output,state = bulid_rnn(hidden_size,layers,inputs,vocab_size,embed_dim,batch_size)
    
    # 这个loss其实就是交叉熵损失,只是他把计算softmax和计算交叉熵方一起了,然后同时计算了一个tf.reduce_sum
    loss = seq2seq.sequence_loss(output,y,tf.ones([batch_size,len_seq]))
    
    accuracy = tf.reduce_sum(tf.cast(tf.equal(tf.argmax(tf.nn.softmax(output),2),\
                                              tf.cast(y,tf.int64)),tf.float32))
    optimizer = tf.train.AdamOptimizer(learing_rate).minimize(loss)

    开始训练模型

    with tf.Session() as sess:
        writer = tf.summary.FileWriter('graphs/seq')
        sess.run(tf.global_variables_initializer())
    
        for epoch in range(epochs):
            total_loss = 0
            train_acc = 0
            for batch_x,batch_y in get_batch(int_word_data,batch_size,len_seq,n_batch):
    
                tmp_loss,tmp_acc,_ = sess.run([loss,accuracy,optimizer],feed_dict={inputs:batch_x,y:batch_y})
                total_loss += tmp_loss
                #train_acc += tmp_acc
            if epoch % 10 == 0:
    
                print('Epoch {}/{} train_loss {:.3f}'.format(epoch,epochs,total_loss/n_batch))
        saver = tf.train.Saver()
        saver.save(sess, './checkpoints/arvix/')
        print('Model Trained and Saved')
        writer.close()

    模型训练完成以后,我们开始预测结果
    定义我们的生成序列的函数

    def get_state(graph):
    
        # 拿到模型的输入,因为我们生成摘要的时候,也是需要给模型一个输入
        inputs = graph.get_tensor_by_name('inputs:0')
        # 拿到训练结束时的输出的状态,当作当前状态的输入,因为在rnn里面,他是有记忆的,他的输入和上一次有关,同时和当前
        #的输入也有关,是二者的一个综合
    
        in_state = graph.get_tensor_by_name('in_state:0')
        # 拿到输出状态,作为下一次的输入状态,
        out_state = graph.get_tensor_by_name('out_state:0')
    
        # 拿到当前输出的每个单词的概率,这个是为了我们预测做准备
        probability = graph.get_tensor_by_name('probability:0')
    
        return inputs,in_state,out_state,probability
    
    def get_word(probability,int_to_word):
    
        # np.random.choice(a,size,p)
        # 其中a表示一个数组,也就是随机数在其中选择生成,如何是一个数比如6,8等,则默认是np.arange(a)里面选择
        # size表示生成的大小,比如可以8行6列等等
        # p表示每一个可以选择的值的概率,必须加起来等于1
        # 使用int_to_word是为了将数值对应的单词输出
        int_w = np.random.choice(probability.shape[2],1,p=probability[0,0,:])[0]
        return int_to_word[int_w]

    设置我们初始的单词和生成序列的长度

    # 设置生成句子的长度
    gen_len = 300
    begin_word = 'deep'

    开始预测

    # 创建一个Graph对象
    graph = tf.Graph()
    
    with tf.Session(graph=graph) as sess:
        #  tf.train.import_meta_graph 表示不重复定义计算图
        load_meta = tf.train.import_meta_graph('./checkpoints/arvix/.meta')
        load_meta.restore(sess,'./checkpoints/arvix/')
    
        inputs,in_state,out_state,probability = get_state(graph)
    
        gen_sentences = [begin_word]
    
        pre_state = sess.run(in_state,feed_dict={inputs:np.array([[5]])})
    
        for n in range(gen_len):
            input_s = [[word_to_int[word] for word in gen_sentences[-gen_len:]]]
            seq_len = len(input_s[0])
            probability_,pre_stat= sess.run([probability,out_state],feed_dict={inputs:input_s,in_state:pre_state})
    
            gen_word = get_word(probability_,int_to_word)
    
            gen_sentences.append(gen_word)
    
        gen_sentences = ' '.join(gen_sentences)
    
        for key,value in tokenize_dict.items():
            gen_sentences = gen_sentences.replace(value,key+' ')
        print(gen_sentences)       

    预测结果如下:
    INFO:tensorflow:Restoring parameters from ./checkpoints/arvix/
    deep stacked rnn networks networks learning stacked rnns learning learning learning learning learning learning learning networks learning learning analysis rnns belief rnn neural neural neural feedforward rnn neural neural learning networks learning feedforward rnn network networks learning nets neural networks neural learning rnns stacked network learning rnns stacked networks autoencoder rnns learning network learning belief stacked autoencoder neural networks networks rnns autoencoder learning networks rnns network networks autoencoder stacked look learning feedforward autoencoder stacked neural rnns learning multi-layer rnn nets learning multi-layer learning learning rnn networks networks networks learning rnn autoencoder network stacked rnns learning models models neural learning clustering learning learning learning look networks learning learning learning networks network neural analysis models belief stacked hierarchical rnn learning rnn learning neural stacked learning networks neural rnns neural autoencoder neural learning networks models neural learning neural belief learning learning learning neural network neural look neural stacked autoencoder learning stacked learning neural learning networks analysis networks belief networks belief network feedforward network multi-layer look rnns models dual-stream neural neural networks learning belief dual-stream learning belief stacked learning learning long learning networks learning learning networks rnn networks learning look multi-layer learning look neural learning network dual-stream neural networks stacked learning stacked neural multi-layer autoencoder neural recurrent networks multi-layer learning learning learning learning rnns learning learning network neural belief networks neural learning learning learning models autoencoder learning recurrent learning stacked learning neural learning stacked neural ones neural networks rendering learning rnn learning multi-layer learning rnns learning belief learning learning networks analysis stacked look learning learning networks learning rnn learning learning networks learning analysis network clustering networks network learning autoencoder stacked learning rnn network dual-stream learning networks learning network stacked learning stacked networks look learning learning learning ones neural neural stacked learning learning learning network look rnns autoencoder neural learning neural learning learning network multi-layer stacked
    这就是利用rnn做序列的预测的方法。

    更多相关内容
  • 大家应该考虑这个函数在服务端应用还是在客户端应用。... 最好数据表中单独一个字段放这个摘要,这样相应的数据库查询也优化了。牺牲一点点空间换很多时间还是划算的。 再聊一下安全性问题,主要是内容安
  • 摘要:对合同文本手工录入方式存在的问题进行了分析,提出在C#环境下利用COM组件读/写MS Office Word和Ex-cel文件的技术,自动地生成Word格式合同文件的方法,并且根据该方法实现了自动生成合同文件的软件系统。...
  • 摘要:VB源码,网络相关,自动排版 vb源码实现文字自动排版并生成Word,最近一直在做核磁图像工作站导出到word模板,终于找到了一个功能简单的vb方法,能够把诊断报告导出到word中,这个源代码真不错,推荐给大家吧。
  • 今天学习的是自动生成文本摘要。当我们的身边的信息越来越多,数据越来越多,链接越来越多的时候,用一句简单的话就能把最重要的信息给表达出来,变得越来越重要。有了这个技能,我们就可以让机器为我们提取一篇文章...

    今天学习的是自动生成文本摘要。

    当我们的身边的信息越来越多,数据越来越多,链接越来越多的时候,用一句简单的话就能把最重要的信息给表达出来,变得越来越重要。

    有了这个技能,我们就可以让机器为我们提取一篇文章的重要信息,以后甚至是一本书的重要信息。

    这个技术最早是在气象领域应用起来的,就是用一个固定的格式把预测出来的数据套入进去,后来在金融领域,医疗领域也得到广泛的应用,这样的工具可以很好的帮助从业人员节省一部分时间。

    过去的方法是提取一个子集,而我们的大脑在对一篇文章进行总结的时候,利用的是抽象性思维,现在我们就可以用深度学习来模拟这个过程。

    pickle, 可以将python的对象转化成character stream,我们可以很轻松的重建这个对象:

    import cPickle as pickle

    FN0 = 'tokens' # this is the name of the data file which I assume you already have

    with open('data/%s.pkl'%FN0, 'rb') as fp:

    heads, desc, keywords = pickle.load(fp) # keywords are not used in this project

    返回的heads就是标题,desc就是相应的文章。

    接着我们需要把整个文章变成一个一个的单词,并且一个词一个词的生成总结。

    from collections import Counter

    from itertools import chain

    def get_vocab(lst):

    vocabcount = Counter(w for txt in lst for w in txt.split())

    vocab = map(lambda x: x[0], sorted(vocabcount.items(), key=lambda x: -x[1]))

    return vocab, vocabcount

    接着我们要用词向量来表示每个单词。

    word2vec是一个用大量数据提前训练好的模型,我们可以直接下载。

    词向量的每个维度可以表示一个性质,可以是性别或者是头衔等,词向量在每个维度的投影长度可以看作是这个单词在这个性质上的相关度。

    另一种算法叫做GloVe,它属于 count based的,

    每一行代表一个单词,每一列代表和这个单词出现在同一语境中的频数。

    GloVe 比 word2vec 稍微快一点,

    首先,将提前训练好的 glove 词向量下载到本地,然后用它们来初始化embedding matrix,我们先随机初始化,然后把 training vocabulary 出现的所有单词的 glove 权重复制一下。对于词汇表以外的单词,我们会找到离它最近的一个 glove 向量。

    path = 'glove.6B.zip'

    path = get_file(path, origin="http://nlp.stanford.edu/data/glove.6B.zip")

    然后我们要用 seq2seq 模型,我们输入一句话。

    encoder,输入就是 vocabulay 集,标签就是相应的一句话标题,embeddings 会在训练过程中不断地优化,loss 是 cross entropy。

    decoder,和encoder一样的 lstm 结构,权重矩阵也是用同样的提前训练好的 glove embeddings,它用来生成 summary。

    model = Sequential()

    model.add(Embedding(vocab_size, embedding_size,

    input_length=maxlen,

    W_regularizer=regularizer, dropout=p_emb, weights=[embedding], mask_zero=True,

    name='embedding_1'))

    for i in range(rnn_layers):

    lstm = LSTM(rnn_size, return_sequences=True, # batch_norm=batch_norm,

    W_regularizer=regularizer, U_regularizer=regularizer,

    b_regularizer=regularizer, dropout_W=p_W, dropout_U=p_U,

    name='lstm_%d'%(i+1)

    )

    model.add(lstm)

    model.add(Dropout(p_dense,name='dropout_%d'%(i+1)))

    这里有一个很关键的点,就是我们需要记住这段文字中的哪些部分呢?关于记忆的话,我们会选择用 ltm 模型来做,而在这个问题上另一个重要的理论就是 attention,它可以学到哪些数据是最相关的最需要记忆的。

    decoder 会先生成一个单词,然后把这个单词投入到下一层中,就会生成下一个单词,一直到生成一句标题。

    我们在 decoder 这里会应用 attention 机制,对于每一个输出的单词,会计算每个输入单词的权重,来决定应该在这个单词上投入多少 attention。这些权重会被用来计算最后一个隐藏层的加权平均,然后投入到 softmax中。

    可以看一下训练效果:

    X = "What have you been listening to this year ? If you want to find out using cold , hard evidence , then Spotify 's new Year in Music tool will tell you ."

    Y = "Spotify Will Make You Smarter for Your App"

    samples = gensamples(X, skips=2, batch_size=batch_size, k=10, temperature=1)

    HEADS:

    12.9753409925 How To Make A <0>^

    展开全文
  • Office2007Word目录自动生成详细方法,提供一个实例帮助您快速理解
  • 自动生成文本摘要

    万次阅读 2018-10-06 14:33:38
    什么是文本摘要生成 如何从网页上提取数据 如何清洗数据 如何构建直方图 如何计算句子分数 如何提取分数最高的句子/摘要 &amp;amp;amp;nbsp; 在继续往下阅读之前,我假设你已经了解下面几...

    欢迎大家关注我们的网站和系列教程:http://panchuang.net/ ,学习更多的机器学习、深度学习的知识!

    Revolver

    本文提及的主要内容有:
    • 什么是文本摘要生成
    • 如何从网页上提取数据
    • 如何清洗数据
    • 如何构建直方图
    • 如何计算句子分数
    • 如何提取分数最高的句子/摘要
     

    在继续往下阅读之前,我假设你已经了解下面几个方面的基础知识:

    • 正则表达式
    • 自然语言处理
    • 网页爬虫
     

     

    一、什么是文本摘要生成

    生成文本摘要的过程其实就是总结文本文档中心意思的过程,目的是创建包含原始文档主要内容的摘要。

    生成摘要的主要思想是找到包含整个数据集“信息”的数据子集。这种技术在当今行业内被广泛使用。搜索引擎就是一个例子; 其他还包括文档摘要生成,图像收集和视频处理。文档摘要生成算法试图通过查找信息量最大的句子来创建整个文档的代表性摘要,而在图像摘要中,计算机则试图找到最具代表性的显著的图像。对于监控视频,人们可能希望从平静的环境影像中提取出重要事件。

    自动摘要有两种通用方法:提取和抽象。

     

    二、如何从网页上提取数据?

    第1步:导入库/包

    • Beautiful Soup(bs)是一个Python库,用于从HTML和XML文件中提取数据。你可以把它和你最喜欢的解析器一起搭配使用,它们一起提供了一种符合我们习惯的导航,搜索和修改解析树的方法。这通常可以节省程序员数小时或数天的工作量。
    • Urllib是一个集合多个URL处理模块的软件包:
     

    urllib.request 用于打开url链接并读取内容

    urllib.error 包含由urllib.request抛出的异常值

    urllib.parse 用于解析URL

    urllib.robotparser用于解析 robots.txt 文件

     

    • re模块提供了类似于在Perl语言里的正则表达式匹配操作功能。
    • nltk是一个帮助构建处理人类语言数据的Python程序的强大平台。它为 50多种语料库和词法资源提供了易于使用的接口(如WordNet),还提供了一套用于分类,分词,词干提取,标注,解析和语义推理的文本处理工具库。
    • heapq这个模块提供了一个堆队列算法的实现,也称为优先队列算法。
     

    import bs4 as bs

    import urllib.request

    import re

    import nltk

    import heapq

     

    接下来检查一下数据包中的stopwords包(停用词)和punkt包是否更新到最新。

     

    nltk.download(‘stopwords’)

    nltk.download(‘punkt’)

    第2步:提取数据

    这里选用了维基上的 Artificial Neural Network 这个页面为例子来说明。你可以根据需要选择其他任何文章。

     

    page = urllib.request.urlopen(“https://en.wikipedia.org/wiki/Artificial_neural_network”).read()

    soup = bs.BeautifulSoup(page,‘lxml’)

    print(page) #print the page

    现在你可以看到我们提取出来的内容,但它看起来有点丑。我们使用BeautifulSoup来解析文档, 并以漂亮的方式来呈现文本。我还使用了prettify函数来使html语法看起来更美观。

     

    print(soup.prettify)

    注意:维基百科中的大多数文章都是在<p>标签下编写的,但不同的网站可能采取不同的方式。例如,一些网站会把文字内容写在<div>标签下。

     

    text = “”

    for paragraph in soup.find_all(‘p’):

    text += paragraph.text

    print(text)

    三、如何清洗数据

    数据清洗指的是对数据集,数据表或数据库中的所有数据,检测并纠正(或删除)损坏的或不准确的记录的过程,也即识别数据中不完整,不正确,不准确或不相关的部分,然后替换,修改,或删除这部分脏数据。

     

    text = re.sub(r’[[0-9]*]’,’ ',text)

    text = re.sub(r’\s+’,’ ',text)

    clean_text = text.lower()

    clean_text = re.sub(r’\W’,’ ',clean_text)

    clean_text = re.sub(r’\d’,’ ',clean_text)

    clean_text = re.sub(r’\s+’,’ ',clean_text)

    sentences = nltk.sent_tokenize(text)

    stop_words = nltk.corpus.stopwords.words(‘english’)

    print(sentences)

     

    第1行:删除文本中由类似[1],[2]表示的所有引用(参见上面的输出文本段)

    第2行:用单个空格替换了所有额外的空格

    第3行:转换成小写

    第4,5,6行:移除所有额外的标点符号,数字,额外空格等。

    第7行:使用sent_tokenize()函数将大段的文本分解为句子

    stop_words #list

    四、如何构建直方图

    构建一个直方图可以帮助你直观地发现文章中比较特别的单词。例如“Geoffrey Hinton is the god father of deep learning. And I love deep learning“这一句,需要计算每个不同的单词出现在句子中的次数,例如”deep“和”learning“都出现两次,其余的单词在一个句子中只出现一次。但在现实世界中,你有成千上万条句子,要具体找出每个单词出现多少次就需要构建直方图来表现。

     

    word2count = {} #line 1

    for word in nltk.word_tokenize(clean_text): #line 2

    if word not in stop_words: #line 3

    if word not in word2count.keys():

    word2count[word]=1

    else:

    word2count[word]+=1

    for key in word2count.keys(): #line 4

    word2count[key]=word2count[key]/max(word2count.values())

     

    第1行:创建一个空字典

    第2行:使用word_tokenize分词clean _text分词,对每个单词循环

    第3行:检查单词是否在stop_words中,然后再次检查单词是否在word2count的键集中,不在则把word2count [word]置为1,否则word2count [word] 加1。

    第4行:计算加权直方图(参见下面的输出,你可以看到对每个单词计算了权重而不是计数。 例如有 ‘artificial’:0.3620689等)

    五、如何计算句子分数

     

    第1行:创建一个空字典

    第2行:对sentences中每个sentence进行循环

    第3行:将sentence转换成小写并分词,对每个word循环

    第4行:使用if检查word2count.keys()中是否存在该单词

    第5行:这里我指定计算句子长度小于30的那部分,你可以根据需要更改

    第6行:再次使用if-else条件,判断如果句子不存在于sentence2keys()中,则执行 sent2score [sentence] = word2count [word],否则执行 sent2score [sentence] + = word2count [word]

     

    计算句子分数

    sent2score = {}

    for sentence in sentences:

    for word in nltk.word_tokenize(sentence.lower()):

    if word in word2count.keys():

    if len(sentence.split(’ '))<30:

    if sentence not in sent2score.keys():

    sent2score[sentence]=word2count[word]

    else:

    sent2score[sentence]+=word2count[word]

     

     

    六、查看句子得分

    七、如何提取分数最高的句子作为简短摘要

     

    使用heapq从文章中找到得分最高的七个句子。

     

    best_sentences = heapq.nlargest(7,sent2score,key=sent2score.get)

    for sentences in best_sentences:

    print(sentences,’\n’)

     

    关于Artificial Neural Network这篇文章七条概括得最好的句子

     

    原文链接

    https://towardsdatascience.com/text-summarization-96079bf23e83

     

    Github源码链接

    https://github.com/mohitsharma44official/Text--Summarization

     

    本篇文章出自http://www.tensorflownews.com,对深度学习感兴趣,热爱Tensorflow的小伙伴,欢迎关注我们的网站!

    展开全文
  • python自动生成word报告

    千次阅读 2021-03-25 21:54:52
    运用python自动生成word版本报告运用zipfile解压docx并替换模版内容 本文章主要介绍根据所提供的word模版,运用python zipfile库将word解压为xml格式,并通过文字替换自动生成word报告。 word模版-示例: python...

    python自动生成word报告


    本文章主要介绍根据所提供的word模版,运用python zipfile库将word解压为xml格式,并通过文字替换自动生成word报告。

    word模版-示例:
    在这里插入图片描述

    python根据word模版自动填充并生成word报告:
    在这里插入图片描述

    运用zipfile解压docx并替换模版内容

    代码如下:

    from zipfile import ZipFile
    import re
    import shutil
    
    
    #读文件
    def read_file(file):
        print(file)
        with open(file, 'r',encoding='UTF-8') as f:
            contents = f.read()
            f.close()
        return contents
    
    #写文件
    def write_file(file,contents):
        with open(file, 'w',encoding='UTF-8') as f:
            f.write(contents)
            f.close()
            
    #提取docx文件对应的xml结构文件
    def docx_to_xml(doc_file):
        document = ZipFile(doc_file)
        document.extractall(doc_file[:-5],)#提取xml到文件夹中   
        document.close()
        return document
    
    #将xml写回docx
    def xml_to_docx(doc_file,doc_xmls):
        new_docx_file = ZipFile(doc_file, mode='w')
        #重新写入word文件
        for xml in doc_xmls.namelist():
            new_docx_file.write(doc_file[:-5]+'/'+xml,xml)
        new_docx_file.close()
        
    #删除docx文件对应的xml结构文件
    def delete_docx_xmlfiles(doc_file):
        shutil.rmtree(doc_file[:-5]) 
    
        
    #获取模版里的要替换的标签(从xml文件中提取),此处标签格式:[标签]
    def get_all_tags(text):
        text=re.sub("<[^>]*>","",text) #移除xml标签
        tag_list=re.findall('\[[^\]]*\]',text)#找到[]配对,获得要替代的标签
        for i in range(len(tag_list)):
            tag_list[i]=re.sub(r"[\[\]\n\r]","",tag_list[i])#去除回车及标签括号
        #print('标签:',tag_list)
        return tag_list
    
    
    #使用re.sub替换xml中标签
    def find_and_replace_tag(content,tag_map):
        def replace_tag(matched):
            ori_tag=re.sub("<[^>]*>","",matched.group()) #去除xml标签,保留tag内容
            tag=re.sub(r"[\[\]\n\r]","",ori_tag)#去除回车及标签括号[]
            if tag in tag_map.keys():
                return tag_map[tag]
            else:
                print('没有为此标签赋值,请赋值:'+tag)
                return ori_tag
        result = re.sub(r"\[[\s\S]*?\]", replace_tag, content)#使用正则表达式获得要替换到字符串,并使用replace_tag自定义替换函数进行替换)
        return result
    
    #替换xml标签数据
    def replace_xml_data(xml_file,tag_map):
        xml=read_file(xml_file)
        tgt_xml = find_and_replace_tag(xml,tag_map)#获取tag并替换字符串,
        #将tgt_xml写入数据到xml文件中
        write_file(xml_file,tgt_xml)
        
    template_file='报告模版.docx' #word模版需是docx格式
    new_report_file='new_报告.docx'#要生成的报告名称
    shutil.copy(template_file,new_report_file)#复制模版至新周报
    doc_xmls=docx_to_xml(new_report_file)#提取docx的xml结构文件
    docx_main_xml=new_report_file[:-5]+'/'+'word/document.xml'#docx主xml文件
    all_tags=get_all_tags(read_file(docx_main_xml)) #获取docx中要替换的标签
    print(all_tags)
    #填充数据举例,变量名与标签名保持一致
    abtract='摘要填充-测试'
    title_1='标题1-测试'
    p_1='本段主要内容为:测试'
    title_2='标题2-测试'
    tag_map={}
    #为标签赋值,将要填充的数据赋值给标签
    for tag in all_tags:
        if tag in vars():
            tag_map[tag]=eval(tag)
    print(tag_map)
    #{'abtract': '摘要填充-测试', 'title_1': '标题1-测试', 'p_1': '本段主要内容为:测试', 'title_2': '标题2-测试'}
    replace_xml_data(docx_main_xml,tag_map) #为主xml替换标签
    xml_to_docx(new_report_file,doc_xmls)#将xml文件写回docx文件
    
    展开全文
  • 本科毕业设计,多文档自动摘要,摘要生成,采用聚类算法生成摘要,简单易调试,
  • word2007自动生成目录,目录里包含有正文,怎么办相关说明:请看,显示级别那项,1级,2级,3级文本显示的都没有正文的,可是目录生成出来就是有大刚视图中确认大刚级别为“正文文本”,不要用手动换行符)。...
  • 深度学习之文本摘要自动生成

    万次阅读 2017-12-06 13:47:10
    当我们点开某个网站或某个新闻APP的时候,经常能看到这样的题目:“14亿人都不知道的真相,历史的血泪……”、“删前速看!XXX视频流出”等,可是当我们点进去的时候,往往...而这需要的就是“文本摘要自动生成”技术!
  • 结合Word文档的模板技术, 巧妙运用 Word软件的“域”和“宏”两个功能, 应用VBA( Visual Basic for Applications) 编程, 研究了利用Visual Basic语言编写 的Word试验报告自动生成软件
  • 总第 182期 一 种基于MATLAB的Word报告自动生成方法 孙 剑 (信阳农林学院,河南 信阳 464000) 摘要自动生成Word文档报告功能是办公 自动化系统中的重要组成部分。为高效的完成数据处理任务,减少 MATLAB数据 处理 ...
  • 2. 论文写好之后才调整1、如果,此时你的论文已经写好了,章节编号都是手动输入的,不是自动生成的。如图:2、按照“1”中视频教的方法,把多级编号链接到对应的标题后,那么你会得到如图所示的结果:一共有自动编号...
  • 用户通过这个word排版工具可以对word文档进行批量自动排版的操作,特别适合处理数百页Word标书、论文、报告、规范、公文等格式要求严格的文档,能够实现自动处理段落,表格,图形,公式,脚注,页眉,页码,域,自动生成目录...
  • Word中如何自动生成、更新英文目录(使用域代码)

    万次阅读 多人点赞 2021-04-21 17:56:58
    毕业论文写作必看——word中如何利用域代码自动生成、更新英文目录
  • 该系统旨在使用深度学习工具自动生成科学文章的摘要(摘要)。 具体来说,我们在科学文章不同部分的表示上使用LSTM来生成摘要。 该存储库包含运行我们框架的不同模块所需的所有代码。 有关此项目的详细建议,可以在...
  • 方法一:根据标题内容生成摘要 # -*- coding: utf-8 -*- import jieba,copy,re,codecs from collections import Counter from text import title,text class Summary(): #**** 切分句子 ************ def ...
  • word目录怎么自动生成详细教程

    千次阅读 2021-06-23 10:57:49
    WORD文件功能众多,目录自动生成是其中的一项功能。使用这一功能能提高工作效率。如果不知道怎么用,就只有自己手动编辑目录,又费时又费力。所以文章写好后,目录怎么自动生成呢?下面以不同版本的word教给大家。...
  • Word文档如何自动生成文献摘要

    千次阅读 2011-03-24 14:54:00
    Word 97/2000/XP/2003均支持此项功能,用Word打开需要编辑的论文后,在“工具”菜单选择“自动编写摘要”即可弹出对话框。
  • 摘要:VB源码,报表打印,批量生成报表 VB源码:VisualBasic6.0利用VB+WORD 模板批量生成合同信息,将数据库的信息和WORD相结合。 可以根据自己的实际需要进行更改并生成合同,此为一个小小的管理程序。正在编写管理...
  • word自动生成目录

    2020-05-08 13:24:01
    我的笔记2:关于word自动生成目录 1.点击视图,选择大纲,大纲显示 2.将光标移到你想要生成的目录名称前 例如:我想将 摘要 设置成我的一个目录,将光标移动到摘要前面 目录栏的大纲显示下方有个1级,2级,3级… 想...
  • 自动摘要有时候,很简单的数学方法,就可以完成很复杂的任务。这个系列的前两部分就是很好的例子。仅仅依靠统计词频,就能找出关键词和相似文章。虽然它们算不上效果最好的方法,但肯定是最简便易行的方法。如果能从...
  • 一段比较好的生成自动摘要代码

    千次阅读 2018-10-12 16:07:03
    if word_idx[i] - word_idx[i - 1] cluster.append(word_idx[i]) else: clusters.append(cluster[:]) cluster = [word_idx[i]] i += 1 clusters.append(cluster) # 对每个族打分,每个族类的最大分数是对...
  • A Hierarchical Network for Abstractive ...1、提出Hierarchical Transformer,能够融合整个对话文本和角色信息,端到端地生成会议摘要; 2、采用新闻摘要数据构造伪会议摘要数据做预训练。 三、实现 (1)
  • 中文文本摘要生成.rar

    2022-03-14 14:57:25
    中文自动文摘,基于jieba分词,全Java代码。给定文本输出自定义长度的文摘
  • 基于BERT-PGN模型的中文新闻文本自动摘要生成

    千次阅读 热门讨论 2021-03-08 20:00:23
    1.将BERT与指针生成网络(PGN)相结合,提出了一种面向中文新闻文本的生成摘要模型,实现快速阅读; 2. 结合多维语义特征的BERT-PGN模型对摘要原文的理解更加充分,生成摘要内容更加丰富,全面且有效地减少重复...
  • 本次作业重点关注基于抽取式的文本自动摘要的实现,以及实现的算法——textrank。 pagerank算法应用于谷歌等搜索引擎中,通过网页链接的数量和质量来初略估计网页的重要性,从而对网页进行排名。textrank是基于...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 12,816
精华内容 5,126
关键字:

word自动生成摘要