initial processing pipeline

.gitignore

@@ -0,0 +1,5 @@
+__pycache__/
+/.vscode/
+
+/conversation/
+/scenario*/

README.md

@@ -0,0 +1,49 @@
+---
+pretty_name: 夜羊L系列简中脚本
+language:
+- zh
+language_details: zho_Hans
+license: cc-by-nc-4.0
+annotations_creators:
+- expert-generated
+- machine-generated
+task_categories:
+- conversational
+- text-generation
+---
+
+> 睡不着的夜晚和不想睡觉的夜晚
+
+## ⚠️注意
+
+- **请注意，数据来自 R18 的视觉小说，并且包含可能被认为是不适当、令人震惊、令人不安、令人反感和极端的主题。如果您不确定在您的国家拥有任何形式的虚构文字内容的法律后果，请不要下载。**
+- **本项目内的所有数据及基于这些数据的衍生作品禁止用作商业性目的。** 我不拥有 `scenario-raw` 里的 krkr2 脚本源文件，而其余的数据处理方法按照 CC BY-NC 4.0 协议开放。
+- 按照数据预处理的先后次序，依次是：`scenario-raw` 里是 krkr2 脚本源文件，`scenario` 里是清理后的结构化脚本，`conversation` 里是我主观分段制作的对话格式数据。
+- 对于主观分段，一部分是手动的，其余是基于文本相似度的不太靠谱自动分段（我还没推的那部分，我不想被剧透啊啊啊）。手动分段道且阻且长，慢慢做吧，进度记录在 [manual_seg-progress.md](manual_seg-progress.md)。
+- 2015-2017 的前四作是单女主，后面的作品都是双女主的，脚本格式也略微不同。
+- 🔑 压缩包已加密，解压密码是 yorunohitsuji
+
+## 感谢数据源背后的汉化组们
+
+- 与小萝莉相思相爱：脸肿汉化组
+- 勾指婚约洛丽塔：守夜人汉化组&7/9工作室
+- 与小萝莉相思相爱的生活：脸肿汉化组
+- 同居恋人洛丽塔：守夜人汉化组
+- 双子洛丽塔后宫：靴下汉化组x仓库汉化组
+- 爱欲姐妹洛丽塔：守夜人汉化组
+- 诱惑自大洛丽塔：守夜人汉化组
+- 每日亲吻洛丽塔：比喵个人汉化
+
+## 给我自己看的预处理流程
+
+0. 各作的脚本提取出来放在 `scenario-raw/` 里，用 `script/transcode.sh` 转成 UTF-8，`2015-sssa` 额外需要 `script/dos2unix.sh` 转成 LF
+1. 修复格式小问题 `cd scenario-raw && bash patch.sh`
+2. 运行 `python ks-parse-all.py` 得到 `scenario/`
+3. 分段，再转成 `conversation/`
+    a. 自动分段：`python -m segment.auto path/to/scenario.jsonl`
+    b. 手动分段后，`python -m segment.manual path/to/scenario-manual_seg.jsonl`
+
+添加新卷：
+
+0. 脚本放在 `scenario-raw/` 里
+1. 在 `ks-parse-all.py` 里添加新卷的元数据

changelog.md

@@ -0,0 +1,5 @@
+
+### 2024-02-01 - 夜如何其？
+
+- 发布了数据处理的代码。
+- 第一版的数据。前四部的手动分段完成一小半；后四部的手动分段还刚刚开始。

ks-parse-all.py

@@ -0,0 +1,36 @@
+from ks_parse.__main__ import parse_file
+
+from attrs import define, Factory
+
+from pathlib import Path
+
+
+@define
+class Volume:
+    name: str
+    stype: str
+    # ロリ妊娠はダメ、下江コハル.jpg
+    ignore_list: list[str] = Factory(list)
+
+
+ALL_VOLUMES = [
+    Volume(name="2015-sssa", stype="novel"),
+    Volume(name="2016a-yubikiri", stype="novel", ignore_list=["C000"]),
+    Volume(name="2016b-sssa2", stype="novel"),
+    Volume(name="2017-otomari", stype="novel", ignore_list=["C000"]),
+    Volume(name="2018-harem", stype="adv", ignore_list=["Z000"]),
+    Volume(name="2019-aiyoku", stype="adv", ignore_list=["B003_2", "Z000"]),
+    Volume(name="2020-yuuwaku", stype="adv", ignore_list=["B000"]),
+    Volume(name="2022-mainichi", stype="adv", ignore_list=["Z000"]),
+]
+BASE = Path("./scenario-raw")
+
+if __name__ == "__main__":
+    for vol in ALL_VOLUMES:
+        print(f"Processing {vol.name}...", end="")
+        for ks_path in sorted((BASE / vol.name).glob("*.ks")):
+            if ks_path.stem in vol.ignore_list:
+                continue
+            print(f" {ks_path.stem}", end="")
+            parse_file(ks_path, vol.stype)
+        print()

ks_parse/__main__.py

@@ -0,0 +1,32 @@
+from .ks import parse
+
+from attrs import asdict
+
+from sys import argv
+from pathlib import Path
+import json
+
+
+def parse_file(ks_path: Path, stype: str):
+    ks_name = f"{ks_path.parent.name}/{ks_path.stem}"
+
+    output_base = Path("./scenario")
+    output_base.mkdir(exist_ok=True)
+    (output_base / ks_path.parent.name).mkdir(exist_ok=True)
+
+    with ks_path.open("r") as fi:
+        chapters = parse(fi, stype)
+        for i, ch in enumerate(chapters):
+            with (output_base / f"{ks_name}-{i:02d}.jsonl").open("w") as fo:
+                json.dump({"title": ch.title}, fo, ensure_ascii=False)
+                print(file=fo)
+                for utt in ch.content:
+                    json.dump(asdict(utt), fo, ensure_ascii=False)
+                    print(file=fo)
+
+
+if __name__ == "__main__":
+    if len(argv) != 3:
+        print(f"Usage: python -m {__package__} path/to/script.ks novel|adv")
+        exit(1)
+    parse_file(Path(argv[1]), argv[2])

ks_parse/chapter.py

@@ -0,0 +1,29 @@
+from attrs import define
+
+
+import re
+from typing import Iterable, Callable
+
+TAG = re.compile(r"\[(.+?)\]")
+# I hope there are no nested tags in the script...
+
+
+@define
+class Utterance:
+    speaker: str
+    text: str
+
+
+@define
+class Chapter:
+    title: str
+    content: Iterable[Utterance]
+
+
+type ChapterParser = Callable[[Iterable[str]], Iterable[Utterance]]
+
+
+def clean_tag(line: str) -> str:
+    line = TAG.sub("", line.strip())
+    line = line.replace("　", "")  # Remove full-width spaces
+    return line

ks_parse/chapter_adv.py

@@ -0,0 +1,51 @@
+from .chapter import Utterance, clean_tag
+
+import re
+from typing import Iterable
+
+TAG_SPEAKER = re.compile(r"\[speaker name=\"(.+)\"\]")
+
+
+def parse(lines: Iterable[str]) -> Iterable[Utterance]:
+    """Parsing Kirikiri2 script chapters of newer format,
+    which are distinguished by the presence of a `[startadv]` tag.
+
+    Most of `[r]` tags are implict.
+    Speaker names are now annotated with `[speaker]` tags.
+    There could be multiple heroines. (Well, for Yoru no Hitsuji, there are two.)
+    Lines start with left quotation marks; otherwise they are narration.
+    Pages only occupy the lower quarter of the screen, and page breaks are usually per sentence.
+    Let's take whiteout/blackout scene changes as significant divisors.
+    """
+
+    speaker = None
+    scene_change = False
+    for line in lines:
+        if line.startswith(";"):
+            continue
+        if line.startswith("[speaker"):
+            match = TAG_SPEAKER.search(line)
+            if match is None:
+                raise ValueError(f"Invalid speaker tag: {line}")
+            speaker = match.group(1)
+            continue
+        scene_change |= "[msgv]" in line
+
+        line = clean_tag(line)
+        if not line:
+            continue
+        if speaker is not None and not line.startswith("「"):
+            # raise ValueError(f"Speaker tag not followed by a line: {line}")
+            # 2022-mainichi does not keep this rule consistently
+            line = "「" + line
+            if not line.endswith("」"):
+                line += "」"
+
+        if speaker is not None:
+            yield Utterance(speaker=speaker, text=line)
+            speaker = None
+        else:
+            yield Utterance(speaker="narrator", text=line)
+        if scene_change:
+            yield Utterance(speaker="(scene change)", text="")
+            scene_change = False

ks_parse/chapter_novel.py

@@ -0,0 +1,42 @@
+from .chapter import Utterance, clean_tag
+
+from typing import Iterable
+
+
+def parse(lines: Iterable[str]) -> Iterable[Utterance]:
+    """Parsing Kirikiri2 script chapters of older format,
+    which are distinguished by the presence of a `[startnovel]` tag.
+
+    Formatting is done almost exclusively with `[r]`, `[l]`, and `[p]` tags.
+    There are only one heroine and one male protagonist,
+    and the heroine's lines can be recognized by the `[voice]` tag in the preceding line.
+    Lines start with left quotation marks; narration starts with spaces.
+    Whiteout/blackout scene changes are significant divisors.
+    """
+
+    heroine_line = False
+    scene_change = False
+    for line in lines:
+        if line.startswith(";"):
+            continue
+        if "[voice" in line:
+            heroine_line = True
+            continue
+        scene_change |= "[msgv]" in line
+
+        line = clean_tag(line)
+        if not line:
+            continue
+        if heroine_line and not line.startswith("「"):
+            raise ValueError(f"Voice tag not followed by heroine line: {line}")
+
+        if line.startswith("「"):
+            yield Utterance(
+                speaker="heroine" if heroine_line else "protagonist", text=line
+            )
+            heroine_line = False
+        else:
+            yield Utterance(speaker="narrator", text=line)
+        if scene_change:
+            yield Utterance(speaker="(scene change)", text="")
+            scene_change = False

ks_parse/ks.py

@@ -0,0 +1,36 @@
+from .chapter import Chapter, ChapterParser
+from .chapter_novel import parse as parse_chapter_novel
+from .chapter_adv import parse as parse_chapter_adv
+
+from typing import Iterable
+
+
+def parse(lines: Iterable[str], stype: str) -> Iterable[Chapter]:
+    """Entry point for parsing Kirikiri2 scripts"""
+
+    cparser: ChapterParser
+    match stype:
+        case "novel":
+            cparser = parse_chapter_novel
+        case "adv":
+            cparser = parse_chapter_adv
+        case _:
+            raise ValueError(f"Unknown script type: {stype}")
+
+    for line in lines:
+        if line.startswith("*"):
+            break
+
+    chunk = []
+    eof = False
+    while not eof:
+        ch = Chapter(title=line.removeprefix("*").strip(), content=[])
+        for line in lines:
+            if line.startswith("*"):
+                break
+            chunk.append(line)
+        else:
+            eof = True
+        ch.content = cparser(chunk)
+        chunk = []
+        yield ch

manual_seg-progress.md

@@ -0,0 +1,26 @@
+
+- [ ] 2015-sssa
+    - [x] A000
+    - [x] A001
+    - [x] A002
+    - [x] A003
+    - [ ] A004
+    - [ ] B000
+    - [ ] B001
+    - [ ] B002
+    - [ ] Z000
+    - [ ] Z001
+- [ ] 2016a-yubikiri
+- [x] 2016b-sssa2
+- [ ] 2017-otomari
+- [ ] 2018-harem
+    - [x] A000
+    - [x] A001
+    - [x] B000
+    - [ ] B001
+    - [ ] B002
+    - [ ] B003
+    - [ ] B004
+- [ ] 2019-aiyoku
+- [ ] 2020-yuuwaku
+- [ ] 2022-mainichi

script/dos2unix.sh

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+
+BASE=$1
+
+for f in $BASE/*.ks; do
+	perl -pe 's/\r\n|\n|\r/\n/g' $f > $f.tmp  # for 2015-sssa
+	mv $f.tmp $f
+done

script/transcode.sh

@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+
+BASE=$1
+
+for f in $BASE/*.ks; do
+	iconv -f unicode -t utf-8 < $f > $f.tmp
+	#iconv -f gbk -t utf-8 < $f > $f.tmp  # for 2016a-yubikiri-old
+	mv $f.tmp $f
+done
+

segment/auto/__main__.py

@@ -0,0 +1,100 @@
+"""Automatically segment the scenario into the final conversation format.
+SentenceTransformer embeddings + classifier
+
+e.g. from scenario/volume1/chapter1.jsonl:
+{"title": "..."}
+{"speaker": "(scene change)", "text": ""}
+{"speaker": "narrator", "text": "..."}
+{"speaker": "narrator", "text": "..."}
+{"speaker": "heroine", "text": "..."}
+{"speaker": "protagonist", "text": "..."}
+{"speaker": "heroine", "text": "..."}
+{"speaker": "protagonist", "text": "..."}
+...
+
+to conversation/volume1/chapter1.json:
+{
+  "title": "...",
+  "conversation": [
+    {
+      "request": [
+        {"speaker": "narrator", "text": "..."},
+        {"speaker": "narrator", "text": "..."},
+      ],
+      "response": [
+        {"speaker": "heroine", "text": "..."}
+      ]
+    },
+    {
+      "request": [
+        {"speaker": "protagonist", "text": "..."}
+      ],
+      "response": [
+        {"speaker": "heroine", "text": "..."}
+      ]
+    },
+    {
+      "request": [
+        {"speaker": "protagonist", "text": "..."},
+...
+"""
+from .classifier import train_classifier, label_scenario, Predictor
+from ..utils import dump_conversation, map_to_file_or_dir
+
+from sys import argv
+from pathlib import Path
+from itertools import chain
+import re
+
+
+def train(target_name: str) -> Predictor:
+    if re.search(r"201[567]", target_name) is not None:
+        tset = Path("./conversation-manual").glob("201[567]*/*.json")
+        print("Training on 2015-2017")
+    else:
+        tset = chain(
+            Path("./conversation-manual").glob("201[89]*/*.json"),
+            Path("./conversation-manual").glob("202[02]*/*.json"),
+        )
+        print("Training on 2018-2022")
+    return train_classifier(tset)
+
+
+def generate_seg(s_path: Path, model: Predictor):
+    ks_name = f"{s_path.parent.name}/{s_path.stem}"
+
+    output_base = Path("./conversation")
+    output_base.mkdir(exist_ok=True)
+    (output_base / s_path.parent.name).mkdir(exist_ok=True)
+
+    entries, labels, title = label_scenario(s_path, model)
+    # make sure to start with request and end with response
+    labels[0], labels[-1] = 0, 1
+
+    # Generate the conversation request-response pairs
+    key = "request"
+    current_round = dict(request=[], response=[])
+    conversation = []
+    for entry, label in zip(entries, labels):
+        if label == 0:  # request
+            if key == "response":
+                conversation.append(current_round)
+                current_round = dict(request=[], response=[])
+                key = "request"
+        else:  # response
+            if key == "request":
+                key = "response"
+        current_round[key].append(entry)
+    conversation.append(current_round)
+
+    dump_conversation(
+        {"title": title, "conversation": conversation}, output_base / f"{ks_name}.json"
+    )
+
+
+if __name__ == "__main__":
+    if len(argv) != 2:
+        print(f"Usage: python -m {__package__} path/to/scenario.jsonl")
+        exit(1)
+    model = train(argv[1])
+    map_to_file_or_dir(generate_seg, Path(argv[1]), model)

segment/auto/classifier.py

@@ -0,0 +1,77 @@
+from ..utils import is_protagonist
+from .similarity import batch_embedding
+
+import numpy as np
+from sklearn.ensemble import RandomForestClassifier
+
+from pathlib import Path
+import json
+from typing import Protocol, Iterable
+
+
+class Predictor(Protocol):
+    def predict(self, X: np.ndarray) -> np.ndarray:
+        ...
+
+
+def conversation_embedding_label(c_path: Path) -> tuple[np.ndarray, np.ndarray]:
+    """Get embedding and label from narrator lines in a segmented conversation."""
+    d = json.loads(c_path.read_text())
+    conv, label, narr_mask = [], [], []
+    for pair in d["conversation"]:
+        for entry in pair["request"]:
+            conv.append(entry)
+            label.append(0)
+            narr_mask.append(entry["speaker"] == "narrator")
+        for entry in pair["response"]:
+            conv.append(entry)
+            label.append(1)
+            narr_mask.append(entry["speaker"] == "narrator")
+
+    em = batch_embedding(conv)
+    return em[narr_mask], np.array(label)[narr_mask]
+
+
+def train_classifier(c_paths: Iterable[Path]) -> Predictor:
+    """Train a classifier to classify narrator lines as request or response."""
+    em, label = [], []
+    for c_path in c_paths:
+        em_, label_ = conversation_embedding_label(c_path)
+        em.append(em_)
+        label.append(label_)
+    em = np.concatenate(em)
+    label = np.concatenate(label)
+
+    model = RandomForestClassifier()
+    model.fit(em, label)
+    print(f"Accuracy: {model.score(em, label)}")
+    return model
+
+
+def label_scenario(
+    s_path: Path, model: Predictor
+) -> tuple[list[dict], np.ndarray, str]:
+    """Label lines for a unsegmented scenario chapter."""
+    conv, role = [], []
+    with s_path.open("r") as fi:
+        title = json.loads(next(fi))["title"]
+        for line in fi:
+            entry = json.loads(line)
+            if entry["speaker"] == "(scene change)":
+                continue  # not recording scene change, since the plots are usually connected
+            conv.append(entry)
+            if entry["speaker"] == "narrator":
+                role.append(2)
+            elif is_protagonist(entry["speaker"]):
+                role.append(0)
+            else:  # heroine
+                role.append(1)
+
+    role = np.array(role)
+    label = np.empty_like(role, dtype=int)
+    em = batch_embedding(conv)
+    label[role == 0] = 0
+    label[role == 1] = 1
+    label[role == 2] = model.predict(em[role == 2])
+
+    return conv, label, title

segment/auto/similarity.py

@@ -0,0 +1,34 @@
+from ..utils import is_protagonist
+
+from sentence_transformers import SentenceTransformer
+import numpy as np
+
+model = SentenceTransformer("moka-ai/m3e-base")
+
+
+def sentence_embedding(s: list[str]) -> np.ndarray:
+    """Compute the sentence embedding."""
+    return model.encode(s, convert_to_tensor=True).cpu().numpy()
+
+
+def batch_embedding(conv: list[dict]) -> np.ndarray:
+    """Compute the sentence embedding for a list of utterances."""
+    sentences = []
+    for c in conv:
+        sen = c["text"]
+        if c["speaker"] != "narrator":
+            if is_protagonist(c["speaker"]):
+                sen = f"我：{sen}"
+            else:  # heroine
+                sen = f"她：{sen}"
+        sentences.append(sen)
+
+    em = sentence_embedding(sentences)
+
+    # Take a convolution with a window size of 3 (index [-1, 0, 1], weight [0.2, 0.6, 0.2])
+    # In hope to capture some context of the sentence
+    em_conv = np.empty_like(em)
+    em_conv[1:-1] = 0.2 * em[:-2] + 0.6 * em[1:-1] + 0.2 * em[2:]
+    em_conv[0] = 0.8 * em[0] + 0.2 * em[1]
+    em_conv[-1] = 0.2 * em[-2] + 0.8 * em[-1]
+    return em_conv

segment/manual/__main__.py

@@ -0,0 +1,111 @@
+"""Parse the manual segmentation of the scenario into the final conversation format.
+
+e.g. from scenario-manual_seg/volume1/chapter1.jsonl:
+{"title": "..."}
+{"speaker": "(scene change)", "text": ""}
+{"speaker": "narrator", "text": "..."}
+{"speaker": "narrator", "text": "..."}
+
+{"speaker": "heroine", "text": "..."}
+
+{"speaker": "protagonist", "text": "..."}
+
+{"speaker": "heroine", "text": "..."}
+
+{"speaker": "protagonist", "text": "..."}
+...
+
+to conversation/volume1/chapter1.json:
+{
+  "title": "...",
+  "conversation": [
+    {
+      "request": [
+        {"speaker": "narrator", "text": "..."},
+        {"speaker": "narrator", "text": "..."},
+      ],
+      "response": [
+        {"speaker": "heroine", "text": "..."}
+      ]
+    },
+    {
+      "request": [
+        {"speaker": "protagonist", "text": "..."}
+      ],
+      "response": [
+        {"speaker": "heroine", "text": "..."}
+      ]
+    },
+    {
+      "request": [
+        {"speaker": "protagonist", "text": "..."},
+...
+"""
+from ..utils import dump_conversation, map_to_file_or_dir, is_protagonist
+
+import json
+from sys import argv
+from pathlib import Path
+from typing import TypedDict
+
+
+def generate_seg(ks_path: Path):
+    ks_name = f"{ks_path.parent.name}/{ks_path.stem}"
+
+    output_base = Path("./conversation")
+    output_base.mkdir(exist_ok=True)
+    (output_base / ks_path.parent.name).mkdir(exist_ok=True)
+
+    d = TypedDict("d", {"title": str, "conversation": list})(
+        {"title": "", "conversation": []}
+    )
+    key = "request"
+    current_round = dict(request=[], response=[])
+    current_scene = ""
+    warned = 5
+    with ks_path.open("r") as fi:
+        d["title"] = json.loads(next(fi))["title"]
+
+        for lineno, line in enumerate(fi, start=2):
+            line = line.strip()
+            if not line:  # segmentation point
+                if key == "request":
+                    key = "response"
+                else:
+                    d["conversation"].append(current_round)
+                    current_round = dict(request=[], response=[])
+                    key = "request"
+                continue
+
+            entry = json.loads(line)
+            if entry["speaker"] == "(scene change)":
+                dump_conversation(d, output_base / f"{ks_name}.json")
+                assert (
+                    not current_round["request"] and not current_round["response"]
+                ), f"Unexpected scene change at line {lineno} in {ks_path}"
+                current_scene = entry["text"]
+                continue
+            current_round[key].append(entry)
+            if current_scene:
+                current_round["scene"] = current_scene
+            if entry["speaker"] != "narrator":
+                if warned > 0 and (key == "request") != is_protagonist(
+                    entry["speaker"]
+                ):
+                    warned -= 1
+                    print(f"WARN: Unexpected speaker at line {lineno}")
+
+    if current_round["request"]:
+        assert current_round["response"], "Unexpected end of file"
+        d["conversation"].append(current_round)
+    else:
+        assert d["conversation"][-1]["response"], "Unexpected end of file"
+
+    dump_conversation(d, output_base / f"{ks_name}.json")
+
+
+if __name__ == "__main__":
+    if len(argv) != 2:
+        print(f"Usage: python -m {__package__} path/to/scenario_manual_seg.jsonl")
+        exit(1)
+    map_to_file_or_dir(generate_seg, Path(argv[1]))

segment/utils.py

@@ -0,0 +1,48 @@
+import re
+import json
+from pathlib import Path
+from typing import Callable, Concatenate
+
+ENTRY = re.compile(r"{\n\s+\"speaker\": \"(.*)\",\n\s+\"text\": \"(.*)\"\n\s+}", re.M)
+
+
+def compact_entry(output: str) -> str:
+    """
+    Collapse the following:
+            {
+              "speaker": "...",
+              "text": "..."
+            },
+    into this:
+            {"speaker": "...", "text": "..."},
+    """
+    return ENTRY.sub(r'{"speaker": "\1", "text": "\2"}', output)
+
+
+def dump_conversation(conversation, output_path: Path):
+    with output_path.open("w") as fo:
+        output = json.dumps(conversation, ensure_ascii=False, indent=2)
+        output = compact_entry(output)
+        print(output, file=fo)
+
+
+def map_to_file_or_dir[**P](
+    fn: Callable[Concatenate[Path, P], None],
+    path: Path,
+    *args: P.args,
+    **kwargs: P.kwargs,
+):
+    if path.is_dir():
+        for p in path.iterdir():
+            print(f"Processing {p}")
+            fn(p, *args, **kwargs)
+    else:
+        fn(path, *args, **kwargs)
+
+
+def is_protagonist(speaker: str) -> bool:
+    return speaker == "protagonist" or speaker == "我"
+
+
+def is_heroine(speaker: str) -> bool:
+    return not (is_protagonist(speaker) or speaker == "narrator")