import{s as oa,o as na,n as q}from"../chunks/scheduler.01eeda35.js";import{S as sa,i as aa,g as l,s as n,r as f,A as ra,h as d,f as a,c as s,j as k,u,x as b,k as M,y as t,a as c,v as h,d as g,t as _,w as v}from"../chunks/index.6dd51b66.js";import{T as go}from"../chunks/Tip.de9bae2b.js";import{D as x}from"../chunks/Docstring.76e6b3cf.js";import{C as Ce}from"../chunks/CodeBlock.864da1b0.js";import{E as yt}from"../chunks/ExampleCodeBlock.6a36fb6b.js";import{H as U,E as ia}from"../chunks/EditOnGithub.7faefd25.js";function la(w){let r,C="Example:",p,m,y;return m=new Ce({props:{code:"ZnJvbSUyMHRyYW5zZm9ybWVycyUyMGltcG9ydCUyMENsdnBDb25maWclMkMlMjBDbHZwTW9kZWxGb3JDb25kaXRpb25hbEdlbmVyYXRpb24lMEElMEElMjMlMjBJbml0aWFsaXppbmclMjBhJTIwQ2x2cENvbmZpZyUyMHdpdGglMjBzdXNuYXRvJTJGY2x2cF9kZXYlMjBzdHlsZSUyMGNvbmZpZ3VyYXRpb24lMEFjb25maWd1cmF0aW9uJTIwJTNEJTIwQ2x2cENvbmZpZygpJTBBJTBBJTIzJTIwSW5pdGlhbGl6aW5nJTIwYSUyMENsdnBNb2RlbEZvckNvbmRpdGlvbmFsR2VuZXJhdGlvbiUyMCh3aXRoJTIwcmFuZG9tJTIwd2VpZ2h0cyklMjBmcm9tJTIwdGhlJTIwc3VzbmF0byUyRmNsdnBfZGV2JTIwc3R5bGUlMjBjb25maWd1cmF0aW9uJTBBbW9kZWwlMjAlM0QlMjBDbHZwTW9kZWxGb3JDb25kaXRpb25hbEdlbmVyYXRpb24oY29uZmlndXJhdGlvbiklMEElMEElMjMlMjBBY2Nlc3NpbmclMjB0aGUlMjBtb2RlbCUyMGNvbmZpZ3VyYXRpb24lMEFjb25maWd1cmF0aW9uJTIwJTNEJTIwbW9kZWwuY29uZmlnJTBBJTBBJTIzJTIwV2UlMjBjYW4lMjBhbHNvJTIwaW5pdGlhbGl6ZSUyMGElMjBDTFZQQ29uZmlnJTIwZnJvbSUyMGElMjBDTFZQVGV4dENvbmZpZyUyQyUyMENMVlBTcGVlY2hDb25maWclMjBhbmQlMjBhJTIwQ0xWUEF1dG9SZWdyZXNzaXZlQ29uZmlnJTBBZnJvbSUyMHRyYW5zZm9ybWVycyUyMGltcG9ydCUyMENsdnBFbmNvZGVyQ29uZmlnJTJDJTIwQ2x2cERlY29kZXJDb25maWclMEElMEElMjMlMjBJbml0aWFsaXppbmclMjBhJTIwQ0xWUCUyMHRleHQlMkMlMjBDTFZQJTIwc3BlZWNoJTIwYW5kJTIwQ0xWUCUyMGRlY29kZXIlMjBjb25maWd1cmF0aW9uJTBBY29uZmlnX3RleHQlMjAlM0QlMjBDbHZwRW5jb2RlckNvbmZpZygpJTBBY29uZmlnX3NwZWVjaCUyMCUzRCUyMENsdnBFbmNvZGVyQ29uZmlnKCklMEFkZWNvZGVyX2NvbmZpZyUyMCUzRCUyMENsdnBEZWNvZGVyQ29uZmlnKCklMEElMEFjb25maWclMjAlM0QlMjBDbHZwQ29uZmlnLmZyb21fc3ViX21vZGVsX2NvbmZpZ3MoY29uZmlnX3RleHQlMkMlMjBjb25maWdfc3BlZWNoJTJDJTIwZGVjb2Rlcl9jb25maWcp",highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> ClvpConfig, ClvpModelForConditionalGeneration

<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-comment"># Initializing a ClvpConfig with susnato/clvp_dev style configuration</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>configuration = ClvpConfig()

<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-comment"># Initializing a ClvpModelForConditionalGeneration (with random weights) from the susnato/clvp_dev style configuration</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>model = ClvpModelForConditionalGeneration(configuration)

<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-comment"># Accessing the model configuration</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>configuration = model.config

<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-comment"># We can also initialize a CLVPConfig from a CLVPTextConfig, CLVPSpeechConfig and a CLVPAutoRegressiveConfig</span>
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> ClvpEncoderConfig, ClvpDecoderConfig

<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-comment"># Initializing a CLVP text, CLVP speech and CLVP decoder configuration</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>config_text = ClvpEncoderConfig()
<span class="hljs-meta">&gt;&gt;&gt; </span>config_speech = ClvpEncoderConfig()
<span class="hljs-meta">&gt;&gt;&gt; </span>decoder_config = ClvpDecoderConfig()

<span class="hljs-meta">&gt;&gt;&gt; </span>config = ClvpConfig.from_sub_model_configs(config_text, config_speech, decoder_config)`,wrap:!1}}),{c(){r=l("p"),r.textContent=C,p=n(),f(m.$$.fragment)},l(o){r=d(o,"P",{"data-svelte-h":!0}),b(r)!=="svelte-11lpom8"&&(r.textContent=C),p=s(o),u(m.$$.fragment,o)},m(o,T){c(o,r,T),c(o,p,T),h(m,o,T),y=!0},p:q,i(o){y||(g(m.$$.fragment,o),y=!0)},o(o){_(m.$$.fragment,o),y=!1},d(o){o&&(a(r),a(p)),v(m,o)}}}function da(w){let r,C="Example:",p,m,y;return m=new Ce({props:{code:"ZnJvbSUyMHRyYW5zZm9ybWVycyUyMGltcG9ydCUyMENsdnBFbmNvZGVyQ29uZmlnJTJDJTIwQ2x2cEVuY29kZXIlMEElMEElMjMlMjBJbml0aWFsaXppbmclMjBhJTIwQ2x2cEVuY29kZXJDb25maWclMjB3aXRoJTIwc3VzbmF0byUyRmNsdnBfZGV2JTIwc3R5bGUlMjBjb25maWd1cmF0aW9uJTBBZW5jb2Rlcl9jb25maWd1cmF0aW9uJTIwJTNEJTIwQ2x2cEVuY29kZXJDb25maWcoKSUwQSUwQSUyMyUyMEluaXRpYWxpemluZyUyMGElMjBDbHZwRW5jb2RlciUyMCh3aXRoJTIwcmFuZG9tJTIwd2VpZ2h0cyklMjBmcm9tJTIwdGhlJTIwc3VzbmF0byUyRmNsdnBfZGV2JTIwc3R5bGUlMjBjb25maWd1cmF0aW9uJTBBbW9kZWwlMjAlM0QlMjBDbHZwRW5jb2RlcihlbmNvZGVyX2NvbmZpZ3VyYXRpb24pJTBBJTBBJTIzJTIwQWNjZXNzaW5nJTIwdGhlJTIwbW9kZWwlMjBjb25maWd1cmF0aW9uJTBBY29uZmlndXJhdGlvbiUyMCUzRCUyMG1vZGVsLmNvbmZpZw==",highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> ClvpEncoderConfig, ClvpEncoder

<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-comment"># Initializing a ClvpEncoderConfig with susnato/clvp_dev style configuration</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>encoder_configuration = ClvpEncoderConfig()

<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-comment"># Initializing a ClvpEncoder (with random weights) from the susnato/clvp_dev style configuration</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>model = ClvpEncoder(encoder_configuration)

<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-comment"># Accessing the model configuration</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>configuration = model.config`,wrap:!1}}),{c(){r=l("p"),r.textContent=C,p=n(),f(m.$$.fragment)},l(o){r=d(o,"P",{"data-svelte-h":!0}),b(r)!=="svelte-11lpom8"&&(r.textContent=C),p=s(o),u(m.$$.fragment,o)},m(o,T){c(o,r,T),c(o,p,T),h(m,o,T),y=!0},p:q,i(o){y||(g(m.$$.fragment,o),y=!0)},o(o){_(m.$$.fragment,o),y=!1},d(o){o&&(a(r),a(p)),v(m,o)}}}function ca(w){let r,C="Example:",p,m,y;return m=new Ce({props:{code:"ZnJvbSUyMHRyYW5zZm9ybWVycyUyMGltcG9ydCUyMENsdnBEZWNvZGVyQ29uZmlnJTJDJTIwQ2x2cERlY29kZXIlMEElMEElMjMlMjBJbml0aWFsaXppbmclMjBhJTIwQ2x2cERlY29kZXJDb25maWclMjB3aXRoJTIwc3VzbmF0byUyRmNsdnBfZGV2JTIwc3R5bGUlMjBjb25maWd1cmF0aW9uJTBBZGVjb2Rlcl9jb25maWd1cmF0aW9uJTIwJTNEJTIwQ2x2cERlY29kZXJDb25maWcoKSUwQSUwQSUyMyUyMEluaXRpYWxpemluZyUyMGElMjBDbHZwRGVjb2RlciUyMCh3aXRoJTIwcmFuZG9tJTIwd2VpZ2h0cyklMjBmcm9tJTIwdGhlJTIwc3VzbmF0byUyRmNsdnBfZGV2JTIwc3R5bGUlMjBjb25maWd1cmF0aW9uJTBBbW9kZWwlMjAlM0QlMjBDbHZwRGVjb2RlcihkZWNvZGVyX2NvbmZpZ3VyYXRpb24pJTBBJTBBJTIzJTIwQWNjZXNzaW5nJTIwdGhlJTIwbW9kZWwlMjBjb25maWd1cmF0aW9uJTBBY29uZmlndXJhdGlvbiUyMCUzRCUyMG1vZGVsLmNvbmZpZw==",highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> ClvpDecoderConfig, ClvpDecoder

<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-comment"># Initializing a ClvpDecoderConfig with susnato/clvp_dev style configuration</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>decoder_configuration = ClvpDecoderConfig()

<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-comment"># Initializing a ClvpDecoder (with random weights) from the susnato/clvp_dev style configuration</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>model = ClvpDecoder(decoder_configuration)

<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-comment"># Accessing the model configuration</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>configuration = model.config`,wrap:!1}}),{c(){r=l("p"),r.textContent=C,p=n(),f(m.$$.fragment)},l(o){r=d(o,"P",{"data-svelte-h":!0}),b(r)!=="svelte-11lpom8"&&(r.textContent=C),p=s(o),u(m.$$.fragment,o)},m(o,T){c(o,r,T),c(o,p,T),h(m,o,T),y=!0},p:q,i(o){y||(g(m.$$.fragment,o),y=!0)},o(o){_(m.$$.fragment,o),y=!1},d(o){o&&(a(r),a(p)),v(m,o)}}}function pa(w){let r,C="be encoded differently whether it is at the beginning of the sentence (without space) or not:",p,m,y;return m=new Ce({props:{code:"ZnJvbSUyMHRyYW5zZm9ybWVycyUyMGltcG9ydCUyMENsdnBUb2tlbml6ZXIlMEElMEF0b2tlbml6ZXIlMjAlM0QlMjBDbHZwVG9rZW5pemVyLmZyb21fcHJldHJhaW5lZCglMjJzdXNuYXRvJTJGY2x2cF9kZXYlMjIpJTBBdG9rZW5pemVyKCUyMkhlbGxvJTIwd29ybGQlMjIpJTVCJTIyaW5wdXRfaWRzJTIyJTVEJTBBJTBBdG9rZW5pemVyKCUyMiUyMEhlbGxvJTIwd29ybGQlMjIpJTVCJTIyaW5wdXRfaWRzJTIyJTVE",highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> ClvpTokenizer

<span class="hljs-meta">&gt;&gt;&gt; </span>tokenizer = ClvpTokenizer.from_pretrained(<span class="hljs-string">&quot;susnato/clvp_dev&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>tokenizer(<span class="hljs-string">&quot;Hello world&quot;</span>)[<span class="hljs-string">&quot;input_ids&quot;</span>]
[<span class="hljs-number">62</span>, <span class="hljs-number">84</span>, <span class="hljs-number">28</span>, <span class="hljs-number">2</span>, <span class="hljs-number">179</span>, <span class="hljs-number">79</span>]

<span class="hljs-meta">&gt;&gt;&gt; </span>tokenizer(<span class="hljs-string">&quot; Hello world&quot;</span>)[<span class="hljs-string">&quot;input_ids&quot;</span>]
[<span class="hljs-number">2</span>, <span class="hljs-number">62</span>, <span class="hljs-number">84</span>, <span class="hljs-number">28</span>, <span class="hljs-number">2</span>, <span class="hljs-number">179</span>, <span class="hljs-number">79</span>]`,wrap:!1}}),{c(){r=l("p"),r.textContent=C,p=n(),f(m.$$.fragment)},l(o){r=d(o,"P",{"data-svelte-h":!0}),b(r)!=="svelte-12atnao"&&(r.textContent=C),p=s(o),u(m.$$.fragment,o)},m(o,T){c(o,r,T),c(o,p,T),h(m,o,T),y=!0},p:q,i(o){y||(g(m.$$.fragment,o),y=!0)},o(o){_(m.$$.fragment,o),y=!1},d(o){o&&(a(r),a(p)),v(m,o)}}}function ma(w){let r,C="When used with <code>is_split_into_words=True</code>, this tokenizer will add a space before each word (even the first one).";return{c(){r=l("p"),r.innerHTML=C},l(p){r=d(p,"P",{"data-svelte-h":!0}),b(r)!=="svelte-jhmxzm"&&(r.innerHTML=C)},m(p,m){c(p,r,m)},p:q,d(p){p&&a(r)}}}function fa(w){let r,C=`Although the recipe for forward pass needs to be defined within this function, one should call the <code>Module</code>
instance afterwards instead of this since the former takes care of running the pre and post processing steps while
the latter silently ignores them.`;return{c(){r=l("p"),r.innerHTML=C},l(p){r=d(p,"P",{"data-svelte-h":!0}),b(r)!=="svelte-fincs2"&&(r.innerHTML=C)},m(p,m){c(p,r,m)},p:q,d(p){p&&a(r)}}}function ua(w){let r,C="Examples:",p,m,y;return m=new Ce({props:{code:"aW1wb3J0JTIwZGF0YXNldHMlMEFmcm9tJTIwdHJhbnNmb3JtZXJzJTIwaW1wb3J0JTIwQ2x2cFByb2Nlc3NvciUyQyUyMENsdnBNb2RlbEZvckNvbmRpdGlvbmFsR2VuZXJhdGlvbiUwQSUwQSUyMyUyMERlZmluZSUyMHRoZSUyMFRleHQlMjBhbmQlMjBMb2FkJTIwdGhlJTIwQXVkaW8lMjAoV2UlMjBhcmUlMjB0YWtpbmclMjBhbiUyMGF1ZGlvJTIwZXhhbXBsZSUyMGZyb20lMjBIdWdnaW5nRmFjZSUyMEh1YiUyMHVzaW5nJTIwJTYwZGF0YXNldHMlNjAlMjBsaWJyYXJ5KSUwQXRleHQlMjAlM0QlMjAlMjJUaGlzJTIwaXMlMjBhbiUyMGV4YW1wbGUlMjB0ZXh0LiUyMiUwQSUwQWRzJTIwJTNEJTIwZGF0YXNldHMubG9hZF9kYXRhc2V0KCUyMmhmLWludGVybmFsLXRlc3RpbmclMkZsaWJyaXNwZWVjaF9hc3JfZHVtbXklMjIlMkMlMjAlMjJjbGVhbiUyMiUyQyUyMHNwbGl0JTNEJTIydmFsaWRhdGlvbiUyMiklMEFkcyUyMCUzRCUyMGRzLmNhc3RfY29sdW1uKCUyMmF1ZGlvJTIyJTJDJTIwZGF0YXNldHMuQXVkaW8oc2FtcGxpbmdfcmF0ZSUzRDIyMDUwKSklMEFfJTJDJTIwYXVkaW8lMkMlMjBzciUyMCUzRCUyMGRzLnNvcnQoJTIyaWQlMjIpLnNlbGVjdChyYW5nZSgxKSklNUIlM0ExJTVEJTVCJTIyYXVkaW8lMjIlNUQlNUIwJTVELnZhbHVlcygpJTBBJTBBJTIzJTIwRGVmaW5lJTIwcHJvY2Vzc29yJTIwYW5kJTIwbW9kZWwlMEFwcm9jZXNzb3IlMjAlM0QlMjBDbHZwUHJvY2Vzc29yLmZyb21fcHJldHJhaW5lZCglMjJzdXNuYXRvJTJGY2x2cF9kZXYlMjIpJTBBbW9kZWwlMjAlM0QlMjBDbHZwTW9kZWxGb3JDb25kaXRpb25hbEdlbmVyYXRpb24uZnJvbV9wcmV0cmFpbmVkKCUyMnN1c25hdG8lMkZjbHZwX2RldiUyMiklMEElMEElMjMlMjBwcm9jZXNzb3IlMjBvdXRwdXRzJTIwYW5kJTIwbW9kZWwlMjBvdXRwdXRzJTBBcHJvY2Vzc29yX291dHB1dCUyMCUzRCUyMHByb2Nlc3NvcihyYXdfc3BlZWNoJTNEYXVkaW8lMkMlMjBzYW1wbGluZ19yYXRlJTNEc3IlMkMlMjB0ZXh0JTNEdGV4dCUyQyUyMHJldHVybl90ZW5zb3JzJTNEJTIycHQlMjIpJTBBb3V0cHV0cyUyMCUzRCUyMG1vZGVsKCUwQSUyMCUyMCUyMCUyMGlucHV0X2lkcyUzRHByb2Nlc3Nvcl9vdXRwdXQlNUIlMjJpbnB1dF9pZHMlMjIlNUQlMkMlMEElMjAlMjAlMjAlMjBpbnB1dF9mZWF0dXJlcyUzRHByb2Nlc3Nvcl9vdXRwdXQlNUIlMjJpbnB1dF9mZWF0dXJlcyUyMiU1RCUyQyUwQSUyMCUyMCUyMCUyMHJldHVybl9kaWN0JTNEVHJ1ZSUyQyUwQSk=",highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">import</span> datasets
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> ClvpProcessor, ClvpModelForConditionalGeneration

<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-comment"># Define the Text and Load the Audio (We are taking an audio example from HuggingFace Hub using \`datasets\` library)</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>text = <span class="hljs-string">&quot;This is an example text.&quot;</span>

<span class="hljs-meta">&gt;&gt;&gt; </span>ds = datasets.load_dataset(<span class="hljs-string">&quot;hf-internal-testing/librispeech_asr_dummy&quot;</span>, <span class="hljs-string">&quot;clean&quot;</span>, split=<span class="hljs-string">&quot;validation&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>ds = ds.cast_column(<span class="hljs-string">&quot;audio&quot;</span>, datasets.Audio(sampling_rate=<span class="hljs-number">22050</span>))
<span class="hljs-meta">&gt;&gt;&gt; </span>_, audio, sr = ds.sort(<span class="hljs-string">&quot;id&quot;</span>).select(<span class="hljs-built_in">range</span>(<span class="hljs-number">1</span>))[:<span class="hljs-number">1</span>][<span class="hljs-string">&quot;audio&quot;</span>][<span class="hljs-number">0</span>].values()

<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-comment"># Define processor and model</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>processor = ClvpProcessor.from_pretrained(<span class="hljs-string">&quot;susnato/clvp_dev&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>model = ClvpModelForConditionalGeneration.from_pretrained(<span class="hljs-string">&quot;susnato/clvp_dev&quot;</span>)

<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-comment"># processor outputs and model outputs</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>processor_output = processor(raw_speech=audio, sampling_rate=sr, text=text, return_tensors=<span class="hljs-string">&quot;pt&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>outputs = model(
<span class="hljs-meta">... </span>    input_ids=processor_output[<span class="hljs-string">&quot;input_ids&quot;</span>],
<span class="hljs-meta">... </span>    input_features=processor_output[<span class="hljs-string">&quot;input_features&quot;</span>],
<span class="hljs-meta">... </span>    return_dict=<span class="hljs-literal">True</span>,
<span class="hljs-meta">... </span>)`,wrap:!1}}),{c(){r=l("p"),r.textContent=C,p=n(),f(m.$$.fragment)},l(o){r=d(o,"P",{"data-svelte-h":!0}),b(r)!=="svelte-kvfsh7"&&(r.textContent=C),p=s(o),u(m.$$.fragment,o)},m(o,T){c(o,r,T),c(o,p,T),h(m,o,T),y=!0},p:q,i(o){y||(g(m.$$.fragment,o),y=!0)},o(o){_(m.$$.fragment,o),y=!1},d(o){o&&(a(r),a(p)),v(m,o)}}}function ha(w){let r,C="Examples:",p,m,y;return m=new Ce({props:{code:"ZnJvbSUyMHRyYW5zZm9ybWVycyUyMGltcG9ydCUyMENsdnBQcm9jZXNzb3IlMkMlMjBDbHZwTW9kZWxGb3JDb25kaXRpb25hbEdlbmVyYXRpb24lMEElMEElMjMlMjBEZWZpbmUlMjB0aGUlMjBUZXh0JTBBdGV4dCUyMCUzRCUyMCUyMlRoaXMlMjBpcyUyMGFuJTIwZXhhbXBsZSUyMHRleHQuJTIyJTBBJTBBJTIzJTIwRGVmaW5lJTIwcHJvY2Vzc29yJTIwYW5kJTIwbW9kZWwlMEFwcm9jZXNzb3IlMjAlM0QlMjBDbHZwUHJvY2Vzc29yLmZyb21fcHJldHJhaW5lZCglMjJzdXNuYXRvJTJGY2x2cF9kZXYlMjIpJTBBbW9kZWwlMjAlM0QlMjBDbHZwTW9kZWxGb3JDb25kaXRpb25hbEdlbmVyYXRpb24uZnJvbV9wcmV0cmFpbmVkKCUyMnN1c25hdG8lMkZjbHZwX2RldiUyMiklMEElMEElMjMlMjBHZW5lcmF0ZSUyMHByb2Nlc3NvciUyMG91dHB1dCUyMGFuZCUyMHRleHQlMjBlbWJlZHMlMEFwcm9jZXNzb3Jfb3V0cHV0JTIwJTNEJTIwcHJvY2Vzc29yKHRleHQlM0R0ZXh0JTJDJTIwcmV0dXJuX3RlbnNvcnMlM0QlMjJwdCUyMiklMEF0ZXh0X2VtYmVkcyUyMCUzRCUyMG1vZGVsLmdldF90ZXh0X2ZlYXR1cmVzKGlucHV0X2lkcyUzRHByb2Nlc3Nvcl9vdXRwdXQlNUIlMjJpbnB1dF9pZHMlMjIlNUQp",highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> ClvpProcessor, ClvpModelForConditionalGeneration

<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-comment"># Define the Text</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>text = <span class="hljs-string">&quot;This is an example text.&quot;</span>

<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-comment"># Define processor and model</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>processor = ClvpProcessor.from_pretrained(<span class="hljs-string">&quot;susnato/clvp_dev&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>model = ClvpModelForConditionalGeneration.from_pretrained(<span class="hljs-string">&quot;susnato/clvp_dev&quot;</span>)

<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-comment"># Generate processor output and text embeds</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>processor_output = processor(text=text, return_tensors=<span class="hljs-string">&quot;pt&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>text_embeds = model.get_text_features(input_ids=processor_output[<span class="hljs-string">&quot;input_ids&quot;</span>])`,wrap:!1}}),{c(){r=l("p"),r.textContent=C,p=n(),f(m.$$.fragment)},l(o){r=d(o,"P",{"data-svelte-h":!0}),b(r)!=="svelte-kvfsh7"&&(r.textContent=C),p=s(o),u(m.$$.fragment,o)},m(o,T){c(o,r,T),c(o,p,T),h(m,o,T),y=!0},p:q,i(o){y||(g(m.$$.fragment,o),y=!0)},o(o){_(m.$$.fragment,o),y=!1},d(o){o&&(a(r),a(p)),v(m,o)}}}function ga(w){let r,C="Examples:",p,m,y;return m=new Ce({props:{code:"aW1wb3J0JTIwZGF0YXNldHMlMEFmcm9tJTIwdHJhbnNmb3JtZXJzJTIwaW1wb3J0JTIwQ2x2cFByb2Nlc3NvciUyQyUyMENsdnBNb2RlbEZvckNvbmRpdGlvbmFsR2VuZXJhdGlvbiUwQSUwQSUyMyUyMERlZmluZSUyMHRoZSUyMFRleHQlMjBhbmQlMjBMb2FkJTIwdGhlJTIwQXVkaW8lMjAoV2UlMjBhcmUlMjB0YWtpbmclMjBhbiUyMGF1ZGlvJTIwZXhhbXBsZSUyMGZyb20lMjBIdWdnaW5nRmFjZSUyMEh1YiUyMHVzaW5nJTIwJTYwZGF0YXNldHMlNjAlMjBsaWJyYXJ5KSUwQXRleHQlMjAlM0QlMjAlMjJUaGlzJTIwaXMlMjBhbiUyMGV4YW1wbGUlMjB0ZXh0LiUyMiUwQWRzJTIwJTNEJTIwZGF0YXNldHMubG9hZF9kYXRhc2V0KCUyMmhmLWludGVybmFsLXRlc3RpbmclMkZsaWJyaXNwZWVjaF9hc3JfZHVtbXklMjIlMkMlMjAlMjJjbGVhbiUyMiUyQyUyMHNwbGl0JTNEJTIydmFsaWRhdGlvbiUyMiklMEFkcyUyMCUzRCUyMGRzLmNhc3RfY29sdW1uKCUyMmF1ZGlvJTIyJTJDJTIwZGF0YXNldHMuQXVkaW8oc2FtcGxpbmdfcmF0ZSUzRDIyMDUwKSklMEFfJTJDJTIwYXVkaW8lMkMlMjBzciUyMCUzRCUyMGRzLnNvcnQoJTIyaWQlMjIpLnNlbGVjdChyYW5nZSgxKSklNUIlM0ExJTVEJTVCJTIyYXVkaW8lMjIlNUQlNUIwJTVELnZhbHVlcygpJTBBJTBBJTIzJTIwRGVmaW5lJTIwcHJvY2Vzc29yJTIwYW5kJTIwbW9kZWwlMEFwcm9jZXNzb3IlMjAlM0QlMjBDbHZwUHJvY2Vzc29yLmZyb21fcHJldHJhaW5lZCglMjJzdXNuYXRvJTJGY2x2cF9kZXYlMjIpJTBBbW9kZWwlMjAlM0QlMjBDbHZwTW9kZWxGb3JDb25kaXRpb25hbEdlbmVyYXRpb24uZnJvbV9wcmV0cmFpbmVkKCUyMnN1c25hdG8lMkZjbHZwX2RldiUyMiklMEElMEElMjMlMjBHZW5lcmF0ZSUyMHByb2Nlc3NvciUyMG91dHB1dCUyMGFuZCUyMG1vZGVsJTIwb3V0cHV0JTBBcHJvY2Vzc29yX291dHB1dCUyMCUzRCUyMHByb2Nlc3NvcihyYXdfc3BlZWNoJTNEYXVkaW8lMkMlMjBzYW1wbGluZ19yYXRlJTNEc3IlMkMlMjB0ZXh0JTNEdGV4dCUyQyUyMHJldHVybl90ZW5zb3JzJTNEJTIycHQlMjIpJTBBc3BlZWNoX2VtYmVkcyUyMCUzRCUyMG1vZGVsLmdldF9zcGVlY2hfZmVhdHVyZXMoJTBBJTIwJTIwJTIwJTIwaW5wdXRfaWRzJTNEcHJvY2Vzc29yX291dHB1dCU1QiUyMmlucHV0X2lkcyUyMiU1RCUyQyUyMGlucHV0X2ZlYXR1cmVzJTNEcHJvY2Vzc29yX291dHB1dCU1QiUyMmlucHV0X2ZlYXR1cmVzJTIyJTVEJTBBKQ==",highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">import</span> datasets
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> ClvpProcessor, ClvpModelForConditionalGeneration

<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-comment"># Define the Text and Load the Audio (We are taking an audio example from HuggingFace Hub using \`datasets\` library)</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>text = <span class="hljs-string">&quot;This is an example text.&quot;</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>ds = datasets.load_dataset(<span class="hljs-string">&quot;hf-internal-testing/librispeech_asr_dummy&quot;</span>, <span class="hljs-string">&quot;clean&quot;</span>, split=<span class="hljs-string">&quot;validation&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>ds = ds.cast_column(<span class="hljs-string">&quot;audio&quot;</span>, datasets.Audio(sampling_rate=<span class="hljs-number">22050</span>))
<span class="hljs-meta">&gt;&gt;&gt; </span>_, audio, sr = ds.sort(<span class="hljs-string">&quot;id&quot;</span>).select(<span class="hljs-built_in">range</span>(<span class="hljs-number">1</span>))[:<span class="hljs-number">1</span>][<span class="hljs-string">&quot;audio&quot;</span>][<span class="hljs-number">0</span>].values()

<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-comment"># Define processor and model</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>processor = ClvpProcessor.from_pretrained(<span class="hljs-string">&quot;susnato/clvp_dev&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>model = ClvpModelForConditionalGeneration.from_pretrained(<span class="hljs-string">&quot;susnato/clvp_dev&quot;</span>)

<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-comment"># Generate processor output and model output</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>processor_output = processor(raw_speech=audio, sampling_rate=sr, text=text, return_tensors=<span class="hljs-string">&quot;pt&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>speech_embeds = model.get_speech_features(
<span class="hljs-meta">... </span>    input_ids=processor_output[<span class="hljs-string">&quot;input_ids&quot;</span>], input_features=processor_output[<span class="hljs-string">&quot;input_features&quot;</span>]
<span class="hljs-meta">... </span>)`,wrap:!1}}),{c(){r=l("p"),r.textContent=C,p=n(),f(m.$$.fragment)},l(o){r=d(o,"P",{"data-svelte-h":!0}),b(r)!=="svelte-kvfsh7"&&(r.textContent=C),p=s(o),u(m.$$.fragment,o)},m(o,T){c(o,r,T),c(o,p,T),h(m,o,T),y=!0},p:q,i(o){y||(g(m.$$.fragment,o),y=!0)},o(o){_(m.$$.fragment,o),y=!1},d(o){o&&(a(r),a(p)),v(m,o)}}}function _a(w){let r,C=`Although the recipe for forward pass needs to be defined within this function, one should call the <code>Module</code>
instance afterwards instead of this since the former takes care of running the pre and post processing steps while
the latter silently ignores them.`;return{c(){r=l("p"),r.innerHTML=C},l(p){r=d(p,"P",{"data-svelte-h":!0}),b(r)!=="svelte-fincs2"&&(r.innerHTML=C)},m(p,m){c(p,r,m)},p:q,d(p){p&&a(r)}}}function va(w){let r,C=`Although the recipe for forward pass needs to be defined within this function, one should call the <code>Module</code>
instance afterwards instead of this since the former takes care of running the pre and post processing steps while
the latter silently ignores them.`;return{c(){r=l("p"),r.innerHTML=C},l(p){r=d(p,"P",{"data-svelte-h":!0}),b(r)!=="svelte-fincs2"&&(r.innerHTML=C)},m(p,m){c(p,r,m)},p:q,d(p){p&&a(r)}}}function ba(w){let r,C=`Although the recipe for forward pass needs to be defined within this function, one should call the <code>Module</code>
instance afterwards instead of this since the former takes care of running the pre and post processing steps while
the latter silently ignores them.`;return{c(){r=l("p"),r.innerHTML=C},l(p){r=d(p,"P",{"data-svelte-h":!0}),b(r)!=="svelte-fincs2"&&(r.innerHTML=C)},m(p,m){c(p,r,m)},p:q,d(p){p&&a(r)}}}function ya(w){let r,C,p,m,y,o,T,cs='<img alt="PyTorch" src="https://img.shields.io/badge/PyTorch-DE3412?style=flat&amp;logo=pytorch&amp;logoColor=white"/>',_o,Te,vo,Me,ps='The CLVP (Contrastive Language-Voice Pretrained Transformer) model was proposed in <a href="https://arxiv.org/abs/2305.07243" rel="nofollow">Better speech synthesis through scaling</a> by James Betker.',bo,ke,ms="The abstract from the paper is the following:",yo,we,fs="<em>In recent years, the field of image generation has been revolutionized by the application of autoregressive transformers and DDPMs. These approaches model the process of image generation as a step-wise probabilistic processes and leverage large amounts of compute and data to learn the image distribution. This methodology of improving performance need not be confined to images. This paper describes a way to apply advances in the image generative domain to speech synthesis. The result is TorToise - an expressive, multi-voice text-to-speech system.</em>",Co,xe,us=`This model was contributed by <a href="https://huggingface.co/susnato" rel="nofollow">Susnato Dhar</a>.
The original code can be found <a href="https://github.com/neonbjb/tortoise-tts" rel="nofollow">here</a>.`,To,$e,Mo,je,hs="<li>CLVP is an integral part of the Tortoise TTS model.</li> <li>CLVP can be used to compare different generated speech candidates with the provided text, and the best speech tokens are forwarded to the diffusion model.</li> <li>The use of the <code>ClvpModelForConditionalGeneration.generate()</code> method is strongly recommended for tortoise usage.</li> <li>Note that the CLVP model expects the audio to be sampled at 22.05 kHz contrary to other audio models which expects 16 kHz.</li>",ko,Je,wo,ze,gs='<li>The <a href="/docs/transformers/main/en/model_doc/clvp#transformers.ClvpTokenizer">ClvpTokenizer</a> tokenizes the text input, and the <a href="/docs/transformers/main/en/model_doc/clvp#transformers.ClvpFeatureExtractor">ClvpFeatureExtractor</a> extracts the log mel-spectrogram from the desired audio.</li> <li><code>ClvpConditioningEncoder</code> takes those text tokens and audio representations and converts them into embeddings conditioned on the text and audio.</li> <li>The <a href="/docs/transformers/main/en/model_doc/clvp#transformers.ClvpForCausalLM">ClvpForCausalLM</a> uses those embeddings to generate multiple speech candidates.</li> <li>Each speech candidate is passed through the speech encoder (<a href="/docs/transformers/main/en/model_doc/clvp#transformers.ClvpEncoder">ClvpEncoder</a>) which converts them into a vector representation, and the text encoder (<a href="/docs/transformers/main/en/model_doc/clvp#transformers.ClvpEncoder">ClvpEncoder</a>) converts the text tokens into the same latent space.</li> <li>At the end, we compare each speech vector with the text vector to see which speech vector is most similar to the text vector.</li> <li><code>ClvpModelForConditionalGeneration.generate()</code> compresses all of the logic described above into a single method.</li>',xo,Fe,_s="Example :",$o,Ee,jo,Ze,Jo,F,Ie,en,Ct,vs=`<a href="/docs/transformers/main/en/model_doc/clvp#transformers.ClvpConfig">ClvpConfig</a> is the configuration class to store the configuration of a <a href="/docs/transformers/main/en/model_doc/clvp#transformers.ClvpModelForConditionalGeneration">ClvpModelForConditionalGeneration</a>. It
is used to instantiate a CLVP model according to the specified arguments, defining the text model, speech model and
decoder model configs. Instantiating a configuration with the defaults will yield a similar configuration to that
of the CLVP <a href="https://huggingface.co/susnato/clvp_dev" rel="nofollow">susnato/clvp_dev</a> architecture.`,tn,Tt,bs=`Configuration objects inherit from <a href="/docs/transformers/main/en/main_classes/configuration#transformers.PretrainedConfig">PretrainedConfig</a> and can be used to control the model outputs. Read the
documentation from <a href="/docs/transformers/main/en/main_classes/configuration#transformers.PretrainedConfig">PretrainedConfig</a> for more information.`,on,te,nn,oe,Ue,sn,Mt,ys=`Instantiate a <a href="/docs/transformers/main/en/model_doc/clvp#transformers.ClvpConfig">ClvpConfig</a> (or a derived class) from CLVP text model configuration, CLVP speech model
configuration and CLVP decoder model configuration.`,zo,We,Fo,G,Ge,an,kt,Cs=`This is the configuration class to store the configuration of a <a href="/docs/transformers/main/en/model_doc/clvp#transformers.ClvpEncoder">ClvpEncoder</a>. It is used to instantiate a CLVP
text or CLVP speech encoder according to the specified arguments. Instantiating a configuration with the defaults
will yield a similar configuration to that of the encoder of the CLVP
<a href="https://huggingface.co/susnato/clvp_dev" rel="nofollow">susnato/clvp_dev</a> architecture.`,rn,wt,Ts=`Configuration objects inherit from <a href="/docs/transformers/main/en/main_classes/configuration#transformers.PretrainedConfig">PretrainedConfig</a> and can be used to control the model outputs. Read the
documentation from <a href="/docs/transformers/main/en/main_classes/configuration#transformers.PretrainedConfig">PretrainedConfig</a> for more information.`,ln,ne,Eo,Be,Zo,E,Ne,dn,xt,Ms=`This is the configuration class to store the configuration of a <a href="/docs/transformers/main/en/model_doc/clvp#transformers.ClvpDecoder">ClvpDecoder</a>. It is used to instantiate a CLVP
Decoder Model according to the specified arguments, defining the model architecture. Instantiating a configuration
with the defaults will yield a similar configuration to that of the Decoder part of the CLVP
<a href="https://huggingface.co/susnato/clvp_dev" rel="nofollow">susnato/clvp_dev</a> architecture.`,cn,$t,ks=`Configuration objects inherit from <a href="/docs/transformers/main/en/main_classes/configuration#transformers.PretrainedConfig">PretrainedConfig</a> and can be used to control the model outputs. Read the
documentation from <a href="/docs/transformers/main/en/main_classes/configuration#transformers.PretrainedConfig">PretrainedConfig</a> for more information.`,pn,jt,ws="The architecture is similar to GPT2.",mn,se,Io,Le,Uo,$,Ve,fn,Jt,xs="Construct a CLVP tokenizer. Based on byte-level Byte-Pair-Encoding.",un,zt,$s="This tokenizer has been trained to treat spaces like parts of the tokens (a bit like sentencepiece) so a word will",hn,ae,gn,Ft,js=`You can get around that behavior by passing <code>add_prefix_space=True</code> when instantiating this tokenizer or when you
call it on some text, but since the model was not pretrained this way, it might yield a decrease in performance.`,_n,re,vn,Et,Js=`This tokenizer inherits from <a href="/docs/transformers/main/en/main_classes/tokenizer#transformers.PreTrainedTokenizer">PreTrainedTokenizer</a> which contains most of the main methods. Users should refer to
this superclass for more information regarding those methods.`,bn,Zt,He,Wo,De,Go,Z,qe,yn,It,zs="Constructs a CLVP feature extractor.",Cn,Ut,Fs=`This feature extractor inherits from <a href="/docs/transformers/main/en/main_classes/feature_extractor#transformers.SequenceFeatureExtractor">SequenceFeatureExtractor</a> which contains
most of the main methods. Users should refer to this superclass for more information regarding those methods.`,Tn,Wt,Es="This class extracts log-mel-spectrogram features from raw speech using a custom numpy implementation of the <code>Short Time Fourier Transform</code> which should match pytorch’s <code>torch.stft</code> equivalent.",Mn,Y,Pe,kn,Gt,Zs=`<code>ClvpFeatureExtractor</code> is used to extract various voice specific properties such as the pitch and tone of the
voice, speaking speed, and even speaking defects like a lisp or stuttering from a sample voice or <code>raw_speech</code>.`,wn,Bt,Is=`First the voice is padded or truncated in a way such that it becomes a waveform of <code>self.default_audio_length</code>
seconds long and then the log-mel spectrogram is extracted from it.`,Bo,Xe,No,z,Re,xn,Nt,Us="Constructs a CLVP processor which wraps a CLVP Feature Extractor and a CLVP Tokenizer into a single processor.",$n,Lt,Ws=`<a href="/docs/transformers/main/en/model_doc/clvp#transformers.ClvpProcessor">ClvpProcessor</a> offers all the functionalities of <a href="/docs/transformers/main/en/model_doc/clvp#transformers.ClvpFeatureExtractor">ClvpFeatureExtractor</a> and <a href="/docs/transformers/main/en/model_doc/clvp#transformers.ClvpTokenizer">ClvpTokenizer</a>. See the
<a href="/docs/transformers/main/en/model_doc/clvp#transformers.ClvpProcessor.__call__"><strong>call</strong>()</a>, <a href="/docs/transformers/main/en/model_doc/clvp#transformers.ClvpProcessor.decode">decode()</a> and <a href="/docs/transformers/main/en/model_doc/clvp#transformers.ClvpProcessor.batch_decode">batch_decode()</a> for more information.`,jn,ie,Ye,Jn,Vt,Gs=`Forwards the <code>audio</code> and <code>sampling_rate</code> arguments to <a href="/docs/transformers/main/en/model_doc/clvp#transformers.ClvpFeatureExtractor.__call__"><strong>call</strong>()</a> and the <code>text</code>
argument to <a href="/docs/transformers/main/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__"><strong>call</strong>()</a>. Please refer to the doctsring of the above two methods for more
information.`,zn,le,Qe,Fn,Ht,Bs=`This method forwards all its arguments to ClvpTokenizer’s <a href="/docs/transformers/main/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.decode">decode()</a>. Please refer to
the docstring of this method for more information.`,En,de,Se,Zn,Dt,Ns=`This method forwards all its arguments to ClvpTokenizer’s <a href="/docs/transformers/main/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.batch_decode">batch_decode()</a>. Please
refer to the docstring of this method for more information.`,Lo,Oe,Vo,j,Ae,In,qt,Ls=`The composite CLVP model with a text encoder, speech encoder and speech decoder model.The speech decoder model generates the speech_ids from the text and the text encoder and speech encoder workstogether to filter out the best speech_ids.
This model inherits from <a href="/docs/transformers/main/en/main_classes/model#transformers.PreTrainedModel">PreTrainedModel</a>. Check the superclass documentation for the generic methods the
library implements for all its model (such as downloading or saving, resizing the input embeddings, pruning heads
etc.)`,Un,Pt,Vs=`This model is also a PyTorch <a href="https://pytorch.org/docs/stable/nn.html#torch.nn.Module" rel="nofollow">torch.nn.Module</a> subclass.
Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
and behavior.`,Wn,D,Ke,Gn,Xt,Hs='The <a href="/docs/transformers/main/en/model_doc/clvp#transformers.ClvpModelForConditionalGeneration">ClvpModelForConditionalGeneration</a> forward method, overrides the <code>__call__</code> special method.',Bn,ce,Nn,pe,Ln,me,et,Vn,Rt,Ds=`Generate method for <code>ClvpModelForConditionalGeneration</code>, this method calls the <code>generate</code> method of
<code>ClvpForCausalLM</code> and then uses those generated <code>speech_ids</code> to process <code>text_embeds</code> and <code>speech_embeds</code> using
<code>ClvpEncoder</code>.`,Hn,Q,tt,Dn,Yt,qs=`This method can be used to extract text_embeds from a text. The text embeddings obtained by applying the
projection layer to the pooled output of the CLVP text encoder model.`,qn,fe,Pn,S,ot,Xn,Qt,Ps=`This method can be used to extract speech_embeds. The speech embeddings are obtained by applying the speech
model on speech_ids. If speech_ids is not present but both input_ids and input_features are given then the
decoder model will be used to first generate the speech_ids and then applying the speech model.`,Rn,ue,Ho,nt,Do,B,st,Yn,St,Xs=`The CLVP decoder model with a language modelling head on top.
This model inherits from <a href="/docs/transformers/main/en/main_classes/model#transformers.PreTrainedModel">PreTrainedModel</a>. Check the superclass documentation for the generic methods the
library implements for all its model (such as downloading or saving, resizing the input embeddings, pruning heads
etc.)`,Qn,Ot,Rs=`This model is also a PyTorch <a href="https://pytorch.org/docs/stable/nn.html#torch.nn.Module" rel="nofollow">torch.nn.Module</a> subclass.
Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
and behavior.`,Sn,O,at,On,At,Ys='The <a href="/docs/transformers/main/en/model_doc/clvp#transformers.ClvpForCausalLM">ClvpForCausalLM</a> forward method, overrides the <code>__call__</code> special method.',An,he,qo,rt,Po,N,it,Kn,Kt,Qs=`The bare Clvp decoder model outputting raw hidden-states without any specific head on top.
This model inherits from <a href="/docs/transformers/main/en/main_classes/model#transformers.PreTrainedModel">PreTrainedModel</a>. Check the superclass documentation for the generic methods the
library implements for all its model (such as downloading or saving, resizing the input embeddings, pruning heads
etc.)`,es,eo,Ss=`This model is also a PyTorch <a href="https://pytorch.org/docs/stable/nn.html#torch.nn.Module" rel="nofollow">torch.nn.Module</a> subclass.
Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
and behavior.`,ts,A,lt,os,to,Os='The <a href="/docs/transformers/main/en/model_doc/clvp#transformers.ClvpModel">ClvpModel</a> forward method, overrides the <code>__call__</code> special method.',ns,ge,Xo,dt,Ro,P,ct,ss,oo,As=`Transformer encoder consisting of <code>config.num_hidden_layers</code> self attention layers. Each layer is a
<code>ClvpEncoderLayer</code>.`,as,no,pt,Yo,mt,Qo,X,ft,rs,so,Ks="Transformer decoder consisting of <em>config.num_hidden_layers</em> layers. Each layer is a <code>ClvpDecoderLayer</code>",is,K,ut,ls,ao,ea='The <a href="/docs/transformers/main/en/model_doc/clvp#transformers.ClvpDecoder">ClvpDecoder</a> forward method, overrides the <code>__call__</code> special method.',ds,_e,So,ht,Oo,uo,Ao;return y=new U({props:{title:"CLVP",local:"clvp",headingTag:"h1"}}),Te=new U({props:{title:"Overview",local:"overview",headingTag:"h2"}}),$e=new U({props:{title:"Usage tips",local:"usage-tips",headingTag:"h2"}}),Je=new U({props:{title:"Brief Explanation:",local:"brief-explanation",headingTag:"h2"}}),Ee=new Ce({props:{code:"aW1wb3J0JTIwZGF0YXNldHMlMEFmcm9tJTIwdHJhbnNmb3JtZXJzJTIwaW1wb3J0JTIwQ2x2cFByb2Nlc3NvciUyQyUyMENsdnBNb2RlbEZvckNvbmRpdGlvbmFsR2VuZXJhdGlvbiUwQSUwQSUyMyUyMERlZmluZSUyMHRoZSUyMFRleHQlMjBhbmQlMjBMb2FkJTIwdGhlJTIwQXVkaW8lMjAoV2UlMjBhcmUlMjB0YWtpbmclMjBhbiUyMGF1ZGlvJTIwZXhhbXBsZSUyMGZyb20lMjBIdWdnaW5nRmFjZSUyMEh1YiUyMHVzaW5nJTIwJTYwZGF0YXNldHMlNjAlMjBsaWJyYXJ5KS4lMEF0ZXh0JTIwJTNEJTIwJTIyVGhpcyUyMGlzJTIwYW4lMjBleGFtcGxlJTIwdGV4dC4lMjIlMEElMEFkcyUyMCUzRCUyMGRhdGFzZXRzLmxvYWRfZGF0YXNldCglMjJoZi1pbnRlcm5hbC10ZXN0aW5nJTJGbGlicmlzcGVlY2hfYXNyX2R1bW15JTIyJTJDJTIwJTIyY2xlYW4lMjIlMkMlMjBzcGxpdCUzRCUyMnZhbGlkYXRpb24lMjIpJTBBZHMlMjAlM0QlMjBkcy5jYXN0X2NvbHVtbiglMjJhdWRpbyUyMiUyQyUyMGRhdGFzZXRzLkF1ZGlvKHNhbXBsaW5nX3JhdGUlM0QyMjA1MCkpJTBBc2FtcGxlJTIwJTNEJTIwZHMlNUIwJTVEJTVCJTIyYXVkaW8lMjIlNUQlMEElMEElMjMlMjBEZWZpbmUlMjBwcm9jZXNzb3IlMjBhbmQlMjBtb2RlbC4lMEFwcm9jZXNzb3IlMjAlM0QlMjBDbHZwUHJvY2Vzc29yLmZyb21fcHJldHJhaW5lZCglMjJzdXNuYXRvJTJGY2x2cF9kZXYlMjIpJTBBbW9kZWwlMjAlM0QlMjBDbHZwTW9kZWxGb3JDb25kaXRpb25hbEdlbmVyYXRpb24uZnJvbV9wcmV0cmFpbmVkKCUyMnN1c25hdG8lMkZjbHZwX2RldiUyMiklMEElMEElMjMlMjBHZW5lcmF0ZSUyMHByb2Nlc3NvciUyMG91dHB1dCUyMGFuZCUyMG1vZGVsJTIwb3V0cHV0LiUwQXByb2Nlc3Nvcl9vdXRwdXQlMjAlM0QlMjBwcm9jZXNzb3IocmF3X3NwZWVjaCUzRHNhbXBsZSU1QiUyMmFycmF5JTIyJTVEJTJDJTIwc2FtcGxpbmdfcmF0ZSUzRHNhbXBsZSU1QiUyMnNhbXBsaW5nX3JhdGUlMjIlNUQlMkMlMjB0ZXh0JTNEdGV4dCUyQyUyMHJldHVybl90ZW5zb3JzJTNEJTIycHQlMjIpJTBBZ2VuZXJhdGVkX291dHB1dCUyMCUzRCUyMG1vZGVsLmdlbmVyYXRlKCoqcHJvY2Vzc29yX291dHB1dCk=",highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">import</span> datasets
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> ClvpProcessor, ClvpModelForConditionalGeneration

<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-comment"># Define the Text and Load the Audio (We are taking an audio example from HuggingFace Hub using \`datasets\` library).</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>text = <span class="hljs-string">&quot;This is an example text.&quot;</span>

<span class="hljs-meta">&gt;&gt;&gt; </span>ds = datasets.load_dataset(<span class="hljs-string">&quot;hf-internal-testing/librispeech_asr_dummy&quot;</span>, <span class="hljs-string">&quot;clean&quot;</span>, split=<span class="hljs-string">&quot;validation&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>ds = ds.cast_column(<span class="hljs-string">&quot;audio&quot;</span>, datasets.Audio(sampling_rate=<span class="hljs-number">22050</span>))
<span class="hljs-meta">&gt;&gt;&gt; </span>sample = ds[<span class="hljs-number">0</span>][<span class="hljs-string">&quot;audio&quot;</span>]

<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-comment"># Define processor and model.</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>processor = ClvpProcessor.from_pretrained(<span class="hljs-string">&quot;susnato/clvp_dev&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>model = ClvpModelForConditionalGeneration.from_pretrained(<span class="hljs-string">&quot;susnato/clvp_dev&quot;</span>)

<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-comment"># Generate processor output and model output.</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>processor_output = processor(raw_speech=sample[<span class="hljs-string">&quot;array&quot;</span>], sampling_rate=sample[<span class="hljs-string">&quot;sampling_rate&quot;</span>], text=text, return_tensors=<span class="hljs-string">&quot;pt&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>generated_output = model.generate(**processor_output)`,wrap:!1}}),Ze=new U({props:{title:"ClvpConfig",local:"transformers.ClvpConfig",headingTag:"h2"}}),Ie=new x({props:{name:"class transformers.ClvpConfig",anchor:"transformers.ClvpConfig",parameters:[{name:"text_config",val:" = None"},{name:"speech_config",val:" = None"},{name:"decoder_config",val:" = None"},{name:"projection_dim",val:" = 768"},{name:"logit_scale_init_value",val:" = 2.6592"},{name:"initializer_factor",val:" = 1.0"},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"transformers.ClvpConfig.text_config",description:`<strong>text_config</strong> (<code>dict</code>, <em>optional</em>) &#x2014;
Dictionary of configuration options used to initialize the CLVP text encoder.`,name:"text_config"},{anchor:"transformers.ClvpConfig.speech_config",description:`<strong>speech_config</strong> (<code>dict</code>, <em>optional</em>) &#x2014;
Dictionary of configuration options used to initialize CLVP speech encoder.`,name:"speech_config"},{anchor:"transformers.ClvpConfig.decoder_config",description:`<strong>decoder_config</strong> (<code>dict</code>, <em>optional</em>) &#x2014;
Dictionary of configuration options used to initialize <a href="/docs/transformers/main/en/model_doc/clvp#transformers.ClvpDecoderConfig">ClvpDecoderConfig</a>.`,name:"decoder_config"},{anchor:"transformers.ClvpConfig.projection_dim",description:`<strong>projection_dim</strong> (<code>int</code>, <em>optional</em>, defaults to 768) &#x2014;
Dimensionality of text and speech projection layers.`,name:"projection_dim"},{anchor:"transformers.ClvpConfig.logit_scale_init_value",description:`<strong>logit_scale_init_value</strong> (<code>float</code>, <em>optional</em>, defaults to 2.6592) &#x2014;
The initial value of the <em>logit_scale</em> parameter. Default is used as per the original CLVP implementation.`,name:"logit_scale_init_value"},{anchor:"transformers.ClvpConfig.initializer_factor",description:`<strong>initializer_factor</strong> (<code>float</code>, <em>optional</em>, defaults to 1.0) &#x2014;
A factor for initializing all weight matrices (should be kept to 1.0, used internally for initialization
testing).`,name:"initializer_factor"},{anchor:"transformers.ClvpConfig.kwargs",description:`<strong>kwargs</strong> (<em>optional</em>) &#x2014;
Dictionary of keyword arguments.`,name:"kwargs"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/configuration_clvp.py#L320"}}),te=new yt({props:{anchor:"transformers.ClvpConfig.example",$$slots:{default:[la]},$$scope:{ctx:w}}}),Ue=new x({props:{name:"from_sub_model_configs",anchor:"transformers.ClvpConfig.from_sub_model_configs",parameters:[{name:"text_config",val:": ClvpEncoderConfig"},{name:"speech_config",val:": ClvpEncoderConfig"},{name:"decoder_config",val:": ClvpDecoderConfig"},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"transformers.ClvpConfig.from_sub_model_configs.text_config",description:`<strong>text_config</strong> (<code>ClvpEncoderConfig</code>) &#x2014;
Text model configuration of type <a href="/docs/transformers/main/en/model_doc/clvp#transformers.ClvpEncoderConfig">ClvpEncoderConfig</a>.`,name:"text_config"},{anchor:"transformers.ClvpConfig.from_sub_model_configs.speech_config",description:`<strong>speech_config</strong> (<code>ClvpEncoderConfig</code>) &#x2014;
Speech model configuration of type <a href="/docs/transformers/main/en/model_doc/clvp#transformers.ClvpEncoderConfig">ClvpEncoderConfig</a>.`,name:"speech_config"},{anchor:"transformers.ClvpConfig.from_sub_model_configs.decoder_config",description:`<strong>decoder_config</strong> (<code>ClvpDecoderConfig</code>) &#x2014;
Decoder model configuration of type <a href="/docs/transformers/main/en/model_doc/clvp#transformers.ClvpDecoderConfig">ClvpDecoderConfig</a>.`,name:"decoder_config"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/configuration_clvp.py#L411",returnDescription:`<script context="module">export const metadata = 'undefined';<\/script>


<p>An instance of a configuration object</p>
`,returnType:`<script context="module">export const metadata = 'undefined';<\/script>


<p><a
  href="/docs/transformers/main/en/model_doc/clvp#transformers.ClvpConfig"
>ClvpConfig</a></p>
`}}),We=new U({props:{title:"ClvpEncoderConfig",local:"transformers.ClvpEncoderConfig",headingTag:"h2"}}),Ge=new x({props:{name:"class transformers.ClvpEncoderConfig",anchor:"transformers.ClvpEncoderConfig",parameters:[{name:"vocab_size",val:" = 256"},{name:"hidden_size",val:" = 768"},{name:"intermediate_size",val:" = 1536"},{name:"projection_dim",val:" = 768"},{name:"num_hidden_layers",val:" = 20"},{name:"num_attention_heads",val:" = 12"},{name:"hidden_act",val:" = 'gelu'"},{name:"layer_norm_eps",val:" = 1e-05"},{name:"attention_dropout",val:" = 0.1"},{name:"dropout",val:" = 0.1"},{name:"use_rotary_embedding",val:" = True"},{name:"use_attention_bias",val:" = False"},{name:"summary_type",val:" = 'mean'"},{name:"initializer_factor",val:" = 1.0"},{name:"bos_token_id",val:" = 255"},{name:"eos_token_id",val:" = 0"},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"transformers.ClvpEncoderConfig.vocab_size",description:`<strong>vocab_size</strong> (<code>int</code>, <em>optional</em>, defaults to 256) &#x2014;
Vocabulary size of the CLVP Encoder model.`,name:"vocab_size"},{anchor:"transformers.ClvpEncoderConfig.hidden_size",description:`<strong>hidden_size</strong> (<code>int</code>, <em>optional</em>, defaults to 768) &#x2014;
Dimensionality of the encoder layers and the pooler layer.`,name:"hidden_size"},{anchor:"transformers.ClvpEncoderConfig.intermediate_size",description:`<strong>intermediate_size</strong> (<code>int</code>, <em>optional</em>, defaults to 1536) &#x2014;
Dimensionality of the &#x201C;intermediate&#x201D; (i.e., feed-forward) layer in the Transformer encoder.`,name:"intermediate_size"},{anchor:"transformers.ClvpEncoderConfig.projection_dim",description:`<strong>projection_dim</strong> (<code>int</code>, <em>optional</em>, defaults to 768) &#x2014;
Dimensionality of the projection vector.`,name:"projection_dim"},{anchor:"transformers.ClvpEncoderConfig.num_hidden_layers",description:`<strong>num_hidden_layers</strong> (<code>int</code>, <em>optional</em>, defaults to 20) &#x2014;
Number of hidden layers in the Transformer encoder.`,name:"num_hidden_layers"},{anchor:"transformers.ClvpEncoderConfig.num_attention_heads",description:`<strong>num_attention_heads</strong> (<code>int</code>, <em>optional</em>, defaults to 12) &#x2014;
Number of attention heads for each attention layer in the Transformer encoder.`,name:"num_attention_heads"},{anchor:"transformers.ClvpEncoderConfig.hidden_act",description:`<strong>hidden_act</strong> (<code>str</code> or <code>function</code>, <em>optional</em>, defaults to <code>&quot;gelu&quot;</code>) &#x2014;
The non-linear activation function (function or string) in the encoder and pooler. If string, <code>&quot;gelu&quot;</code>,
<code>&quot;relu&quot;</code>, <code>&quot;selu&quot;</code> and <code>&quot;gelu_new&quot;</code> <code>&quot;quick_gelu&quot;</code> are supported.`,name:"hidden_act"},{anchor:"transformers.ClvpEncoderConfig.layer_norm_eps",description:`<strong>layer_norm_eps</strong> (<code>float</code>, <em>optional</em>, defaults to 1e-05) &#x2014;
The epsilon used by the layer normalization layers.`,name:"layer_norm_eps"},{anchor:"transformers.ClvpEncoderConfig.attention_dropout",description:`<strong>attention_dropout</strong> (<code>float</code>, <em>optional</em>, defaults to 0.1) &#x2014;
The dropout ratio for the attention probabilities.`,name:"attention_dropout"},{anchor:"transformers.ClvpEncoderConfig.dropout",description:`<strong>dropout</strong> (<code>float</code>, <em>optional</em>, defaults to 0.1) &#x2014;
The dropout ratio for the feed-forward layers in <code>ClvpEncoderMLP</code>.`,name:"dropout"},{anchor:"transformers.ClvpEncoderConfig.use_rotary_embedding",description:`<strong>use_rotary_embedding</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>True</code>) &#x2014;
Whether to use rotary_embedding or not.`,name:"use_rotary_embedding"},{anchor:"transformers.ClvpEncoderConfig.use_attention_bias",description:`<strong>use_attention_bias</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>False</code>) &#x2014;
Whether to use bias in Query, Key and Value layers during self attention.`,name:"use_attention_bias"},{anchor:"transformers.ClvpEncoderConfig.summary_type",description:`<strong>summary_type</strong> (<code>str</code>, <em>optional</em>, defaults to <code>&quot;mean&quot;</code>) &#x2014;
What strategy to use to get pooler_output from the last_hidden_state. <code>&quot;last&quot;</code>, <code>&quot;first&quot;</code>, <code>&quot;mean&quot;</code> and
<code>&quot;cls_index&quot;</code> are supported.`,name:"summary_type"},{anchor:"transformers.ClvpEncoderConfig.initializer_factor",description:`<strong>initializer_factor</strong> (<code>float</code>, <em>optional</em>, defaults to 1.0) &#x2014;
A factor for initializing all weight matrices (should be kept to 1.0, used internally for initialization
testing).`,name:"initializer_factor"},{anchor:"transformers.ClvpEncoderConfig.bos_token_id",description:`<strong>bos_token_id</strong> (<code>int</code>, <em>optional</em>, defaults to 255) &#x2014;
Beginning of sequence token id.`,name:"bos_token_id"},{anchor:"transformers.ClvpEncoderConfig.eos_token_id",description:`<strong>eos_token_id</strong> (<code>int</code>, <em>optional</em>, defaults to 0) &#x2014;
End of sequence token id.`,name:"eos_token_id"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/configuration_clvp.py#L31"}}),ne=new yt({props:{anchor:"transformers.ClvpEncoderConfig.example",$$slots:{default:[da]},$$scope:{ctx:w}}}),Be=new U({props:{title:"ClvpDecoderConfig",local:"transformers.ClvpDecoderConfig",headingTag:"h2"}}),Ne=new x({props:{name:"class transformers.ClvpDecoderConfig",anchor:"transformers.ClvpDecoderConfig",parameters:[{name:"vocab_size",val:" = 8194"},{name:"max_position_embeddings",val:" = 608"},{name:"max_text_tokens",val:" = 404"},{name:"hidden_size",val:" = 1024"},{name:"num_hidden_layers",val:" = 30"},{name:"num_attention_heads",val:" = 16"},{name:"n_inner",val:" = None"},{name:"num_mel_attn_blocks",val:" = 6"},{name:"activation_function",val:" = 'gelu_new'"},{name:"resid_pdrop",val:" = 0.1"},{name:"embd_pdrop",val:" = 0.1"},{name:"attention_dropout",val:" = 0.1"},{name:"layer_norm_epsilon",val:" = 1e-05"},{name:"initializer_range",val:" = 0.02"},{name:"summary_type",val:" = 'cls_index'"},{name:"summary_use_proj",val:" = True"},{name:"summary_activation",val:" = None"},{name:"summary_proj_to_labels",val:" = True"},{name:"summary_first_dropout",val:" = 0.1"},{name:"use_cache",val:" = True"},{name:"bos_token_id",val:" = 8192"},{name:"eos_token_id",val:" = 8193"},{name:"feature_size",val:" = 80"},{name:"use_attention_bias",val:" = True"},{name:"initializer_factor",val:" = 1.0"},{name:"decoder_fixing_codes",val:" = [83, 45, 45, 248]"},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"transformers.ClvpDecoderConfig.vocab_size",description:`<strong>vocab_size</strong> (<code>int</code>, <em>optional</em>, defaults to 8194) &#x2014;
Vocabulary size of the model.`,name:"vocab_size"},{anchor:"transformers.ClvpDecoderConfig.max_position_embeddings",description:`<strong>max_position_embeddings</strong> (<code>int</code>, <em>optional</em>, defaults to 608) &#x2014;
The maximum sequence length of mel tokens that this model might ever be used with. Similar to <code>n_positions</code>
in <code>GPT2Config</code>.`,name:"max_position_embeddings"},{anchor:"transformers.ClvpDecoderConfig.max_text_tokens",description:`<strong>max_text_tokens</strong> (<code>int</code>, <em>optional</em>, defaults to 404) &#x2014;
The maximum sequence length of text tokens that this model might ever be used with. Similar to
<code>n_positions</code> in <code>GPT2Config</code>.`,name:"max_text_tokens"},{anchor:"transformers.ClvpDecoderConfig.hidden_size",description:`<strong>hidden_size</strong> (<code>int</code>, <em>optional</em>, defaults to 1024) &#x2014;
Dimensionality of the embeddings and hidden states.`,name:"hidden_size"},{anchor:"transformers.ClvpDecoderConfig.num_hidden_layers",description:`<strong>num_hidden_layers</strong> (<code>int</code>, <em>optional</em>, defaults to 30) &#x2014;
Number of hidden layers in the Transformer encoder.`,name:"num_hidden_layers"},{anchor:"transformers.ClvpDecoderConfig.num_attention_heads",description:`<strong>num_attention_heads</strong> (<code>int</code>, <em>optional</em>, defaults to 16) &#x2014;
Number of attention heads for each attention layer in the Transformer encoder.`,name:"num_attention_heads"},{anchor:"transformers.ClvpDecoderConfig.n_inner",description:`<strong>n_inner</strong> (<code>int</code>, <em>optional</em>) &#x2014;
Dimensionality of the inner feed-forward layers. <code>None</code> will set it to 4 times <code>hidden_size</code>.`,name:"n_inner"},{anchor:"transformers.ClvpDecoderConfig.num_mel_attn_blocks",description:`<strong>num_mel_attn_blocks</strong> (<code>int</code>, <em>optional</em>, defaults to 6) &#x2014;
Denotes the number of self attention layers in <code>ClvpConditioningEncoder</code>.`,name:"num_mel_attn_blocks"},{anchor:"transformers.ClvpDecoderConfig.activation_function",description:`<strong>activation_function</strong> (<code>str</code>, <em>optional</em>, defaults to <code>&quot;gelu_new&quot;</code>) &#x2014;
Activation function, to be selected in the list <code>[&quot;relu&quot;, &quot;silu&quot;, &quot;gelu&quot;, &quot;tanh&quot;, &quot;gelu_new&quot;]</code>.`,name:"activation_function"},{anchor:"transformers.ClvpDecoderConfig.resid_pdrop",description:`<strong>resid_pdrop</strong> (<code>float</code>, <em>optional</em>, defaults to 0.1) &#x2014;
The dropout probability for all fully connected layers in the embeddings, encoder, and pooler.`,name:"resid_pdrop"},{anchor:"transformers.ClvpDecoderConfig.embd_pdrop",description:`<strong>embd_pdrop</strong> (<code>float</code>, <em>optional</em>, defaults to 0.1) &#x2014;
The dropout ratio for the embeddings.`,name:"embd_pdrop"},{anchor:"transformers.ClvpDecoderConfig.attention_dropout",description:`<strong>attention_dropout</strong> (<code>float</code>, <em>optional</em>, defaults to 0.1) &#x2014;
The dropout ratio for the attention.`,name:"attention_dropout"},{anchor:"transformers.ClvpDecoderConfig.layer_norm_epsilon",description:`<strong>layer_norm_epsilon</strong> (<code>float</code>, <em>optional</em>, defaults to 1e-05) &#x2014;
The epsilon to use in the layer normalization layers.`,name:"layer_norm_epsilon"},{anchor:"transformers.ClvpDecoderConfig.initializer_range",description:`<strong>initializer_range</strong> (<code>float</code>, <em>optional</em>, defaults to 0.02) &#x2014;
The standard deviation of the truncated_normal_initializer for initializing all weight matrices.`,name:"initializer_range"},{anchor:"transformers.ClvpDecoderConfig.summary_type",description:`<strong>summary_type</strong> (<code>string</code>, <em>optional</em>, defaults to <code>&quot;cls_index&quot;</code>) &#x2014;
Argument used when doing sequence summary.</p>
<p>Has to be one of the following options:</p>
<ul>
<li><code>&quot;last&quot;</code>: Take the last token hidden state (like XLNet).</li>
<li><code>&quot;first&quot;</code>: Take the first token hidden state (like BERT).</li>
<li><code>&quot;mean&quot;</code>: Take the mean of all tokens hidden states.</li>
<li><code>&quot;cls_index&quot;</code>: Supply a Tensor of classification token position (like GPT/GPT-2).</li>
<li><code>&quot;attn&quot;</code>: Not implemented now, use multi-head attention.</li>
</ul>`,name:"summary_type"},{anchor:"transformers.ClvpDecoderConfig.summary_use_proj",description:`<strong>summary_use_proj</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>True</code>) &#x2014;
Whether or not to add a projection after the vector extraction.`,name:"summary_use_proj"},{anchor:"transformers.ClvpDecoderConfig.summary_activation",description:`<strong>summary_activation</strong> (<code>str</code>, <em>optional</em>) &#x2014;
Pass <code>&quot;tanh&quot;</code> for a tanh activation to the output, any other value will result in no activation.`,name:"summary_activation"},{anchor:"transformers.ClvpDecoderConfig.summary_proj_to_labels",description:`<strong>summary_proj_to_labels</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>True</code>) &#x2014;
Whether the projection outputs should have <code>config.num_labels</code> or <code>config.hidden_size</code> classes.`,name:"summary_proj_to_labels"},{anchor:"transformers.ClvpDecoderConfig.summary_first_dropout",description:`<strong>summary_first_dropout</strong> (<code>float</code>, <em>optional</em>, defaults to 0.1) &#x2014;
The dropout ratio to be used after the projection and activation.`,name:"summary_first_dropout"},{anchor:"transformers.ClvpDecoderConfig.use_cache",description:`<strong>use_cache</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>True</code>) &#x2014;
Whether or not the model should return the last key/values attentions (not used by all models).`,name:"use_cache"},{anchor:"transformers.ClvpDecoderConfig.bos_token_id",description:`<strong>bos_token_id</strong> (<code>int</code>, <em>optional</em>, defaults to 8192) &#x2014;
Beginning of sequence token id, used at the start of the generation.`,name:"bos_token_id"},{anchor:"transformers.ClvpDecoderConfig.eos_token_id",description:`<strong>eos_token_id</strong> (<code>int</code>, <em>optional</em>, defaults to 8193) &#x2014;
End of sequence token id, used in the method
<code>ClvpModelForConditionalGeneration.fix_speech_decoder_output()</code> to correct decoder outputs.`,name:"eos_token_id"},{anchor:"transformers.ClvpDecoderConfig.feature_size",description:`<strong>feature_size</strong> (<code>int</code>, <em>optional</em>, defaults to 80) &#x2014;
The feature dimension of the extracted mel features. This value is used in <code>ClvpConditioningEncoder</code>.`,name:"feature_size"},{anchor:"transformers.ClvpDecoderConfig.use_attention_bias",description:`<strong>use_attention_bias</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>True</code>) &#x2014;
Whether to use bias in Query, Key and Value layers during self attention.`,name:"use_attention_bias"},{anchor:"transformers.ClvpDecoderConfig.initializer_factor",description:`<strong>initializer_factor</strong> (<code>float</code>, <em>optional</em>, defaults to 1.0) &#x2014;
A factor for initializing all weight matrices (should be kept to 1.0, used internally for initialization
testing).`,name:"initializer_factor"},{anchor:"transformers.ClvpDecoderConfig.decoder_fixing_codes",description:`<strong>decoder_fixing_codes</strong> (<code>list</code>, <em>optional</em>, defaults to <code>[83, 45, 45, 248]</code>) &#x2014;
These values are used in the method <code>fix_speech_decoder_output</code> to fix decoder generated outputs.`,name:"decoder_fixing_codes"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/configuration_clvp.py#L163"}}),se=new yt({props:{anchor:"transformers.ClvpDecoderConfig.example",$$slots:{default:[ca]},$$scope:{ctx:w}}}),Le=new U({props:{title:"ClvpTokenizer",local:"transformers.ClvpTokenizer",headingTag:"h2"}}),Ve=new x({props:{name:"class transformers.ClvpTokenizer",anchor:"transformers.ClvpTokenizer",parameters:[{name:"vocab_file",val:""},{name:"merges_file",val:""},{name:"errors",val:" = 'replace'"},{name:"unk_token",val:" = '[UNK]'"},{name:"bos_token",val:" = '<|endoftext|>'"},{name:"eos_token",val:" = '[STOP]'"},{name:"pad_token",val:" = '[STOP]'"},{name:"add_prefix_space",val:" = False"},{name:"add_bos_token",val:" = False"},{name:"add_eos_token",val:" = False"},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"transformers.ClvpTokenizer.vocab_file",description:`<strong>vocab_file</strong> (<code>str</code>) &#x2014;
Path to the vocabulary file.`,name:"vocab_file"},{anchor:"transformers.ClvpTokenizer.merges_file",description:`<strong>merges_file</strong> (<code>str</code>) &#x2014;
Path to the merges file.`,name:"merges_file"},{anchor:"transformers.ClvpTokenizer.errors",description:`<strong>errors</strong> (<code>str</code>, <em>optional</em>, defaults to <code>&quot;replace&quot;</code>) &#x2014;
Paradigm to follow when decoding bytes to UTF-8. See
<a href="https://docs.python.org/3/library/stdtypes.html#bytes.decode" rel="nofollow">bytes.decode</a> for more information.`,name:"errors"},{anchor:"transformers.ClvpTokenizer.unk_token",description:`<strong>unk_token</strong> (<code>str</code>, <em>optional</em>, defaults to <code>&quot;[UNK]&quot;</code>) &#x2014;
The unknown token. A token that is not in the vocabulary cannot be converted to an ID and is set to be this
token instead.`,name:"unk_token"},{anchor:"transformers.ClvpTokenizer.bos_token",description:`<strong>bos_token</strong> (<code>str</code>, <em>optional</em>, defaults to <code>&quot;&lt;|endoftext|&gt;&quot;</code>) &#x2014;
The beginning of sequence token.`,name:"bos_token"},{anchor:"transformers.ClvpTokenizer.eos_token",description:`<strong>eos_token</strong> (<code>str</code>, <em>optional</em>, defaults to <code>&quot;[STOP]&quot;</code>) &#x2014;
The end of sequence token.`,name:"eos_token"},{anchor:"transformers.ClvpTokenizer.pad_token",description:`<strong>pad_token</strong> (<code>str</code>, <em>optional</em>, defaults to <code>&quot;[STOP]&quot;</code>) &#x2014;
The pad token of the sequence.`,name:"pad_token"},{anchor:"transformers.ClvpTokenizer.add_prefix_space",description:`<strong>add_prefix_space</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>False</code>) &#x2014;
Whether or not to add an initial space to the input. This allows to treat the leading word just as any
other word. (CLVP tokenizer detect beginning of words by the preceding space).`,name:"add_prefix_space"},{anchor:"transformers.ClvpTokenizer.add_bos_token",description:`<strong>add_bos_token</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>False</code>) &#x2014;
Whether to add <code>bos_token</code> in front of the sequence when add_special_tokens=True.`,name:"add_bos_token"},{anchor:"transformers.ClvpTokenizer.add_eos_token",description:`<strong>add_eos_token</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>False</code>) &#x2014;
Whether to add <code>eos_token</code> in end of the sequence when add_special_tokens=True.`,name:"add_eos_token"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/tokenization_clvp.py#L78"}}),ae=new yt({props:{anchor:"transformers.ClvpTokenizer.example",$$slots:{default:[pa]},$$scope:{ctx:w}}}),re=new go({props:{$$slots:{default:[ma]},$$scope:{ctx:w}}}),He=new x({props:{name:"save_vocabulary",anchor:"transformers.ClvpTokenizer.save_vocabulary",parameters:[{name:"save_directory",val:": str"},{name:"filename_prefix",val:": typing.Optional[str] = None"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/tokenization_clvp.py#L337"}}),De=new U({props:{title:"ClvpFeatureExtractor",local:"transformers.ClvpFeatureExtractor",headingTag:"h2"}}),qe=new x({props:{name:"class transformers.ClvpFeatureExtractor",anchor:"transformers.ClvpFeatureExtractor",parameters:[{name:"feature_size",val:" = 80"},{name:"sampling_rate",val:" = 22050"},{name:"default_audio_length",val:" = 6"},{name:"hop_length",val:" = 256"},{name:"chunk_length",val:" = 30"},{name:"n_fft",val:" = 1024"},{name:"padding_value",val:" = 0.0"},{name:"mel_norms",val:" = None"},{name:"return_attention_mask",val:" = False"},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"transformers.ClvpFeatureExtractor.feature_size",description:`<strong>feature_size</strong> (<code>int</code>, <em>optional</em>, defaults to 80) &#x2014;
The feature dimension of the extracted features.`,name:"feature_size"},{anchor:"transformers.ClvpFeatureExtractor.sampling_rate",description:`<strong>sampling_rate</strong> (<code>int</code>, <em>optional</em>, defaults to 22050) &#x2014;
The sampling rate at which the audio files should be digitalized expressed in hertz (Hz).`,name:"sampling_rate"},{anchor:"transformers.ClvpFeatureExtractor.default_audio_length",description:`<strong>default_audio_length</strong> (<code>int</code>, <em>optional</em>, defaults to 6) &#x2014;
The default length of raw audio in seconds. If <code>max_length</code> is not set during <code>__call__</code> then it will
automatically be set to default_audio_length * <code>self.sampling_rate</code>.`,name:"default_audio_length"},{anchor:"transformers.ClvpFeatureExtractor.hop_length",description:`<strong>hop_length</strong> (<code>int</code>, <em>optional</em>, defaults to 256) &#x2014;
Length of the overlaping windows for the STFT used to obtain the Mel Frequency coefficients.`,name:"hop_length"},{anchor:"transformers.ClvpFeatureExtractor.chunk_length",description:`<strong>chunk_length</strong> (<code>int</code>, <em>optional</em>, defaults to 30) &#x2014;
The maximum number of chuncks of <code>sampling_rate</code> samples used to trim and pad longer or shorter audio
sequences.`,name:"chunk_length"},{anchor:"transformers.ClvpFeatureExtractor.n_fft",description:`<strong>n_fft</strong> (<code>int</code>, <em>optional</em>, defaults to 1024) &#x2014;
Size of the Fourier transform.`,name:"n_fft"},{anchor:"transformers.ClvpFeatureExtractor.padding_value",description:`<strong>padding_value</strong> (<code>float</code>, <em>optional</em>, defaults to 0.0) &#x2014;
Padding value used to pad the audio. Should correspond to silences.`,name:"padding_value"},{anchor:"transformers.ClvpFeatureExtractor.mel_norms",description:`<strong>mel_norms</strong> (<code>list</code> of length <code>feature_size</code>, <em>optional</em>) &#x2014;
If <code>mel_norms</code> is provided then it will be used to normalize the log-mel spectrograms along each
mel-filter.`,name:"mel_norms"},{anchor:"transformers.ClvpFeatureExtractor.return_attention_mask",description:`<strong>return_attention_mask</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>False</code>) &#x2014;
Whether to return the attention mask. If left to the default, it will return the attention mask.</p>
<p><a href="../glossary#attention-mask">What are attention masks?</a>`,name:"return_attention_mask"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/feature_extraction_clvp.py#L33"}}),Pe=new x({props:{name:"__call__",anchor:"transformers.ClvpFeatureExtractor.__call__",parameters:[{name:"raw_speech",val:": typing.Union[numpy.ndarray, typing.List[float], typing.List[numpy.ndarray], typing.List[typing.List[float]]]"},{name:"sampling_rate",val:": typing.Optional[int] = None"},{name:"truncation",val:": bool = True"},{name:"pad_to_multiple_of",val:": typing.Optional[int] = None"},{name:"return_tensors",val:": typing.Union[str, transformers.utils.generic.TensorType, NoneType] = None"},{name:"return_attention_mask",val:": typing.Optional[bool] = True"},{name:"padding",val:": typing.Optional[str] = 'max_length'"},{name:"max_length",val:": typing.Optional[int] = None"},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"transformers.ClvpFeatureExtractor.__call__.raw_speech",description:`<strong>raw_speech</strong> (<code>np.ndarray</code>, <code>List[float]</code>, <code>List[np.ndarray]</code>, <code>List[List[float]]</code>) &#x2014;
The sequence or batch of sequences to be padded. Each sequence can be a numpy array, a list of float
values, a list of numpy arrays or a list of list of float values. Must be mono channel audio, not
stereo, i.e. single float per timestep.`,name:"raw_speech"},{anchor:"transformers.ClvpFeatureExtractor.__call__.sampling_rate",description:`<strong>sampling_rate</strong> (<code>int</code>, <em>optional</em>) &#x2014;
The sampling rate at which the <code>raw_speech</code> input was sampled. It is strongly recommended to pass
<code>sampling_rate</code> at the forward call to prevent silent errors and allow automatic speech recognition
pipeline.`,name:"sampling_rate"},{anchor:"transformers.ClvpFeatureExtractor.__call__.truncation",description:`<strong>truncation</strong> (<code>bool</code>, <em>optional</em>, default to <code>True</code>) &#x2014;
Activates truncation to cut input sequences longer than <em>max_length</em> to <em>max_length</em>.`,name:"truncation"},{anchor:"transformers.ClvpFeatureExtractor.__call__.pad_to_multiple_of",description:`<strong>pad_to_multiple_of</strong> (<code>int</code>, <em>optional</em>) &#x2014;
If set will pad the sequence to a multiple of the provided value.</p>
<p>This is especially useful to enable the use of Tensor Cores on NVIDIA hardware with compute capability
<code>&gt;= 7.5</code> (Volta), or on TPUs which benefit from having sequence lengths be a multiple of 128.`,name:"pad_to_multiple_of"},{anchor:"transformers.ClvpFeatureExtractor.__call__.return_attention_mask",description:`<strong>return_attention_mask</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>True</code>) &#x2014;
Whether to return the attention mask. If left to the default, it will return the attention mask.</p>
<p><a href="../glossary#attention-mask">What are attention masks?</a>`,name:"return_attention_mask"},{anchor:"transformers.ClvpFeatureExtractor.__call__.return_tensors",description:`<strong>return_tensors</strong> (<code>str</code> or <a href="/docs/transformers/main/en/internal/file_utils#transformers.TensorType">TensorType</a>, <em>optional</em>) &#x2014;
If set, will return tensors instead of list of python integers. Acceptable values are:</p>
<ul>
<li><code>&apos;tf&apos;</code>: Return TensorFlow <code>tf.constant</code> objects.</li>
<li><code>&apos;pt&apos;</code>: Return PyTorch <code>torch.Tensor</code> objects.</li>
<li><code>&apos;np&apos;</code>: Return Numpy <code>np.ndarray</code> objects.</li>
</ul>`,name:"return_tensors"},{anchor:"transformers.ClvpFeatureExtractor.__call__.padding_value",description:`<strong>padding_value</strong> (<code>float</code>, <em>optional</em>, defaults to 0.0) &#x2014;
The value that is used to fill the padding values / vectors.`,name:"padding_value"},{anchor:"transformers.ClvpFeatureExtractor.__call__.max_length",description:`<strong>max_length</strong> (<code>int</code>, <em>optional</em>) &#x2014;
The maximum input length of the inputs.`,name:"max_length"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/feature_extraction_clvp.py#L131"}}),Xe=new U({props:{title:"ClvpProcessor",local:"transformers.ClvpProcessor",headingTag:"h2"}}),Re=new x({props:{name:"class transformers.ClvpProcessor",anchor:"transformers.ClvpProcessor",parameters:[{name:"feature_extractor",val:""},{name:"tokenizer",val:""}],parametersDescription:[{anchor:"transformers.ClvpProcessor.feature_extractor",description:`<strong>feature_extractor</strong> (<code>ClvpFeatureExtractor</code>) &#x2014;
An instance of <a href="/docs/transformers/main/en/model_doc/clvp#transformers.ClvpFeatureExtractor">ClvpFeatureExtractor</a>. The feature extractor is a required input.`,name:"feature_extractor"},{anchor:"transformers.ClvpProcessor.tokenizer",description:`<strong>tokenizer</strong> (<code>ClvpTokenizer</code>) &#x2014;
An instance of <a href="/docs/transformers/main/en/model_doc/clvp#transformers.ClvpTokenizer">ClvpTokenizer</a>. The tokenizer is a required input.`,name:"tokenizer"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/processing_clvp.py#L23"}}),Ye=new x({props:{name:"__call__",anchor:"transformers.ClvpProcessor.__call__",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/processing_clvp.py#L48"}}),Qe=new x({props:{name:"decode",anchor:"transformers.ClvpProcessor.decode",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/processing_clvp.py#L85"}}),Se=new x({props:{name:"batch_decode",anchor:"transformers.ClvpProcessor.batch_decode",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/processing_clvp.py#L77"}}),Oe=new U({props:{title:"ClvpModelForConditionalGeneration",local:"transformers.ClvpModelForConditionalGeneration",headingTag:"h2"}}),Ae=new x({props:{name:"class transformers.ClvpModelForConditionalGeneration",anchor:"transformers.ClvpModelForConditionalGeneration",parameters:[{name:"config",val:": ClvpConfig"}],parametersDescription:[{anchor:"transformers.ClvpModelForConditionalGeneration.config",description:`<strong>config</strong> (<a href="/docs/transformers/main/en/model_doc/clvp#transformers.ClvpConfig">ClvpConfig</a>) &#x2014; Model configuration class with all the parameters of the model.
Initializing with a config file does not load the weights associated with the model, only the
configuration. Check out the <a href="/docs/transformers/main/en/main_classes/model#transformers.PreTrainedModel.from_pretrained">from_pretrained()</a> method to load the model weights.`,name:"config"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/modeling_clvp.py#L1508"}}),Ke=new x({props:{name:"forward",anchor:"transformers.ClvpModelForConditionalGeneration.forward",parameters:[{name:"input_ids",val:": LongTensor = None"},{name:"input_features",val:": FloatTensor = None"},{name:"conditioning_encoder_inputs_embeds",val:": typing.Optional[torch.FloatTensor] = None"},{name:"text_encoder_inputs_embeds",val:": typing.Optional[torch.FloatTensor] = None"},{name:"attention_mask",val:": typing.Optional[torch.LongTensor] = None"},{name:"return_loss",val:": typing.Optional[bool] = None"},{name:"output_hidden_states",val:": typing.Optional[bool] = None"},{name:"output_attentions",val:": typing.Optional[bool] = False"},{name:"return_dict",val:": typing.Optional[bool] = None"}],parametersDescription:[{anchor:"transformers.ClvpModelForConditionalGeneration.forward.input_ids",description:`<strong>input_ids</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size, sequence_length)</code>, <em>optional</em>) &#x2014;
Indices of input sequence tokens in the vocabulary. Padding will be ignored by default should you provide
it.</p>
<p>Indices can be obtained using <a href="/docs/transformers/main/en/model_doc/auto#transformers.AutoTokenizer">AutoTokenizer</a>. See <a href="/docs/transformers/main/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode">PreTrainedTokenizer.encode()</a> and
<a href="/docs/transformers/main/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__">PreTrainedTokenizer.<strong>call</strong>()</a> for details.</p>
<p><a href="../glossary#input-ids">What are input IDs?</a>`,name:"input_ids"},{anchor:"transformers.ClvpModelForConditionalGeneration.forward.input_features",description:`<strong>input_features</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, feature_size, time_dim)</code>) &#x2014;
Indicates log mel-spectrogram representations for audio returned by <a href="/docs/transformers/main/en/model_doc/clvp#transformers.ClvpFeatureExtractor">ClvpFeatureExtractor</a>.`,name:"input_features"},{anchor:"transformers.ClvpModelForConditionalGeneration.forward.conditioning_encoder_inputs_embeds",description:`<strong>conditioning_encoder_inputs_embeds</strong> (<code>torch.FloatTensor</code>, <em>optional</em>) &#x2014;
inputs_embeds for <code>ClvpConditioningEncoder</code>. Can be used in place of <code>input_ids</code>.`,name:"conditioning_encoder_inputs_embeds"},{anchor:"transformers.ClvpModelForConditionalGeneration.forward.text_encoder_inputs_embeds",description:`<strong>text_encoder_inputs_embeds</strong> (<code>torch.FloatTensor</code>, <em>optional</em>) &#x2014;
inputs_embeds for the text encoder model passed in place of <code>input_ids</code>.`,name:"text_encoder_inputs_embeds"},{anchor:"transformers.ClvpModelForConditionalGeneration.forward.attention_mask",description:`<strong>attention_mask</strong> (<code>torch.Tensor</code> of shape <code>(batch_size, sequence_length)</code>, <em>optional</em>) &#x2014;
Mask to avoid performing attention on padding text token indices. Mask values selected in <code>[0, 1]</code>:</p>
<ul>
<li>1 for tokens that are <strong>not masked</strong>,</li>
<li>0 for tokens that are <strong>masked</strong>.</li>
</ul>
<p><a href="../glossary#attention-mask">What are attention masks?</a>`,name:"attention_mask"},{anchor:"transformers.ClvpModelForConditionalGeneration.forward.return_loss",description:`<strong>return_loss</strong> (<code>bool</code>, <em>optional</em>) &#x2014;
Whether or not to return the contrastive loss.`,name:"return_loss"},{anchor:"transformers.ClvpModelForConditionalGeneration.forward.output_attentions",description:`<strong>output_attentions</strong> (<code>bool</code>, <em>optional</em>) &#x2014;
Whether or not to return the attentions tensors of all attention layers. See <code>attentions</code> under returned
tensors for more detail.`,name:"output_attentions"},{anchor:"transformers.ClvpModelForConditionalGeneration.forward.output_hidden_states",description:`<strong>output_hidden_states</strong> (<code>bool</code>, <em>optional</em>) &#x2014;
Whether or not to return the hidden states of all layers. See <code>hidden_states</code> under returned tensors for
more detail.`,name:"output_hidden_states"},{anchor:"transformers.ClvpModelForConditionalGeneration.forward.return_dict",description:`<strong>return_dict</strong> (<code>bool</code>, <em>optional</em>) &#x2014;
Whether or not to return a <a href="/docs/transformers/main/en/main_classes/output#transformers.utils.ModelOutput">ModelOutput</a> instead of a plain tuple.`,name:"return_dict"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/modeling_clvp.py#L1736",returnDescription:`<script context="module">export const metadata = 'undefined';<\/script>


<p>A <code>transformers.models.clvp.modeling_clvp.ClvpOutput</code> or a tuple of
<code>torch.FloatTensor</code> (if <code>return_dict=False</code> is passed or when <code>config.return_dict=False</code>) comprising various
elements depending on the configuration (<code>&lt;class 'transformers.models.clvp.configuration_clvp.ClvpConfig'&gt;</code>) and inputs.</p>
<ul>
<li><strong>loss</strong> (<code>torch.FloatTensor</code> of shape <code>(1,)</code>, <em>optional</em>, returned when <code>return_loss</code> is <code>True</code>) — Contrastive loss for speech-text similarity.</li>
<li><strong>speech_ids</strong> (<code>torch.LongTensor</code>, <em>optional</em>) — speech_ids (or speech candidates) generated by the <code>ClvpForCausalLM</code> model.</li>
<li><strong>logits_per_speech</strong> (<code>torch.FloatTensor</code> of shape <code>(speech_batch_size, text_batch_size)</code>) — The scaled dot product scores between <code>speech_embeds</code> and <code>text_embeds</code>. This represents the speech-text
similarity scores.</li>
<li><strong>logits_per_text</strong> (<code>torch.FloatTensor</code> of shape <code>(text_batch_size, speech_batch_size)</code>) — The scaled dot product scores between <code>text_embeds</code> and <code>speech_embeds</code>. This represents the text-speech
similarity scores.</li>
<li><strong>text_embeds</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, output_dim</code>) — The text embeddings obtained by applying the projection layer to the pooled output of the text encoder
model.</li>
<li><strong>speech_embeds</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, output_dim</code>) — The speech embeddings obtained by applying the projection layer to the pooled output of the speech encoder
model.</li>
<li><strong>text_model_output</strong> (<code>BaseModelOutputWithPooling</code>) — The pooled output of the <code>last_hidden_state</code> of the text encoder Model.</li>
<li><strong>speech_model_output</strong> (<code>BaseModelOutputWithPooling</code>) — The pooled output of the <code>last_hidden_state</code> of the speech encoder Model.</li>
<li><strong>decoder_hidden_states</strong> (<code>torch.FloatTensor</code>, <em>optional</em>) — The hidden states of the decoder model.</li>
<li><strong>text_encoder_hidden_states</strong> (<code>torch.FloatTensor</code>, <em>optional</em>) — The hidden states of the text encoder model.</li>
<li><strong>speech_encoder_hidden_states</strong> (<code>torch.FloatTensor</code>, <em>optional</em>) — The hidden states of the speech encoder model.</li>
</ul>
`,returnType:`<script context="module">export const metadata = 'undefined';<\/script>


<p><code>transformers.models.clvp.modeling_clvp.ClvpOutput</code> or <code>tuple(torch.FloatTensor)</code></p>
`}}),ce=new go({props:{$$slots:{default:[fa]},$$scope:{ctx:w}}}),pe=new yt({props:{anchor:"transformers.ClvpModelForConditionalGeneration.forward.example",$$slots:{default:[ua]},$$scope:{ctx:w}}}),et=new x({props:{name:"generate",anchor:"transformers.ClvpModelForConditionalGeneration.generate",parameters:[{name:"input_ids",val:": LongTensor = None"},{name:"input_features",val:": FloatTensor = None"},{name:"attention_mask",val:": typing.Optional[torch.LongTensor] = None"},{name:"generation_config",val:": typing.Optional[transformers.generation.configuration_utils.GenerationConfig] = None"},{name:"pad_to_max_mel_tokens",val:": typing.Optional[int] = None"},{name:"output_hidden_states",val:": typing.Optional[bool] = None"},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"transformers.ClvpModelForConditionalGeneration.generate.input_ids",description:`<strong>input_ids</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length)</code>, <em>optional</em>) &#x2014;
Input text Tokens. Processed from the <a href="/docs/transformers/main/en/model_doc/clvp#transformers.ClvpTokenizer">ClvpTokenizer</a>.`,name:"input_ids"},{anchor:"transformers.ClvpModelForConditionalGeneration.generate.input_features",description:`<strong>input_features</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, feature_size, time_dim)</code>, <em>optional</em>) &#x2014;
Indicates log-melspectrogram representations for audio returned by <a href="/docs/transformers/main/en/model_doc/clvp#transformers.ClvpFeatureExtractor">ClvpFeatureExtractor</a>.`,name:"input_features"},{anchor:"transformers.ClvpModelForConditionalGeneration.generate.attention_mask",description:`<strong>attention_mask</strong> (<code>torch.Tensor</code> of shape <code>(batch_size, sequence_length)</code>, <em>optional</em>) &#x2014;
Mask to avoid performing attention on padding text token indices. Mask values selected in <code>[0, 1]</code>:</p>
<ul>
<li>1 for tokens that are <strong>not masked</strong>,</li>
<li>0 for tokens that are <strong>masked</strong>.</li>
</ul>
<p><a href="../glossary#attention-mask">What are attention masks?</a>`,name:"attention_mask"},{anchor:"transformers.ClvpModelForConditionalGeneration.generate.generation_config",description:`<strong>generation_config</strong> (<code>~generation.GenerationConfig</code>, <em>optional</em>) &#x2014;
The generation configuration to be used as base parametrization for the generation call. <code>**kwargs</code>
passed to generate matching the attributes of <code>generation_config</code> will override them. If
<code>generation_config</code> is not provided, the default will be used, which had the following loading
priority: 1) from the <code>generation_config.json</code> model file, if it exists; 2) from the model
configuration. Please note that unspecified parameters will inherit <a href="/docs/transformers/main/en/main_classes/text_generation#transformers.GenerationConfig">GenerationConfig</a>&#x2019;s
default values, whose documentation should be checked to parameterize generation.`,name:"generation_config"},{anchor:"transformers.ClvpModelForConditionalGeneration.generate.pad_to_max_mel_tokens",description:`<strong>pad_to_max_mel_tokens</strong> (<code>int</code>, <em>optional</em>) &#x2014;
Pads generated speech_ids to the specified value. This is to implement the same logic from the official
repo, link: <a href="https://github.com/neonbjb/tortoise-tts/blob/80f89987a5abda5e2b082618cd74f9c7411141dc/tortoise/api.py#L430" rel="nofollow">https://github.com/neonbjb/tortoise-tts/blob/80f89987a5abda5e2b082618cd74f9c7411141dc/tortoise/api.py#L430</a>
and to make sure the logits are same.
This does not affect generation quality so please don&#x2019;t consider using it since it is less efficient.`,name:"pad_to_max_mel_tokens"},{anchor:"transformers.ClvpModelForConditionalGeneration.generate.output_hidden_states",description:`<strong>output_hidden_states</strong> (<code>bool</code>, <em>optional</em>) &#x2014;
Whether or not to return the hidden states of decoder model, text encoder and speech encoder models.`,name:"output_hidden_states"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/modeling_clvp.py#L1868",returnDescription:`<script context="module">export const metadata = 'undefined';<\/script>


<p>A <code>ClvpOutput</code> (if <code>return_dict_in_generate=True</code> or when
<code>config.return_dict_in_generate=True</code>) or a tuple.</p>
`,returnType:`<script context="module">export const metadata = 'undefined';<\/script>


<p><code>ClvpOutput</code> or tuple</p>
`}}),tt=new x({props:{name:"get_text_features",anchor:"transformers.ClvpModelForConditionalGeneration.get_text_features",parameters:[{name:"input_ids",val:": typing.Optional[torch.LongTensor] = None"},{name:"text_encoder_inputs_embeds",val:": typing.Optional[torch.FloatTensor] = None"},{name:"attention_mask",val:": typing.Optional[torch.LongTensor] = None"}],parametersDescription:[{anchor:"transformers.ClvpModelForConditionalGeneration.get_text_features.input_ids",description:`<strong>input_ids</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size, sequence_length)</code>) &#x2014;
Indices of input sequence tokens in the vocabulary. Padding will be ignored by default should you
provide it.</p>
<p><a href="../glossary#input-ids">What are input IDs?</a>`,name:"input_ids"},{anchor:"transformers.ClvpModelForConditionalGeneration.get_text_features.text_encoder_inputs_embeds",description:`<strong>text_encoder_inputs_embeds</strong> (<code>torch.FloatTensor</code>, <em>optional</em>) &#x2014;
inputs_embeds for the text encoder model passed in place of <code>input_ids</code>.`,name:"text_encoder_inputs_embeds"},{anchor:"transformers.ClvpModelForConditionalGeneration.get_text_features.attention_mask",description:`<strong>attention_mask</strong> (<code>torch.Tensor</code> of shape <code>(batch_size, sequence_length)</code>, <em>optional</em>) &#x2014;
Mask to avoid performing attention on padding token indices. Mask values selected in <code>[0, 1]</code>:</p>
<ul>
<li>1 for tokens that are <strong>not masked</strong>,</li>
<li>0 for tokens that are <strong>masked</strong>.</li>
</ul>
<p><a href="../glossary#attention-mask">What are attention masks?</a>`,name:"attention_mask"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/modeling_clvp.py#L1582",returnDescription:`<script context="module">export const metadata = 'undefined';<\/script>


<p>The text embeddings obtained by applying the projection layer to the pooled output of the CLVP Text
Model.</p>
`,returnType:`<script context="module">export const metadata = 'undefined';<\/script>


<p><code>torch.FloatTensor</code> of shape <code>(batch_size, output_dim)</code></p>
`}}),fe=new yt({props:{anchor:"transformers.ClvpModelForConditionalGeneration.get_text_features.example",$$slots:{default:[ha]},$$scope:{ctx:w}}}),ot=new x({props:{name:"get_speech_features",anchor:"transformers.ClvpModelForConditionalGeneration.get_speech_features",parameters:[{name:"speech_ids",val:": typing.Optional[torch.LongTensor] = None"},{name:"input_ids",val:": typing.Optional[torch.LongTensor] = None"},{name:"input_features",val:": typing.Optional[torch.FloatTensor] = None"},{name:"conditioning_encoder_inputs_embeds",val:": typing.Optional[torch.FloatTensor] = None"},{name:"attention_mask",val:": typing.Optional[torch.Tensor] = None"},{name:"generation_config",val:": typing.Optional[transformers.generation.configuration_utils.GenerationConfig] = None"},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"transformers.ClvpModelForConditionalGeneration.get_speech_features.speech_ids",description:`<strong>speech_ids</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size, num_speech_ids)</code>, <em>optional</em>) &#x2014;
Speech Tokens. Padding will be ignored by default should you provide it. If speech_ids are provided
then input_ids and input_features will be automatically ignored.`,name:"speech_ids"},{anchor:"transformers.ClvpModelForConditionalGeneration.get_speech_features.input_ids",description:`<strong>input_ids</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size, sequence_length)</code>, <em>optional</em>) &#x2014;
Input text Tokens. Processed from the <a href="/docs/transformers/main/en/model_doc/clvp#transformers.ClvpTokenizer">ClvpTokenizer</a>. If speech_ids is not provided, then input_ids
and input_features will be used.`,name:"input_ids"},{anchor:"transformers.ClvpModelForConditionalGeneration.get_speech_features.input_features",description:`<strong>input_features</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, feature_size, time_dim)</code>, <em>optional</em>) &#x2014;
Indicates log-melspectrogram representations for audio returned by <a href="/docs/transformers/main/en/model_doc/clvp#transformers.ClvpFeatureExtractor">ClvpFeatureExtractor</a>. If
speech_ids is not provided, then input_ids and input_features will be used.`,name:"input_features"},{anchor:"transformers.ClvpModelForConditionalGeneration.get_speech_features.conditioning_encoder_inputs_embeds",description:`<strong>conditioning_encoder_inputs_embeds</strong> (<code>torch.FloatTensor</code>, <em>optional</em>) &#x2014;
inputs_embeds for <code>ClvpConditioningEncoder</code>. Can be used in place of <code>input_ids</code>.`,name:"conditioning_encoder_inputs_embeds"},{anchor:"transformers.ClvpModelForConditionalGeneration.get_speech_features.attention_mask",description:`<strong>attention_mask</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size, sequence_length)</code>, <em>optional</em>) &#x2014;
Mask to avoid performing attention on padding speech token indices. Mask values selected in <code>[0, 1]</code>:</p>
<ul>
<li>1 for tokens that are <strong>not masked</strong>,</li>
<li>0 for tokens that are <strong>masked</strong>.</li>
</ul>
<p><a href="../glossary#attention-mask">What are attention masks?</a>`,name:"attention_mask"},{anchor:"transformers.ClvpModelForConditionalGeneration.get_speech_features.generation_config",description:`<strong>generation_config</strong> (<code>GenerationConfig</code>, <em>optional</em>) &#x2014;
generation config to control the generation of speech_ids if they are not provided.`,name:"generation_config"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/modeling_clvp.py#L1639",returnDescription:`<script context="module">export const metadata = 'undefined';<\/script>


<p>The speech embeddings obtained by applying the projection layer to the pooled output of the CLVP Speech
Model.</p>
`,returnType:`<script context="module">export const metadata = 'undefined';<\/script>


<p><code>torch.FloatTensor</code> of shape <code>(batch_size, output_dim)</code></p>
`}}),ue=new yt({props:{anchor:"transformers.ClvpModelForConditionalGeneration.get_speech_features.example",$$slots:{default:[ga]},$$scope:{ctx:w}}}),nt=new U({props:{title:"ClvpForCausalLM",local:"transformers.ClvpForCausalLM",headingTag:"h2"}}),st=new x({props:{name:"class transformers.ClvpForCausalLM",anchor:"transformers.ClvpForCausalLM",parameters:[{name:"config",val:""}],parametersDescription:[{anchor:"transformers.ClvpForCausalLM.config",description:`<strong>config</strong> (<a href="/docs/transformers/main/en/model_doc/clvp#transformers.ClvpConfig">ClvpConfig</a>) &#x2014; Model configuration class with all the parameters of the model.
Initializing with a config file does not load the weights associated with the model, only the
configuration. Check out the <a href="/docs/transformers/main/en/main_classes/model#transformers.PreTrainedModel.from_pretrained">from_pretrained()</a> method to load the model weights.`,name:"config"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/modeling_clvp.py#L1277"}}),at=new x({props:{name:"forward",anchor:"transformers.ClvpForCausalLM.forward",parameters:[{name:"input_ids",val:": typing.Optional[torch.LongTensor] = None"},{name:"past_key_values",val:": typing.Optional[typing.Tuple[typing.Tuple[torch.Tensor]]] = None"},{name:"attention_mask",val:": typing.Optional[torch.FloatTensor] = None"},{name:"token_type_ids",val:": typing.Optional[torch.LongTensor] = None"},{name:"position_ids",val:": typing.Optional[torch.LongTensor] = None"},{name:"head_mask",val:": typing.Optional[torch.FloatTensor] = None"},{name:"inputs_embeds",val:": typing.Optional[torch.FloatTensor] = None"},{name:"labels",val:": typing.Optional[torch.LongTensor] = None"},{name:"use_cache",val:": typing.Optional[bool] = None"},{name:"output_attentions",val:": typing.Optional[bool] = None"},{name:"output_hidden_states",val:": typing.Optional[bool] = None"},{name:"return_dict",val:": typing.Optional[bool] = None"}],parametersDescription:[{anchor:"transformers.ClvpForCausalLM.forward.input_ids",description:`<strong>input_ids</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size, input_ids_length)</code>) &#x2014;
Indices of input sequence tokens in the vocabulary.</p>
<p>Indices can be obtained using <a href="/docs/transformers/main/en/model_doc/auto#transformers.AutoTokenizer">AutoTokenizer</a>. See <a href="/docs/transformers/main/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode">PreTrainedTokenizer.encode()</a> and
<a href="/docs/transformers/main/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__">PreTrainedTokenizer.<strong>call</strong>()</a> for details.</p>
<p><a href="../glossary#input-ids">What are input IDs?</a>`,name:"input_ids"},{anchor:"transformers.ClvpForCausalLM.forward.past_key_values",description:`<strong>past_key_values</strong> (<code>Tuple[Tuple[torch.Tensor]]</code> of length <code>config.n_layers</code>) &#x2014;
Contains precomputed hidden-states (key and values in the attention blocks) as computed by the model (see
<code>past_key_values</code> output below). Can be used to speed up sequential decoding. The <code>input_ids</code> which have
their past given to this model should not be passed as <code>input_ids</code> as they have already been computed.`,name:"past_key_values"},{anchor:"transformers.ClvpForCausalLM.forward.attention_mask",description:`<strong>attention_mask</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length)</code>, <em>optional</em>) &#x2014;
Mask to avoid performing attention on padding token indices. Mask values selected in <code>[0, 1]</code>:</p>
<ul>
<li>1 for tokens that are <strong>not masked</strong>,</li>
<li>0 for tokens that are <strong>masked</strong>.</li>
</ul>
<p>If <code>past_key_values</code> is used, <code>attention_mask</code> needs to contain the masking strategy that was used for
<code>past_key_values</code>. In other words, the <code>attention_mask</code> always has to have the length:
<code>len(past_key_values) + len(input_ids)</code></p>
<p><a href="../glossary#attention-mask">What are attention masks?</a>`,name:"attention_mask"},{anchor:"transformers.ClvpForCausalLM.forward.token_type_ids",description:`<strong>token_type_ids</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size, input_ids_length)</code>, <em>optional</em>) &#x2014;
Segment token indices to indicate first and second portions of the inputs. Indices are selected in <code>[0, 1]</code>:</p>
<ul>
<li>0 corresponds to a <em>sentence A</em> token,</li>
<li>1 corresponds to a <em>sentence B</em> token.</li>
</ul>
<p><a href="../glossary#token-type-ids">What are token type IDs?</a>`,name:"token_type_ids"},{anchor:"transformers.ClvpForCausalLM.forward.position_ids",description:`<strong>position_ids</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size, sequence_length)</code>, <em>optional</em>) &#x2014;
Indices of positions of each input sequence tokens in the position embeddings. Selected in the range <code>[0, config.max_position_embeddings - 1]</code>.</p>
<p><a href="../glossary#position-ids">What are position IDs?</a>`,name:"position_ids"},{anchor:"transformers.ClvpForCausalLM.forward.head_mask",description:`<strong>head_mask</strong> (<code>torch.FloatTensor</code> of shape <code>(num_heads,)</code> or <code>(num_layers, num_heads)</code>, <em>optional</em>) &#x2014;
Mask to nullify selected heads of the self-attention modules. Mask values selected in <code>[0, 1]</code>:</p>
<ul>
<li>1 indicates the head is <strong>not masked</strong>,</li>
<li>0 indicates the head is <strong>masked</strong>.</li>
</ul>`,name:"head_mask"},{anchor:"transformers.ClvpForCausalLM.forward.inputs_embeds",description:`<strong>inputs_embeds</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>, <em>optional</em>) &#x2014;
Optionally, instead of passing <code>input_ids</code> you can choose to directly pass an embedded representation. This
is useful if you want more control over how to convert <code>input_ids</code> indices into associated vectors than the
model&#x2019;s internal embedding lookup matrix.</p>
<p>If <code>past_key_values</code> is used, optionally only the last <code>inputs_embeds</code> have to be input (see
<code>past_key_values</code>).`,name:"inputs_embeds"},{anchor:"transformers.ClvpForCausalLM.forward.use_cache",description:`<strong>use_cache</strong> (<code>bool</code>, <em>optional</em>) &#x2014;
If set to <code>True</code>, <code>past_key_values</code> key value states are returned and can be used to speed up decoding (see
<code>past_key_values</code>).`,name:"use_cache"},{anchor:"transformers.ClvpForCausalLM.forward.output_attentions",description:`<strong>output_attentions</strong> (<code>bool</code>, <em>optional</em>) &#x2014;
Whether or not to return the attentions tensors of all attention layers. See <code>attentions</code> under returned
tensors for more detail.`,name:"output_attentions"},{anchor:"transformers.ClvpForCausalLM.forward.output_hidden_states",description:`<strong>output_hidden_states</strong> (<code>bool</code>, <em>optional</em>) &#x2014;
Whether or not to return the hidden states of all layers. See <code>hidden_states</code> under returned tensors for
more detail.`,name:"output_hidden_states"},{anchor:"transformers.ClvpForCausalLM.forward.return_dict",description:`<strong>return_dict</strong> (<code>bool</code>, <em>optional</em>) &#x2014;
Whether or not to return a <a href="/docs/transformers/main/en/main_classes/output#transformers.utils.ModelOutput">ModelOutput</a> instead of a plain tuple.`,name:"return_dict"},{anchor:"transformers.ClvpForCausalLM.forward.labels",description:`<strong>labels</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size, sequence_length)</code>, <em>optional</em>) &#x2014;
Labels for language modeling. Note that the labels <strong>are shifted</strong> inside the model, i.e. you can set
<code>labels = input_ids</code> Indices are selected in <code>[-100, 0, ..., config.vocab_size]</code> All labels set to <code>-100</code>
are ignored (masked), the loss is only computed for labels in <code>[0, ..., config.vocab_size]</code>`,name:"labels"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/modeling_clvp.py#L1420"}}),he=new go({props:{$$slots:{default:[_a]},$$scope:{ctx:w}}}),rt=new U({props:{title:"ClvpModel",local:"transformers.ClvpModel",headingTag:"h2"}}),it=new x({props:{name:"class transformers.ClvpModel",anchor:"transformers.ClvpModel",parameters:[{name:"config",val:": ClvpDecoderConfig"}],parametersDescription:[{anchor:"transformers.ClvpModel.config",description:`<strong>config</strong> (<a href="/docs/transformers/main/en/model_doc/clvp#transformers.ClvpConfig">ClvpConfig</a>) &#x2014; Model configuration class with all the parameters of the model.
Initializing with a config file does not load the weights associated with the model, only the
configuration. Check out the <a href="/docs/transformers/main/en/main_classes/model#transformers.PreTrainedModel.from_pretrained">from_pretrained()</a> method to load the model weights.`,name:"config"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/modeling_clvp.py#L1206"}}),lt=new x({props:{name:"forward",anchor:"transformers.ClvpModel.forward",parameters:[{name:"input_ids",val:": typing.Optional[torch.LongTensor] = None"},{name:"attention_mask",val:": typing.Optional[torch.FloatTensor] = None"},{name:"token_type_ids",val:": typing.Optional[torch.LongTensor] = None"},{name:"position_ids",val:": typing.Optional[torch.LongTensor] = None"},{name:"head_mask",val:": typing.Optional[torch.FloatTensor] = None"},{name:"past_key_values",val:": typing.Optional[typing.Tuple[typing.Tuple[torch.Tensor]]] = None"},{name:"inputs_embeds",val:": typing.Optional[torch.FloatTensor] = None"},{name:"use_cache",val:": typing.Optional[bool] = None"},{name:"output_attentions",val:": typing.Optional[bool] = None"},{name:"output_hidden_states",val:": typing.Optional[bool] = None"},{name:"return_dict",val:": typing.Optional[bool] = None"}],parametersDescription:[{anchor:"transformers.ClvpModel.forward.input_ids",description:`<strong>input_ids</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size, input_ids_length)</code>) &#x2014;
Indices of input sequence tokens in the vocabulary.</p>
<p>Indices can be obtained using <a href="/docs/transformers/main/en/model_doc/auto#transformers.AutoTokenizer">AutoTokenizer</a>. See <a href="/docs/transformers/main/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode">PreTrainedTokenizer.encode()</a> and
<a href="/docs/transformers/main/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__">PreTrainedTokenizer.<strong>call</strong>()</a> for details.</p>
<p><a href="../glossary#input-ids">What are input IDs?</a>`,name:"input_ids"},{anchor:"transformers.ClvpModel.forward.past_key_values",description:`<strong>past_key_values</strong> (<code>Tuple[Tuple[torch.Tensor]]</code> of length <code>config.n_layers</code>) &#x2014;
Contains precomputed hidden-states (key and values in the attention blocks) as computed by the model (see
<code>past_key_values</code> output below). Can be used to speed up sequential decoding. The <code>input_ids</code> which have
their past given to this model should not be passed as <code>input_ids</code> as they have already been computed.`,name:"past_key_values"},{anchor:"transformers.ClvpModel.forward.attention_mask",description:`<strong>attention_mask</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length)</code>, <em>optional</em>) &#x2014;
Mask to avoid performing attention on padding token indices. Mask values selected in <code>[0, 1]</code>:</p>
<ul>
<li>1 for tokens that are <strong>not masked</strong>,</li>
<li>0 for tokens that are <strong>masked</strong>.</li>
</ul>
<p>If <code>past_key_values</code> is used, <code>attention_mask</code> needs to contain the masking strategy that was used for
<code>past_key_values</code>. In other words, the <code>attention_mask</code> always has to have the length:
<code>len(past_key_values) + len(input_ids)</code></p>
<p><a href="../glossary#attention-mask">What are attention masks?</a>`,name:"attention_mask"},{anchor:"transformers.ClvpModel.forward.token_type_ids",description:`<strong>token_type_ids</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size, input_ids_length)</code>, <em>optional</em>) &#x2014;
Segment token indices to indicate first and second portions of the inputs. Indices are selected in <code>[0, 1]</code>:</p>
<ul>
<li>0 corresponds to a <em>sentence A</em> token,</li>
<li>1 corresponds to a <em>sentence B</em> token.</li>
</ul>
<p><a href="../glossary#token-type-ids">What are token type IDs?</a>`,name:"token_type_ids"},{anchor:"transformers.ClvpModel.forward.position_ids",description:`<strong>position_ids</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size, sequence_length)</code>, <em>optional</em>) &#x2014;
Indices of positions of each input sequence tokens in the position embeddings. Selected in the range <code>[0, config.max_position_embeddings - 1]</code>.</p>
<p><a href="../glossary#position-ids">What are position IDs?</a>`,name:"position_ids"},{anchor:"transformers.ClvpModel.forward.head_mask",description:`<strong>head_mask</strong> (<code>torch.FloatTensor</code> of shape <code>(num_heads,)</code> or <code>(num_layers, num_heads)</code>, <em>optional</em>) &#x2014;
Mask to nullify selected heads of the self-attention modules. Mask values selected in <code>[0, 1]</code>:</p>
<ul>
<li>1 indicates the head is <strong>not masked</strong>,</li>
<li>0 indicates the head is <strong>masked</strong>.</li>
</ul>`,name:"head_mask"},{anchor:"transformers.ClvpModel.forward.inputs_embeds",description:`<strong>inputs_embeds</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>, <em>optional</em>) &#x2014;
Optionally, instead of passing <code>input_ids</code> you can choose to directly pass an embedded representation. This
is useful if you want more control over how to convert <code>input_ids</code> indices into associated vectors than the
model&#x2019;s internal embedding lookup matrix.</p>
<p>If <code>past_key_values</code> is used, optionally only the last <code>inputs_embeds</code> have to be input (see
<code>past_key_values</code>).`,name:"inputs_embeds"},{anchor:"transformers.ClvpModel.forward.use_cache",description:`<strong>use_cache</strong> (<code>bool</code>, <em>optional</em>) &#x2014;
If set to <code>True</code>, <code>past_key_values</code> key value states are returned and can be used to speed up decoding (see
<code>past_key_values</code>).`,name:"use_cache"},{anchor:"transformers.ClvpModel.forward.output_attentions",description:`<strong>output_attentions</strong> (<code>bool</code>, <em>optional</em>) &#x2014;
Whether or not to return the attentions tensors of all attention layers. See <code>attentions</code> under returned
tensors for more detail.`,name:"output_attentions"},{anchor:"transformers.ClvpModel.forward.output_hidden_states",description:`<strong>output_hidden_states</strong> (<code>bool</code>, <em>optional</em>) &#x2014;
Whether or not to return the hidden states of all layers. See <code>hidden_states</code> under returned tensors for
more detail.`,name:"output_hidden_states"},{anchor:"transformers.ClvpModel.forward.return_dict",description:`<strong>return_dict</strong> (<code>bool</code>, <em>optional</em>) &#x2014;
Whether or not to return a <a href="/docs/transformers/main/en/main_classes/output#transformers.utils.ModelOutput">ModelOutput</a> instead of a plain tuple.`,name:"return_dict"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/modeling_clvp.py#L1228"}}),ge=new go({props:{$$slots:{default:[va]},$$scope:{ctx:w}}}),dt=new U({props:{title:"ClvpEncoder",local:"transformers.ClvpEncoder",headingTag:"h2"}}),ct=new x({props:{name:"class transformers.ClvpEncoder",anchor:"transformers.ClvpEncoder",parameters:[{name:"config",val:": ClvpConfig"}],parametersDescription:[{anchor:"transformers.ClvpEncoder.config",description:"<strong>config</strong> &#x2014; ClvpConfig",name:"config"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/modeling_clvp.py#L871"}}),pt=new x({props:{name:"forward",anchor:"transformers.ClvpEncoder.forward",parameters:[{name:"input_ids",val:": typing.Optional[torch.LongTensor] = None"},{name:"inputs_embeds",val:": typing.Optional[torch.LongTensor] = None"},{name:"attention_mask",val:": typing.Optional[torch.LongTensor] = None"},{name:"position_ids",val:": typing.Optional[torch.LongTensor] = None"},{name:"output_attentions",val:": typing.Optional[bool] = None"},{name:"output_hidden_states",val:": typing.Optional[bool] = None"},{name:"return_dict",val:": typing.Optional[bool] = None"}],parametersDescription:[{anchor:"transformers.ClvpEncoder.forward.input_ids",description:`<strong>input_ids</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size, input_ids_length)</code>, <em>optional</em>) &#x2014;
Indices of input sequence tokens in the vocabulary.</p>
<p>Indices can be obtained using <a href="/docs/transformers/main/en/model_doc/auto#transformers.AutoTokenizer">AutoTokenizer</a>. See <a href="/docs/transformers/main/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode">PreTrainedTokenizer.encode()</a> and
<a href="/docs/transformers/main/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__">PreTrainedTokenizer.<strong>call</strong>()</a> for details.</p>
<p><a href="../glossary#input-ids">What are input IDs?</a>`,name:"input_ids"},{anchor:"transformers.ClvpEncoder.forward.inputs_embeds",description:`<strong>inputs_embeds</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>, <em>optional</em>) &#x2014;
input embeddings for the model. This bypasses the model&#x2019;s internal embedding lookup matrix.`,name:"inputs_embeds"},{anchor:"transformers.ClvpEncoder.forward.attention_mask",description:`<strong>attention_mask</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size, sequence_length)</code>, <em>optional</em>) &#x2014;
Mask to avoid performing attention on padding token indices. Mask values selected in <code>[0, 1]</code>:</p>
<ul>
<li>1 for tokens that are <strong>not masked</strong>,</li>
<li>0 for tokens that are <strong>masked</strong>.</li>
</ul>
<p><a href="../glossary#attention-mask">What are attention masks?</a>`,name:"attention_mask"},{anchor:"transformers.ClvpEncoder.forward.position_ids",description:`<strong>position_ids</strong> (<code>torch.LongTensor</code>, <em>optional</em>) &#x2014;
Denotes the position ids of <code>input_ids</code>.`,name:"position_ids"},{anchor:"transformers.ClvpEncoder.forward.output_attentions",description:`<strong>output_attentions</strong> (<code>bool</code>, <em>optional</em>) &#x2014;
Whether or not to return the attentions tensors of all attention layers. See <code>attentions</code> under
returned tensors for more detail.`,name:"output_attentions"},{anchor:"transformers.ClvpEncoder.forward.output_hidden_states",description:`<strong>output_hidden_states</strong> (<code>bool</code>, <em>optional</em>) &#x2014;
Whether or not to return the hidden states of all layers. See <code>hidden_states</code> under returned tensors
for more detail.`,name:"output_hidden_states"},{anchor:"transformers.ClvpEncoder.forward.return_dict",description:`<strong>return_dict</strong> (<code>bool</code>, <em>optional</em>) &#x2014;
Whether or not to return a <a href="/docs/transformers/main/en/main_classes/output#transformers.utils.ModelOutput">ModelOutput</a> instead of a plain tuple.`,name:"return_dict"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/modeling_clvp.py#L903"}}),mt=new U({props:{title:"ClvpDecoder",local:"transformers.ClvpDecoder",headingTag:"h2"}}),ft=new x({props:{name:"class transformers.ClvpDecoder",anchor:"transformers.ClvpDecoder",parameters:[{name:"config",val:""}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/modeling_clvp.py#L1027"}}),ut=new x({props:{name:"forward",anchor:"transformers.ClvpDecoder.forward",parameters:[{name:"input_ids",val:": typing.Optional[torch.LongTensor] = None"},{name:"attention_mask",val:": typing.Optional[torch.FloatTensor] = None"},{name:"token_type_ids",val:": typing.Optional[torch.LongTensor] = None"},{name:"position_ids",val:": typing.Optional[torch.LongTensor] = None"},{name:"head_mask",val:": typing.Optional[torch.FloatTensor] = None"},{name:"past_key_values",val:": typing.Optional[typing.Tuple[typing.Tuple[torch.Tensor]]] = None"},{name:"inputs_embeds",val:": typing.Optional[torch.FloatTensor] = None"},{name:"use_cache",val:": typing.Optional[bool] = None"},{name:"output_attentions",val:": typing.Optional[bool] = None"},{name:"output_hidden_states",val:": typing.Optional[bool] = None"},{name:"return_dict",val:": typing.Optional[bool] = None"}],parametersDescription:[{anchor:"transformers.ClvpDecoder.forward.input_ids",description:`<strong>input_ids</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size, input_ids_length)</code>) &#x2014;
Indices of input sequence tokens in the vocabulary.</p>
<p>Indices can be obtained using <a href="/docs/transformers/main/en/model_doc/auto#transformers.AutoTokenizer">AutoTokenizer</a>. See <a href="/docs/transformers/main/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode">PreTrainedTokenizer.encode()</a> and
<a href="/docs/transformers/main/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__">PreTrainedTokenizer.<strong>call</strong>()</a> for details.</p>
<p><a href="../glossary#input-ids">What are input IDs?</a>`,name:"input_ids"},{anchor:"transformers.ClvpDecoder.forward.past_key_values",description:`<strong>past_key_values</strong> (<code>Tuple[Tuple[torch.Tensor]]</code> of length <code>config.n_layers</code>) &#x2014;
Contains precomputed hidden-states (key and values in the attention blocks) as computed by the model (see
<code>past_key_values</code> output below). Can be used to speed up sequential decoding. The <code>input_ids</code> which have
their past given to this model should not be passed as <code>input_ids</code> as they have already been computed.`,name:"past_key_values"},{anchor:"transformers.ClvpDecoder.forward.attention_mask",description:`<strong>attention_mask</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length)</code>, <em>optional</em>) &#x2014;
Mask to avoid performing attention on padding token indices. Mask values selected in <code>[0, 1]</code>:</p>
<ul>
<li>1 for tokens that are <strong>not masked</strong>,</li>
<li>0 for tokens that are <strong>masked</strong>.</li>
</ul>
<p>If <code>past_key_values</code> is used, <code>attention_mask</code> needs to contain the masking strategy that was used for
<code>past_key_values</code>. In other words, the <code>attention_mask</code> always has to have the length:
<code>len(past_key_values) + len(input_ids)</code></p>
<p><a href="../glossary#attention-mask">What are attention masks?</a>`,name:"attention_mask"},{anchor:"transformers.ClvpDecoder.forward.token_type_ids",description:`<strong>token_type_ids</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size, input_ids_length)</code>, <em>optional</em>) &#x2014;
Segment token indices to indicate first and second portions of the inputs. Indices are selected in <code>[0, 1]</code>:</p>
<ul>
<li>0 corresponds to a <em>sentence A</em> token,</li>
<li>1 corresponds to a <em>sentence B</em> token.</li>
</ul>
<p><a href="../glossary#token-type-ids">What are token type IDs?</a>`,name:"token_type_ids"},{anchor:"transformers.ClvpDecoder.forward.position_ids",description:`<strong>position_ids</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size, sequence_length)</code>, <em>optional</em>) &#x2014;
Indices of positions of each input sequence tokens in the position embeddings. Selected in the range <code>[0, config.max_position_embeddings - 1]</code>.</p>
<p><a href="../glossary#position-ids">What are position IDs?</a>`,name:"position_ids"},{anchor:"transformers.ClvpDecoder.forward.head_mask",description:`<strong>head_mask</strong> (<code>torch.FloatTensor</code> of shape <code>(num_heads,)</code> or <code>(num_layers, num_heads)</code>, <em>optional</em>) &#x2014;
Mask to nullify selected heads of the self-attention modules. Mask values selected in <code>[0, 1]</code>:</p>
<ul>
<li>1 indicates the head is <strong>not masked</strong>,</li>
<li>0 indicates the head is <strong>masked</strong>.</li>
</ul>`,name:"head_mask"},{anchor:"transformers.ClvpDecoder.forward.inputs_embeds",description:`<strong>inputs_embeds</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>, <em>optional</em>) &#x2014;
Optionally, instead of passing <code>input_ids</code> you can choose to directly pass an embedded representation. This
is useful if you want more control over how to convert <code>input_ids</code> indices into associated vectors than the
model&#x2019;s internal embedding lookup matrix.</p>
<p>If <code>past_key_values</code> is used, optionally only the last <code>inputs_embeds</code> have to be input (see
<code>past_key_values</code>).`,name:"inputs_embeds"},{anchor:"transformers.ClvpDecoder.forward.use_cache",description:`<strong>use_cache</strong> (<code>bool</code>, <em>optional</em>) &#x2014;
If set to <code>True</code>, <code>past_key_values</code> key value states are returned and can be used to speed up decoding (see
<code>past_key_values</code>).`,name:"use_cache"},{anchor:"transformers.ClvpDecoder.forward.output_attentions",description:`<strong>output_attentions</strong> (<code>bool</code>, <em>optional</em>) &#x2014;
Whether or not to return the attentions tensors of all attention layers. See <code>attentions</code> under returned
tensors for more detail.`,name:"output_attentions"},{anchor:"transformers.ClvpDecoder.forward.output_hidden_states",description:`<strong>output_hidden_states</strong> (<code>bool</code>, <em>optional</em>) &#x2014;
Whether or not to return the hidden states of all layers. See <code>hidden_states</code> under returned tensors for
more detail.`,name:"output_hidden_states"},{anchor:"transformers.ClvpDecoder.forward.return_dict",description:`<strong>return_dict</strong> (<code>bool</code>, <em>optional</em>) &#x2014;
Whether or not to return a <a href="/docs/transformers/main/en/main_classes/output#transformers.utils.ModelOutput">ModelOutput</a> instead of a plain tuple.`,name:"return_dict"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/modeling_clvp.py#L1062"}}),_e=new go({props:{$$slots:{default:[ba]},$$scope:{ctx:w}}}),ht=new ia({props:{source:"https://github.com/huggingface/transformers/blob/main/docs/source/en/model_doc/clvp.md"}}),{c(){r=l("meta"),C=n(),p=l("p"),m=n(),f(y.$$.fragment),o=n(),T=l("div"),T.innerHTML=cs,_o=n(),f(Te.$$.fragment),vo=n(),Me=l("p"),Me.innerHTML=ps,bo=n(),ke=l("p"),ke.textContent=ms,yo=n(),we=l("p"),we.innerHTML=fs,Co=n(),xe=l("p"),xe.innerHTML=us,To=n(),f($e.$$.fragment),Mo=n(),je=l("ol"),je.innerHTML=hs,ko=n(),f(Je.$$.fragment),wo=n(),ze=l("ul"),ze.innerHTML=gs,xo=n(),Fe=l("p"),Fe.textContent=_s,$o=n(),f(Ee.$$.fragment),jo=n(),f(Ze.$$.fragment),Jo=n(),F=l("div"),f(Ie.$$.fragment),en=n(),Ct=l("p"),Ct.innerHTML=vs,tn=n(),Tt=l("p"),Tt.innerHTML=bs,on=n(),f(te.$$.fragment),nn=n(),oe=l("div"),f(Ue.$$.fragment),sn=n(),Mt=l("p"),Mt.innerHTML=ys,zo=n(),f(We.$$.fragment),Fo=n(),G=l("div"),f(Ge.$$.fragment),an=n(),kt=l("p"),kt.innerHTML=Cs,rn=n(),wt=l("p"),wt.innerHTML=Ts,ln=n(),f(ne.$$.fragment),Eo=n(),f(Be.$$.fragment),Zo=n(),E=l("div"),f(Ne.$$.fragment),dn=n(),xt=l("p"),xt.innerHTML=Ms,cn=n(),$t=l("p"),$t.innerHTML=ks,pn=n(),jt=l("p"),jt.textContent=ws,mn=n(),f(se.$$.fragment),Io=n(),f(Le.$$.fragment),Uo=n(),$=l("div"),f(Ve.$$.fragment),fn=n(),Jt=l("p"),Jt.textContent=xs,un=n(),zt=l("p"),zt.textContent=$s,hn=n(),f(ae.$$.fragment),gn=n(),Ft=l("p"),Ft.innerHTML=js,_n=n(),f(re.$$.fragment),vn=n(),Et=l("p"),Et.innerHTML=Js,bn=n(),Zt=l("div"),f(He.$$.fragment),Wo=n(),f(De.$$.fragment),Go=n(),Z=l("div"),f(qe.$$.fragment),yn=n(),It=l("p"),It.textContent=zs,Cn=n(),Ut=l("p"),Ut.innerHTML=Fs,Tn=n(),Wt=l("p"),Wt.innerHTML=Es,Mn=n(),Y=l("div"),f(Pe.$$.fragment),kn=n(),Gt=l("p"),Gt.innerHTML=Zs,wn=n(),Bt=l("p"),Bt.innerHTML=Is,Bo=n(),f(Xe.$$.fragment),No=n(),z=l("div"),f(Re.$$.fragment),xn=n(),Nt=l("p"),Nt.textContent=Us,$n=n(),Lt=l("p"),Lt.innerHTML=Ws,jn=n(),ie=l("div"),f(Ye.$$.fragment),Jn=n(),Vt=l("p"),Vt.innerHTML=Gs,zn=n(),le=l("div"),f(Qe.$$.fragment),Fn=n(),Ht=l("p"),Ht.innerHTML=Bs,En=n(),de=l("div"),f(Se.$$.fragment),Zn=n(),Dt=l("p"),Dt.innerHTML=Ns,Lo=n(),f(Oe.$$.fragment),Vo=n(),j=l("div"),f(Ae.$$.fragment),In=n(),qt=l("p"),qt.innerHTML=Ls,Un=n(),Pt=l("p"),Pt.innerHTML=Vs,Wn=n(),D=l("div"),f(Ke.$$.fragment),Gn=n(),Xt=l("p"),Xt.innerHTML=Hs,Bn=n(),f(ce.$$.fragment),Nn=n(),f(pe.$$.fragment),Ln=n(),me=l("div"),f(et.$$.fragment),Vn=n(),Rt=l("p"),Rt.innerHTML=Ds,Hn=n(),Q=l("div"),f(tt.$$.fragment),Dn=n(),Yt=l("p"),Yt.textContent=qs,qn=n(),f(fe.$$.fragment),Pn=n(),S=l("div"),f(ot.$$.fragment),Xn=n(),Qt=l("p"),Qt.textContent=Ps,Rn=n(),f(ue.$$.fragment),Ho=n(),f(nt.$$.fragment),Do=n(),B=l("div"),f(st.$$.fragment),Yn=n(),St=l("p"),St.innerHTML=Xs,Qn=n(),Ot=l("p"),Ot.innerHTML=Rs,Sn=n(),O=l("div"),f(at.$$.fragment),On=n(),At=l("p"),At.innerHTML=Ys,An=n(),f(he.$$.fragment),qo=n(),f(rt.$$.fragment),Po=n(),N=l("div"),f(it.$$.fragment),Kn=n(),Kt=l("p"),Kt.innerHTML=Qs,es=n(),eo=l("p"),eo.innerHTML=Ss,ts=n(),A=l("div"),f(lt.$$.fragment),os=n(),to=l("p"),to.innerHTML=Os,ns=n(),f(ge.$$.fragment),Xo=n(),f(dt.$$.fragment),Ro=n(),P=l("div"),f(ct.$$.fragment),ss=n(),oo=l("p"),oo.innerHTML=As,as=n(),no=l("div"),f(pt.$$.fragment),Yo=n(),f(mt.$$.fragment),Qo=n(),X=l("div"),f(ft.$$.fragment),rs=n(),so=l("p"),so.innerHTML=Ks,is=n(),K=l("div"),f(ut.$$.fragment),ls=n(),ao=l("p"),ao.innerHTML=ea,ds=n(),f(_e.$$.fragment),So=n(),f(ht.$$.fragment),Oo=n(),uo=l("p"),this.h()},l(e){const i=ra("svelte-u9bgzb",document.head);r=d(i,"META",{name:!0,content:!0}),i.forEach(a),C=s(e),p=d(e,"P",{}),k(p).forEach(a),m=s(e),u(y.$$.fragment,e),o=s(e),T=d(e,"DIV",{class:!0,"data-svelte-h":!0}),b(T)!=="svelte-13t8s2t"&&(T.innerHTML=cs),_o=s(e),u(Te.$$.fragment,e),vo=s(e),Me=d(e,"P",{"data-svelte-h":!0}),b(Me)!=="svelte-hsgi6a"&&(Me.innerHTML=ps),bo=s(e),ke=d(e,"P",{"data-svelte-h":!0}),b(ke)!=="svelte-vfdo9a"&&(ke.textContent=ms),yo=s(e),we=d(e,"P",{"data-svelte-h":!0}),b(we)!=="svelte-1io4mb1"&&(we.innerHTML=fs),Co=s(e),xe=d(e,"P",{"data-svelte-h":!0}),b(xe)!=="svelte-4bcqbf"&&(xe.innerHTML=us),To=s(e),u($e.$$.fragment,e),Mo=s(e),je=d(e,"OL",{"data-svelte-h":!0}),b(je)!=="svelte-1m39cyt"&&(je.innerHTML=hs),ko=s(e),u(Je.$$.fragment,e),wo=s(e),ze=d(e,"UL",{"data-svelte-h":!0}),b(ze)!=="svelte-xm54ps"&&(ze.innerHTML=gs),xo=s(e),Fe=d(e,"P",{"data-svelte-h":!0}),b(Fe)!=="svelte-12pxzug"&&(Fe.textContent=_s),$o=s(e),u(Ee.$$.fragment,e),jo=s(e),u(Ze.$$.fragment,e),Jo=s(e),F=d(e,"DIV",{class:!0});var L=k(F);u(Ie.$$.fragment,L),en=s(L),Ct=d(L,"P",{"data-svelte-h":!0}),b(Ct)!=="svelte-1xsxtze"&&(Ct.innerHTML=vs),tn=s(L),Tt=d(L,"P",{"data-svelte-h":!0}),b(Tt)!=="svelte-o55m63"&&(Tt.innerHTML=bs),on=s(L),u(te.$$.fragment,L),nn=s(L),oe=d(L,"DIV",{class:!0});var gt=k(oe);u(Ue.$$.fragment,gt),sn=s(gt),Mt=d(gt,"P",{"data-svelte-h":!0}),b(Mt)!=="svelte-147s9qv"&&(Mt.innerHTML=ys),gt.forEach(a),L.forEach(a),zo=s(e),u(We.$$.fragment,e),Fo=s(e),G=d(e,"DIV",{class:!0});var R=k(G);u(Ge.$$.fragment,R),an=s(R),kt=d(R,"P",{"data-svelte-h":!0}),b(kt)!=="svelte-9u7dqp"&&(kt.innerHTML=Cs),rn=s(R),wt=d(R,"P",{"data-svelte-h":!0}),b(wt)!=="svelte-o55m63"&&(wt.innerHTML=Ts),ln=s(R),u(ne.$$.fragment,R),R.forEach(a),Eo=s(e),u(Be.$$.fragment,e),Zo=s(e),E=d(e,"DIV",{class:!0});var V=k(E);u(Ne.$$.fragment,V),dn=s(V),xt=d(V,"P",{"data-svelte-h":!0}),b(xt)!=="svelte-au4l01"&&(xt.innerHTML=Ms),cn=s(V),$t=d(V,"P",{"data-svelte-h":!0}),b($t)!=="svelte-o55m63"&&($t.innerHTML=ks),pn=s(V),jt=d(V,"P",{"data-svelte-h":!0}),b(jt)!=="svelte-18r2yl3"&&(jt.textContent=ws),mn=s(V),u(se.$$.fragment,V),V.forEach(a),Io=s(e),u(Le.$$.fragment,e),Uo=s(e),$=d(e,"DIV",{class:!0});var J=k($);u(Ve.$$.fragment,J),fn=s(J),Jt=d(J,"P",{"data-svelte-h":!0}),b(Jt)!=="svelte-dtdgzo"&&(Jt.textContent=xs),un=s(J),zt=d(J,"P",{"data-svelte-h":!0}),b(zt)!=="svelte-1s077p3"&&(zt.textContent=$s),hn=s(J),u(ae.$$.fragment,J),gn=s(J),Ft=d(J,"P",{"data-svelte-h":!0}),b(Ft)!=="svelte-1jfcabo"&&(Ft.innerHTML=js),_n=s(J),u(re.$$.fragment,J),vn=s(J),Et=d(J,"P",{"data-svelte-h":!0}),b(Et)!=="svelte-1c3t5ty"&&(Et.innerHTML=Js),bn=s(J),Zt=d(J,"DIV",{class:!0});var ho=k(Zt);u(He.$$.fragment,ho),ho.forEach(a),J.forEach(a),Wo=s(e),u(De.$$.fragment,e),Go=s(e),Z=d(e,"DIV",{class:!0});var H=k(Z);u(qe.$$.fragment,H),yn=s(H),It=d(H,"P",{"data-svelte-h":!0}),b(It)!=="svelte-4dw9vm"&&(It.textContent=zs),Cn=s(H),Ut=d(H,"P",{"data-svelte-h":!0}),b(Ut)!=="svelte-3gz575"&&(Ut.innerHTML=Fs),Tn=s(H),Wt=d(H,"P",{"data-svelte-h":!0}),b(Wt)!=="svelte-1z3w69"&&(Wt.innerHTML=Es),Mn=s(H),Y=d(H,"DIV",{class:!0});var ee=k(Y);u(Pe.$$.fragment,ee),kn=s(ee),Gt=d(ee,"P",{"data-svelte-h":!0}),b(Gt)!=="svelte-3nm4pm"&&(Gt.innerHTML=Zs),wn=s(ee),Bt=d(ee,"P",{"data-svelte-h":!0}),b(Bt)!=="svelte-11lzm20"&&(Bt.innerHTML=Is),ee.forEach(a),H.forEach(a),Bo=s(e),u(Xe.$$.fragment,e),No=s(e),z=d(e,"DIV",{class:!0});var I=k(z);u(Re.$$.fragment,I),xn=s(I),Nt=d(I,"P",{"data-svelte-h":!0}),b(Nt)!=="svelte-14s26xb"&&(Nt.textContent=Us),$n=s(I),Lt=d(I,"P",{"data-svelte-h":!0}),b(Lt)!=="svelte-14u9hwi"&&(Lt.innerHTML=Ws),jn=s(I),ie=d(I,"DIV",{class:!0});var _t=k(ie);u(Ye.$$.fragment,_t),Jn=s(_t),Vt=d(_t,"P",{"data-svelte-h":!0}),b(Vt)!=="svelte-1wrgp3p"&&(Vt.innerHTML=Gs),_t.forEach(a),zn=s(I),le=d(I,"DIV",{class:!0});var vt=k(le);u(Qe.$$.fragment,vt),Fn=s(vt),Ht=d(vt,"P",{"data-svelte-h":!0}),b(Ht)!=="svelte-8jzq9o"&&(Ht.innerHTML=Bs),vt.forEach(a),En=s(I),de=d(I,"DIV",{class:!0});var bt=k(de);u(Se.$$.fragment,bt),Zn=s(bt),Dt=d(bt,"P",{"data-svelte-h":!0}),b(Dt)!=="svelte-1pkr46"&&(Dt.innerHTML=Ns),bt.forEach(a),I.forEach(a),Lo=s(e),u(Oe.$$.fragment,e),Vo=s(e),j=d(e,"DIV",{class:!0});var W=k(j);u(Ae.$$.fragment,W),In=s(W),qt=d(W,"P",{"data-svelte-h":!0}),b(qt)!=="svelte-10372mp"&&(qt.innerHTML=Ls),Un=s(W),Pt=d(W,"P",{"data-svelte-h":!0}),b(Pt)!=="svelte-hswkmf"&&(Pt.innerHTML=Vs),Wn=s(W),D=d(W,"DIV",{class:!0});var ve=k(D);u(Ke.$$.fragment,ve),Gn=s(ve),Xt=d(ve,"P",{"data-svelte-h":!0}),b(Xt)!=="svelte-csozb4"&&(Xt.innerHTML=Hs),Bn=s(ve),u(ce.$$.fragment,ve),Nn=s(ve),u(pe.$$.fragment,ve),ve.forEach(a),Ln=s(W),me=d(W,"DIV",{class:!0});var Ko=k(me);u(et.$$.fragment,Ko),Vn=s(Ko),Rt=d(Ko,"P",{"data-svelte-h":!0}),b(Rt)!=="svelte-11sygp1"&&(Rt.innerHTML=Ds),Ko.forEach(a),Hn=s(W),Q=d(W,"DIV",{class:!0});var ro=k(Q);u(tt.$$.fragment,ro),Dn=s(ro),Yt=d(ro,"P",{"data-svelte-h":!0}),b(Yt)!=="svelte-1gkgya2"&&(Yt.textContent=qs),qn=s(ro),u(fe.$$.fragment,ro),ro.forEach(a),Pn=s(W),S=d(W,"DIV",{class:!0});var io=k(S);u(ot.$$.fragment,io),Xn=s(io),Qt=d(io,"P",{"data-svelte-h":!0}),b(Qt)!=="svelte-10cw2ku"&&(Qt.textContent=Ps),Rn=s(io),u(ue.$$.fragment,io),io.forEach(a),W.forEach(a),Ho=s(e),u(nt.$$.fragment,e),Do=s(e),B=d(e,"DIV",{class:!0});var be=k(B);u(st.$$.fragment,be),Yn=s(be),St=d(be,"P",{"data-svelte-h":!0}),b(St)!=="svelte-1db7k6x"&&(St.innerHTML=Xs),Qn=s(be),Ot=d(be,"P",{"data-svelte-h":!0}),b(Ot)!=="svelte-hswkmf"&&(Ot.innerHTML=Rs),Sn=s(be),O=d(be,"DIV",{class:!0});var lo=k(O);u(at.$$.fragment,lo),On=s(lo),At=d(lo,"P",{"data-svelte-h":!0}),b(At)!=="svelte-x6vtps"&&(At.innerHTML=Ys),An=s(lo),u(he.$$.fragment,lo),lo.forEach(a),be.forEach(a),qo=s(e),u(rt.$$.fragment,e),Po=s(e),N=d(e,"DIV",{class:!0});var ye=k(N);u(it.$$.fragment,ye),Kn=s(ye),Kt=d(ye,"P",{"data-svelte-h":!0}),b(Kt)!=="svelte-a6gzib"&&(Kt.innerHTML=Qs),es=s(ye),eo=d(ye,"P",{"data-svelte-h":!0}),b(eo)!=="svelte-hswkmf"&&(eo.innerHTML=Ss),ts=s(ye),A=d(ye,"DIV",{class:!0});var co=k(A);u(lt.$$.fragment,co),os=s(co),to=d(co,"P",{"data-svelte-h":!0}),b(to)!=="svelte-1szwxvk"&&(to.innerHTML=Os),ns=s(co),u(ge.$$.fragment,co),co.forEach(a),ye.forEach(a),Xo=s(e),u(dt.$$.fragment,e),Ro=s(e),P=d(e,"DIV",{class:!0});var po=k(P);u(ct.$$.fragment,po),ss=s(po),oo=d(po,"P",{"data-svelte-h":!0}),b(oo)!=="svelte-sugv3q"&&(oo.innerHTML=As),as=s(po),no=d(po,"DIV",{class:!0});var ta=k(no);u(pt.$$.fragment,ta),ta.forEach(a),po.forEach(a),Yo=s(e),u(mt.$$.fragment,e),Qo=s(e),X=d(e,"DIV",{class:!0});var mo=k(X);u(ft.$$.fragment,mo),rs=s(mo),so=d(mo,"P",{"data-svelte-h":!0}),b(so)!=="svelte-1yztecs"&&(so.innerHTML=Ks),is=s(mo),K=d(mo,"DIV",{class:!0});var fo=k(K);u(ut.$$.fragment,fo),ls=s(fo),ao=d(fo,"P",{"data-svelte-h":!0}),b(ao)!=="svelte-1ypwjpw"&&(ao.innerHTML=ea),ds=s(fo),u(_e.$$.fragment,fo),fo.forEach(a),mo.forEach(a),So=s(e),u(ht.$$.fragment,e),Oo=s(e),uo=d(e,"P",{}),k(uo).forEach(a),this.h()},h(){M(r,"name","hf:doc:metadata"),M(r,"content",Ca),M(T,"class","flex flex-wrap space-x-1"),M(oe,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),M(F,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),M(G,"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,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),M(Zt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),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(Y,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),M(Z,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),M(ie,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),M(le,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),M(de,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),M(z,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),M(D,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),M(me,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),M(Q,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),M(S,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),M(j,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),M(O,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),M(B,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),M(A,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),M(N,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),M(no,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),M(P,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),M(K,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),M(X,"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,i){t(document.head,r),c(e,C,i),c(e,p,i),c(e,m,i),h(y,e,i),c(e,o,i),c(e,T,i),c(e,_o,i),h(Te,e,i),c(e,vo,i),c(e,Me,i),c(e,bo,i),c(e,ke,i),c(e,yo,i),c(e,we,i),c(e,Co,i),c(e,xe,i),c(e,To,i),h($e,e,i),c(e,Mo,i),c(e,je,i),c(e,ko,i),h(Je,e,i),c(e,wo,i),c(e,ze,i),c(e,xo,i),c(e,Fe,i),c(e,$o,i),h(Ee,e,i),c(e,jo,i),h(Ze,e,i),c(e,Jo,i),c(e,F,i),h(Ie,F,null),t(F,en),t(F,Ct),t(F,tn),t(F,Tt),t(F,on),h(te,F,null),t(F,nn),t(F,oe),h(Ue,oe,null),t(oe,sn),t(oe,Mt),c(e,zo,i),h(We,e,i),c(e,Fo,i),c(e,G,i),h(Ge,G,null),t(G,an),t(G,kt),t(G,rn),t(G,wt),t(G,ln),h(ne,G,null),c(e,Eo,i),h(Be,e,i),c(e,Zo,i),c(e,E,i),h(Ne,E,null),t(E,dn),t(E,xt),t(E,cn),t(E,$t),t(E,pn),t(E,jt),t(E,mn),h(se,E,null),c(e,Io,i),h(Le,e,i),c(e,Uo,i),c(e,$,i),h(Ve,$,null),t($,fn),t($,Jt),t($,un),t($,zt),t($,hn),h(ae,$,null),t($,gn),t($,Ft),t($,_n),h(re,$,null),t($,vn),t($,Et),t($,bn),t($,Zt),h(He,Zt,null),c(e,Wo,i),h(De,e,i),c(e,Go,i),c(e,Z,i),h(qe,Z,null),t(Z,yn),t(Z,It),t(Z,Cn),t(Z,Ut),t(Z,Tn),t(Z,Wt),t(Z,Mn),t(Z,Y),h(Pe,Y,null),t(Y,kn),t(Y,Gt),t(Y,wn),t(Y,Bt),c(e,Bo,i),h(Xe,e,i),c(e,No,i),c(e,z,i),h(Re,z,null),t(z,xn),t(z,Nt),t(z,$n),t(z,Lt),t(z,jn),t(z,ie),h(Ye,ie,null),t(ie,Jn),t(ie,Vt),t(z,zn),t(z,le),h(Qe,le,null),t(le,Fn),t(le,Ht),t(z,En),t(z,de),h(Se,de,null),t(de,Zn),t(de,Dt),c(e,Lo,i),h(Oe,e,i),c(e,Vo,i),c(e,j,i),h(Ae,j,null),t(j,In),t(j,qt),t(j,Un),t(j,Pt),t(j,Wn),t(j,D),h(Ke,D,null),t(D,Gn),t(D,Xt),t(D,Bn),h(ce,D,null),t(D,Nn),h(pe,D,null),t(j,Ln),t(j,me),h(et,me,null),t(me,Vn),t(me,Rt),t(j,Hn),t(j,Q),h(tt,Q,null),t(Q,Dn),t(Q,Yt),t(Q,qn),h(fe,Q,null),t(j,Pn),t(j,S),h(ot,S,null),t(S,Xn),t(S,Qt),t(S,Rn),h(ue,S,null),c(e,Ho,i),h(nt,e,i),c(e,Do,i),c(e,B,i),h(st,B,null),t(B,Yn),t(B,St),t(B,Qn),t(B,Ot),t(B,Sn),t(B,O),h(at,O,null),t(O,On),t(O,At),t(O,An),h(he,O,null),c(e,qo,i),h(rt,e,i),c(e,Po,i),c(e,N,i),h(it,N,null),t(N,Kn),t(N,Kt),t(N,es),t(N,eo),t(N,ts),t(N,A),h(lt,A,null),t(A,os),t(A,to),t(A,ns),h(ge,A,null),c(e,Xo,i),h(dt,e,i),c(e,Ro,i),c(e,P,i),h(ct,P,null),t(P,ss),t(P,oo),t(P,as),t(P,no),h(pt,no,null),c(e,Yo,i),h(mt,e,i),c(e,Qo,i),c(e,X,i),h(ft,X,null),t(X,rs),t(X,so),t(X,is),t(X,K),h(ut,K,null),t(K,ls),t(K,ao),t(K,ds),h(_e,K,null),c(e,So,i),h(ht,e,i),c(e,Oo,i),c(e,uo,i),Ao=!0},p(e,[i]){const L={};i&2&&(L.$$scope={dirty:i,ctx:e}),te.$set(L);const gt={};i&2&&(gt.$$scope={dirty:i,ctx:e}),ne.$set(gt);const R={};i&2&&(R.$$scope={dirty:i,ctx:e}),se.$set(R);const V={};i&2&&(V.$$scope={dirty:i,ctx:e}),ae.$set(V);const J={};i&2&&(J.$$scope={dirty:i,ctx:e}),re.$set(J);const ho={};i&2&&(ho.$$scope={dirty:i,ctx:e}),ce.$set(ho);const H={};i&2&&(H.$$scope={dirty:i,ctx:e}),pe.$set(H);const ee={};i&2&&(ee.$$scope={dirty:i,ctx:e}),fe.$set(ee);const I={};i&2&&(I.$$scope={dirty:i,ctx:e}),ue.$set(I);const _t={};i&2&&(_t.$$scope={dirty:i,ctx:e}),he.$set(_t);const vt={};i&2&&(vt.$$scope={dirty:i,ctx:e}),ge.$set(vt);const bt={};i&2&&(bt.$$scope={dirty:i,ctx:e}),_e.$set(bt)},i(e){Ao||(g(y.$$.fragment,e),g(Te.$$.fragment,e),g($e.$$.fragment,e),g(Je.$$.fragment,e),g(Ee.$$.fragment,e),g(Ze.$$.fragment,e),g(Ie.$$.fragment,e),g(te.$$.fragment,e),g(Ue.$$.fragment,e),g(We.$$.fragment,e),g(Ge.$$.fragment,e),g(ne.$$.fragment,e),g(Be.$$.fragment,e),g(Ne.$$.fragment,e),g(se.$$.fragment,e),g(Le.$$.fragment,e),g(Ve.$$.fragment,e),g(ae.$$.fragment,e),g(re.$$.fragment,e),g(He.$$.fragment,e),g(De.$$.fragment,e),g(qe.$$.fragment,e),g(Pe.$$.fragment,e),g(Xe.$$.fragment,e),g(Re.$$.fragment,e),g(Ye.$$.fragment,e),g(Qe.$$.fragment,e),g(Se.$$.fragment,e),g(Oe.$$.fragment,e),g(Ae.$$.fragment,e),g(Ke.$$.fragment,e),g(ce.$$.fragment,e),g(pe.$$.fragment,e),g(et.$$.fragment,e),g(tt.$$.fragment,e),g(fe.$$.fragment,e),g(ot.$$.fragment,e),g(ue.$$.fragment,e),g(nt.$$.fragment,e),g(st.$$.fragment,e),g(at.$$.fragment,e),g(he.$$.fragment,e),g(rt.$$.fragment,e),g(it.$$.fragment,e),g(lt.$$.fragment,e),g(ge.$$.fragment,e),g(dt.$$.fragment,e),g(ct.$$.fragment,e),g(pt.$$.fragment,e),g(mt.$$.fragment,e),g(ft.$$.fragment,e),g(ut.$$.fragment,e),g(_e.$$.fragment,e),g(ht.$$.fragment,e),Ao=!0)},o(e){_(y.$$.fragment,e),_(Te.$$.fragment,e),_($e.$$.fragment,e),_(Je.$$.fragment,e),_(Ee.$$.fragment,e),_(Ze.$$.fragment,e),_(Ie.$$.fragment,e),_(te.$$.fragment,e),_(Ue.$$.fragment,e),_(We.$$.fragment,e),_(Ge.$$.fragment,e),_(ne.$$.fragment,e),_(Be.$$.fragment,e),_(Ne.$$.fragment,e),_(se.$$.fragment,e),_(Le.$$.fragment,e),_(Ve.$$.fragment,e),_(ae.$$.fragment,e),_(re.$$.fragment,e),_(He.$$.fragment,e),_(De.$$.fragment,e),_(qe.$$.fragment,e),_(Pe.$$.fragment,e),_(Xe.$$.fragment,e),_(Re.$$.fragment,e),_(Ye.$$.fragment,e),_(Qe.$$.fragment,e),_(Se.$$.fragment,e),_(Oe.$$.fragment,e),_(Ae.$$.fragment,e),_(Ke.$$.fragment,e),_(ce.$$.fragment,e),_(pe.$$.fragment,e),_(et.$$.fragment,e),_(tt.$$.fragment,e),_(fe.$$.fragment,e),_(ot.$$.fragment,e),_(ue.$$.fragment,e),_(nt.$$.fragment,e),_(st.$$.fragment,e),_(at.$$.fragment,e),_(he.$$.fragment,e),_(rt.$$.fragment,e),_(it.$$.fragment,e),_(lt.$$.fragment,e),_(ge.$$.fragment,e),_(dt.$$.fragment,e),_(ct.$$.fragment,e),_(pt.$$.fragment,e),_(mt.$$.fragment,e),_(ft.$$.fragment,e),_(ut.$$.fragment,e),_(_e.$$.fragment,e),_(ht.$$.fragment,e),Ao=!1},d(e){e&&(a(C),a(p),a(m),a(o),a(T),a(_o),a(vo),a(Me),a(bo),a(ke),a(yo),a(we),a(Co),a(xe),a(To),a(Mo),a(je),a(ko),a(wo),a(ze),a(xo),a(Fe),a($o),a(jo),a(Jo),a(F),a(zo),a(Fo),a(G),a(Eo),a(Zo),a(E),a(Io),a(Uo),a($),a(Wo),a(Go),a(Z),a(Bo),a(No),a(z),a(Lo),a(Vo),a(j),a(Ho),a(Do),a(B),a(qo),a(Po),a(N),a(Xo),a(Ro),a(P),a(Yo),a(Qo),a(X),a(So),a(Oo),a(uo)),a(r),v(y,e),v(Te,e),v($e,e),v(Je,e),v(Ee,e),v(Ze,e),v(Ie),v(te),v(Ue),v(We,e),v(Ge),v(ne),v(Be,e),v(Ne),v(se),v(Le,e),v(Ve),v(ae),v(re),v(He),v(De,e),v(qe),v(Pe),v(Xe,e),v(Re),v(Ye),v(Qe),v(Se),v(Oe,e),v(Ae),v(Ke),v(ce),v(pe),v(et),v(tt),v(fe),v(ot),v(ue),v(nt,e),v(st),v(at),v(he),v(rt,e),v(it),v(lt),v(ge),v(dt,e),v(ct),v(pt),v(mt,e),v(ft),v(ut),v(_e),v(ht,e)}}}const Ca='{"title":"CLVP","local":"clvp","sections":[{"title":"Overview","local":"overview","sections":[],"depth":2},{"title":"Usage tips","local":"usage-tips","sections":[],"depth":2},{"title":"Brief Explanation:","local":"brief-explanation","sections":[],"depth":2},{"title":"ClvpConfig","local":"transformers.ClvpConfig","sections":[],"depth":2},{"title":"ClvpEncoderConfig","local":"transformers.ClvpEncoderConfig","sections":[],"depth":2},{"title":"ClvpDecoderConfig","local":"transformers.ClvpDecoderConfig","sections":[],"depth":2},{"title":"ClvpTokenizer","local":"transformers.ClvpTokenizer","sections":[],"depth":2},{"title":"ClvpFeatureExtractor","local":"transformers.ClvpFeatureExtractor","sections":[],"depth":2},{"title":"ClvpProcessor","local":"transformers.ClvpProcessor","sections":[],"depth":2},{"title":"ClvpModelForConditionalGeneration","local":"transformers.ClvpModelForConditionalGeneration","sections":[],"depth":2},{"title":"ClvpForCausalLM","local":"transformers.ClvpForCausalLM","sections":[],"depth":2},{"title":"ClvpModel","local":"transformers.ClvpModel","sections":[],"depth":2},{"title":"ClvpEncoder","local":"transformers.ClvpEncoder","sections":[],"depth":2},{"title":"ClvpDecoder","local":"transformers.ClvpDecoder","sections":[],"depth":2}],"depth":1}';function Ta(w){return na(()=>{new URLSearchParams(window.location.search).get("fw")}),[]}class za extends sa{constructor(r){super(),aa(this,r,Ta,ya,oa,{})}}export{za as component};
