File size: 4,993 Bytes
51143b4 | 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 | """Unmodified upstream SWE-Pruner inference behind a bounded private SSH pipe."""
import argparse
from contextlib import redirect_stdout
from hashlib import sha256
import importlib.metadata
import json
import os
from pathlib import Path
import sys
import time
REVISION = '863cee3198c715c9df1faa422a3490e0832bb734'
BACKBONE = 'e61197ed45024b0ed8a2d74b80b4d909f1255473'
ROOT = Path('/workspace/atmem-swe-pruner')
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('--qualify', action='store_true')
args = parser.parse_args()
output = sys.stdout
os.environ['HF_HOME'] = str(ROOT / 'hf')
os.environ['HF_HUB_DISABLE_IMPLICIT_TOKEN'] = '1'
tick = time.monotonic()
with redirect_stdout(sys.stderr):
from huggingface_hub import snapshot_download
path = snapshot_download('ayanami-kitasan/code-pruner', revision=REVISION,
local_dir=str(ROOT / 'model'), token=False)
base = snapshot_download('Qwen/Qwen3-Reranker-0.6B', revision=BACKBONE,
local_dir=str(ROOT / 'backbone-config'), allow_patterns=['config.json'], token=False)
import torch
from swe_pruner.configuration import SwePrunerConfig
from swe_pruner.prune_wrapper import SwePrunerForCodePruning, PruneRequest
if not torch.cuda.is_available():
raise RuntimeError('qualified CUDA device required; no silent CPU fallback')
config = SwePrunerConfig.from_pretrained(path, local_files_only=True,
backbone_model_name_or_path=base, trust_remote_code=False)
model = SwePrunerForCodePruning.from_pretrained(path, config=config, local_files_only=True)
torch.cuda.synchronize()
attention = model.model.backbone.config._attn_implementation
if attention != 'flash_attention_2':
raise RuntimeError('FlashAttention-2 did not activate; do not score an unqualified backend')
metadata = {'model_revision': REVISION, 'backbone_config_revision': BACKBONE,
'gpu': torch.cuda.get_device_name(), 'torch': torch.__version__,
'dtype': str(next(model.parameters()).dtype), 'attention': attention,
'package': importlib.metadata.version('swe-pruner'),
'flash_attention': importlib.metadata.version('flash-attn'),
'transformers': importlib.metadata.version('transformers'),
'load_seconds': time.monotonic() - tick,
'adaptations': [], 'threshold': 0.5}
(ROOT / 'last-runtime.json').write_text(json.dumps(metadata, indent=2))
def prune(request):
if set(request) != {'query', 'code'} or not all(isinstance(v, str) for v in request.values()):
raise ValueError('exact textual query and code required')
if not 1 <= len(request['query']) <= 1000 or not 1 <= len(request['code'].encode()) <= 24000:
raise ValueError('bounded nonempty query and source required')
tick = time.monotonic()
with redirect_stdout(sys.stderr):
result = model.prune(PruneRequest(**request, threshold=0.5))
torch.cuda.synchronize()
elapsed = time.monotonic() - tick
raw = result.model_dump()
if result.error_msg:
raise RuntimeError(result.error_msg)
with (ROOT / 'inference-audit.jsonl').open('a') as audit:
audit.write(json.dumps({'request': request, 'result': raw, 'seconds': elapsed,
'runtime': metadata}) + '\n')
return {key: raw[key] for key in ('pruned_code', 'kept_frags', 'origin_token_cnt',
'left_token_cnt', 'model_input_token_cnt', 'score')} | {
'seconds': elapsed, 'source_sha256': sha256(request['code'].encode()).hexdigest()}
if args.qualify:
cases = json.loads((ROOT / 'cases.json').read_text())
trials = []
for case in cases['cases']:
trial = {'id': case['id'], **prune({'query': case['query'], 'code': case['code']})}
trials.append(trial)
print(json.dumps({'stage': 'qualified_case', 'id': case['id'], 'seconds': trial['seconds'],
'original_tokens': trial['origin_token_cnt'], 'remaining_tokens': trial['left_token_cnt']}),
file=output, flush=True)
(ROOT / 'qualification.json').write_text(json.dumps({'runtime': metadata, 'cases': trials}, indent=2))
return
print(json.dumps({'status': 'ready', 'runtime': metadata}), file=output, flush=True)
for line in sys.stdin:
try:
if len(line.encode()) > 50000:
raise ValueError('request too large')
response = prune(json.loads(line))
except Exception as exc:
response = {'error': type(exc).__name__ + ': ' + str(exc)}
print(json.dumps(response), file=output, flush=True)
if __name__ == '__main__':
main()
|