Spaces:
Build error
Build error
| """Le point de depart de la recette : un checkpoint DEJA quantifie. | |
| La recette partait de `Qwen/Qwen3.8-27B` (poids bf16, ~54 Go telecharges) et | |
| quantifiait a la volee via un `BitsAndBytesConfig` passe dans | |
| `model_init_kwargs`. Elle part maintenant de | |
| `unsloth/Qwen3.8-27B-unsloth-bnb-4bit` (22,4 Go). | |
| Le piege de ce changement n'est pas la taille, c'est l'INTERACTION. Quand le | |
| checkpoint porte deja un `quantization_config` dans son `config.json` ET qu'on | |
| passe un `BitsAndBytesConfig` explicite, `transformers` n'echoue pas et ne | |
| fusionne pas : il IGNORE celui qu'on passe et garde celui du checkpoint, avec | |
| pour seule trace un `warnings.warn` que 25 h de log noient. Une recette qui | |
| continue de le passer decrit donc une quantification qui ne sera jamais | |
| appliquee. | |
| Ce fichier mesure ce fait sur la pile INSTALLEE plutot que de le supposer, puis | |
| verifie la decision qu'on en tire. | |
| """ | |
| import pathlib | |
| import textwrap | |
| import types | |
| import warnings | |
| import torch | |
| from scripts.training.base_quantization import ( | |
| build_model_init_kwargs, | |
| is_already_quantized, | |
| ) | |
| # --- Le fait, MESURE sur la pile installee -------------------------------- | |
| def test_transformers_ignores_a_passed_config_when_the_checkpoint_carries_one(): | |
| """La reponse a « erreur ? ecrasement silencieux ? avertissement ignore ? ». | |
| On appelle la fonction que `from_pretrained` appelle | |
| (`transformers/quantizers/auto.py`, `get_hf_quantizer` -> | |
| `merge_quantization_configs`) avec un config de checkpoint et un config | |
| d'appel VOLONTAIREMENT differents. Si un jour transformers se mettait a | |
| honorer celui qu'on passe, ce test rougit et la decision ci-dessous doit | |
| etre relue -- pas conservee telle quelle.""" | |
| from transformers import BitsAndBytesConfig | |
| from transformers.quantizers.auto import AutoHfQuantizer | |
| from_checkpoint = { | |
| "quant_method": "bitsandbytes", | |
| "load_in_4bit": True, | |
| "load_in_8bit": False, | |
| "bnb_4bit_quant_type": "nf4", | |
| "bnb_4bit_use_double_quant": True, | |
| "bnb_4bit_compute_dtype": "bfloat16", | |
| } | |
| ours = BitsAndBytesConfig( | |
| load_in_4bit=True, | |
| bnb_4bit_quant_type="fp4", | |
| bnb_4bit_use_double_quant=False, | |
| ) | |
| with warnings.catch_warnings(record=True) as caught: | |
| warnings.simplefilter("always") | |
| merged = AutoHfQuantizer.merge_quantization_configs(from_checkpoint, ours) | |
| # Ni erreur, ni fusion : les DEUX attributs qu'on a poses differents sont | |
| # revenus a la valeur du checkpoint. | |
| assert merged.bnb_4bit_quant_type == "nf4", ( | |
| "transformers a honore le quant_type passe a from_pretrained : la " | |
| "raison d'etre de ce module tombe, relire la decision." | |
| ) | |
| assert merged.bnb_4bit_use_double_quant is True | |
| # Et la seule trace est un avertissement -- pas une exception. | |
| assert any( | |
| "already has a `quantization_config`" in str(w.message) for w in caught | |
| ), f"aucun avertissement emis : {[str(w.message) for w in caught]}" | |
| def test_the_prequantized_fact_is_read_where_transformers_reads_it(): | |
| """`is_already_quantized` doit lire EXACTEMENT le meme fait que | |
| `get_hf_quantizer` (`pre_quantized = hasattr(config, "quantization_config")`), | |
| pas une heuristique sur le nom du depot -- un nom peut mentir, la config | |
| non.""" | |
| import inspect | |
| import pathlib | |
| import sys | |
| import sysconfig | |
| candidates = [ | |
| pathlib.Path(sysconfig.get_paths()[key]) | |
| / "transformers" | |
| / "quantizers" | |
| / "auto.py" | |
| for key in ("purelib", "platlib") | |
| ] | |
| candidates += list( | |
| pathlib.Path(sys.prefix).glob( | |
| "**/site-packages/transformers/quantizers/auto.py" | |
| ) | |
| ) | |
| source = None | |
| for candidate in candidates: | |
| if candidate.is_file(): | |
| source = candidate.read_text(encoding="utf-8", errors="replace") | |
| break | |
| assert source is not None, ( | |
| "transformers est installe mais sa source est introuvable : le garde " | |
| "se sauterait lui-meme alors qu'il a de quoi mesurer." | |
| ) | |
| assert 'pre_quantized = hasattr(config, "quantization_config")' in source | |
| # Et notre lecture est la meme. Verifie sur l'AST du CORPS, docstring | |
| # exclue : la seule chaine que la decision a le droit de connaitre est | |
| # "quantization_config". Une mutation vers une heuristique de nom | |
| # (`return "4bit" in repo`) introduit une autre chaine, et rougit ici. | |
| import ast | |
| tree = ast.parse(textwrap.dedent(inspect.getsource(is_already_quantized))) | |
| body = tree.body[0].body | |
| if isinstance(body[0], ast.Expr) and isinstance(body[0].value, ast.Constant): | |
| body = body[1:] # docstring | |
| strings = { | |
| node.value | |
| for statement in body | |
| for node in ast.walk(statement) | |
| if isinstance(node, ast.Constant) and isinstance(node.value, str) | |
| } | |
| assert strings == {"quantization_config"}, ( | |
| "la decision connait d'autres chaines que le nom de l'attribut de " | |
| f"config : {sorted(strings)}. Une heuristique sur le nom du depot " | |
| "(« -4bit », « bnb ») ferait mentir un depot mal nomme." | |
| ) | |
| # --- La decision qu'on en tire -------------------------------------------- | |
| def _prequantized_config(): | |
| """Un config de la forme que rend `AutoConfig.from_pretrained` sur un | |
| checkpoint bnb-4bit : l'attribut existe, c'est tout ce qui compte.""" | |
| return types.SimpleNamespace( | |
| quantization_config={ | |
| "quant_method": "bitsandbytes", | |
| "load_in_4bit": True, | |
| "bnb_4bit_quant_type": "nf4", | |
| } | |
| ) | |
| def test_no_bitsandbytes_config_is_handed_to_an_already_quantized_base(): | |
| kwargs = build_model_init_kwargs(_prequantized_config(), torch.bfloat16) | |
| assert "quantization_config" not in kwargs, ( | |
| "la recette repasse un BitsAndBytesConfig a un checkpoint qui en porte " | |
| "deja un : transformers l'ignore (voir le test mesure ci-dessus) et la " | |
| "recette decrit alors une quantification qui n'est jamais appliquee." | |
| ) | |
| def test_the_full_weights_base_is_still_quantized_on_the_fly(): | |
| """Le chemin ne doit PAS disparaitre : `TRAIN_BASE_MODEL` reste | |
| surchargeable, et pointer un depot de poids pleins sans quantifier ferait | |
| tenir 54 Go de bf16 en VRAM -- OOM immediat sur toute carte visee.""" | |
| kwargs = build_model_init_kwargs(types.SimpleNamespace(), torch.bfloat16) | |
| quantization = kwargs.get("quantization_config") | |
| assert quantization is not None, ( | |
| "un depot de poids pleins ne serait plus quantifie du tout : 54 Go de " | |
| "bf16 en VRAM." | |
| ) | |
| assert quantization.load_in_4bit is True | |
| assert quantization.bnb_4bit_quant_type == "nf4" | |
| assert quantization.bnb_4bit_use_double_quant is True | |
| assert quantization.bnb_4bit_compute_dtype == torch.bfloat16 | |
| def test_the_compute_dtype_travels_with_the_rest_in_both_cases(): | |
| """`dtype` et `trust_remote_code` ne dependent pas du point de depart : les | |
| perdre sur la branche pre-quantifiee chargerait en fp32 par defaut.""" | |
| for base_config in (types.SimpleNamespace(), _prequantized_config()): | |
| kwargs = build_model_init_kwargs(base_config, torch.bfloat16) | |
| assert kwargs["dtype"] == torch.bfloat16 | |
| assert kwargs["trust_remote_code"] is True | |
| # --- Un LoRA entraine sur du 4-bit s'applique-t-il a la meme architecture ? -- | |
| # | |
| # La question n'est pas rhetorique : c'est elle qui decide si l'adaptateur | |
| # publie pourra etre converti en GGUF contre la config de poids PLEINS que | |
| # `export_otaku_adapter.sh` donne a `convert_lora_to_gguf.py`. Si les noms de | |
| # modules ciblables changeaient entre les deux points de depart, le | |
| # convertisseur ne saurait plus a quoi rattacher les tenseurs -- et rien en | |
| # aval ne le dirait (ce depot a deja vu convert + ollama create + ollama run | |
| # sortir tous en code 0 sur un adaptateur inutilisable). | |
| # | |
| # On la tranche ICI, sans GPU : `replace_with_bnb_linear` s'execute sur CPU, et | |
| # `get_peft_model` rend les cles reelles de l'etat sauvegarde. | |
| def _script_target_modules() -> list: | |
| """Les `target_modules` REELS de la recette, lus dans son AST -- pas une | |
| liste recopiee qui divergerait au premier changement.""" | |
| import ast | |
| script = ( | |
| pathlib.Path(__file__).resolve().parents[2] | |
| / "scripts" | |
| / "training" | |
| / "train_otaku_qwen38.py" | |
| ).read_text(encoding="utf-8") | |
| for node in ast.walk(ast.parse(script)): | |
| if ( | |
| isinstance(node, ast.Call) | |
| and getattr(node.func, "id", None) == "LoraConfig" | |
| ): | |
| for keyword in node.keywords: | |
| if keyword.arg == "target_modules": | |
| return [element.value for element in keyword.value.elts] | |
| raise AssertionError("LoraConfig(target_modules=...) introuvable dans la recette") | |
| def _adapter_keys(model, target_modules): | |
| from peft import LoraConfig, get_peft_model | |
| peft_model = get_peft_model( | |
| model, LoraConfig(r=4, target_modules=target_modules, task_type=None) | |
| ) | |
| return sorted(key for key in peft_model.state_dict() if "lora_" in key) | |
| def _toy_model(target_modules): | |
| import torch.nn as nn | |
| class Block(nn.Module): | |
| def __init__(self): | |
| super().__init__() | |
| for name in target_modules: | |
| setattr(self, name, nn.Linear(8, 8)) | |
| # Les noms fusionnes de la tour vision, qui ne doivent JAMAIS etre | |
| # matches par la recette. | |
| self.qkv = nn.Linear(8, 24) | |
| self.linear_fc1 = nn.Linear(8, 8) | |
| class Model(nn.Module): | |
| def __init__(self): | |
| super().__init__() | |
| self.layers = nn.ModuleList([Block()]) | |
| self.lm_head = nn.Linear(8, 8) | |
| return Model() | |
| def test_the_adapter_keys_are_the_same_on_4bit_and_on_full_weights(): | |
| """Reponse mesuree : `bitsandbytes` remplace `nn.Linear` par | |
| `bnb.nn.Linear4bit` SOUS LE MEME NOM | |
| (`transformers/integrations/bitsandbytes.py` : | |
| `model._modules[name] = bnb.nn.Linear4bit(...)`), donc `target_modules` | |
| matche a l'identique et l'etat sauvegarde porte les memes cles. C'est ce | |
| qui rend l'adaptateur convertible contre la config de poids pleins que | |
| `export_otaku_adapter.sh` passe a convert_lora_to_gguf.py.""" | |
| from transformers import BitsAndBytesConfig | |
| from transformers.integrations.bitsandbytes import replace_with_bnb_linear | |
| targets = _script_target_modules() | |
| on_full_weights = _adapter_keys(_toy_model(targets), targets) | |
| quantized = _toy_model(targets) | |
| quantized = replace_with_bnb_linear( | |
| quantized, | |
| modules_to_not_convert=["lm_head"], | |
| quantization_config=BitsAndBytesConfig( | |
| load_in_4bit=True, | |
| bnb_4bit_quant_type="nf4", | |
| llm_int8_skip_modules=["lm_head"], | |
| ), | |
| ) | |
| # Anti-vacuite : sans ca, un `replace_with_bnb_linear` devenu sans effet | |
| # ferait passer le test en comparant deux fois le meme modele. | |
| replaced = { | |
| type(module).__name__ | |
| for name, module in quantized.named_modules() | |
| if name.endswith(tuple(targets)) | |
| } | |
| assert replaced == {"Linear4bit"}, ( | |
| "les modules cibles n'ont pas ete quantifies : la comparaison " | |
| f"ci-dessous ne prouverait rien ({replaced})." | |
| ) | |
| on_4bit = _adapter_keys(quantized, targets) | |
| assert on_full_weights == on_4bit, ( | |
| "les cles de l'adaptateur different selon le point de depart : " | |
| "convert_lora_to_gguf.py ne saurait plus a quoi rattacher les " | |
| "tenseurs, et rien en aval ne le dirait.\n" | |
| f"poids pleins : {on_full_weights}\n4-bit : {on_4bit}" | |
| ) | |
| assert on_4bit, "aucune cle LoRA : le harnais ne mesure rien" | |
| # Et la tour vision reste hors du LoRA, des deux cotes. | |
| assert not any( | |
| fragment in key for key in on_4bit for fragment in (".qkv.", ".linear_fc1.") | |
| ), "la recette matche des modules fusionnes de la tour vision" | |