diff --git a/bench.py b/bench.py deleted file mode 100644 index a207ec9..0000000 --- a/bench.py +++ /dev/null @@ -1,260 +0,0 @@ -import argparse -import json -import os -import statistics -import time -from pathlib import Path - -import numpy as np -import onnxruntime as ort - -ort.set_default_logger_severity(3) - -NP = { - "tensor(float)": np.float32, "tensor(float16)": np.float16, "tensor(double)": np.float64, - "tensor(int64)": np.int64, "tensor(int32)": np.int32, "tensor(int8)": np.int8, - "tensor(uint8)": np.uint8, "tensor(bool)": np.bool_, -} -TAG = {"tensor(float)": "f32", "tensor(float16)": "f16", "tensor(double)": "f64", - "tensor(int64)": "i64", "tensor(int32)": "i32", "tensor(int8)": "i8", - "tensor(uint8)": "u8", "tensor(bool)": "b"} -GRAPHS = ["ssl", "encode", "decode", "global"] - - -def cpu_info(): - info = {"cpu": platform_cpu(), "logical": os.cpu_count(), "phys": "?", "isa": {}} - try: - txt = Path("/proc/cpuinfo").read_text() - for l in txt.splitlines(): - if l.startswith("model name"): - info["cpu"] = l.split(":", 1)[1].strip(); break - flags = next((l for l in txt.splitlines() if l.startswith("flags")), "") - cc = next((l for l in txt.splitlines() if l.startswith("cpu cores")), "") - if cc: - info["phys"] = cc.split(":")[1].strip() - info["isa"] = {k: int(k in flags) for k in - ["avx2", "avx512f", "avx_vnni", "avx512_vnni", "amx_int8"]} - except Exception: - pass - return info - - -def platform_cpu(): - import platform - return platform.processor() or platform.machine() - - -def make_session(path, provider, intra, inter, profile=False): - so = ort.SessionOptions() - so.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL - if intra: - so.intra_op_num_threads = intra - if inter: - so.inter_op_num_threads = inter - so.enable_profiling = profile - if provider == "openvino": - providers = [("OpenVINOExecutionProvider", {"device_type": "CPU"}), "CPUExecutionProvider"] - else: - providers = ["CPUExecutionProvider"] - return ort.InferenceSession(str(path), sess_options=so, providers=providers) - - -def dim_value(name, axis, ndim, meta, seq): - n = name.lower() - if axis == 0 and ndim >= 2: - return 1 - if "audio" in n: - return int(meta.get("ssl_in_16k", seq)) - if "local" in n or ("ssl_features" in n and "global" not in n): - return int(meta.get("enc_tokens", 1) * meta.get("downsample_factor", 1)) or seq - if "token" in n or "indices" in n: - return int(meta.get("dec_tokens", seq)) - return seq - - -def resolve_inputs(sess, meta, seq, rng): - feeds, shapes = {}, {} - for inp in sess.get_inputs(): - dt = NP.get(inp.type, np.float32) - shape = [d if isinstance(d, int) and d > 0 - else dim_value(inp.name, ax, len(inp.shape), meta, seq) - for ax, d in enumerate(inp.shape)] - shapes[inp.name] = (shape, TAG.get(inp.type, "?")) - n = inp.name.lower() - if np.issubdtype(dt, np.integer): - feeds[inp.name] = np.zeros(shape, dtype=dt) - elif dt == np.bool_: - feeds[inp.name] = np.ones(shape, dtype=dt) - else: - a = rng.standard_normal(shape).astype(dt) - if "std" in n: - a = np.abs(a) + 1.0 - elif "mean" in n: - a *= 0.0 - elif "audio" in n: - a *= 0.1 - feeds[inp.name] = a - return feeds, shapes - - -def bench(sess, feeds, runs, warmup): - out = [o.name for o in sess.get_outputs()] - for _ in range(warmup): - sess.run(out, feeds) - ts = [] - for _ in range(runs): - t = time.perf_counter() - sess.run(out, feeds) - ts.append((time.perf_counter() - t) * 1e3) - return ts, out - - -def profile_ops(path, provider, intra, inter, feeds, out, runs): - sess = make_session(path, provider, intra, inter, profile=True) - for _ in range(runs): - sess.run(out, feeds) - prof = Path(sess.end_profiling()) - events = json.loads(prof.read_text()) - prof.unlink(missing_ok=True) - agg, prov = {}, {} - for e in events: - if e.get("cat") == "Node" and e.get("name", "").endswith("kernel_time"): - op = e.get("args", {}).get("op_name", "?") - agg[op] = agg.get(op, 0.0) + e.get("dur", 0) - p = e.get("args", {}).get("provider", "") - if p: - prov.setdefault(op, set()).add(p) - rows = sorted(agg.items(), key=lambda kv: kv[1], reverse=True) - return rows, (sum(agg.values()) or 1.0), prov - - -def static_ops(path): - try: - import onnx - except Exception: - return None - m = onnx.load(str(path), load_external_data=False) - c = {} - for node in m.graph.node: - c[node.op_type] = c.get(node.op_type, 0) + 1 - return dict(sorted(c.items(), key=lambda kv: kv[1], reverse=True)) - - -def main(): - ap = argparse.ArgumentParser() - ap.add_argument("--dir", default="outputs") - ap.add_argument("--meta") - ap.add_argument("--provider", choices=["cpu", "openvino"], default="cpu") - ap.add_argument("--intra", type=int, default=0) - ap.add_argument("--inter", type=int, default=0) - ap.add_argument("--runs", type=int, default=50) - ap.add_argument("--warmup", type=int, default=5) - ap.add_argument("--seq", type=int, default=100) - ap.add_argument("--extra", nargs="*", default=[]) - ap.add_argument("--quant", action="store_true") - args = ap.parse_args() - - d = Path(args.dir) - meta = json.loads(Path(args.meta or d / "meta.json").read_text()) - rng = np.random.default_rng(0) - avail = ort.get_available_providers() - prov = args.provider - if prov == "openvino" and "OpenVINOExecutionProvider" not in avail: - prov = "cpu" - ov_note = "requested but NOT installed -> fell back to cpu" - else: - ov_note = "available" if "OpenVINOExecutionProvider" in avail else "not installed" - - models = {g: d / f"{g}.onnx" for g in GRAPHS if (d / f"{g}.onnx").exists()} - if args.quant: - for g in GRAPHS: - q = d / f"{g}_quant.onnx" - if q.exists(): - models[f"{g}_q"] = q - for kv in args.extra: - name, _, path = kv.partition("=") - models[name] = Path(path) - - ci = cpu_info() - isa = " ".join(f"{k}={v}" for k, v in ci["isa"].items()) - print("=== ENV ===") - print(f"cpu: {ci['cpu']}") - print(f"cores: {ci['phys']} phys / {ci['logical']} logical") - print(f"isa: {isa}") - print(f"onnxruntime: {ort.__version__}") - print(f"providers avail: {avail}") - print(f"openvino EP: {ov_note}") - print(f"config: provider={prov} intra={args.intra or 'default'} " - f"inter={args.inter or 'default'} runs={args.runs}") - - med = {} - csv_rows = [("graph", "med_ms", "mean_ms", "p90_ms", "min_ms", "runs")] - op_rows = [("graph", "op", "ms_per_run", "pct", "provider")] - for name, path in models.items(): - print(f"\n=== {name.upper()} ===") - print(f"path: {path} size: {path.stat().st_size / 1e6:.3g} MB") - try: - sess = make_session(path, prov, args.intra, args.inter) - feeds, shapes = resolve_inputs(sess, meta, args.seq, rng) - print("inputs: " + " ".join( - f"{k}[{','.join(map(str, s))}]{t}" for k, (s, t) in shapes.items())) - ts, out = bench(sess, feeds, args.runs, args.warmup) - m = statistics.median(ts) - med[name] = m - p90 = sorted(ts)[int(0.9 * len(ts)) - 1] - print(f"latency ms: med {m:.3g} mean {statistics.fmean(ts):.3g} " - f"p90 {p90:.3g} min {min(ts):.3g}") - csv_rows.append((name, f"{m:.3g}", f"{statistics.fmean(ts):.3g}", - f"{p90:.3g}", f"{min(ts):.3g}", args.runs)) - - so = static_ops(path) - if so: - print("ops static: " + " ".join(f"{k}:{v}" for k, v in list(so.items())[:10])) - - rows, total, pmap = profile_ops(path, prov, args.intra, args.inter, feeds, out, args.warmup or 5) - multi = len({p for ps in pmap.values() for p in ps}) > 1 - parts = [] - for op, dur in rows[:6]: - pr = "/".join(sorted(x.replace("ExecutionProvider", "") for x in pmap.get(op, []))) - tag = f"({pr})" if multi else "" - parts.append(f"{op}{tag} {dur / (args.warmup or 5) / 1e3:.3g}ms {100 * dur / total:.0f}%") - op_rows.append((name, op, f"{dur / (args.warmup or 5) / 1e3:.3g}", - f"{100 * dur / total:.0f}", pr or "CPU")) - print("ops time: " + " | ".join(parts)) - except Exception as e: - print(f"FAILED: {e}") - - print("\n=== ROLLUP ===") - ds = meta.get("downsample_factor", 1) - tok16 = ds * meta.get("wavlm_hop", 1) - sr16 = meta.get("ssl_sample_rate", 16000) - chunk = meta.get("chunk", 1) - audio_s = chunk * tok16 / sr16 - per_win = sum(med.get(g, 0.0) for g in ("ssl", "encode", "decode")) - print(f"chunk={chunk} tok16={tok16} audio/window={audio_s * 1e3:.3g}ms") - print(f"per-window compute (ssl+encode+decode): {per_win:.3g}ms") - if audio_s > 0: - print(f"est streaming RTF: {(per_win / 1e3) / audio_s:.3g} (global enc one-shot, excluded)") - - if args.quant: - print("fp32 -> quant:") - for g in ("ssl", "encode", "decode", "global"): - if g in med and f"{g}_q" in med: - f0, f1 = med[g], med[f"{g}_q"] - print(f" {g}: {f0:.3g} -> {f1:.3g}ms ({100 * (1 - f1 / f0):+.0f}%)") - per_q = sum(med.get(f"{g}_q", med.get(g, 0.0)) for g in ("ssl", "encode", "decode")) - if audio_s > 0: - print(f"per-window quant: {per_q:.3g}ms RTF {(per_q / 1e3) / audio_s:.3g}") - - od = Path("outputs") - od.mkdir(exist_ok=True) - import csv - with open(od / "bench.csv", "w", newline="") as f: - csv.writer(f).writerows(csv_rows) - with open(od / "ops.csv", "w", newline="") as f: - csv.writer(f).writerows(op_rows) - print(f"\nwrote {od/'bench.csv'} {od/'ops.csv'}") - - -if __name__ == "__main__": - main() \ No newline at end of file diff --git a/live.py b/live.py index 5cec234..773c3a6 100644 --- a/live.py +++ b/live.py @@ -222,9 +222,9 @@ def main(): parser.add_argument("--seed-audio", type=Path, help="Seed speaker calibration WAV (optional)") parser.add_argument("--chunk", type=int, default=6) parser.add_argument("--enc-left", type=int, default=48) - parser.add_argument("--enc-right", type=int, default=2) + parser.add_argument("--enc-right", type=int, default=4) parser.add_argument("--dec-left", type=int, default=32) - parser.add_argument("--dec-right", type=int, default=3) + parser.add_argument("--dec-right", type=int, default=4) parser.add_argument("--ema-alpha", type=float, default=0.9, help="EMA smoothing on local SSL features (0=full smoothing, 1=no smoothing)") parser.add_argument("--rms-floor", type=float, default=0.0035, diff --git a/live_onnx.py b/live_onnx.py index ecee1e8..e18f329 100644 --- a/live_onnx.py +++ b/live_onnx.py @@ -53,7 +53,20 @@ class StreamingISTFT: self.win_sq = self.window ** 2 self.tail_y = np.zeros(0, dtype=np.float32) self.tail_e = np.zeros(0, dtype=np.float32) - self.started = False + self.started = False\ + + def block(self, real, imag): + spec = real + 1j * imag + T = spec.shape[1] + ifft = (np.fft.irfft(spec, self.n_fft, axis=0) * self.window[:, None]).astype(np.float32) + region = (T - 1) * self.hop + self.win + y = np.zeros(region, dtype=np.float32) + e = np.zeros(region, dtype=np.float32) + for t in range(T): + s = t * self.hop + y[s : s + self.win] += ifft[:, t] + e[s : s + self.win] += self.win_sq + return (y / np.maximum(e, 1e-8)).astype(np.float32) def process(self, real, imag): spec = real + 1j * imag @@ -110,13 +123,16 @@ class StreamingVCONNX: prov = ["CUDAExecutionProvider", "CPUExecutionProvider"] else: prov = ["CPUExecutionProvider"] - + self.ssl = ort.InferenceSession(args.ssl, sess_options=opts, providers=prov) self.enc = ort.InferenceSession(args.encode, sess_options=opts, providers=prov) self.dec = ort.InferenceSession(args.decode, sess_options=opts, providers=prov) self.glb = ort.InferenceSession(args.global_path, sess_options=opts, providers=prov) self.istft = StreamingISTFT(meta["n_fft"], meta["hop_length"]) + self.xfade_frames = 9 + self.istft_margin = int(np.ceil(meta["n_fft"] / meta["hop_length"])) + self.xfade_tail = None self.global_emb = None self.src_mean = None self.src_std = None @@ -159,33 +175,46 @@ class StreamingVCONNX: frames = np.concatenate([l[c : c + keep * self.ds] for keep, l in locals_], axis=0) self.src_mean = frames.mean(axis=0).astype(np.float32) self.src_std = frames.std(axis=0, ddof=1).astype(np.float32) - + seed_tokens = np.concatenate( [self._encode(l, self.src_mean, self.src_std)[self.enc_left : self.enc_left + keep] for keep, l in locals_] ) if locals_ else np.zeros(0, dtype=np.int64) - + self.tokens = seed_tokens.astype(np.int64) self.decoded = len(self.tokens) def reset(self): self.istft = StreamingISTFT(self.meta["n_fft"], self.meta["hop_length"]) + self.xfade_tail = None self.tokens = None self.decoded = 0 def apply_ema(self, local_feats): - if self.prev_local_feats is not None and local_feats.shape == self.prev_local_feats.shape: - local_feats = self.ema_alpha * local_feats + (1.0 - self.ema_alpha) * self.prev_local_feats + shift = self.chunk * self.ds + if self.prev_local_feats is not None: + n = local_feats.shape[0] - shift + if n > 0: + local_feats[:n] = (self.ema_alpha * local_feats[:n] + + (1 - self.ema_alpha) * self.prev_local_feats[shift:shift + n]) self.prev_local_feats = local_feats.copy() return local_feats - def _decode(self, win_tokens, keep_left, keep_n): + def _decode(self, win_tokens, keep_left, keep_n, right_tokens): real, imag = self.dec.run( ["spec_real", "spec_imag"], - {"content_token_indices": win_tokens, "global_embedding": self.global_emb} + {"content_token_indices": win_tokens, "global_embedding": self.global_emb}, ) - f0 = keep_left * self.fpt - f1 = (keep_left + keep_n) * self.fpt - return self.istft.process(real[:, f0:f1], imag[:, f0:f1]) + fpt, hop = self.fpt, self.istft.hop + a = keep_left * fpt + b = (keep_left + keep_n) * fpt + right_frames = right_tokens * fpt + ov = min(self.xfade_frames, max(0, right_frames)) + m = min(self.istft_margin, a, max(0, right_frames - ov)) + F0, F1 = a - m, b + ov + m + audio = self.istft.block(real[:, F0:F1], imag[:, F0:F1]) + start = (a - F0) * hop + seg = audio[start : start + (keep_n * fpt + ov) * hop] + return seg, ov * hop def _commit_tokens(self, new_idx): if self.tokens is None: @@ -195,6 +224,7 @@ class StreamingVCONNX: def _drain(self, final=False): out = [] + hop = self.istft.hop committed = len(self.tokens) if self.tokens is not None else 0 while True: d0 = self.decoded @@ -204,13 +234,23 @@ class StreamingVCONNX: keep_n = min(self.chunk, avail) if final else self.chunk left = min(self.dec_left, d0) right = min(self.dec_right, committed - (d0 + keep_n)) - - lo = d0 - left - hi = d0 + keep_n + right - win_idx = np.clip(np.arange(lo, hi), 0, committed - 1) - win = self.tokens[win_idx].astype(np.int64) - - out.append(self._decode(win, left, keep_n)) + lo, hi = d0 - left, d0 + keep_n + right + win = self.tokens[np.clip(np.arange(lo, hi), 0, committed - 1)].astype(np.int64) + + seg, h = self._decode(win, left, keep_n, right) + body_end = keep_n * self.fpt * hop + head, body, tail = seg[:h], seg[h:body_end], seg[body_end:] + + if self.xfade_tail is not None and len(self.xfade_tail) == h and h > 0: + t = np.linspace(0.0, 1.0, h, dtype=np.float32) + out.append((1.0 - t) * self.xfade_tail + t * head) + else: + out.append(head) + out.append(body) + + self.xfade_tail = None if final else tail + if final and tail.size: + out.append(tail) self.decoded += keep_n return np.concatenate(out) if out else np.zeros(0, dtype=np.float32) @@ -264,7 +304,7 @@ def main(): sr = vc.sr sr16 = vc.sr16 - + token_hz = meta["token_hz"] tok_samples = sr // token_hz chunk_samples = vc.chunk * tok_samples @@ -274,6 +314,10 @@ def main(): chunk_samples_16k = vc.chunk * tok16 left_pad_16k = vc.enc_left * tok16 right_pad_16k = vc.enc_right * tok16 + required_samples_16k = left_pad_16k + chunk_samples_16k + right_pad_16k + + fade_len = int(0.01 * sr16) + ramp_down = np.linspace(1.0, 0.0, fade_len, dtype=np.float32) print(f"Sample Rate: {sr} Hz (target) | 16000 Hz (SSL internal)") print(f"Chunk Size: {vc.chunk} tokens ({budget_ms:.1f}ms budget)") @@ -295,12 +339,11 @@ def main(): vc.seed(seed_audio) if len(seed_audio) >= left_pad_16k: - raw_input_accum_16k = seed_audio[-left_pad_16k:] + accum_16k = seed_audio[-left_pad_16k:] else: - raw_input_accum_16k = np.pad(seed_audio, (left_pad_16k - len(seed_audio), 0)) + accum_16k = np.pad(seed_audio, (left_pad_16k - len(seed_audio), 0)) in_q = queue.Queue(maxsize=8) - ssl_q = queue.Queue(maxsize=8) out_q = queue.Queue(maxsize=2) stop_event = threading.Event() @@ -318,58 +361,12 @@ def main(): except queue.Empty: continue - def ssl_thread_func(accum_16k): - hangover_counter = 0 - t_last = None - while not stop_event.is_set(): - try: - raw = in_q.get(timeout=0.5) - except queue.Empty: - continue - - t_now = time.perf_counter() - gap_ms = (t_now - t_last) * 1000 if t_last else 0.0 - t_last = t_now - - rms = float(np.sqrt(np.mean(raw ** 2))) - - if rms >= args.rms_floor: - hangover_counter = args.hangover_chunks - is_silence = False - else: - if hangover_counter > 0: - hangover_counter -= 1 - is_silence = False - else: - is_silence = True - - raw_16k = resample(raw, sr, sr16) - accum_16k = np.concatenate([accum_16k, raw_16k]) - required_samples_16k = left_pad_16k + chunk_samples_16k + right_pad_16k - - if len(accum_16k) >= required_samples_16k: - window_16k = accum_16k[:required_samples_16k] - accum_16k = accum_16k[chunk_samples_16k:] - - fade_len = int(0.01 * sr16) - ramp_down = np.linspace(1.0, 0.0, fade_len, dtype=np.float32) - - if is_silence: - window_16k = window_16k.copy() - active_start = left_pad_16k - active_end = left_pad_16k + chunk_samples_16k - window_16k[active_start : active_start + fade_len] *= ramp_down - window_16k[active_start + fade_len : active_end] = 0.0 - - local_feats, t_ssl = sync_time(lambda: vc._ssl(window_16k)[0]) - ssl_q.put((local_feats, is_silence, t_ssl, gap_ms, rms)) - else: - ssl_q.put((None, is_silence, 0.0, gap_ms, rms)) - - print(f"\n{'chunk':>6} {'q_in':>4} {'q_ss':>4} {'q_out':>5} {'ssl':>7} {'enc':>7} {'dec':>7} {'total':>7} {'budget':>7} {'gap':>7}") - print("-" * 88) + print(f"\n{'chunk':>6} {'q_in':>4} {'q_out':>5} {'ssl':>7} {'enc':>7} {'dec':>7} {'total':>7} {'budget':>7} {'gap':>7}") + print("-" * 80) chunk_n = 0 + t_last = None + hangover_counter = 0 with sd.InputStream(device=args.input, channels=n_in_ch, samplerate=sr, blocksize=chunk_samples, dtype="float32", @@ -378,21 +375,40 @@ def main(): dtype="float32", latency="low") as out_stream: writer = threading.Thread(target=write_thread, args=(out_stream,), daemon=True) - ssl_worker = threading.Thread(target=ssl_thread_func, args=(raw_input_accum_16k,), daemon=True) - writer.start() - ssl_worker.start() try: while True: - try: - item = ssl_q.get(timeout=0.5) - except queue.Empty: - continue + raw = in_q.get() + t_now = time.perf_counter() + gap_ms = (t_now - t_last) * 1000 if t_last else 0.0 + t_last = t_now - local_feats, is_silence, t_ssl, gap_ms, rms = item + rms = float(np.sqrt(np.mean(raw ** 2))) + if rms >= args.rms_floor: + hangover_counter = args.hangover_chunks + is_silence = False + elif hangover_counter > 0: + hangover_counter -= 1 + is_silence = False + else: + is_silence = True - if local_feats is not None: + raw_16k = resample(raw, sr, sr16) + accum_16k = np.concatenate([accum_16k, raw_16k]) + + if len(accum_16k) >= required_samples_16k: + window_16k = accum_16k[:required_samples_16k] + accum_16k = accum_16k[chunk_samples_16k:] + + if is_silence: + window_16k = window_16k.copy() + active_start = left_pad_16k + active_end = left_pad_16k + chunk_samples_16k + window_16k[active_start : active_start + fade_len] *= ramp_down + window_16k[active_start + fade_len : active_end] = 0.0 + + local_feats, t_ssl = sync_time(lambda: vc._ssl(window_16k)[0]) local_feats = vc.apply_ema(local_feats) idx, t_enc = sync_time(lambda: vc._encode(local_feats, vc.src_mean, vc.src_std)) chunk_tokens = idx[vc.enc_left : vc.enc_left + vc.chunk] @@ -406,22 +422,22 @@ def main(): pcm_out = np.stack([pcm, pcm], axis=1) else: pcm_out = np.zeros((chunk_samples, 2), dtype=np.float32) - t_enc, t_dec = 0.0, 0.0 + t_ssl, t_enc, t_dec = 0.0, 0.0, 0.0 out_q.put(pcm_out) total = t_ssl + t_enc + t_dec chunk_n += 1 - + if is_silence: print( - f"{chunk_n:>6} {in_q.qsize():>4} {ssl_q.qsize():>4} {out_q.qsize():>5} " - f"{'--silence--':>54} rms={rms:.4f}", + f"{chunk_n:>6} {in_q.qsize():>4} {out_q.qsize():>5} " + f"{'--silence--':>41} rms={rms:.4f}", flush=True, ) else: print( - f"{chunk_n:>6} {in_q.qsize():>4} {ssl_q.qsize():>4} {out_q.qsize():>5} " + f"{chunk_n:>6} {in_q.qsize():>4} {out_q.qsize():>5} " f"{t_ssl:>6.1f}ms {t_enc:>6.1f}ms {t_dec:>6.1f}ms " f"{total:>6.1f}ms {budget_ms:>6.0f}ms {gap_ms:>6.1f}ms", flush=True, @@ -432,7 +448,6 @@ def main(): finally: stop_event.set() writer.join() - ssl_worker.join() print("stopped") diff --git a/pyproject.toml b/pyproject.toml index 36c1eac..8d2ad71 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -7,8 +7,6 @@ requires-python = ">=3.12" dependencies = [ "miocodec", "numpy>=2.4.6", - "onnxruntime>=1.26.0", - "onnxruntime-gpu>=1.26.0", "onnxruntime-openvino>=1.24.1", "onnxscript>=0.7.0", "sounddevice>=0.5.5", diff --git a/uv.lock b/uv.lock index 0e0cbc4..36951ef 100644 --- a/uv.lock +++ b/uv.lock @@ -208,8 +208,6 @@ source = { virtual = "." } dependencies = [ { name = "miocodec" }, { name = "numpy" }, - { name = "onnxruntime" }, - { name = "onnxruntime-gpu" }, { name = "onnxruntime-openvino" }, { name = "onnxscript" }, { name = "sounddevice" }, @@ -221,8 +219,6 @@ dependencies = [ requires-dist = [ { name = "miocodec", git = "https://github.com/Aratako/MioCodec" }, { name = "numpy", specifier = ">=2.4.6" }, - { name = "onnxruntime", specifier = ">=1.26.0" }, - { name = "onnxruntime-gpu", specifier = ">=1.26.0" }, { name = "onnxruntime-openvino", specifier = ">=1.24.1" }, { name = "onnxscript", specifier = ">=0.7.0" }, { name = "sounddevice", specifier = ">=0.5.5" }, @@ -835,59 +831,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/8c/aa/f7a53321c60b9ad9ee184b6018292ed6b5389947592a2c8c09c736bb7f9e/onnx_ir-0.2.1-py3-none-any.whl", hash = "sha256:c7285da889312f91882de2092e298a9eeeefbfc1d1951c49d983992967eb09a7", size = 166792, upload-time = "2026-04-20T20:21:46.357Z" }, ] -[[package]] -name = "onnxruntime" -version = "1.26.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "flatbuffers" }, - { name = "numpy" }, - { name = "packaging" }, - { name = "protobuf" }, -] -wheels = [ - { url = "https://files.pythonhosted.org/packages/81/b1/d111b1df656761f980d9e298a60039a9cb66036b1d039e777537743d0ac3/onnxruntime-1.26.0-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:05b028781b322ad74b57ce5b50aa5280bb1fe96ceec334628ade681e0b24c1ac", size = 18016624, upload-time = "2026-05-12T00:41:01.735Z" }, - { url = "https://files.pythonhosted.org/packages/f6/a0/3f9d896a0385a36bd04345d6d0b802821a5782adde562e7e135f6bb71c73/onnxruntime-1.26.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:91f2bb870a4b9224eba0a6728c1fa7a9e552b8e59e1083c51fbbc3d013f2b5c0", size = 16052692, upload-time = "2026-05-08T19:07:13.829Z" }, - { url = "https://files.pythonhosted.org/packages/7c/43/2a4e04f8dbeffad19bbcced4bcd4289bf478921518437404d6b92bdf213b/onnxruntime-1.26.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9b6dd70599005bd1bf29779f04a91978b92b5e719c11a20068a8f8e535f725b6", size = 18185439, upload-time = "2026-05-08T19:07:36.299Z" }, - { url = "https://files.pythonhosted.org/packages/44/fc/026d0a7162b9c2153dac292baea9e027c42304dc1d9dc6f8ff5b4cfbaedd/onnxruntime-1.26.0-cp312-cp312-win_amd64.whl", hash = "sha256:a26374dc7fbcaae593601086b242120e13f2310558df0991da6dd8b8fac00414", size = 13026427, upload-time = "2026-05-08T19:08:03.503Z" }, - { url = "https://files.pythonhosted.org/packages/3e/27/1dcf88e45e4c69db5f7b106f2dacc3801ba98994e082ca03e1dfdf7bfe57/onnxruntime-1.26.0-cp312-cp312-win_arm64.whl", hash = "sha256:54a8053410fd31fd66469bd754fcfe8a4df9f7eb44756b4b5479bf50c842d948", size = 12796647, upload-time = "2026-05-08T19:07:52.108Z" }, - { url = "https://files.pythonhosted.org/packages/cf/a2/c801242685e0ce48a4ca51dfafbb588765e0446397e123be53ba5598f3f5/onnxruntime-1.26.0-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:ccce19c5f771b8268902f77d9fed9e88f9499465d6780808faa6611a789d33f0", size = 18016563, upload-time = "2026-05-08T19:07:28.081Z" }, - { url = "https://files.pythonhosted.org/packages/e2/64/0492c0b1db04e29b2630c87cfa36f9d6872b1ca8614b90c5cad58fac7d76/onnxruntime-1.26.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bdbed8cf3b672b66acb032f33a253bc27f42bce6ece48ae3fab4fa483a5e96e0", size = 16052634, upload-time = "2026-05-08T19:07:16.885Z" }, - { url = "https://files.pythonhosted.org/packages/3d/26/4d09ddc755a84fc8d5e192991626b0e0680e8f6c5d58f4f1d05c42bc48cf/onnxruntime-1.26.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c07af6fc6d5557835f2b6ee7a96d8b3235d0c57a8e230efdedaee106a8a3cbc6", size = 18185632, upload-time = "2026-05-08T19:07:38.756Z" }, - { url = "https://files.pythonhosted.org/packages/77/89/3e52249aa08fa301e217ecba07b5246a8338fa2b401e109326e3fc5be0f9/onnxruntime-1.26.0-cp313-cp313-win_amd64.whl", hash = "sha256:61bec80655efa460591c2bc655392d57d2650ce85533a6b9b3b7a790d7ea7916", size = 13026751, upload-time = "2026-05-08T19:08:06.2Z" }, - { url = "https://files.pythonhosted.org/packages/06/b3/c1c8782b14af6797c303de132d6eef26a9fb80dfacd3750ce57911d11c6b/onnxruntime-1.26.0-cp313-cp313-win_arm64.whl", hash = "sha256:a6677545ff451e3539a02746d2f207d8c5baa4a0a818886bb9d6a6eb9511ee89", size = 12796807, upload-time = "2026-05-08T19:07:54.879Z" }, - { url = "https://files.pythonhosted.org/packages/c3/f5/47b0676408abec652c14b84d7173e389837832d850c24f87184277313e8d/onnxruntime-1.26.0-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5e016edc15d3c19f36807e1c6b10be5b27807688c32720f91b5ae480a95215d0", size = 16057265, upload-time = "2026-05-08T19:07:19.603Z" }, - { url = "https://files.pythonhosted.org/packages/3b/45/33ab6deeef010ca844c877dd618cebc079590bbe52d2a3678e7223b1b908/onnxruntime-1.26.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f5fc48a91a046a6a5c9b147f83fb41d65d24d24923373b222cdd248f0f4f4aac", size = 18197590, upload-time = "2026-05-08T19:07:41.422Z" }, - { url = "https://files.pythonhosted.org/packages/40/89/17546c1c20f6bfc3ae41c22152378a26edfea918af3129e2139dcd7c99f3/onnxruntime-1.26.0-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:33a791f31432a3af1a96db5e54818b37aba5e5eefc2e6af5794c10a9118a9993", size = 18019724, upload-time = "2026-05-08T19:07:30.723Z" }, - { url = "https://files.pythonhosted.org/packages/bb/24/89457a35f6af29538a76647f2c18c3a28277e6c19234c847e7b4b7c19860/onnxruntime-1.26.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e90c00732c4553618103149d93f688e8c3063017938f8983e21a71d9f3b6d22e", size = 16054821, upload-time = "2026-05-08T19:07:22.348Z" }, - { url = "https://files.pythonhosted.org/packages/12/f9/15b2e1815cf570d238e0135529f80d2dce64e8e8818a1489cae83823c5c6/onnxruntime-1.26.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:01498e80ba8988428d08c2d51b1338f89e3de2a93e6ffe555f79c68f26a5c06b", size = 18185815, upload-time = "2026-05-08T19:07:44.179Z" }, - { url = "https://files.pythonhosted.org/packages/d7/65/2e11055faf015e4b07f45b513fa49b391baf2e19d92d77d73ebee13c1004/onnxruntime-1.26.0-cp314-cp314-win_amd64.whl", hash = "sha256:7ead61450d8405167c87dd3a31d8da1d576b490a57dab1aa8b82a7da6825f5aa", size = 13349887, upload-time = "2026-05-08T19:08:08.671Z" }, - { url = "https://files.pythonhosted.org/packages/19/e4/0f9d1a5718b1781c610c1e354765a3820597081754277a6a9a2b50705702/onnxruntime-1.26.0-cp314-cp314-win_arm64.whl", hash = "sha256:31d71a53490e46910877d0902b5ad99c69a5955e5c7ea6c82863519410e1ba7c", size = 13140121, upload-time = "2026-05-08T19:07:57.804Z" }, - { url = "https://files.pythonhosted.org/packages/1c/42/3b8e635f067d06d9f45bede470b8d539d101a4166c272213158dfd08b6ce/onnxruntime-1.26.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d7b6d258fb78fdfcf049795bcfaa74dcb90ae7baa277afd21e6fd28b83f2c496", size = 16057240, upload-time = "2026-05-08T19:07:25.163Z" }, - { url = "https://files.pythonhosted.org/packages/93/99/f2be40a31b908d96b861ae0ce98582fa376c18a7f816b9d5eb4cd6aa0a4c/onnxruntime-1.26.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4eefd386a45202aefb7a5132b94f32df9d506c9edcc7faf2fc60d65183f4b183", size = 18197382, upload-time = "2026-05-08T19:07:46.965Z" }, -] - -[[package]] -name = "onnxruntime-gpu" -version = "1.26.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "flatbuffers" }, - { name = "numpy" }, - { name = "packaging" }, - { name = "protobuf" }, -] -wheels = [ - { url = "https://files.pythonhosted.org/packages/94/fd/59bee7cffaa435da44fefdeb63e29c61de4dbfa4b279852f59cd02c042ae/onnxruntime_gpu-1.26.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3c01119ed4d9449d60367fa8ccffcd02bd3fe736754284e4b198d131f54edad6", size = 276971796, upload-time = "2026-05-08T19:15:46.192Z" }, - { url = "https://files.pythonhosted.org/packages/a4/e4/9b378a5466ea0bed65e5beb8e09254973c580a6522810a38afbcc45e5105/onnxruntime_gpu-1.26.0-cp312-cp312-win_amd64.whl", hash = "sha256:5f49c44689894650990e4c8a857d2edafc276fbd79bba57ceb224bd18d25d491", size = 226548963, upload-time = "2026-05-08T19:09:34.925Z" }, - { url = "https://files.pythonhosted.org/packages/dd/97/fe8979f44b9275654b42f7bb556e30789b71a1b22998c83b540df2b1b774/onnxruntime_gpu-1.26.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:cfda2fad535595bfc3e570eb588092717711dcb2957656d814695e0c9ceb1508", size = 276974871, upload-time = "2026-05-08T19:15:58.052Z" }, - { url = "https://files.pythonhosted.org/packages/67/3f/59f1777a394625ecc9a85636de57dc47c25dbb5f888da050f1463955a0ce/onnxruntime_gpu-1.26.0-cp313-cp313-win_amd64.whl", hash = "sha256:6ab9f9c741d2e239b2e321ab0d389c04329d4ab7f11e3b92dd3aa7db1c59dee4", size = 226548083, upload-time = "2026-05-08T19:09:44.408Z" }, - { url = "https://files.pythonhosted.org/packages/89/96/360328e3c463f7ea08e853c4239c397e83363dd0204de71a710dc1a544bd/onnxruntime_gpu-1.26.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bcf6f347cad9f88a9a625c2b352cf9de927528aedb627ebbc089a201f1990b94", size = 276992052, upload-time = "2026-05-08T19:16:09.892Z" }, - { url = "https://files.pythonhosted.org/packages/fd/c8/aa2dc0e79bba577f37d5448bcb32fea79977e07506684d8138c19a0f1077/onnxruntime_gpu-1.26.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9e6e4fb1ec9ae1cf456534d9115f106ab2a1ae96fa513b4ed0f4795302b4a2c6", size = 276978254, upload-time = "2026-05-08T19:16:22.096Z" }, - { url = "https://files.pythonhosted.org/packages/41/e7/923298431e669567d7ccc2a4c898b6534a47641a051569fd97165fe6d9b8/onnxruntime_gpu-1.26.0-cp314-cp314-win_amd64.whl", hash = "sha256:3e592439b0183d303c2374517b5b392599a3d50b2dc9de949b9b15731ac921c9", size = 229142768, upload-time = "2026-05-08T19:09:54.589Z" }, - { url = "https://files.pythonhosted.org/packages/97/91/93ffe5431d154989f5e04864a25a97eea480997d771232bcbbc538188241/onnxruntime_gpu-1.26.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:56dc7b73954ff4bdc71f5b8ab306b6f61be5d007881b6ef423a609e2b9cd088b", size = 276991545, upload-time = "2026-05-08T19:16:33.347Z" }, -] - [[package]] name = "onnxruntime-openvino" version = "1.24.1"