File size: 8,001 Bytes
de01f6a | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 | """argparse-based CLI.
Commands::
video2dataset process ./videos # full pipeline
video2dataset transcribe ./audio # transcripts only -> JSONL
video2dataset segment ./audio # cut clips from sidecar transcripts
video2dataset features ./dataset # build features/train.{bin,dat}
video2dataset train ./dataset # launch wav2vec2 training
Global options (``--config``, ``--device``, ``--whisper-model``, ``--language``,
``--output-dir``, ``--verbose``) override the YAML configuration.
"""
from __future__ import annotations
import argparse
import sys
from pathlib import Path
from typing import Optional, Sequence
from video_vec2wav2_tokenizer import __version__
from video_vec2wav2_tokenizer.utils.config import Config, load_config
from video_vec2wav2_tokenizer.utils.io import Segment, ensure_dir, read_jsonl, write_jsonl
from video_vec2wav2_tokenizer.utils.logging import get_logger, setup_logging
logger = get_logger(__name__)
# --------------------------------------------------------------------------- #
# Parser
# --------------------------------------------------------------------------- #
def build_parser() -> argparse.ArgumentParser:
parser = argparse.ArgumentParser(
prog="video2dataset",
description="Convert videos into ASR/TTS training datasets.",
)
parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
# Shared options applied to every subcommand.
common = argparse.ArgumentParser(add_help=False)
common.add_argument("--config", type=str, default=None, help="Path to config.yaml")
common.add_argument("--output-dir", type=str, default=None, help="Output directory")
common.add_argument("--device", choices=["auto", "cpu", "cuda"], default=None)
common.add_argument("--whisper-model", type=str, default=None)
common.add_argument("--language", type=str, default=None, help="ISO code or 'auto'")
common.add_argument("-v", "--verbose", action="store_true", help="Debug logging")
sub = parser.add_subparsers(dest="command", required=True)
p_process = sub.add_parser("process", parents=[common], help="Run the full pipeline")
p_process.add_argument("input", help="Directory of input videos")
p_process.add_argument(
"--extract-features", action="store_true", help="Also build feature store"
)
p_process.set_defaults(func=cmd_process)
p_tr = sub.add_parser("transcribe", parents=[common], help="Transcribe audio only")
p_tr.add_argument("input", help="Directory of audio (.wav) files")
p_tr.set_defaults(func=cmd_transcribe)
p_seg = sub.add_parser("segment", parents=[common], help="Cut clips from transcripts")
p_seg.add_argument("input", help="Directory of audio with sidecar .json transcripts")
p_seg.set_defaults(func=cmd_segment)
p_feat = sub.add_parser("features", parents=[common], help="Extract features")
p_feat.add_argument("input", help="Dataset directory containing audio/")
p_feat.set_defaults(func=cmd_features)
p_train = sub.add_parser("train", parents=[common], help="Train wav2vec2 CTC model")
p_train.add_argument("input", help="Dataset directory")
p_train.add_argument("--epochs", type=int, default=None)
p_train.add_argument("--batch-size", type=int, default=None)
p_train.add_argument("--resume", action="store_true", help="Resume from checkpoint")
p_train.set_defaults(func=cmd_train)
return parser
def _config_from_args(args: argparse.Namespace) -> Config:
overrides: dict[str, object] = {}
if getattr(args, "output_dir", None):
overrides["output_dir"] = args.output_dir
if getattr(args, "device", None):
overrides["device"] = args.device
if getattr(args, "whisper_model", None):
overrides["whisper_model"] = args.whisper_model
if getattr(args, "language", None) and args.language != "auto":
overrides["language"] = args.language
return load_config(args.config, overrides=overrides)
# --------------------------------------------------------------------------- #
# Commands
# --------------------------------------------------------------------------- #
def cmd_process(args: argparse.Namespace) -> int:
from video_vec2wav2_tokenizer.pipeline import Pipeline
cfg = _config_from_args(args)
Pipeline(cfg).run(args.input, extract_features=args.extract_features)
return 0
def cmd_transcribe(args: argparse.Namespace) -> int:
from video_vec2wav2_tokenizer.transcription.transcriber import Transcriber
cfg = _config_from_args(args)
transcriber = Transcriber.from_config(cfg)
out_dir = ensure_dir(Path(cfg.output_dir) / "transcripts")
audio_files = sorted(Path(args.input).rglob("*.wav"))
if not audio_files:
logger.warning("No .wav files found under %s", args.input)
return 1
from tqdm import tqdm
for audio in tqdm(audio_files, desc="transcribe", unit="file"):
result = transcriber.transcribe(audio)
write_jsonl(
out_dir / f"{audio.stem}.jsonl",
(s.to_dict() for s in result.segments),
)
logger.info("Wrote transcripts to %s", out_dir)
return 0
def cmd_segment(args: argparse.Namespace) -> int:
from video_vec2wav2_tokenizer.segmentation.segmenter import Segmenter, normalize_segments
cfg = _config_from_args(args)
segmenter = Segmenter(sample_rate=cfg.sample_rate)
audio_dir = ensure_dir(cfg.audio_dir)
audio_files = sorted(Path(args.input).rglob("*.wav"))
clip_index = 1
for audio in audio_files:
transcript = audio.with_suffix(".json")
if not transcript.exists():
transcript = audio.with_suffix(".jsonl")
if not transcript.exists():
logger.warning("No transcript for %s, skipping", audio.name)
continue
segments = [Segment.from_dict(r) for r in read_jsonl(transcript)]
segments = normalize_segments(
segments,
min_length=cfg.min_segment_length,
max_length=cfg.max_segment_length,
padding=cfg.segment_padding,
)
clips = segmenter.segment_file(audio, segments, audio_dir, start_index=clip_index)
clip_index += len(clips)
logger.info("Wrote clips to %s", audio_dir)
return 0
def cmd_features(args: argparse.Namespace) -> int:
from video_vec2wav2_tokenizer.features.extractor import FeatureExtractor
cfg = _config_from_args(args)
audio_dir = Path(args.input) / "audio"
if not audio_dir.exists():
audio_dir = Path(args.input)
clip_paths = sorted(audio_dir.rglob("*.wav"))
if not clip_paths:
logger.warning("No .wav clips found under %s", audio_dir)
return 1
fx = FeatureExtractor(sample_rate=cfg.sample_rate)
fx.extract_dataset(clip_paths, cfg.features_dir)
return 0
def cmd_train(args: argparse.Namespace) -> int:
from video_vec2wav2_tokenizer.training.train_wav2vec2 import TrainingArguments, train
cfg = _config_from_args(args)
targs = TrainingArguments(
dataset_dir=Path(args.input),
model_name=cfg.model_name,
output_dir=Path(cfg.output_dir) / "checkpoints",
resume=args.resume,
)
if args.epochs is not None:
targs.num_epochs = args.epochs
if args.batch_size is not None:
targs.batch_size = args.batch_size
train(targs)
return 0
def main(argv: Optional[Sequence[str]] = None) -> int:
parser = build_parser()
args = parser.parse_args(argv)
setup_logging("DEBUG" if getattr(args, "verbose", False) else "INFO")
try:
return int(args.func(args))
except KeyboardInterrupt: # pragma: no cover
logger.error("Interrupted by user")
return 130
except Exception as exc: # pragma: no cover - top-level guard
logger.exception("Command failed: %s", exc)
return 1
if __name__ == "__main__": # pragma: no cover
sys.exit(main())
|