import{S as jr,i as $r,s as Ir,e as r,k as p,w as y,t as n,M as Cr,c as a,d as o,m,a as i,x as b,h as s,b as c,G as t,g as d,y as v,q as w,o as T,B as k,v as Nr,L as Ur}from"../../chunks/vendor-hf-doc-builder.js";import{T as Wr}from"../../chunks/Tip-hf-doc-builder.js";import{D as at}from"../../chunks/Docstring-hf-doc-builder.js";import{C as me}from"../../chunks/CodeBlock-hf-doc-builder.js";import{I as it}from"../../chunks/IconCopyLink-hf-doc-builder.js";import{E as Er}from"../../chunks/ExampleCodeBlock-hf-doc-builder.js";function Zr(G){let u,V,g,f,M;return f=new me({props:{code:"ZnJvbSUyMHRyYW5zZm9ybWVycyUyMGltcG9ydCUyMFZpdHNNb2RlbCUyQyUyMFZpdHNDb25maWclMEElMEElMjMlMjBJbml0aWFsaXppbmclMjBhJTIwJTIyZmFjZWJvb2slMkZtbXMtdHRzLWVuZyUyMiUyMHN0eWxlJTIwY29uZmlndXJhdGlvbiUwQWNvbmZpZ3VyYXRpb24lMjAlM0QlMjBWaXRzQ29uZmlnKCklMEElMEElMjMlMjBJbml0aWFsaXppbmclMjBhJTIwbW9kZWwlMjAod2l0aCUyMHJhbmRvbSUyMHdlaWdodHMpJTIwZnJvbSUyMHRoZSUyMCUyMmZhY2Vib29rJTJGbW1zLXR0cy1lbmclMjIlMjBzdHlsZSUyMGNvbmZpZ3VyYXRpb24lMEFtb2RlbCUyMCUzRCUyMFZpdHNNb2RlbChjb25maWd1cmF0aW9uKSUwQSUwQSUyMyUyMEFjY2Vzc2luZyUyMHRoZSUyMG1vZGVsJTIwY29uZmlndXJhdGlvbiUwQWNvbmZpZ3VyYXRpb24lMjAlM0QlMjBtb2RlbC5jb25maWc=",highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> VitsModel, VitsConfig

<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-comment"># Initializing a &quot;facebook/mms-tts-eng&quot; style configuration</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>configuration = VitsConfig()

<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-comment"># Initializing a model (with random weights) from the &quot;facebook/mms-tts-eng&quot; style configuration</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>model = VitsModel(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`}}),{c(){u=r("p"),V=n("Example:"),g=p(),y(f.$$.fragment)},l(h){u=a(h,"P",{});var _=i(u);V=s(_,"Example:"),_.forEach(o),g=m(h),b(f.$$.fragment,h)},m(h,_){d(h,u,_),t(u,V),d(h,g,_),v(f,h,_),M=!0},p:Ur,i(h){M||(w(f.$$.fragment,h),M=!0)},o(h){T(f.$$.fragment,h),M=!1},d(h){h&&o(u),h&&o(g),k(f,h)}}}function Rr(G){let u,V,g,f,M;return{c(){u=r("p"),V=n("Although the recipe for forward pass needs to be defined within this function, one should call the "),g=r("code"),f=n("Module"),M=n(`
instance afterwards instead of this since the former takes care of running the pre and post processing steps while
the latter silently ignores them.`)},l(h){u=a(h,"P",{});var _=i(u);V=s(_,"Although the recipe for forward pass needs to be defined within this function, one should call the "),g=a(_,"CODE",{});var H=i(g);f=s(H,"Module"),H.forEach(o),M=s(_,`
instance afterwards instead of this since the former takes care of running the pre and post processing steps while
the latter silently ignores them.`),_.forEach(o)},m(h,_){d(h,u,_),t(u,V),t(u,g),t(g,f),t(u,M)},d(h){h&&o(u)}}}function Sr(G){let u,V,g,f,M;return f=new me({props:{code:"ZnJvbSUyMHRyYW5zZm9ybWVycyUyMGltcG9ydCUyMFZpdHNUb2tlbml6ZXIlMkMlMjBWaXRzTW9kZWwlMkMlMjBzZXRfc2VlZCUwQWltcG9ydCUyMHRvcmNoJTBBJTBBdG9rZW5pemVyJTIwJTNEJTIwVml0c1Rva2VuaXplci5mcm9tX3ByZXRyYWluZWQoJTIyZmFjZWJvb2slMkZtbXMtdHRzLWVuZyUyMiklMEFtb2RlbCUyMCUzRCUyMFZpdHNNb2RlbC5mcm9tX3ByZXRyYWluZWQoJTIyZmFjZWJvb2slMkZtbXMtdHRzLWVuZyUyMiklMEElMEFpbnB1dHMlMjAlM0QlMjB0b2tlbml6ZXIodGV4dCUzRCUyMkhlbGxvJTIwLSUyMG15JTIwZG9nJTIwaXMlMjBjdXRlJTIyJTJDJTIwcmV0dXJuX3RlbnNvcnMlM0QlMjJwdCUyMiklMEElMEFzZXRfc2VlZCg1NTUpJTIwJTIwJTIzJTIwbWFrZSUyMGRldGVybWluaXN0aWMlMEElMEF3aXRoJTIwdG9yY2gubm9fZ3JhZCgpJTNBJTBBJTIwJTIwJTIwJTIwb3V0cHV0cyUyMCUzRCUyMG1vZGVsKGlucHV0cyU1QiUyMmlucHV0X2lkcyUyMiU1RCklMEFvdXRwdXRzLndhdmVmb3JtLnNoYXBl",highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> VitsTokenizer, VitsModel, set_seed
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">import</span> torch

<span class="hljs-meta">&gt;&gt;&gt; </span>tokenizer = VitsTokenizer.from_pretrained(<span class="hljs-string">&quot;facebook/mms-tts-eng&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>model = VitsModel.from_pretrained(<span class="hljs-string">&quot;facebook/mms-tts-eng&quot;</span>)

<span class="hljs-meta">&gt;&gt;&gt; </span>inputs = tokenizer(text=<span class="hljs-string">&quot;Hello - my dog is cute&quot;</span>, return_tensors=<span class="hljs-string">&quot;pt&quot;</span>)

<span class="hljs-meta">&gt;&gt;&gt; </span>set_seed(<span class="hljs-number">555</span>)  <span class="hljs-comment"># make deterministic</span>

<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">with</span> torch.no_grad():
<span class="hljs-meta">... </span>    outputs = model(inputs[<span class="hljs-string">&quot;input_ids&quot;</span>])
<span class="hljs-meta">&gt;&gt;&gt; </span>outputs.waveform.shape
torch.Size([<span class="hljs-number">1</span>, <span class="hljs-number">45824</span>])`}}),{c(){u=r("p"),V=n("Example:"),g=p(),y(f.$$.fragment)},l(h){u=a(h,"P",{});var _=i(u);V=s(_,"Example:"),_.forEach(o),g=m(h),b(f.$$.fragment,h)},m(h,_){d(h,u,_),t(u,V),d(h,g,_),v(f,h,_),M=!0},p:Ur,i(h){M||(w(f.$$.fragment,h),M=!0)},o(h){T(f.$$.fragment,h),M=!1},d(h){h&&o(u),h&&o(g),k(f,h)}}}function qr(G){let u,V,g,f,M,h,_,H,Uo,Rt,Z,P,lt,he,jo,dt,$o,St,Q,Io,ue,Co,No,qt,J,Wo,ct,Zo,Ro,pt,So,qo,mt,Fo,Xo,ht,Ao,Bo,Ft,Xe,Go,Xt,Ae,Ho,At,Be,Po,Bt,Ge,ut,Qo,Gt,L,Lo,fe,Yo,Do,Ht,U,Oo,ge,Ko,en,_e,tn,on,ye,nn,sn,Pt,R,Y,ft,be,rn,gt,an,Qt,He,ln,Lt,ve,Yt,D,dn,_t,cn,pn,Dt,we,Ot,Pe,mn,Kt,Te,eo,O,hn,ke,yt,un,fn,to,j,gn,bt,_n,yn,vt,bn,vn,wt,wn,Tn,oo,Me,no,I,kn,Tt,Mn,Vn,kt,zn,Jn,so,K,xn,Mt,En,Un,ro,Ve,ao,C,jn,Vt,$n,In,zt,Cn,Nn,io,ze,lo,S,ee,Jt,Je,Wn,xt,Zn,co,x,xe,Rn,q,Sn,Qe,qn,Fn,Ee,Xn,An,Bn,F,Gn,Le,Hn,Pn,Ye,Qn,Ln,Yn,te,po,X,oe,Et,Ue,Dn,Ut,On,mo,z,je,Kn,jt,es,ts,$e,os,De,ns,ss,rs,ne,Ie,as,$t,is,ls,Oe,Ce,ho,A,se,It,Ne,ds,Ct,cs,uo,E,We,ps,Ze,ms,Ke,hs,us,fs,Re,gs,Se,_s,ys,bs,$,qe,vs,B,ws,et,Ts,ks,Nt,Ms,Vs,zs,re,Js,ae,fo;return h=new it({}),he=new it({}),be=new it({}),ve=new me({props:{code:"aW1wb3J0JTIwdG9yY2glMEFmcm9tJTIwdHJhbnNmb3JtZXJzJTIwaW1wb3J0JTIwVml0c1Rva2VuaXplciUyQyUyMFZpdHNNb2RlbCUyQyUyMHNldF9zZWVkJTBBJTBBdG9rZW5pemVyJTIwJTNEJTIwVml0c1Rva2VuaXplci5mcm9tX3ByZXRyYWluZWQoJTIyZmFjZWJvb2slMkZtbXMtdHRzLWVuZyUyMiklMEFtb2RlbCUyMCUzRCUyMFZpdHNNb2RlbC5mcm9tX3ByZXRyYWluZWQoJTIyZmFjZWJvb2slMkZtbXMtdHRzLWVuZyUyMiklMEElMEFpbnB1dHMlMjAlM0QlMjB0b2tlbml6ZXIodGV4dCUzRCUyMkhlbGxvJTIwLSUyMG15JTIwZG9nJTIwaXMlMjBjdXRlJTIyJTJDJTIwcmV0dXJuX3RlbnNvcnMlM0QlMjJwdCUyMiklMEElMEFzZXRfc2VlZCg1NTUpJTIwJTIwJTIzJTIwbWFrZSUyMGRldGVybWluaXN0aWMlMEElMEF3aXRoJTIwdG9yY2gubm9fZ3JhZCgpJTNBJTBBJTIwJTIwJTIwb3V0cHV0cyUyMCUzRCUyMG1vZGVsKCoqaW5wdXRzKSUwQSUwQXdhdmVmb3JtJTIwJTNEJTIwb3V0cHV0cy53YXZlZm9ybSU1QjAlNUQ=",highlighted:`<span class="hljs-keyword">import</span> torch
<span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> VitsTokenizer, VitsModel, set_seed

tokenizer = VitsTokenizer.from_pretrained(<span class="hljs-string">&quot;facebook/mms-tts-eng&quot;</span>)
model = VitsModel.from_pretrained(<span class="hljs-string">&quot;facebook/mms-tts-eng&quot;</span>)

inputs = tokenizer(text=<span class="hljs-string">&quot;Hello - my dog is cute&quot;</span>, return_tensors=<span class="hljs-string">&quot;pt&quot;</span>)

set_seed(<span class="hljs-number">555</span>)  <span class="hljs-comment"># make deterministic</span>

<span class="hljs-keyword">with</span> torch.no_grad():
   outputs = model(**inputs)

waveform = outputs.waveform[<span class="hljs-number">0</span>]`}}),we=new me({props:{code:"aW1wb3J0JTIwc2NpcHklMEElMEFzY2lweS5pby53YXZmaWxlLndyaXRlKCUyMnRlY2huby53YXYlMjIlMkMlMjByYXRlJTNEbW9kZWwuY29uZmlnLnNhbXBsaW5nX3JhdGUlMkMlMjBkYXRhJTNEd2F2ZWZvcm0p",highlighted:`<span class="hljs-keyword">import</span> scipy

scipy.io.wavfile.write(<span class="hljs-string">&quot;techno.wav&quot;</span>, rate=model.config.sampling_rate, data=waveform)`}}),Te=new me({props:{code:"ZnJvbSUyMElQeXRob24uZGlzcGxheSUyMGltcG9ydCUyMEF1ZGlvJTBBJTBBQXVkaW8od2F2ZWZvcm0lMkMlMjByYXRlJTNEbW9kZWwuY29uZmlnLnNhbXBsaW5nX3JhdGUp",highlighted:`<span class="hljs-keyword">from</span> IPython.display <span class="hljs-keyword">import</span> Audio

Audio(waveform, rate=model.config.sampling_rate)`}}),Me=new me({props:{code:"ZnJvbSUyMHRyYW5zZm9ybWVycyUyMGltcG9ydCUyMFZpdHNUb2tlbml6ZXIlMEElMEF0b2tlbml6ZXIlMjAlM0QlMjBWaXRzVG9rZW5pemVyLmZyb21fcHJldHJhaW5lZCglMjJmYWNlYm9vayUyRm1tcy10dHMtZW5nJTIyKSUwQXByaW50KHRva2VuaXplci5pc191cm9tYW4p",highlighted:`<span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> VitsTokenizer

tokenizer = VitsTokenizer.from_pretrained(<span class="hljs-string">&quot;facebook/mms-tts-eng&quot;</span>)
<span class="hljs-built_in">print</span>(tokenizer.is_uroman)`}}),Ve=new me({props:{code:"Z2l0JTIwY2xvbmUlMjBodHRwcyUzQSUyRiUyRmdpdGh1Yi5jb20lMkZpc2ktbmxwJTJGdXJvbWFuLmdpdCUwQWNkJTIwdXJvbWFuJTBBZXhwb3J0JTIwVVJPTUFOJTNEJTI0KHB3ZCk=",highlighted:`git <span class="hljs-built_in">clone</span> https://github.com/isi-nlp/uroman.git
<span class="hljs-built_in">cd</span> uroman
<span class="hljs-built_in">export</span> UROMAN=$(<span class="hljs-built_in">pwd</span>)`}}),ze=new me({props:{code:"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",highlighted:`<span class="hljs-keyword">import</span> torch
<span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> VitsTokenizer, VitsModel, set_seed
<span class="hljs-keyword">import</span> os
<span class="hljs-keyword">import</span> subprocess

tokenizer = VitsTokenizer.from_pretrained(<span class="hljs-string">&quot;facebook/mms-tts-kor&quot;</span>)
model = VitsModel.from_pretrained(<span class="hljs-string">&quot;facebook/mms-tts-kor&quot;</span>)

<span class="hljs-keyword">def</span> <span class="hljs-title function_">uromanize</span>(<span class="hljs-params">input_string, uroman_path</span>):
    <span class="hljs-string">&quot;&quot;&quot;Convert non-Roman strings to Roman using the \`uroman\` perl package.&quot;&quot;&quot;</span>
    script_path = os.path.join(uroman_path, <span class="hljs-string">&quot;bin&quot;</span>, <span class="hljs-string">&quot;uroman.pl&quot;</span>)

    command = [<span class="hljs-string">&quot;perl&quot;</span>, script_path]

    process = subprocess.Popen(command, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
    <span class="hljs-comment"># Execute the perl command</span>
    stdout, stderr = process.communicate(<span class="hljs-built_in">input</span>=input_string.encode())

    <span class="hljs-keyword">if</span> process.returncode != <span class="hljs-number">0</span>:
        <span class="hljs-keyword">raise</span> ValueError(<span class="hljs-string">f&quot;Error <span class="hljs-subst">{process.returncode}</span>: <span class="hljs-subst">{stderr.decode()}</span>&quot;</span>)

    <span class="hljs-comment"># Return the output as a string and skip the new-line character at the end</span>
    <span class="hljs-keyword">return</span> stdout.decode()[:-<span class="hljs-number">1</span>]

text = <span class="hljs-string">&quot;\uC774\uBD10 \uBB34\uC2A8 \uC77C\uC774\uC57C&quot;</span>
uromaized_text = uromanize(text, uroman_path=os.environ[<span class="hljs-string">&quot;UROMAN&quot;</span>])

inputs = tokenizer(text=uromaized_text, return_tensors=<span class="hljs-string">&quot;pt&quot;</span>)

set_seed(<span class="hljs-number">555</span>)  <span class="hljs-comment"># make deterministic</span>
<span class="hljs-keyword">with</span> torch.no_grad():
   outputs = model(inputs[<span class="hljs-string">&quot;input_ids&quot;</span>])

waveform = outputs.waveform[<span class="hljs-number">0</span>]`}}),Je=new it({}),xe=new at({props:{name:"class transformers.VitsConfig",anchor:"transformers.VitsConfig",parameters:[{name:"vocab_size",val:" = 38"},{name:"hidden_size",val:" = 192"},{name:"num_hidden_layers",val:" = 6"},{name:"num_attention_heads",val:" = 2"},{name:"window_size",val:" = 4"},{name:"use_bias",val:" = True"},{name:"ffn_dim",val:" = 768"},{name:"layerdrop",val:" = 0.1"},{name:"ffn_kernel_size",val:" = 3"},{name:"flow_size",val:" = 192"},{name:"spectrogram_bins",val:" = 513"},{name:"hidden_act",val:" = 'relu'"},{name:"hidden_dropout",val:" = 0.1"},{name:"attention_dropout",val:" = 0.1"},{name:"activation_dropout",val:" = 0.1"},{name:"initializer_range",val:" = 0.02"},{name:"layer_norm_eps",val:" = 1e-05"},{name:"use_stochastic_duration_prediction",val:" = True"},{name:"num_speakers",val:" = 1"},{name:"speaker_embedding_size",val:" = 0"},{name:"upsample_initial_channel",val:" = 512"},{name:"upsample_rates",val:" = [8, 8, 2, 2]"},{name:"upsample_kernel_sizes",val:" = [16, 16, 4, 4]"},{name:"resblock_kernel_sizes",val:" = [3, 7, 11]"},{name:"resblock_dilation_sizes",val:" = [[1, 3, 5], [1, 3, 5], [1, 3, 5]]"},{name:"leaky_relu_slope",val:" = 0.1"},{name:"depth_separable_channels",val:" = 2"},{name:"depth_separable_num_layers",val:" = 3"},{name:"duration_predictor_flow_bins",val:" = 10"},{name:"duration_predictor_tail_bound",val:" = 5.0"},{name:"duration_predictor_kernel_size",val:" = 3"},{name:"duration_predictor_dropout",val:" = 0.5"},{name:"duration_predictor_num_flows",val:" = 4"},{name:"duration_predictor_filter_channels",val:" = 256"},{name:"prior_encoder_num_flows",val:" = 4"},{name:"prior_encoder_num_wavenet_layers",val:" = 4"},{name:"posterior_encoder_num_wavenet_layers",val:" = 16"},{name:"wavenet_kernel_size",val:" = 5"},{name:"wavenet_dilation_rate",val:" = 1"},{name:"wavenet_dropout",val:" = 0.0"},{name:"speaking_rate",val:" = 1.0"},{name:"noise_scale",val:" = 0.667"},{name:"noise_scale_duration",val:" = 0.8"},{name:"sampling_rate",val:" = 16000"},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"transformers.VitsConfig.vocab_size",description:`<strong>vocab_size</strong> (<code>int</code>, <em>optional</em>, defaults to 38) &#x2014;
Vocabulary size of the VITS model. Defines the number of different tokens that can be represented by the
<code>inputs_ids</code> passed to the forward method of <a href="/docs/transformers/v4.33.0/en/model_doc/vits#transformers.VitsModel">VitsModel</a>.`,name:"vocab_size"},{anchor:"transformers.VitsConfig.hidden_size",description:`<strong>hidden_size</strong> (<code>int</code>, <em>optional</em>, defaults to 192) &#x2014;
Dimensionality of the text encoder layers.`,name:"hidden_size"},{anchor:"transformers.VitsConfig.num_hidden_layers",description:`<strong>num_hidden_layers</strong> (<code>int</code>, <em>optional</em>, defaults to 6) &#x2014;
Number of hidden layers in the Transformer encoder.`,name:"num_hidden_layers"},{anchor:"transformers.VitsConfig.num_attention_heads",description:`<strong>num_attention_heads</strong> (<code>int</code>, <em>optional</em>, defaults to 2) &#x2014;
Number of attention heads for each attention layer in the Transformer encoder.`,name:"num_attention_heads"},{anchor:"transformers.VitsConfig.window_size",description:`<strong>window_size</strong> (<code>int</code>, <em>optional</em>, defaults to 4) &#x2014;
Window size for the relative positional embeddings in the attention layers of the Transformer encoder.`,name:"window_size"},{anchor:"transformers.VitsConfig.use_bias",description:`<strong>use_bias</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>True</code>) &#x2014;
Whether to use bias in the key, query, value projection layers in the Transformer encoder.`,name:"use_bias"},{anchor:"transformers.VitsConfig.ffn_dim",description:`<strong>ffn_dim</strong> (<code>int</code>, <em>optional</em>, defaults to 768) &#x2014;
Dimensionality of the &#x201C;intermediate&#x201D; (i.e., feed-forward) layer in the Transformer encoder.`,name:"ffn_dim"},{anchor:"transformers.VitsConfig.layerdrop",description:`<strong>layerdrop</strong> (<code>float</code>, <em>optional</em>, defaults to 0.1) &#x2014;
The LayerDrop probability for the encoder. See the [LayerDrop paper](see <a href="https://arxiv.org/abs/1909.11556" rel="nofollow">https://arxiv.org/abs/1909.11556</a>)
for more details.`,name:"layerdrop"},{anchor:"transformers.VitsConfig.ffn_kernel_size",description:`<strong>ffn_kernel_size</strong> (<code>int</code>, <em>optional</em>, defaults to 3) &#x2014;
Kernel size of the 1D convolution layers used by the feed-forward network in the Transformer encoder.`,name:"ffn_kernel_size"},{anchor:"transformers.VitsConfig.flow_size",description:`<strong>flow_size</strong> (<code>int</code>, <em>optional</em>, defaults to 192) &#x2014;
Dimensionality of the flow layers.`,name:"flow_size"},{anchor:"transformers.VitsConfig.spectrogram_bins",description:`<strong>spectrogram_bins</strong> (<code>int</code>, <em>optional</em>, defaults to 513) &#x2014;
Number of frequency bins in the target spectrogram.`,name:"spectrogram_bins"},{anchor:"transformers.VitsConfig.hidden_act",description:`<strong>hidden_act</strong> (<code>str</code> or <code>function</code>, <em>optional</em>, defaults to <code>&quot;relu&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> are supported.`,name:"hidden_act"},{anchor:"transformers.VitsConfig.hidden_dropout",description:`<strong>hidden_dropout</strong> (<code>float</code>, <em>optional</em>, defaults to 0.1) &#x2014;
The dropout probability for all fully connected layers in the embeddings and encoder.`,name:"hidden_dropout"},{anchor:"transformers.VitsConfig.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.VitsConfig.activation_dropout",description:`<strong>activation_dropout</strong> (<code>float</code>, <em>optional</em>, defaults to 0.1) &#x2014;
The dropout ratio for activations inside the fully connected layer.`,name:"activation_dropout"},{anchor:"transformers.VitsConfig.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.VitsConfig.layer_norm_eps",description:`<strong>layer_norm_eps</strong> (<code>float</code>, <em>optional</em>, defaults to 1e-5) &#x2014;
The epsilon used by the layer normalization layers.`,name:"layer_norm_eps"},{anchor:"transformers.VitsConfig.use_stochastic_duration_prediction",description:`<strong>use_stochastic_duration_prediction</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>True</code>) &#x2014;
Whether to use the stochastic duration prediction module or the regular duration predictor.`,name:"use_stochastic_duration_prediction"},{anchor:"transformers.VitsConfig.num_speakers",description:`<strong>num_speakers</strong> (<code>int</code>, <em>optional</em>, defaults to 1) &#x2014;
Number of speakers if this is a multi-speaker model.`,name:"num_speakers"},{anchor:"transformers.VitsConfig.speaker_embedding_size",description:`<strong>speaker_embedding_size</strong> (<code>int</code>, <em>optional</em>, defaults to 0) &#x2014;
Number of channels used by the speaker embeddings. Is zero for single-speaker models.`,name:"speaker_embedding_size"},{anchor:"transformers.VitsConfig.upsample_initial_channel",description:`<strong>upsample_initial_channel</strong> (<code>int</code>, <em>optional</em>, defaults to 512) &#x2014;
The number of input channels into the HiFi-GAN upsampling network.`,name:"upsample_initial_channel"},{anchor:"transformers.VitsConfig.upsample_rates",description:`<strong>upsample_rates</strong> (<code>Tuple[int]</code> or <code>List[int]</code>, <em>optional</em>, defaults to <code>[8, 8, 2, 2]</code>) &#x2014;
A tuple of integers defining the stride of each 1D convolutional layer in the HiFi-GAN upsampling network.
The length of <code>upsample_rates</code> defines the number of convolutional layers and has to match the length of
<code>upsample_kernel_sizes</code>.`,name:"upsample_rates"},{anchor:"transformers.VitsConfig.upsample_kernel_sizes",description:`<strong>upsample_kernel_sizes</strong> (<code>Tuple[int]</code> or <code>List[int]</code>, <em>optional</em>, defaults to <code>[16, 16, 4, 4]</code>) &#x2014;
A tuple of integers defining the kernel size of each 1D convolutional layer in the HiFi-GAN upsampling
network. The length of <code>upsample_kernel_sizes</code> defines the number of convolutional layers and has to match
the length of <code>upsample_rates</code>.`,name:"upsample_kernel_sizes"},{anchor:"transformers.VitsConfig.resblock_kernel_sizes",description:`<strong>resblock_kernel_sizes</strong> (<code>Tuple[int]</code> or <code>List[int]</code>, <em>optional</em>, defaults to <code>[3, 7, 11]</code>) &#x2014;
A tuple of integers defining the kernel sizes of the 1D convolutional layers in the HiFi-GAN
multi-receptive field fusion (MRF) module.`,name:"resblock_kernel_sizes"},{anchor:"transformers.VitsConfig.resblock_dilation_sizes",description:`<strong>resblock_dilation_sizes</strong> (<code>Tuple[Tuple[int]]</code> or <code>List[List[int]]</code>, <em>optional</em>, defaults to <code>[[1, 3, 5], [1, 3, 5], [1, 3, 5]]</code>) &#x2014;
A nested tuple of integers defining the dilation rates of the dilated 1D convolutional layers in the
HiFi-GAN multi-receptive field fusion (MRF) module.`,name:"resblock_dilation_sizes"},{anchor:"transformers.VitsConfig.leaky_relu_slope",description:`<strong>leaky_relu_slope</strong> (<code>float</code>, <em>optional</em>, defaults to 0.1) &#x2014;
The angle of the negative slope used by the leaky ReLU activation.`,name:"leaky_relu_slope"},{anchor:"transformers.VitsConfig.depth_separable_channels",description:`<strong>depth_separable_channels</strong> (<code>int</code>, <em>optional</em>, defaults to 2) &#x2014;
Number of channels to use in each depth-separable block.`,name:"depth_separable_channels"},{anchor:"transformers.VitsConfig.depth_separable_num_layers",description:`<strong>depth_separable_num_layers</strong> (<code>int</code>, <em>optional</em>, defaults to 3) &#x2014;
Number of convolutional layers to use in each depth-separable block.`,name:"depth_separable_num_layers"},{anchor:"transformers.VitsConfig.duration_predictor_flow_bins",description:`<strong>duration_predictor_flow_bins</strong> (<code>int</code>, <em>optional</em>, defaults to 10) &#x2014;
Number of channels to map using the unonstrained rational spline in the duration predictor model.`,name:"duration_predictor_flow_bins"},{anchor:"transformers.VitsConfig.duration_predictor_tail_bound",description:`<strong>duration_predictor_tail_bound</strong> (<code>float</code>, <em>optional</em>, defaults to 5.0) &#x2014;
Value of the tail bin boundary when computing the unconstrained rational spline in the duration predictor
model.`,name:"duration_predictor_tail_bound"},{anchor:"transformers.VitsConfig.duration_predictor_kernel_size",description:`<strong>duration_predictor_kernel_size</strong> (<code>int</code>, <em>optional</em>, defaults to 3) &#x2014;
Kernel size of the 1D convolution layers used in the duration predictor model.`,name:"duration_predictor_kernel_size"},{anchor:"transformers.VitsConfig.duration_predictor_dropout",description:`<strong>duration_predictor_dropout</strong> (<code>float</code>, <em>optional</em>, defaults to 0.5) &#x2014;
The dropout ratio for the duration predictor model.`,name:"duration_predictor_dropout"},{anchor:"transformers.VitsConfig.duration_predictor_num_flows",description:`<strong>duration_predictor_num_flows</strong> (<code>int</code>, <em>optional</em>, defaults to 4) &#x2014;
Number of flow stages used by the duration predictor model.`,name:"duration_predictor_num_flows"},{anchor:"transformers.VitsConfig.duration_predictor_filter_channels",description:`<strong>duration_predictor_filter_channels</strong> (<code>int</code>, <em>optional</em>, defaults to 256) &#x2014;
Number of channels for the convolution layers used in the duration predictor model.`,name:"duration_predictor_filter_channels"},{anchor:"transformers.VitsConfig.prior_encoder_num_flows",description:`<strong>prior_encoder_num_flows</strong> (<code>int</code>, <em>optional</em>, defaults to 4) &#x2014;
Number of flow stages used by the prior encoder flow model.`,name:"prior_encoder_num_flows"},{anchor:"transformers.VitsConfig.prior_encoder_num_wavenet_layers",description:`<strong>prior_encoder_num_wavenet_layers</strong> (<code>int</code>, <em>optional</em>, defaults to 4) &#x2014;
Number of WaveNet layers used by the prior encoder flow model.`,name:"prior_encoder_num_wavenet_layers"},{anchor:"transformers.VitsConfig.posterior_encoder_num_wavenet_layers",description:`<strong>posterior_encoder_num_wavenet_layers</strong> (<code>int</code>, <em>optional</em>, defaults to 16) &#x2014;
Number of WaveNet layers used by the posterior encoder model.`,name:"posterior_encoder_num_wavenet_layers"},{anchor:"transformers.VitsConfig.wavenet_kernel_size",description:`<strong>wavenet_kernel_size</strong> (<code>int</code>, <em>optional</em>, defaults to 5) &#x2014;
Kernel size of the 1D convolution layers used in the WaveNet model.`,name:"wavenet_kernel_size"},{anchor:"transformers.VitsConfig.wavenet_dilation_rate",description:`<strong>wavenet_dilation_rate</strong> (<code>int</code>, <em>optional</em>, defaults to 1) &#x2014;
Dilation rates of the dilated 1D convolutional layers used in the WaveNet model.`,name:"wavenet_dilation_rate"},{anchor:"transformers.VitsConfig.wavenet_dropout",description:`<strong>wavenet_dropout</strong> (<code>float</code>, <em>optional</em>, defaults to 0.0) &#x2014;
The dropout ratio for the WaveNet layers.`,name:"wavenet_dropout"},{anchor:"transformers.VitsConfig.speaking_rate",description:`<strong>speaking_rate</strong> (<code>float</code>, <em>optional</em>, defaults to 1.0) &#x2014;
Speaking rate. Larger values give faster synthesised speech.`,name:"speaking_rate"},{anchor:"transformers.VitsConfig.noise_scale",description:`<strong>noise_scale</strong> (<code>float</code>, <em>optional</em>, defaults to 0.667) &#x2014;
How random the speech prediction is. Larger values create more variation in the predicted speech.`,name:"noise_scale"},{anchor:"transformers.VitsConfig.noise_scale_duration",description:`<strong>noise_scale_duration</strong> (<code>float</code>, <em>optional</em>, defaults to 0.8) &#x2014;
How random the duration prediction is. Larger values create more variation in the predicted durations.`,name:"noise_scale_duration"},{anchor:"transformers.VitsConfig.sampling_rate",description:`<strong>sampling_rate</strong> (<code>int</code>, <em>optional</em>, defaults to 16000) &#x2014;
The sampling rate at which the output audio waveform is digitalized expressed in hertz (Hz).`,name:"sampling_rate"}],source:"https://github.com/huggingface/transformers/blob/v4.33.0/src/transformers/models/vits/configuration_vits.py#L29"}}),te=new Er({props:{anchor:"transformers.VitsConfig.example",$$slots:{default:[Zr]},$$scope:{ctx:G}}}),Ue=new it({}),je=new at({props:{name:"class transformers.VitsTokenizer",anchor:"transformers.VitsTokenizer",parameters:[{name:"vocab_file",val:""},{name:"pad_token",val:" = '<pad>'"},{name:"unk_token",val:" = '<unk>'"},{name:"language",val:" = None"},{name:"add_blank",val:" = True"},{name:"normalize",val:" = True"},{name:"phonemize",val:" = True"},{name:"is_uroman",val:" = False"},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"transformers.VitsTokenizer.vocab_file",description:`<strong>vocab_file</strong> (<code>str</code>) &#x2014;
Path to the vocabulary file.`,name:"vocab_file"},{anchor:"transformers.VitsTokenizer.language",description:`<strong>language</strong> (<code>str</code>, <em>optional</em>) &#x2014;
Language identifier.`,name:"language"},{anchor:"transformers.VitsTokenizer.add_blank",description:`<strong>add_blank</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>True</code>) &#x2014;
Whether to insert token id 0 in between the other tokens.`,name:"add_blank"},{anchor:"transformers.VitsTokenizer.normalize",description:`<strong>normalize</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>True</code>) &#x2014;
Whether to normalize the input text by removing all casing and punctuation.`,name:"normalize"},{anchor:"transformers.VitsTokenizer.phonemize",description:`<strong>phonemize</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>True</code>) &#x2014;
Whether to convert the input text into phonemes.`,name:"phonemize"},{anchor:"transformers.VitsTokenizer.is_uroman",description:`<strong>is_uroman</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>False</code>) &#x2014;
Whether the <code>uroman</code> Romanizer needs to be applied to the input text prior to tokenizing.`,name:"is_uroman"}],source:"https://github.com/huggingface/transformers/blob/v4.33.0/src/transformers/models/vits/tokenization_vits.py#L57"}}),Ie=new at({props:{name:"__call__",anchor:"transformers.VitsTokenizer.__call__",parameters:[{name:"text",val:": typing.Union[str, typing.List[str], typing.List[typing.List[str]]] = None"},{name:"text_pair",val:": typing.Union[str, typing.List[str], typing.List[typing.List[str]], NoneType] = None"},{name:"text_target",val:": typing.Union[str, typing.List[str], typing.List[typing.List[str]]] = None"},{name:"text_pair_target",val:": typing.Union[str, typing.List[str], typing.List[typing.List[str]], NoneType] = None"},{name:"add_special_tokens",val:": bool = True"},{name:"padding",val:": typing.Union[bool, str, transformers.utils.generic.PaddingStrategy] = False"},{name:"truncation",val:": typing.Union[bool, str, transformers.tokenization_utils_base.TruncationStrategy] = None"},{name:"max_length",val:": typing.Optional[int] = None"},{name:"stride",val:": int = 0"},{name:"is_split_into_words",val:": bool = False"},{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_token_type_ids",val:": typing.Optional[bool] = None"},{name:"return_attention_mask",val:": typing.Optional[bool] = None"},{name:"return_overflowing_tokens",val:": bool = False"},{name:"return_special_tokens_mask",val:": bool = False"},{name:"return_offsets_mapping",val:": bool = False"},{name:"return_length",val:": bool = False"},{name:"verbose",val:": bool = True"},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"transformers.VitsTokenizer.__call__.text",description:`<strong>text</strong> (<code>str</code>, <code>List[str]</code>, <code>List[List[str]]</code>, <em>optional</em>) &#x2014;
The sequence or batch of sequences to be encoded. Each sequence can be a string or a list of strings
(pretokenized string). If the sequences are provided as list of strings (pretokenized), you must set
<code>is_split_into_words=True</code> (to lift the ambiguity with a batch of sequences).`,name:"text"},{anchor:"transformers.VitsTokenizer.__call__.text_pair",description:`<strong>text_pair</strong> (<code>str</code>, <code>List[str]</code>, <code>List[List[str]]</code>, <em>optional</em>) &#x2014;
The sequence or batch of sequences to be encoded. Each sequence can be a string or a list of strings
(pretokenized string). If the sequences are provided as list of strings (pretokenized), you must set
<code>is_split_into_words=True</code> (to lift the ambiguity with a batch of sequences).`,name:"text_pair"},{anchor:"transformers.VitsTokenizer.__call__.text_target",description:`<strong>text_target</strong> (<code>str</code>, <code>List[str]</code>, <code>List[List[str]]</code>, <em>optional</em>) &#x2014;
The sequence or batch of sequences to be encoded as target texts. Each sequence can be a string or a
list of strings (pretokenized string). If the sequences are provided as list of strings (pretokenized),
you must set <code>is_split_into_words=True</code> (to lift the ambiguity with a batch of sequences).`,name:"text_target"},{anchor:"transformers.VitsTokenizer.__call__.text_pair_target",description:`<strong>text_pair_target</strong> (<code>str</code>, <code>List[str]</code>, <code>List[List[str]]</code>, <em>optional</em>) &#x2014;
The sequence or batch of sequences to be encoded as target texts. Each sequence can be a string or a
list of strings (pretokenized string). If the sequences are provided as list of strings (pretokenized),
you must set <code>is_split_into_words=True</code> (to lift the ambiguity with a batch of sequences).`,name:"text_pair_target"},{anchor:"transformers.VitsTokenizer.__call__.add_special_tokens",description:`<strong>add_special_tokens</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>True</code>) &#x2014;
Whether or not to encode the sequences with the special tokens relative to their model.`,name:"add_special_tokens"},{anchor:"transformers.VitsTokenizer.__call__.padding",description:`<strong>padding</strong> (<code>bool</code>, <code>str</code> or <a href="/docs/transformers/v4.33.0/en/internal/file_utils#transformers.utils.PaddingStrategy">PaddingStrategy</a>, <em>optional</em>, defaults to <code>False</code>) &#x2014;
Activates and controls padding. Accepts the following values:</p>
<ul>
<li><code>True</code> or <code>&apos;longest&apos;</code>: Pad to the longest sequence in the batch (or no padding if only a single
sequence if provided).</li>
<li><code>&apos;max_length&apos;</code>: Pad to a maximum length specified with the argument <code>max_length</code> or to the maximum
acceptable input length for the model if that argument is not provided.</li>
<li><code>False</code> or <code>&apos;do_not_pad&apos;</code> (default): No padding (i.e., can output a batch with sequences of different
lengths).</li>
</ul>`,name:"padding"},{anchor:"transformers.VitsTokenizer.__call__.truncation",description:`<strong>truncation</strong> (<code>bool</code>, <code>str</code> or <a href="/docs/transformers/v4.33.0/en/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy">TruncationStrategy</a>, <em>optional</em>, defaults to <code>False</code>) &#x2014;
Activates and controls truncation. Accepts the following values:</p>
<ul>
<li><code>True</code> or <code>&apos;longest_first&apos;</code>: Truncate to a maximum length specified with the argument <code>max_length</code> or
to the maximum acceptable input length for the model if that argument is not provided. This will
truncate token by token, removing a token from the longest sequence in the pair if a pair of
sequences (or a batch of pairs) is provided.</li>
<li><code>&apos;only_first&apos;</code>: Truncate to a maximum length specified with the argument <code>max_length</code> or to the
maximum acceptable input length for the model if that argument is not provided. This will only
truncate the first sequence of a pair if a pair of sequences (or a batch of pairs) is provided.</li>
<li><code>&apos;only_second&apos;</code>: Truncate to a maximum length specified with the argument <code>max_length</code> or to the
maximum acceptable input length for the model if that argument is not provided. This will only
truncate the second sequence of a pair if a pair of sequences (or a batch of pairs) is provided.</li>
<li><code>False</code> or <code>&apos;do_not_truncate&apos;</code> (default): No truncation (i.e., can output batch with sequence lengths
greater than the model maximum admissible input size).</li>
</ul>`,name:"truncation"},{anchor:"transformers.VitsTokenizer.__call__.max_length",description:`<strong>max_length</strong> (<code>int</code>, <em>optional</em>) &#x2014;
Controls the maximum length to use by one of the truncation/padding parameters.</p>
<p>If left unset or set to <code>None</code>, this will use the predefined model maximum length if a maximum length
is required by one of the truncation/padding parameters. If the model has no specific maximum input
length (like XLNet) truncation/padding to a maximum length will be deactivated.`,name:"max_length"},{anchor:"transformers.VitsTokenizer.__call__.stride",description:`<strong>stride</strong> (<code>int</code>, <em>optional</em>, defaults to 0) &#x2014;
If set to a number along with <code>max_length</code>, the overflowing tokens returned when
<code>return_overflowing_tokens=True</code> will contain some tokens from the end of the truncated sequence
returned to provide some overlap between truncated and overflowing sequences. The value of this
argument defines the number of overlapping tokens.`,name:"stride"},{anchor:"transformers.VitsTokenizer.__call__.is_split_into_words",description:`<strong>is_split_into_words</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>False</code>) &#x2014;
Whether or not the input is already pre-tokenized (e.g., split into words). If set to <code>True</code>, the
tokenizer assumes the input is already split into words (for instance, by splitting it on whitespace)
which it will tokenize. This is useful for NER or token classification.`,name:"is_split_into_words"},{anchor:"transformers.VitsTokenizer.__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. Requires <code>padding</code> to be activated.
This is especially useful to enable the use of Tensor Cores on NVIDIA hardware with compute capability
<code>&gt;= 7.5</code> (Volta).`,name:"pad_to_multiple_of"},{anchor:"transformers.VitsTokenizer.__call__.return_tensors",description:`<strong>return_tensors</strong> (<code>str</code> or <a href="/docs/transformers/v4.33.0/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.VitsTokenizer.__call__.return_token_type_ids",description:`<strong>return_token_type_ids</strong> (<code>bool</code>, <em>optional</em>) &#x2014;
Whether to return token type IDs. If left to the default, will return the token type IDs according to
the specific tokenizer&#x2019;s default, defined by the <code>return_outputs</code> attribute.</p>
<p><a href="../glossary#token-type-ids">What are token type IDs?</a>`,name:"return_token_type_ids"},{anchor:"transformers.VitsTokenizer.__call__.return_attention_mask",description:`<strong>return_attention_mask</strong> (<code>bool</code>, <em>optional</em>) &#x2014;
Whether to return the attention mask. If left to the default, will return the attention mask according
to the specific tokenizer&#x2019;s default, defined by the <code>return_outputs</code> attribute.</p>
<p><a href="../glossary#attention-mask">What are attention masks?</a>`,name:"return_attention_mask"},{anchor:"transformers.VitsTokenizer.__call__.return_overflowing_tokens",description:`<strong>return_overflowing_tokens</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>False</code>) &#x2014;
Whether or not to return overflowing token sequences. If a pair of sequences of input ids (or a batch
of pairs) is provided with <code>truncation_strategy = longest_first</code> or <code>True</code>, an error is raised instead
of returning overflowing tokens.`,name:"return_overflowing_tokens"},{anchor:"transformers.VitsTokenizer.__call__.return_special_tokens_mask",description:`<strong>return_special_tokens_mask</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>False</code>) &#x2014;
Whether or not to return special tokens mask information.`,name:"return_special_tokens_mask"},{anchor:"transformers.VitsTokenizer.__call__.return_offsets_mapping",description:`<strong>return_offsets_mapping</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>False</code>) &#x2014;
Whether or not to return <code>(char_start, char_end)</code> for each token.</p>
<p>This is only available on fast tokenizers inheriting from <a href="/docs/transformers/v4.33.0/en/main_classes/tokenizer#transformers.PreTrainedTokenizerFast">PreTrainedTokenizerFast</a>, if using
Python&#x2019;s tokenizer, this method will raise <code>NotImplementedError</code>.`,name:"return_offsets_mapping"},{anchor:"transformers.VitsTokenizer.__call__.return_length",description:`<strong>return_length</strong>  (<code>bool</code>, <em>optional</em>, defaults to <code>False</code>) &#x2014;
Whether or not to return the lengths of the encoded inputs.`,name:"return_length"},{anchor:"transformers.VitsTokenizer.__call__.verbose",description:`<strong>verbose</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>True</code>) &#x2014;
Whether or not to print more information and warnings.
**kwargs &#x2014; passed to the <code>self.tokenize()</code> method`,name:"verbose"}],source:"https://github.com/huggingface/transformers/blob/v4.33.0/src/transformers/tokenization_utils_base.py#L2528",returnDescription:`
<p>A <a
  href="/docs/transformers/v4.33.0/en/main_classes/tokenizer#transformers.BatchEncoding"
>BatchEncoding</a> with the following fields:</p>
<ul>
<li>
<p><strong>input_ids</strong> \u2014 List of token ids to be fed to a model.</p>
<p><a href="../glossary#input-ids">What are input IDs?</a></p>
</li>
<li>
<p><strong>token_type_ids</strong> \u2014 List of token type ids to be fed to a model (when <code>return_token_type_ids=True</code> or
if <em>\u201Ctoken_type_ids\u201D</em> is in <code>self.model_input_names</code>).</p>
<p><a href="../glossary#token-type-ids">What are token type IDs?</a></p>
</li>
<li>
<p><strong>attention_mask</strong> \u2014 List of indices specifying which tokens should be attended to by the model (when
<code>return_attention_mask=True</code> or if <em>\u201Cattention_mask\u201D</em> is in <code>self.model_input_names</code>).</p>
<p><a href="../glossary#attention-mask">What are attention masks?</a></p>
</li>
<li>
<p><strong>overflowing_tokens</strong> \u2014 List of overflowing tokens sequences (when a <code>max_length</code> is specified and
<code>return_overflowing_tokens=True</code>).</p>
</li>
<li>
<p><strong>num_truncated_tokens</strong> \u2014 Number of tokens truncated (when a <code>max_length</code> is specified and
<code>return_overflowing_tokens=True</code>).</p>
</li>
<li>
<p><strong>special_tokens_mask</strong> \u2014 List of 0s and 1s, with 1 specifying added special tokens and 0 specifying
regular sequence tokens (when <code>add_special_tokens=True</code> and <code>return_special_tokens_mask=True</code>).</p>
</li>
<li>
<p><strong>length</strong> \u2014 The length of the inputs (when <code>return_length=True</code>)</p>
</li>
</ul>
`,returnType:`
<p><a
  href="/docs/transformers/v4.33.0/en/main_classes/tokenizer#transformers.BatchEncoding"
>BatchEncoding</a></p>
`}}),Ce=new at({props:{name:"save_vocabulary",anchor:"transformers.VitsTokenizer.save_vocabulary",parameters:[{name:"save_directory",val:": str"},{name:"filename_prefix",val:": typing.Optional[str] = None"}],source:"https://github.com/huggingface/transformers/blob/v4.33.0/src/transformers/models/vits/tokenization_vits.py#L237"}}),Ne=new it({}),We=new at({props:{name:"class transformers.VitsModel",anchor:"transformers.VitsModel",parameters:[{name:"config",val:": VitsConfig"}],parametersDescription:[{anchor:"transformers.VitsModel.config",description:`<strong>config</strong> (<a href="/docs/transformers/v4.33.0/en/model_doc/vits#transformers.VitsConfig">VitsConfig</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/v4.33.0/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/v4.33.0/src/transformers/models/vits/modeling_vits.py#L1356"}}),qe=new at({props:{name:"forward",anchor:"transformers.VitsModel.forward",parameters:[{name:"input_ids",val:": typing.Optional[torch.Tensor] = None"},{name:"attention_mask",val:": typing.Optional[torch.Tensor] = None"},{name:"speaker_id",val:": typing.Optional[int] = 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"},{name:"labels",val:": typing.Optional[torch.FloatTensor] = None"}],parametersDescription:[{anchor:"transformers.VitsModel.forward.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>Indices can be obtained using <a href="/docs/transformers/v4.33.0/en/model_doc/auto#transformers.AutoTokenizer">AutoTokenizer</a>. See <a href="/docs/transformers/v4.33.0/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode">PreTrainedTokenizer.encode()</a> and
<a href="/docs/transformers/v4.33.0/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.VitsModel.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 convolution and 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.VitsModel.forward.speaker_id",description:`<strong>speaker_id</strong> (<code>int</code>, <em>optional</em>) &#x2014;
Which speaker embedding to use. Only used for multispeaker models.`,name:"speaker_id"},{anchor:"transformers.VitsModel.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.VitsModel.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.VitsModel.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/v4.33.0/en/main_classes/output#transformers.utils.ModelOutput">ModelOutput</a> instead of a plain tuple.`,name:"return_dict"},{anchor:"transformers.VitsModel.forward.labels",description:`<strong>labels</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, config.spectrogram_bins, sequence_length)</code>, <em>optional</em>) &#x2014;
Float values of target spectrogram. Timesteps set to <code>-100.0</code> are ignored (masked) for the loss
computation.`,name:"labels"}],source:"https://github.com/huggingface/transformers/blob/v4.33.0/src/transformers/models/vits/modeling_vits.py#L1386",returnDescription:`
<p>A <code>transformers.models.vits.modeling_vits.VitsModelOutput</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 (<a
  href="/docs/transformers/v4.33.0/en/model_doc/vits#transformers.VitsConfig"
>VitsConfig</a>) and inputs.</p>
<ul>
<li>
<p><strong>waveform</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length)</code>) \u2014 The final audio waveform predicted by the model.</p>
</li>
<li>
<p><strong>sequence_lengths</strong>  (<code>torch.FloatTensor</code> of shape <code>(batch_size,)</code>) \u2014 The length in samples of each element in the <code>waveform</code> batch.</p>
</li>
<li>
<p><strong>spectrogram</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, num_bins)</code>) \u2014 The log-mel spectrogram predicted at the output of the flow model. This spectrogram is passed to the Hi-Fi
GAN decoder model to obtain the final audio waveform.</p>
</li>
<li>
<p><strong>hidden_states</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) \u2014 Tuple of <code>torch.FloatTensor</code> (one for the output of the embeddings, if the model has an embedding layer, +
one for the output of each layer) of shape <code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the model at the output of each layer plus the optional initial embedding outputs.</p>
</li>
<li>
<p><strong>attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) \u2014 Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attention weights after the attention softmax, used to compute the weighted average in the self-attention
heads.</p>
</li>
</ul>
`,returnType:`
<p><code>transformers.models.vits.modeling_vits.VitsModelOutput</code> or <code>tuple(torch.FloatTensor)</code></p>
`}}),re=new Wr({props:{$$slots:{default:[Rr]},$$scope:{ctx:G}}}),ae=new Er({props:{anchor:"transformers.VitsModel.forward.example",$$slots:{default:[Sr]},$$scope:{ctx:G}}}),{c(){u=r("meta"),V=p(),g=r("h1"),f=r("a"),M=r("span"),y(h.$$.fragment),_=p(),H=r("span"),Uo=n("VITS"),Rt=p(),Z=r("h2"),P=r("a"),lt=r("span"),y(he.$$.fragment),jo=p(),dt=r("span"),$o=n("Overview"),St=p(),Q=r("p"),Io=n("The VITS model was proposed in "),ue=r("a"),Co=n("Conditional Variational Autoencoder with Adversarial Learning for End-to-End Text-to-Speech"),No=n(" by Jaehyeon Kim, Jungil Kong, Juhee Son."),qt=p(),J=r("p"),Wo=n("VITS ("),ct=r("strong"),Zo=n("V"),Ro=n("ariational "),pt=r("strong"),So=n("I"),qo=n("nference with adversarial learning for end-to-end "),mt=r("strong"),Fo=n("T"),Xo=n("ext-to-"),ht=r("strong"),Ao=n("S"),Bo=n(`peech) is an end-to-end
speech synthesis model that predicts a speech waveform conditional on an input text sequence. It is a conditional variational
autoencoder (VAE) comprised of a posterior encoder, decoder, and conditional prior.`),Ft=p(),Xe=r("p"),Go=n(`A set of spectrogram-based acoustic features are predicted by the flow-based module, which is formed of a Transformer-based
text encoder and multiple coupling layers. The spectrogram is decoded using a stack of transposed convolutional layers,
much in the same style as the HiFi-GAN vocoder. Motivated by the one-to-many nature of the TTS problem, where the same text
input can be spoken in multiple ways, the model also includes a stochastic duration predictor, which allows the model to
synthesise speech with different rhythms from the same input text.`),Xt=p(),Ae=r("p"),Ho=n(`The model is trained end-to-end with a combination of losses derived from variational lower bound and adversarial training.
To improve the expressiveness of the model, normalizing flows are applied to the conditional prior distribution. During
inference, the text encodings are up-sampled based on the duration prediction module, and then mapped into the
waveform using a cascade of the flow module and HiFi-GAN decoder. Due to the stochastic nature of the duration predictor,
the model is non-deterministic, and thus requires a fixed seed to generate the same speech waveform.`),At=p(),Be=r("p"),Po=n("The abstract from the paper is the following:"),Bt=p(),Ge=r("p"),ut=r("em"),Qo=n("Several recent end-to-end text-to-speech (TTS) models enabling single-stage training and parallel sampling have been proposed, but their sample quality does not match that of two-stage TTS systems. In this work, we present a parallel end-to-end TTS method that generates more natural sounding audio than current two-stage models. Our method adopts variational inference augmented with normalizing flows and an adversarial training process, which improves the expressive power of generative modeling. We also propose a stochastic duration predictor to synthesize speech with diverse rhythms from input text. With the uncertainty modeling over latent variables and the stochastic duration predictor, our method expresses the natural one-to-many relationship in which a text input can be spoken in multiple ways with different pitches and rhythms. A subjective human evaluation (mean opinion score, or MOS) on the LJ Speech, a single speaker dataset, shows that our method outperforms the best publicly available TTS systems and achieves a MOS comparable to ground truth."),Gt=p(),L=r("p"),Lo=n("This model can also be used with TTS checkpoints from "),fe=r("a"),Yo=n("Massively Multilingual Speech (MMS)"),Do=n(`
as these checkpoints use the same architecture and a slightly modified tokenizer.`),Ht=p(),U=r("p"),Oo=n("This model was contributed by "),ge=r("a"),Ko=n("Matthijs"),en=n(" and "),_e=r("a"),tn=n("sanchit-gandhi"),on=n(". The original code can be found "),ye=r("a"),nn=n("here"),sn=n("."),Pt=p(),R=r("h2"),Y=r("a"),ft=r("span"),y(be.$$.fragment),rn=p(),gt=r("span"),an=n("Model Usage"),Qt=p(),He=r("p"),ln=n(`Both the VITS and MMS-TTS checkpoints can be used with the same API. Since the flow-based model is non-deterministic, it
is good practice to set a seed to ensure reproducibility of the outputs. For languages with a Roman alphabet,
such as English or French, the tokenizer can be used directly to pre-process the text inputs. The following code example
runs a forward pass using the MMS-TTS English checkpoint:`),Lt=p(),y(ve.$$.fragment),Yt=p(),D=r("p"),dn=n("The resulting waveform can be saved as a "),_t=r("code"),cn=n(".wav"),pn=n(" file:"),Dt=p(),y(we.$$.fragment),Ot=p(),Pe=r("p"),mn=n("Or displayed in a Jupyter Notebook / Google Colab:"),Kt=p(),y(Te.$$.fragment),eo=p(),O=r("p"),hn=n("For certain languages with a non-Roman alphabet, such as Arabic, Mandarin or Hindi, the "),ke=r("a"),yt=r("code"),un=n("uroman"),fn=n(`
perl package is required to pre-process the text inputs to the Roman alphabet.`),to=p(),j=r("p"),gn=n("You can check whether you require the "),bt=r("code"),_n=n("uroman"),yn=n(" package for your language by inspecting the "),vt=r("code"),bn=n("is_uroman"),vn=n(` attribute of
the pre-trained `),wt=r("code"),wn=n("tokenizer"),Tn=n(":"),oo=p(),y(Me.$$.fragment),no=p(),I=r("p"),kn=n("If required, you should apply the uroman package to your text inputs "),Tt=r("strong"),Mn=n("prior"),Vn=n(" to passing them to the "),kt=r("code"),zn=n("VitsTokenizer"),Jn=n(`,
since currently the tokenizer does not support performing the pre-processing itself.`),so=p(),K=r("p"),xn=n("To do this, first clone the uroman repository to your local machine and set the bash variable "),Mt=r("code"),En=n("UROMAN"),Un=n(" to the local path:"),ro=p(),y(Ve.$$.fragment),ao=p(),C=r("p"),jn=n(`You can then pre-process the text input using the following code snippet. You can either rely on using the bash variable
`),Vt=r("code"),$n=n("UROMAN"),In=n(" to point to the uroman repository, or you can pass the uroman directory as an argument to the "),zt=r("code"),Cn=n("uromaize"),Nn=n(" function:"),io=p(),y(ze.$$.fragment),lo=p(),S=r("h2"),ee=r("a"),Jt=r("span"),y(Je.$$.fragment),Wn=p(),xt=r("span"),Zn=n("VitsConfig"),co=p(),x=r("div"),y(xe.$$.fragment),Rn=p(),q=r("p"),Sn=n("This is the configuration class to store the configuration of a "),Qe=r("a"),qn=n("VitsModel"),Fn=n(`. It is used to instantiate a VITS
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 VITS
`),Ee=r("a"),Xn=n("facebook/mms-tts-eng"),An=n(" architecture."),Bn=p(),F=r("p"),Gn=n("Configuration objects inherit from "),Le=r("a"),Hn=n("PretrainedConfig"),Pn=n(` and can be used to control the model outputs. Read the
documentation from `),Ye=r("a"),Qn=n("PretrainedConfig"),Ln=n(" for more information."),Yn=p(),y(te.$$.fragment),po=p(),X=r("h2"),oe=r("a"),Et=r("span"),y(Ue.$$.fragment),Dn=p(),Ut=r("span"),On=n("VitsTokenizer"),mo=p(),z=r("div"),y(je.$$.fragment),Kn=p(),jt=r("p"),es=n("Construct a VITS tokenizer. Also supports MMS-TTS."),ts=p(),$e=r("p"),os=n("This tokenizer inherits from "),De=r("a"),ns=n("PreTrainedTokenizer"),ss=n(` which contains most of the main methods. Users should refer to
this superclass for more information regarding those methods.`),rs=p(),ne=r("div"),y(Ie.$$.fragment),as=p(),$t=r("p"),is=n(`Main method to tokenize and prepare for the model one or several sequence(s) or one or several pair(s) of
sequences.`),ls=p(),Oe=r("div"),y(Ce.$$.fragment),ho=p(),A=r("h2"),se=r("a"),It=r("span"),y(Ne.$$.fragment),ds=p(),Ct=r("span"),cs=n("VitsModel"),uo=p(),E=r("div"),y(We.$$.fragment),ps=p(),Ze=r("p"),ms=n(`The complete VITS model, for text-to-speech synthesis.
This model inherits from `),Ke=r("a"),hs=n("PreTrainedModel"),us=n(`. 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.)`),fs=p(),Re=r("p"),gs=n("This model is also a PyTorch "),Se=r("a"),_s=n("torch.nn.Module"),ys=n(` subclass.
Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
and behavior.`),bs=p(),$=r("div"),y(qe.$$.fragment),vs=p(),B=r("p"),ws=n("The "),et=r("a"),Ts=n("VitsModel"),ks=n(" forward method, overrides the "),Nt=r("code"),Ms=n("__call__"),Vs=n(" special method."),zs=p(),y(re.$$.fragment),Js=p(),y(ae.$$.fragment),this.h()},l(e){const l=Cr('[data-svelte="svelte-1phssyn"]',document.head);u=a(l,"META",{name:!0,content:!0}),l.forEach(o),V=m(e),g=a(e,"H1",{class:!0});var Fe=i(g);f=a(Fe,"A",{id:!0,class:!0,href:!0});var Wt=i(f);M=a(Wt,"SPAN",{});var Zt=i(M);b(h.$$.fragment,Zt),Zt.forEach(o),Wt.forEach(o),_=m(Fe),H=a(Fe,"SPAN",{});var xs=i(H);Uo=s(xs,"VITS"),xs.forEach(o),Fe.forEach(o),Rt=m(e),Z=a(e,"H2",{class:!0});var go=i(Z);P=a(go,"A",{id:!0,class:!0,href:!0});var Es=i(P);lt=a(Es,"SPAN",{});var Us=i(lt);b(he.$$.fragment,Us),Us.forEach(o),Es.forEach(o),jo=m(go),dt=a(go,"SPAN",{});var js=i(dt);$o=s(js,"Overview"),js.forEach(o),go.forEach(o),St=m(e),Q=a(e,"P",{});var _o=i(Q);Io=s(_o,"The VITS model was proposed in "),ue=a(_o,"A",{href:!0,rel:!0});var $s=i(ue);Co=s($s,"Conditional Variational Autoencoder with Adversarial Learning for End-to-End Text-to-Speech"),$s.forEach(o),No=s(_o," by Jaehyeon Kim, Jungil Kong, Juhee Son."),_o.forEach(o),qt=m(e),J=a(e,"P",{});var N=i(J);Wo=s(N,"VITS ("),ct=a(N,"STRONG",{});var Is=i(ct);Zo=s(Is,"V"),Is.forEach(o),Ro=s(N,"ariational "),pt=a(N,"STRONG",{});var Cs=i(pt);So=s(Cs,"I"),Cs.forEach(o),qo=s(N,"nference with adversarial learning for end-to-end "),mt=a(N,"STRONG",{});var Ns=i(mt);Fo=s(Ns,"T"),Ns.forEach(o),Xo=s(N,"ext-to-"),ht=a(N,"STRONG",{});var Ws=i(ht);Ao=s(Ws,"S"),Ws.forEach(o),Bo=s(N,`peech) is an end-to-end
speech synthesis model that predicts a speech waveform conditional on an input text sequence. It is a conditional variational
autoencoder (VAE) comprised of a posterior encoder, decoder, and conditional prior.`),N.forEach(o),Ft=m(e),Xe=a(e,"P",{});var Zs=i(Xe);Go=s(Zs,`A set of spectrogram-based acoustic features are predicted by the flow-based module, which is formed of a Transformer-based
text encoder and multiple coupling layers. The spectrogram is decoded using a stack of transposed convolutional layers,
much in the same style as the HiFi-GAN vocoder. Motivated by the one-to-many nature of the TTS problem, where the same text
input can be spoken in multiple ways, the model also includes a stochastic duration predictor, which allows the model to
synthesise speech with different rhythms from the same input text.`),Zs.forEach(o),Xt=m(e),Ae=a(e,"P",{});var Rs=i(Ae);Ho=s(Rs,`The model is trained end-to-end with a combination of losses derived from variational lower bound and adversarial training.
To improve the expressiveness of the model, normalizing flows are applied to the conditional prior distribution. During
inference, the text encodings are up-sampled based on the duration prediction module, and then mapped into the
waveform using a cascade of the flow module and HiFi-GAN decoder. Due to the stochastic nature of the duration predictor,
the model is non-deterministic, and thus requires a fixed seed to generate the same speech waveform.`),Rs.forEach(o),At=m(e),Be=a(e,"P",{});var Ss=i(Be);Po=s(Ss,"The abstract from the paper is the following:"),Ss.forEach(o),Bt=m(e),Ge=a(e,"P",{});var qs=i(Ge);ut=a(qs,"EM",{});var Fs=i(ut);Qo=s(Fs,"Several recent end-to-end text-to-speech (TTS) models enabling single-stage training and parallel sampling have been proposed, but their sample quality does not match that of two-stage TTS systems. In this work, we present a parallel end-to-end TTS method that generates more natural sounding audio than current two-stage models. Our method adopts variational inference augmented with normalizing flows and an adversarial training process, which improves the expressive power of generative modeling. We also propose a stochastic duration predictor to synthesize speech with diverse rhythms from input text. With the uncertainty modeling over latent variables and the stochastic duration predictor, our method expresses the natural one-to-many relationship in which a text input can be spoken in multiple ways with different pitches and rhythms. A subjective human evaluation (mean opinion score, or MOS) on the LJ Speech, a single speaker dataset, shows that our method outperforms the best publicly available TTS systems and achieves a MOS comparable to ground truth."),Fs.forEach(o),qs.forEach(o),Gt=m(e),L=a(e,"P",{});var yo=i(L);Lo=s(yo,"This model can also be used with TTS checkpoints from "),fe=a(yo,"A",{href:!0,rel:!0});var Xs=i(fe);Yo=s(Xs,"Massively Multilingual Speech (MMS)"),Xs.forEach(o),Do=s(yo,`
as these checkpoints use the same architecture and a slightly modified tokenizer.`),yo.forEach(o),Ht=m(e),U=a(e,"P",{});var ie=i(U);Oo=s(ie,"This model was contributed by "),ge=a(ie,"A",{href:!0,rel:!0});var As=i(ge);Ko=s(As,"Matthijs"),As.forEach(o),en=s(ie," and "),_e=a(ie,"A",{href:!0,rel:!0});var Bs=i(_e);tn=s(Bs,"sanchit-gandhi"),Bs.forEach(o),on=s(ie,". The original code can be found "),ye=a(ie,"A",{href:!0,rel:!0});var Gs=i(ye);nn=s(Gs,"here"),Gs.forEach(o),sn=s(ie,"."),ie.forEach(o),Pt=m(e),R=a(e,"H2",{class:!0});var bo=i(R);Y=a(bo,"A",{id:!0,class:!0,href:!0});var Hs=i(Y);ft=a(Hs,"SPAN",{});var Ps=i(ft);b(be.$$.fragment,Ps),Ps.forEach(o),Hs.forEach(o),rn=m(bo),gt=a(bo,"SPAN",{});var Qs=i(gt);an=s(Qs,"Model Usage"),Qs.forEach(o),bo.forEach(o),Qt=m(e),He=a(e,"P",{});var Ls=i(He);ln=s(Ls,`Both the VITS and MMS-TTS checkpoints can be used with the same API. Since the flow-based model is non-deterministic, it
is good practice to set a seed to ensure reproducibility of the outputs. For languages with a Roman alphabet,
such as English or French, the tokenizer can be used directly to pre-process the text inputs. The following code example
runs a forward pass using the MMS-TTS English checkpoint:`),Ls.forEach(o),Lt=m(e),b(ve.$$.fragment,e),Yt=m(e),D=a(e,"P",{});var vo=i(D);dn=s(vo,"The resulting waveform can be saved as a "),_t=a(vo,"CODE",{});var Ys=i(_t);cn=s(Ys,".wav"),Ys.forEach(o),pn=s(vo," file:"),vo.forEach(o),Dt=m(e),b(we.$$.fragment,e),Ot=m(e),Pe=a(e,"P",{});var Ds=i(Pe);mn=s(Ds,"Or displayed in a Jupyter Notebook / Google Colab:"),Ds.forEach(o),Kt=m(e),b(Te.$$.fragment,e),eo=m(e),O=a(e,"P",{});var wo=i(O);hn=s(wo,"For certain languages with a non-Roman alphabet, such as Arabic, Mandarin or Hindi, the "),ke=a(wo,"A",{href:!0,rel:!0});var Os=i(ke);yt=a(Os,"CODE",{});var Ks=i(yt);un=s(Ks,"uroman"),Ks.forEach(o),Os.forEach(o),fn=s(wo,`
perl package is required to pre-process the text inputs to the Roman alphabet.`),wo.forEach(o),to=m(e),j=a(e,"P",{});var le=i(j);gn=s(le,"You can check whether you require the "),bt=a(le,"CODE",{});var er=i(bt);_n=s(er,"uroman"),er.forEach(o),yn=s(le," package for your language by inspecting the "),vt=a(le,"CODE",{});var tr=i(vt);bn=s(tr,"is_uroman"),tr.forEach(o),vn=s(le,` attribute of
the pre-trained `),wt=a(le,"CODE",{});var or=i(wt);wn=s(or,"tokenizer"),or.forEach(o),Tn=s(le,":"),le.forEach(o),oo=m(e),b(Me.$$.fragment,e),no=m(e),I=a(e,"P",{});var tt=i(I);kn=s(tt,"If required, you should apply the uroman package to your text inputs "),Tt=a(tt,"STRONG",{});var nr=i(Tt);Mn=s(nr,"prior"),nr.forEach(o),Vn=s(tt," to passing them to the "),kt=a(tt,"CODE",{});var sr=i(kt);zn=s(sr,"VitsTokenizer"),sr.forEach(o),Jn=s(tt,`,
since currently the tokenizer does not support performing the pre-processing itself.`),tt.forEach(o),so=m(e),K=a(e,"P",{});var To=i(K);xn=s(To,"To do this, first clone the uroman repository to your local machine and set the bash variable "),Mt=a(To,"CODE",{});var rr=i(Mt);En=s(rr,"UROMAN"),rr.forEach(o),Un=s(To," to the local path:"),To.forEach(o),ro=m(e),b(Ve.$$.fragment,e),ao=m(e),C=a(e,"P",{});var ot=i(C);jn=s(ot,`You can then pre-process the text input using the following code snippet. You can either rely on using the bash variable
`),Vt=a(ot,"CODE",{});var ar=i(Vt);$n=s(ar,"UROMAN"),ar.forEach(o),In=s(ot," to point to the uroman repository, or you can pass the uroman directory as an argument to the "),zt=a(ot,"CODE",{});var ir=i(zt);Cn=s(ir,"uromaize"),ir.forEach(o),Nn=s(ot," function:"),ot.forEach(o),io=m(e),b(ze.$$.fragment,e),lo=m(e),S=a(e,"H2",{class:!0});var ko=i(S);ee=a(ko,"A",{id:!0,class:!0,href:!0});var lr=i(ee);Jt=a(lr,"SPAN",{});var dr=i(Jt);b(Je.$$.fragment,dr),dr.forEach(o),lr.forEach(o),Wn=m(ko),xt=a(ko,"SPAN",{});var cr=i(xt);Zn=s(cr,"VitsConfig"),cr.forEach(o),ko.forEach(o),co=m(e),x=a(e,"DIV",{class:!0});var de=i(x);b(xe.$$.fragment,de),Rn=m(de),q=a(de,"P",{});var nt=i(q);Sn=s(nt,"This is the configuration class to store the configuration of a "),Qe=a(nt,"A",{href:!0});var pr=i(Qe);qn=s(pr,"VitsModel"),pr.forEach(o),Fn=s(nt,`. It is used to instantiate a VITS
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 VITS
`),Ee=a(nt,"A",{href:!0,rel:!0});var mr=i(Ee);Xn=s(mr,"facebook/mms-tts-eng"),mr.forEach(o),An=s(nt," architecture."),nt.forEach(o),Bn=m(de),F=a(de,"P",{});var st=i(F);Gn=s(st,"Configuration objects inherit from "),Le=a(st,"A",{href:!0});var hr=i(Le);Hn=s(hr,"PretrainedConfig"),hr.forEach(o),Pn=s(st,` and can be used to control the model outputs. Read the
documentation from `),Ye=a(st,"A",{href:!0});var ur=i(Ye);Qn=s(ur,"PretrainedConfig"),ur.forEach(o),Ln=s(st," for more information."),st.forEach(o),Yn=m(de),b(te.$$.fragment,de),de.forEach(o),po=m(e),X=a(e,"H2",{class:!0});var Mo=i(X);oe=a(Mo,"A",{id:!0,class:!0,href:!0});var fr=i(oe);Et=a(fr,"SPAN",{});var gr=i(Et);b(Ue.$$.fragment,gr),gr.forEach(o),fr.forEach(o),Dn=m(Mo),Ut=a(Mo,"SPAN",{});var _r=i(Ut);On=s(_r,"VitsTokenizer"),_r.forEach(o),Mo.forEach(o),mo=m(e),z=a(e,"DIV",{class:!0});var W=i(z);b(je.$$.fragment,W),Kn=m(W),jt=a(W,"P",{});var yr=i(jt);es=s(yr,"Construct a VITS tokenizer. Also supports MMS-TTS."),yr.forEach(o),ts=m(W),$e=a(W,"P",{});var Vo=i($e);os=s(Vo,"This tokenizer inherits from "),De=a(Vo,"A",{href:!0});var br=i(De);ns=s(br,"PreTrainedTokenizer"),br.forEach(o),ss=s(Vo,` which contains most of the main methods. Users should refer to
this superclass for more information regarding those methods.`),Vo.forEach(o),rs=m(W),ne=a(W,"DIV",{class:!0});var zo=i(ne);b(Ie.$$.fragment,zo),as=m(zo),$t=a(zo,"P",{});var vr=i($t);is=s(vr,`Main method to tokenize and prepare for the model one or several sequence(s) or one or several pair(s) of
sequences.`),vr.forEach(o),zo.forEach(o),ls=m(W),Oe=a(W,"DIV",{class:!0});var wr=i(Oe);b(Ce.$$.fragment,wr),wr.forEach(o),W.forEach(o),ho=m(e),A=a(e,"H2",{class:!0});var Jo=i(A);se=a(Jo,"A",{id:!0,class:!0,href:!0});var Tr=i(se);It=a(Tr,"SPAN",{});var kr=i(It);b(Ne.$$.fragment,kr),kr.forEach(o),Tr.forEach(o),ds=m(Jo),Ct=a(Jo,"SPAN",{});var Mr=i(Ct);cs=s(Mr,"VitsModel"),Mr.forEach(o),Jo.forEach(o),uo=m(e),E=a(e,"DIV",{class:!0});var ce=i(E);b(We.$$.fragment,ce),ps=m(ce),Ze=a(ce,"P",{});var xo=i(Ze);ms=s(xo,`The complete VITS model, for text-to-speech synthesis.
This model inherits from `),Ke=a(xo,"A",{href:!0});var Vr=i(Ke);hs=s(Vr,"PreTrainedModel"),Vr.forEach(o),us=s(xo,`. 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.)`),xo.forEach(o),fs=m(ce),Re=a(ce,"P",{});var Eo=i(Re);gs=s(Eo,"This model is also a PyTorch "),Se=a(Eo,"A",{href:!0,rel:!0});var zr=i(Se);_s=s(zr,"torch.nn.Module"),zr.forEach(o),ys=s(Eo,` subclass.
Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
and behavior.`),Eo.forEach(o),bs=m(ce),$=a(ce,"DIV",{class:!0});var pe=i($);b(qe.$$.fragment,pe),vs=m(pe),B=a(pe,"P",{});var rt=i(B);ws=s(rt,"The "),et=a(rt,"A",{href:!0});var Jr=i(et);Ts=s(Jr,"VitsModel"),Jr.forEach(o),ks=s(rt," forward method, overrides the "),Nt=a(rt,"CODE",{});var xr=i(Nt);Ms=s(xr,"__call__"),xr.forEach(o),Vs=s(rt," special method."),rt.forEach(o),zs=m(pe),b(re.$$.fragment,pe),Js=m(pe),b(ae.$$.fragment,pe),pe.forEach(o),ce.forEach(o),this.h()},h(){c(u,"name","hf:doc:metadata"),c(u,"content",JSON.stringify(Fr)),c(f,"id","vits"),c(f,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),c(f,"href","#vits"),c(g,"class","relative group"),c(P,"id","overview"),c(P,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),c(P,"href","#overview"),c(Z,"class","relative group"),c(ue,"href","https://arxiv.org/abs/2106.06103"),c(ue,"rel","nofollow"),c(fe,"href","https://arxiv.org/abs/2305.13516"),c(fe,"rel","nofollow"),c(ge,"href","https://huggingface.co/Matthijs"),c(ge,"rel","nofollow"),c(_e,"href","https://huggingface.co/sanchit-gandhi"),c(_e,"rel","nofollow"),c(ye,"href","https://github.com/jaywalnut310/vits"),c(ye,"rel","nofollow"),c(Y,"id","model-usage"),c(Y,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),c(Y,"href","#model-usage"),c(R,"class","relative group"),c(ke,"href","https://github.com/isi-nlp/uroman"),c(ke,"rel","nofollow"),c(ee,"id","transformers.VitsConfig"),c(ee,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),c(ee,"href","#transformers.VitsConfig"),c(S,"class","relative group"),c(Qe,"href","/docs/transformers/v4.33.0/en/model_doc/vits#transformers.VitsModel"),c(Ee,"href","https://huggingface.co/facebook/mms-tts-eng"),c(Ee,"rel","nofollow"),c(Le,"href","/docs/transformers/v4.33.0/en/main_classes/configuration#transformers.PretrainedConfig"),c(Ye,"href","/docs/transformers/v4.33.0/en/main_classes/configuration#transformers.PretrainedConfig"),c(x,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),c(oe,"id","transformers.VitsTokenizer"),c(oe,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),c(oe,"href","#transformers.VitsTokenizer"),c(X,"class","relative group"),c(De,"href","/docs/transformers/v4.33.0/en/main_classes/tokenizer#transformers.PreTrainedTokenizer"),c(ne,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),c(Oe,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),c(z,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),c(se,"id","transformers.VitsModel"),c(se,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),c(se,"href","#transformers.VitsModel"),c(A,"class","relative group"),c(Ke,"href","/docs/transformers/v4.33.0/en/main_classes/model#transformers.PreTrainedModel"),c(Se,"href","https://pytorch.org/docs/stable/nn.html#torch.nn.Module"),c(Se,"rel","nofollow"),c(et,"href","/docs/transformers/v4.33.0/en/model_doc/vits#transformers.VitsModel"),c($,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),c(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(e,l){t(document.head,u),d(e,V,l),d(e,g,l),t(g,f),t(f,M),v(h,M,null),t(g,_),t(g,H),t(H,Uo),d(e,Rt,l),d(e,Z,l),t(Z,P),t(P,lt),v(he,lt,null),t(Z,jo),t(Z,dt),t(dt,$o),d(e,St,l),d(e,Q,l),t(Q,Io),t(Q,ue),t(ue,Co),t(Q,No),d(e,qt,l),d(e,J,l),t(J,Wo),t(J,ct),t(ct,Zo),t(J,Ro),t(J,pt),t(pt,So),t(J,qo),t(J,mt),t(mt,Fo),t(J,Xo),t(J,ht),t(ht,Ao),t(J,Bo),d(e,Ft,l),d(e,Xe,l),t(Xe,Go),d(e,Xt,l),d(e,Ae,l),t(Ae,Ho),d(e,At,l),d(e,Be,l),t(Be,Po),d(e,Bt,l),d(e,Ge,l),t(Ge,ut),t(ut,Qo),d(e,Gt,l),d(e,L,l),t(L,Lo),t(L,fe),t(fe,Yo),t(L,Do),d(e,Ht,l),d(e,U,l),t(U,Oo),t(U,ge),t(ge,Ko),t(U,en),t(U,_e),t(_e,tn),t(U,on),t(U,ye),t(ye,nn),t(U,sn),d(e,Pt,l),d(e,R,l),t(R,Y),t(Y,ft),v(be,ft,null),t(R,rn),t(R,gt),t(gt,an),d(e,Qt,l),d(e,He,l),t(He,ln),d(e,Lt,l),v(ve,e,l),d(e,Yt,l),d(e,D,l),t(D,dn),t(D,_t),t(_t,cn),t(D,pn),d(e,Dt,l),v(we,e,l),d(e,Ot,l),d(e,Pe,l),t(Pe,mn),d(e,Kt,l),v(Te,e,l),d(e,eo,l),d(e,O,l),t(O,hn),t(O,ke),t(ke,yt),t(yt,un),t(O,fn),d(e,to,l),d(e,j,l),t(j,gn),t(j,bt),t(bt,_n),t(j,yn),t(j,vt),t(vt,bn),t(j,vn),t(j,wt),t(wt,wn),t(j,Tn),d(e,oo,l),v(Me,e,l),d(e,no,l),d(e,I,l),t(I,kn),t(I,Tt),t(Tt,Mn),t(I,Vn),t(I,kt),t(kt,zn),t(I,Jn),d(e,so,l),d(e,K,l),t(K,xn),t(K,Mt),t(Mt,En),t(K,Un),d(e,ro,l),v(Ve,e,l),d(e,ao,l),d(e,C,l),t(C,jn),t(C,Vt),t(Vt,$n),t(C,In),t(C,zt),t(zt,Cn),t(C,Nn),d(e,io,l),v(ze,e,l),d(e,lo,l),d(e,S,l),t(S,ee),t(ee,Jt),v(Je,Jt,null),t(S,Wn),t(S,xt),t(xt,Zn),d(e,co,l),d(e,x,l),v(xe,x,null),t(x,Rn),t(x,q),t(q,Sn),t(q,Qe),t(Qe,qn),t(q,Fn),t(q,Ee),t(Ee,Xn),t(q,An),t(x,Bn),t(x,F),t(F,Gn),t(F,Le),t(Le,Hn),t(F,Pn),t(F,Ye),t(Ye,Qn),t(F,Ln),t(x,Yn),v(te,x,null),d(e,po,l),d(e,X,l),t(X,oe),t(oe,Et),v(Ue,Et,null),t(X,Dn),t(X,Ut),t(Ut,On),d(e,mo,l),d(e,z,l),v(je,z,null),t(z,Kn),t(z,jt),t(jt,es),t(z,ts),t(z,$e),t($e,os),t($e,De),t(De,ns),t($e,ss),t(z,rs),t(z,ne),v(Ie,ne,null),t(ne,as),t(ne,$t),t($t,is),t(z,ls),t(z,Oe),v(Ce,Oe,null),d(e,ho,l),d(e,A,l),t(A,se),t(se,It),v(Ne,It,null),t(A,ds),t(A,Ct),t(Ct,cs),d(e,uo,l),d(e,E,l),v(We,E,null),t(E,ps),t(E,Ze),t(Ze,ms),t(Ze,Ke),t(Ke,hs),t(Ze,us),t(E,fs),t(E,Re),t(Re,gs),t(Re,Se),t(Se,_s),t(Re,ys),t(E,bs),t(E,$),v(qe,$,null),t($,vs),t($,B),t(B,ws),t(B,et),t(et,Ts),t(B,ks),t(B,Nt),t(Nt,Ms),t(B,Vs),t($,zs),v(re,$,null),t($,Js),v(ae,$,null),fo=!0},p(e,[l]){const Fe={};l&2&&(Fe.$$scope={dirty:l,ctx:e}),te.$set(Fe);const Wt={};l&2&&(Wt.$$scope={dirty:l,ctx:e}),re.$set(Wt);const Zt={};l&2&&(Zt.$$scope={dirty:l,ctx:e}),ae.$set(Zt)},i(e){fo||(w(h.$$.fragment,e),w(he.$$.fragment,e),w(be.$$.fragment,e),w(ve.$$.fragment,e),w(we.$$.fragment,e),w(Te.$$.fragment,e),w(Me.$$.fragment,e),w(Ve.$$.fragment,e),w(ze.$$.fragment,e),w(Je.$$.fragment,e),w(xe.$$.fragment,e),w(te.$$.fragment,e),w(Ue.$$.fragment,e),w(je.$$.fragment,e),w(Ie.$$.fragment,e),w(Ce.$$.fragment,e),w(Ne.$$.fragment,e),w(We.$$.fragment,e),w(qe.$$.fragment,e),w(re.$$.fragment,e),w(ae.$$.fragment,e),fo=!0)},o(e){T(h.$$.fragment,e),T(he.$$.fragment,e),T(be.$$.fragment,e),T(ve.$$.fragment,e),T(we.$$.fragment,e),T(Te.$$.fragment,e),T(Me.$$.fragment,e),T(Ve.$$.fragment,e),T(ze.$$.fragment,e),T(Je.$$.fragment,e),T(xe.$$.fragment,e),T(te.$$.fragment,e),T(Ue.$$.fragment,e),T(je.$$.fragment,e),T(Ie.$$.fragment,e),T(Ce.$$.fragment,e),T(Ne.$$.fragment,e),T(We.$$.fragment,e),T(qe.$$.fragment,e),T(re.$$.fragment,e),T(ae.$$.fragment,e),fo=!1},d(e){o(u),e&&o(V),e&&o(g),k(h),e&&o(Rt),e&&o(Z),k(he),e&&o(St),e&&o(Q),e&&o(qt),e&&o(J),e&&o(Ft),e&&o(Xe),e&&o(Xt),e&&o(Ae),e&&o(At),e&&o(Be),e&&o(Bt),e&&o(Ge),e&&o(Gt),e&&o(L),e&&o(Ht),e&&o(U),e&&o(Pt),e&&o(R),k(be),e&&o(Qt),e&&o(He),e&&o(Lt),k(ve,e),e&&o(Yt),e&&o(D),e&&o(Dt),k(we,e),e&&o(Ot),e&&o(Pe),e&&o(Kt),k(Te,e),e&&o(eo),e&&o(O),e&&o(to),e&&o(j),e&&o(oo),k(Me,e),e&&o(no),e&&o(I),e&&o(so),e&&o(K),e&&o(ro),k(Ve,e),e&&o(ao),e&&o(C),e&&o(io),k(ze,e),e&&o(lo),e&&o(S),k(Je),e&&o(co),e&&o(x),k(xe),k(te),e&&o(po),e&&o(X),k(Ue),e&&o(mo),e&&o(z),k(je),k(Ie),k(Ce),e&&o(ho),e&&o(A),k(Ne),e&&o(uo),e&&o(E),k(We),k(qe),k(re),k(ae)}}}const Fr={local:"vits",sections:[{local:"overview",title:"Overview"},{local:"model-usage",title:"Model Usage"},{local:"transformers.VitsConfig",title:"VitsConfig"},{local:"transformers.VitsTokenizer",title:"VitsTokenizer"},{local:"transformers.VitsModel",title:"VitsModel"}],title:"VITS"};function Xr(G){return Nr(()=>{new URLSearchParams(window.location.search).get("fw")}),[]}class Lr extends jr{constructor(u){super();$r(this,u,Xr,qr,Ir,{})}}export{Lr as default,Fr as metadata};
