GLM-4-9B-Chat-1M自动化批量处理长文本文件的脚本编写1. 引言当长文本处理遇上自动化想象一下这个场景你手头有几十份PDF格式的年度报告每份都超过100页老板让你在一天内整理出所有报告的核心观点和风险提示。或者你负责的代码仓库有上千个文件需要快速理解整个项目的架构和关键逻辑。手动处理光是想想就让人头皮发麻。这正是GLM-4-9B-Chat-1M大显身手的地方。这个模型最厉害的能力就是能一口气“吃下”长达100万字的文本然后帮你分析、总结、问答。但问题来了——如果每次都要手动复制粘贴、等待模型处理、再整理结果效率还是太低。今天我要分享的就是如何用Python脚本把GLM-4-9B-Chat-1M变成你的“自动化长文本处理工厂”。通过编写简单的脚本你可以让模型批量处理成百上千个文件自动生成报告把原本需要几天的工作压缩到几小时内完成。2. 为什么需要批量处理脚本在深入代码之前我们先聊聊为什么脚本化如此重要。GLM-4-9B-Chat-1M虽然强大但它的Web界面更适合交互式使用。当你面对大量文件时手动操作会面临几个痛点效率瓶颈假设你有50个文档每个文档处理需要3分钟包括上传、等待、复制结果总共就需要150分钟。这还不算中间可能出现的网络问题、操作失误等。一致性难以保证手动操作时你可能会用不同的提示词、忘记保存某些结果或者处理顺序混乱导致最终的报告格式不统一。无法规模化当文件数量从50个增加到500个时手动处理就完全不现实了。而脚本可以轻松应对这种规模的增长。集成困难手动处理的结果很难直接集成到其他工作流中比如自动生成数据库记录、触发后续处理流程等。脚本化解决了这些问题。它让GLM-4-9B-Chat-1M从一个“智能助手”升级为“自动化流水线”真正释放了百万上下文能力的价值。3. 环境准备与基础脚本框架3.1 准备工作在开始编写脚本前你需要确保几件事GLM-4-9B-Chat-1M已经部署并运行模型应该在本地运行可以通过API访问。默认情况下Streamlit应用会在http://localhost:8080提供服务。安装必要的Python库除了模型运行所需的环境你还需要安装处理文件的库。pip install requests python-dotenv tqdmrequests用于发送HTTP请求到模型APIpython-dotenv管理环境变量比如API密钥如果需要tqdm显示处理进度条让长时间运行的任务有反馈准备测试文件创建一些示例文本文件放在一个文件夹里比如documents/目录下。3.2 最基础的批量处理脚本我们先从一个最简单的脚本开始感受一下自动化处理的流程。这个脚本会读取指定文件夹中的所有文本文件然后逐个发送给模型处理。import os import requests import glob from tqdm import tqdm class GLMBatchProcessor: def __init__(self, base_urlhttp://localhost:8080): 初始化批量处理器 :param base_url: GLM模型服务的地址 self.base_url base_url self.api_endpoint f{base_url}/api/chat # 假设这是聊天API端点 def process_single_file(self, file_path, prompt_template): 处理单个文件 :param file_path: 文件路径 :param prompt_template: 提示词模板 :return: 处理结果 try: # 读取文件内容 with open(file_path, r, encodingutf-8) as f: content f.read() # 构建完整的提示词 full_prompt prompt_template.format(contentcontent) # 准备请求数据 payload { messages: [ {role: user, content: full_prompt} ], max_tokens: 1000, temperature: 0.7 } # 发送请求到GLM模型 response requests.post(self.api_endpoint, jsonpayload) response.raise_for_status() # 检查请求是否成功 # 解析响应 result response.json() return result.get(choices, [{}])[0].get(message, {}).get(content, ) except Exception as e: print(f处理文件 {file_path} 时出错: {str(e)}) return None def process_folder(self, folder_path, prompt_template, output_dirresults): 处理整个文件夹的文件 :param folder_path: 文件夹路径 :param prompt_template: 提示词模板 :param output_dir: 输出目录 # 确保输出目录存在 os.makedirs(output_dir, exist_okTrue) # 获取所有文本文件 text_files glob.glob(os.path.join(folder_path, *.txt)) print(f找到 {len(text_files)} 个文本文件) # 使用进度条显示处理进度 for file_path in tqdm(text_files, desc处理文件中): # 获取文件名不含扩展名 file_name os.path.splitext(os.path.basename(file_path))[0] # 处理文件 result self.process_single_file(file_path, prompt_template) if result: # 保存结果 output_path os.path.join(output_dir, f{file_name}_result.txt) with open(output_path, w, encodingutf-8) as f: f.write(result) print(f✓ 已处理: {file_name}) else: print(f✗ 处理失败: {file_name}) # 使用示例 if __name__ __main__: # 创建处理器实例 processor GLMBatchProcessor() # 定义提示词模板 prompt_template 请分析以下文本内容并总结出核心观点 {content} 请用简洁的语言总结不超过300字。 # 处理文件夹中的所有文件 processor.process_folder( folder_pathdocuments, # 你的文档文件夹 prompt_templateprompt_template, output_diranalysis_results )这个基础脚本虽然简单但已经具备了批量处理的核心功能。它展示了自动化处理的基本流程读取文件、构建提示词、调用模型API、保存结果。4. 高级功能让脚本更智能实用基础脚本能工作但还不够好用。在实际工作中我们需要处理各种复杂情况。下面我分享几个让脚本更实用的高级功能。4.1 支持多种文件格式现实中的文档很少是纯文本格式。我们需要让脚本能处理PDF、Word、Excel等常见格式。import PyPDF2 from docx import Document import pandas as pd class MultiFormatProcessor(GLMBatchProcessor): def __init__(self, base_urlhttp://localhost:8080): super().__init__(base_url) def extract_text_from_pdf(self, pdf_path): 从PDF提取文本 text try: with open(pdf_path, rb) as file: reader PyPDF2.PdfReader(file) for page_num in range(len(reader.pages)): page reader.pages[page_num] text page.extract_text() \n except Exception as e: print(f读取PDF文件 {pdf_path} 失败: {e}) return text def extract_text_from_docx(self, docx_path): 从Word文档提取文本 text try: doc Document(docx_path) for paragraph in doc.paragraphs: text paragraph.text \n except Exception as e: print(f读取Word文件 {docx_path} 失败: {e}) return text def extract_text_from_excel(self, excel_path, sheet_nameNone): 从Excel提取文本读取所有单元格 text try: df pd.read_excel(excel_path, sheet_namesheet_name) # 将DataFrame转换为文本 text df.to_string(indexFalse) except Exception as e: print(f读取Excel文件 {excel_path} 失败: {e}) return text def process_any_file(self, file_path, prompt_template): 智能识别文件类型并提取文本 # 根据文件扩展名选择提取方法 file_ext os.path.splitext(file_path)[1].lower() if file_ext .pdf: content self.extract_text_from_pdf(file_path) elif file_ext .docx: content self.extract_text_from_docx(file_path) elif file_ext in [.xlsx, .xls]: content self.extract_text_from_excel(file_path) elif file_ext .txt: with open(file_path, r, encodingutf-8) as f: content f.read() else: print(f不支持的文件格式: {file_ext}) return None if not content.strip(): print(f文件 {file_path} 内容为空) return None # 使用父类的方法处理文本 return super().process_single_file_with_content(content, prompt_template, file_path) def process_single_file_with_content(self, content, prompt_template, file_path): 直接处理文本内容供子类调用 try: full_prompt prompt_template.format(contentcontent) payload { messages: [ {role: user, content: full_prompt} ], max_tokens: 1000, temperature: 0.7 } response requests.post(self.api_endpoint, jsonpayload) response.raise_for_status() result response.json() return result.get(choices, [{}])[0].get(message, {}).get(content, ) except Exception as e: print(f处理文件 {file_path} 时出错: {str(e)}) return None4.2 智能分块处理超长文档GLM-4-9B-Chat-1M支持100万tokens但有时候我们可能遇到更长的文档或者想更精细地控制处理粒度。这时候需要分块处理。class ChunkProcessor(MultiFormatProcessor): def __init__(self, base_urlhttp://localhost:8080, chunk_size50000): :param chunk_size: 每个块的最大字符数 super().__init__(base_url) self.chunk_size chunk_size def split_into_chunks(self, text, overlap1000): 将长文本分割成块保留重叠部分确保上下文连贯 :param overlap: 块之间的重叠字符数避免在句子中间切断 chunks [] start 0 while start len(text): # 计算块的结束位置 end start self.chunk_size # 如果结束位置不在文本末尾尝试在句号处分割 if end len(text): # 查找最近的句号 period_pos text.rfind(。, start, end) if period_pos ! -1 and period_pos start self.chunk_size * 0.5: end period_pos 1 # 包含句号 chunk text[start:end] chunks.append(chunk) # 移动起始位置考虑重叠 start end - overlap if end - overlap start else end # 防止无限循环 if start len(text): break return chunks def process_long_document(self, file_path, prompt_template, summary_promptNone): 处理超长文档先分块处理再整体总结 # 提取文本 content self.extract_text_from_file(file_path) if not content: return None print(f文档长度: {len(content)} 字符) # 如果文档不长直接处理 if len(content) self.chunk_size: return self.process_single_file_with_content(content, prompt_template, file_path) # 分块处理 chunks self.split_into_chunks(content) print(f分割成 {len(chunks)} 个块) chunk_results [] for i, chunk in enumerate(tqdm(chunks, desc处理文档块)): # 处理每个块 chunk_prompt f这是文档的第{i1}部分共{len(chunks)}部分 {chunk} 请分析这部分内容的主要信息。 result self.process_single_file_with_content(chunk, chunk_prompt, f{file_path}_chunk_{i1}) if result: chunk_results.append(result) # 如果有多个块进行整体总结 if len(chunk_results) 1: all_summaries \n\n.join([f第{i1}部分总结{summary} for i, summary in enumerate(chunk_results)]) if summary_prompt is None: summary_prompt 以下是长文档各个部分的分析结果 {summaries} 请基于以上各部分的分析给出整个文档的完整总结。 突出文档的核心主题、关键论点和重要发现。 final_prompt summary_prompt.format(summariesall_summaries) final_result self.process_single_file_with_content(all_summaries, final_prompt, f{file_path}_final) # 保存分块结果和最终结果 output_dir chunked_results os.makedirs(output_dir, exist_okTrue) base_name os.path.splitext(os.path.basename(file_path))[0] # 保存分块结果 for i, result in enumerate(chunk_results): with open(os.path.join(output_dir, f{base_name}_chunk_{i1}.txt), w, encodingutf-8) as f: f.write(result) # 保存最终总结 if final_result: with open(os.path.join(output_dir, f{base_name}_final_summary.txt), w, encodingutf-8) as f: f.write(final_result) return final_result return \n.join(chunk_results) if chunk_results else None def extract_text_from_file(self, file_path): 统一提取文本的方法 file_ext os.path.splitext(file_path)[1].lower() if file_ext .pdf: return self.extract_text_from_pdf(file_path) elif file_ext .docx: return self.extract_text_from_docx(file_path) elif file_ext in [.xlsx, .xls]: return self.extract_text_from_excel(file_path) elif file_ext .txt: with open(file_path, r, encodingutf-8) as f: return f.read() else: print(f不支持的文件格式: {file_ext}) return None4.3 结果后处理与格式化模型返回的结果可能需要进一步处理比如提取关键信息、格式化输出、生成报告等。import json from datetime import datetime class ResultPostProcessor: staticmethod def extract_key_points(text, max_points5): 从文本中提取关键点 prompt f请从以下文本中提取{max_points}个最关键的点 {text} 请用简洁的要点形式列出每个要点不超过一句话。 # 这里可以调用GLM模型或者使用简单的规则提取 # 为了示例我们假设调用模型 return text # 实际应用中这里应该是模型返回的结果 staticmethod def generate_report(results_dict, templatedefault): 生成汇总报告 report [] report.append(# 文档分析报告) report.append(f生成时间: {datetime.now().strftime(%Y-%m-%d %H:%M:%S)}) report.append(f分析文件数: {len(results_dict)}) report.append() for filename, content in results_dict.items(): report.append(f## {filename}) report.append() report.append(content) report.append(---) report.append() return \n.join(report) staticmethod def save_as_json(results_dict, output_path): 保存为JSON格式 data { metadata: { generated_at: datetime.now().isoformat(), total_files: len(results_dict) }, results: results_dict } with open(output_path, w, encodingutf-8) as f: json.dump(data, f, ensure_asciiFalse, indent2) staticmethod def save_as_markdown(results_dict, output_path): 保存为Markdown格式 report ResultPostProcessor.generate_report(results_dict) with open(output_path, w, encodingutf-8) as f: f.write(report)5. 完整实战构建企业文档分析流水线现在我们把所有功能组合起来构建一个完整的企业文档分析系统。这个系统可以自动处理各种格式的文档生成统一格式的分析报告。import yaml import logging from concurrent.futures import ThreadPoolExecutor, as_completed class EnterpriseDocAnalyzer: def __init__(self, config_pathconfig.yaml): 企业级文档分析器 :param config_path: 配置文件路径 # 加载配置 with open(config_path, r, encodingutf-8) as f: self.config yaml.safe_load(f) # 初始化组件 self.processor ChunkProcessor( base_urlself.config.get(glm_api_url, http://localhost:8080), chunk_sizeself.config.get(chunk_size, 50000) ) self.post_processor ResultPostProcessor() # 设置日志 logging.basicConfig( levellogging.INFO, format%(asctime)s - %(levelname)s - %(message)s, handlers[ logging.FileHandler(doc_analysis.log), logging.StreamHandler() ] ) self.logger logging.getLogger(__name__) def load_prompt_templates(self): 加载提示词模板 templates { summary: self.config.get(prompts, {}).get(summary, 请总结以下文档的核心内容\n\n{content}\n\n总结要求突出关键信息不超过300字。), qa: self.config.get(prompts, {}).get(qa, 基于以下文档内容\n\n{content}\n\n请回答这个问题{question}), extract_facts: self.config.get(prompts, {}).get(extract_facts, 从以下文本中提取关键事实和数据\n\n{content}\n\n以列表形式呈现。), risk_analysis: self.config.get(prompts, {}).get(risk_analysis, 分析以下文档中的风险点\n\n{content}\n\n列出主要风险和建议措施。) } return templates def process_with_template(self, file_path, template_type, **kwargs): 使用指定模板处理文件 templates self.load_prompt_templates() if template_type not in templates: self.logger.error(f未知的模板类型: {template_type}) return None prompt_template templates[template_type] # 如果有额外参数格式化提示词 if kwargs: prompt prompt_template.format(content{content}, **kwargs) else: prompt prompt_template return self.processor.process_long_document(file_path, prompt) def batch_process_with_threading(self, file_list, template_typesummary, max_workers3): 使用多线程批量处理文件 :param max_workers: 最大并发数根据你的硬件调整 results {} with ThreadPoolExecutor(max_workersmax_workers) as executor: # 提交所有任务 future_to_file { executor.submit(self.process_with_template, file_path, template_type): file_path for file_path in file_list } # 收集结果 for future in tqdm(as_completed(future_to_file), totallen(file_list), desc批量处理): file_path future_to_file[future] try: result future.result(timeout300) # 5分钟超时 if result: filename os.path.basename(file_path) results[filename] result self.logger.info(f成功处理: {filename}) else: self.logger.warning(f处理失败: {file_path}) except Exception as e: self.logger.error(f处理 {file_path} 时发生异常: {str(e)}) return results def run_analysis_pipeline(self, input_dir, output_formatall): 运行完整的分析流水线 self.logger.info(f开始分析目录: {input_dir}) # 收集所有支持的文件 supported_extensions [.txt, .pdf, .docx, .xlsx, .xls] file_list [] for ext in supported_extensions: file_list.extend(glob.glob(os.path.join(input_dir, f*{ext}))) self.logger.info(f找到 {len(file_list)} 个文件) if not file_list: self.logger.warning(没有找到可处理的文件) return # 批量处理 results self.batch_process_with_threading( file_list, template_typeself.config.get(default_template, summary), max_workersself.config.get(max_workers, 3) ) # 后处理 timestamp datetime.now().strftime(%Y%m%d_%H%M%S) output_dir fanalysis_output_{timestamp} os.makedirs(output_dir, exist_okTrue) # 保存结果 if output_format in [json, all]: json_path os.path.join(output_dir, analysis_results.json) self.post_processor.save_as_json(results, json_path) self.logger.info(fJSON报告已保存: {json_path}) if output_format in [markdown, all]: md_path os.path.join(output_dir, analysis_report.md) self.post_processor.save_as_markdown(results, md_path) self.logger.info(fMarkdown报告已保存: {md_path}) # 生成摘要 if results: all_content \n\n.join(results.values()) summary_prompt self.config.get(prompts, {}).get(overall_summary, 以下是多个文档的分析结果汇总\n\n{content}\n\n请给出整体性的洞察和发现。) overall_summary self.processor.process_single_file_with_content( all_content, summary_prompt.format(contentall_content), overall_summary ) if overall_summary: summary_path os.path.join(output_dir, overall_summary.txt) with open(summary_path, w, encodingutf-8) as f: f.write(overall_summary) self.logger.info(f整体摘要已保存: {summary_path}) self.logger.info(f分析完成结果保存在: {output_dir}) return output_dir # 配置文件示例 (config.yaml) glm_api_url: http://localhost:8080 chunk_size: 50000 max_workers: 3 default_template: summary prompts: summary: | 请分析以下文档内容 {content} 请总结 1. 核心主题和目的 2. 关键发现或结论 3. 主要建议或行动计划 4. 潜在风险或问题 总结请控制在500字以内。 qa: | 文档内容 {content} 问题{question} 请基于文档内容回答上述问题。 extract_facts: | 从以下文本中提取关键事实、数据和统计信息 {content} 请以清晰的列表形式呈现。 risk_analysis: | 分析以下文档中的风险因素 {content} 请列出 1. 已识别的风险 2. 风险等级评估高/中/低 3. 缓解建议 overall_summary: | 以下是多个相关文档的分析结果 {content} 请综合分析找出 1. 共同的主题和趋势 2. 矛盾或不一致之处 3. 整体性的洞察和建议 # 使用示例 if __name__ __main__: # 创建分析器 analyzer EnterpriseDocAnalyzer(config.yaml) # 运行完整流水线 output_dir analyzer.run_analysis_pipeline( input_dir企业文档, # 你的文档目录 output_formatall # 生成所有格式的报告 ) print(f分析完成结果保存在: {output_dir})6. 实用技巧与最佳实践在实际使用中有几个技巧能让你的批量处理脚本更加稳定高效6.1 错误处理与重试机制网络请求可能会失败模型可能暂时不可用。良好的错误处理能让脚本更健壮。import time from tenacity import retry, stop_after_attempt, wait_exponential class RobustProcessor(GLMBatchProcessor): retry(stopstop_after_attempt(3), waitwait_exponential(multiplier1, min4, max10)) def process_with_retry(self, file_path, prompt_template): 带重试机制的处理方法 try: return self.process_single_file(file_path, prompt_template) except requests.exceptions.RequestException as e: self.logger.warning(f请求失败准备重试: {str(e)}) raise # 触发重试 except Exception as e: self.logger.error(f处理失败且不可重试: {str(e)}) return None def safe_process_folder(self, folder_path, prompt_template, output_dirresults): 安全的文件夹处理方法 # 创建输出目录 os.makedirs(output_dir, exist_okTrue) # 创建检查点文件记录处理进度 checkpoint_file os.path.join(output_dir, .checkpoint) processed_files set() # 加载已处理的文件 if os.path.exists(checkpoint_file): with open(checkpoint_file, r, encodingutf-8) as f: processed_files set(f.read().splitlines()) # 获取所有文件 all_files glob.glob(os.path.join(folder_path, *.txt)) files_to_process [f for f in all_files if f not in processed_files] print(f找到 {len(all_files)} 个文件其中 {len(files_to_process)} 个待处理) for file_path in tqdm(files_to_process, desc处理文件中): try: result self.process_with_retry(file_path, prompt_template) if result: # 保存结果 file_name os.path.splitext(os.path.basename(file_path))[0] output_path os.path.join(output_dir, f{file_name}_result.txt) with open(output_path, w, encodingutf-8) as f: f.write(result) # 更新检查点 processed_files.add(file_path) with open(checkpoint_file, a, encodingutf-8) as f: f.write(file_path \n) self.logger.info(f成功处理: {file_name}) else: self.logger.error(f处理失败: {file_path}) except Exception as e: self.logger.error(f处理 {file_path} 时发生严重错误: {str(e)}) # 可以选择跳过或停止 continue print(f处理完成成功处理 {len(processed_files)}/{len(all_files)} 个文件)6.2 性能优化建议处理大量文件时性能很重要。这里有几个优化建议合理设置并发数根据你的硬件配置调整max_workers。通常CPU核心数的2-3倍是个不错的起点。批量发送请求如果模型API支持批量处理可以一次发送多个请求。缓存处理结果对于相同的文件可以缓存处理结果避免重复计算。增量处理使用检查点机制支持从上次中断的地方继续处理。资源监控监控内存和显存使用避免资源耗尽。import psutil import threading class ResourceAwareProcessor(RobustProcessor): def __init__(self, base_urlhttp://localhost:8080, memory_threshold0.9): super().__init__(base_url) self.memory_threshold memory_threshold # 内存使用阈值 self._stop_event threading.Event() def monitor_resources(self): 监控资源使用 while not self._stop_event.is_set(): memory_percent psutil.virtual_memory().percent / 100 if memory_percent self.memory_threshold: self.logger.warning(f内存使用过高: {memory_percent:.1%}暂停处理) time.sleep(10) # 暂停10秒 else: time.sleep(5) # 每5秒检查一次 def process_with_resource_monitor(self, folder_path, prompt_template, output_dirresults): 带资源监控的处理 # 启动资源监控线程 monitor_thread threading.Thread(targetself.monitor_resources, daemonTrue) monitor_thread.start() try: result self.safe_process_folder(folder_path, prompt_template, output_dir) return result finally: self._stop_event.set() monitor_thread.join(timeout5)6.3 定制化提示词模板不同的任务需要不同的提示词。你可以创建专门的提示词模板库class PromptTemplateManager: def __init__(self, templates_dirprompt_templates): self.templates_dir templates_dir os.makedirs(templates_dir, exist_okTrue) def load_template(self, template_name): 加载模板 template_path os.path.join(self.templates_dir, f{template_name}.txt) if os.path.exists(template_path): with open(template_path, r, encodingutf-8) as f: return f.read() else: # 返回默认模板 return self.get_default_template(template_name) def get_default_template(self, template_type): 获取默认模板 templates { summary: 请总结以下内容的核心要点 {content} 总结要求 1. 用简洁的语言概括主要内容 2. 突出关键信息和结论 3. 列出重要的数据或事实 4. 总结控制在300字以内, qa: 基于以下文本 {content} 请回答{question} 回答要求 1. 基于文本内容不要编造信息 2. 如果文本中没有相关信息请说明 3. 回答要具体、准确, extract_entities: 从以下文本中提取实体信息 {content} 请提取 1. 人名 2. 组织机构 3. 地点 4. 时间 5. 关键数字 以JSON格式输出。, sentiment_analysis: 分析以下文本的情感倾向 {content} 请判断 1. 整体情感倾向正面/负面/中性 2. 情感强度1-5分5分最强 3. 主要情感关键词 4. 简要分析原因 } return templates.get(template_type, templates[summary]) def save_template(self, template_name, content): 保存模板 template_path os.path.join(self.templates_dir, f{template_name}.txt) with open(template_path, w, encodingutf-8) as f: f.write(content) print(f模板已保存: {template_path})7. 总结通过本文的脚本编写指南你已经掌握了如何将GLM-4-9B-Chat-1M的强大能力转化为自动化处理流水线。让我们回顾一下关键要点批量处理的核心价值在于将重复性工作自动化。无论是处理几十份报告还是分析整个代码库脚本都能帮你节省大量时间同时保证处理质量的一致性。脚本的进阶功能让处理更加智能。支持多种文件格式、智能分块处理、结果后处理等功能让脚本能够应对真实世界的复杂需求。企业级流水线展示了如何将各个组件组合成完整的解决方案。通过配置文件管理、多线程处理、错误恢复机制等你可以构建出稳定可靠的生产级系统。实用技巧帮助你优化脚本性能。错误重试、资源监控、提示词管理等技巧能让你的脚本更加健壮和高效。最重要的是这些脚本都是可扩展的起点。你可以根据自己的需求添加新功能比如集成到现有工作流、添加Web界面、支持更多文件格式等。GLM-4-9B-Chat-1M的百万上下文能力加上自动化脚本的处理效率让你能够轻松应对海量文本分析任务。无论是学术研究、商业分析还是技术文档处理这套组合都能显著提升你的工作效率。现在你可以根据自己的具体需求调整和扩展这些脚本打造属于你自己的智能文档处理系统。从简单的批量总结开始逐步添加更多高级功能你会发现自动化处理带来的效率提升是惊人的。获取更多AI镜像想探索更多AI镜像和应用场景访问 CSDN星图镜像广场提供丰富的预置镜像覆盖大模型推理、图像生成、视频生成、模型微调等多个领域支持一键部署。