>:j6FSSKrSSKrSSKrSSKrSSKrSSKJr SSKJr SSKJ r SSK J r SSK J r SSKJr SS KJr S \R$S \S \4S jr\R,"5SS\ S\\-S\S \\R$\R$\44Sjj5rSS\R4R6S\\-S\S\S \\\\\R$444 SjjrSS\\R>-S\R4R6S\\-S\S\S S4 Sjjr g)N) save_file)tqdm)Conv1D)BaseTunerLayer)SAFETENSORS_WEIGHTS_NAME)ModulesToSaveWrapper) LoraConfigS thresholdreturncUR5S:wa [S5eUS-n[R"USS9nUSnX-n[R"X55R 5nUS-$)Nr zInput vector must be 1d.r)dim)r ValueErrortorchcumsum searchsorteditem)r r energycstotalcutoffks X/home/mande/repo/quber/.venv/lib/python3.13/site-packages/peft/tuners/lora/conversion.py_find_cutoff_indexr sguuw!|344 TF f! $B rFE  F 2&++-A q5Lmodulerank adapter_namecURU5nURnUR5n[RR USS9upVn[ U[5(aUnO [XaS9nXRS:a[SUSURSS35eUSS2SU24USU-n USUn U RU5U RU5p[ UR5[5(a5U RR5U RR5U4$U R5U R5U4$) zgConvert a single BaseTunerLayer's adapter weight to a LoRA weight, return A, B, and the effective rank.F) full_matrices)r r zThe chosen rank z" is larger than the weight shape (z), please choose a lower rank.N)get_delta_weightdtypefloatrlinalgsvd isinstanceintrshapertoget_base_layerrT contiguous) rr r! delta_weight orig_dtypeUr Veffective_ranklora_Blora_As r_convert_module_to_lorar70sO **<8L##J%%'Lll|5AGA!$,A> "~..PQRQXQXYZQ[P\]   q/>/! "Q%7 7F  FYYz*FIIj,AF&'')622xx""$fhh&9&9&;^KK     1 1 3^ CCrmodel progressbarc j SSKJn [U[5(aSUs=:aS::dO [ SUS35eUS:Xa [ S5e/nSnSnUR 5HMn US- n[U [ 5(dMU RU5(aUS- nM<URU 5 MO UV s1sHn [[U 55iM n n U (a[SSRU 5S35eUS:Xa [S 5e[US 05RU5n U b0U RUR :Xa["R$"S 5 [U S [U SS55n U S:wa[ SU S35eSn 00['5S.nU bUR(Un [*R*"U R,5US'U R.US'[1U S5(aU R2US'U R4US'[U[65(a[9S%XS.UD6nO4[9S%SSS.UD6nO%[9S%[U[65(aUOS/S.UD6nUb[:R<"[>40UD6nO[>n0n[AURC5U(+SUS9GH unn [U [ 5(dM[1U S5(d[S[U 5S35eU"XUS9unnnUS:Xa,URDRGURIU 55 MUU:wd[UR,[J5(a=UURLURIU 5'UURNURIU 5'O*UR,RGURIU 55 UUUS 3'UUUS!3'GM# U(d [ S"5eU b[U S#S 5(a[*R*"U RP5Ul(URC5Hunn [U [R5(dMU RPRU5HDunnURWS$5un nURYS5u nnURZUUSU3'MF M UU4$s sn f)&a Convert a non-LoRA model with PEFT layers to a LoRA checkpoint. This is only supported for some specific PEFT methods that allow an equivalent conversion. Essentially, this comes down to PEFT methods that work by updating the base weight with a delta weight. Also, right now, only linear layers are supported. The LoRA adapter will try to approximate the initial adapter as close as possible. The higher the rank, the better the approximation. It is expected that the approximation will never reach the full performance of the original adapter, and that the parameter efficiency of the LoRA adapter will be less than that of the original adapter (i.e. for a similar performance, it will require more parameters). The conversion can still be useful in many situations: - In PEFT, LoRA supports more features than most other methods, e.g. mixed adapter batches. Thus the converted adapter can be used with those features. - Some downstream packages support LoRA adapters, but not other PEFT methods, e.g. Diffusers. The conversion allows to use a non-LoRA adapter with those packages. The LoRA scaling factor is already baked into the LoRA weights, thus the scaling will always be one (i.e. rank and alpha are chosen to be identical). Note: This function does not support sharded models (yet). Args: model: The model to be converted. Should be a model that has PEFT layers that support conversion. rank (`int` or `float`): The desired rank for the returned LoRA adapter. A higher rank results in a LoRA adapter that more accurately mirrors the original adapter. It will, however, also require more memory, compute, and disk space. Therefore, choose a value that represents the best trade off for your use case and validate the final adapter. If a float is passed, it is interpreted as an explained variance / energy threshold: we pick the smallest rank k such that the top k singular values account for at least that fraction of the total squared singular values. This effectively results in lower ranks being assigned if a few singular can capture the adaptation of this layer. A lower float means the rank is lower and vice versa. Be aware that dynamic ranks can lead to very unequal ranks per layer, which means that some layers may require a disproportionally high amount of memory for activations. Choosing a fixed (int) rank is better to achieve predictable memory requirement. adapter_name (`str`, *optional*): The name of the adapter to be converted. Can only convert a single adapter at a time. Defaults to `"default"`. progressbar (`bool`): whether to show a progressbar indicating the progress of the conversion (it can take a few minutes for big models). compile_kwargs (`dict`, *optional*): If provided, compile the function to convert individual modules to LoRA with the given kwargs being passed to `torch.compile`. This can potentially speed up the conversion on large models. Returns: lora_config (`LoraConfig`) The `LoraConfig` that corresponds to the converted LoRA adapter. state_dict (`dict[str, torch.Tensor]`) The `state_dict` containing the LoRA weights. Raises TypeError: If the provided model does not have any layers that can be converted to LoRA, a `TypeError` is raised. ValueError: If an invalid rank was chosen (too high or too low). r)PeftTyper zYIf rank is a float, it is interpreted as a threshold. It must be between 0 and 1 but got .zBPassing a rank of 0 doesn't make sense, please pass a valid value.z@Some module types on this model do not support LoRA conversion: z, z9Could not detect any layer that supports LoRA conversion. peft_configNzfConverting a PEFT adapter to LoRA that is already a LoRA adapter. There is typically no need for that.bias lora_biasnonezThe adapter's config sets bias=z", this is not supported right now.zbase_model.model.) rank_pattern alpha_patternexclude_modulestarget_modulesbase_model_name_or_pathlayers_patternlayers_to_transform)r lora_alpha)rHrDzConverting to LoRA)disabledescrr$zModule of type z does not have a get_delta_weight method, which is required for conversion. Please open an issue: https://github.com/huggingface/peft/issues)r r!z.lora_A.weightz.lora_B.weightzDid not convert a single layer, this means that something went wrong. Please open an issue: https://github.com/huggingface/peft/issuesmodules_to_savez.modules_to_save.).peftr;r)r&rmodulesrsupports_lora_conversionappendreprtype TypeErrorjoingetattrget peft_typeLORAwarningswarnsetr=copyrDrEhasattrrFrGr*r rcompiler7r named_modulesrCadd removeprefixstrrArBrLrnamed_parameters partition rpartitiondata)r8r r!r9compile_kwargsr;modules_not_supporting_loranum_modules_with_supportnum_modules_totalr unsupportedr= config_bias peft_prefix config_kwargs lora_configconvert_module_to_lora state_dictnamer6r5r4 module_name param_nameparamprefix_suffixs rconvert_to_lorarzQsB $D A ghlgmmn o   ]^^#% --/Q&.11   * *< 8 8 $ ) $ ' . .v 6"5PP4O&4V %4OKPZ[_[d[dep[qZrrstuu1$STT%377 EKk&;&;x}}&L t +vw{KQW/XYKf:;-Gijkk &K5M '' 5 *.))K4N4N*O &'3>3V3V /0 ; 0 1 1.9.H.HM* +3>3R3RM/ 0 dC $NtN NK%HqQH-HK!  s++d  !!&/F!Y.!Y!8 J ;=QYj f&.11 v122!$v,0__  *@`l)m& Q   ' ' + +D,=,=k,J K  d "z+2L2Lc'R'RHVK $ $T%6%6{%C DHVK % %d&7&7 &D E  & & * *4+<+<[+I J/5 dV>*+.4 dV>*+EH  9   W[:KT%R%R&*ii 0K0K&L ##(#6#6#8 K&"677)/)?)?)P)P)R%J#.#8#89L#MLFAq#-#8#8#=LAq&7>> lora_path = ... >>> save_as_lora(lora_path, model, rank=...) >>> base_model = AutoModel.from_pretrained(...) >>> lora_model = PeftModel.from_pretrained(base_model, lora_path) ``` Note: This function does not support sharded models (yet). Args: model: The model to be converted. Should be a model that has PEFT layers that support conversion. rank (`int` or `float`): The desired rank for the returned LoRA adapter. A higher rank results in a LoRA adapter that more accurately mirrors the original adapter. It will, however, also require more memory, compute, and disk space. Therefore, choose a value that represents the best trade off for your use case and validate the final adapter. If a float is passed, it is interpreted as an explained variance / energy threshold: we pick the smallest rank k such that the top k singular values account for at least that fraction of the total squared singular values. This effectively results in lower ranks being assigned if a few singular can capture the adaptation of this layer. A lower float means the rank is lower and vice versa. Be aware that dynamic ranks can lead to very unequal ranks per layer, which means that some layers may require a disproportionally high amount of memory for activations. Choosing a fixed (int) rank is better to achieve predictable memory requirement. adapter_name (`str`, *optional*): The name of the adapter to be converted. Can only convert a single adapter at a time. Defaults to `"default"`. progressbar (`bool`): whether to show a progressbar indicating the progress of the conversion (it can take a few minutes for big models). compile_kwargs (`dict`, *optional*): If provided, compile the function to convert individual modules to LoRA with the given kwargs being passed to `torch.compile`. This can potentially speed up the conversion on large models. Raises TypeError: If the provided model does not have any layers that can be converted to LoRA, a `TypeError` is raised. ValueError: If an invalid rank was chosen (too high or too low). )r r!r9rhN) pathlibPathexistsosmakedirsrzrrsave_pretrainedrc)r{r8r r!r9rhrprrs r save_as_lorar*saJ << D ;;== D- |]kKj!99:D *r)default)rFN)!r]rr}rZrsafetensors.torchrrtransformers.pytorch_utilsrpeft.tuners.tuners_utilsr peft.utilsrpeft.utils.otherrconfigr Tensorr&r*rno_gradrctupler7nnModulebooldictrzPathLikerrMrrrsr  '-3/1 %,, 5 S  CLD D"%+D=@D 5<<s *+DDF" V# 88??V# +V#V# V#  :tC-. ./ V#z" M+  M+ 88??M+ +M+ M+  M+ M+r