Add files using upload-large-folder tool

.gitattributes

@@ -58,3 +58,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+lora_0311_10w+55w+noise_nost_error_train90_with_domain_100k_sample_rewritten.jsonl filter=lfs diff=lfs merge=lfs -text
+lora_0311_10w+55w+noise_nost_error_train90_with_domain_100k_sample.jsonl filter=lfs diff=lfs merge=lfs -text

audios.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8f910ebf0b29b6fd4674c71502c10ebe2873a6dcdde405eff4ffb8ff4e28e305
+size 39108130317

compress_audios_tar_gz.py

@@ -0,0 +1,95 @@
+#!/usr/bin/env python3
+import argparse
+import gzip
+import subprocess
+from concurrent.futures import FIRST_COMPLETED, ProcessPoolExecutor, wait
+from pathlib import Path
+
+
+DEFAULT_WORKERS = 32
+DEFAULT_CHUNK_MB = 32
+
+
+def gzip_chunk(data: bytes, compresslevel: int) -> bytes:
+    return gzip.compress(data, compresslevel=compresslevel, mtime=0)
+
+
+def stream_tar_gz_parallel(
+    input_dir: Path,
+    output_file: Path,
+    workers: int,
+    chunk_size: int,
+    compresslevel: int,
+) -> None:
+    tar_cmd = ["tar", "-cf", "-", "-C", str(input_dir.parent), input_dir.name]
+    tar_proc = subprocess.Popen(tar_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    if tar_proc.stdout is None or tar_proc.stderr is None:
+        raise RuntimeError("Failed to start tar process")
+
+    pending = {}
+    completed = {}
+    next_index = 0
+    next_to_write = 0
+    max_in_flight = max(workers * 2, 1)
+
+    with output_file.open("wb") as out_f, ProcessPoolExecutor(max_workers=workers) as executor:
+        try:
+            while True:
+                while len(pending) < max_in_flight:
+                    chunk = tar_proc.stdout.read(chunk_size)
+                    if not chunk:
+                        break
+                    future = executor.submit(gzip_chunk, chunk, compresslevel)
+                    pending[future] = next_index
+                    next_index += 1
+
+                if not pending:
+                    break
+
+                done, _ = wait(pending, return_when=FIRST_COMPLETED)
+                for future in done:
+                    completed[pending.pop(future)] = future.result()
+
+                while next_to_write in completed:
+                    out_f.write(completed.pop(next_to_write))
+                    next_to_write += 1
+        finally:
+            tar_proc.stdout.close()
+
+        stderr = tar_proc.stderr.read().decode("utf-8", errors="replace").strip()
+        tar_proc.stderr.close()
+        return_code = tar_proc.wait()
+        if return_code != 0:
+            raise RuntimeError(f"tar failed with exit code {return_code}: {stderr}")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Compress a directory into tar.gz with parallel gzip workers.")
+    parser.add_argument("--input-dir", required=True, help="Directory to compress.")
+    parser.add_argument("--output", required=True, help="Output tar.gz file path.")
+    parser.add_argument("--workers", type=int, default=DEFAULT_WORKERS, help="Number of gzip worker processes.")
+    parser.add_argument("--chunk-mb", type=int, default=DEFAULT_CHUNK_MB, help="Chunk size in MB.")
+    parser.add_argument("--compresslevel", type=int, default=6, help="Gzip level from 0 to 9.")
+    args = parser.parse_args()
+
+    input_dir = Path(args.input_dir).resolve()
+    output_file = Path(args.output).resolve()
+
+    if not input_dir.exists():
+        raise FileNotFoundError(f"Input directory not found: {input_dir}")
+    if not input_dir.is_dir():
+        raise NotADirectoryError(f"Input path is not a directory: {input_dir}")
+
+    output_file.parent.mkdir(parents=True, exist_ok=True)
+    stream_tar_gz_parallel(
+        input_dir=input_dir,
+        output_file=output_file,
+        workers=args.workers,
+        chunk_size=args.chunk_mb * 1024 * 1024,
+        compresslevel=args.compresslevel,
+    )
+    print(f"Created archive: {output_file}")
+
+
+if __name__ == "__main__":
+    main()

copy_audio_and_rewrite_jsonl.py

@@ -0,0 +1,95 @@
+#!/usr/bin/env python3
+import argparse
+import json
+import shutil
+from pathlib import Path
+
+
+def build_target_path(audio_path: Path, audio_root: Path) -> Path:
+    if audio_path.is_absolute():
+        relative_path = audio_path.relative_to("/")
+    else:
+        relative_path = audio_path
+    return audio_root / relative_path
+
+
+def copy_audio(audio_path: Path, audio_root: Path, copied: dict[str, Path]) -> Path:
+    key = str(audio_path)
+    if key in copied:
+        return copied[key]
+    if not audio_path.exists():
+        raise FileNotFoundError(f"Audio file not found: {audio_path}")
+
+    target_path = build_target_path(audio_path, audio_root)
+    target_path.parent.mkdir(parents=True, exist_ok=True)
+    shutil.copy2(audio_path, target_path)
+    copied[key] = target_path
+    return target_path
+
+
+def rewrite_record(item: dict, audio_root: Path, copied: dict[str, Path], input_path: Path, line_no: int) -> int:
+    rewritten = 0
+
+    if "audio" in item:
+        audio_path = Path(item["audio"])
+        item["audio"] = str(copy_audio(audio_path, audio_root, copied))
+        rewritten += 1
+
+    if "audios" in item:
+        audios = item["audios"]
+        if not isinstance(audios, list):
+            raise ValueError(f"{input_path}:{line_no} field 'audios' is not a list")
+        item["audios"] = [str(copy_audio(Path(audio), audio_root, copied)) for audio in audios]
+        rewritten += len(item["audios"])
+
+    if rewritten == 0:
+        raise ValueError(f"{input_path}:{line_no} has neither 'audio' nor 'audios'")
+
+    return rewritten
+
+
+def process_jsonl(input_path: Path, output_path: Path, audio_root: Path) -> tuple[int, int, int]:
+    copied: dict[str, Path] = {}
+    line_count = 0
+    audio_refs = 0
+
+    with input_path.open("r", encoding="utf-8") as src, output_path.open("w", encoding="utf-8") as dst:
+        for line_no, line in enumerate(src, start=1):
+            if not line.strip():
+                continue
+
+            item = json.loads(line)
+            audio_refs += rewrite_record(item, audio_root, copied, input_path, line_no)
+            dst.write(json.dumps(item, ensure_ascii=False) + "\n")
+            line_count += 1
+
+    return line_count, audio_refs, len(copied)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Copy referenced audio files and rewrite JSONL audio paths.")
+    parser.add_argument("--input", required=True, help="Input JSONL file.")
+    parser.add_argument("--output", required=True, help="Output rewritten JSONL file.")
+    parser.add_argument("--audio-root", required=True, help="Destination root for copied audio files.")
+    args = parser.parse_args()
+
+    input_path = Path(args.input).resolve()
+    output_path = Path(args.output).resolve()
+    audio_root = Path(args.audio_root).resolve()
+
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    audio_root.mkdir(parents=True, exist_ok=True)
+
+    line_count, audio_refs, unique_audio_count = process_jsonl(
+        input_path=input_path,
+        output_path=output_path,
+        audio_root=audio_root,
+    )
+    print(
+        f"Processed {line_count} lines, rewrote {audio_refs} audio references, "
+        f"copied {unique_audio_count} unique audio files"
+    )
+
+
+if __name__ == "__main__":
+    main()

lora_0311_10w+55w+noise_nost_error_train90_with_domain_100k_sample.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b1c456b52ba754c284718603a727cb6f4659fbd062014898032ecd7395b8e8d4
+size 44323395

lora_0311_10w+55w+noise_nost_error_train90_with_domain_100k_sample_rewritten.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:39f41850c9b03b3f0a997821c51f0089e779e71eadb41ec86596ec0dd703b892
+size 48423395

sample_jsonl_first_n.py

@@ -0,0 +1,31 @@
+#!/usr/bin/env python3
+import argparse
+from pathlib import Path
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Write the first N non-empty JSONL lines to a new file.")
+    parser.add_argument("--input", required=True, help="Input JSONL file.")
+    parser.add_argument("--output", required=True, help="Output JSONL file.")
+    parser.add_argument("--limit", type=int, default=100000, help="Number of non-empty lines to keep.")
+    args = parser.parse_args()
+
+    input_path = Path(args.input).resolve()
+    output_path = Path(args.output).resolve()
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    kept = 0
+    with input_path.open("r", encoding="utf-8") as src, output_path.open("w", encoding="utf-8") as dst:
+        for line in src:
+            if not line.strip():
+                continue
+            dst.write(line)
+            kept += 1
+            if kept >= args.limit:
+                break
+
+    print(f"Wrote {kept} lines to {output_path}")
+
+
+if __name__ == "__main__":
+    main()