# 同步更新自manga-image-translator import logging import re import time from typing import List, Dict, Union, Callable import time import os import json import openai from .base import BaseTranslator, register_translator OPENAPI_V1_API = int(openai.__version__.split('.')[0]) >= 1 class InvalidNumTranslations(Exception): pass class SakuraDict(): """ Sakura字典类，用于加载和管理Sakura字典。 属性: -------- logger : logging.Logger 日志记录器对象 dict_str : str 字典内容字符串 version : str Sakura字典版本号 path : str 字典文件路径 方法: -------- __init__(self, path: str, logger: logging.Logger, version: str = "0.9") -> None: 初始化Sakura字典对象。 load_dict(self, dic_path: str) -> None: 根据字典类型加载字典。 get_dict_str(self) -> str: 获取字典内容字符串。 save_dict_to_file(self, dic_path: str, dict_type: str = "sakura") -> None: 将字典内容保存到文件。 """ def __init__(self, path: str, logger: logging.Logger, version: str = "0.9") -> None: """ 初始化Sakura字典对象。 参数: -------- path : str 字典文件路径 logger : logging.Logger 日志记录器对象 version : str, optional Sakura字典版本号，默认为"0.9" """ self.logger = logger self.dict_str = "" self.version = version self.path = path if not path: return # 如果路径为空，直接返回，不加载字典 if not os.path.exists(path): if self.version != "0.9": self.logger.info(f"字典文件不存在: {path}\n 如果您不需要字典功能，请忽略此警告。") return if self.version == "1.0": try: self.load_dict(path) except Exception as e: self.logger.warning(f"载入字典失败: {e}") elif self.version == "0.9": pass else: self.logger.info("您当前选择了Sakura 0.9版本，暂不支持术语表") def load_dict(self, dic_path: str) -> None: """ 根据字典类型加载字典。 参数: -------- dic_path : str 字典文件路径 """ if self.version == "0.9" or not dic_path: return dic_type = self._detect_type(dic_path) if dic_type == "galtransl": self._load_galtransl_dic(dic_path) elif dic_type == "sakura": self._load_sakura_dict(dic_path) elif dic_type == "json": self._load_json_dict(dic_path) else: self.logger.warning(f"未知的字典类型: {dic_path}") self.logger.debug(f"字典内容（转换后）: {self.dict_str[:100]}") def _load_galtransl_dic(self, dic_path: str) -> None: """ 加载Galtransl格式的字典。 参数: -------- dic_path : str 字典文件路径 """ if self.version == "0.9": return with open(dic_path, encoding="utf8") as f: dic_lines = f.readlines() if not dic_lines: return dic_name = os.path.basename(dic_path) gpt_dict = [] for line in dic_lines: if line.startswith(("\n", "\\\\", "//")): continue line = line.replace(" ", "\t") sp = line.rstrip("\r\n").split("\t") if len(sp) < 2: continue src, dst, *info = sp gpt_dict.append( {"src": src, "dst": dst, "info": info[0] if info else None}) gpt_dict_text_list = [ f"{gpt['src']}->{gpt['dst']}{' #' + gpt['info'] if gpt['info'] else ''}" for gpt in gpt_dict] self.dict_str = "\n".join(gpt_dict_text_list) self.logger.info(f"载入 Galtransl 字典: {dic_name} {len(gpt_dict)}普通词条") def _load_sakura_dict(self, dic_path: str) -> None: """ 加载Sakura格式的字典。 参数: -------- dic_path : str 字典文件路径 """ if self.version == "0.9": return with open(dic_path, encoding="utf8") as f: dic_lines = f.readlines() if not dic_lines: return dic_name = os.path.basename(dic_path) gpt_dict_text_list = [] for line in dic_lines: if line.startswith(("\n", "\\\\", "//")): continue sp = line.rstrip("\r\n").split("->") if len(sp) < 2: continue src, dst_info = sp dst_info_sp = dst_info.split("#") dst = dst_info_sp[0].strip() info = dst_info_sp[1].strip() if len(dst_info_sp) > 1 else None gpt_dict_text_list.append( f"{src}->{dst}{' #' + info if info else ''}") self.dict_str = "\n".join(gpt_dict_text_list) self.logger.info( f"载入标准Sakura字典: {dic_name} {len(gpt_dict_text_list)}普通词条") def _load_json_dict(self, dic_path: str) -> None: """ 加载JSON格式的字典。 参数: -------- dic_path : str 字典文件路径 """ if self.version == "0.9": return with open(dic_path, encoding="utf8") as f: dic_json = json.load(f) if not dic_json: return dic_name = os.path.basename(dic_path) gpt_dict_text_list = [] for item in dic_json: if not item: continue src = item.get("src", "") dst = item.get("dst", "") info = item.get("info", "") gpt_dict_text_list.append( f"{src}->{dst}{' #' + info if info else ''}") self.dict_str = "\n".join(gpt_dict_text_list) self.logger.info(f"载入JSON字典: {dic_name} {len(gpt_dict_text_list)}条记录") def _detect_type(self, dic_path: str) -> str: """ 检测字典文件的类型。 参数: -------- dic_path : str 字典文件路径 返回: -------- str 字典类型，可能的值有"galtransl"、"sakura"、"json"和"unknown" """ if self.version == "0.9": return "unknown" with open(dic_path, encoding="utf8") as f: dic_lines = f.readlines() self.logger.debug(f"检测字典类型: {dic_path}") if not dic_lines: return "unknown" if dic_path.endswith(".json"): return "json" for line in dic_lines: if line.startswith(("\n", "\\\\", "//")): continue if "\t" in line or " " in line: return "galtransl" elif "->" in line: return "sakura" return "unknown" def get_dict_str(self) -> str: """ 获取字典内容字符串。 返回: -------- str 字典内容字符串 """ if self.version == "0.9" or not self.path: return "" if not self.dict_str: try: self.load_dict(self.path) except Exception as e: self.logger.warning(f"载入字典失败: {e}") return self.dict_str def get_dict_str_within_text(self, text: str, force_apply_dict: bool = False) -> str: """ 获取字典内容字符串，仅保留字典中出现的词条。 参数: -------- text : str 待翻译文本 返回: -------- str 字典内容字符串 """ if force_apply_dict: return self.get_dict_str() if self.version == "0.9" or not self.path: return "" if not self.dict_str: try: self.load_dict(self.path) except Exception as e: self.logger.warning(f"载入字典失败: {e}") return "" # 初始化一个空列表用于存储匹配的字典行 matched_dict_lines = [] # 遍历字典中的每一行 for line in self.dict_str.splitlines(): if '->' in line: src = line.split('->')[0] # 检查 src 是否在输入文本中 # self.logger.debug(f"检查字典原文{src}是否在文本{text}中") if src in text: # self.logger.debug(f"匹配到字典行: {line}") matched_dict_lines.append(line) # 将匹配的字典行拼接成一个字符串并返回 return '\n'.join(matched_dict_lines) def dict_to_json(self) -> str: """ 将字典内容转换为JSON格式。 返回: -------- str 字典内容的JSON格式字符串 """ if self.version == "0.9" or not self.path: return "" if not self.dict_str: try: self.load_dict(self.path) except Exception as e: self.logger.warning(f"载入字典失败: {e}") dict_json = [] for line in self.dict_str.split("\n"): if not line: continue sp = line.split("->") if len(sp) < 2: continue src, dst_info = sp dst_info_sp = dst_info.split("#") dst = dst_info_sp[0].strip() info = dst_info_sp[1].strip() if len(dst_info_sp) > 1 else None dict_json.append({"src": src, "dst": dst, "info": info}) return json.dumps(dict_json, ensure_ascii=False, indent=4) def save_dict_to_file(self, dic_path: str, dict_type: str = "sakura") -> None: """ 将字典内容保存到文件。 参数: -------- dic_path : str 字典文件保存路径 dict_type : str, optional 字典类型，可选值有"sakura"、"galtransl"和"json"，默认为"sakura" """ if self.version == "0.9" or not self.path: return if dict_type == "sakura": with open(dic_path, "w", encoding="utf8") as f: f.write(self.dict_str) elif dict_type == "galtransl": with open(dic_path, "w", encoding="utf8") as f: f.write(self.dict_str.replace( "->", " ").replace(" #", " ")) elif dict_type == "json": json_data = self.dict_to_json() with open(dic_path, "w", encoding="utf8") as f: json.dump(json_data, f, ensure_ascii=False, indent=4) else: self.logger.warning(f"未知的字典类型: {dict_type}") @register_translator('Sakura') class SakuraTranslator(BaseTranslator): concate_text = False cht_require_convert = True params: Dict = { 'low vram mode': { 'value': True, 'description': 'check it if you\'re running it locally on a single device and encountered a crash due to vram OOM', 'type': 'checkbox', }, 'api baseurl': 'http://127.0.0.1:8080/v1', 'dict path': '', 'version': { 'type': 'selector', 'options': [ '0.9', '1.0', 'galtransl-v1' ], 'value': '0.9' }, 'retry attempts': 3, 'timeout': 999, 'max tokens': 1024, 'repeat detect threshold': 20, 'force apply dict': { 'value': False, 'description': 'Force apply the dictionary regardless of whether the terms appear in the original text \n DO NOT CHECK THIS IF YOU ARE NOT SURE WHAT IT MEANS', 'type': 'checkbox', }, 'do enlarge small kana': { 'value': False, 'description': 'Enlarge small kana to normal size', 'type': 'checkbox', } } _CHAT_SYSTEM_TEMPLATE_009 = ( '你是一个轻小说翻译模型，可以流畅通顺地以日本轻小说的风格将日文翻译成简体中文，并联系上下文正确使用人称代词，不擅自添加原文中没有的代词。' ) _CHAT_SYSTEM_TEMPLATE_100 = ( '你是一个轻小说翻译模型，可以流畅通顺地以日本轻小说的风格将日文翻译成简体中文，并联系上下文正确使用人称代词，不擅自添加原文中没有的代词。' ) _CHAT_SYSTEM_TEMPLATE_GALTRANSL_V1 = ( '你是一个视觉小说翻译模型，可以通顺地使用给定的术语表以指定的风格将日文翻译成简体中文，并联系上下文正确使用人称代词，注意不要混淆使役态和被动态的主语和宾语，不要擅自添加原文中没有的代词，也不要擅自增加或减少换行。' ) @property def timeout(self) -> int: return self.params['timeout'] @property def retry_attempts(self) -> int: return self.params['retry attempts'] @property def repeat_detect_threshold(self) -> int: return self.params['repeat detect threshold'] @property def max_tokens(self) -> int: return self.params['max tokens'] @property def api_base_raw(self) -> str: return self.params['api baseurl'] @property def api_base(self) -> str: url = self.api_base_raw if url.endswith('/'): url = url[:-1] if not url.endswith('/v1'): url += '/v1' return url @property def sakura_version(self) -> str: return self.params['version']['value'] @property def dict_path(self) -> str: return self.params['dict path'] @property def force_apply_dict(self) -> bool: return self.params['force apply dict']['value'] @property def do_enlarge_small_kana(self) -> bool: return self.params['do enlarge small kana']['value'] def _setup_translator(self): self.lang_map['简体中文'] = 'Simplified Chinese' self.lang_map['日本語'] = 'Japanese' self.temperature = 0.1 self.top_p = 0.3 self.frequency_penalty = 0.05 self._current_style = "precise" self._emoji_pattern = re.compile(r'[\U00010000-\U0010ffff]') self._heart_pattern = re.compile(r'❤') sakura_version = self.sakura_version if self.sakura_version!= 'galtransl-v1' else '1.0' self.sakura_dict = SakuraDict( self.dict_path, self.logger, sakura_version) self.logger.info(f'当前选择的Sakura版本: {self.sakura_version}') def updateParam(self, param_key: str, param_content): super().updateParam(param_key, param_content) if param_key == 'dict path' or param_key == 'version': self.set_dict_path(self.params['dict path']) def set_dict_path(self, path: str): self.params['dict path'] = path self.sakura_dict = SakuraDict(path, self.logger, self.sakura_version) self.logger.debug(f'更新Sakura字典路径为: {path}') @staticmethod def enlarge_small_kana(text, ignore=''): """将小写平假名或片假名转换为普通大小 参数 ---------- text : str 全角平假名或片假名字符串。 ignore : str, 可选 转换时要忽略的字符。 返回 ------ str 平假名或片假名字符串，小写假名已转换为大写 示例 -------- >>> print(enlarge_small_kana('さくらきょうこ')) さくらきようこ >>> print(enlarge_small_kana('キュゥべえ')) キユウべえ """ SMALL_KANA = list('ぁぃぅぇぉゃゅょっァィゥェォヵヶャュョッ') SMALL_KANA_NORMALIZED = list('あいうえおやゆよつアイウエオカケヤユヨツ') SMALL_KANA2BIG_KANA = dict( zip(map(ord, SMALL_KANA), SMALL_KANA_NORMALIZED)) def _exclude_ignorechar(ignore, conv_map): for character in map(ord, ignore): del conv_map[character] return conv_map def _convert(text, conv_map): return text.translate(conv_map) def _translate(text, ignore, conv_map): if ignore: _conv_map = _exclude_ignorechar(ignore, conv_map.copy()) return _convert(text, _conv_map) return _convert(text, conv_map) return _translate(text, ignore, SMALL_KANA2BIG_KANA) def detect_and_calculate_repeats(self, s: str, threshold: int = 20, remove_all=True) -> Union[bool, str, int, str, int]: """ 检测文本中是否存在重复模式,并计算重复次数。 返回值: (是否重复, 去除重复后的文本, 重复次数, 重复模式, 实际阈值) """ # 初始化标记重复模式的变量 repeated = False longest_pattern = '' # 存储最长的重复模式 longest_count = 0 # 存储最长模式的重复次数 counts = [] # 存储所有找到的重复次数 # 遍历所有可能的模式长度，从1到字符串长度的一半 for pattern_length in range(1, len(s) // 2 + 1): # 构建正则表达式模式，匹配指定长度的重复模式 pattern = re.compile(r'(.{%d})\1+' % pattern_length) # 查找所有匹配的重复模式 for match in re.finditer(pattern, s): current_pattern = match.group(1) # 当前找到的重复模式 current_count = len(match.group(0)) // pattern_length # 计算重复次数 counts.append(current_count) # 将当前模式的重复次数添加到 counts 列表 # 如果当前模式的重复次数达到或超过阈值 if current_count >= threshold: self.logger.warning(f"检测到重复模式: {current_pattern}，重复次数: {current_count}") repeated = True # 标记检测到重复模式 # 如果当前模式的重复次数大于最长的重复次数 if current_count > longest_count: longest_count = current_count # 更新最长的重复次数 longest_pattern = current_pattern # 更新最长的重复模式 # 如果需要移除所有重复模式 if remove_all: s = s[:match.start()] + s[match.end():] # 从字符串中移除重复模式 break # 跳出当前循环，检查下一个模式长度 if repeated: break # 如果已经检测到重复模式，跳出外层循环 # 计算实际阈值，取默认阈值和所有找到的重复次数的最大众数中的最大值 actual_threshold = max(threshold, max(counts, default=0)) # 返回检测结果，包括是否重复、去除重复后的文本、重复次数、重复模式和实际阈值 return repeated, s, longest_count, longest_pattern, actual_threshold def _format_prompt_log(self, prompt: str) -> str: gpt_dict_raw_text = self.sakura_dict.get_dict_str_within_text(prompt, self.force_apply_dict) prompt_009 = '\n'.join([ 'System:', self._CHAT_SYSTEM_TEMPLATE_009, 'User:', '将下面的日文文本翻译成中文：', prompt, ]) prompt_100 = '\n'.join([ 'System:', self._CHAT_SYSTEM_TEMPLATE_100, 'User:', "根据以下术语表（可以为空）：", gpt_dict_raw_text, "将下面的日文文本根据对应关系和备注翻译成中文：", prompt, ]) prompt_galtransl_v1 = '\n'.join([ 'System:', self._CHAT_SYSTEM_TEMPLATE_GALTRANSL_V1, 'User:', "根据以下术语表：", gpt_dict_raw_text, "将下面的日文文本根据上述术语表的对应关系和注释翻译成中文：", prompt, ]) if self.sakura_version == '0.9': return prompt_009 elif self.sakura_version == '1.0': return prompt_100 else: return prompt_galtransl_v1 def _split_text(self, text: str) -> List[str]: """ 将字符串按换行符分割为列表。 """ if isinstance(text, list): return text return text.split('\n') def _preprocess_queries(self, queries: List[str]) -> List[str]: """ 预处理查询文本,去除emoji,替换特殊字符,并添加「」标记。 """ if self.do_enlarge_small_kana: queries = [self.enlarge_small_kana(query) for query in queries] queries = [self._emoji_pattern.sub('', query) for query in queries] queries = [self._heart_pattern.sub('♥', query) for query in queries] queries = [f'「{query}」' for query in queries] self.logger.debug(f'预处理后的查询文本：{queries}') return queries def _check_translation_quality(self, queries: List[str], response: str) -> List[str]: """ 检查翻译结果的质量,包括重复和行数对齐问题,如果存在问题则尝试重新翻译或返回原始文本。 """ def _retry_translation(queries: List[str], check_func: Callable[[str], bool], error_message: str) -> str: styles = ["precise", "normal", "aggressive", ] for i in range(self.retry_attempts): self._set_gpt_style(styles[i]) self.logger.warning( f'{error_message} 尝试次数: {i + 1}。当前参数风格：{self._current_style}。') response = self._handle_translation_request(queries) if not check_func(response): return response return None # 检查请求内容是否含有超过默认阈值的重复内容 if self.detect_and_calculate_repeats(''.join(queries), self.repeat_detect_threshold)[0]: self.logger.warning( f'请求内容本身含有超过默认阈值{self.repeat_detect_threshold}的重复内容。') # 根据译文众数和默认阈值计算实际阈值 actual_threshold = max(max(self.detect_and_calculate_repeats( query)[4] for query in queries), self.repeat_detect_threshold) if self.detect_and_calculate_repeats(response, actual_threshold)[0]: response = _retry_translation(queries, lambda r: self.detect_and_calculate_repeats( r, actual_threshold)[0], f'检测到大量重复内容（当前阈值：{actual_threshold}），疑似模型退化，重新翻译。') if response is None: self.logger.warning( f'疑似模型退化，尝试{self.retry_attempts}次仍未解决，进行单行翻译。') return self._translate_single_lines(queries) if not self.check_align(queries, response): response = _retry_translation(queries, lambda r: not self.check_align( queries, r), '因为检测到原文与译文行数不匹配，重新翻译。') if response is None: self.logger.warning( f'原文与译文行数不匹配，尝试{self.retry_attempts}次仍未解决，进行单行翻译。') return self._translate_single_lines(queries) return self._split_text(response) def _translate_single_lines(self, queries: List[str]) -> List[str]: """ 逐行翻译查询文本。 """ translations = [] for query in queries: response = self._handle_translation_request(query) if self.detect_and_calculate_repeats(response)[0]: self.logger.warning(f"单行翻译结果存在重复内容: {response}，返回原文。") translations.append(query) else: translations.append(response) return translations def check_align(self, queries: List[str], response: str) -> bool: """ 检查原始文本和翻译结果的行数是否对齐。 """ translations = self._split_text(response) is_aligned = len(queries) == len(translations) if not is_aligned: self.logger.warning( f"行数不匹配 - 原文行数: {len(queries)}，译文行数： {len(translations)}") return is_aligned def _delete_quotation_mark(self, texts: List[str]) -> List[str]: """ 删除文本中的「」标记。 """ new_texts = [] for text in texts: text = text.strip('「」') new_texts.append(text) return new_texts def _translate(self, src_list) -> List[str]: self.logger.debug( f'Temperature: {self.temperature}, TopP: {self.top_p}') self.logger.debug(f'原文： {src_list}') text_prompt = '\n'.join(src_list) self.logger.debug('-- Sakura Prompt --\n' + self._format_prompt_log(text_prompt) + '\n\n') # 预处理查询文本 queries = self._preprocess_queries(src_list) # 发送翻译请求 response = self._handle_translation_request(queries) self.logger.debug('-- Sakura Response --\n' + response + '\n\n') # 检查翻译结果是否存在重复或行数不匹配的问题 translations = self._check_translation_quality(queries, response) return self._delete_quotation_mark(translations) def _handle_translation_request(self, prompt): ratelimit_attempt = 0 server_error_attempt = 0 timeout_attempt = 0 while True: if OPENAPI_V1_API: try: response = self._request_translation(prompt) break except openai.RateLimitError: ratelimit_attempt += 1 if ratelimit_attempt >= self.retry_attempts: raise self.logger.warning( f'Sakura因被限速而进行重试。尝试次数： {ratelimit_attempt}') time.sleep(2) except openai.APIError as e: server_error_attempt += 1 if server_error_attempt >= self.retry_attempts: self.logger.warning(e) self.logger.warning('Sakura翻译失败。返回原始文本。') return '\n'.join(prompt) self.logger.warning( f'Sakura因服务器错误而进行重试。 当前API baseurl为"{self.api_base}"，尝试次数： {server_error_attempt}, 错误信息： {e}') time.sleep(1) except FileNotFoundError: self.logger.warning( 'Sakura因文件不存在而进行重试。') time.sleep(30) except TimeoutError: timeout_attempt += 1 if timeout_attempt >= self.retry_attempts: raise Exception('Sakura超时。') self.logger.warning( f'Sakura因超时而进行重试。尝试次数： {timeout_attempt}') else: try: response = self._request_translation(prompt) break except openai.error.RateLimitError: ratelimit_attempt += 1 if ratelimit_attempt >= self.retry_attempts: raise self.logger.warning( f'Sakura因被限速而进行重试。尝试次数： {ratelimit_attempt}') time.sleep(2) except openai.error.APIError as e: server_error_attempt += 1 if server_error_attempt >= self.retry_attempts: self.logger.warning( e, 'Sakura翻译失败。返回原始文本。') return '\n'.join(prompt) self.logger.warning( f'Sakura因服务器错误而进行重试，请检查Sakura是否已经启动，API baseurl是否正确，并关闭一切代理软件后重试。\n 当前API baseurl为"{self.api_base}"，尝试次数： {server_error_attempt}, 错误信息： {e}') time.sleep(1) except openai.error.APIConnectionError as e: server_error_attempt += 1 if server_error_attempt >= self.retry_attempts: self.logger.warning( e, 'Sakura翻译失败。返回原始文本。') return '\n'.join(prompt) self.logger.warning( f'Sakura因服务器连接错误而进行重试，请检查Sakura是否已经启动，API baseurl是否正确，并关闭一切代理软件后重试。\n 当前API baseurl为"{self.api_base}"，尝试次数： {server_error_attempt}, 错误信息： {e}') time.sleep(1) except FileNotFoundError: self.logger.warning( 'Sakura因文件不存在而进行重试。') time.sleep(30) except TimeoutError: timeout_attempt += 1 if timeout_attempt >= self.retry_attempts: raise Exception('Sakura超时。') self.logger.warning( f'Sakura因超时而进行重试。尝试次数： {timeout_attempt}') return response def _request_translation(self, input_text_list): if isinstance(input_text_list, list): raw_text = "\n".join(input_text_list) else: raw_text = input_text_list extra_query = { 'do_sample': False, 'num_beams': 1, 'repetition_penalty': 1.0, } gpt_dict_raw_text = self.sakura_dict.get_dict_str_within_text(raw_text, self.force_apply_dict) if self.sakura_version == "0.9" or gpt_dict_raw_text == "": messages = [ { "role": "system", "content": f"{self._CHAT_SYSTEM_TEMPLATE_009}" }, { "role": "user", "content": f"将下面的日文文本翻译成中文：{raw_text}" } ] elif self.sakura_version == "1.0": messages = [ { "role": "system", "content": f"{self._CHAT_SYSTEM_TEMPLATE_100}" }, { "role": "user", "content": f"根据以下术语表（可以为空）：\n{gpt_dict_raw_text}\n将下面的日文文本根据对应关系和备注翻译成中文：{raw_text}" } ] else: messages = [ { "role": "system", "content": f"{self._CHAT_SYSTEM_TEMPLATE_GALTRANSL_V1}" }, { "role": "user", "content": f"根据以下术语表：\n{gpt_dict_raw_text}\n将下面的日文文本根据上述术语表的对应关系和注释翻译成中文：{raw_text}" } ] if OPENAPI_V1_API: client = openai.Client( api_key="sk-114514", base_url=self.api_base ) response = client.chat.completions.create( model="sukinishiro", messages=messages, temperature=self.temperature, top_p=self.top_p, max_tokens=self.max_tokens, frequency_penalty=self.frequency_penalty, seed=-1, extra_query=extra_query, ) else: openai.api_base = self.api_base openai.api_key = "sk-114514" response = openai.ChatCompletion.create( model="sukinishiro", messages=messages, temperature=self.temperature, top_p=self.top_p, max_tokens=self.max_tokens, frequency_penalty=self.frequency_penalty, seed=-1, extra_query=extra_query, ) for choice in response.choices: if OPENAPI_V1_API: return choice.message.content else: if 'text' in choice: return choice.text return response.choices[0].message.content def _set_gpt_style(self, style_name: str): """ 设置GPT的生成风格。 """ if self._current_style == style_name: return self._current_style = style_name if style_name == "precise": temperature, top_p = 0.1, 0.3 frequency_penalty = 0.05 elif style_name == "normal": temperature, top_p = 0.3, 0.3 frequency_penalty = 0.2 elif style_name == "aggressive": temperature, top_p = 0.3, 0.3 frequency_penalty = 0.3 self.temperature = temperature self.top_p = top_p self.frequency_penalty = frequency_penalty