multi-voice distillation: train_texts, train_voices.py, notebook_train.py

kaggle/notebook_train.py

@@ -0,0 +1,71 @@
+"""Kaggle notebook body: distil the flow head on the seven mined voices.
+
+Order matters. A smoke pass (5 texts, 5 optimizer steps) validates the
+trajectory and training code paths before spending an hour generating 840
+trajectories; the earlier failures in this project each cost a full session.
+
+  smoke   traj x5 on one GPU, train x5 steps          ~4 min
+  traj    7 voices x 120 texts, sharded over 2 GPUs   ~70 min
+  train   4-step student on all shards                ~25 min
+  export  ONNX fp32 + int4                            ~5 min
+  eval    40 sentences x 2 voices x {teacher, stu}    ~25 min
+"""
+import os
+import subprocess
+import sys
+import time
+
+from notebook_eval import BUNDLE, MODEL, ROOT, WEIGHTS, pull, stage_deps, stage_repo
+
+BUNDLE_REPO = "idefinity/webfm-eval"
+SHARDS = [["a01", "a03", "a04"], ["a05", "a06", "a07", "a08"]]
+EVAL_VOICES = "a08,a01"
+
+
+def run(tag: str, env_extra: dict, gpu: int = 0) -> int:
+    env = dict(os.environ, WORK_ROOT=str(ROOT), **env_extra)
+    if gpu is not None:
+        env["CUDA_VISIBLE_DEVICES"] = str(gpu)
+    log = open(ROOT / f"train_{tag}.log", "w")
+    p = subprocess.Popen([sys.executable, str(BUNDLE / "kaggle/train_voices.py")],
+                         env=env, stdout=log, stderr=subprocess.STDOUT, cwd=str(ROOT))
+    return p.wait()
+
+
+def main() -> None:
+    stage_repo()
+    stage_deps()
+    pull(WEIGHTS, MODEL)
+    pull(BUNDLE_REPO, BUNDLE, repo_type="dataset")
+
+    print("== smoke: traj x5, train x5 ==", flush=True)
+    rc = run("smoke_traj", {"STAGE": "traj", "VOICES": "a08", "SMOKE": "1", "N_TEXTS": "5"})
+    print("smoke traj rc", rc)
+    rc = run("smoke_train", {"STAGE": "train", "TRAIN_STEPS": "5", "BATCH": "4"})
+    print("smoke train rc", rc)
+    if rc != 0:
+        print((ROOT / "train_smoke_train.log").read_text()[-3000:])
+        raise SystemExit("training path failed in smoke")
+
+    print("== full trajectories ==", flush=True)
+    procs = []
+    for gpu, shard in enumerate(SHARDS):
+        env = dict(os.environ, WORK_ROOT=str(ROOT), STAGE="traj",
+                   VOICES=",".join(shard), CUDA_VISIBLE_DEVICES=str(gpu))
+        log = open(ROOT / f"traj_gpu{gpu}.log", "w")
+        procs.append(subprocess.Popen([sys.executable, str(BUNDLE / "kaggle/train_voices.py")],
+                                      env=env, stdout=log, stderr=subprocess.STDOUT, cwd=str(ROOT)))
+    while any(p.poll() is None for p in procs):
+        time.sleep(60)
+        n = len(list((ROOT / "train/traj").glob("*/*.pt")))
+        print(f"[{time.strftime('%H:%M')}] trajectories={n}", flush=True)
+    print("traj exits:", [p.returncode for p in procs])
+
+    print("== train + export + eval ==", flush=True)
+    rc = run("final", {"STAGE": "all", "TRAIN_STEPS": "1500", "BATCH": "16",
+                       "EVAL_VOICES": EVAL_VOICES}, gpu=0)
+    print("final rc", rc)
+
+
+if __name__ == "__main__":
+    main()

kaggle/train_voices.py

@@ -0,0 +1,451 @@
+"""Distil the Ming flow head on the seven mined voices.
+
+Why this run: the existing 3/4-step students were trained on 200 utterances of a
+single voice (`lingguang`). On a clean prompt at eval time they cost +5.2 pp
+(v08, 4step) to +11.8 pp (3step) CER against the teacher. The hypothesis is that
+the gap is voice generalisation, not step count, and the fix is trajectory data
+that spans the voices we actually ship.
+
+One variable changes this round: the data. The training recipe is copied from
+ming_multistep.py unchanged, including the CFG coefficient, so the new student
+is comparable to the old one. If multi-voice data does not close the gap, that
+coefficient is the next thing to look at.
+
+Stages:
+  STAGE=traj   shard by VOICES env, write traj/{voice}/{i}.pt, resumable
+  STAGE=train  merge shards, train the 4-step CFG-free student
+  STAGE=export ONNX fp32 + int4, validate against PyTorch
+  STAGE=eval   40 sentences x EVAL_VOICES x {teacher, student}
+  STAGE=all    train -> export -> eval (traj is run separately, per GPU)
+"""
+import json
+import os
+import sys
+import time
+import traceback
+from pathlib import Path
+
+import numpy as np
+
+ROOT = Path(os.environ.get("WORK_ROOT", "/kaggle/working"))
+REPO = ROOT / "Ming-3.0-tts"
+MODEL = ROOT / "Ming-3.0-tts-0.5b"
+BUNDLE = ROOT / "webfm-eval"
+OUT = ROOT / "train"
+TRAJ = OUT / "traj"
+
+STAGE = os.environ.get("STAGE", "all")
+SEED = 20261030
+STEPS = int(os.environ.get("STEPS", "4"))
+TRAIN_STEPS = int(os.environ.get("TRAIN_STEPS", "1500"))
+BATCH = int(os.environ.get("BATCH", "16"))
+LR = float(os.environ.get("LR", "1e-4"))
+VOICE_FILTER = [v for v in os.environ.get("VOICES", "").split(",") if v]
+EVAL_VOICES = [v for v in os.environ.get("EVAL_VOICES", "").split(",") if v]
+N_TEXTS = int(os.environ.get("N_TEXTS", "120"))
+SMOKE = os.environ.get("SMOKE", "0") == "1"
+
+TEACHER_CFG = 2.0
+CFG_MULT = 2.0          # unchanged from ming_multistep.py, for comparability
+DROP = {"Miss哈尼"}
+
+
+def log(msg: str) -> None:
+    print(f"[{time.strftime('%H:%M:%S')}] {msg}", flush=True)
+
+
+def patch_fp32() -> None:
+    for name in ("ming_tts.py", "modeling_bailingmm.py"):
+        path = REPO / name
+        s = path.read_text()
+        s = s.replace("torch_dtype=torch.bfloat16", "torch_dtype=torch.float32")
+        s = s.replace(".eval().to(torch.bfloat16).to(device)", ".eval().to(torch.float32).to(device)")
+        s = s.replace("dtype=torch.bfloat16", "dtype=torch.float32")
+        path.write_text(s)
+
+
+def voices() -> list[dict]:
+    vs = json.loads((BUNDLE / "mined/manifest.json").read_text())["voices"]
+    vs = [v for v in vs if v["artist"] not in DROP]
+    if VOICE_FILTER:
+        vs = [v for v in vs if v["slot"] in VOICE_FILTER]
+    return vs
+
+
+def texts() -> list[str]:
+    t = json.loads((BUNDLE / "train_texts.json").read_text())["texts"]
+    return t[:N_TEXTS]
+
+
+def stage_traj() -> None:
+    import torch
+
+    sys.path.insert(0, str(REPO))
+    from ming_tts import MingTTS
+    import tts_tasks
+
+    TRAJ.mkdir(parents=True, exist_ok=True)
+    tts = MingTTS(str(MODEL), device="cuda", text_normalization=False)
+    mm = tts.model
+    device = next(mm.parameters()).device
+    dtype = next(mm.parameters()).dtype
+    task_prompt = tts_tasks.build_tts_prompt("Chinese")
+    torch.set_grad_enabled(False)
+
+    total = 0
+    for v in voices():
+        vdir = TRAJ / v["slot"]
+        vdir.mkdir(parents=True, exist_ok=True)
+        prompt_latent, spk = tts.prepare_prompt(str(BUNDLE / v["wav"]), use_spk_emb=True)
+        prompt_latent = prompt_latent.to(device=device, dtype=dtype)
+        spk = [x.to(device=device, dtype=dtype) for x in spk]
+
+        for i, text in enumerate(texts()):
+            dst = vdir / f"{i:04d}.pt"
+            if dst.exists():
+                continue
+            try:
+                torch.manual_seed(SEED + i)
+                input_ids, inputs_embeds = mm.prepare_input_embed(
+                    prompt=task_prompt, text=text, spk_emb=spk,
+                    prompt_latent=prompt_latent, prompt_text=v["prompt_text"],
+                )
+                attention_mask = torch.ones(input_ids.shape, device=device)
+                position_ids = (attention_mask.cumsum(-1) - 1).masked_fill_(attention_mask == 0, 1)
+                past = None
+                hist = torch.zeros(1, mm.history_patch_size, mm.latent_dim,
+                                   device=device, dtype=dtype)
+                start = mm.history_patch_size - prompt_latent.size(1)
+                if start < 0:
+                    hist[:] = prompt_latent[:, -start:, :]
+                else:
+                    hist[:, start:, :] = prompt_latent
+
+                budget = (512 - inputs_embeds.shape[1]) // mm.patch_size
+                n = max(1, min(200, max(16, int(len(text) * 2.6)), budget))
+                zs, hs, ns, ls = [], [], [], []
+                for _ in range(n):
+                    with torch.no_grad():
+                        out = mm.model(
+                            attention_mask=attention_mask, position_ids=position_ids,
+                            inputs_embeds=inputs_embeds, audio_mask=None, image_mask=None,
+                            output_hidden_states=True, return_dict=True, use_cache=True,
+                            past_key_values=past,
+                        )
+                    past = out.past_key_values
+                    z = out.hidden_states[-1][:, -1:, :]
+                    noise = torch.randn(1, 1, mm.latent_dim, device=device, dtype=dtype)
+                    sde = torch.randn(10, 1, 1, mm.latent_dim, device=device, dtype=dtype)
+                    with torch.no_grad():
+                        latent = mm.flowloss.cfm.sample(
+                            noise=noise, c=z, latent_history=hist, sde_noise=sde,
+                            cfg_scale=TEACHER_CFG, sway_sampling_coef=-1.0, use_epss=True,
+                            patch_size=1, sigma=0.25, temperature=0.0,
+                        )
+                    zs.append(z[0, 0].detach().float().cpu())
+                    hs.append(hist[0].detach().float().cpu())
+                    ns.append(noise[0, 0].detach().float().cpu())
+                    ls.append(latent[0, 0].detach().float().cpu())
+                    inputs_embeds = mm.linear_proj_audio(latent)
+                    position_ids = position_ids[:, -1:] + 1
+                    attention_mask = torch.ones(inputs_embeds.shape[0], 1, device=device)
+                    hist[:, :-mm.patch_size, :] = hist[:, mm.patch_size:, :].clone()
+                    hist[:, -mm.patch_size:, :] = latent
+
+                torch.save({"text": text, "voice": v["slot"],
+                            "z": torch.stack(zs), "history": torch.stack(hs),
+                            "noise": torch.stack(ns), "latent": torch.stack(ls)}, dst)
+                total += n
+                if i % 10 == 0:
+                    log(f"{v['slot']} {i+1}/{len(texts())} frames={n} total={total}")
+            except Exception:
+                log(f"{v['slot']} {i} failed\n{traceback.format_exc()}")
+            if SMOKE and i >= 4:
+                break
+    log(f"traj done: {total} frames")
+
+
+def load_dataset():
+    import torch
+
+    zs, hs, ns, ls = [], [], [], []
+    for path in sorted(TRAJ.glob("*/*.pt")):
+        row = torch.load(path, map_location="cpu", weights_only=False)
+        zs.append(row["z"]); hs.append(row["history"])
+        ns.append(row["noise"]); ls.append(row["latent"])
+    if not zs:
+        raise RuntimeError("no trajectories")
+    z, h, n, l = (torch.cat(x).float() for x in (zs, hs, ns, ls))
+    log(f"dataset: {z.shape[0]} frames from {len(zs)} files")
+    return z, h, n, l
+
+
+def train_student(teacher, data, n_steps, device):
+    import copy
+    import torch
+    import torch.nn.functional as F
+
+    z, h, n, target = [x.to(device) for x in data]
+    count = z.shape[0]
+    student = copy.deepcopy(teacher).to(device).train()
+    for p in student.parameters():
+        p.requires_grad_(True)
+    opt = torch.optim.AdamW(student.parameters(), lr=LR, weight_decay=0.01)
+    times = torch.linspace(0, 1, n_steps + 1).tolist()
+    losses = []
+    for step in range(TRAIN_STEPS):
+        idx = torch.randint(0, count, (min(BATCH, count),), device=device)
+        bz, bh = z[idx].unsqueeze(1), h[idx]
+        bn, bt = n[idx].unsqueeze(1), target[idx].unsqueeze(1)
+        y = bn
+        loss = 0.0
+        for i in range(n_steps):
+            ti, dt = times[i], times[i + 1] - times[i]
+            with torch.no_grad():
+                pred_cfg = teacher.forward_with_cfg(
+                    x=y, t=torch.tensor(float(ti), device=device), c=bz,
+                    latent_history=bh, patch_size=1,
+                )
+                pred, null = torch.chunk(pred_cfg, 2, dim=0)
+                tv = pred + (pred - null) * CFG_MULT
+            sv = student(
+                x=y, t=torch.full((y.shape[0],), float(ti), device=device),
+                c=bz, latent_history=bh, mask=None,
+            )[:, -1:, :]
+            loss = loss + F.mse_loss(sv, tv) * dt
+            y = (y + sv * dt).detach()
+        loss = loss + 0.5 * F.mse_loss(y, bt)
+        opt.zero_grad(set_to_none=True)
+        loss.backward()
+        torch.nn.utils.clip_grad_norm_(student.parameters(), 1.0)
+        opt.step()
+        losses.append(float(loss.detach().cpu()))
+        if step % 100 == 0 or step == TRAIN_STEPS - 1:
+            log(f"train {step+1}/{TRAIN_STEPS} loss={losses[-1]:.5f}")
+    student.eval()
+    return student, losses
+
+
+class _unused:
+    pass
+
+
+def export_onnx(student, path: Path):
+    import copy
+    import torch
+
+    class Graph(torch.nn.Module):
+        def __init__(self, dit):
+            super().__init__()
+            self.dit = dit
+
+        def forward(self, x, t, c, history):
+            return self.dit(x=x, t=t, c=c, latent_history=history, mask=None)[:, -1:, :]
+
+    g = Graph(copy.deepcopy(student).float()).cpu().eval()
+    x = torch.randn(1, 1, 64); t = torch.tensor([0.5])
+    c = torch.randn(1, 1, 896); h = torch.randn(1, 1, 64)
+    with torch.inference_mode():
+        ref = g(x, t, c, h)
+        torch.onnx.export(g, (x, t, c, h), str(path),
+                          input_names=["x", "t", "c", "history"],
+                          output_names=["velocity"], opset_version=20,
+                          do_constant_folding=True, dynamo=False)
+    import onnxruntime as ort
+    sess = ort.InferenceSession(str(path), providers=["CPUExecutionProvider"])
+    got = sess.run(None, {"x": x.numpy(), "t": t.numpy(), "c": c.numpy(), "history": h.numpy()})[0]
+    err = float(np.abs(ref.numpy().reshape(-1) - got.reshape(-1)).max())
+    log(f"{path.name} {path.stat().st_size/1e6:.1f}MB max_abs={err:.2e}")
+    return err
+
+
+def quantize(src: Path, dst: Path) -> None:
+    from onnxruntime.quantization.matmul_nbits_quantizer import MatMulNBitsQuantizer
+
+    q = MatMulNBitsQuantizer(str(src), bits=4, block_size=32, is_symmetric=True,
+                             accuracy_level=4, op_types_to_quantize=("MatMul",))
+    q.process()
+    q.model.save_model_to_file(str(dst), use_external_data_format=False)
+    log(f"{dst.name} {dst.stat().st_size/1e6:.1f}MB")
+
+
+def sample_latent(dit, z, hist, noise, n_steps):
+    import torch
+
+    y = noise
+    for i in range(n_steps):
+        dt = 1.0 / n_steps
+        v = dit(x=y, t=torch.full((y.shape[0],), i / n_steps, device=y.device),
+                c=z, latent_history=hist, mask=None)[:, -1:, :]
+        y = y + v * dt
+    return y
+
+
+def ar_generate(mm, dit, n_steps, text, task_prompt, prompt_latent, prompt_text, spk, frames):
+    import torch
+
+    device = next(mm.parameters()).device
+    dtype = next(mm.parameters()).dtype
+    with torch.no_grad():
+        input_ids, inputs_embeds = mm.prepare_input_embed(
+            prompt=task_prompt, text=text, spk_emb=spk,
+            prompt_latent=prompt_latent, prompt_text=prompt_text,
+        )
+    attention_mask = torch.ones(input_ids.shape, device=device)
+    position_ids = (attention_mask.cumsum(-1) - 1).masked_fill_(attention_mask == 0, 1)
+    past = None
+    hist = torch.zeros(1, mm.history_patch_size, mm.latent_dim, device=device, dtype=dtype)
+    start = mm.history_patch_size - prompt_latent.size(1)
+    if start < 0:
+        hist[:] = prompt_latent[:, -start:, :]
+    else:
+        hist[:, start:, :] = prompt_latent
+    out = []
+    for _ in range(frames):
+        with torch.no_grad():
+            hidden = mm.model(attention_mask=attention_mask, position_ids=position_ids,
+                              inputs_embeds=inputs_embeds, audio_mask=None, image_mask=None,
+                              output_hidden_states=True, return_dict=True, use_cache=True,
+                              past_key_values=past)
+        past = hidden.past_key_values
+        z = hidden.hidden_states[-1][:, -1:, :]
+        noise = torch.randn(1, 1, mm.latent_dim, device=device, dtype=dtype)
+        latent = sample_latent(dit, z, hist, noise, n_steps).to(device=device, dtype=dtype)
+        out.append(latent)
+        inputs_embeds = mm.linear_proj_audio(latent)
+        position_ids = position_ids[:, -1:] + 1
+        attention_mask = torch.ones(inputs_embeds.shape[0], 1, device=device)
+        hist[:, :-mm.patch_size, :] = hist[:, mm.patch_size:, :].clone()
+        hist[:, -mm.patch_size:, :] = latent
+    with torch.no_grad():
+        speech = mm.audio.decode(torch.cat(out, dim=1), past_key_values=None,
+                                 use_cache=False, last_chunk=True)[0]
+    return speech.cpu().float().reshape(-1).numpy()
+
+
+def stage_eval() -> None:
+    import copy
+    import torch
+    from transformers import pipeline
+
+    sys.path.insert(0, str(REPO))
+    from ming_tts import MingTTS
+    import tts_tasks
+    sys.path.insert(0, str(BUNDLE / "eval"))
+    from score import load_t2s, score_row
+
+    table = load_t2s()
+    task_prompt = tts_tasks.build_tts_prompt("Chinese")
+    ckpt = OUT / f"student{STEPS}.pt"
+    state = {k: v.float() for k, v in torch.load(ckpt, map_location="cpu").items()}
+
+    tts = MingTTS(str(MODEL), device="cuda", text_normalization=False)
+    mm = tts.model
+    device = next(mm.parameters()).device
+    teacher = mm.flowloss.cfm.model.float().eval()
+    student = copy.deepcopy(teacher)
+    student.load_state_dict(state)
+    student = student.to(device).eval()
+
+    asr_pipe = pipeline("automatic-speech-recognition", model="openai/whisper-small",
+                        device=0, torch_dtype=torch.float16)
+
+    def asr(y):
+        out = asr_pipe({"array": y.astype(np.float32), "sampling_rate": 44100},
+                       generate_kwargs={"language": "zh", "task": "transcribe"})
+        return (out.get("text", "") if isinstance(out, dict) else str(out)).strip()
+
+    sents = json.loads((BUNDLE / "eval/sentences.json").read_text())["items"]
+    want = EVAL_VOICES or [v["slot"] for v in voices()[:2]]
+    rows = []
+    for v in [x for x in voices() if x["slot"] in want]:
+        latent, spk = tts.prepare_prompt(str(BUNDLE / v["wav"]), use_spk_emb=True)
+        latent = latent.to(device=device, dtype=next(mm.parameters()).dtype)
+        spk = [x.to(device=device, dtype=next(mm.parameters()).dtype) for x in spk]
+        for item in sents:
+            text = item["text"]
+            try:
+                tw = tts.synthesize(task="TTS", text=text, language_id="Chinese",
+                                    prompt_wav_path=str(BUNDLE / v["wav"]),
+                                    prompt_text=v["prompt_text"], use_spk_emb=True,
+                                    raw_text=True, max_decode_steps=max(32, min(400, int(len(text) * 3.5))))
+                tw = tw.cpu().numpy().reshape(-1)
+                frames = max(16, int(round(tw.size / 3528)))
+                torch.manual_seed(SEED)
+                sw = ar_generate(mm, student, STEPS, text, task_prompt, latent,
+                                 v["prompt_text"], spk, frames)
+                for name, arr in (("teacher", tw), ("student", sw)):
+                    hyp = asr(arr)
+                    s = score_row({"text": text, "hyp_text": hyp}, table)
+                    rows.append({"voice": v["slot"], "artist": v["artist"], "id": item["id"],
+                                 "model": name, "text": text, "cer": s["cer_norm"],
+                                 "cer_head": s["cer_prefix"], "hyp": hyp})
+            except Exception:
+                log(f"eval {v['slot']} {item['id']} failed\n{traceback.format_exc()}")
+        log(f"eval {v['slot']} done ({len(rows)} rows)")
+
+    (OUT / "eval_rows.json").write_text(json.dumps(rows, ensure_ascii=False, indent=1))
+    for name in ("teacher", "student"):
+        sel = [r for r in rows if r["model"] == name]
+        if sel:
+            log(f"{name:<8} n={len(sel)} cer={np.mean([r['cer'] for r in sel]):.4f} "
+                f"head={np.mean([r['cer_head'] for r in sel]):.4f}")
+        for v in sorted({r["voice"] for r in sel}):
+            vs = [r["cer"] for r in sel if r["voice"] == v]
+            log(f"   {v} n={len(vs)} cer={np.mean(vs):.4f}")
+
+
+def main() -> None:
+    import torch
+
+    torch.manual_seed(SEED)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed_all(SEED)
+    device = torch.device("cuda")
+
+    if STAGE == "traj":
+        patch_fp32()
+        stage_traj()
+        return
+
+    sys.path.insert(0, str(REPO))
+    patch_fp32()
+    from ming_tts import MingTTS
+    tts = MingTTS(str(MODEL), device="cuda", text_normalization=False)
+    mm = tts.model
+
+    if STAGE in ("train", "all"):
+        data = load_dataset()
+        teacher = mm.flowloss.cfm.model.float().to(device).eval()
+        for p in teacher.parameters():
+            p.requires_grad_(False)
+        student, losses = train_student(teacher, data, STEPS, device)
+        torch.save({k: v.half().cpu() for k, v in student.state_dict().items()},
+                   OUT / f"student{STEPS}.pt")
+        (OUT / "train_loss.json").write_text(json.dumps({"first": losses[0], "last": losses[-1],
+                                                         "steps": TRAIN_STEPS, "lr": LR}))
+        log(f"saved student{STEPS}.pt loss {losses[0]:.4f} -> {losses[-1]:.4f}")
+
+    if STAGE in ("export", "all"):
+        student = copy_state(mm, OUT / f"student{STEPS}.pt", device) if STAGE == "export" else student
+        fp32 = OUT / f"dit{STEPS}.onnx"
+        export_onnx(student, fp32)
+        quantize(fp32, OUT / f"dit{STEPS}_int4.onnx")
+
+    if STAGE in ("eval", "all"):
+        stage_eval()
+
+
+def copy_state(mm, path, device):
+    import copy
+    import torch
+
+    state = {k: v.float() for k, v in torch.load(path, map_location="cpu").items()}
+    dit = copy.deepcopy(mm.flowloss.cfm.model.float())
+    dit.load_state_dict(state)
+    return dit.to(device).eval()
+
+
+if __name__ == "__main__":
+    main()
+

train_texts.json

@@ -0,0 +1,127 @@
+{
+ "seed": 20261030,
+ "source": "books/story.txt",
+ "n": 120,
+ "texts": [
+  "‘大王是向来善于猜疑，又极残忍的。",
+  "巡士反背着手，看他渐跑渐远，没入尘头中，这才慢慢的回转身，向原来的路上踱去。",
+  "O.K美国式的英语：“对啦。",
+  "”老子再三称谢，收了口袋，和大家走下城楼，到得关口，还要牵着青牛走路；",
+  "“这模样了，还要来攻它！",
+  "特别的寂静倒使殿上殿下的人们警醒。",
+  "前面并没有仪仗，不过一大批乞丐似的随员。",
+  "谓其妻曰：‘吾藏剑在南山之阴，北山之阳；",
+  "”他说着，又看看网兜里的母鸡，倒并没有压坏，便跨上马，径自走了。",
+  "）阿金姐作者虚拟的人名。",
+  "现在谁都讲卫生，卫生是顶要紧的。",
+  "”他看见他的母亲坐在灰白色的月影中，仿佛身体都在颤动；",
+  "于是轰轰了一阵，屋里逐渐坐满了听讲的人们。",
+  "我庄周曾经做梦变了蝴蝶，是一只飘飘荡荡的蝴蝶，醒来成了庄周，是一个忙忙碌碌的庄周。",
+  "不过……”孔子很有些焦躁模样，这是他从来所没有的。",
+  "指物件，含有轻蔑、厌恶的意思。",
+  "口渴可不是玩意儿呀，真不如化为蝴蝶。",
+  "我是有正经事，探亲去的。",
+  "“三弟，有什么捞儿没有？",
+  "六樵夫偶然发见了伯夷和叔齐都缩做一团，死在山背后的石洞里，是大约这之后的二十天。",
+  "公孙高古书中无可查考，当是作者虚拟的人名。",
+  "’子墨子归，过宋，天雨，庇其闾中，守闾者不内（纳）也。",
+  "大家只得停住，等候她的到来。",
+  "然而这诧异使伊喜欢，以未曾有的勇往和愉快继续着伊的事业，呼吸吹嘘着，汗混和着……“Nga！",
+  "人迹绝了许久之后，忽然从城里闪出那一个黑色的人来。",
+  "我看你也还不如收拾收拾，回家看看你的老婆去罢。",
+  "……”文盲们不大懂得他的议论，但看见声势汹汹，知道一定是反对的意思，也只好作罢了。",
+  "真是对不起得很，我要捞青苔去了，等您上了呈子之后，我再来投案罢。",
+  "只在文化山上，还聚集着许多学者，他们的食粮，是都从奇肱国用飞车运来的，因此不怕缺乏，因此也能够研究学问。",
+  "杀缺少的来争有余的，不能说是智；",
+  "非攻一子夏的徒弟公孙高来找墨子，已经好几回了，总是不在家，见不着。",
+  "于是也只好重行归并，作为疑案了。",
+  "要知道活就是死，死就是活呀，奴才也就是主人公。",
+  "尧爷的时候，我曾经射死过几匹野猪，几条蛇……。",
+  "这消息一传到村子里，又哄动了一大批来看的人，来来往往，一直闹到夜。",
+  "武王使师尚父与百夫致师，以大卒驰帝纣师。",
+  "但他是一个世上无二的铸剑的名工。",
+  "”又《史记·夏本纪》也说：“禹行自冀州始。",
+  "这是我家最好的母鸡，天天生蛋。",
+  "他们的东西，却不但‘怨’，简直‘骂’了。",
+  "你还该记得罢，丈母的门前就常有黑熊走过，叫我去射了好几回……。",
+  "花白了胡子，还是想不通。",
+  "）逢蒙我国古代善射的人，相传他是羿的弟子。",
+  "剥树皮不可剥光，要留下一道，那么，明年春天树枝梢还是长叶子，有收成。",
+  "直到鼎里面只剩下清汤，才始住手；",
+  "别人家还拿不出这样的东西来呢。",
+  "臣以三事之攻宋也，为与此同类。",
+  "他怕那看不见的雄剑伤了人，不敢挤进去；",
+  "”太师、少师都是乐官名。",
+  "一个最有谋略的老臣独又上前，伸手向鼎边一摸，然而浑身一抖，立刻缩了回来，伸出两个指头，放在口边吹个不住。",
+  "”挂冠归隐《后汉书·逢萌传》载：王莽时逢萌为了避祸，“即解冠挂东都城门”而去。",
+  "庄子——慢慢的，慢慢的，我的衣服旧了，很脆，拉不得。",
+  "羿吃着炸酱面，自己觉得确也不好吃；",
+  "’”关于他治水事迹的传说，在《尚书》、《孟子》及其他先秦古籍中多有记述。",
+  "荆国（按即楚国）有余于地，而不足于民，杀所不足，而争所有余，不可谓智；",
+  "跑到养老堂里来，倒也罢了，可又不肯超然；",
+  "”墨子在手心上写着字，请他看了有无听错之后，这才牢牢的记在心里，谢过主人，迈开大步，径奔他所指点的处所。",
+  "”伯夷和叔齐听得清清楚楚，到了末一句，就好像一个大霹雳，震得他们发昏；",
+  "***本篇在收入《故事新编》前没有在报刊上发表过。",
+  "现在你用鉤去鉤人，人也用鉤来鉤你，你用拒去拒人，人也用拒来拒你，互相鉤，互相拒，也就等于互相害了。",
+  "那是逢蒙老爷和别人合伙射死的。",
+  "他���为那两个家伙是谈不来诗歌的。",
+  "“黄昏了，不正是私贩子爬城偷税的时候了吗？",
+  "老子像一段呆木头似的坐在中央，沉默了一会，这才咳嗽几声，白胡子里面的嘴唇在动起来了。",
+  "性不可易，命不可变，时不可止，道不可壅。",
+  "’禹拜稽首，让于契、后稷、皋陶。",
+  "”然而这竟是兜头一桶冷水，使两个人同时打了一个寒噤，但仍然不动声色，谢过老人，向着他所指示的路前行。",
+  "《左传》文公十八年：“少暤氏有不才子……天下之民谓之穷奇。",
+  "在《墨子·贵义》中有如下的一段记载：“子墨子仕人于卫，所仕者至而反。",
+  "我只要说：太太，这是我来回跑了二百里路才找来的。",
+  "“我总是这样子，”老子答道。",
+  "上真道教称修炼得道的人为真人。",
+  "连周王手里的白牛尾巴也歪了过去。",
+  "《淮南子·本经训》中记有关于苍颉的一种传说：“昔者苍颉作书而天雨粟，鬼夜哭。",
+  "”等了一会，王不耐烦地问。",
+  "结果是有几个多事的人，就地用黄土把他们埋起来，还商量立一块石碑，刻上几个字，给后来好做古迹。",
+  "“人心不古，康回实有豕心，觑天位，我后躬行天讨，战于郊，天实祐德，我师攻战无敌，殛康回于不周之山。",
+  "此后捞出来的是一团糟的白头发和黑头发；",
+  "“我用爱来鉤，用恭来拒。",
+  "二十年前，王妃生下了一块铁，听说是抱了一回铁柱之后受孕的，是一块纯青透明的铁。",
+  "“早该知道这正是你的话。",
+  "购求甚急，乃逃朱兴山中。",
+  "义不杀少，然而杀多，不能说是知类。",
+  "……”大家彼此面面相觑，没有抄。",
+  "他的母亲站起了，揭去床头的木板，下床点了松明，到门背后取过一把锄，交给眉间尺道：“掘下去！",
+  "……’帝曰：‘毋若丹朱傲，维慢游是好，毋水行舟，朋淫于家，用绝其世，予不能顺是。",
+  "金玉的粉末指道士服食的丹砂金玉之类的东西，道士认为服食后可以长生不老。",
+  "首先是一乘白彩的大轿，总该有八十一人抬着罢，里面一座木主，写的是‘大周文王之灵位’；",
+  "大家定了定神，便在殿门外商议打捞办法。",
+  "伊恐怕那些山碰了自己的脚，便伸手将他们撮住，望那山坳里，还伏着许多未曾见过的东西。",
+  "泥点也就暴雨似的从藤身上飞溅开来，还在空中便成了哇哇地啼哭的小东西，爬来爬去的撒得满地。",
+  "鬼魂——那么，就给你当场出丑……庄子——楚王的圣旨在我头上，更不怕你们小鬼的起哄！",
+  "于是取了绳子，穿起木札来，计两串，扶着拄杖，到关尹喜的公事房里去交稿，并且声明他立刻要走的意思。",
+  "“唉唉，我从来没有这样的无聊过。",
+  "）庄子——（高兴起来，）不错！",
+  "他一看见，便大声的喝道：“先生不见客！",
+  "庄子（约前369—前286）名周，战国时宋国人，曾为漆园吏，我国古代思想家，道家思想的代表人物。",
+  "伯夷和叔齐的丧事，就这样的算是告了一段落。",
+  "”然而关于禹爷的新闻，也和珍宝的入京一同多起来了。",
+  "午后，国王一起身，就又有些不高兴，待到用过午膳，简直现出怒容来。",
+  "”“你不能用小一点的箭头的么？",
+  "“王升到姚家找太太去了。",
+  "”当主客谈笑之间，午餐也摆好了，有鱼，有肉，有酒。",
+  "《周本纪》说他“笃仁，敬老，慈少”。",
+  "“大王，”那黑色人半跪着说。",
+  "简放古代君主任命高级官员。",
+  "”“我们那里有钱呢，大王。",
+  "”他一面大笑，一面站了起来，“又是引经据典。",
+  "’”阿廉作者虚拟的人名。",
+  "我是达性命之源的，可不受你们小鬼的运动。",
+  "兽炭古时豪富之家将木炭屑做成各种兽形的一种燃料。",
+  "……天之报施善人，其何如哉？",
+  "分见《墨子》中的《耕柱》、《鲁问》、《公输》等篇。",
+  "第三天是学者们公请在最高峰上赏偃盖古松，下半天又同往山背后钓黄鳝，一直玩到黄昏。",
+  "我鉤强：我鉤之以爱，揣之以恭。",
+  "”两人就笑嘻嘻的来尝烤薇菜；",
+  "幸而她撒娇坐在他的御膝上，特别扭了七十多回，这才使龙眉之间的皱纹渐渐地舒展。",
+  "“况且，”老臣们向太监说，“大王的后枕骨是这么尖的么？",
+  "“你们是受了谣言的骗的。",
+  "还是换一换便当……”“可以可以，”墨子也诚恳的说。"
+ ]
+}