import{s as Qe,o as Be,n as Oe}from"../chunks/scheduler.78382b47.js";import{S as Xe,i as Ke,e as p,s,c as y,h as et,a as d,d as a,b as o,f as te,g as w,j as u,k as ae,l,m as r,n as A,t as x,o as M,p as $}from"../chunks/index.6dd35eb6.js";import{C as tt,H as Te,E as at}from"../chunks/MermaidChart.svelte_svelte_type_style_lang.fed9dfe4.js";import{D as Ue}from"../chunks/Docstring.32e826ec.js";import{C as Ye}from"../chunks/CodeBlock.af1ec02e.js";import{E as Je}from"../chunks/ExampleCodeBlock.7f184f2e.js";function nt(W){let i,k="Example:",b,c,f;return c=new Ye({props:{code:"ZnJvbSUyMHRyYW5zZm9ybWVycyUyMGltcG9ydCUyMEF1dG9Nb2RlbEZvckltYWdlQ2xhc3NpZmljYXRpb24lMEFmcm9tJTIwcGVmdCUyMGltcG9ydCUyMEFkYW1zc0NvbmZpZyUyQyUyMGdldF9wZWZ0X21vZGVsJTBBJTBBY29uZmlnJTIwJTNEJTIwQWRhbXNzQ29uZmlnKCUwQSUyMCUyMCUyMCUyMHIlM0Q1MDAlMkMlMEElMjAlMjAlMjAlMjBudW1fc3Vic3BhY2VzJTNENSUyQyUwQSUyMCUyMCUyMCUyMHRhcmdldF9tb2R1bGVzJTNEJTVCJTIycXVlcnklMjIlMkMlMjAlMjJ2YWx1ZSUyMiU1RCUyQyUwQSklMEElMEFtb2RlbCUyMCUzRCUyMEF1dG9Nb2RlbEZvckltYWdlQ2xhc3NpZmljYXRpb24uZnJvbV9wcmV0cmFpbmVkKCUyMmdvb2dsZSUyRnZpdC1iYXNlLXBhdGNoMTYtMjI0JTIyKSUwQWFkYW1zc19tb2RlbCUyMCUzRCUyMGdldF9wZWZ0X21vZGVsKG1vZGVsJTJDJTIwY29uZmlnKQ==",highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> AutoModelForImageClassification
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> peft <span class="hljs-keyword">import</span> AdamssConfig, get_peft_model

<span class="hljs-meta">&gt;&gt;&gt; </span>config = AdamssConfig(
<span class="hljs-meta">... </span>    r=<span class="hljs-number">500</span>,
<span class="hljs-meta">... </span>    num_subspaces=<span class="hljs-number">5</span>,
<span class="hljs-meta">... </span>    target_modules=[<span class="hljs-string">&quot;query&quot;</span>, <span class="hljs-string">&quot;value&quot;</span>],
<span class="hljs-meta">... </span>)

<span class="hljs-meta">&gt;&gt;&gt; </span>model = AutoModelForImageClassification.from_pretrained(<span class="hljs-string">&quot;google/vit-base-patch16-224&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>adamss_model = get_peft_model(model, config)`,wrap:!1}}),{c(){i=p("p"),i.textContent=k,b=s(),y(c.$$.fragment)},l(n){i=d(n,"P",{"data-svelte-h":!0}),u(i)!=="svelte-11lpom8"&&(i.textContent=k),b=o(n),w(c.$$.fragment,n)},m(n,_){r(n,i,_),r(n,b,_),A(c,n,_),f=!0},p:Oe,i(n){f||(x(c.$$.fragment,n),f=!0)},o(n){M(c.$$.fragment,n),f=!1},d(n){n&&(a(i),a(b)),$(c,n)}}}function st(W){let i,k="Example:",b,c,f;return c=new Ye({props:{code:"Zm9yJTIwc3RlcCUyQyUyMGJhdGNoJTIwaW4lMjBlbnVtZXJhdGUoZGF0YWxvYWRlciklM0ElMEFsb3NzJTIwJTNEJTIwbW9kZWwoKipiYXRjaCkubG9zcyUyMGxvc3MuYmFja3dhcmQoKSUyMG9wdGltaXplci5zdGVwKCklMjBtb2RlbC5iYXNlX21vZGVsLnVwZGF0ZV9hbmRfYWxsb2NhdGUoc3RlcCklMEFvcHRpbWl6ZXIuemVyb19ncmFkKCk=",highlighted:`<span class="hljs-keyword">for</span> step, batch <span class="hljs-keyword">in</span> <span class="hljs-built_in">enumerate</span>(dataloader):
loss = model(**batch).loss loss.backward() optimizer.step() model.base_model.update_and_allocate(step)
optimizer.zero_grad()`,wrap:!1}}),{c(){i=p("p"),i.textContent=k,b=s(),y(c.$$.fragment)},l(n){i=d(n,"P",{"data-svelte-h":!0}),u(i)!=="svelte-11lpom8"&&(i.textContent=k),b=o(n),w(c.$$.fragment,n)},m(n,_){r(n,i,_),r(n,b,_),A(c,n,_),f=!0},p:Oe,i(n){f||(x(c.$$.fragment,n),f=!0)},o(n){M(c.$$.fragment,n),f=!1},d(n){n&&(a(i),a(b)),$(c,n)}}}function ot(W){let i,k,b,c,f,n,_,ne,j,je='<a href="https://openreview.net/forum?id=8ZdWmpYxT0" rel="nofollow">AdaMSS</a> (AdaMSS: Adaptive Multi-Subspace Approach for Parameter-Efficient Fine-Tuning) is a parameter-efficient fine-tuning method that decomposes weight matrices using SVD and clusters the decomposed space into multiple trainable subspaces. Each subspace learns independent low-rank updates while the original weights remain frozen. AdaMSS also supports Adaptive Subspace Allocation (ASA), which dynamically prunes less important subspaces during training based on gradient information.',se,E,Ee="The abstract from the paper is:",oe,L,Le="<p>We propose AdaMSS, an adaptive multi-subspace approach for parameter-efficient fine-tuning of large models. Unlike traditional parameterefficient fine-tuning methods that operate within a large single subspace of the network weights, AdaMSS leverages subspace segmentation to obtain multiple smaller subspaces and adaptively reduces the number of trainable parameters during training, ultimately updating only those associated with a small subset of subspaces most relevant to the target downstream task. By using the lowest-rank representation, AdaMSS achieves more compact expressiveness and finer tuning of the model parameters. Theoretical analyses demonstrate that AdaMSS has better generalization guarantee than LoRA, PiSSA, and other single-subspace low-rankbased methods. Extensive experiments across image classification, natural language understanding, and natural language generation tasks show that AdaMSS achieves comparable performance to full fine-tuning and outperforms other parameterefficient fine-tuning methods in most cases, all while requiring fewer trainable parameters. Notably, on the ViT-Large model, AdaMSS achieves 4.7% higher average accuracy than LoRA across seven tasks, using just 15.4% of the trainable parameters. On RoBERTa-Large, AdaMSS outperforms PiSSA by 7% in average accuracy across six tasks while reducing the number of trainable parameters by approximately 94.4%. These results demonstrate the effectiveness of AdaMSS in parameter-efficient fine-tuning. The code for AdaMSS is available at https: //github.com/jzheng20/AdaMSS.</p>",re,D,De="AdaMSS currently has the following constraints:",ie,N,Ne="<li>Only <code>nn.Linear</code> layers are supported.</li> <li>Requires scikit-learn for the KMeans clustering step.</li>",le,z,ze="If these constraints don’t work for your use case, consider other methods instead.",pe,Z,de,C,F,he,I,Ze="Configuration class for Adamss (Adaptive Multi-Subspaces) method.",be,q,Fe=`AdaMSS is a parameter-efficient fine-tuning method that decomposes weight matrices using SVD and clusters the
decomposed space into multiple trainable subspaces. It learns low-rank updates within these subspaces while keeping
the original weights frozen.`,ce,H,me,m,R,_e,P,He="Creates Adamss (Adaptive Multi-Subspaces) model from a pretrained model.",ve,J,Re=`The method decomposes weight matrices using SVD and clusters the decomposed space into multiple trainable subspaces
for parameter-efficient fine-tuning.`,ye,T,we,O,Ge="<strong>Attributes</strong>:",Ae,Y,Ve='<li><strong>model</strong> (<code>~torch.nn.Module</code>) — The model to be adapted.</li> <li><strong>peft_config</strong> (<a href="/docs/peft/main/en/package_reference/adamss#peft.AdamssConfig">AdamssConfig</a>): The configuration of the Adamss model.</li>',xe,h,G,Me,Q,We="Update importance scores and apply ASA masking (if enabled).",$e,B,Ie=`This method should be called in <strong>every</strong> training step after <code>loss.backward()</code> and before
<code>optimizer.zero_grad()</code> when ASA is enabled. Internally it:`,Ce,X,qe="<li>Accumulates importance scores via EMA every step during the warmup period.</li> <li>At mask intervals, applies global top-K masking and resets importance.</li>",ke,K,Pe=`This is the single entry point for ASA – using the <code>AdamssAsaCallback</code> with HuggingFace <code>Trainer</code>
simply delegates to this method. For custom training loops, call this directly instead of the callback.`,Se,U,ue,V,fe,ee,ge;return f=new tt({props:{containerStyle:"float: right; margin-left: 10px; display: inline-flex; position: relative; z-index: 10;"}}),_=new Te({props:{title:"AdaMSS",local:"adamss",headingTag:"h1"}}),Z=new Te({props:{title:"AdamssConfig",local:"peft.AdamssConfig",headingTag:"h2"}}),F=new Ue({props:{name:"class peft.AdamssConfig",anchor:"peft.AdamssConfig",parameters:[{name:"task_type",val:": Optional[Union[str, TaskType]] = None"},{name:"peft_type",val:": Optional[Union[str, PeftType]] = None"},{name:"auto_mapping",val:": Optional[dict] = None"},{name:"peft_version",val:": Optional[str] = None"},{name:"base_model_name_or_path",val:": Optional[str] = None"},{name:"revision",val:": Optional[str] = None"},{name:"inference_mode",val:": bool = False"},{name:"r",val:": int = 100"},{name:"num_subspaces",val:": int = 5"},{name:"subspace_rank",val:": int = 1"},{name:"target_modules",val:": Optional[Union[list[str], str]] = None"},{name:"init_weights",val:": Optional[Literal['orthogonal']] = 'orthogonal'"},{name:"modules_to_save",val:": Optional[list[str]] = None"},{name:"layers_to_transform",val:": Optional[Union[list[int], int]] = None"},{name:"layers_pattern",val:": Optional[Union[list[str], str]] = None"},{name:"use_asa",val:": bool = False"},{name:"asa_target_subspaces",val:": int = 50"},{name:"init_warmup",val:": int = 50"},{name:"final_warmup",val:": int = 1000"},{name:"mask_interval",val:": int = 100"},{name:"asa_importance_beta",val:": float = 0.85"},{name:"asa_uncertainty_beta",val:": float = 0.85"},{name:"asa_schedule_exponent",val:": float = 3.0"},{name:"use_dynamic_rank",val:": bool = False"},{name:"svd_threshold",val:": float = 0.1"}],parametersDescription:[{anchor:"peft.AdamssConfig.r",description:`<strong>r</strong> (<code>int</code>) &#x2014;
Total rank for SVD decomposition (denoted as R in the paper). This determines how many singular vectors are
used to represent the weight matrix before clustering. Higher values capture more information from the
original weights but require more computation and memory. Lower values provide stronger regularization.
Typical values range from 50 to 500. Default is 100.`,name:"r"},{anchor:"peft.AdamssConfig.num_subspaces",description:`<strong>num_subspaces</strong> (<code>int</code>) &#x2014;
Number of subspaces (K) to cluster the SVD-decomposed space into. Each subspace learns independent low-rank
updates. Increasing this value allows finer-grained adaptation but increases the number of trainable
parameters proportionally. When using ASA (Adaptive Subspace Allocation), this determines the initial
number of subspaces before pruning. Typical values range from 3 to 10. Default is 5.`,name:"num_subspaces"},{anchor:"peft.AdamssConfig.subspace_rank",description:`<strong>subspace_rank</strong> (<code>int</code>) &#x2014;
The rank (r_i) for each trainable subspace. This controls the capacity of each subspace to learn
adaptations. Higher values increase expressiveness but also increase trainable parameters. Total trainable
parameters scale as O(num_subspaces <em> subspace_rank </em> (in_dim + out_dim) / num_subspaces). For most tasks,
values of 1-4 work well. Default is 1.`,name:"subspace_rank"},{anchor:"peft.AdamssConfig.target_modules",description:`<strong>target_modules</strong> (<code>Optional[Union[list[str], str]]</code>) &#x2014;
The names of the modules to apply AdaMSS to. If specified, only these modules will be adapted. Can be a
list of exact module names or a regex expression. For example, <code>[&apos;q_proj&apos;, &apos;v_proj&apos;]</code> for attention layers,
or <code>&apos;.*decoder.*(SelfAttention|EncDecAttention).*(q|v)$&apos;</code> for regex matching.`,name:"target_modules"},{anchor:"peft.AdamssConfig.modules_to_save",description:`<strong>modules_to_save</strong> (<code>Optional[list[str]]</code>) &#x2014;
List of modules apart from AdaMSS layers to be set as trainable and saved in the final checkpoint. These
modules will be fully fine-tuned (not just low-rank). Required for randomly initialized heads like
<code>classifier</code> or <code>score</code> in classification tasks.`,name:"modules_to_save"},{anchor:"peft.AdamssConfig.init_weights",description:`<strong>init_weights</strong> (<code>Literal[&quot;orthogonal&quot;]</code>) &#x2014;
Initialization method for AdaMSS trainable weights. Currently only &#x201C;orthogonal&#x201D; is supported, which uses
orthogonal initialization for the B matrices (output projection). The A matrices are initialized to zero to
ensure the model starts from the pretrained weights. Set to None to skip initialization when loading from a
checkpoint. Default is &#x201C;orthogonal&#x201D;.`,name:"init_weights"},{anchor:"peft.AdamssConfig.layers_to_transform",description:`<strong>layers_to_transform</strong> (<code>Optional[Union[list[int], int]]</code>) &#x2014;
Specific layer indices to apply AdaMSS to. If specified, only these layers will be adapted, useful for
experimenting with which layers benefit most from adaptation. Can be a single integer or a list of
integers.`,name:"layers_to_transform"},{anchor:"peft.AdamssConfig.layers_pattern",description:`<strong>layers_pattern</strong> (<code>Optional[Union[list[str], str]]</code>) &#x2014;
Pattern to match layer names when <code>layers_to_transform</code> is specified. Used to extract layer indices from
module names that don&#x2019;t follow the common pattern.`,name:"layers_pattern"},{anchor:"peft.AdamssConfig.use_asa",description:`<strong>use_asa</strong> (<code>bool</code>) &#x2014;
Whether to enable Adaptive Subspace Allocation (ASA). When enabled, ASA dynamically prunes less important
subspaces during training based on gradient information, reducing the effective number of parameters while
maintaining performance. Requires integration with a training callback. Default is False.`,name:"use_asa"},{anchor:"peft.AdamssConfig.asa_target_subspaces",description:`<strong>asa_target_subspaces</strong> (<code>int</code>) &#x2014;
Target total number of active subspaces across all layers when ASA is enabled. ASA will progressively prune
subspaces until this target is reached. Lower values result in more aggressive pruning and fewer trainable
parameters. Should be less than <code>num_subspaces * num_target_modules</code>. Typical values range from 20 to 100
depending on model size. Default is 50.`,name:"asa_target_subspaces"},{anchor:"peft.AdamssConfig.init_warmup",description:`<strong>init_warmup</strong> (<code>int</code>) &#x2014;
Number of training steps to wait before starting ASA pruning. During warmup, all subspaces remain active to
allow importance scores to stabilize. Higher values give more time for accurate importance estimation but
delay pruning. Typical values range from 50 to 200. Default is 50.`,name:"init_warmup"},{anchor:"peft.AdamssConfig.final_warmup",description:`<strong>final_warmup</strong> (<code>int</code>) &#x2014;
Training step at which ASA completes pruning and reaches <code>asa_target_subspaces</code> active subspaces. The
pruning is distributed between <code>init_warmup</code> and <code>final_warmup</code>. Should be set based on total training
steps; typically 1/3 to 1/2 of total training steps. Default is 1000.`,name:"final_warmup"},{anchor:"peft.AdamssConfig.mask_interval",description:`<strong>mask_interval</strong> (<code>int</code>) &#x2014;
Number of training steps between ASA mask updates. Lower values allow more frequent adaptation but increase
overhead. Higher values provide more stable importance estimates between updates. Typical values range from
50 to 200. Default is 100.`,name:"mask_interval"},{anchor:"peft.AdamssConfig.asa_importance_beta",description:`<strong>asa_importance_beta</strong> (<code>float</code>) &#x2014;
Exponential moving average (EMA) coefficient for smoothing subspace importance scores. Higher values
(closer to 1.0) give more weight to historical importance, providing stability. Lower values make
importance more responsive to recent gradients. Typical values range from 0.8 to 0.95. Default is 0.85.`,name:"asa_importance_beta"},{anchor:"peft.AdamssConfig.asa_uncertainty_beta",description:`<strong>asa_uncertainty_beta</strong> (<code>float</code>) &#x2014;
EMA coefficient for smoothing importance uncertainty estimates. Controls how quickly uncertainty adapts to
gradient variance. Similar to asa_importance_beta, higher values provide more stable estimates. Typical
values range from 0.8 to 0.95. Default is 0.85.`,name:"asa_uncertainty_beta"},{anchor:"peft.AdamssConfig.asa_schedule_exponent",description:`<strong>asa_schedule_exponent</strong> (<code>float</code>) &#x2014;
Schedule exponent controlling the decay rate from total subspaces to <code>asa_target_subspaces</code> during ASA
warmup. Higher values result in faster initial pruning (more aggressive early reduction), while lower
values provide a more gradual, linear-like decay. The formula is: current_active_subspaces =
asa_target_subspaces + (asa_total_subspaces - asa_target_subspaces) * (progress ** exponent). Typical
values range from 1.0 (linear) to 5.0 (aggressive). Default is 3.0.`,name:"asa_schedule_exponent"},{anchor:"peft.AdamssConfig.use_dynamic_rank",description:`<strong>use_dynamic_rank</strong> (<code>bool</code>) &#x2014;
Whether to dynamically determine subspace ranks based on singular value magnitudes. When True, each
subspace&#x2019;s rank is determined by counting singular values above a threshold, allowing different subspaces
to have different effective ranks. When False, all subspaces use the fixed <code>subspace_rank</code>. Default is
False.`,name:"use_dynamic_rank"},{anchor:"peft.AdamssConfig.svd_threshold",description:`<strong>svd_threshold</strong> (<code>float</code>) &#x2014;
Threshold ratio for dynamic rank selection, only used when <code>use_dynamic_rank=True</code>. A singular value is
considered significant if it exceeds <code>threshold * max_singular_value</code>. Higher values result in lower
effective ranks (more aggressive truncation). Typical values range from 0.05 to 0.2. Default is 0.1 (10% of
max).`,name:"svd_threshold"}],source:"https://github.com/huggingface/peft/blob/main/src/peft/tuners/adamss/config.py#L25"}}),H=new Te({props:{title:"AdamssModel",local:"peft.AdamssModel",headingTag:"h2"}}),R=new Ue({props:{name:"class peft.AdamssModel",anchor:"peft.AdamssModel",parameters:[{name:"model",val:""},{name:"config",val:""},{name:"adapter_name",val:""},{name:"low_cpu_mem_usage",val:": bool = False"},{name:"state_dict",val:": Optional[dict] = None"}],parametersDescription:[{anchor:"peft.AdamssModel.model",description:"<strong>model</strong> (<code>torch.nn.Module</code>) &#x2014; The model to be adapted.",name:"model"},{anchor:"peft.AdamssModel.config",description:"<strong>config</strong> (<code>AdamssConfig</code>) &#x2014; The configuration of the Adamss model.",name:"config"},{anchor:"peft.AdamssModel.adapter_name",description:"<strong>adapter_name</strong> (<code>str</code>) &#x2014; The name of the adapter, defaults to <code>&quot;default&quot;</code>.",name:"adapter_name"}],source:"https://github.com/huggingface/peft/blob/main/src/peft/tuners/adamss/model.py#L31",returnDescription:`<script context="module">export const metadata = 'undefined';<\/script>


<p>The Adamss model.</p>
`,returnType:`<script context="module">export const metadata = 'undefined';<\/script>


<p><code>torch.nn.Module</code></p>
`}}),T=new Je({props:{anchor:"peft.AdamssModel.example",$$slots:{default:[nt]},$$scope:{ctx:W}}}),G=new Ue({props:{name:"update_and_allocate",anchor:"peft.AdamssModel.update_and_allocate",parameters:[{name:"global_step",val:": int"}],parametersDescription:[{anchor:"peft.AdamssModel.update_and_allocate.global_step",description:"<strong>global_step</strong> (<em>int</em>) &#x2014; The current training step.",name:"global_step"}],source:"https://github.com/huggingface/peft/blob/main/src/peft/tuners/adamss/model.py#L157"}}),U=new Je({props:{anchor:"peft.AdamssModel.update_and_allocate.example",$$slots:{default:[st]},$$scope:{ctx:W}}}),V=new at({props:{source:"https://github.com/huggingface/peft/blob/main/docs/source/package_reference/adamss.md"}}),{c(){i=p("meta"),k=s(),b=p("p"),c=s(),y(f.$$.fragment),n=s(),y(_.$$.fragment),ne=s(),j=p("p"),j.innerHTML=je,se=s(),E=p("p"),E.textContent=Ee,oe=s(),L=p("blockquote"),L.innerHTML=Le,re=s(),D=p("p"),D.textContent=De,ie=s(),N=p("ul"),N.innerHTML=Ne,le=s(),z=p("p"),z.textContent=ze,pe=s(),y(Z.$$.fragment),de=s(),C=p("div"),y(F.$$.fragment),he=s(),I=p("p"),I.textContent=Ze,be=s(),q=p("p"),q.textContent=Fe,ce=s(),y(H.$$.fragment),me=s(),m=p("div"),y(R.$$.fragment),_e=s(),P=p("p"),P.textContent=He,ve=s(),J=p("p"),J.textContent=Re,ye=s(),y(T.$$.fragment),we=s(),O=p("p"),O.innerHTML=Ge,Ae=s(),Y=p("ul"),Y.innerHTML=Ve,xe=s(),h=p("div"),y(G.$$.fragment),Me=s(),Q=p("p"),Q.textContent=We,$e=s(),B=p("p"),B.innerHTML=Ie,Ce=s(),X=p("ol"),X.innerHTML=qe,ke=s(),K=p("p"),K.innerHTML=Pe,Se=s(),y(U.$$.fragment),ue=s(),y(V.$$.fragment),fe=s(),ee=p("p"),this.h()},l(e){const t=et("svelte-u9bgzb",document.head);i=d(t,"META",{name:!0,content:!0}),t.forEach(a),k=o(e),b=d(e,"P",{}),te(b).forEach(a),c=o(e),w(f.$$.fragment,e),n=o(e),w(_.$$.fragment,e),ne=o(e),j=d(e,"P",{"data-svelte-h":!0}),u(j)!=="svelte-120xbwd"&&(j.innerHTML=je),se=o(e),E=d(e,"P",{"data-svelte-h":!0}),u(E)!=="svelte-1cwsb16"&&(E.textContent=Ee),oe=o(e),L=d(e,"BLOCKQUOTE",{"data-svelte-h":!0}),u(L)!=="svelte-1rltl19"&&(L.innerHTML=Le),re=o(e),D=d(e,"P",{"data-svelte-h":!0}),u(D)!=="svelte-15fs9qr"&&(D.textContent=De),ie=o(e),N=d(e,"UL",{"data-svelte-h":!0}),u(N)!=="svelte-4mb2y9"&&(N.innerHTML=Ne),le=o(e),z=d(e,"P",{"data-svelte-h":!0}),u(z)!=="svelte-hr8j55"&&(z.textContent=ze),pe=o(e),w(Z.$$.fragment,e),de=o(e),C=d(e,"DIV",{class:!0});var S=te(C);w(F.$$.fragment,S),he=o(S),I=d(S,"P",{"data-svelte-h":!0}),u(I)!=="svelte-1pg4l5"&&(I.textContent=Ze),be=o(S),q=d(S,"P",{"data-svelte-h":!0}),u(q)!=="svelte-1di2avu"&&(q.textContent=Fe),S.forEach(a),ce=o(e),w(H.$$.fragment,e),me=o(e),m=d(e,"DIV",{class:!0});var g=te(m);w(R.$$.fragment,g),_e=o(g),P=d(g,"P",{"data-svelte-h":!0}),u(P)!=="svelte-1adqxtr"&&(P.textContent=He),ve=o(g),J=d(g,"P",{"data-svelte-h":!0}),u(J)!=="svelte-dx6dac"&&(J.textContent=Re),ye=o(g),w(T.$$.fragment,g),we=o(g),O=d(g,"P",{"data-svelte-h":!0}),u(O)!=="svelte-1xx6nm4"&&(O.innerHTML=Ge),Ae=o(g),Y=d(g,"UL",{"data-svelte-h":!0}),u(Y)!=="svelte-1jkb9yw"&&(Y.innerHTML=Ve),xe=o(g),h=d(g,"DIV",{class:!0});var v=te(h);w(G.$$.fragment,v),Me=o(v),Q=d(v,"P",{"data-svelte-h":!0}),u(Q)!=="svelte-1vrk6t"&&(Q.textContent=We),$e=o(v),B=d(v,"P",{"data-svelte-h":!0}),u(B)!=="svelte-w7ld42"&&(B.innerHTML=Ie),Ce=o(v),X=d(v,"OL",{"data-svelte-h":!0}),u(X)!=="svelte-n3ua4v"&&(X.innerHTML=qe),ke=o(v),K=d(v,"P",{"data-svelte-h":!0}),u(K)!=="svelte-v3pra5"&&(K.innerHTML=Pe),Se=o(v),w(U.$$.fragment,v),v.forEach(a),g.forEach(a),ue=o(e),w(V.$$.fragment,e),fe=o(e),ee=d(e,"P",{}),te(ee).forEach(a),this.h()},h(){ae(i,"name","hf:doc:metadata"),ae(i,"content",rt),ae(C,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),ae(h,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),ae(m,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8")},m(e,t){l(document.head,i),r(e,k,t),r(e,b,t),r(e,c,t),A(f,e,t),r(e,n,t),A(_,e,t),r(e,ne,t),r(e,j,t),r(e,se,t),r(e,E,t),r(e,oe,t),r(e,L,t),r(e,re,t),r(e,D,t),r(e,ie,t),r(e,N,t),r(e,le,t),r(e,z,t),r(e,pe,t),A(Z,e,t),r(e,de,t),r(e,C,t),A(F,C,null),l(C,he),l(C,I),l(C,be),l(C,q),r(e,ce,t),A(H,e,t),r(e,me,t),r(e,m,t),A(R,m,null),l(m,_e),l(m,P),l(m,ve),l(m,J),l(m,ye),A(T,m,null),l(m,we),l(m,O),l(m,Ae),l(m,Y),l(m,xe),l(m,h),A(G,h,null),l(h,Me),l(h,Q),l(h,$e),l(h,B),l(h,Ce),l(h,X),l(h,ke),l(h,K),l(h,Se),A(U,h,null),r(e,ue,t),A(V,e,t),r(e,fe,t),r(e,ee,t),ge=!0},p(e,[t]){const S={};t&2&&(S.$$scope={dirty:t,ctx:e}),T.$set(S);const g={};t&2&&(g.$$scope={dirty:t,ctx:e}),U.$set(g)},i(e){ge||(x(f.$$.fragment,e),x(_.$$.fragment,e),x(Z.$$.fragment,e),x(F.$$.fragment,e),x(H.$$.fragment,e),x(R.$$.fragment,e),x(T.$$.fragment,e),x(G.$$.fragment,e),x(U.$$.fragment,e),x(V.$$.fragment,e),ge=!0)},o(e){M(f.$$.fragment,e),M(_.$$.fragment,e),M(Z.$$.fragment,e),M(F.$$.fragment,e),M(H.$$.fragment,e),M(R.$$.fragment,e),M(T.$$.fragment,e),M(G.$$.fragment,e),M(U.$$.fragment,e),M(V.$$.fragment,e),ge=!1},d(e){e&&(a(k),a(b),a(c),a(n),a(ne),a(j),a(se),a(E),a(oe),a(L),a(re),a(D),a(ie),a(N),a(le),a(z),a(pe),a(de),a(C),a(ce),a(me),a(m),a(ue),a(fe),a(ee)),a(i),$(f,e),$(_,e),$(Z,e),$(F),$(H,e),$(R),$(T),$(G),$(U),$(V,e)}}}const rt='{"title":"AdaMSS","local":"adamss","sections":[{"title":"AdamssConfig","local":"peft.AdamssConfig","sections":[],"depth":2},{"title":"AdamssModel","local":"peft.AdamssModel","sections":[],"depth":2}],"depth":1}';function it(W){return Be(()=>{new URLSearchParams(window.location.search).get("fw")}),[]}class ft extends Xe{constructor(i){super(),Ke(this,i,it,ot,Qe,{})}}export{ft as component};
