Ollama 命令行与对话指令全解

#!/bin/bash
# 离线安装：机器不通外网（课堂环境、内网机房）时怎么把 Ollama 装起来。
#
# 联网机器上一条 curl 就完事，离线环境要自己做三件事：
#   ① 把二进制放进 PATH
#   ② 手写 systemd 服务（一键脚本才会替你写，解压包不会）
#   ③ 把模型文件也搬过来 —— 这一步最容易被忘，装好了却拉不到模型
#
# 用法：把 ollama-linux-amd64.tgz 和模型目录拷到本机后执行
#   sudo bash ollama_offline_install.sh
set -euo pipefail

PKG="${PKG:-./ollama-linux-amd64.tgz}"      # 离线安装包路径
MODELS_DIR="${MODELS_DIR:-/data/ollama/models}"   # 模型存放目录，指到数据盘
MODELS_SRC="${MODELS_SRC:-}"                # 别的机器拷来的模型目录，可以为空

echo "===== ① 解压二进制 ====="
if [ ! -f "$PKG" ]; then
  echo "找不到安装包 $PKG，先把它拷到当前目录"
  exit 1
fi
tar -xzf "$PKG" -C /usr
# 验证：打得出版本号才算装上。报 command not found 就是解压路径不对
ollama -v

echo
echo "===== ② 准备模型目录 ====="
# 模型动辄几十 G，一定要放数据盘，不能留在系统盘
mkdir -p "$MODELS_DIR"

if [ -n "$MODELS_SRC" ] && [ -d "$MODELS_SRC" ]; then
  echo "从 $MODELS_SRC 拷模型过来（这一步可能很久）"
  # -a 保留权限和时间戳，模型目录里的 blobs 和 manifests 结构必须原样保留
  cp -a "$MODELS_SRC"/. "$MODELS_DIR"/
else
  echo "没指定 MODELS_SRC，跳过；稍后需要联网 pull 或再手动拷贝"
fi

# 服务以哪个用户跑，目录就得属于谁；不然服务起来了却读不到模型
chown -R root:root "$MODELS_DIR"

echo
echo "===== ③ 写 systemd 服务 ====="
# 注意：这里是新建一个服务文件。如果机器上已经有 /etc/systemd/system/ollama.service，
# 先备份再改，不要直接覆盖别人配好的参数。
if [ -f /etc/systemd/system/ollama.service ]; then
  cp -a /etc/systemd/system/ollama.service \
        "/etc/systemd/system/ollama.service.bak.$(date +%Y%m%d%H%M%S)"
  echo "已备份原有服务文件"
fi

cat > /etc/systemd/system/ollama.service <<EOF
[Unit]
Description=Ollama Service
After=network-online.target
Wants=network-online.target

[Service]
ExecStart=/usr/bin/ollama serve
User=root
Group=root
Restart=always
RestartSec=3
Environment="OLLAMA_MODELS=${MODELS_DIR}"
Environment="OLLAMA_HOST=127.0.0.1:11434"
Environment="OLLAMA_KEEP_ALIVE=30m"

[Install]
WantedBy=default.target
EOF

echo
echo "===== ④ 启动并设开机自启 ====="
# 改完服务文件必须 daemon-reload，否则 systemd 还在用旧的那份
systemctl daemon-reload
systemctl enable ollama
systemctl restart ollama
sleep 2
systemctl status ollama --no-pager | head -6

echo
echo "===== ⑤ 验证 ====="
ss -lntp | grep 11434 || echo "11434 没在监听，看 journalctl -u ollama -n 30"
# 环境变量有没有真的吃进去，看进程实际拿到的环境最可靠
PID=$(systemctl show -p MainPID --value ollama)
[ "$PID" != "0" ] && tr '\0' '\n' < "/proc/$PID/environ" | grep '^OLLAMA_' || true
ollama list

"""调参实验台：同一个问题，在不同参数下各跑几遍，把差异摆到眼前。

为什么需要它：
    「temperature 调低会更稳定」这句话，看文档记不住，
    自己跑一遍、看着同一个问题在 0.0 下三次回答一模一样、
    在 1.2 下三次各说各话，十秒钟就理解了。

对话里的 /set parameter 一次只能试一个值，退出还会丢。
这个脚本一次把整条梯度跑完，并把结果并排打印出来。

用法：
    python3 param_explore.py --model qwen2:1.5b
    python3 param_explore.py --model qwen2:1.5b --param top_p --values 0.1,0.5,0.9
    python3 param_explore.py --model qwen2:1.5b --prompt "给这段日志写一句故障摘要"

依赖：只用标准库。
"""
import argparse
import difflib
import json
import os
import sys
import urllib.request

BASE = os.environ.get("OLLAMA_BASE", "http://127.0.0.1:11434").rstrip("/")

# 默认问一个「有标准答案但允许不同表述」的问题：
# 太开放（写首诗）看不出稳定性，太封闭（1+1）所有参数都一样。
DEFAULT_PROMPT = "用一句话说明什么是私有化部署。"


def ask(model, prompt, options, timeout=180):
    payload = {
        "model": model,
        "messages": [{"role": "user", "content": prompt}],
        "stream": False,
        "options": options,
    }
    req = urllib.request.Request(
        BASE + "/api/chat",
        data=json.dumps(payload).encode("utf-8"),
        headers={"Content-Type": "application/json"},
    )
    with urllib.request.urlopen(req, timeout=timeout) as resp:
        return json.loads(resp.read().decode("utf-8"))["message"]["content"].strip()


def similarity(answers):
    """两两比对答案的相似度，用来量化「稳不稳定」。

    用标准库的 difflib 做字符级比对就够了：
    这里要的不是语义相似度，而是「是不是几乎逐字一样」。
    返回 0~1，越接近 1 表示几轮回答越像。
    """
    if len(answers) < 2:
        return 1.0
    scores = []
    for i in range(len(answers)):
        for j in range(i + 1, len(answers)):
            scores.append(difflib.SequenceMatcher(None, answers[i], answers[j]).ratio())
    return sum(scores) / len(scores)


def run_sweep(model, prompt, param, values, repeat):
    print("模型：%s" % model)
    print("问题：%s" % prompt)
    print("扫描参数：%s    每档重复 %d 次\n" % (param, repeat))

    summary = []
    for v in values:
        # 注意这里每一档都是独立的一次次请求，互相之间没有上下文，
        # 所以差异完全来自参数本身，不会被前面的对话影响。
        options = {param: v}
        print("=" * 60)
        print("%s = %s" % (param, v))
        print("-" * 60)

        answers = []
        for k in range(repeat):
            try:
                a = ask(model, prompt, options)
            except Exception as exc:
                print("  第 %d 次失败：%s" % (k + 1, exc))
                continue
            answers.append(a)
            print("  [%d] %s" % (k + 1, a))

        if answers:
            sim = similarity(answers)
            avg_len = sum(len(a) for a in answers) / len(answers)
            summary.append((v, sim, avg_len))
            print("  —— 几次回答的平均相似度 %.2f，平均长度 %.0f 字" % (sim, avg_len))
        print()

    if summary:
        print("=" * 60)
        print("汇总（相似度越高＝越稳定、越可复现）")
        print("-" * 60)
        print("%-12s %-12s %s" % (param, "相似度", "平均长度"))
        for v, sim, ln in summary:
            bar = "█" * int(sim * 20)
            print("%-12s %-12.2f %-6.0f %s" % (v, sim, ln, bar))
        print()
        print("解读：")
        print("  · 相似度接近 1.00 —— 几乎每次都给同样的话，适合分类、抽取这类任务")
        print("  · 相似度明显下降 —— 表达开始发散，适合创作，但也更容易跑偏")
        print("  · 注意看平均长度：有些参数不改变稳定性，只改变啰嗦程度")


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--model", required=True, help="模型全名，例如 qwen2:1.5b")
    ap.add_argument("--prompt", default=DEFAULT_PROMPT)
    ap.add_argument("--param", default="temperature",
                    help="要扫描的参数名：temperature / top_p / top_k")
    ap.add_argument("--values", default="",
                    help="逗号分隔的取值；不给就按参数名用内置梯度")
    ap.add_argument("--repeat", type=int, default=3,
                    help="每档重复几次；至少 2 次才看得出稳定性")
    args = ap.parse_args()

    # 不同参数的取值范围不一样，内置梯度按参数名分别给
    presets = {
        "temperature": [0.0, 0.3, 0.8, 1.2],
        "top_p": [0.1, 0.5, 0.9, 1.0],
        "top_k": [1, 10, 40, 100],
    }
    if args.values:
        raw = [x.strip() for x in args.values.split(",") if x.strip()]
        values = [int(x) if args.param == "top_k" else float(x) for x in raw]
    else:
        values = presets.get(args.param)
        if values is None:
            print("参数 %s 没有内置梯度，请用 --values 指定" % args.param)
            return 1

    run_sweep(args.model, args.prompt, args.param, values, args.repeat)
    return 0


if __name__ == "__main__":
    sys.exit(main())

#!/bin/bash
# 最小可复现路径：从一台干净的 Linux 机器，到能跟模型说上话。
# 每一步都带验证动作，上一步没验证通过就别走下一步。
set -euo pipefail

# ---------- ① 安装 ----------
# 方式 A：离线包（课堂环境用这个，安装包已经在本地）
#   tar -xzf ollama-linux-amd64.tgz -C /usr
# 方式 B：联网一键脚本（工作中常用，会顺带把 systemd 服务也装好）
#   curl -fsSL https://ollama.com/install.sh | sh
ollama -v      # 打得出版本号才算装上；报 command not found 就是 PATH 没生效

# ---------- ② 起服务 ----------
# 前台起（调试用，关掉终端服务就没了）：ollama serve
# 后台托管（生产用，开机自启）：
systemctl start ollama
systemctl status ollama --no-pager | head -5   # 要看到 active (running)

# 端口真的在监听吗？这一步最容易被跳过
ss -lntp | grep 11434 || echo "11434 没在监听，先看 journalctl -u ollama"

# ---------- ③ 拉模型 ----------
# 模型名必须写全「名字:版本」；不写版本默认拉 latest，体积可能大得多
ollama pull qwen2:1.5b

ollama list    # 拉下来的模型在这里，看 NAME 和 SIZE 两列

# ---------- ④ 对话 ----------
# 交互式：进去后用 /bye 退出
#   ollama run qwen2:1.5b
# 一次性问答：带上提示词，答完自动退出，适合写进脚本
ollama run qwen2:1.5b "用一句话说明什么是私有化部署"

# ---------- ⑤ 收尾确认 ----------
ollama ps      # 看模型是不是还占着内存；PROCESSOR 列显示 GPU 还是 CPU

#!/bin/bash
# 模型仓库的日常运维：盘点 → 体检 → 清理 → 复核。
# 场景：机器磁盘快满了，要在不影响线上服务的前提下腾空间。
set -euo pipefail

KEEP_MODEL="${KEEP_MODEL:-qwen2:1.5b}"   # 线上正在用的，绝对不能删

echo "===== ① 盘点：本地一共有哪些模型 ====="
ollama list

echo
echo "===== ② 体检：谁正占着内存/显存 ====="
# PROCESSOR 列是关键：100% GPU 才是全进显存；出现 CPU 说明显存不够溢出了
# UNTIL 列是 keep_alive 到期时间，到点模型自动卸载
ollama ps

echo
echo "===== ③ 看清楚线上这个模型的底细 ====="
# 不用把模型跑起来就能看信息
ollama show "$KEEP_MODEL"                  # 参数量、量化等级、上下文长度
ollama show "$KEEP_MODEL" --parameters     # 内置的停止词等参数
ollama show "$KEEP_MODEL" --template       # 提示词模板，排查「答非所问」时要看它

echo
echo "===== ④ 清理：删掉不再需要的模型 ====="
# 注意：ollama rm 只认模型全名，不能像 docker 那样用 ID 前缀
for m in $(ollama list | awk 'NR>1 {print $1}'); do
  if [ "$m" = "$KEEP_MODEL" ]; then
    echo "跳过线上模型：$m"
    continue
  fi
  echo "待删除：$m"
  # 真要删就去掉下面这行的注释；保持注释状态时这个脚本是只读的
  # ollama rm "$m"
done

echo
echo "===== ⑤ 复核：确认线上模型还在、还能答 ====="
ollama list | grep -q "^${KEEP_MODEL}" && echo "线上模型仍在：$KEEP_MODEL"
# 让它立刻卸载，把显存还回来（keep_alive 传 0）
curl -s http://127.0.0.1:11434/api/generate \
  -d "{\"model\":\"${KEEP_MODEL}\",\"keep_alive\":0}" > /dev/null
echo "已请求卸载模型，再看一次 ps："
ollama ps

"""模型盘点：磁盘上有什么、显存里跑着什么、哪些可以删。

`ollama list` 和 `ollama ps` 各给一半信息，人要自己在脑子里拼。
机器上模型一多，这个拼接就开始出错 —— 删掉了正在用的，
或者留着一个半年没人碰的 20G 模型占着数据盘。

这个脚本把两边的信息合到一张表里，并给出清理建议。
它**只读**，不会删任何东西：删除命令打印出来，由你自己复制执行。

用法：
    python3 model_inventory.py
    python3 model_inventory.py --keep qwen2:1.5b,deepseek-r1:7b

依赖：只用标准库，走 HTTP 接口，不依赖 ollama 命令是否在 PATH 里。
"""
import argparse
import json
import os
import sys
import urllib.error
import urllib.request

BASE = os.environ.get("OLLAMA_BASE", "http://127.0.0.1:11434").rstrip("/")


def get(path):
    """GET 一个接口，拿不到就抛出带说明的错误。"""
    try:
        with urllib.request.urlopen(BASE + path, timeout=15) as resp:
            return json.loads(resp.read().decode("utf-8"))
    except urllib.error.URLError as exc:
        raise RuntimeError(
            "连不上 %s%s —— 先确认服务在跑：systemctl is-active ollama" % (BASE, path)
        ) from exc


def human(n):
    """字节数转成人看得懂的单位。"""
    for unit in ("B", "KB", "MB", "GB", "TB"):
        if n < 1024 or unit == "TB":
            return "%.1f%s" % (n, unit)
        n /= 1024


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--keep", default="",
                    help="逗号分隔的保留清单，这些模型不会出现在清理建议里")
    args = ap.parse_args()
    keep = set(x.strip() for x in args.keep.split(",") if x.strip())

    # /api/tags 对应 ollama list：磁盘上有哪些
    disk = get("/api/tags").get("models", [])
    # /api/ps 对应 ollama ps：显存里跑着哪些
    loaded = {m["name"]: m for m in get("/api/ps").get("models", [])}

    if not disk:
        print("磁盘上一个模型都没有。先 ollama pull 一个。")
        return 0

    total = sum(m.get("size", 0) for m in disk)
    print("=" * 74)
    print("本地模型盘点   共 %d 个，合计占用 %s" % (len(disk), human(total)))
    print("=" * 74)
    print("%-28s %-10s %-12s %-10s %s"
          % ("模型", "大小", "量化", "参数量", "状态"))
    print("-" * 74)

    # 按体积从大到小排：要腾空间时，先看最上面几行就够了
    for m in sorted(disk, key=lambda x: -x.get("size", 0)):
        name = m["name"]
        det = m.get("details", {}) or {}
        state = "显存中" if name in loaded else "仅磁盘"
        if name in keep:
            state += " · 保留"
        print("%-28s %-10s %-12s %-10s %s"
              % (name,
                 human(m.get("size", 0)),
                 det.get("quantization_level", "-"),
                 det.get("parameter_size", "-"),
                 state))

    # 正在显存里的单独列一遍，带上到期时间
    if loaded:
        print()
        print("当前占着内存/显存的模型：")
        for name, m in loaded.items():
            # expires_at 就是 keep_alive 到期的时刻，到点自动卸载
            print("  · %-26s 占用 %-10s 到期 %s"
                  % (name, human(m.get("size", 0)), m.get("expires_at", "未知")))
    else:
        print()
        print("当前没有模型占用内存/显存。")

    # 清理建议：只挑「不在保留清单、且当前没在跑」的
    candidates = [m for m in disk
                  if m["name"] not in keep and m["name"] not in loaded]
    print()
    if candidates:
        freeable = sum(m.get("size", 0) for m in candidates)
        print("可清理候选（不在保留清单、且当前没在跑），共可腾出 %s：" % human(freeable))
        for m in sorted(candidates, key=lambda x: -x.get("size", 0)):
            print("  ollama rm %s        # %s" % (m["name"], human(m.get("size", 0))))
        print()
        print("⚠️  上面只是打印，脚本不会替你删。")
        print("    删之前再确认一遍：这个模型有没有被别的服务或定时任务用着。")
    else:
        print("没有可清理的候选：要么都在保留清单里，要么都正在跑。")

    return 0


if __name__ == "__main__":
    try:
        sys.exit(main())
    except RuntimeError as exc:
        print(exc)
        sys.exit(1)

# 骨架模板：把一个通用模型固化成「带人设、带默认参数」的私有模型。
#
# 用法：
#   1. 复制成 Modelfile，按 TODO 改
#   2. ollama create 你的模型名 -f Modelfile
#   3. ollama run 你的模型名
#   4. ollama list 里会多出这一条，像普通模型一样使用
#
# 为什么要做这个：把「人设 + 参数」写死在模型里，业务代码就不必每次都传一长串
# system 提示词和 options，换模型时也只改这一个文件。

# TODO: 换成本地已经拉好的基座模型全名（ollama list 里能查到的那个）
FROM qwen2:1.5b

# ---------- 人设 ----------
# TODO: 改成你自己的业务角色设定。写得越具体，跑偏的概率越低。
SYSTEM """
你是某公司内部的运维助手。
回答只依据用户提供的信息，不确定就直接说不确定，不要编造命令和参数。
回答用中文，先给结论，再给步骤。
"""

# ---------- 默认生成参数 ----------
# 这些值等价于对话里敲 /set parameter，区别是这里写死、重启也在

# TODO: 确定性任务（分类、抽取）调低到 0.1~0.3；创作类才往上调
PARAMETER temperature 0.3

# TODO: 上下文长度。调大更能记事，但显存占用同步上涨，并发时成倍放大
PARAMETER num_ctx 4096

# TODO: 单次回答最多生成多少 token，防止模型长篇大论刷屏
PARAMETER num_predict 512

# TODO: 遇到这些串就停止生成，按你的输出格式来定；不需要就整行删掉
# PARAMETER stop "###"

# ---------- 提示词模板 ----------
# 一般不用动：模板由基座模型自带，改错会导致模型答非所问。
# 确实要改时，先用 `ollama show 基座模型 --template` 把原版抄出来再改。

# 填好的实例：一个内部知识库问答助手。
# 对照 Modelfile.skeleton 看，能直观看出「该写多具体」。
#
# 落地：
#   ollama create kb-assistant -f Modelfile.kb-assistant
#   ollama run kb-assistant
#   ollama list      # 它会像普通模型一样出现在列表里

FROM qwen2:1.5b

# 人设写得越具体，跑偏概率越低。
# 注意三件事都写死了：身份、边界、输出格式 —— 缺任何一条模型都会自由发挥。
SYSTEM """
你是某制造企业的内部知识库助手，服务对象是一线生产和质检人员。

回答规则：
1. 只依据用户在问题中提供的信息回答。用户没给的内容，直接说「资料里没有，需要人工确认」，不要推测。
2. 涉及安全操作、设备参数、质量判定标准时，必须提醒对方以现行作业指导书为准。
3. 回答用中文，先给结论，再给依据，最后给下一步动作。总长度控制在五句话以内。
4. 不回答与生产业务无关的问题，礼貌拒绝即可。
"""

# 知识库问答属于确定性任务：同一个问题应该每次给同样的答案。
# 温度压到 0.2，配合上面的「不要推测」，能显著减少编造。
PARAMETER temperature 0.2

# top_p 一起收紧，进一步压住发散。
PARAMETER top_p 0.7

# 用户会把整段作业指导书贴进来，上下文要够。
# 但注意：这个值直接决定 KV 缓存大小，并发场景下要重新算显存账。
PARAMETER num_ctx 8192

# 回答限制在五句话以内，生成上限给 400 就够，防止模型长篇大论。
PARAMETER num_predict 400

"""批量跑：把一个文件里的几百条问题喂给本地模型，结果存成 CSV。

私有化部署最划算的用法之一就是离线批处理 ——
机器慢没关系，晚上挂着跑，第二天来看结果。
这类活儿交给云端 API 反而贵，而且几百条数据全要出网。

这个脚本负责把这件事做稳：
    · 断点续跑：中途挂了重跑，已完成的不再重复调用
    · 逐条落盘：跑一条写一条，进程被杀也不丢前面的结果
    · 失败隔离：单条失败记下错误继续跑，不让一条脏数据毁掉整批

用法：
    python3 batch_ask.py --model qwen2:1.5b --input questions.txt --output result.csv
    python3 batch_ask.py --model qwen2:1.5b --input questions.txt \
        --system "你是质检助手，只回答是或否。"

依赖：只用标准库。
"""
import argparse
import csv
import json
import os
import sys
import time
import urllib.error
import urllib.request

BASE = os.environ.get("OLLAMA_BASE", "http://127.0.0.1:11434").rstrip("/")


def ask(model, system, question, timeout, retries=2):
    """问一条。失败重试，重试仍失败就抛出去由上层记录。"""
    messages = []
    if system:
        messages.append({"role": "system", "content": system})
    messages.append({"role": "user", "content": question})

    payload = {
        "model": model,
        "messages": messages,
        "stream": False,
        # 批处理要可复现：同一批数据重跑，结果应该一致
        "options": {"temperature": 0},
    }
    body = json.dumps(payload).encode("utf-8")

    last = None
    for attempt in range(retries + 1):
        try:
            req = urllib.request.Request(
                BASE + "/api/chat", data=body,
                headers={"Content-Type": "application/json"})
            with urllib.request.urlopen(req, timeout=timeout) as resp:
                data = json.loads(resp.read().decode("utf-8"))
            return data["message"]["content"].strip(), data.get("eval_count", 0)
        except (urllib.error.URLError, TimeoutError, KeyError) as exc:
            last = exc
            if attempt < retries:
                # 退避重试：服务在加载模型或正忙时，等一下往往就好了
                time.sleep(2 ** attempt)
    raise RuntimeError(str(last))


def load_done(path):
    """读已有的输出文件，拿到已经跑完的行号，用于断点续跑。

    几百条跑到一半断了，从头再来既费时间又浪费电。
    """
    done = set()
    if not os.path.exists(path):
        return done
    with open(path, encoding="utf-8", newline="") as f:
        for row in csv.DictReader(f):
            if row.get("index"):
                done.add(int(row["index"]))
    return done


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--model", required=True)
    ap.add_argument("--input", required=True, help="问题文件，一行一条")
    ap.add_argument("--output", default="batch_result.csv")
    ap.add_argument("--system", default="", help="统一人设，可留空")
    ap.add_argument("--timeout", type=int, default=300)
    args = ap.parse_args()

    with open(args.input, encoding="utf-8") as f:
        questions = [ln.strip() for ln in f if ln.strip()]
    if not questions:
        print("输入文件里没有问题")
        return 1

    done = load_done(args.output)
    if done:
        print("检测到已有结果 %d 条，将跳过这些继续跑。" % len(done))

    # 追加模式打开；文件不存在时先写表头
    new_file = not os.path.exists(args.output)
    fout = open(args.output, "a", encoding="utf-8", newline="")
    writer = csv.writer(fout)
    if new_file:
        writer.writerow(["index", "question", "answer", "tokens", "seconds", "error"])
        fout.flush()

    ok = fail = 0
    t_start = time.time()
    for i, q in enumerate(questions, 1):
        if i in done:
            continue
        t0 = time.time()
        try:
            answer, tokens = ask(args.model, args.system, q, args.timeout)
            err = ""
            ok += 1
        except RuntimeError as exc:
            # 单条失败不中断整批：把错误写进结果文件，人工再看
            answer, tokens, err = "", 0, str(exc)
            fail += 1

        writer.writerow([i, q, answer, tokens, "%.1f" % (time.time() - t0), err])
        # 每条都 flush：进程被杀也不会丢掉前面已经跑出来的结果
        fout.flush()

        status = "OK " if not err else "FAIL"
        print("[%s] %d/%d  %.1fs  %s"
              % (status, i, len(questions), time.time() - t0, q[:30]))

    fout.close()
    elapsed = time.time() - t_start
    print("-" * 56)
    print("完成 %d 条，失败 %d 条，总耗时 %.1f 分钟" % (ok, fail, elapsed / 60))
    print("结果已写入 %s" % args.output)
    if fail:
        print("⚠️  有失败记录，在 CSV 的 error 列里；修好之后重跑同一条命令即可续跑。")
    return 0


if __name__ == "__main__":
    sys.exit(main())