Instructions to use RenormalizationTech/qwen2.5-7b-refusal-steering-experiment with libraries, inference providers, notebooks, and local apps. Follow these links to get started.
- Libraries
- Transformers
How to use RenormalizationTech/qwen2.5-7b-refusal-steering-experiment with Transformers:
# pip install -U transformers accelerate # Load model directly from transformers import AutoModel model = AutoModel.from_pretrained("RenormalizationTech/qwen2.5-7b-refusal-steering-experiment", device_map="auto") - Notebooks
- Google Colab
- Kaggle
Download refusal_runtime.py from RenormalizationTech/qwen2.5-7b-refusal-steering-experiment: direct link, hf CLI and curl.
- Browser
- Download file 6.36 kB
-
https://huggingface.co/RenormalizationTech/qwen2.5-7b-refusal-steering-experiment/resolve/main/refusal_runtime.py
- Command line
-
hf download hf://RenormalizationTech/qwen2.5-7b-refusal-steering-experiment/refusal_runtime.py
-
curl -L -o refusal_runtime.py https://huggingface.co/RenormalizationTech/qwen2.5-7b-refusal-steering-experiment/resolve/main/refusal_runtime.py
6.36 kB
| # SPDX-License-Identifier: Apache-2.0 | |
| """Standalone fixed experimental refusal shift; no tuneLLM imports/downloads.""" | |
| import argparse | |
| from contextlib import contextmanager, nullcontext | |
| import hashlib | |
| import json | |
| import math | |
| from pathlib import Path | |
| import torch | |
| BASE = "Qwen/Qwen2.5-7B-Instruct" | |
| REVISION = "a09a35458c702b33eeacc393d103063234e8bc28" | |
| PT_SHA256 = "671c6a839cd01a3767d6455b9a1b59a37059f712097ff1f8142324dfccbae28e" | |
| TENSOR_SHA256 = "1d2b29bc37636b26c6ba803467052e31fa4758e9928ea0f9fc8183c9791d646b" | |
| def sha256(file): | |
| digest = hashlib.sha256() | |
| with Path(file).open("rb") as stream: | |
| for chunk in iter(lambda: stream.read(8*1024*1024), b""): digest.update(chunk) | |
| return digest.hexdigest() | |
| def validate_direction(value): | |
| if (not isinstance(value, torch.Tensor) or value.shape != (3584,) or value.dtype != torch.float32 | |
| or value.device.type != "cpu" or not torch.isfinite(value).all() or not torch.isfinite(value.norm()) or value.norm() == 0): | |
| raise ValueError("exact finite nonzero CPU FP32 [3584] raw direction required") | |
| if hashlib.sha256(value.contiguous().numpy().tobytes()).hexdigest() != TENSOR_SHA256: | |
| raise ValueError("frozen raw tensor content differs") | |
| return value | |
| def load_direction(root=None, *, use_pt=False): | |
| """Prefer safetensors key 'direction'; exact .pt provenance is a ROOT tensor.""" | |
| root = Path(root) if root is not None else Path(__file__).resolve().parent | |
| if use_pt: | |
| file = root/"direction.pt" | |
| if sha256(file) != PT_SHA256: raise ValueError("frozen .pt file hash differs") | |
| value = torch.load(file, map_location="cpu", weights_only=True) | |
| else: | |
| from safetensors.torch import load_file | |
| values = load_file(str(root/"direction.safetensors"), device="cpu") | |
| if set(values) != {"direction"}: raise ValueError("exact safetensors direction key required") | |
| value = values["direction"] | |
| return validate_direction(value).detach().clone() | |
| def validate_model(model, *, model_id=BASE, revision=REVISION): | |
| cfg = model.config | |
| if model_id != BASE or revision != REVISION or getattr(cfg, "_commit_hash", None) not in (None, REVISION): | |
| raise ValueError("exact base model ID and revision required") | |
| if (cfg.model_type, cfg.num_hidden_layers, cfg.hidden_size, cfg.num_attention_heads, cfg.num_key_value_heads) != ("qwen2", 28, 3584, 28, 4) or len(model.model.layers) != 28: | |
| raise ValueError("pinned Qwen2 architecture/config required") | |
| def steering(model, raw_direction, *, strength=1.0, model_id=BASE, revision=REVISION): | |
| """Fixed -0.25raw at block18 OUTPUT, including prefill and cached decode. | |
| strength=0 is an identity check; strength=1 is the only experimental setting. | |
| Preserve the original two power-of-two scalings and FP32 arithmetic exactly. | |
| No input tensor, weight, output tuple tail or cache object is mutated. | |
| """ | |
| validate_model(model, model_id=model_id, revision=revision) | |
| if type(strength) not in (int, float) or not math.isfinite(strength) or strength not in (0, 1): | |
| raise ValueError("only identity0 or fixed experimental strength1 supported") | |
| raw = validate_direction(raw_direction.detach().cpu()).clone() | |
| effective = .5*raw if strength else torch.zeros_like(raw) | |
| local = {} | |
| def change(hidden): | |
| if hidden.ndim != 3 or hidden.shape[-1] != 3584 or not hidden.is_floating_point(): | |
| raise ValueError("floating [batch,sequence,3584] block output required") | |
| if hidden.device not in local: local[hidden.device] = effective.to(hidden.device) | |
| return (hidden.float()-.5*local[hidden.device]).to(hidden.dtype) | |
| def hook(module, args, output): | |
| return (change(output[0]), *output[1:]) if isinstance(output, tuple) else change(output) | |
| handle = model.model.layers[18].register_forward_hook(hook) | |
| try: | |
| yield | |
| finally: | |
| handle.remove() | |
| def validate_snapshot(snapshot, root): | |
| """CLI verifies pinned metadata AND weight hashes before model allocation.""" | |
| snapshot, root = Path(snapshot), Path(root) | |
| metadata = json.loads((root/"base_model.json").read_text()) | |
| if metadata["model_id"] != BASE or metadata["revision"] != REVISION: | |
| raise ValueError("base metadata identity differs") | |
| for name, expected in metadata["files_sha256"].items(): | |
| if Path(name).name != name or sha256(snapshot/name) != expected: | |
| raise ValueError("local pinned base asset differs: "+name) | |
| def main(): | |
| parser = argparse.ArgumentParser(description=__doc__) | |
| parser.add_argument("--snapshot", required=True, help="Existing local pinned base snapshot; never downloads") | |
| parser.add_argument("--prompt", required=True) | |
| parser.add_argument("--steer", action="store_true", help="Opt in to fixed experimental -0.25raw shift") | |
| parser.add_argument("--device", default="cpu", help="cpu (default) or an explicitly selected CUDA device") | |
| args = parser.parse_args(); root = Path(__file__).resolve().parent | |
| validate_snapshot(args.snapshot, root) | |
| from transformers import AutoModelForCausalLM, AutoTokenizer | |
| tok = AutoTokenizer.from_pretrained(args.snapshot, local_files_only=True, trust_remote_code=False) | |
| if (tok.eos_token_id, tok.pad_token_id) != (151645, 151643): raise ValueError("native tokenizer EOS/PAD differ") | |
| model = AutoModelForCausalLM.from_pretrained(args.snapshot, local_files_only=True, trust_remote_code=False, | |
| torch_dtype=torch.bfloat16, attn_implementation="sdpa", device_map={"": args.device}).eval() | |
| validate_model(model) | |
| prompt = tok.apply_chat_template([{"role": "user", "content": args.prompt}], tokenize=False, add_generation_prompt=True) | |
| inputs = tok(prompt, add_special_tokens=False, return_tensors="pt").to(model.device) | |
| torch.manual_seed(42) | |
| context = steering(model, load_direction(root)) if args.steer else nullcontext() | |
| with torch.inference_mode(), context: | |
| output = model.generate(**inputs, do_sample=False, num_beams=1, max_new_tokens=320, | |
| temperature=None, top_p=None, top_k=None, repetition_penalty=1.0, | |
| eos_token_id=151645, pad_token_id=151643, use_cache=True) | |
| print(tok.decode(output[0, inputs.input_ids.shape[1]:], skip_special_tokens=True)) | |
| if __name__ == "__main__": main() | |