Python-翻译服务器

可以根据需求禁用相应功能来降低资源

`app.py`
```python
# 下列是所需环境(≥ Python3.8)
# flask
# gevent
# transformers
# sentencepiece
# torch

# 下载的模型会存在：
# C:\Users\<用户名>\.cache\huggingface\hub

# 导入 Flask 框架和相关模块
from flask import Flask, request, render_template, jsonify
# 导入 transformers 库中的 MarianTokenizer 和 MarianMTModel
from transformers import MarianTokenizer, MarianMTModel
# 导入 gevent 中的 pywsgi
from gevent import pywsgi
# 导入 Python 内置的 concurrent.futures 库，用于并行处理
import concurrent.futures

# 创建 Flask 应用程序实例
app = Flask(__name__)

# 读取配置文件中的模型信息，将模型名称和模型路径存储在字典 models 中
# 配置文件中每行为一组模型，以模型名称和模型地址为两个字段，中间用空格分隔
print("读取模型列表...")
with open('templates\models.txt', 'r') as f:
    model_config = f.read().strip().split('\n')
    models = {model.split()[0]: model.split()[1] for model in model_config}

# 创建空字典，用于存储预加载的模型
print("预先加载所有模型...")
loaded_models = {}
# 遍历所有模型，通过 MarianTokenizer 和 MarianMTModel 预加载模型，将它们作为键值对存储在 loaded_models 中
for model_name, model_path in models.items():
    loaded_models[model_name] = (MarianTokenizer.from_pretrained(model_path), MarianMTModel.from_pretrained(model_path))
print("加载完成...")

# 定义一个函数，用于翻译文本。接收两个参数，分别是待翻译的文本和使用的模型名称
def translate_text(text, model_name):
    # 从 loaded_models 中获取指定模型的 tokenizer 和 model。
    tokenizer, model = loaded_models[model_name]
    # 通过添加前缀将翻译任务传递给模型,有的模型不需要
    input_text = text
    # 使用 tokenizer 对文本进行编码，生成输入的 tensor
    input_ids = tokenizer.encode(input_text, return_tensors="pt")
    # 使用 model 对编码后的 tensor 进行翻译，生成输出的 tensor
    outputs = model.generate(input_ids=input_ids, max_length=1024)
    # 将输出的 tensor 解码成文本，跳过特殊标记
    decoded_output = tokenizer.decode(outputs[0], skip_special_tokens=True)
    # 手动释放 input_ids 和 outputs 占用的内存
    del input_ids, outputs
    # 返回翻译结果
    return decoded_output

# 定义 Flask 应用程序的根路由
@app.route('/')
# 定义 home 函数，用于渲染模板
def home():
    return render_template('index.html', default_text="请输入待翻译内容",model_list=models.keys())

# 定义 Flask 应用程序的翻译路由，限定请求方法为 POST
@app.route('/translate', methods=['POST'])
# 定义 translate 函数，用于接收 POST 请求，解析请求体中的参数，调用 translate_text 函数进行翻译，并将翻译结果渲染到模板中
def translate():
    text = request.form['text']
    model_name = request.form['model']
    # 不使用线程池方式
    # translated_text = translate_text(text, model_name)
    with concurrent.futures.ThreadPoolExecutor() as executor:
        # 将需要翻译的文本 text 和模型名称 model_name 提交给线程池中的一个空闲线程，并返回一个 Future 对象，表示异步任务的未来结果
        future = executor.submit(translate_text, text, model_name)
        # 调用 Future 对象的 result 方法，阻塞当前线程，直到异步任务完成并返回结果
        # 这里等价于直接调用 translate_text(text, model_name)，但使用线程池的方式可以提高翻译请求的并发性能
        translated_text = future.result()
    return render_template('index.html', default_text=text, translated_text=translated_text, model_list=models.keys())

# 定义 Flask 应用程序的 API 翻译路由，限定请求方法为 POST
@app.route('/api', methods=['POST'])
# 定义 api_translate 函数，用于接收 POST 请求，解析请求体中的参数，使用并行处理的方式调用 translate_text 函数进行翻译，并返回翻译结果
def api_translate():
    text = request.get_json()['text']
    model_name = request.get_json()['model']
    if model_name not in models:
        return "找不到模型:" + model_name, 404
    # 使用 ThreadPoolExecutor 创建线程池，最大并发数量默认为 CPU 核心数
    with concurrent.futures.ThreadPoolExecutor() as executor:
        # 将需要翻译的文本 text 和模型名称 model_name 提交给线程池中的一个空闲线程，并返回一个 Future 对象，表示异步任务的未来结果
        future = executor.submit(translate_text, text, model_name)
        # 调用 Future 对象的 result 方法，阻塞当前线程，直到异步任务完成并返回结果
        # 这里等价于直接调用 translate_text(text, model_name)，但使用线程池的方式可以提高翻译请求的并发性能
        translated_text = future.result()
    # 返回翻译结果
    return translated_text

# 判断当前文件是否作为脚本被执行
print("启动服务...")
print("Web访问：http://localhost:5005\nApi访问：http://localhost:5005/api...")
if __name__ == '__main__':
    server = pywsgi.WSGIServer(('0.0.0.0', 5005), app)
    server.serve_forever()
```

`templates\models.txt`，翻译模型(简称 模型地址)
```bash
en2zh Helsinki-NLP/opus-mt-en-zh
zh2en Helsinki-NLP/opus-mt-zh-en
```

`templates\index.html`，web主页
```html
<!DOCTYPE html>
<html>
<head>
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <style>
    /* 设置全局样式 */
    * {
      box-sizing: border-box;
      font-family: Arial, sans-serif;
    }

/* 设置页面标题样式 */
    h1 {
      text-align: center;
      font-size: 36px;
      margin-bottom: 20px;
    }

/* 设置表单样式 */
    form {
      max-width: 600px;
      margin: 0 auto;
      display: flex;
      flex-direction: column;
      align-items: center;
      justify-content: center;
    }

/* 设置文本框样式 */
    textarea {
      width: 100%;
      padding: 10px;
      margin-bottom: 20px;
      border-radius: 10px;
      border: none;
      resize: none;
    }

/* 设置选择框样式 */
    select {
      padding: 10px;
      margin-bottom: 20px;
      border-radius: 10px;
      border: none;
      background-color: #f5f5f5;
    }

/* 设置按钮样式 */
    input[type="submit"] {
      background-color: #4CAF50;
      color: white;
      padding: 10px 20px;
      border-radius: 10px;
      border: none;
      cursor: pointer;
      transition: background-color 0.3s;
    }

input[type="submit"]:hover {
      background-color: #3e8e41;
    }

/* 设置翻译结果样式 */
    hr {
      margin-top: 50px;
      margin-bottom: 20px;
      border: none;
      border-top: 2px solid #f5f5f5;
    }

h3 {
      font-size: 24px;
      margin-bottom: 20px;
    }

p {
      font-size: 18px;
      line-height: 1.5;
    }

/* 设置响应式样式 */
    @media only screen and (max-width: 600px) {
      form {
        max-width: 100%;
        padding: 20px;
      }
    }
  </style>
</head>

<body>
    <h1>ZWZW翻译</h1>
    <form method="POST" action="/translate">
        <label for="text">输入待翻译内容:</label><br>
        <textarea id="text" name="text" rows="4" cols="50">{{ default_text }}</textarea><br>
        <label for="model">选择翻译:</label>
        <select name="model" id="model">
            <option value="zh2en">中文 ——> English</option>
            <option value="en2zh">English ——> 中文</option>
        </select><br><br>
        <input type="submit" value="Translate">
    </form>
    {% if translated_text %}
        <hr>
        <h3>翻译结果:</h3>
        <p>{{ translated_text }}</p>
    {% endif %}
</body>
</html>
```

## 其他大佬程序
```python
# 下列是所需环境(≥ Python3.8)
# flask
# gevent
# transformers
# sentencepiece
# torch

# 下载的模型会存在：
# C:\Users\<用户名>\.cache\huggingface\hub

# 离线翻译服务代码
# 导入必要的库
from flask import Flask, request
from gevent import pywsgi
import warnings
warnings.filterwarnings('ignore')
from transformers import (
    T5Tokenizer,
    MT5ForConditionalGeneration,
    Text2TextGenerationPipeline,
)

# 打印正在加载翻译模型的信息
print('正在加载翻译模型... ...')

# 加载模型
path = 'K024/mt5-zh-ja-en-trimmed' # 模型路径
pipe = Text2TextGenerationPipeline(
    model=MT5ForConditionalGeneration.from_pretrained(path), # 加载预训练模型
    tokenizer=T5Tokenizer.from_pretrained(path), # 加载对应的分词器
)

# 初始化 Flask 应用
app = Flask(__name__)

# 定义接口
@app.route('/wesky-translater', methods=['POST'])
def translate():
    mod = request.form['mod'] # 获取请求参数 mod
    text = request.form['text'] # 获取请求参数 text
    # 根据不同的 mod 参数，进行相应的翻译
    if mod == 'zh2en':
        result = pipe("zh2en:" + text, max_length=10240, num_beams=4)[0]['generated_text'] # 中文翻译为英文
        return result
    elif mod == 'en2zh':
        result = pipe("en2zh:" + text, max_length=10240, num_beams=4)[0]['generated_text'] # 英文翻译为中文
        return result
    elif mod == 'ja2zh':
        result = pipe("ja2zh:" + text, max_length=10240, num_beams=4)[0]['generated_text'] # 日文翻译为中文
        return result
    elif mod == 'zh2ja':
        result = pipe("zh2ja:" + text, max_length=10240, num_beams=4)[0]['generated_text'] # 中文翻译为日文
        return result

# 打印翻译服务已启动的信息
print('翻译服务已启动，请通过api形式访问该服务地址：http://ip:16888/wesky-translater')

# 启动服务
server = pywsgi.WSGIServer(('0.0.0.0', 16888), app)
server.serve_forever()

# nuitka --standalone --show-memory --show-progress --nofollow-import-to=transformers,email,numpy,torch,gevent,flask,urlib3,http,requests  --output-dir=out  translation.py
```