| |
| """Run repeated VecAlign trials without restarting Python for every trial.""" |
|
|
| from __future__ import annotations |
|
|
| import io |
| import json |
| import random |
| from math import ceil |
| from pathlib import Path |
|
|
| import numpy as np |
|
|
|
|
| def read_embedding_candidates(text_file: Path, embed_file: Path): |
| candidates = json.loads(text_file.read_text(encoding="utf-8")) |
| if not isinstance(candidates, list) or not candidates or not all(isinstance(value, str) for value in candidates): |
| raise ValueError("embedding candidates must be a non-empty string list") |
| sent2line = {} |
| for index, candidate in enumerate(candidates): |
| key = candidate.strip() |
| if key in sent2line: |
| raise ValueError("multiple embeddings for the same candidate") |
| sent2line[key] = index |
| embeddings = np.fromfile(embed_file, dtype=np.float32) |
| if not embeddings.size or embeddings.size % len(candidates): |
| raise ValueError("embedding row count does not match candidates") |
| return sent2line, embeddings.reshape(len(candidates), -1) |
|
|
|
|
| def load_case(paths: dict[str, Path], max_size: int) -> dict: |
| from vecalign import dp_utils |
|
|
| effective_max_size = max(2, max_size) |
| random.seed(42) |
| np.random.seed(42) |
|
|
| src_sent2line, src_line_embeddings = read_embedding_candidates( |
| paths["src_overlap"], paths["src_embed"] |
| ) |
| tgt_sent2line, tgt_line_embeddings = read_embedding_candidates( |
| paths["tgt_overlap"], paths["tgt_embed"] |
| ) |
| src_lines = json.loads(paths["src"].read_text(encoding="utf-8")) |
| tgt_lines = json.loads(paths["tgt"].read_text(encoding="utf-8")) |
|
|
| vecs0 = dp_utils.make_doc_embedding( |
| src_sent2line, src_line_embeddings, src_lines, effective_max_size |
| ) |
| vecs1 = dp_utils.make_doc_embedding( |
| tgt_sent2line, tgt_line_embeddings, tgt_lines, effective_max_size |
| ) |
| return { |
| "dp_utils": dp_utils, |
| "vecs0": vecs0, |
| "vecs1": vecs1, |
| "alignment_types": dp_utils.make_alignment_types(effective_max_size), |
| "width_over2": ceil(effective_max_size / 2.0) + 5, |
| |
| |
| "python_random_state": random.getstate(), |
| "numpy_random_state": np.random.get_state(), |
| } |
|
|
|
|
| def run_trial(case: dict, del_percentile_frac: float) -> list[str]: |
| dp_utils = case["dp_utils"] |
| random.setstate(case["python_random_state"]) |
| np.random.set_state(case["numpy_random_state"]) |
| stack = dp_utils.vecalign( |
| vecs0=case["vecs0"].copy(), |
| vecs1=case["vecs1"].copy(), |
| final_alignment_types=case["alignment_types"], |
| del_percentile_frac=del_percentile_frac, |
| width_over2=case["width_over2"], |
| max_size_full_dp=300, |
| costs_sample_size=20000, |
| num_samps_for_norm=100, |
| ) |
| output = io.StringIO() |
| dp_utils.print_alignments( |
| stack[0]["final_alignments"], |
| scores=stack[0]["alignment_scores"], |
| ofile=output, |
| ) |
| return output.getvalue().strip().splitlines() |
|
|
