Hugging Face + 百度翻译：零门槛解锁中文AI文生图

相比本地部署Hugging Face模型，需要强悍的硬件配置才能实现，Hugging Face Inference API方案具有以下核心优势： 1）零本地计算资源消耗：2）无需GPU显存支持开箱即用：3）省去模型下载和环境配置 4）弹性扩展：支持多种预训练模型快速切换（本文采用最新版Stable Diffusion XL1.0模型） 5）完全免费。

三、具体功能

1. 描述语言生成图像功能

1）建议使用英文描述

后文将介绍调用百度翻译API

2‌）优化提示词

结构化描述‌：分主体、环境、风格三部分，如：

A cyberpunk cat (主体) wearing neon goggles, standing on a floating holographic platform in a futuristic city (环境), trending on ArtStation, unreal engine 5 rendering (风格)

避免模糊描述，需明确主体、环境、细节。
✅ 正确示例："a realistic white cat with blue eyes, sitting on a red velvet cushion, golden hour lighting, soft shadows"
❌ 错误示例："a cat in a room"

‌关键词堆叠与分隔‌
用逗号分隔多关键词，增强模型理解。

关键词分类
1）质量词
高质量: masterpiece, high quality, best quality, ultra detailed
细节: detailed, intricate details, ultra high res
清晰度: sharp focus, 8k uhd, high resolution
2）风格词
写实风格: photorealistic, realistic, photograph
艺术风格: oil painting, watercolor, digital art
特定风格: anime style, comic style, concept art
3）光照词
自然光: natural lighting, sunlight, daylight
人工光: studio lighting, neon lights, dramatic lighting
氛围光: soft lighting, ambient light, rim light
4）构图词
视角: front view, side view, aerial view
景深: bokeh, depth of field, blur background
构图: rule of thirds, symmetrical, centered composition

提示词示例
1）人物肖像
A professional portrait of a young woman, photorealistic,
detailed facial features, soft natural lighting,
shallow depth of field, high-end fashion photography,
8k resolution, sharp focus
2）风景图片
A majestic mountain landscape at sunset,
ultra detailed, dramatic lighting,
wide angle shot, volumetric fog,
atmospheric perspective, cinematic composition,
high resolution, masterpiece
3 ）概念艺术
A futuristic cyberpunk city,
neon lights, rain-slicked streets,
detailed architecture, moody atmosphere,
cinematic lighting, rule of thirds composition,
concept art, ultra detailed

常用提示词模板
Text

# 基础模板
[质量词], [主体描述], [风格词], [环境词], [光照词], [其他细节]

# 高级模板
[质量词], [主体描述], [动作/姿势], [表情/情绪],
[服装/配饰], [环境/背景], [光照/氛围], [风格/媒介],
[视角/构图], [色彩/色调], [其他细节]

2. 分辨率选择功能

添加了三个预设分辨率选项：1920×1080、1280×720、800×600
使用单选按钮(Radiobutton)实现分辨率选择
在生成图片时应用所选分辨率

3. 保存功能

添加了保存按钮
支持选择保存位置和文件格式
自动生成带时间戳的文件名
添加保存成功提示

四、Python调用Hugging Face接口

1. 获取Hugging Face API令牌：

访问 https://huggingface.co/
注册并登录
在设置中创建新的API令牌

2. 新建一个.env文件

内容如下：HUGGINGFACE_API_TOKEN=你的HuggingFace_API令牌

将 .env 文件放在程序运行的当前目录下

3. 环境配置

pip install requests python-dotenv pillow

五、文生图完整代码

import tkinter as tk
from tkinter import ttk, scrolledtext, filedialog, messagebox
import requests
import json
import base64
from PIL import Image, ImageTk
from io import BytesIO
import os
from datetime import datetime
import threading
from dotenv import load_dotenv
import logging

# 配置日志
logging.basicConfig(level=logging.DEBUG,
                    format='%(asctime)s - %(levelname)s - %(message)s')


class ImageGeneratorApp:
    def __init__(self, root):
        self.root = root
        self.root.title("Hugging Face 图像生成器")
        self.root.geometry("1200x800")

        # 初始化变量
        self.generated_image = None
        self.api_token = None

        # 加载环境变量
        self.load_api_token()

        # 设置UI
        self.setup_ui()

    def load_api_token(self):
        """从.env文件加载API令牌"""
        try:
            load_dotenv()
            self.api_token = os.getenv('HUGGINGFACE_API_TOKEN')
            if not self.api_token:
                raise ValueError("未找到 HUGGINGFACE_API_TOKEN")
            logging.info("API token loaded successfully")
        except Exception as e:
            logging.error(f"Error loading API token: {str(e)}")
            messagebox.showerror("错误", f"加载API令牌失败: {str(e)}")

    def setup_ui(self):
        # 创建主框架
        main_frame = ttk.Frame(self.root, padding="10")
        main_frame.pack(fill=tk.BOTH, expand=True)

        # 左侧控制面板
        control_frame = ttk.Frame(main_frame)
        control_frame.pack(side=tk.LEFT, fill=tk.Y, padx=(0, 10))

        # 提示文本输入区
        prompt_frame = ttk.LabelFrame(control_frame, text="输入描述文字", padding="5")
        prompt_frame.pack(fill=tk.X, pady=(0, 10))

        self.prompt_text = scrolledtext.ScrolledText(prompt_frame, height=6, width=40)
        self.prompt_text.pack(fill=tk.X)

        # 分辨率选择区
        resolution_frame = ttk.LabelFrame(control_frame, text="选择分辨率", padding="5")
        resolution_frame.pack(fill=tk.X, pady=(0, 10))

        self.resolution_var = tk.StringVar(value="1280x720")
        resolutions = ["1920x1080", "1280x720", "800x600"]

        for res in resolutions:
            ttk.Radiobutton(resolution_frame, text=res, value=res,
                            variable=self.resolution_var).pack(anchor=tk.W)

        # 按钮区
        button_frame = ttk.Frame(control_frame)
        button_frame.pack(fill=tk.X, pady=10)

        self.generate_btn = ttk.Button(button_frame, text="生成图片",
                                       command=self.start_generation)
        self.generate_btn.pack(side=tk.LEFT, padx=5)

        self.save_btn = ttk.Button(button_frame, text="保存图片",
                                   command=self.save_image, state=tk.DISABLED)
        self.save_btn.pack(side=tk.LEFT, padx=5)

        # 状态标签
        self.status_label = ttk.Label(control_frame, text="准备就绪")
        self.status_label.pack(fill=tk.X, pady=5)

        # 右侧图片显示区
        self.image_frame = ttk.LabelFrame(main_frame, text="生成的图片")
        self.image_frame.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)

        self.image_label = ttk.Label(self.image_frame)
        self.image_label.pack(fill=tk.BOTH, expand=True, padx=5, pady=5)

    def start_generation(self):
        """在新线程中启动图片生成"""
        if not self.api_token:
            messagebox.showerror("错误", "API令牌未设置")
            return

        prompt = self.prompt_text.get("1.0", tk.END).strip()
        if not prompt:
            messagebox.showwarning("警告", "请输入描述文字！")
            return

        self.generate_btn.config(state=tk.DISABLED)
        self.status_label.config(text="正在生成图片...")

        # 在新线程中运行生成过程
        thread = threading.Thread(target=self.generate_image, args=(prompt,))
        thread.daemon = True
        thread.start()

    def generate_image(self, prompt):
        """使用Hugging Face API生成图片"""
        try:
            # 获取选择的分辨率
            width, height = map(int, self.resolution_var.get().split('x'))

            # API端点
            API_URL = "https://api-inference.huggingface.co/models/stabilityai/stable-diffusion-xl-base-1.0"

            # 设置请求头
            headers = {
                "Authorization": f"Bearer {self.api_token}",
                "Content-Type": "application/json"
            }

            # 准备请求数据
            payload = {
                "inputs": prompt,
                "parameters": {
                    "width": width,
                    "height": height
                }
            }

            # 发送请求
            logging.debug(f"Sending request to API with prompt: {prompt}")
            response = requests.post(API_URL, headers=headers, json=payload)

            if response.status_code != 200:
                raise ValueError(f"API请求失败: {response.status_code} - {response.text}")

            # 处理响应
            image_bytes = response.content
            image = Image.open(BytesIO(image_bytes))
            self.generated_image = image

            # 调整图片大小以适应显示区域
            display_image = image.copy()
            display_image.thumbnail((800, 800))  # 最大显示尺寸

            # 在主线程中更新UI
            self.root.after(0, self.update_image_display, display_image)

        except Exception as e:
            logging.error(f"Error generating image: {str(e)}")
            self.root.after(0, self.show_error, str(e))
        finally:
            self.root.after(0, lambda: self.generate_btn.config(state=tk.NORMAL))

    def update_image_display(self, display_image):
        """更新界面上的图片显示"""
        photo = ImageTk.PhotoImage(display_image)
        self.image_label.config(image=photo)
        self.image_label.image = photo  # 保持引用
        self.save_btn.config(state=tk.NORMAL)
        self.status_label.config(text="图片生成完成！")

    def save_image(self):
        """保存生成的图片"""
        if self.generated_image:
            # 生成默认文件名
            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
            default_filename = f"generated_image_{timestamp}.png"

            # 打开文件对话框
            file_path = filedialog.asksaveasfilename(
                defaultextension=".png",
                initialfile=default_filename,
                filetypes=[
                    ("PNG files", "*.png"),
                    ("JPEG files", "*.jpg"),
                    ("All files", "*.*")
                ]
            )

            if file_path:
                try:
                    self.generated_image.save(file_path)
                    self.status_label.config(text=f"图片已保存至: {file_path}")
                    messagebox.showinfo("成功", "图片保存成功！")
                except Exception as e:
                    error_msg = f"保存图片时出错: {str(e)}"
                    logging.error(error_msg)
                    messagebox.showerror("错误", error_msg)
        else:
            messagebox.showwarning("警告", "没有可保存的图片！")

    def show_error(self, error_message):
        """显示错误消息"""
        self.status_label.config(text=f"错误: {error_message}")
        messagebox.showerror("错误", error_message)


def main():
    try:
        root = tk.Tk()
        app = ImageGeneratorApp(root)
        root.mainloop()
    except Exception as e:
        logging.error(f"Application error: {str(e)}")
        messagebox.showerror("错误", str(e))


if __name__ == "__main__":
    main()

（二、百度翻译部分）

六、百度翻译效果图

当然可以直接用网页百度翻译，不过自己还是做了一个小程序，不想费工夫的可以跳过以下步骤。

七、创建百度翻译API

1. 访问 http://api.fanyi.baidu.com/
2. 注册账号并创建应用
3. 获取APPID和密钥
4. 将APPID和密钥填入代码中相应位置

八、主要功能

1. 文件菜单：导出功能
2. 主题菜单：切换主题
3. 历史菜单：查看和管理历史记录
4. 翻译功能：支持多种语言
5. 字体调整：可以改变显示大小
6. 数据存储：历史记录存储在 translator_history.db 文件中
导出的文件可以是 CSV 或 TXT 格式

九、环境配置

pip install requests langdetect

十、百度翻译完整代码

import tkinter as tk
from tkinter import ttk, scrolledtext, messagebox, filedialog
import requests
import random
import json
import hashlib
import langdetect
from datetime import datetime
import sqlite3
import csv


class TranslatorApp:
    def __init__(self, root):
        self.root = root
        self.root.title("多语言翻译器")
        self.root.geometry("1200x800")

        # 主题配置
        self.themes = {
            "浅色": {
                "bg": "#ecf0f1",
                "fg": "#2c3e50",
                "button": "#3498db",
                "text_bg": "white",
                "text_fg": "black"
            },
            "深色": {
                "bg": "#2c3e50",
                "fg": "#ecf0f1",
                "button": "#3498db",
                "text_bg": "#34495e",
                "text_fg": "#ffffff"
            }
        }
        self.current_theme = "浅色"

        # 初始化数据库
        self.init_database()

        # 其他初始化
        self.default_font_size = 12
        self.current_font_size = self.default_font_size
        self.appid = '你的id'
        self.secret_key = '你的key'

        # 设置UI
        self.setup_ui()
        self.apply_theme()

    def init_database(self):
        """初始化数据库"""
        self.conn = sqlite3.connect('../实用脚本/办公与多媒体/translator_history.db')
        self.cursor = self.conn.cursor()
        self.cursor.execute('''
            CREATE TABLE IF NOT EXISTS history (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                source_text TEXT,
                target_text TEXT,
                source_lang TEXT,
                target_lang TEXT,
                timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
            )
        ''')
        self.conn.commit()

    def setup_ui(self):
        """设置用户界面"""
        self.main_frame = ttk.Frame(self.root, padding="10")
        self.main_frame.grid(row=0, column=0, sticky=(tk.W, tk.E, tk.N, tk.S))

        # 创建菜单栏
        self.create_menu()

        # 创建控制面板
        self.create_control_panel()

        # 创建主要内容区域
        self.create_content_area()

        # 创建状态栏
        self.create_status_bar()

    def create_menu(self):
        """创建菜单栏"""
        menubar = tk.Menu(self.root)
        self.root.config(menu=menubar)

        # 文件菜单
        file_menu = tk.Menu(menubar, tearoff=0)
        menubar.add_cascade(label="文件", menu=file_menu)
        file_menu.add_command(label="导出翻译历史", command=self.export_history)
        file_menu.add_command(label="导出当前翻译", command=self.export_current)
        file_menu.add_separator()
        file_menu.add_command(label="退出", command=self.root.quit)

        # 主题菜单
        theme_menu = tk.Menu(menubar, tearoff=0)
        menubar.add_cascade(label="主题", menu=theme_menu)
        for theme in self.themes:
            theme_menu.add_command(
                label=theme,
                command=lambda t=theme: self.change_theme(t)
            )

        # 历史记录菜单
        history_menu = tk.Menu(menubar, tearoff=0)
        menubar.add_cascade(label="历史", menu=history_menu)
        history_menu.add_command(label="显示历史记录", command=self.show_history)
        history_menu.add_command(label="清除历史记录", command=self.clear_history)

    def create_control_panel(self):
        """创建控制面板"""
        control_frame = ttk.Frame(self.main_frame)
        control_frame.grid(row=0, column=0, columnspan=3, sticky=(tk.W, tk.E), pady=10)

        # 语言选择
        self.languages = {
            '自动检测': 'auto',
            '中文': 'zh',
            '英语': 'en',
            '日语': 'jp',
            '韩语': 'kor',
            '法语': 'fra',
            '西班牙语': 'spa',
            '俄语': 'ru'
        }

        # 源语言选择
        ttk.Label(control_frame, text="源语言:").pack(side=tk.LEFT, padx=5)
        self.source_lang = ttk.Combobox(control_frame, values=list(self.languages.keys()), width=10)
        self.source_lang.pack(side=tk.LEFT, padx=5)
        self.source_lang.set('自动检测')

        # 目标语言选择
        ttk.Label(control_frame, text="目标语言:").pack(side=tk.LEFT, padx=5)
        self.target_lang = ttk.Combobox(control_frame, values=list(self.languages.keys()), width=10)
        self.target_lang.pack(side=tk.LEFT, padx=5)
        self.target_lang.set('英语')

        # 字体大小选择
        ttk.Label(control_frame, text="字体大小:").pack(side=tk.LEFT, padx=5)
        self.font_size_var = tk.StringVar(value=str(self.default_font_size))
        self.font_size_combo = ttk.Combobox(control_frame, textvariable=self.font_size_var,
                                            values=[str(i) for i in range(8, 25, 2)], width=5)
        self.font_size_combo.pack(side=tk.LEFT, padx=5)
        self.font_size_combo.bind('<<ComboboxSelected>>', self.change_font_size)

    def create_content_area(self):
        """创建主要内容区域"""
        # 源文本区域
        source_frame = ttk.LabelFrame(self.main_frame, text="输入文本")
        source_frame.grid(row=1, column=0, sticky=(tk.W, tk.E, tk.N, tk.S), padx=5, pady=5)

        self.source_text = scrolledtext.ScrolledText(
            source_frame,
            wrap=tk.WORD,
            width=40,
            height=15,
            font=('Arial', self.current_font_size)
        )
        self.source_text.pack(expand=True, fill='both', padx=5, pady=5)

        # 按钮区域
        button_frame = ttk.Frame(self.main_frame)
        button_frame.grid(row=1, column=1, sticky=(tk.N, tk.S))

        ttk.Button(button_frame, text="翻译 →", command=self.translate).pack(pady=5)
        ttk.Button(button_frame, text="清除 ⌫", command=self.clear_text).pack(pady=5)
        ttk.Button(button_frame, text="复制 ⎘", command=self.copy_to_clipboard).pack(pady=5)

        # 目标文本区域
        target_frame = ttk.LabelFrame(self.main_frame, text="翻译结果")
        target_frame.grid(row=1, column=2, sticky=(tk.W, tk.E, tk.N, tk.S), padx=5, pady=5)

        self.target_text = scrolledtext.ScrolledText(
            target_frame,
            wrap=tk.WORD,
            width=40,
            height=15,
            font=('Arial', self.current_font_size)
        )
        self.target_text.pack(expand=True, fill='both', padx=5, pady=5)

    def create_status_bar(self):
        """创建状态栏"""
        self.status_var = tk.StringVar()
        status_bar = ttk.Label(self.main_frame, textvariable=self.status_var)
        status_bar.grid(row=2, column=0, columnspan=3, sticky=(tk.W, tk.E))

    def change_theme(self, theme_name):
        """切换主题"""
        self.current_theme = theme_name
        self.apply_theme()

    def apply_theme(self):
        """应用主题"""
        theme = self.themes[self.current_theme]

        self.root.configure(bg=theme["bg"])
        self.main_frame.configure(style='Custom.TFrame')

        style = ttk.Style()
        style.configure('Custom.TFrame', background=theme["bg"])
        style.configure('Custom.TLabel', background=theme["bg"], foreground=theme["fg"])
        style.configure('Custom.TButton', background=theme["button"])

        # 更新文本框颜色
        self.source_text.configure(bg=theme["text_bg"], fg=theme["text_fg"])
        self.target_text.configure(bg=theme["text_bg"], fg=theme["text_fg"])

    def save_to_history(self, source_text, target_text):
        """保存翻译历史"""
        self.cursor.execute('''
            INSERT INTO history (source_text, target_text, source_lang, target_lang)
            VALUES (?, ?, ?, ?)
        ''', (source_text, target_text, self.source_lang.get(), self.target_lang.get()))
        self.conn.commit()

    def show_history(self):
        """显示历史记录"""
        history_window = tk.Toplevel(self.root)
        history_window.title("翻译历史")
        history_window.geometry("800x600")

        # 创建树形视图
        columns = ('时间', '源语言', '目标语言', '源文本', '翻译结果')
        tree = ttk.Treeview(history_window, columns=columns, show='headings')

        # 设置列标题
        for col in columns:
            tree.heading(col, text=col)
            tree.column(col, width=150)

        # 获取历史记录
        self.cursor.execute('''
            SELECT timestamp, source_lang, target_lang, source_text, target_text
            FROM history ORDER BY timestamp DESC
        ''')

        # 插入数据
        for row in self.cursor.fetchall():
            tree.insert('', 'end', values=row)

        # 添加滚动条
        scrollbar = ttk.Scrollbar(history_window, orient=tk.VERTICAL, command=tree.yview)
        tree.configure(yscrollcommand=scrollbar.set)

        # 布局
        tree.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
        scrollbar.pack(side=tk.RIGHT, fill=tk.Y)

    def clear_history(self):
        """清除历史记录"""
        if messagebox.askyesno("确认", "确定要清除所有历史记录吗？"):
            self.cursor.execute("DELETE FROM history")
            self.conn.commit()
            self.status_var.set("历史记录已清除")

    def export_history(self):
        """导出历史记录"""
        file_path = filedialog.asksaveasfilename(
            defaultextension=".csv",
            filetypes=[("CSV files", "*.csv"), ("All files", "*.*")]
        )

        if file_path:
            self.cursor.execute('''
                SELECT timestamp, source_lang, target_lang, source_text, target_text
                FROM history ORDER BY timestamp DESC
            ''')

            with open(file_path, 'w', newline='', encoding='utf-8') as file:
                writer = csv.writer(file)
                writer.writerow(['时间', '源语言', '目标语言', '源文本', '翻译结果'])
                writer.writerows(self.cursor.fetchall())

            self.status_var.set(f"历史记录已导出到: {file_path}")

    def export_current(self):
        """导出当前翻译"""
        file_path = filedialog.asksaveasfilename(
            defaultextension=".txt",
            filetypes=[("Text files", "*.txt"), ("All files", "*.*")]
        )

        if file_path:
            with open(file_path, 'w', encoding='utf-8') as file:
                file.write("源文本:\n")
                file.write(self.source_text.get(1.0, tk.END))
                file.write("\n\n翻译结果:\n")
                file.write(self.target_text.get(1.0, tk.END))

            self.status_var.set(f"当前翻译已导出到: {file_path}")

    def translate(self):
        """执行翻译"""
        try:
            source_text = self.source_text.get(1.0, tk.END).strip()
            if not source_text:
                messagebox.showwarning("警告", "请输入要翻译的文本！")
                return

            self.status_var.set("正在翻译...")
            self.root.update()

            # 设置语言代码
            from_lang = self.languages[self.source_lang.get()]
            to_lang = self.languages[self.target_lang.get()]

            if from_lang == 'auto':
                from_lang = self.detect_language(source_text)

            # 准备请求参数
            salt = str(random.randint(32768, 65536))
            sign = self.make_sign(source_text, salt)

            params = {
                'q': source_text,
                'from': from_lang,
                'to': to_lang,
                'appid': self.appid,
                'salt': salt,
                'sign': sign
            }

            response = requests.get(
                'http://api.fanyi.baidu.com/api/trans/vip/translate',
                params=params
            )
            result = response.json()

            if 'error_code' in result:
                raise Exception(f"翻译错误 (错误码: {result['error_code']})")

            translated_text = '\n'.join(item['dst'] for item in result['trans_result'])
            self.target_text.delete(1.0, tk.END)
            self.target_text.insert(1.0, translated_text)

            # 保存到历史记录
            self.save_to_history(source_text, translated_text)

            self.status_var.set("翻译完成")

        except Exception as e:
            self.status_var.set(f"翻译失败: {str(e)}")
            messagebox.showerror("错误", f"翻译失败: {str(e)}")

    def detect_language(self, text):
        """检测文本语言"""
        try:
            lang = langdetect.detect(text)
            lang_map = {
                'zh-cn': 'zh',
                'en': 'en',
                'ja': 'jp',
                'ko': 'kor',
                'fr': 'fra',
                'es': 'spa',
                'ru': 'ru'
            }
            return lang_map.get(lang, 'auto')
        except:
            return 'auto'

    def make_sign(self, text, salt):
        """生成签名"""
        sign = self.appid + text + salt + self.secret_key
        return hashlib.md5(sign.encode()).hexdigest()

    def clear_text(self):
        """清除文本"""
        self.source_text.delete(1.0, tk.END)
        self.target_text.delete(1.0, tk.END)
        self.status_var.set("已清除所有内容")

    def copy_to_clipboard(self):
        """复制到剪贴板"""
        text = self.target_text.get(1.0, tk.END).strip()
        if text:
            self.root.clipboard_clear()
            self.root.clipboard_append(text)
            self.status_var.set("已复制到剪贴板")
        else:
            self.status_var.set("没有可复制的内容")

    def change_font_size(self, event=None):
        """更改字体大小"""
        try:
            new_size = int(self.font_size_var.get())
            self.current_font_size = new_size
            self.source_text.configure(font=('Arial', new_size))
            self.target_text.configure(font=('Arial', new_size))
        except ValueError:
            messagebox.showerror("错误", "请输入有效的字体大小！")
            self.font_size_var.set(str(self.current_font_size))

    def __del__(self):
        """清理资源"""
        if hasattr(self, 'conn'):
            self.conn.close()


def main():
    root = tk.Tk()
    app = TranslatorApp(root)
    root.mainloop()


if __name__ == "__main__":
    main()

十一、总结

两个强大的功能合二为一，而且又都是免费的，相比百度自家收费的文心一格不是更香吗？

需要注意的：如果点击生成图片按钮界面一直没反应，可能是国内访问Hugging Face 网站受限，懂得都懂，可能需要1）采取某种<科学上网>的方式。 2）采用Fugging Face 国内镜像

# 可选的其他镜像API端点
MIRROR_APIS = {
    "modelscope": "https://api.modelscope.cn/api/v1/models/",
    "openxlab": "https://api.openxlab.org.cn/api/v1/models/",
    "autodl": "https://api.autodl.com/api/v1/models/"
}

喜欢这篇文章的话记得点赞收藏加关注哦！！