fix bugs

1_app.py

@@ -0,0 +1,44 @@
+import numpy as np
+import gradio as gr
+import textInput
+
+output = []
+keys = []
+
+# css = ".output {min-height: 500px}"
+
+
+with gr.Blocks(css = ".output {min-height: 500px}") as demo:
+    #用markdown语法编辑输出一段话
+    gr.Markdown("# 文本分类系统")
+    gr.Markdown("请选择要输入的文件或填入文本")
+    topic_num = gr.Number(label="主题个数")
+    max_length = gr.Number(label="摘要最大长度")
+    with gr.Tabs():
+        with gr.Tab("文本输入"):
+            text_input = gr.TextArea(lines=10)
+            text_button = gr.Button("生成")
+    
+        with gr.Tab("文件输入"):
+            gr.Markdown("目前支持的格式有PDF、Word、txt")
+            file_input = gr.File(file_types=["text", ".pdf", ".docx"])
+            file_button = gr.Button("生成")
+    # 设置tab选项卡
+    with gr.Tabs():
+        with gr.Tab("分类页"):
+            text_keys_output = gr.TextArea(lines=30)
+
+        with gr.Tab("摘要页",):
+            #Blocks特有组件，设置所有子组件按水平排列
+            text_ab_output = gr.TextArea(lines=30)
+
+        with gr.Tab("下载页"):
+            file_txt_output = gr.File(label="txt格式")
+            file_docx_output = gr.File(label="docx格式")
+            file_pdf_output = gr.File(label="pdf格式")
+    # with gr.Accordion("Open for More!"):
+    #     gr.Markdown("Look at me...")
+    text_button.click(textInput.text_dump_to_lines, inputs=[text_input,topic_num,max_length], outputs=[text_keys_output,text_ab_output,file_txt_output,file_docx_output,file_pdf_output])
+    file_button.click(textInput.file_dump_to_lines,inputs=[file_input,topic_num,max_length], outputs=[text_keys_output,text_ab_output,file_txt_output,file_docx_output,file_pdf_output])
+    
+demo.launch()

1_textInput.py

@@ -0,0 +1,18 @@
+import docx
+from docx.oxml.ns import qn
+from docx.shared import Pt,RGBColor
+import fitz
+import os
+from fpdf import FPDF
+import run
+
+def text_dump_to_lines(text,topic_num,max_length):
+    lines = [x.strip() for x in text.split("\n") if x.strip()!='']
+    sentences = run.texClear(lines)
+    keys, output = run.textToAb(sentences,lines,int(topic_num),int(max_length))
+    keysText = "\n".join(keys)
+    outputText = "\n".join(output)
+    # text = "\n".join(lines)
+    # return text, text, dump_to_txt(lines), dump_to_docx(lines), dump_to_pdf(lines)
+    return keysText, outputText, dump_to_txt(output), dump_to_docx(output), dump_to_pdf(output)
+

BERT_inference.py

@@ -1,217 +1,18 @@
-# %%
-import numpy as np
-import pandas as pd
-import csv
-import torch.nn as nn
-from torch.optim.lr_scheduler import ReduceLROnPlateau
-from torch.utils.data import TensorDataset, DataLoader
-from transformers import BertTokenizer,BertConfig,AdamW
-from sklearn.metrics import accuracy_score
-from sklearn.metrics import classification_report
-from tqdm import tqdm
-import torch
-import transformers
-from torch.utils.data import Dataset, DataLoader
-
-# %%
-
-class MyDataSet(Dataset):
-    def __init__(self, loaded_data):
-        self.data = loaded_data
-    
-    def __len__(self):
-        return len(self.data)
-    
-    def __getitem__(self, idx):
-        return self.data[idx]
- 
-Data_path = "/kaggle/input/inference/train.csv"
-Totle_data = pd.read_csv(Data_path)
-Totle_data = Totle_data.sample(frac=0.1)
-Totle_data = Totle_data.dropna(axis=0,subset = ["2"])
-custom_dataset = MyDataSet(Totle_data)
-#按照比例划分
-train_size = int(len(custom_dataset) * 0.6)
-validate_size = int(len(custom_dataset) * 0.1)
-test_size = len(custom_dataset) - validate_size - train_size
-train_dataset, validate_dataset, test_dataset = torch.utils.data.random_split(custom_dataset, [train_size, validate_size, test_size])
- 
-#设置保存路径
-train_data_path="Bert_Try.csv"
-dev_data_path = "Bert_Dev.csv" 
-test_data_path="Bert_Test.csv"
-
-train_dataset = Totle_data.iloc[train_dataset.indices]
-validate_dataset = Totle_data.iloc[validate_dataset.indices]
-test_dataset = Totle_data.iloc[test_dataset.indices]
-
-#index参数设置为False表示不保存行索引,header设置为False表示不保存列索引
-train_dataset.to_csv(train_data_path,index=False,header=True)
-validate_dataset.to_csv(dev_data_path ,index=False,header=True)
-test_dataset.to_csv(test_data_path,index=False,header=True)
-
-# %%
-data = pd.read_csv(train_data_path)
-data.head
 
-# %%
+import transformers
+import torch.nn as nn
 
 class BertClassificationModel(nn.Module):
     def __init__(self):
         super(BertClassificationModel, self).__init__()   
-        #加载预训练模型
         pretrained_weights="bert-base-chinese"
         self.bert = transformers.BertModel.from_pretrained(pretrained_weights)
         for param in self.bert.parameters():
-            param.requires_grad = True
-        #定义线性函数      
+            param.requires_grad = True    
         self.dense = nn.Linear(768, 3)
         
     def forward(self, input_ids,token_type_ids,attention_mask):
-        #得到bert_output
         bert_output = self.bert(input_ids=input_ids,token_type_ids=token_type_ids, attention_mask=attention_mask)
-        #获得预训练模型的输出
         bert_cls_hidden_state = bert_output[1]
-        #将768维的向量输入到线性层映射为二维向量
         linear_output = self.dense(bert_cls_hidden_state)
-        return  linear_output
-
-# %%
-
-def encoder(max_len,vocab_path,text_list):
-    #将text_list embedding成bert模型可用的输入形式
-    #加载分词模型
-    tokenizer = BertTokenizer.from_pretrained("bert-base-chinese")
-    tokenizer = tokenizer(
-        text_list,
-        padding = True,
-        truncation = True,
-        max_length = max_len,
-        return_tensors='pt'  # 返回的类型为pytorch tensor
-        )
-    input_ids = tokenizer['input_ids']
-    token_type_ids = tokenizer['token_type_ids']
-    attention_mask = tokenizer['attention_mask']
-    return input_ids,token_type_ids,attention_mask
-
-# %%
-labels2dict = {"neutral":0,"entailment":1,"contradiction":2}
-def load_data(path):
-    csvFileObj = open(path)
-    readerObj = csv.reader(csvFileObj)
-    text_list = []
-    labels = []
-    for row in readerObj:
-        #跳过表头
-        if readerObj.line_num == 1:
-            continue
-        #label在什么位置就改成对应的index
-        label = int(labels2dict[row[0]])
-        text = row[1]
-        text_list.append(text)
-        labels.append(label)
-    #调用encoder函数，获得预训练模型的三种输入形式
-    input_ids,token_type_ids,attention_mask = encoder(max_len=150,vocab_path="/root/Bert/bert-base-chinese/vocab.txt",text_list=text_list)
-    labels = torch.tensor(labels)
-    #将encoder的返回值以及label封装为Tensor的形式
-    data = TensorDataset(input_ids,token_type_ids,attention_mask,labels)
-    return data
-
-# %%
-#设定batch_size
-batch_size = 16
-#引入数据路径
-train_data_path="Bert_Try.csv"
-dev_data_path="Bert_Dev.csv"
-test_data_path="Bert_Test.csv"
-#调用load_data函数，将数据加载为Tensor形式
-train_data = load_data(train_data_path)
-dev_data = load_data(dev_data_path)
-test_data = load_data(test_data_path)
-#将训练数据和测试数据进行DataLoader实例化
-train_loader = DataLoader(dataset=train_data, batch_size=batch_size, shuffle=True)
-dev_loader = DataLoader(dataset=dev_data, batch_size=batch_size, shuffle=True)
-test_loader = DataLoader(dataset=test_data, batch_size=batch_size, shuffle=False)
-
-# %%
-def dev(model,dev_loader):
-    model.to(device)
-
-    model.eval()
-
-    with torch.no_grad():
-        correct = 0
-        total = 0
-        for step, (input_ids,token_type_ids,attention_mask,labels) in tqdm(enumerate(dev_loader),desc='Dev Itreation:'):                
-            input_ids,token_type_ids,attention_mask,labels=input_ids.to(device),token_type_ids.to(device),attention_mask.to(device),labels.to(device)
-            out_put = model(input_ids,token_type_ids,attention_mask)
-            _, predict = torch.max(out_put.data, 1)
-            correct += (predict==labels).sum().item()
-            total += labels.size(0)
-        res = correct / total
-    return res
-
-# %%
-
-device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
-def train(model,train_loader,dev_loader) :
-
-    model.to(device)
-    model.train()
-    criterion = nn.CrossEntropyLoss()
-    param_optimizer = list(model.named_parameters())
-    no_decay = ['bias', 'LayerNorm.bias', 'LayerNorm.weight']
-
-    optimizer_grouped_parameters = [
-        {'params': [p for n, p in param_optimizer if not any(nd in n for nd in no_decay)],
-         'weight_decay': 0.01},
-        {'params': [p for n, p in param_optimizer if any(nd in n for nd in no_decay)], 'weight_decay': 0.0}
-    ]
-
-    optimizer_params = {'lr': 1e-5, 'eps': 1e-6, 'correct_bias': False}
-    optimizer = AdamW(optimizer_grouped_parameters, **optimizer_params)
-    scheduler = ReduceLROnPlateau(optimizer,mode='max',factor=0.5,min_lr=1e-7, patience=5,verbose= True, threshold=0.0001, eps=1e-08)
-    t_total = len(train_loader)
-
-    total_epochs = 10
-    bestAcc = 0
-    correct = 0
-    total = 0
-    print('Training and verification begin!')
-    for epoch in range(total_epochs): 
-        for step, (input_ids,token_type_ids,attention_mask,labels) in enumerate(train_loader):
-
-            optimizer.zero_grad()
-            input_ids,token_type_ids,attention_mask,labels=input_ids.to(device),token_type_ids.to(device),attention_mask.to(device),labels.to(device)
-            out_put =  model(input_ids,token_type_ids,attention_mask)
-            loss = criterion(out_put, labels)
-            _, predict = torch.max(out_put.data, 1)
-            correct += (predict == labels).sum().item()
-            total += labels.size(0)
-            loss.backward()
-            optimizer.step()
-             #每两步进行一次打印
-            if (step + 1) % 10 == 0:
-                train_acc = correct / total
-                print("Train Epoch[{}/{}],step[{}/{}],tra_acc{:.6f} %,loss:{:.6f}".format(epoch + 1, total_epochs, step + 1, len(train_loader),train_acc*100,loss.item()))
-            #每五十次进行一次验证
-            if (step + 1) % 200 == 0:
-                train_acc = correct / total
-                #调用验证函数dev对模型进行验证，并将有效果提升的模型进行保存
-                acc = dev(model, dev_loader)
-                if bestAcc < acc:
-                    bestAcc = acc
-                    #模型保存路径
-                    path = 'bert_model.pkl'
-                    torch.save(model, path)
-                print("DEV Epoch[{}/{}],step[{}/{}],tra_acc{:.6f} %,bestAcc{:.6f}%,dev_acc{:.6f} %,loss:{:.6f}".format(epoch + 1, total_epochs, step + 1, len(train_loader),train_acc*100,bestAcc*100,acc*100,loss.item()))
-        scheduler.step(bestAcc)
-
-# %%
-
-path = '/kaggle/input/inference/bert_model.pkl'
-# model = torch.load(path)
-#实例化模型
-model = BertClassificationModel()
-#调用训练函数进行训练与验证
-train(model,train_loader,dev_loader)
+        return  linear_output

app.py

@@ -5,31 +5,40 @@ import textInput
 output = []
 keys = []
 
+# css = ".output {min-height: 500px}"
 
-with gr.Blocks() as demo:
+
+with gr.Blocks(css = ".output {min-height: 500px}") as demo:
     #用markdown语法编辑输出一段话
     gr.Markdown("# 文本分类系统")
     gr.Markdown("请选择要输入的文件或填入文本")
-    topic_num = gr.Number(label = "主题数")
+    topic_num = gr.Number(label="主题个数")
     max_length = gr.Number(label="摘要最大长度")
     with gr.Tabs():
         with gr.Tab("文本输入"):
-            text_input = gr.Textbox()
+            text_input = gr.TextArea(lines=10)
             text_button = gr.Button("生成")
     
         with gr.Tab("文件输入"):
             gr.Markdown("目前支持的格式有PDF、Word、txt")
-            file_input = gr.File()
+            file_input = gr.File(file_types=["text", ".pdf", ".docx"])
+            file_button = gr.Button("生成")
     # 设置tab选项卡
     with gr.Tabs():
         with gr.Tab("分类页"):
-            text_keys_output = gr.Textbox()
+            text_keys_output = gr.TextArea(lines=30)
 
-        with gr.Tab("摘要页"):
+        with gr.Tab("摘要页",):
             #Blocks特有组件，设置所有子组件按水平排列
-            text_ab_output = gr.Textbox()
+            text_ab_output = gr.TextArea(lines=30)
+
+        with gr.Tab("下载页"):
+            file_txt_output = gr.File(label="txt格式")
+            file_docx_output = gr.File(label="docx格式")
+            file_pdf_output = gr.File(label="pdf格式")
     # with gr.Accordion("Open for More!"):
     #     gr.Markdown("Look at me...")
-    text_button.click(textInput.text_dump_to_json, inputs=[text_input,topic_num,max_length], outputs=[text_keys_output,text_ab_output])
-    # image_button.click(flip_image, inputs=image_input, outputs=image_output)
+    text_button.click(textInput.text_dump_to_lines, inputs=[text_input,topic_num,max_length], outputs=[text_keys_output,text_ab_output,file_txt_output,file_docx_output,file_pdf_output])
+    file_button.click(textInput.file_dump_to_lines,inputs=[file_input,topic_num,max_length], outputs=[text_keys_output,text_ab_output,file_txt_output,file_docx_output,file_pdf_output])
+    
 demo.launch()

classification.py

@@ -12,13 +12,13 @@ def classify_by_topic(articles, central_topics):
     def compute_similarity(articles, central_topics):
 
         model = AutoModel.from_pretrained("distilbert-base-multilingual-cased")
-        tokenizer = AutoTokenizer.from_pretrained("distilbert-base-multilingual-cased",max_length=512)
+        tokenizer = AutoTokenizer.from_pretrained("distilbert-base-multilingual-cased")
 
         def sentence_to_vector(sentence, context):
 
             sentence = context[0]+context[1]+sentence*4+context[2]+context[3]
             tokens = tokenizer.encode_plus(
-                sentence, add_special_tokens=True, return_tensors="pt")
+                sentence, add_special_tokens=True, return_tensors="pt",max_length = 512,truncation=True)
 
             outputs = model(**tokens)
             hidden_states = outputs.last_hidden_state

inference.py

@@ -5,6 +5,7 @@ import torch
 import torch.nn as nn
 from torch import cuda
 from transformers import BertTokenizer
+from BERT_inference import BertClassificationModel
 
 
 def encoder(max_len,text):
@@ -35,31 +36,16 @@ def predict(model,device,text):
         # print(probs)
         return probs[0][1]
  
-
-class BertClassificationModel(nn.Module):
-    def __init__(self):
-        super(BertClassificationModel, self).__init__()   
-        pretrained_weights="bert-base-chinese"
-        self.bert = transformers.BertModel.from_pretrained(pretrained_weights)
-        for param in self.bert.parameters():
-            param.requires_grad = True    
-        self.dense = nn.Linear(768, 3)
-        
-    def forward(self, input_ids,token_type_ids,attention_mask):
-        bert_output = self.bert(input_ids=input_ids,token_type_ids=token_type_ids, attention_mask=attention_mask)
-        bert_cls_hidden_state = bert_output[1]
-        linear_output = self.dense(bert_cls_hidden_state)
-        return  linear_output
         
 def inference_matrix(topics):
     device = torch.device('cuda' if cuda.is_available() else 'cpu')
-    load_path = "bert_model.pkl"   
+    load_path = "TSA/bert_model.pkl"   
     model = torch.load(load_path,map_location=torch.device(device))
     matrix = np.zeros([len(topics),len(topics)],dtype=float)
     for i,i_text in enumerate(topics):
         for j,j_text in enumerate(topics):
             if(i == j):
-                matrix[i][j] = 1
+                matrix[i][j] = 0
             else:
                 test = i_text+"  是否包含  "+j_text
                 outputs = predict(model,device,test)

outline.py

@@ -1,38 +1,137 @@
 import numpy as np
 from scipy.cluster.hierarchy import linkage, fcluster, dendrogram
 import matplotlib.pyplot as plt
+import numpy as np
 
-def passage_outline(matrix,sentences):
+def find_parent(matrix, node):
+    # 获取该节点的所有可能的父节点及其概率
+    parents = matrix[:, node]
+    # 找出其中概率最大的父节点
+    max_parent = np.argmax(parents)
+    # 如果该父节点的概率不为零，那么返回该父节点
+    if parents[max_parent] > 0:
+        return max_parent
+    # 否则，返回None，表示该节点没有父节点
+    else:
+        return None
 
-    Z = linkage(matrix, method="average")
 
-    mask = np.eye(matrix.shape[0], dtype=bool)
-    matrix = np.ma.masked_array(matrix, mask)
-    median = np.median(matrix)
+def find_tree(matrix, node, depth=1, children=[], max_depth=1, visited=set()):
+    # 定义一个空列表，用来存储结果
+    result = []
+    # 调用find_parent函数，找出该节点的最可能的父节点
+    parent = find_parent(matrix, node)
+    # 如果该父节点存在，且不在visited中
+    if parent is not None and parent not in visited:
+        # 将该父子关系添加到结果列表中
+        result.append([parent, node])
+        # 遍历当前节点的所有子节点
+        for child in children:
+            # 将该子节点和当前节点的关系也添加到结果列表中
+            result.append([node, child])
+        # 如果当前深度小于最大深度，那么递归地调用find_tree函数，传入概率矩阵和该父节点作为参数，并将深度加一
+        if depth < max_depth:
+            # 将当前节点添加到visited中
+            visited.add(node)
+            # 递归调用find_tree函数，并将visited传入
+            result.extend(find_tree(matrix, parent, depth + 1, visited=visited))
+    # 返回结果列表
+    return result
 
-    labels = fcluster(Z, t=median, criterion="distance")
+# 定义一个函数，它接受一个树形结构作为参数，然后返回该树形结构的概率
+def find_prob(tree, matrix):
+    # 定义一个变量，用来存储概率，初始值为1
+    prob = 1
+    # 遍历树形结构中的每个父子关系
+    for parent, child in tree:
+        # 将该父子关系对应的概率乘到变量上
+        prob *= matrix[parent][child]
+    # 返回最终的概率
+    return prob
 
+# 定义一个函数，它接受一个概率矩阵和一个k值作为参数，然后返回前k个最可能的森林及其概率
+def find_forests(matrix, k):
+    # 定义一个空字典，用来存储每个森林及其概率
+    forests = {}
+    # 遍历所有的节点
+    for i in range(len(matrix)):
+        # 获取该节点的所有可能的子节点及其概率
+        children = matrix[i]
+        # 定义一个空列表，用来存储该节点的所有子节点
+        child_list = []
+        # 遍历所有的子节点
+        for j in range(len(children)):
+            # 如果子节点的概率不为零
+            if children[j] > 0:
+                # 将该子节点添加到列表中
+                child_list.append(j)
+        # 调用find_tree函数，传入概率矩阵、当前节点和子节点列表作为参数，并将返回的结果赋值给tree
+        tree = find_tree(matrix, i, children=child_list)
+        tree = tuple([tuple(x) for x in tree]) # 将列表中的每个元素转换为元组，然后再将整个列表转换为元组
+        if tree:
+            # 调用find_prob函数，传入tree作为参数，并将返回的结果赋值给prob
+            prob = find_prob(tree, matrix)
+            # 如果tree已经在字典的键中，即该树形结构已经被添加过
+            if tuple(tree) in forests:  # 将tree转换为元组
+                # 那么将prob加到字典的值上，表示该树形结构出现了多次
+                forests[tuple(tree)] += prob  # 将tree转换为元组
+            # 否则，即该树形结构是第一次被添加
+            else:
+                # 那么将tree和prob作为键值对添加到字典中
+                forests[tuple(tree)] = prob  # 将tree转换为元组
+    # 将字典按照值降序排序，得到一个列表，每个元素是一个键值对的元组
+    sorted_forests = sorted(forests.items(), key=lambda x: x[1], reverse=True)
+    # 返回列表的第一个元素，即最可能的森林及其概率
+    forest, prob = sorted_forests[0]
+    # 定义一个空字典，用来存储带有层级结构的森林
+    result = {}
+    # 遍历森林中的每个树形结构
+    for parent, child in forest:
+        # 如果父节点已经在字典的键中，即该父节点已经有其他子节点
+        if parent in result:
+            # 那么将当前子节点添加到父节点对应的值中，即该父节点的子节点列表中
+            result[parent].append(child)
+        # 否则，即该父节点是第一次出现
+        else:
+            # 那么将父节点和当前子节点作为键值对添加到字典中，即创建���个新的子节点列表
+            result[parent] = [child]
+    # 返回带有层级结构的字典和概率
+    return result, prob
+def passage_outline(matrix,sentences):
 
-    # 根据簇标签和主题句子生成文章结构
+    # Z = linkage(matrix, method="average")
+    # median = np.median(matrix)
+    # print(median)
+    # print('yes')
+    # labels = fcluster(Z, t=median, criterion="distance")
+    # print(labels)
+    # 调用函数，传入概率矩阵作为参数，并且指定最大深度为1
+    result, prob = find_forests(matrix, 1)
+    # 打印结果字典和概率
+    print(result, prob)
+        # 根据簇标签和主题句子生成文章结构
     structure = {}
-    for label, sentence in zip(labels, sentences):
-        if label not in structure:
-            structure[label] = []
-        structure[label].append(sentence)
+    for each in result.keys():
+        structure[each] =[sentences[i] for i in result[each]]
+    # for label, sentence in zip(result.keys(), sentences):
+    #     if label not in structure:
+    #         structure[label] = []
+    #     structure[label].append(sentence)
     outline = ""
     outline_list = []
     for key in sorted(structure.keys()):
-        outline_list.append(f"主题{key}：")
-        outline = outline+f"主题{key}：\n"
+        outline_list.append(f"主题：")
+        outline = outline+f"主题：\n"
         for sentence in structure[key]:
             outline_list.append(sentence)
             outline = outline+f"- {sentence}\n"
     return outline,outline_list
 if __name__ == "__main__":
-    matrix = np.array([[1.0, 0.8, 0.2, 0.1],
-                [0.8, 1.0, 0.3, 0.2],
-                [0.2, 0.3, 1.0, 0.9],
-                [0.1, 0.2, 0.9, 1.0]])
-    sentences = ["主题句子1", "主题句子2", "主题句子3", "主题句子4"]
+    matrix = np.array([[0.0 ,0.02124888, 0.10647043 ,0.09494194 ,0.0689209 ],
+                        [0.01600688 ,0.0 ,0.05879448 ,0.0331325 , 0.0155093 ],
+                        [0.01491911 ,0.01652437, 0.0, 0.04714563, 0.04577385],
+                        [0.01699071 ,0.0313585 , 0.040299   ,0.0 ,0.014933  ],
+                        [0.02308992 ,0.02791895 ,0.06547201, 0.08517842 ,0.0]])
+    sentences = ["主题句子1", "主题句子2", "主题句子3", "主题句子4", "主题句子5"]
     print(passage_outline(matrix,sentences)[0])
     

run.py

@@ -25,6 +25,8 @@ from inference import BertClassificationModel
 
 def texClear(article):
     sentencesCleared = [util.clean_text(sentence) for sentence in article]
+    sentencesCleared = [string for string in sentencesCleared if string != '' ]
+    # print(sentencesCleared)
     return sentencesCleared
 
 def textToAb(sentences, article, topic_num, max_length):
@@ -34,14 +36,11 @@ def textToAb(sentences, article, topic_num, max_length):
     title_dict,title = util.generation(groups, max_length)
     # ans:
     # {Ai_abstruct:(main_sentence,paragraph)}
-
+    print(title)
     matrix = inference.inference_matrix(title)
 
     _,outline_list = outline.passage_outline(matrix,title)
 
     output = util.formate_text(title_dict,outline_list)
-    keys = []
-    for key in title.keys():
-        keys.append(key)
 
-    return keys, output
+    return title, output

test.txt

@@ -0,0 +1,32 @@
+计算机科学与技术在现代教育中的应用
+1.  增强效率
+计算机科学与技术的应用可以在现代教育中大大增强教学和学习的效率。从教学方面来看，教师不仅可以利用电脑和互联网以及多种课程支持软件，提供丰富多彩的课堂内容，而且可以通过投影仪、多媒体幻灯片和电视等技术来辅助教学、展示多样性以及改进课堂氛围，以帮助提高学生的学习兴趣。在学习方面，学生可以通过网络课程或通过互联网查阅各种信息来获取知识，大大增强学习的效率和效果；此外，学生也可以利用图形配文工具，进一步帮助让文字表达更加明确，使推理更加简单和便捷。考试方面，计算机科学与技术也可以发挥独特的作用，比如，通过计算机在线考试系统来更好地实施考试，使考试结果更准确、及时；而且，在考试中加入计算机图形，有助于将考试难度提高，从而更好地测试学生的思维能力。综上所述，计算机科学与技术已在现代教育中发挥着重要作用，有助于大幅提高教育的效率。
+
+1.1  方便高效的教学
+计算机科学是认知科学研究的主要领域之一，它主要研究信息处理和控制的机制，而技术代表了手段、方式和手段。由此可见，计算机科学与技术对于现代教育显然是至关重要的，它们不仅具有极大的潜力，而且可以为教育活动提供有效、高效的支持。
+计算机技术可以用于从基础到较高水平的各种学习成果的测量。例如，学校可以利用电脑系统开发和管理学生的作业和测验，提供准确的评估机制和工具，并且能够帮助学生更好地学习和理解学科知识。不仅如此，计算机技术还可以通过开放式教育、网络教学形式等方式改进常规的教学与学习模式，从而提升教育质量。
+带有计算机技术的教室可以更好地提升学生的学习体验，让学生能够了解复杂的概念，从而对学科有更深入的理解。同时，计算机科学可以为学校和家庭提供有效的学习渠道，让学生从最舒适的环境中接受教育，激发学生的更多想象力和创造力。
+总之，计算机科学和技术在现代教育中发挥着至关重要的作用。它们不仅改变了现代教育的局面，提供了更为有效和高效的教学办法，而且同时可以为学生和家长带来更多种可能性，提高全社会的教育素质。在未来，计算机科学与技术将继续发挥重要作用，促进发展学科教育，推动教育革新。
+
+1.2  提高教学质量
+在当今的社会，计算机科学与技术已成为教育的一个重要组成部分，甚至有助于提高当今教育的质量。对于那些精通计算机技术的教师而言，他们可以更好地把这些知识和技术纳入到课堂教学中，帮助学生更好地理解这些难以把握的概念。使用计算机技术，教师可以为学生提供更多有趣的学习方式，丰富课程、带来新的学习方式。例如，一些计算机科学和技术的软件可以帮助学生可视化地理解这些复杂的课程和概念，他们可以以一种全新的方法去接受这些知识，也可以使他们更容易地掌握新内容。此外，在现代教育中使用技术可以更快地从一个概念转到另一个概念，教师们可以更快更有效地完成他们的课程计划。
+在教学中，计算机科学与技术可以使教学变得生动有趣自然，尤其是对于跨学科的课程，而且教师可以更轻松地与学生进行交流，使学生了解知识的更多细节，并为学生提出困惑的问题和解决可能存在的问题。例如，可以使用在线视频来进行实时互动，也可以使用一个特定的计算机程序来解决数学问题，使学生更容易掌握数学概念。此外，教师可以使用网络资源来激发学生的学习兴趣，从而提高学生对课程的学习兴趣。在学校里，也可以使用计算机技术支持学生的作业管理，教师可以节省时间来更有效地完成诸多任务，同时学生也可以使用聊天机器人等软件来了解和学习课程的内容。
+因此，计算机科学与技术对当今的教育有着重要的意义和影响。它可以为教师提供更有效的教学工具，促进他们教授新内容，同时也为学生提供新有趣的学习方式，帮助他们更好地理解它们。此外，教师也可以使用计算机技术来节省自己的工作时间，减少课堂的压力，提高教学的质量和效率。因此，在当今快速发展的教育环境中，计算机科学与技术的应用已经成为必不可少的有效途径。
+
+2.  拓展视野
+计算机科学与技术在现代教育中已经广泛应用，从初中到高等教育都可以看出其影响的足迹。光影现代化的信息技术越来越成为教学及学习的重要工具，成为一个不可缺少的教育基础设施，深刻改变了传统教育模式，开发了教学资源和学习资源，让学习更便捷、趣味性增强，并且让课堂及学习活动更加紧凑有效，更有利于学习者们的认知过程的发展。
+计算机技术在教育中的拓展视野和使用方式变得越来越广泛。计算机可以作为通讯工具，连接教师和学生之间，通过电子邮件、网络学习平台以及虚拟互动空间等在线社区来实现教学过程的自动化，为新的教育理念提供技术支持。在线教学平台可以实现远程教学，远程教学可以不受地域限制，跨国受教，这样一个跨境学习者网络就可以形成，让教师和学生有机会正向互动，极大地拓展了学习者们的认知视野。
+计算机科学与技术不仅仅只是改变教育理念，还可以帮助学习者们更好的执行学习计划，学习分析
+
+2.1  扩展课程范围
+计算机科学与技术（CST）在现代教育中占据着重要的地位，它可以帮助学生提高他们的数学能力，掌握现代技术，从而帮助他们牢牢把握未来社会发展的主动权。在现代课程体系中，CST有着广泛的应用。
+首先，CST可以帮助学生增强数学素养。在学校里，机器学习（ML）课程可以帮助学生在使用技术的同时加强基础的数学能力，加深学生对数学的理解。ML还可以让学生在开发数学方面得到更多的练习机会。
+此外，CST还可以帮助学生学习现代技术。现在，许多社会都在使用一些前沿技术，如机器人，人工智能，大数据分析等，因此要掌握这些技术，掌握CST就变得更加重要。在学校的课程中，学生可以学习有关编程语言，系统管理，网络架构等内容，帮助他们更好地掌握相关技术。
+最后，CST还可以帮助学生牢牢把握未来社会发展的主动权。现代社会，基于信息技术的环境正在变得越来越广泛，因此对于学生来说，学习CST成为至关重要。CST不仅可以让他们掌握基本技术，也可以让他们熟悉信息技术产业和社会热点，为他们深入学习未来技术提供强有力的支持。
+总之，CST在现代教育中占据着重要的地位，可以帮助学生提高数学能力，掌握现代技术，从而牢牢把握未来社会发展的主动权。在学校的课程体系里，针对不同的学生层次，可以提供机器学习，编程，系统管理，网络架构等知识的相关课程。当学生拥有这样的学习能力时，他们就可以跟上社会的变化，并使自己更好地适应未来发展的趋势。
+
+2.2  探索技术
+计算机科学与技术已经成为现代教育领域中越来越重要的部分。随着新世纪到来，各种形式的技术不断提高，人们都在探索如何最好地使用新技术和知识来更好地教育我们的学生。在21世纪，计算机科学和技术在教育领域发挥着重要作用，它可以改善学习环境，使学习变得更有效率，并为学生提供独特的机会来拓宽知识面。
+计算机科学和技术可以用来支持传统的教育方法，从而改善传统的学习方式。它可以使学生针对个性化的教学目标进行自主学习。计算机科学和技术也可以用来提高学生的技能。例如，它可以帮助学生学习新技能，包括计算机编程，图形设计，信息技术以及许多其他领域。这些新技能将令学生能够更好地发挥创新的潜力，并有助于将他们的职业发展到新的高度。
+计算机科学和技术还可以为学生带来更加丰富的学习体验。它可以通过科技手段激发学习的兴趣，通过虚拟实践提高学习的效果，使得学习者更好地理解课程内容，增加学习的效率。此外，计算机科学技术还可以通过社交媒体大大节省学习者与教师之间的交流时间，使教师可以精准地帮助学生解决学习中遇到的难题。
+总而言之，计算机科学和技术为现代教育领域提供了无限的机遇，能够有效地改善教育水平，提高学生的学习能力以及技能，帮助他们获得更广阔的知识面。此外，计算机科学技术还可以为学生带来可持续的学习体验，以及更遥远的跨文化交流机会。让我们共同努力，使计算机科学和技术发挥最大的社会效应，为人类发展服务。

textInput.py

@@ -1,13 +1,111 @@
 import run
+import util
+import docx
+from docx.oxml.ns import qn
+from docx.shared import Pt,RGBColor
+import fitz
+import os
+from fpdf import FPDF
+import run
+from BERT_inference import BertClassificationModel
+
 
 def text_dump_to_json(text,topic_num,max_length):
-    lines = [x.strip() for x in text.split("\n") if x.strip()!='']
+    lines = util.seg(text)
+    sentences  = run.texClear(lines)
+    print(sentences)
+    keys, output = run.textToAb(sentences,lines,int(topic_num),int(max_length))
+    keysText = "\n".join(keys)
+    outputText = "\n".join(output)
+    print(keys,output)
+    return keysText, outputText, dump_to_txt(output), dump_to_docx(output), dump_to_pdf(output)
+
+def file_dump_to_lines(file,topic_num,max_length):
+    lines = []
+    # print(file.name)
+    fileFormat = file.name.split(".")[-1]
+    # print(fileFormat)
+    if fileFormat == "txt":
+        with open(file.name,  encoding='utf-8') as f:
+            content = f.read()
+            lines = [x.strip() for x in content.split("\n") if x.strip()!='']
+    elif fileFormat == "docx":
+        doc=docx.Document(file.name)
+        paragraphs = doc.paragraphs
+        lines = [par.text for par in paragraphs]
+    elif fileFormat == "pdf":
+        pdf = fitz.open(file.name)
+        for page in pdf:
+            pageText = page.get_text("text")
+            lines.extend([x.strip() for x in pageText.split("\n") if x.strip()!=''])
+    # print(lines)
+    # text = "\n".join(lines)
     sentences = run.texClear(lines)
     keys, output = run.textToAb(sentences,lines,int(topic_num),int(max_length))
     keysText = "\n".join(keys)
     outputText = "\n".join(output)
-    return keys, output
+    # text = "\n".join(lines)
+    # return text, text, dump_to_txt(lines), dump_to_docx(lines), dump_to_pdf(lines)
+    return keysText, outputText, dump_to_txt(output), dump_to_docx(output), dump_to_pdf(output)
+
+def dump_to_txt(lines):
+    text = "\n".join(lines)
+    with open('temp.txt',mode="w",encoding="utf-8") as f:
+        f.write(text)
+    path = os.path.abspath('temp.txt')
+    return path
+
+def dump_to_docx(lines):
+    document = docx.Document()
+    document.styles['Normal'].font.name = u'宋体'
+    document.styles['Normal']._element.rPr.rFonts.set(qn('w:eastAsia'), u'宋体')
+    document.styles['Normal'].font.size = Pt(14)
+    document.styles['Normal'].font.color.rgb = RGBColor(0,0,0)
+
+
+    paragraph = document.add_paragraph()
+    run = paragraph.add_run()
+    #run.font.name = 'Times New Roman' 
+    run.font.name=u'Cambria'
+    run.font.color.rgb = RGBColor(0,0,0)
+    run._element.rPr.rFonts.set(qn('w:eastAsia'), u'Cambria')
+
+    for line in lines:
+        document.add_paragraph(line)
+    
+    document.save(r'temp.docx')
+    path = os.path.abspath('temp.docx')
+
+    return path
 
-def file_dump_to_json(file):
+def dump_to_pdf(lines):
+    pdf = FPDF()
+    #读取字体文件
+    pdf.add_font('FZY3JW', '', 'TSA/FZY3JW.TTF', True)
+    pdf.add_page()
+    #设置pdf字体大小
+    pdf.set_font("FZY3JW", size=12)
+    #打开txt文本
+    try:
+        #按行读取txt文本内容
+        for line in lines:
+            str=line
+            num=len(str)
+            temp=45#判断标志，实现pdf文件每行最多村45个字符
+            for j in range(0,num,temp):
+                if(j+temp<num):
+                    data=str[j:j+temp]
+                else:
+                    data=str[j:num]
+                pdf.cell(0, 5, data, ln=1)
+    except Exception as e:
+        print(e)
+    pdf.output("temp.pdf")
+    path = os.path.abspath('temp.pdf')
+    return path
 
-    return
+if __name__ == "__main__":
+    with open('TSA/test.txt', 'r', encoding='utf-8') as f:
+        data = f.read()
+        # print(data)
+        text_dump_to_json(data,10,50)

train.py

@@ -0,0 +1,217 @@
+# %%
+import numpy as np
+import pandas as pd
+import csv
+import torch.nn as nn
+from torch.optim.lr_scheduler import ReduceLROnPlateau
+from torch.utils.data import TensorDataset, DataLoader
+from transformers import BertTokenizer,BertConfig,AdamW
+from sklearn.metrics import accuracy_score
+from sklearn.metrics import classification_report
+from tqdm import tqdm
+import torch
+import transformers
+from torch.utils.data import Dataset, DataLoader
+
+# %%
+
+class MyDataSet(Dataset):
+    def __init__(self, loaded_data):
+        self.data = loaded_data
+    
+    def __len__(self):
+        return len(self.data)
+    
+    def __getitem__(self, idx):
+        return self.data[idx]
+ 
+Data_path = "/kaggle/input/inference/train.csv"
+Totle_data = pd.read_csv(Data_path)
+Totle_data = Totle_data.sample(frac=0.1)
+Totle_data = Totle_data.dropna(axis=0,subset = ["2"])
+custom_dataset = MyDataSet(Totle_data)
+#按照比例划分
+train_size = int(len(custom_dataset) * 0.6)
+validate_size = int(len(custom_dataset) * 0.1)
+test_size = len(custom_dataset) - validate_size - train_size
+train_dataset, validate_dataset, test_dataset = torch.utils.data.random_split(custom_dataset, [train_size, validate_size, test_size])
+ 
+#设置保存路径
+train_data_path="Bert_Try.csv"
+dev_data_path = "Bert_Dev.csv" 
+test_data_path="Bert_Test.csv"
+
+train_dataset = Totle_data.iloc[train_dataset.indices]
+validate_dataset = Totle_data.iloc[validate_dataset.indices]
+test_dataset = Totle_data.iloc[test_dataset.indices]
+
+#index参数设置为False表示不保存行索引,header设置为False表示不保存列索引
+train_dataset.to_csv(train_data_path,index=False,header=True)
+validate_dataset.to_csv(dev_data_path ,index=False,header=True)
+test_dataset.to_csv(test_data_path,index=False,header=True)
+
+# %%
+data = pd.read_csv(train_data_path)
+data.head
+
+# %%
+
+class BertClassificationModel(nn.Module):
+    def __init__(self):
+        super(BertClassificationModel, self).__init__()   
+        #加载预训练模型
+        pretrained_weights="bert-base-chinese"
+        self.bert = transformers.BertModel.from_pretrained(pretrained_weights)
+        for param in self.bert.parameters():
+            param.requires_grad = True
+        #定义线性函数      
+        self.dense = nn.Linear(768, 3)
+        
+    def forward(self, input_ids,token_type_ids,attention_mask):
+        #得到bert_output
+        bert_output = self.bert(input_ids=input_ids,token_type_ids=token_type_ids, attention_mask=attention_mask)
+        #获得预训练模型的输出
+        bert_cls_hidden_state = bert_output[1]
+        #将768维的向量输入到线性层映射为二维向量
+        linear_output = self.dense(bert_cls_hidden_state)
+        return  linear_output
+
+# %%
+
+def encoder(max_len,vocab_path,text_list):
+    #将text_list embedding成bert模型可用的输入形式
+    #加载分词模型
+    tokenizer = BertTokenizer.from_pretrained("bert-base-chinese")
+    tokenizer = tokenizer(
+        text_list,
+        padding = True,
+        truncation = True,
+        max_length = max_len,
+        return_tensors='pt'  # 返回的类型为pytorch tensor
+        )
+    input_ids = tokenizer['input_ids']
+    token_type_ids = tokenizer['token_type_ids']
+    attention_mask = tokenizer['attention_mask']
+    return input_ids,token_type_ids,attention_mask
+
+# %%
+labels2dict = {"neutral":0,"entailment":1,"contradiction":2}
+def load_data(path):
+    csvFileObj = open(path)
+    readerObj = csv.reader(csvFileObj)
+    text_list = []
+    labels = []
+    for row in readerObj:
+        #跳过表头
+        if readerObj.line_num == 1:
+            continue
+        #label在什么位置就改成对应的index
+        label = int(labels2dict[row[0]])
+        text = row[1]
+        text_list.append(text)
+        labels.append(label)
+    #调用encoder函数，获得预训练模型的三种输入形式
+    input_ids,token_type_ids,attention_mask = encoder(max_len=150,vocab_path="/root/Bert/bert-base-chinese/vocab.txt",text_list=text_list)
+    labels = torch.tensor(labels)
+    #将encoder的返回值以及label封装为Tensor的形式
+    data = TensorDataset(input_ids,token_type_ids,attention_mask,labels)
+    return data
+
+# %%
+#设定batch_size
+batch_size = 16
+#引入数据路径
+train_data_path="Bert_Try.csv"
+dev_data_path="Bert_Dev.csv"
+test_data_path="Bert_Test.csv"
+#调用load_data函数，将数据加载为Tensor形式
+train_data = load_data(train_data_path)
+dev_data = load_data(dev_data_path)
+test_data = load_data(test_data_path)
+#将训练数据和测试数据进行DataLoader实例化
+train_loader = DataLoader(dataset=train_data, batch_size=batch_size, shuffle=True)
+dev_loader = DataLoader(dataset=dev_data, batch_size=batch_size, shuffle=True)
+test_loader = DataLoader(dataset=test_data, batch_size=batch_size, shuffle=False)
+
+# %%
+def dev(model,dev_loader):
+    model.to(device)
+
+    model.eval()
+
+    with torch.no_grad():
+        correct = 0
+        total = 0
+        for step, (input_ids,token_type_ids,attention_mask,labels) in tqdm(enumerate(dev_loader),desc='Dev Itreation:'):                
+            input_ids,token_type_ids,attention_mask,labels=input_ids.to(device),token_type_ids.to(device),attention_mask.to(device),labels.to(device)
+            out_put = model(input_ids,token_type_ids,attention_mask)
+            _, predict = torch.max(out_put.data, 1)
+            correct += (predict==labels).sum().item()
+            total += labels.size(0)
+        res = correct / total
+    return res
+
+# %%
+
+device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
+def train(model,train_loader,dev_loader) :
+
+    model.to(device)
+    model.train()
+    criterion = nn.CrossEntropyLoss()
+    param_optimizer = list(model.named_parameters())
+    no_decay = ['bias', 'LayerNorm.bias', 'LayerNorm.weight']
+
+    optimizer_grouped_parameters = [
+        {'params': [p for n, p in param_optimizer if not any(nd in n for nd in no_decay)],
+         'weight_decay': 0.01},
+        {'params': [p for n, p in param_optimizer if any(nd in n for nd in no_decay)], 'weight_decay': 0.0}
+    ]
+
+    optimizer_params = {'lr': 1e-5, 'eps': 1e-6, 'correct_bias': False}
+    optimizer = AdamW(optimizer_grouped_parameters, **optimizer_params)
+    scheduler = ReduceLROnPlateau(optimizer,mode='max',factor=0.5,min_lr=1e-7, patience=5,verbose= True, threshold=0.0001, eps=1e-08)
+    t_total = len(train_loader)
+
+    total_epochs = 10
+    bestAcc = 0
+    correct = 0
+    total = 0
+    print('Training and verification begin!')
+    for epoch in range(total_epochs): 
+        for step, (input_ids,token_type_ids,attention_mask,labels) in enumerate(train_loader):
+
+            optimizer.zero_grad()
+            input_ids,token_type_ids,attention_mask,labels=input_ids.to(device),token_type_ids.to(device),attention_mask.to(device),labels.to(device)
+            out_put =  model(input_ids,token_type_ids,attention_mask)
+            loss = criterion(out_put, labels)
+            _, predict = torch.max(out_put.data, 1)
+            correct += (predict == labels).sum().item()
+            total += labels.size(0)
+            loss.backward()
+            optimizer.step()
+             #每两步进行一次打印
+            if (step + 1) % 10 == 0:
+                train_acc = correct / total
+                print("Train Epoch[{}/{}],step[{}/{}],tra_acc{:.6f} %,loss:{:.6f}".format(epoch + 1, total_epochs, step + 1, len(train_loader),train_acc*100,loss.item()))
+            #每五十次进行一次验证
+            if (step + 1) % 200 == 0:
+                train_acc = correct / total
+                #调用验证函数dev对模型进行验证，并将有效果提升的模型进行保存
+                acc = dev(model, dev_loader)
+                if bestAcc < acc:
+                    bestAcc = acc
+                    #模型保存路径
+                    path = 'bert_model.pkl'
+                    torch.save(model, path)
+                print("DEV Epoch[{}/{}],step[{}/{}],tra_acc{:.6f} %,bestAcc{:.6f}%,dev_acc{:.6f} %,loss:{:.6f}".format(epoch + 1, total_epochs, step + 1, len(train_loader),train_acc*100,bestAcc*100,acc*100,loss.item()))
+        scheduler.step(bestAcc)
+
+# %%
+
+path = '/kaggle/input/inference/bert_model.pkl'
+# model = torch.load(path)
+#实例化模型
+model = BertClassificationModel()
+#调用训练函数进行训练与验证
+train(model,train_loader,dev_loader)

util.py

@@ -8,18 +8,20 @@ import time
 
 @backoff.on_exception(backoff.expo, requests.exceptions.RequestException)
 def post_url(url, headers, payload):
-    time.sleep(0.3)
+    time.sleep(1)
     response = requests.request("POST", url, headers=headers, data=payload)
     return response
 
 
 def seg(text):
-    sentences = re.split(r'(?<=[。！？])\s*', text)
+    text = text.replace('\n', " ")
+    sentences = re.split(r'(?<=[。！？.!?:])\s*', text)
+    sentences  = [string for string in sentences if string != '']
     return sentences
 
 
 def clean_text(text):
-    text = text.replace('\n', " ")
+    text = text.replace('\n', "")
     text = re.sub(r"-", " ", text)
     text = re.sub(r"\d+/\d+/\d+", "", text)  # 日期
     text = re.sub(r"[0-2]?[0-9]:[0-6][0-9]", "", text)  # 时间
@@ -73,6 +75,11 @@ def generation(para, max_length):
         response = post_url(url, headers, payload)
         text_dict = json.loads(response.text)
         # print(text_dict)
+        while('summary' not in text_dict.keys()):
+            response = post_url(url, headers, payload)
+            text_dict = json.loads(response.text)
+            print("ReTrying")
+
         topic[text_dict['summary']] = (j, k)
         Ai_abstract.append(text_dict['summary'])
     return topic,Ai_abstract