"""HF Job (a100-large): e5-large embeddings (zero-shot or fine-tuned; MODEL env) for all 24.2M normalised records. Parametrised copy of encode_e5.py: MODEL (default intfloat/multilingual-e5-large; e.g. Arushhh/amlc-e5-ft, private, loaded with HF_TOKEN), MODEL_REVISION (default main), EMB_DIR (output prefix in the repo, default emb; emb_ft for the fine-tuned model). Everything else (texts, prompt, max_seq_length, batch, chunking, checks, layout) is unchanged. Spec (matches the validated zero-shot evaluation): * sentence-transformers, model loaded in float16 on CUDA, prompt "query: " on every text, normalize_embeddings=True * variant "full": raw_name.strip() + " | " + raw_address.strip() (just the name when the address is empty), max_seq_length=80 * variant "name": raw_name.strip(), max_seq_length=32 * batch_size 512; sentence-transformers length-sorts inside each encode() call and restores the original order. Each table is fed to encode() in contiguous chunks of CHUNK rows (for progress logging and bounded host memory); rows are never reordered. * output per table: emb/e5_{variant}/{table}.npy (float16, shape (n_rows, 1024), parquet row order) emb/e5_{variant}/{table}_ids.parquet (entity_id, same order) * order: variant "full" for s1,s2,s3,t1,t2,t3, then variant "name"; each table is committed to the Hub (Arushhh/amlc-work, dataset) as soon as it is written, in a background thread so the GPU keeps working. Job splitting (env): TABLES=s1,s2,s3 restricts the job to those tables (default: all six, in the order above); JOB_TAG names this job's manifest emb/e5_manifest_{JOB_TAG}.json (default emb/e5_manifest.json); SKIP_EXISTING=1 (default) skips a variant/table whose .npy (exact expected byte size) and _ids.parquet are already on the Hub. In-job integrity checks per table: shape/dtype via np.load(mmap), non-finite count, min/max L2 norm over all rows, and an order check (256 random rows re-encoded on their own must have cosine > 0.99 with the stored rows). """ import os, sys, time, json, shutil, threading from concurrent.futures import ThreadPoolExecutor import numpy as np import pyarrow as pa import pyarrow.parquet as pq import torch from huggingface_hub import HfApi, snapshot_download, CommitOperationAdd REPO = 'Arushhh/amlc-work' MODEL = os.environ.get('MODEL', 'intfloat/multilingual-e5-large') MODEL_REVISION = os.environ.get('MODEL_REVISION', 'main') EMB = os.environ.get('EMB_DIR', 'emb') PROMPT = 'query: ' BATCH = 512 CHUNK = int(os.environ.get('CHUNK', 262144)) DIM = 1024 ALL_TABLES = ['s1', 's2', 's3', 't1', 't2', 't3'] TABLES = [t for t in ALL_TABLES if t in os.environ.get('TABLES', ','.join(ALL_TABLES)).split(',')] JOB_TAG = os.environ.get('JOB_TAG', '') MANIFEST = f'{EMB}/e5_manifest_{JOB_TAG}.json' if JOB_TAG else f'{EMB}/e5_manifest.json' SKIP_EXISTING = os.environ.get('SKIP_EXISTING', '1') == '1' VARIANTS = [v for v in [('full', 80), ('name', 32)] if os.environ.get('ONLY_VARIANT', '') in ('', v[0])] # ONLY_VARIANT=full|name splits a table across jobs EXPECTED_ROWS = {'s1': 2206821, 's2': 5034616, 's3': 5285603, 't1': 1732544, 't2': 4887273, 't3': 5082316} WORK = os.environ.get('WORKDIR', '/workspace/e5') TOKEN = os.environ['HF_TOKEN'] T0 = time.time() def log(*a): print(f"[{time.strftime('%H:%M:%S', time.gmtime())} +{time.time() - T0:7.0f}s]", *a, flush=True) def build_texts(names, addrs, variant): out = [] n_empty_name = n_empty_addr = 0 for n, a in zip(names, addrs): n = (n or '').strip() if not n: n_empty_name += 1 if variant == 'name': out.append(n) continue a = (a or '').strip() if a: out.append(n + ' | ' + a) else: n_empty_addr += 1 out.append(n) return out, n_empty_name, n_empty_addr def main(): os.makedirs(WORK, exist_ok=True) api = HfApi(token=TOKEN) log('python', sys.version.split()[0], 'torch', torch.__version__, 'cuda', torch.version.cuda) import sentence_transformers, transformers, huggingface_hub log('sentence-transformers', sentence_transformers.__version__, 'transformers', transformers.__version__, 'huggingface_hub', huggingface_hub.__version__) assert torch.cuda.is_available(), 'CUDA not available' gpu = torch.cuda.get_device_name(0) log('GPU:', gpu, f'{torch.cuda.get_device_properties(0).total_memory / 2**30:.1f} GiB', 'CPUs:', os.cpu_count()) du = shutil.disk_usage(WORK) log(f'disk at {WORK}: free {du.free / 2**30:.0f} GiB of {du.total / 2**30:.0f} GiB') log(f'TABLES={TABLES} JOB_TAG={JOB_TAG!r} manifest={MANIFEST} SKIP_EXISTING={SKIP_EXISTING}') assert TABLES, 'no tables selected' on_hub = {} if SKIP_EXISTING: try: for f in api.list_repo_tree(REPO, path_in_repo=EMB, recursive=True, repo_type='dataset'): if getattr(f, 'size', None) is not None: on_hub[f.path] = f.size except Exception as ex: # noqa: BLE001 (no output folder yet) log(f'list_repo_tree {EMB}/:', repr(ex)) skip = set() for variant, _ in VARIANTS: for table in TABLES: npy_p, ids_p = f'{EMB}/e5_{variant}/{table}.npy', f'{EMB}/e5_{variant}/{table}_ids.parquet' if on_hub.get(npy_p) == 128 + EXPECTED_ROWS[table] * DIM * 2 and ids_p in on_hub: skip.add((variant, table)) log(f'SKIP {variant}/{table}: already on the Hub ({npy_p} {on_hub[npy_p]} bytes, {ids_p} present)') t = time.time() snapshot_download(REPO, repo_type='dataset', allow_patterns=['norm/*'], local_dir=f'{WORK}/hub', token=TOKEN) log(f'downloaded norm/* in {time.time() - t:.0f}s:', {f: os.path.getsize(f'{WORK}/hub/norm/{f}') for f in sorted(os.listdir(f'{WORK}/hub/norm'))}) from sentence_transformers import SentenceTransformer t = time.time() # private repo: fetch the exact revision with an explicit token, then load from the local copy mpath = MODEL if os.path.isdir(MODEL) else snapshot_download(MODEL, revision=MODEL_REVISION, token=TOKEN, local_dir=f'{WORK}/model') log('model files', sorted(os.listdir(mpath))) model = SentenceTransformer(mpath, device='cuda', model_kwargs={'torch_dtype': torch.float16}) wa = float(os.environ.get('WISE_ALPHA', '0') or 0) if wa > 0: # WiSE-FT: weights = (1 - a) * stock e5-large + a * this model (fine-tuned), then fp16 base = SentenceTransformer('intfloat/multilingual-e5-large', device='cuda', model_kwargs={'torch_dtype': torch.float32}) ft32 = SentenceTransformer(mpath, device='cuda', model_kwargs={'torch_dtype': torch.float32}) sd_b, sd_f = base.state_dict(), ft32.state_dict() with torch.no_grad(): for k, v in base.state_dict().items(): if v.is_floating_point(): v.copy_((1 - wa) * sd_b[k] + wa * sd_f[k]) model = base.half(); del ft32 log(f'WiSE-FT weight average: alpha={wa} (0 = stock e5-large, 1 = {MODEL}@{MODEL_REVISION})') model.eval() pdt = next(model.parameters()).dtype if pdt != torch.float16: log('params loaded as', pdt, '-> casting with .half()') model.half() pdt = next(model.parameters()).dtype assert pdt == torch.float16, pdt am = getattr(model[0].auto_model.config, '_attn_implementation', '?') log(f'MODEL LOADED {MODEL}@{MODEL_REVISION} in {time.time() - t:.0f}s: param dtype {pdt}, attn {am}, modules', [type(m).__name__ for m in model], 'dim', model.get_sentence_embedding_dimension()) assert model.get_sentence_embedding_dimension() == DIM pool = ThreadPoolExecutor(max_workers=1) futures = [] manifest = {'model': MODEL, 'model_revision': MODEL_REVISION, 'prompt': PROMPT, 'normalize_embeddings': True, 'dtype': 'float16', 'batch_size': BATCH, 'chunk_rows': CHUNK, 'job_tables': TABLES, 'skipped_already_on_hub': sorted(f'{v}/{t}' for v, t in skip), 'gpu': gpu, 'torch': torch.__version__, 'sentence_transformers': sentence_transformers.__version__, 'transformers': transformers.__version__, 'tables': {}} mlock = threading.Lock() def upload(variant, table, npy, ids, manifest_bytes): dest = f'{EMB}/e5_{variant}' for attempt in range(1, 6): try: t = time.time() ops = [CommitOperationAdd(path_in_repo=f'{dest}/{table}.npy', path_or_fileobj=npy), CommitOperationAdd(path_in_repo=f'{dest}/{table}_ids.parquet', path_or_fileobj=ids), CommitOperationAdd(path_in_repo=MANIFEST, path_or_fileobj=manifest_bytes)] api.create_commit(repo_id=REPO, repo_type='dataset', operations=ops, commit_message=f'{MODEL} {variant}/{table}') sz = os.path.getsize(npy) log(f'UPLOADED {dest}/{table}.npy ({sz} bytes) + {table}_ids.parquet in {time.time() - t:.0f}s ' f'({sz / 2**20 / max(time.time() - t, 1e-6):.0f} MiB/s)') os.remove(npy) return sz except Exception as ex: # noqa: BLE001 log(f'upload {dest}/{table} attempt {attempt} FAILED: {ex!r}') time.sleep(30 * attempt) raise RuntimeError(f'upload of {dest}/{table} failed 5 times') grand_n = 0 grand_t = 0.0 rng = np.random.default_rng(20260925) for variant, max_len in VARIANTS: model.max_seq_length = max_len log(f'===== variant {variant}: max_seq_length={model.max_seq_length}, prompt={PROMPT!r}, batch={BATCH}') os.makedirs(f'{WORK}/out/e5_{variant}', exist_ok=True) var_n = 0 var_t = 0.0 for table in TABLES: if (variant, table) in skip: continue tb = pq.read_table(f'{WORK}/hub/norm/{table}.parquet', columns=['entity_id', 'raw_name', 'raw_address']) n = tb.num_rows if n != EXPECTED_ROWS[table]: log(f'WARNING {table}: {n} rows, expected {EXPECTED_ROWS[table]}') texts, e_name, e_addr = build_texts(tb.column('raw_name').to_pylist(), tb.column('raw_address').to_pylist(), variant) log(f'{variant}/{table}: {n} rows, empty names {e_name}, empty addresses {e_addr}; examples: {texts[:2]}') npy = f'{WORK}/out/e5_{variant}/{table}.npy' ids = f'{WORK}/out/e5_{variant}/{table}_ids.parquet' pq.write_table(pa.table({'entity_id': tb.column('entity_id')}), ids) ids_arr = tb.column('entity_id') del tb out = np.lib.format.open_memmap(npy, mode='w+', dtype=np.float16, shape=(n, DIM)) t = time.time() for s in range(0, n, CHUNK): tc = time.time() chunk = texts[s:s + CHUNK] e = model.encode(chunk, batch_size=BATCH, prompt=PROMPT, normalize_embeddings=True, convert_to_numpy=True, show_progress_bar=False) assert e.shape == (len(chunk), DIM), e.shape out[s:s + len(chunk)] = e.astype(np.float16, copy=False) done = s + len(chunk) el = time.time() - t log(f' {variant}/{table} rows {done}/{n}: chunk {len(chunk) / (time.time() - tc):.0f} rec/s, ' f'table {done / el:.0f} rec/s, ETA table {(n - done) / (done / el) / 60:.1f} min') enc_s = time.time() - t out.flush() del out # ---- integrity checks arr = np.load(npy, mmap_mode='r') assert arr.shape == (n, DIM) and arr.dtype == np.float16, (arr.shape, arr.dtype) hdr = int(arr.offset) nmin, nmax, nonfin = 9.0, 0.0, 0 for s in range(0, n, 1 << 20): blk = np.asarray(arr[s:s + (1 << 20)], dtype=np.float32) nonfin += int((~np.isfinite(blk)).sum()) nr = np.linalg.norm(blk, axis=1) nmin = min(nmin, float(nr.min())) nmax = max(nmax, float(nr.max())) idx = np.sort(rng.choice(n, size=min(256, n), replace=False)) chk = model.encode([texts[i] for i in idx], batch_size=BATCH, prompt=PROMPT, normalize_embeddings=True, convert_to_numpy=True, show_progress_bar=False).astype(np.float32) cos = (np.asarray(arr[idx], dtype=np.float32) * chk).sum(1) ids_back = pq.read_table(ids).column('entity_id') ids_ok = ids_back.equals(ids_arr) if hasattr(ids_back, 'equals') else None del arr fsize = os.path.getsize(npy) rps = n / enc_s var_n += n var_t += enc_s grand_n += n grand_t += enc_s log(f'TABLE DONE {variant}/{table}: n={n} encode {enc_s:.0f}s = {rps:.0f} rec/s | variant so far ' f'{var_n} rows {var_n / var_t:.0f} rec/s | ALL so far {grand_n} rows {grand_n / grand_t:.0f} rec/s | ' f'norm min {nmin:.4f} max {nmax:.4f} nonfinite {nonfin} | order check cos min {cos.min():.5f} ' f'mean {cos.mean():.5f} | ids equal {ids_ok} | file {fsize} bytes (expected {128 + n * DIM * 2})') if cos.min() < 0.99 or nonfin > 0 or not ids_ok or fsize != hdr + n * DIM * 2: log(f'FATAL integrity failure on {variant}/{table}; aborting') sys.exit(3) with mlock: manifest['tables'][f'{variant}/{table}'] = dict( rows=n, max_seq_length=max_len, encode_seconds=round(enc_s, 1), rec_per_s=round(rps, 1), npy_bytes=fsize, norm_min=nmin, norm_max=nmax, nonfinite=nonfin, order_check_cos_min=float(cos.min()), empty_names=e_name, empty_addresses=e_addr) mb = json.dumps(manifest, indent=1).encode() # surface any earlier upload failure before queueing more work for f in futures: if f.done() and f.exception() is not None: raise f.exception() futures.append(pool.submit(upload, variant, table, npy, ids, mb)) del texts, ids_arr log(f'===== variant {variant} encoded: {var_n} rows in {var_t:.0f}s = {var_n / max(var_t, 1e-9):.0f} rec/s') log('all encoding done; waiting for uploads') for f in futures: f.result() pool.shutdown() log(f'ALL DONE: {grand_n} row-encodings in {grand_t:.0f}s encode time ({grand_n / max(grand_t, 1e-9):.0f} rec/s), ' f'wall {time.time() - T0:.0f}s') log(f'GPU {torch.cuda.get_device_name(0)} max_memory_allocated ' f'{torch.cuda.max_memory_allocated() / 2**30:.2f} GiB ({torch.cuda.max_memory_allocated()} bytes)') print(json.dumps(manifest, indent=1), flush=True) if __name__ == '__main__': main()