bi dddlmZddlZddlZddlZddlZddlZddlmZm Z ddlm Z ddl m Z ddl mZmZmZmZddlZddlZddlZddlmZmZddlmZmZmZdd lmZmZdd l m!Z!m"Z"m#Z#m$Z$dd l%m&Z&dd l'm(Z)dd l*m+Z+m,Z,m-Z-ddlm.Z.m/Z/m0Z0m1Z1m2Z2ddl3m4Z4m5Z5m6Z6ddl7m8Z8ddl9m:Z:m;Z;ddlm?Z?ddl@mAZAmBZBddlCmDZDddlEmFZFddlGmHZHmIZImJZJddlKmLZLmMZMmNZNmOZOmPZPmQZQmRZRmSZSmTZTmUZUmVZVmWZWmXZXmYZYmZZZm[Z[Gdde8ejjZ^Gdde^Z_Gdde^Z`Gd d!e^ZaGd"d#e^ZbGd$d%e^ZcGd&d'e^Zde Gd(d)Zed/d*Zfe Gd+d,Zgd0d-Zhd.Ziy)1) annotationsN)contextmanager nullcontext)deepcopy) dataclass)AnyLiteralOptionalUnion)dispatch_modelinfer_auto_device_map)AlignDevicesHookadd_hook_to_moduleremove_hook_from_submodules)get_balanced_memorynamed_module_tensors) HfFileSystem ModelCard ModelCardDatahf_hub_download) safe_open) save_file)BCEWithLogitsLossCrossEntropyLossMSELoss)Cache DynamicCacheEncoderDecoderCache HybridCachePreTrainedModel)QuestionAnsweringModelOutputSequenceClassifierOutputTokenClassifierOutput)PushToHubMixin) BaseTunerBaseTunerLayer)DUMMY_MODEL_CONFIG)init_empty_weights)create_attention_mask set_additional_trainable_modules) __version__) PeftConfig)PEFT_TYPE_TO_CONFIG_MAPPINGPEFT_TYPE_TO_PREFIX_MAPPINGPEFT_TYPE_TO_TUNER_MAPPING)SAFETENSORS_WEIGHTS_NAME8TRANSFORMERS_MODELS_TO_PREFIX_TUNING_POSTPROCESS_MAPPING WEIGHTS_NAMEPeftTypeTaskType_get_batch_size_prepare_prompt_learning_config _set_adapter_set_trainableget_peft_model_state_dictid_tensor_storage infer_deviceload_peft_weightsmap_cache_to_layer_device_mapset_peft_model_state_dictshift_tokens_rightcfeZdZdZ d$ d%fd Zed&dZed'dZejd(dZ d) d*dZ e d+ d,dZ d-dZ d.d Z d.d Zd/fd Z d0 d1d Zd2d Zd3dZd4fd ZedZd5dZdZd6dZedZd7dZd6d8dZd9dZed:dZd;dZddZ!d?dZ" d@ dAdZ#d9dZ$ed Z%ed!Z&d"Z'dBd#Z(xZ)S)C PeftModelaH Base model encompassing various Peft methods. Args: model ([`~transformers.PreTrainedModel`]): The base transformer model used for Peft. peft_config ([`PeftConfig`]): The configuration of the Peft model. adapter_name (`str`, *optional*): The name of the adapter, defaults to `"default"`. autocast_adapter_dtype (`bool`, *optional*): Whether to autocast the adapter dtype. Defaults to `True`. Right now, this will only cast adapter weights using float16 and bfloat16 to float32, as this is typically required for stable training, and only affect select PEFT tuners. low_cpu_mem_usage (`bool`, `optional`, defaults to `False`): Create empty adapter weights on meta device. Useful to speed up the loading loading process. Don't use `low_cpu_mem_usage=True` when creating a new PEFT adapter for training. **Attributes**: - **base_model** ([`torch.nn.Module`]) -- The base transformer model used for Peft. - **peft_config** ([`PeftConfig`]) -- The configuration of the Peft model. - **modules_to_save** (`list` of `str`) -- The list of sub-module names to save when saving the model. - **prompt_encoder** ([`PromptEncoder`]) -- The prompt encoder used for Peft if using [`PromptLearningConfig`]. - **prompt_tokens** (`torch.Tensor`) -- The virtual prompt tokens used for Peft if using [`PromptLearningConfig`]. - **transformer_backbone_name** (`str`) -- The name of the transformer backbone in the base model if using [`PromptLearningConfig`]. - **word_embeddings** (`torch.nn.Embedding`) -- The word embeddings of the transformer backbone in the base model if using [`PromptLearningConfig`]. ct|||_|j|_dh|_|j |_|j r%||i|_||_|j|||nId|_t|j}|rtnt}|5||||i||_dddt|jdr|jj||t|ddr|j!|}t|jdr=t|jj"drd |jj"_yyy#1swYxYw) N adapter_nameslow_cpu_mem_usage_cast_adapter_dtype adapter_nameautocast_adapter_dtypeis_gradient_checkpointingTconfigpretraining_tpr+)super__init__active_adapter peft_typespecial_peft_forward_argsis_prompt_learning_is_prompt_learning _peft_config base_model add_adapterr0r(rhasattrrGgetattr(prepare_model_for_gradient_checkpointingrLrM) selfmodel peft_configrIrJrFclsctx __class__s J/home/cdr/jupyterlab/.venv/lib/python3.12/site-packages/peft/peft_model.pyrOzPeftModel.__init__isT *$..+:):&#.#A#A  # #!-{ ;D #DO   \;J[  \ $D ,[-B-BCC(9${C X"%elK-H,"W X 4??$9 : OO / /)BX 0  55t <AA%HE 4??H -'$//:P:PRb2c45DOO " " 13d - X Xs !E  E)c^|jr |jS|jjSNrTrUrVr]r[s rar]zPeftModel.peft_configs'  # #$$ $***c |jj}t|ts|j}t|t r|g}|S#t $r#|j}t|t r|g}Y|SwxYwrc)rVactive_adapters isinstancelistrPstrAttributeError)r[adapterss rarhzPeftModel.active_adapterssx &66Hh-  ..h, (zH   &**H(C($:  &sAA (A54A5cN|jr||_y||j_yrcrd)r[values rar]zPeftModel.peft_configs  # # %D */DOO 'rfc  tjj|rtd|d|$t j j }nGtfd|Dr3tdt j j d|dfd}|r(tj|d j||D]} j | } t|jd d| | } | d k7r tjj|| n|} tj| d |r`|r]tjt} | jD]Z\}}t!|t"j$r| t'|j)|>| t+|j)|\| jDcic]\}}t-|dkDs||}}}|jD]%\}}|ddD]}| |j/| |<'|8t1j2| } d | _| j7||| || |} t9| tjj| t:ddint|rr|8t1j2| } d | _| j7||| || |} t#j<| tjj| t>| j@g| jBr&jDjFjddn/jDjHjFjdd| _ | jJ}d | _%| jL8jO| jB}|jP}|jR|d}nd}|r|d | _| xjTdzc_*| jVs| xjXdzc_,n| xjXdzc_,| jZr6| jZjDcic] \}}|d|z c}}| _-| j\r6| j\jDcic] \}}|d|z c}}| _.| j7| ||| _% ycc}}wcc}}wcc}}w)u This function saves the adapter model and the adapter configuration files to a directory, so that it can be reloaded using the [`PeftModel.from_pretrained`] class method, and also used by the [`PeftModel.push_to_hub`] method. Args: save_directory (`str`): Directory where the adapter model and configuration files will be saved (will be created if it does not exist). safe_serialization (`bool`, *optional*): Whether to save the adapter files in safetensors format, defaults to `True`. selected_adapters (`List[str]`, *optional*): A list of adapters to be saved. If `None`, will default to all adapters. save_embedding_layers (`Union[bool, str]`, *optional*, defaults to `"auto"`): If `True`, save the embedding layers in addition to adapter weights. If `auto`, checks the common embedding layers `peft.utils.other.EMBEDDING_LAYER_NAMES` in config's `target_modules` when available. and automatically sets the boolean flag. This only works for 🤗 transformers models. is_main_process (`bool`, *optional*): Whether the process calling this is the main process or not. Will default to `True`. Will not save the checkpoint if not on the main process, which is important for multi device setups (e.g. DDP). path_initial_model_for_weight_conversion (`str, *optional*`): The path to the initialized adapter, which is obtained after initializing the model with PiSSA/CorDA/OLoRA and before performing any training. When `path_initial_model_for_weight_conversion` is not None, the difference in adapter before and after fine-tuning is calculated. This difference can be represented as the parameters of a standard LoRA adapter. Using this converted adapter does not require changes to the base model, thus conveniently allowing the use of multiple PiSSA/CorDA/OLoRA adapters with LoRA adapters, and the activation or deactivation of any adapters. Note that this conversion is not supported if `rslora` is used in combination with `rank_pattern` or `alpha_pattern`. kwargs (additional keyword arguments, *optional*): Additional keyword arguments passed along to the `push_to_hub` method. zProvided path (z#) should be a directory, not a fileNc3hK|])}|tjjv+ywrc)rjr]keys).0selected_adapter_namer[s ra z,PeftModel.save_pretrained..s2)&T$2B2B2G2G2I-JJs/2zYYou passed an invalid `selected_adapters` arguments, current supported adapter names are z - got .cTjr%js jr d}t|t fddDst j dtjj|} jtjj|||t j|jjj!d}t j|jjdk(}t j|jjdk(}|s|s|r td  j"j%|||} j'||S# j'|wxYw) NzPassing `path_initial_model_for_weight_conversion` to `save_pretrained` is not supported when using `rank_pattern` or `alpha_pattern` at the same time as `use_rslora=True`.c3K|]6}tjjj|8ywrc)rkinit_lora_weightslower startswith)rsprefixr]s raruzJPeftModel.save_pretrained..save_mutated_as_lora..s8K11288:EEfMs.save_mutated_as_loras%%;+C+C{G`G`e!o%A %$&77#3#34\#]  :!!GGOO$LM2!5" t//0DEWWX^^`kklstt//0DEWWX^^`dkkt//0DEWWX^^`dkkx8$* %)OO$I$I%';V%!##$89$ $##$89s =DFF'T)exist_ok state_dict)rrIsave_embedding_layersdefaultr+formatptmetadata name_or_path)is_prompt_tuning)base_model_classparent_libraryg;f?)auto_mapping_dict)/rrisfilerrjr]rrrmakedirscreate_or_update_model_cardr:getjoin collections defaultdictitemsritorchTensorr;appendidlenclonecopyrrysave_pretrainedsafe_save_filer1saver3base_model_name_or_pathrSrV__dict__r\inference_mode task_type_get_base_model_class __module____name__rr lora_alpharr)r[save_directorysafe_serializationselected_adaptersris_main_processrrrrIr]r output_dirptrsnametensorptrnames shared_ptrs_shared_tensor_namerrrrkeyvals` rarzPeftModel.save_pretrainedsT 77>>. )~.>>abc c  $ $T%5%5%:%:%< = ->!T--22456g>O=PPQS % %N  KK 6  , ,^ <-` 8L**<8K 9!::lD9)&; !  HTW`G`nlCftJ KK T 2#5#..t4$5$;$;$=6LD&"&%,,7.v67>>tDRZ(//56=AJJL[jc5CPUJYZNsEz[ [ + 1 1 3nHAu/4ABin*@QRd@e@k@k@m)*<=nn <G"&-- "$ "2!0))$jjd;#ZZ D9$jjd;#)::.>#E **Wd3  oh 2+1 2F +(4$4F !J6K[K[J\]^ ^  &*C*C!%)I2NK 6+ ,:OF ! ! 7$ cd 5/ *25$GHJ5LE % 3 3 5 I f6:.76??L^3_v::IF & ; ; C C I I%??DDFI!??;;C@ELLQWDXX(,,SY_s3x-GHI  IFJJ/@$$G ![\\(__. ! L( ,1!H5G,H'(!$Z]%8%8!9!A!A(B!O! !+8' E?D 1 =3 ##**, - : :E6? KD D ( .  $ $qr r(4$4F ! ge\48* Efk2"?V ~Z XYYV#"("4ww~~h/$AGHdd8n%>BX\]cXdhsXsV S]Q%6%89%M%%'M(5W 68ggll8X6V l3W&3FO)6F&!/()qrr   #C#H#H#J J'="3 EG4V5E5EF'="3 E)e((    /#   #// 3Gq3PUemnUnA    WWcVddefL044V5E5EFF,&0#L>1XY_X`aSS MM, ' }!@%T s$?>T TT T (T -T c|j|}t|ds+tjj i|_i|_d}|jjD]>\}}|jD] }d|_ t|ts3|6|}||_ @| |j}|j&|jt j"k(rdnd|_d} |jj%d}|!t)|j+D]\}} t-| dd} t|jj.dr/|jj.j1j2} ncd|jj.vr+|jj.j4j2} n |jj.j2} | j6d | k(s | | d | k(s|j%|j9d d }n||_t<|j>} |j>t@jBt@jDt@jFfvr| ||j:} n|j>t@jHk(r | |} nj|j>t@jJk(rBtMd |jOjQDr tSd | |} n tSd| jU|jV} |j jYtjj || itjZ|j\|jzj_|j |<y#t&$rYwxYw)NrFrr+zembeddings.word_embeddingsds_shapeget_text_config text_configrz.weightrc36K|]}t|ddyw)gradient_checkpointingFNrY)rsr s raruz2PeftModel._setup_prompt_encoder..sr76#;UCrsz8Prefix tuning does not work with gradient checkpointing.z Not supported)0r]rXrnn ModuleDictr prompt_tokensrVnamed_children parameters requires_gradrir transformer_backbone_namenum_transformer_submodulesrr5 SEQ_2_SEQ_LM get_submodulerlrjnamed_parametersrYrLr vocab_sizershaperword_embeddingsr0rQr4 PROMPT_TUNINGMULTITASK_PROMPT_TUNINGCPTP_TUNING PREFIX_TUNINGrget_base_modelmodulesrtorupdatearangenum_virtual_tokenslong)r[rIrLtransformer_backbonerr paramr% named_paramro"deepspeed_distributed_tensor_shaper# model_clsrs ra_setup_prompt_encoderzPeftModel._setup_prompt_encoderMsJ!!,/t-."'(("5"5b"9D !#D # OO::< :LD&**, ,&+# ,&/2'/+1(59D2 : '#'??  , , 45;5E5EI^I^5^deF - #oo;;Z/6B:1=K&:&H&HI\I\]fhjIk&lO+ . /.v/?/?@    6 68X8XZbZfZfg g&vt/C/CDN   !2!2 2&v.N   !7!7 7rRVReReRgRoRoRqrr ![\\&v.N_- -'**4;;7 ""588#6#6 n7U#VW+0<<  % %(I(I I, $& <(]   s'N<< O O c&|j|y)zL Prepares the model for gradient checkpointing if necessary N))_prepare_model_for_gradient_checkpointing)r[r\s rarZz2PeftModel.prepare_model_for_gradient_checkpointings 66u=rfct|ddsft|ddsYt|ddsLt|dr|j|St|dr"d}|jj ||S)Nis_loaded_in_8bitFis_loaded_in_4bit is_quantizedenable_input_require_gradsget_input_embeddingsc&|jdy)NT)requires_grad_)r inputoutputs ramake_inputs_require_gradzUPeftModel._prepare_model_for_gradient_checkpointing..make_inputs_require_grads))$/rf)rYrXr>r?register_forward_hook)r[r\rDs rar9z3PeftModel._prepare_model_for_gradient_checkpointingsw E. 6u159une4u:;002  670**,BBC[\ rfcz|j|}|j|jdjddj |j j j}|j|j}|j|jtjk(r"|ddd|j|jf}|j|jtjk(rt|}t||C|}n||}|dj#j%S)z Returns the prompt embedding to save when saving the model. Only applicable when using a prompt learning method. rr+N)rr unsqueezeexpandr- embeddingweightrr]rQr4r*r0r'r0rNforwarddetachr)r[rIrrrQprompt_embedding_clsprompt_embeddingsr`s raget_prompt_embedding_to_savez&PeftModel.get_prompt_embedding_to_saves  ,,\:   | , 6 6q 9 @ @B G J J>KcKcKjKjKqKq r $$\2<<   L ) 3 3x7M7M M)!-`t/?/? /M/`/`-`*`aM   L ) 3 3x7W7W W#=i#H %&:N STa b  .} =  #**,0022rfc|j}|j|j}|j|jj dj |dj |jjj}|jtjk(r7|ddd|jf}|jr(|jjj|dd}n||}|j |j |j }|j#||j|j$dz|j&|j(|j&z}|j*dk(rt-j.||gd}|j1gdj3|j*dz}|j5}t7|dd} t7| d d } t9j:|j<j>d't8|j<j>} | |}nd | vsd | vr| tAd |j<} tC| dr| jE} tG| |||djH|dj} t-jJ|j|dj}tM|j$D])}|d||d|}}| jO|||d|i+| }n|j*dk(rtQjR|}n|j*dk(rwt7|jTddr`tWjR|}tQ|_,tMt[|jXj\Dcic]}|dc}|_/ta|j5||S|jtjbk(r |||}|S|jr|jj}n |dd}||}|j|dd}|Scc}w)zs Returns the virtual prompts to use for Peft. Only applicable when using a prompt learning method. rrGNr+rdim)rrr+rL model_typergemma2 gemma3_textzmax_cache_len is None but it should have been passed. Something went wrong, please open an issue on GitHub with a reproducer: https://github.com/huggingface/peft/issuesr)max_batch_size max_cache_lenrrrcache_position) cache_kwargs_supports_cache_classTF)2active_peft_configrrPrrHrIr-rJrKrrQr4r*r0rrepeatbase_model_torch_dtypeview num_layersnum_attention_heads token_dimrrcatpermutesplitr+rYr2rrLrVrrXrrrr/ranger.rfrom_legacy_cacherVrcross_attention_cacher key_cache is_updatedr>r')r[ batch_sizetask_idsrZr]rrpast_key_valuesrV model_configrVpost_process_fn base_config new_cacher\ layer_idx key_states value_statespromptss ra get_promptzPeftModel.get_prompts" -- ,,T-@-@A   t22 3 Yq\ VJ # R((//66 7   H$:$: :)!-M{/M/M-M*MNM))"0":":"A"A"H"HUVXY"Z"0"?**6"1"4"4T5P5P"Q-22..&&*//%%)H)HH O55:"'))_o,NTU"V.55oFLL66:O,,.J":x>L |R@JGKKDKKLbLbdhiu"Z[_[f[f[q[q"r"1/"Bj(mz.I ($h)// ;(9:"-"="="?K'#-"/)!,22*1-44  "'k.L.LUdefUgUnUn!o!&{'='=!>I/>q/A)/Lo^_N`ajNk J$$"L)K[]kJl% #,771<#/"@"@"Q88A=7!8$D #6"G"G"X8D56;C@e@e@o@ocr|s |jjjS|jjS)z/ Returns the base model class. )rVr\r`)r[rs rarzPeftModel._get_base_model_classxs- ??((22 2(((rfc#K|j|jjrb |j}|jj|_|j }|jj |_d||_||_y|j|jj r: |jjd|jjy|j}|jdk(rtjd |jjd|jdur|jjyy#|_|_wxYw#|jjwxYw#|jdur|jjwwxYww)z Context manager that disables the adapter module. Use this to run inference on the base model. Example: ```py >>> with model.disable_adapter(): ... model(inputs) ``` N irregularzThe model contains some adapter layers that are enabled and others that are disabled. This is most likely unintentional. After exiting the disable_adapter context, all adapters will be enabledF) r]rPrSrLrVprepare_inputs_for_generationis_adaption_promptdisable_adapter_layersenable_adapter_layersget_model_statusenabledrr)r[ old_forward!old_prepare_inputs_for_generation model_statuss radisable_adapterzPeftModel.disable_adaptersk   D// 0 C C W#ll #66 484V4V159__5b5b2* 5V2   d11 2 E E 8668557 002L##{2 &  <668''u4OO99;5- + 5V2557 ''u4OO99;5sN$GAE"92G,E5 AGF8*G"E22G5FG+F??Gc|jjs|jtjk(r |j S|j j S)z) Returns the base model. )r_rSrQr4POLYrVr\res rar+zPeftModel.get_base_modelsG ''::dnnPXP]P]>] OO && rfctj|j}|r ||vrtjd|d|d|j|jk7r&t d|jd|jd |j r||j|<t|jdr|jj}n |j}t||}|j|t|j|tj ||y |j"rI|jj%||t|j|tj ||y ||j|<|jj'|jj(|| y #t*$r||jvr |j|=wxYw) _ Add an adapter to the model based on the passed configuration. This adapter is not trained. To load a trained adapter, check out [`PeftModel.load_adapter`]. The name for the new adapter should be unique. The new adapter is not automatically set as the active adapter. Use [`PeftModel.set_adapter`] to set the active adapter. Args: adapter_name (`str`): The name of the adapter to be added. peft_config ([`PeftConfig`]): The configuration of the adapter to be added. low_cpu_mem_usage (`bool`, `optional`, defaults to `False`): Create empty adapter weights on meta device. Useful to speed up the process when loading saved adapters. Don't use this option when creating a new PEFT adapter for training. rrzI.This may lead to reinitialization of the adapter weights during loading.z9Cannot combine adapters with different peft types. Found z and rvto_dict)r\r]rqrIrEN)r/rrQrrrrSr]rXrLrr7r7r*rVr%get_model_configrrWinject_adapterr\ Exception)r[rIr]rFr| dict_configs rarWzPeftModel.add_adapters*-001F1FG lf, MM ~-TU[T\][[   DNN 2(k.C.C-DAG  --1<  .4;; 2"&++"5"5"7K"&++K=k;W **<80// +!*!;!;D!A!-  //++L+F0// +!*!;!;D!A!- 2=  ...OO))S*S&*4+=+=+?&@&Q %k>B(7-(G(S]S^J_(_IBRBXBXBZ(uhc3^mqt^tc(uI(u7@oo6G> 2()1)<*27F*;,>P*PS[\b\cSd*d5= ' 2> )/(9H(DI/: ),#;$NN9- )~~/aBK\_-` c*a!# :I77>>)4 I."9i(K9LL* L'= LT)vLLs&BL)! L#.L#3C!L)#L))L3 c|jr |r td|gt|jj z}t |dkDrt d|Drd}tj|y t d|Drd}tj|y t d|Drd}tj|y y y ) z?Perform checks on newly added PEFT configs to ensure integrity.rr+c3<K|]}t|dddk(yw)ryNr}rrsrLs raruz6PeftModel._check_new_adapter_config..scV76#6=HczPiSSA changes the base weights of the model and should thus not be used with other adapters. Consider converting the PiSSA adapter into a normal LoRA adapter: https://github.com/huggingface/peft/tree/main/examples/pissa_finetuning#convert-pissa-to-lorac3<K|]}t|dddk(yw)ryNr~rrs raruz6PeftModel._check_new_adapter_config..evWV%8$?7JerzCorDA changes the base weights of the model and should thus not be used with other adapters. Consider converting the CorDA adapter into a normal LoRA adapter: https://github.com/huggingface/peft/tree/main/examples/corda_finetuning#convert-corda-to-lorac3<K|]}t|dddk(yw)ryNrrrs raruz6PeftModel._check_new_adapter_config..rrzOLoRA changes the base weights of the model and should thus not be used with other adapters. Consider converting the OLoRA adapter into a normal LoRA adapter: https://github.com/huggingface/peft/tree/main/examples/olora_finetuning#olora-and-loraN) rSrrjr]rrrrr)r[r]r all_configsrs ra_check_new_adapter_configz#PeftModel._check_new_adapter_configs  ) )lqr r#md4+;+;+B+B+D&EE { a cWbcct  c"eYdeet  c"eYdeem  c" f rfc  ddlm} |j| \} } | t}||jvr[| t j |fi| j|fd|i| } |j| || | _ |j|| |t|f||d| } | jdd }t|| ||| }|j|j}tj|d }g}|j D]}||vs||vs |j#||j j%|j j'|t)|d dt+t-|j.j1j3d dhdkDrmt+|jdk(rT| jdd}| jdd}| jdd}| jdd}| jdd}| | t5d||}i}dt7j8t:j<vr||d<|j>}|dk7rtA||||dk(}tC|tDrtG|||}|jI|| ||d<t;|f||d|tKd}|j|jLrtO|jPtS|jU|tW|jXdr|jXj[|||s|j]|S) a Load a trained adapter into the model. The name for the new adapter should be unique. The new adapter is not automatically set as the active adapter. Use [`PeftModel.set_adapter`] to set the active adapter. Args: model_id (`str` or `os.PathLike`): The name of the PEFT configuration to use. Can be either: - A string, the `model id` of a PEFT configuration hosted inside a model repo on the Hugging Face Hub. - A path to a directory containing a PEFT configuration file saved using the `save_pretrained` method (`./my_peft_config_directory/`). adapter_name (`str`): The name of the adapter to be added. is_trainable (`bool`, *optional*, defaults to `False`): Whether the adapter should be trainable or not. If `False`, the adapter will be frozen and can only be used for inference. torch_device (`str`, *optional*, defaults to None): The device to load the adapter on. If `None`, the device will be inferred. autocast_adapter_dtype (`bool`, *optional*, defaults to `True`): Whether to autocast the adapter dtype. Defaults to `True`. Right now, this will only cast adapter weights using float16 and bfloat16 to float32, as this is typically required for stable training, and only affect select PEFT tuners. ephemeral_gpu_offload (`bool`, *optional*, defaults to `False`): Whether to use ephemeral GPU offloading for partially loaded modules. Defaults to `False`. low_cpu_mem_usage (`bool`, `optional`, defaults to `False`): Create empty adapter weights on meta device before loading the saved weights. Useful to speed up the process. key_mapping (dict, *optional*, defaults to None) Extra mapping of PEFT `state_dict` keys applied before loading the `state_dict`. When this mapping is applied, the PEFT-specific `"base_model.model"` prefix is removed beforehand and the adapter name (e.g. `"default"`) is not inserted yet. Only pass this argument if you know what you're doing. kwargs: (`optional`): Additional arguments to modify the way the adapter is loaded, e.g. the token for Hugging Face Hub. r+)r.Nr)rrE)rrignore_mismatched_sizesF)rIrrFrrrrr device_mapr max_memoryoffload_folder offload_dirrzL t// /5)), o '< ) K  * *;\ * R-9)9K &   \;J[  \,  ){ F\  #)**-F"N/  %$;/    .88266ubA !++ 1Cs"|s':$++C0 1   &&(  ''(<=T?D 1 =S++2245BBE6?STWXXD$$%*L&9JL$7J#ZZ(8$?N **]D9K"JJ=M&>+E !_``$, $& !'"3"3N"C"N"NN9F%o6&*&<&< #\)0),C(,<<  *c*2ZI`   0@ A5B !/ 2  %' (  $48D -@@+D,?,?@ t224d ; 4??$9 : OO / /)BX 0   IIKrfc||jvrtd|d||_|j|js|jj |t ||y)aa Sets the active adapter. Only one adapter can be active at a time. Additionally, this function will set the specified adapter to trainable (i.e., requires_grad=True). If this is not desired, use the following code. ```py >>> for name, param in model_peft.named_parameters(): ... if ...: # some check on name (ex. if 'lora' in name) ... param.requires_grad = False ``` Args: adapter_name (`str`): The name of the adapter to be set as active. The adapter must be loaded first. rz not found.N)r]rrPrSrV set_adapterr8)r[rIs rarzPeftModel.set_adapters^& t// /x ~[AB B* -@@ OO ' ' 5T<(rfc0t|jddS)Nr)rYrVres raraz PeftModel.base_model_torch_dtypest66rfc4|j|jSrc)r]rPres rar_zPeftModel.active_peft_configs 3 344rfc|jj}t|ts |j}g}t |j dr?t|j jtjr|jd|dk(r|jdt |j dr(|jd|j j|S)zDerive tags for the model card from the adapter's config. For example, setting the base model is important for enabling support for HF inference providers but it also makes models more searchable on the HF hub. r\ transformersLORAlorarzbase_model:adapter:) r_rQrirkrorXrVr\rr rr)r[ peft_methodtagss ra_get_peft_specific_model_tagsz'PeftModel._get_peft_specific_model_tagss --77 +s+%++K 4??G ,DOO>(+Cy~~h'I`I`anapIq$* .!u((* :| ,::j339r:Dzz$<<>?  &t DIIf yy%%*T;O*P%6DII " 11$7 +/AAt|  #<(G&2?&CDIIl # $$&" R=STU#; [M "% /&%/ U[[)@AAEQ\P]G^_ 78 K=QRIIe$  ('/ts*K )rTF) r\r r]r-rIrkrJrrFrreturnNone)rdict[str, PeftConfig])r list[str])ror)TNrTN)rrkrrrzOptional[list[str]]rzUnion[str, bool]rrr Optional[str]rrrr)rFNTFFN)r\torch.nn.ModulerUnion[str, os.PathLike]rIrkrrrLzOptional[PeftConfig]rJrrrrFrrOptional[dict[str, str]]rrrrB)rIrk)r\r )rIrkr torch.Tensor)NN)rnintroOptional[torch.Tensor]rZz Optional[int]rr!)rztuple[int, int])rr)rrk)rrrrF)rrrIrkr]r-rFrrr)rIrkrr)rzOptional[set[str]])rlist[TunerLayerStatus])rTunerModelStatus)rzdict[str, Any])rzdict[str, dict[str, str]]rzdict[str, torch.tensor])r]r-rrrr)FNTFFN)rrrIrkrrrrrJrrrrFrrr rr)rrk)*rr __qualname____doc__rOpropertyr]rhsetterr classmethodrr7rZr9rPryrrrrrrLrrrr+rWrrrrrrrrrrar_rr __classcell__r`s@rarBrBEs?!N&'+"' '6'6 '6 '6 !% '6  '6 '6R++ $00$(1528 $BFD8D8!D8/ D8 0 D8  D83@D8D8 D8L &"'+'+&+"'04RR*R R  R % R!%R $R R.RR RRhJX>  3,hl``)?`Wd` `D+< "2  :C )-<-<^ BH9&  &<&&P 4 4NL`#D#&*'+&+"'04`)`` ` $ ` !% ` $` `.``D)47755,?rfrBcreZdZdZ d dfd Zdd fd Z d dZ d dZxZS) "PeftModelForSequenceClassificationa] Peft model for sequence classification tasks. Args: model ([`~transformers.PreTrainedModel`]): Base transformer model. peft_config ([`PeftConfig`]): Peft config. adapter_name (`str`, *optional*): The name of the adapter, defaults to `"default"`. autocast_adapter_dtype (`bool`, *optional*): Whether to autocast the adapter dtype. Defaults to `True`. Right now, this will only cast adapter weights using float16 and bfloat16 to float32, as this is typically required for stable training, and only affect select PEFT tuners. **Attributes**: - **config** ([`~transformers.PretrainedConfig`]) -- The configuration object of the base model. - **cls_layer_name** (`str`) -- The name of the classification layer. Example: ```py >>> from transformers import AutoModelForSequenceClassification >>> from peft import PeftModelForSequenceClassification, get_peft_config >>> config = { ... "peft_type": "PREFIX_TUNING", ... "task_type": "SEQ_CLS", ... "inference_mode": False, ... "num_virtual_tokens": 20, ... "token_dim": 768, ... "num_transformer_submodules": 1, ... "num_attention_heads": 12, ... "num_layers": 12, ... "encoder_hidden_size": 768, ... "prefix_projection": False, ... "postprocess_past_key_value_function": None, ... } >>> peft_config = get_peft_config(config) >>> model = AutoModelForSequenceClassification.from_pretrained("bert-base-cased") >>> peft_model = PeftModelForSequenceClassification(model, peft_config) >>> peft_model.print_trainable_parameters() trainable params: 370178 || all params: 108680450 || trainable%: 0.3406113979101117 ``` c ddg}t|dr2|j |dd|_n|jj|t||||fi|t|drI|j j D],\}tfd|jDs%|_nt||t|ddy)N classifierscorerc3&K|]}|v ywrcrs module_namers raruz>PeftModelForSequenceClassification.__init__..;sS{{d*S module_names) rXrrrNrOrVrrcls_layer_namer9rY r[r\r]rIrclassifier_module_namesrrr`s @rarOz+PeftModelForSequenceClassification.__init__)s$0"9 ; 1 2**2.Ea.H +++223JK  \DVD ; 1 2??99; aSd>R>RSS*.D'  t\ M^`d8efrfct|dr6ddg}|j |dd|_n|jj|t||||Srrr2r3NrErXrrrNrWr[rIr]rFr=r`s rarWz.PeftModelForSequenceClassification.add_adapterBa, ; 1 2'3W&= #**2.Ea.H +++223JKw"<Pa"bbrfc 8||n|jj}|j} | js|jd i| 5| j D cic]\} } | |j vs| | } } } | jtjk(r|| d<|jd |||||||d| cdddSt||} |Rtj| | jj|j }tj"||fd}| j%ddt'j(dd| d<| j+|||||d| jtj,k(r|j.d d|i| S| j%d dxtj"tj0| | jj|j2j4j | d fdj7| d <||j3|}|j9| | }|j|j:}tj"||fd}|jd d |i| Scc} } w#1swYxYw Nro input_idsattention_mask inputs_embedslabelsoutput_attentionsoutput_hidden_states return_dictr+rR position_idsUPosition ids are not supported for parameter efficient tuning. Ignoring position ids.rGrIrJrKrLrFtoken_type_idsrnrorHr5)rLuse_return_dictr_rSrrrRrQr4rrVr6ronesr0r-rrfrrrr.r*_prefix_tuning_forwardzerosr%rKr1ryrr[rFrGrHrIrJrKrLrorr]rrrnprefix_attention_maskrxs rarLz*PeftModelForSequenceClassification.forwardas&1%e41aQdFdFd=d!Q$ee((HMM9)1F:&&t '#1"/!&7)= +    %Y >  %$)JJz;;Y;Y$Z$]$]^l^s^s$t !"YY(=~'NTUVN ::nd + 7 MMq r%)F> " "0 %6(<*     H$:$: :.4..MMfM Mzz*D1=+099 J 0N0NORRSWSgSgSnSnSuSuv/0 , $& '($ $ 4 4Y ? oohoOGjj!4!45G!IIw &>AFM"4??II&I Iaf  $JJ 0J 5>J JJc :t||} |j| } ttj|j j jj} |j||||||| dd| vr|j dd|i|S|j j|j} ttj| j jj} d| vr td| di|} t| dkDr| dn| d}dt|j jDcgc]\}}| c}}vr|j j|}|j j|j |}d}||j"j$|j j&dk(rd|j"_nv|j j&dkDrL|j(t*j,k(s|j(t*j.k(rd |j"_nd |j"_|j"j$dk(rSt1}|j j&dk(r&||j3|j3}n|||}n|j"j$d k(rGt5}||j7d |j j&|j7d }n,|j"j$d k(rt9}|||}|s|f| d dz}||f|zS|St;||| j<| j> Scc}}w)NrFrGrHrJrKrLrprprILModel does not support past key values which are required for prefix tuning.r+rdropout regressionsingle_label_classificationmulti_label_classificationrGrlosslogits hidden_states attentionsr5) r6ryrjrrrVrLrrrr.r!rrrrr\r;rL problem_type num_labelsrrr1r"rsqueezerrbrr"rcrd)r[rFrGrHrIrJrKrLrrnrp fwd_paramsroutputs pooled_outputrrrbraloss_fctrCs rarTz9PeftModelForSequenceClassification._prefix_tuning_forwards%Y > //*5'++DOO,C,CDOOTTVW  &"0!.%6(<*#2    *"4??;&;F; ;(,(E(EdFdFd(e %g//0I0Q0QR]]bbdeJ 2 !opp/9&9G*-g,*:GAJ Mdoo6T6T6V1WXgdATXX $ 7 7 F GT__2243F3FG VFD!;;++311Q63? 033a7V\\UZZ=W[a[g[gkpktkt[t3P 03O 0;;++|;&yH11Q6'(8&..:JK'7[[--1NN/1H#FKKDOO4N4N$OQWQ\Q\]_Q`aD[[--1MM02H#FF3D WQR[0-1-=&(I6I+%33"--  =Ys Nrr\rr]r-rIrkrrr$r%NNNNNNNNNNNNNNN rrr(r)rOrWrLrTr-r.s@rar0r0s*ZT]g$g3=gMPg g2cB!@JH!Erfr0cheZdZdZ d d fd Z d dZdZdZddd dZxZ S) r aU Peft model for causal language modeling. Args: model ([`~transformers.PreTrainedModel`]): Base transformer model. peft_config ([`PeftConfig`]): Peft config. adapter_name (`str`, *optional*): The name of the adapter, defaults to `"default"`. autocast_adapter_dtype (`bool`, *optional*): Whether to autocast the adapter dtype. Defaults to `True`. Right now, this will only cast adapter weights using float16 and bfloat16 to float32, as this is typically required for stable training, and only affect select PEFT tuners. Example: ```py >>> from transformers import AutoModelForCausalLM >>> from peft import PeftModelForCausalLM, get_peft_config >>> config = { ... "peft_type": "PREFIX_TUNING", ... "task_type": "CAUSAL_LM", ... "inference_mode": False, ... "num_virtual_tokens": 20, ... "token_dim": 1280, ... "num_transformer_submodules": 1, ... "num_attention_heads": 20, ... "num_layers": 36, ... "encoder_hidden_size": 1280, ... "prefix_projection": False, ... "postprocess_past_key_value_function": None, ... } >>> peft_config = get_peft_config(config) >>> model = AutoModelForCausalLM.from_pretrained("gpt2-large") >>> peft_model = PeftModelForCausalLM(model, peft_config) >>> peft_model.print_trainable_parameters() trainable params: 1843200 || all params: 775873280 || trainable%: 0.23756456724479544 ``` c `t||||fi||jj|_yrc)rNrOrVr(base_model_prepare_inputs_for_generationr[r\r]rIrr`s rarOzPeftModelForCausalLM.__init__s-  \DVD8<8e8e5rfNc |j} | js|jjjdk(r&| t d|jd||||||d| S| j tjk(r|| d<|jdi| 5| jD cic]\} } | |jvs| | } } } |jd|||||||d| cdddSt||} |Rtj| | jj!|j"}tj$||fd}| j'ddt)j*d d| d<| j'd dt)j*d d| d <| j-|||||d | j tj.k(rf||j0d| jz}n|j0d| jz}|j3| | | d<|jd||d| S| j tj4k(r|j6||| || fi| S||j9|}|Wtj:| | jfdj!|j"}tj$||fd| d<|j3| |}|j!|j<}tj$||fd}|jdd|i| Scc} } w#1swY]xYw)Nmptz8forward in MPTForCausalLM does not support inputs_embeds)rFrGrIrJrKrLrorEr+rRrMrNrPXToken type ids are not supported for parameter efficient tuning. Ignoring token type idsrO)rZrp)rFrHrIrQrHr5)r_rSrVrLrVAssertionErrorrQr4rrrrRr6rrSr0r-rrfrrrr.r*r$ryr( _cpt_forwardr%fullr)r[rFrGrHrIrJrKrLrorr]rrrnrWrZ prefix_labelsrxs rarLzPeftModelForCausalLM.forwardsa-- --%%00E9 ,()cdd&t'#1!&7)= + $$ 5%-z"000:6: +1<<>e41aQdFdFd=d!Q$ee&t '#1"/!&7)= +    %Y >  %$)JJz;;Y;Y$Z$]$]^l^s^s$t !"YY(=~'NTUVN ::nd + 7 MMq r%)F> " ::& - 9 MMt u'+F# $ "0 %6(<*     H$:$: :$ ) 2[5S5S S - 3 3A 69W9W W (, R_(`F$ %"4??^Ym^W]^ ^  " "hll 2$4$$Y {HV`kdjk k$ $ 4 4Y ? ! % J 8V8V+WY] ^ a abhbobo p #(99mV-D!#Lx oohoOGjj!4!45G!IIw &>AFM"4??II&I Iof  s$L?*L9L9L?9L??M c F|jd}|||fDcgc]}||jc}d} d|jvr!|jdj| } nJ||jd} n|jd} t j || fj| dz} |j} |j} ||j|}|j||}|j|j}t j||fd}d}|"t j| jjdd}|j!|dj|j}t j||fd}t j| jjdd}|j!|dj|j}| }||dkDxx|j#z cc<t j||fd}|dkD|dzdk(z}d ||<||d<|j$d d |i|}||St&|j(}|j+|||j,d }|Scc}w) NrIrinput_type_maskr+rUrQrRrGrxrHrr5)poprrrr-r$rrS cpt_token_idscpt_tokens_type_maskr%ryrrfrr1rbr`maxrVr0rQcalculate_lossr])r[rFrHr]rornrrIrrr~N_tokensrrrx cpt_labelsr|prefix_type_maskadjusted_input_type_mask cpt_type_mask labels_idxbase_model_output cpt_embeddings rarzz!PeftModelForCausalLM._cpt_forwardrsH%%. v$FXq!-!((XYZ[  -$jj):;>>vFO (..q1$??1-#jj*h)?@CCFKaOO#11 *??   00;M//Z(/K**]001 7M":B   !LL7<<>CCArJM)00Q?BB6==QMM6#:BJ$||,@AFFHMMaQST /66z1EHHW '6 $ $%=%A BFVFZFZF\ \ B!II'79Q&RXYZM'!+ 0AQ0FGJ&*J { #&x+DOOR-R6R >$ $7{7L7LMM - < <!:}d>N>Ny>Y! % $gYs JJc|j}|j|j_t|jdr&|j|jj _n|j|j_ |j sj|j|i|5|jDcic]\}}||jvs||}}}|jj|i|}dddn|jjdi|}|j|j_Scc}}w#1swY,xYw#|j|j_xYw)Nr\r5) r_rrVrXgeneration_configr\rSrrrRrrs)r[rrr]rrris rarzPeftModelForCausalLM.generates8-- 8<8Z8Z5 4??G ,6:6L6LDOO ! ! 3040F0FDOO - 114T44dEfEH/5||~itq!$JhJhAhadiFi6doo66GGGHH3$//22:EEroc p |j}|j|i|}tjj t j tjj dk\}tjj t j tjj dk\}gd}tjj t j tjj dkDr|jd|xs&|xr"|jjj|v} |jdduxr |dddk(} |jtjk(r||d<|jr| ry|jd dg|d } t!| t"t$fr| ddj&d } n| j)} | |d j&d k\r|d ddd df|d <|jddx} t!| t*rBt-| d k7rt/dt-| dt%| j1d} |d j&d|j2f}t5j6|j9|d j:}| j=dk(r| j&d}|j&d | j&dz}t5j6||f| j>}| rB|jtj@k7r%t5jB||d j:}n|d}tE|jGd||jd ||||jdd}||d<nt5jH|| fd |d<|jddtKjLdd|d<|jddtKjLdd|d<|jd dduxs3t!|d t jNxr|d j) }|rc|jtj@k(rFtQ|jd ddd}|jS|d j&d|}||d <nu|rs|jU|d }|jS|d j&d|}|j9|j>}t5jH||fd |d<d|d <| r6|jtj@k(r|dxx|j2z cc<|S|jtj@k7r|jWdd}|S)Nz4.38.0z4.36.0)llamamistral persimmonphiz4.43.3bloomr\rrorprFr+rGrGz&Expected a single attention mask, got za instead, please open an issue (https://github.com/huggingface/peft/issues) and report the error.rUr)rr[rM) model_inputrGrpr\rnsequence_lengthrMrRrNrPrwrZ)rnrZrQrH),r_rs packagingversionparserr,rrVrLrVrrQr4rrSrituplerjr$get_seq_lengthrrrrr0rrSr-rrSrr*r/r)r+rfrrrrYryr%r)r[rorrr] model_kwargsuses_transformers_4_38uses_transformers_4_36transformers_new_cache_archs uses_cache is_prefillrpseq_lenrGsizerWbs total_seq_lenattention_mask_2dcache_position_attention_mask_newrequires_prompt_injectionrZnew_past_key_valuesrHrxrs rarz2PeftModelForCausalLM.prepare_inputs_for_generations-- DtDDdUfU "+!2!2!8!89Q9Q!RV_VgVgVmVmnvVw!w!*!2!2!8!89Q9Q!RV_VgVgVmVmnvVw!w'O$    " "<#;#; Gl;7==a@@0<[0I!RS&0QL-"."2"23CT"JJWnd3>*a/(DSEXDYZgg&*.*?*?*A%B1%EN#K066q9;;Y;YY(- 4(8(;(;L++-$('8(4(8(89J(K'6#%(5%1%5%5nd%K *&6HL!126;YY@UWe?flm5nL!125A uv/3 ^,zz*D1= n,0'(*6)9)9:KT)RVZ)Z)<(9:L>qA"/'6'#3F ./* $ 4 4\+5N O //\+5N5T5TUV5Wbj/k!**]%8%8905 7M:RXY0Z _-,0 [) ;00H4J4JJ ) *k.L.L L * " "h&<&< <   !148Arfrlrmrn)ror#) rrr(r)rOrLrzrrr-r.s@rar r sz&RT]f$f3=fMPf f!VJp6%p*W[||rfr cheZdZdZ d d fd Z d dZdZddd dZxZS) PeftModelForSeq2SeqLMa Peft model for sequence-to-sequence language modeling. Args: model ([`~transformers.PreTrainedModel`]): Base transformer model. peft_config ([`PeftConfig`]): Peft config. adapter_name (`str`, *optional*): The name of the adapter, defaults to `"default"`. autocast_adapter_dtype (`bool`, *optional*): Whether to autocast the adapter dtype. Defaults to `True`. Right now, this will only cast adapter weights using float16 and bfloat16 to float32, as this is typically required for stable training, and only affect select PEFT tuners. Example: ```py >>> from transformers import AutoModelForSeq2SeqLM >>> from peft import PeftModelForSeq2SeqLM, get_peft_config >>> config = { ... "peft_type": "LORA", ... "task_type": "SEQ_2_SEQ_LM", ... "inference_mode": False, ... "r": 8, ... "target_modules": ["q", "v"], ... "lora_alpha": 32, ... "lora_dropout": 0.1, ... "fan_in_fan_out": False, ... "enable_lora": None, ... "bias": "none", ... } >>> peft_config = get_peft_config(config) >>> model = AutoModelForSeq2SeqLM.from_pretrained("t5-base") >>> peft_model = PeftModelForSeq2SeqLM(model, peft_config) >>> peft_model.print_trainable_parameters() trainable params: 884736 || all params: 223843584 || trainable%: 0.3952474242013566 ``` c t||||fi||jj|_|jj |_yrc)rNrOrVrrs._prepare_encoder_decoder_kwargs_for_generation8base_model_prepare_encoder_decoder_kwargs_for_generationrts rarOzPeftModelForSeq2SeqLM.__init__fsB  \DVD8<8e8e5 OO J J ErfNc   |j} | js| jtjk(r| | d<|j di| 5| j Dcic]\}}||jvs||} }}|jd||||||||| | d | cdddSt||}|~tj|| jj|j}| jtjtj fvrtj"||fd}| j%ddt'j(dd| d<| j%ddt'j(dd| d<| j+||||| | d | jtj,k(r*|j/|| d <|jd|||d | S| jtjtj fvr||j1|}|Utj|| jj|j}tj"||fd| d <|j/| }|j|j2}tj"|ddd| jf|fd}|jd|||d| S||j1|}|H|Ft5||j6j8|j6j:}|j1|}|Utj|| jj|j}tj"||fd| d <|{| j<dk(r|| d<nf| j<dk(rWtj>|| jfdj|j}tj"||fd| d<|j/|| }|j|j2}tj"|ddd| jf|fd}| j<dk(r|jdd|i| S| j<dk(rAtj"|dd| jdf|fd}|jd||d| Sycc}}w#1swYWxYw)Nro) rFrGrHdecoder_input_idsdecoder_attention_maskdecoder_inputs_embedsrIrJrKrLr+rRrMrNrPrw)rGrrIrJrKrLrp)rFrrrGrn)rHrrrIrrxrQrH)rHrr5) r_rSrQr4rrrrRrVr6rrSr0r-rr&r)rfrrrr.r*ryr%rr@rL pad_token_iddecoder_start_token_idrr{)r[rFrGrHrrrrIrJrKrLrorr]rrrnrWrxr|s rarLzPeftModelForSeq2SeqLM.forwardos-- --$$ 5%-z"000:6: +1<<>e41aQdFdFd=d!Q$ee&t '#1"/&7+A*?!&7)= +     %Y > ! -$)JJz;;Y;Y$Z$]$]&--% !$$X-C-CXEVEV,WW).4IKa3bhi)j& ::nd + 7 MMq r%)F> " ::& - 9 MMt u'+F# $ "0*@ %6(<*     H$:$: :(, (CF$ %"4??#"3&;    " "x'='=x?P?P&Q Q$ $ 4 4Y ? )(- :{?]?](^(a(a")))%,1996K^5\bc+d'(ooo'-F8$ ;;q@$)JJ K > @@ACXY_`)%'t"/G\`f =Ef  s$ S3!S-8S-=S3-S33S=c |j}|j|j_|j|j_ |jsk|j di|5|j Dcic]\}}||jvs||}}}|jjdi|}dddn&d|vr td|jddtjdd|d<|jddtjdd|d<|jtjk(r|jjdi|}n|jtj tj"tj$fvrBt'|}d|vr|d=tjd|j)d}|j+|}|j,d }|j/||j)d d } | j1|j2} t5j6| ddd|j8f|fd }||d<d|vr[t5j:||j8j1|dj<} t5j6| |dfd |d<|jjdi|St>|j@|j_|jB|j_Scc}}w#1swYGxYw#|j@|j_|jB|j_xYw)NrFz4input_ids must be provided for Peft model generationrMrNrPrwencoder_outputsz[`encoder_outputs` should not be passed to `generate` when using prompt tuning. Ignoring it.rrorQr+rRrHrGr5)"r_rrVrrSrrrRrrrrrrQr4r*r&r)r'rrr%r$ryr-rrrfr0rSrNotImplementedErrorrsr) r[rr]rrrirFrHrnrxrWs rarzPeftModelForSeq2SeqLM.generates6-- 8<8Z8Z5  ? ? F? 114T44>v>A/5||~itq!$JhJhAhadiFi6doo66@@GAAf,$%[\\::nd3?MMo.2F>*::.5AMMr04F+,((H,B,BB6doo66@@G ****%%44/ &f-F(F2"#45 y!' ; 7I$($8$8$CM!.!4!4Q!7J"oofjjYceiNjokG%jj)<)<=G$)IIwq:ZKSU[\lUm=ntu3v/034??33=f==--=AGN!D(U6SN1DDQG &*ooj&A#2E ./rfrlrm NNNNNNNNNNN)ror!) rrr(r)rOrLrrr-r.s@rarr>sw%PT] $ 3= MP  #"!}~ENMQrfrcreZdZdZ d dfd Zdd fd Z d dZ d dZxZS) PeftModelForTokenClassificationaS Peft model for token classification tasks. Args: model ([`~transformers.PreTrainedModel`]): Base transformer model. peft_config ([`PeftConfig`]): Peft config. adapter_name (`str`, *optional*): The name of the adapter, defaults to `"default"`. autocast_adapter_dtype (`bool`, *optional*): Whether to autocast the adapter dtype. Defaults to `True`. Right now, this will only cast adapter weights using float16 and bfloat16 to float32, as this is typically required for stable training, and only affect select PEFT tuners. **Attributes**: - **config** ([`~transformers.PretrainedConfig`]) -- The configuration object of the base model. - **cls_layer_name** (`str`) -- The name of the classification layer. Example: ```py >>> from transformers import AutoModelForSequenceClassification >>> from peft import PeftModelForTokenClassification, get_peft_config >>> config = { ... "peft_type": "PREFIX_TUNING", ... "task_type": "TOKEN_CLS", ... "inference_mode": False, ... "num_virtual_tokens": 20, ... "token_dim": 768, ... "num_transformer_submodules": 1, ... "num_attention_heads": 12, ... "num_layers": 12, ... "encoder_hidden_size": 768, ... "prefix_projection": False, ... "postprocess_past_key_value_function": None, ... } >>> peft_config = get_peft_config(config) >>> model = AutoModelForTokenClassification.from_pretrained("bert-base-cased") >>> peft_model = PeftModelForTokenClassification(model, peft_config) >>> peft_model.print_trainable_parameters() trainable params: 370178 || all params: 108680450 || trainable%: 0.3406113979101117 ``` c tt||||fi|ddg}t|dr2|j |dd|_n|jj ||j j D],\}tfd|jDs%|_nt||t|ddy)Nr2r3rc3&K|]}|v ywrcr5r6s raruz;PeftModelForTokenClassification.__init__.. O;;$&Or8r9 rNrOrXrrrVrrr;r9rYr<s @rarOz(PeftModelForTokenClassification.__init__y s  \DVD#/"9 ; 1 2**2.Ea.H +++223JK557 GD!O$:N:NOO&*#  t\ M^`d8efrfct|dr6ddg}|j |dd|_n|jj|t||||Sr?r@rAs rarWz+PeftModelForTokenClassification.add_adapter rBrfc 8|j} ||n|jj}| js|jd i| 5| j D cic]\} } | |j vs| | } } } | jtjk(r|| d<|jd |||||||d| cdddSt||} |Rtj| | jj|j }tj"||fd}| j%ddt'j(dd| d<| j+|||||d| jtj,k(r|j.d d|i| S| j%d dxtj"tj0| | jj|j2j4j | d fdj7| d <||j3|}|j9| | }|j|j:}tj"||fd}|jd d |i| Scc} } w#1swYxYwrD)r_rLrRrSrrrRrQr4rrVr6rrSr0r-rrfrrrr.r*rTrUr%rKr1ryrrVs rarLz'PeftModelForTokenClassification.forward s-- %0%e41aQdFdFd=d!Q$ee((HMM9)1F:&&t '#1"/!&7)= +    %Y >  %$)JJz;;Y;Y$Z$]$]^l^s^s$t !"YY(=~'NTUVN ::nd + 7 MMq r%)F> " "0 %6(<*     H$:$: :.4..MMfM Mzz*D1=+099 J 0N0NORRSWSgSgSnSnSuSuv/0 , $& '($ $ 4 4Y ? oohoOGjj!4!45G!IIw &>AFM"4??II&I Iaf  rXc ,t||} |j| } ttj|j j jj} |j||||||| dd| vr|j d d|i|S|j j|j} ttj| j jj} d| vr td| d i|} | d}dt|j jDcgc]\}}| c}}vr|j j|}|j j|j|}d}| //*5'++DOO,C,CDOOTTVW  &"0!.%6(<*#2    *"4??;&;F; ;(,(E(EdFdFd(e %g//0I0Q0QR]]bbdeJ 2 !opp/9&9G%ajOdoo6T6T6V1WXgdATXX"&//"9"9/"JGT__2243F3FGXFD!+- B @&++b/R WQR[0-1-=&(I6I(%33"--  Ys H)Nrrmr$r%rnrorpr.s@rarrL s*Z[dg$g3=gTWg g(cB!AJJ!4rfrczeZdZdZ d dfd Zdd fd Z d dZ d dZxZS) PeftModelForQuestionAnsweringa Peft model for extractive question answering. Args: model ([`~transformers.PreTrainedModel`]): Base transformer model. peft_config ([`PeftConfig`]): Peft config. adapter_name (`str`, *optional*): The name of the adapter, defaults to `"default"`. autocast_adapter_dtype (`bool`, *optional*): Whether to autocast the adapter dtype. Defaults to `True`. Right now, this will only cast adapter weights using float16 and bfloat16 to float32, as this is typically required for stable training, and only affect select PEFT tuners. **Attributes**: - **config** ([`~transformers.PretrainedConfig`]) -- The configuration object of the base model. - **cls_layer_name** (`str`) -- The name of the classification layer. Example: ```py >>> from transformers import AutoModelForQuestionAnswering >>> from peft import PeftModelForQuestionAnswering, get_peft_config >>> config = { ... "peft_type": "LORA", ... "task_type": "QUESTION_ANS", ... "inference_mode": False, ... "r": 16, ... "target_modules": ["query", "value"], ... "lora_alpha": 32, ... "lora_dropout": 0.05, ... "fan_in_fan_out": False, ... "bias": "none", ... } >>> peft_config = get_peft_config(config) >>> model = AutoModelForQuestionAnswering.from_pretrained("bert-base-cased") >>> peft_model = PeftModelForQuestionAnswering(model, peft_config) >>> peft_model.print_trainable_parameters() trainable params: 592900 || all params: 108312580 || trainable%: 0.5473971721475013 ``` c rt||||fi|dg}t|dr2|j |dd|_n|jj ||j j D],\}tfd|jDs%|_nt||t|ddy)N qa_outputsrc3&K|]}|v ywrcr5r6s raruz9PeftModelForQuestionAnswering.__init__..^ rr8r9r) r[r\r]rIrqa_module_namesrrr`s @rarOz&PeftModelForQuestionAnswering.__init__Q s  \DVD'. ; 1 2**2.=a.@ +++22?C557 GD!O$:N:NOO&*#  t\ M^`d8efrfct|dr5dg}|j |dd|_n|jj|t||||S)rrrNrEr@)r[rIr]rFrr`s rarWz)PeftModelForQuestionAnswering.add_adaptere s\, ; 1 2+nO**2.=a.@ +++22?Cw"<Pa"bbrfc :|j} | | n|jj} | js| jt j k(r| | d<|jd i| 5| jDcic]\}}||jvs||} }}|jd ||||||| | d| cdddSt||}|Rtj|| jj|j }tj"||fd}| j%ddt'j(dd| d<| j+||||| | d| jt j,k(r|j.d d|i| S| j%d dxtj"tj0|| jj|j2j4j | d fdj7| d <||j3|}|j9| }|j|j:}tj"||fd}|jd d |i| Scc}}w#1swYxYw) Nro)rFrGrHstart_positions end_positionsrJrKrLr+rRrMrN)rGrrrJrKrLrFrPrrHr5)r_rLrRrSrQr4rrrrRrVr6rrSr0r-rrfrrrr.r*rTrUr%rKr1ryr)r[rFrGrPrMrHrrrJrKrLrorr]rrrnrWrxs rarLz%PeftModelForQuestionAnswering.forward s-- %0%e41aQdFdFd=d!Q$ee&t '#1"/$3"/&7)= +    %Y >  %$)JJz;;Y;Y$Z$]$]^l^s^s$t !"YY(=~'NTUVN ::nd + 7 MMq r%)F> " "0#2!.%6(<*     H$:$: :.4..MMfM Mzz*D1=+099 J 0N0NORRSWSgSgSnSnSuSuv/0 , $& '($ $ 4 4Y ? oooAFM"4??II&I Iaf  s$'J;J J J JJc t||} |j| } ttj|j j jj} | j||||||| dd| vr|j d ||d| S|j j|j} ttj| j jj} d| vr td| d i| }|d}dt|j jDcgc]\}}| c}}vr|j j|}|j j|j|}|j!dd \}}|j#dj%}|j#dj%}d}||t'|j)dkDr|j#d}t'|j)dkDr|j#d}|j)d}|j+d|}|j+d|}t-| }|||}|||}||zd z }|s||f|d dz}||f|zS|St/||||j0|j2 Scc}}w)NrZrp)rrr[rr\r+rGrR) ignore_indexr)ra start_logits end_logitsrcrdr5)r6ryrjrrrVrLrrrr.r!rrrr\r;rhrg contiguousrrclamprr!rcrd)r[rFrGrHrrrJrKrLrrnrprhrrirrrrbrr total_loss ignored_indexrk start_lossend_lossrCs rarTz4PeftModelForQuestionAnswering._prefix_tuning_forward s%Y > //*5'++DOO,C,CDOOTTVW  &"0!.%6(<*#2    *"4??j?R_jcij j(,(E(EdFdFd(e %g//0I0Q0QR]]bbdeJ 2 !opp/9&9G%ajOdoo6T6T6V1WXgdATXX"&//"9"9/"JGT__2243F3FGXF'-||A2|'> $L*'//3>>@L#++B/::>> from transformers import AutoModel >>> from peft import PeftModelForFeatureExtraction, get_peft_config >>> config = { ... "peft_type": "LORA", ... "task_type": "FEATURE_EXTRACTION", ... "inference_mode": False, ... "r": 16, ... "target_modules": ["query", "value"], ... "lora_alpha": 32, ... "lora_dropout": 0.05, ... "fan_in_fan_out": False, ... "bias": "none", ... } >>> peft_config = get_peft_config(config) >>> model = AutoModel.from_pretrained("bert-base-cased") >>> peft_model = PeftModelForFeatureExtraction(model, peft_config) >>> peft_model.print_trainable_parameters() ``` c *t||||fi|yrc)rNrOrts rarOz&PeftModelForFeatureExtraction.__init__= s  \DVDrfc j|j} | js| jtjk(r||d<|j di|5|j D cic]\} } | |jvs| | }} } |jd||||||d|cdddSt||} |Rtj| | jj|j} tj| |fd}|j!ddt#j$dd|d<|j!ddt#j$dd|d<|j'||||d | jtj(k(r(|j+| |d <|jdd |i|S||j-|}|j+| }|j|j.}tj||fd}|jdd |i|Scc} } w#1swYxYw)Nro)rFrGrHrJrKrLr+rRrMrNrPrw)rGrJrKrLrprFrrHr5)r_rSrQr4rrrrRrVr6rrSr0r-rrfrrrr.r*ryr%r)r[rFrGrHrJrKrLrorr]rrrnrWrxs rarLz%PeftModelForFeatureExtraction.forward@ s3-- --$$ 5%-z"000:6: +1<<>e41aQdFdFd=d!Q$ee&t'#1"/&7)= +   %Y >  %$)JJz;;Y;Y$Z$]$]^l^s^s$t !"YY(=~'NTUVN ::nd + 7 MMq r%)F> " ::& - 9 MMt u'+F# $ "0%6(<*     H$:$: :(, (CF$ %"4??AYA&A A$ $ 4 4Y ? oooAFM"4??II&I IUf  s$ H(!H"8H"=H("H((H2rl)r\rr]r-rIrkro)rrr(r)rOrLr-r.s@rarr s,%NE !;Jrfrc^eZdZUded<ded<ded<ded<ded<d ed <ded <d ed <y)TunerLayerStatusrkr module_typerrrrhmerged_adapters&dict[str, bool | Literal['irregular']]ravailable_adaptersdict[str, list[str]]devicesNrrr(__annotations__r5rfrarr~ s0 I M99!! !!rfrc Ft|tr'|j}t|ts t d|}g}|j D]3\}}t|t stjt}|jD]}t||}t|tjjrL|jD]8\}} | j!D] } ||j#| j$":t|tjj&r7|jD]#\}} ||j#| j$%ڌdd} |jD cic]\}} || | } }} tjt}|j|j(zD]}t||}t|tjjr]|jD]I\}} ||j+| j!D cgc]} | j,j.c} Kt|tjj&s|j0j2dk(s|jD]-\}} ||j#| j,j./|jDcic]\}}|t5t7|}}}t9|t;|j=dd|j> |j@|jB| t5|jE|}|j#|6|s tGd|Scc} }wcc} wcc}}w) aGet the status of each adapter layer in the model. This function returns a list of `TunerLayerStatus` dataclass instances, each of which contains the following attributes: - `name` (`str`): The name of the adapter layer, e.g. `model.encoder.block.0.layer.0.SelfAttention.q`. - `module_type` (`str`): The type of the adapter layer, e.g. `lora.Linear`. - `enabled` (`bool`): Whether the adapter layer is enabled. - `active_adapters` (`list[str]`): The names of the active adapters, if any, e.g. `["default"]`. - `merged_adapters` (`list[str]`): The names of the merged adapters, if any, e.g. `["default"]`. - requires_grad : dict[str, bool | Literal["irregular"]] The requires_grad status of the parameters for each adapter module. Ideally, it should be either `True` or `False`. If the requires_grad status is not consistent across all parameters, the value will be set to `"irregular"`. - `available_adapters` (`list[str]`): The names of the available adapters, e.g. `["default"]`. - `devices` (`dict[str, list[str]]`): The devices where the parameters of the given adapter are stored, e.g. `["cuda"]`. Args: model ([Union[`~PeftModel`, `~transformers.PreTrainedModel`, `nn.Module`]]): The model to get the adapter layer status from. Returns: list[`peft.peft_model.TunerLayerStatus`]: A list of dataclasses, each containing the status of the corresponding adapter layer. zjget_layer_status() got an invalid PeftModel instance; prefix tuning and adaption prompt are not supported.c4t|ryt|syy)NTFr)allrvalss racheck_irrgularz(get_layer_status..check_irrgular s4yt9rf BufferDict(r)rrrrhrrrrzNo adapter layers found in the model, please ensure that it's a PEFT model or that you have PEFT adapters injected in the model.)rz list[bool]rbool | Literal['irregular'])$rirBrVr%rrr&rrrjadapter_layer_namesrYrrrrrrr ParameterDictother_param_namesrrrr`rr rrrepr partitiondisable_adaptersrhr_get_available_adaptersr)r\rV layer_statusrr mapping_requires_grad_listadapter_module_nameadapter_moduler submoduler3rrr devices_ddrrstatuss rarr s[D%#%% *i0   +-L"0023$ f&.1 =H&4&:&:&<TNC!*!5!5!7T237>>u?R?RSTTNEHH,B,BC"0"6"6"8PJC.s3::5;N;NOP  E_DdDdDfgysDnT22g g ,,T2 #)#=#=@X@X#X > $V-@AN.%((*=*=>&4&:&:&<dNCsO**9K_K_Ka+b%ELL,=,=+bcdNEHH,B,BC((11\A"0"6"6"8>JCsO**5<<+<+<=> >:D9I9I9KLXS#3s3x((LL!V ..s3A6///"22"22'%f&D&D&FG   F#g3$j  %  Ch,c Ms<N.N)NceZdZUded<ded<ded<ded<ded<ded <d ed <d ed <d ed<ded<ded<ded<y)r'rkbase_model_typeadapter_model_typezdict[str, str] peft_typesr"r total_paramsnum_adapter_layersrrz list[str] | Literal['irregular']rhrrrrrrrNrr5rfrar'r' sJ ((555599!! !!rfr'ct|trt|jts t d|j j j}|j\}}|j}|jjDcic]-\}}|t|jjdd/}}}|j j}net|tr5|j j}tj|\}}|}i}d}n d}tj|\}}|}i}d}t|} t!| } | D chc]} | j"} } t!| dk(r| j%} nd} t't)j*d| D}| D chc]} t-| j.}} |sg}n*t!|dk(rt1|j%}nd}t)}| D]} |j3| j4t'|}| D]6} t)| j6t)| j4z }||zs4d}nt9j:t0}| D]8} | j<jD]\}}||j?|:d d }|jDcic]\}}|||}}}t9j:t0}| D]8} | j@jD]\}}||jC|:|jDcic]\}}|t't)|}}}tE|||||| | ||||| }|Scc}}wcc} wcc} wcc}}wcc}}w) aJ Get the status of tuners of the model. This function returns a `TunerModelStatus` dataclass instance, which contains the following attributes: - `base_model_type` (`str`): The type of the base model, e.g. `T5Model`. - `adapter_model_type` (`str`): The type of the adapter model, e.g. `LoraModel`. - `peft_types` (`dict[str, str]`): The mapping of adapter name to adapter type, e.g. `{"default": "LORA"}`. - `trainable_params` (`int`): The number of trainable parameters in the model. - `total_params` (`int`): The total number of parameters in the model. - `num_adapter_layers` (`int`): The number of adapter layers in the model. - `enabled` (`bool`, `Literal["irregular"]`): Whether all adapter layers are enabled. If some are enabled and some are not, this will be `"irregular"`. This means that your model is in an inconsistent state and might not work as expected. - `active_adapters` (`list[str]`, `Literal["irregular"]`): The names of the active adapters. If the active adapters are not consistent across all layers, this will be `"irregular"`, which means that your model is in an inconsistent state and might not work as expected. - `merged_adapters` (`list[str]`, `Literal["irregular"]`): The names of the merged adapters. If the merged adapters are not consistent across all layers, this will be `"irregular"`, which means that your model is in an inconsistent state and might not work as expected. - `requires_grad` (`dict[str, bool | Literal["irregular"]]`): Whether for the given adapter, all adapter layers have `requires_grad` set to `True` or `False`. If there is a mix, this will be set to `"irregular"`, which means that your model is in an inconsistent state and might not work as expected. - `available_adapters` (`list[str]`): The names of the available adapters, e.g. `["default"]`. - `devices` (`dict[str, list[str]]`): The devices where the parameters of the given adapter are stored, e.g. `["cuda"]`. Args: model ([Union[`~PeftModel`, `~transformers.PreTrainedModel`, `nn.Module`]]): The model to get the adapter layer status from. Returns: `peft.peft_model.TunerModelStatus`: A dataclass containing the status of the model. zjget_model_status() got an invalid PeftModel instance; prefix tuning and adaption prompt are not supported.rvrGrotherr+rc34K|]}|jywrc)r)rsrs raruz#get_model_status..S s8nW]9R9R8nscPtd|Drytd|Dryy)Nc3$K|]}|du yw)TNr5rsrs raruz;get_model_status..check_irrgular..z s+ssd{+Tc3$K|]}|du yw)FNr5r s raruz;get_model_status..check_irrgular..| s,se|,r Fr)rrs rarz(get_model_status..check_irrgulary s' +d+ + ,t, ,rf) rrrrrrrrhrrrr)rz!list[bool | Literal['irregular']]rr)#rirBrVr%rr+r`rrr]rrkrQrr rrrrr rr rrhrjr.rrrrrrrrr')r\rrrrVrrLrrrrr enabled_setrrall_active_adaptersrh merged_allrunmergedrequires_grad_allrrrrrradapter_model_statuss rarr sX%#%**I6  ..0::CC).)J)J)L&,%% WaWmWmWsWsWuv Vc3v//0::3?CCv v'11:: E? +//22)2)N)Nu)U&,  #!)2)N)Nu)U&,  ##E*L\*;GHfnnHKH ;1//#$*;35;;8nam8n+o$p^j0jSYv7M7M1N0j0j  !Q &26689%5J2&00129?z8JOv001C8N8N4OO j )O  GRF]F]^bFc/,,224 /HC c " ) )# . // AR@W@W@YZ93S...ZMZ((.J(,,. (HC sO " "3 ' ((6@5E5E5GHcsF3s8$$HGH+'-)!-''#-  yw$I1kT[ Is2N(!N.N3.N8-N>c||dk(r#d}tj|ttSt dt d|)NPEFT_TYPE_TO_MODEL_MAPPINGzPEFT_TYPE_TO_MODEL_MAPPING is deprecated, please use `from peft import PEFT_TYPE_TO_TUNER_MAPPING` instead. The deprecated variable will be removed in 2026.)categoryzmodule z has no attribute )rrDeprecationWarningr0rlr)rrs rarr sE ++  ?   c$67)) 78,.@I JJrf)r\rrr&)r\rrr')j __future__rrrrrr contextlibrrr dataclassesrtypingrr r r packaging.versionrrr accelerater r accelerate.hooksrrraccelerate.utilsrrhuggingface_hubrrrr safetensorsrsafetensors.torchrrtorch.nnrrrrrrrr transformers.modeling_outputsr!r"r#transformers.utilsr$peft.tuners.tuners_utilsr%r&peft.utils.constantsr'peft.utils.integrationsr(peft.utils.otherr)r*rr,rLr-rr.r/r0utilsr1r2r3r4r5r6r7r8r9r:r;r<r=r>r?r@rModulerBr0r rrrrrrr'rrr5rfrar-sJ#  2!00 <^^FSS!9AA__ww->36Tii(ttn-ll^P9Pf KIK\WiWtlIl^fJIfJR "" "hV  " "  "Q h Krf