import{S as b$,i as w$,s as F$,e as s,k as u,w,t,M as v$,c as r,d as n,m as p,a,x as F,h as o,b as m,G as e,g as _,y as v,q as $,o as E,B as M,v as $$,L as Ge}from"../../chunks/vendor-hf-doc-builder.js";import{T as Ve}from"../../chunks/Tip-hf-doc-builder.js";import{D as se}from"../../chunks/Docstring-hf-doc-builder.js";import{C as Ze}from"../../chunks/CodeBlock-hf-doc-builder.js";import{I as Xe}from"../../chunks/IconCopyLink-hf-doc-builder.js";import{E as Ye}from"../../chunks/ExampleCodeBlock-hf-doc-builder.js";function E$(x){let d,k,h,f,T;return f=new Ze({props:{code:`2 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1
| first sequence    | second sequence |`,highlighted:`2<span class="hljs-number"> 0 </span>0<span class="hljs-number"> 0 </span>0<span class="hljs-number"> 0 </span>0<span class="hljs-number"> 0 </span>0<span class="hljs-number"> 0 </span>0<span class="hljs-number"> 1 </span>1<span class="hljs-number"> 1 </span>1<span class="hljs-number"> 1 </span>1<span class="hljs-number"> 1 </span>1 1
| first sequence    | second sequence |`}}),{c(){d=s("p"),k=t("Transformer sequence pair mask has the following format:"),h=u(),w(f.$$.fragment)},l(l){d=r(l,"P",{});var c=a(d);k=o(c,"Transformer sequence pair mask has the following format:"),c.forEach(n),h=p(l),F(f.$$.fragment,l)},m(l,c){_(l,d,c),e(d,k),_(l,h,c),v(f,l,c),T=!0},p:Ge,i(l){T||($(f.$$.fragment,l),T=!0)},o(l){E(f.$$.fragment,l),T=!1},d(l){l&&n(d),l&&n(h),M(f,l)}}}function M$(x){let d,k,h,f,T;return f=new Ze({props:{code:`2 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1
| first sequence    | second sequence |`,highlighted:`2<span class="hljs-number"> 0 </span>0<span class="hljs-number"> 0 </span>0<span class="hljs-number"> 0 </span>0<span class="hljs-number"> 0 </span>0<span class="hljs-number"> 0 </span>0<span class="hljs-number"> 1 </span>1<span class="hljs-number"> 1 </span>1<span class="hljs-number"> 1 </span>1<span class="hljs-number"> 1 </span>1 1
| first sequence    | second sequence |`}}),{c(){d=s("p"),k=t("Transformer sequence pair mask has the following format:"),h=u(),w(f.$$.fragment)},l(l){d=r(l,"P",{});var c=a(d);k=o(c,"Transformer sequence pair mask has the following format:"),c.forEach(n),h=p(l),F(f.$$.fragment,l)},m(l,c){_(l,d,c),e(d,k),_(l,h,c),v(f,l,c),T=!0},p:Ge,i(l){T||($(f.$$.fragment,l),T=!0)},o(l){E(f.$$.fragment,l),T=!1},d(l){l&&n(d),l&&n(h),M(f,l)}}}function z$(x){let d,k,h,f,T;return{c(){d=s("p"),k=t("Although the recipe for forward pass needs to be defined within this function, one should call the "),h=s("code"),f=t("Module"),T=t(`
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(l){d=r(l,"P",{});var c=a(d);k=o(c,"Although the recipe for forward pass needs to be defined within this function, one should call the "),h=r(c,"CODE",{});var P=a(h);f=o(P,"Module"),P.forEach(n),T=o(c,`
instance afterwards instead of this since the former takes care of running the pre and post processing steps while
the latter silently ignores them.`),c.forEach(n)},m(l,c){_(l,d,c),e(d,k),e(d,h),e(h,f),e(d,T)},d(l){l&&n(d)}}}function q$(x){let d,k,h,f,T;return f=new Ze({props:{code:`from transformers import AutoTokenizer, FunnelBaseModel
import torch

tokenizer = AutoTokenizer.from_pretrained("funnel-transformer/small-base")
model = FunnelBaseModel.from_pretrained("funnel-transformer/small-base")

inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
outputs = model(**inputs)

last_hidden_states = outputs.last_hidden_state`,highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> AutoTokenizer, FunnelBaseModel
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">import</span> torch

<span class="hljs-meta">&gt;&gt;&gt; </span>tokenizer = AutoTokenizer.from_pretrained(<span class="hljs-string">&quot;funnel-transformer/small-base&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>model = FunnelBaseModel.from_pretrained(<span class="hljs-string">&quot;funnel-transformer/small-base&quot;</span>)

<span class="hljs-meta">&gt;&gt;&gt; </span>inputs = tokenizer(<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>outputs = model(**inputs)

<span class="hljs-meta">&gt;&gt;&gt; </span>last_hidden_states = outputs.last_hidden_state`}}),{c(){d=s("p"),k=t("Example:"),h=u(),w(f.$$.fragment)},l(l){d=r(l,"P",{});var c=a(d);k=o(c,"Example:"),c.forEach(n),h=p(l),F(f.$$.fragment,l)},m(l,c){_(l,d,c),e(d,k),_(l,h,c),v(f,l,c),T=!0},p:Ge,i(l){T||($(f.$$.fragment,l),T=!0)},o(l){E(f.$$.fragment,l),T=!1},d(l){l&&n(d),l&&n(h),M(f,l)}}}function P$(x){let d,k,h,f,T;return{c(){d=s("p"),k=t("Although the recipe for forward pass needs to be defined within this function, one should call the "),h=s("code"),f=t("Module"),T=t(`
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(l){d=r(l,"P",{});var c=a(d);k=o(c,"Although the recipe for forward pass needs to be defined within this function, one should call the "),h=r(c,"CODE",{});var P=a(h);f=o(P,"Module"),P.forEach(n),T=o(c,`
instance afterwards instead of this since the former takes care of running the pre and post processing steps while
the latter silently ignores them.`),c.forEach(n)},m(l,c){_(l,d,c),e(d,k),e(d,h),e(h,f),e(d,T)},d(l){l&&n(d)}}}function x$(x){let d,k,h,f,T;return f=new Ze({props:{code:`from transformers import AutoTokenizer, FunnelModel
import torch

tokenizer = AutoTokenizer.from_pretrained("funnel-transformer/small")
model = FunnelModel.from_pretrained("funnel-transformer/small")

inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
outputs = model(**inputs)

last_hidden_states = outputs.last_hidden_state`,highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> AutoTokenizer, FunnelModel
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">import</span> torch

<span class="hljs-meta">&gt;&gt;&gt; </span>tokenizer = AutoTokenizer.from_pretrained(<span class="hljs-string">&quot;funnel-transformer/small&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>model = FunnelModel.from_pretrained(<span class="hljs-string">&quot;funnel-transformer/small&quot;</span>)

<span class="hljs-meta">&gt;&gt;&gt; </span>inputs = tokenizer(<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>outputs = model(**inputs)

<span class="hljs-meta">&gt;&gt;&gt; </span>last_hidden_states = outputs.last_hidden_state`}}),{c(){d=s("p"),k=t("Example:"),h=u(),w(f.$$.fragment)},l(l){d=r(l,"P",{});var c=a(d);k=o(c,"Example:"),c.forEach(n),h=p(l),F(f.$$.fragment,l)},m(l,c){_(l,d,c),e(d,k),_(l,h,c),v(f,l,c),T=!0},p:Ge,i(l){T||($(f.$$.fragment,l),T=!0)},o(l){E(f.$$.fragment,l),T=!1},d(l){l&&n(d),l&&n(h),M(f,l)}}}function C$(x){let d,k,h,f,T;return{c(){d=s("p"),k=t("Although the recipe for forward pass needs to be defined within this function, one should call the "),h=s("code"),f=t("Module"),T=t(`
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(l){d=r(l,"P",{});var c=a(d);k=o(c,"Although the recipe for forward pass needs to be defined within this function, one should call the "),h=r(c,"CODE",{});var P=a(h);f=o(P,"Module"),P.forEach(n),T=o(c,`
instance afterwards instead of this since the former takes care of running the pre and post processing steps while
the latter silently ignores them.`),c.forEach(n)},m(l,c){_(l,d,c),e(d,k),e(d,h),e(h,f),e(d,T)},d(l){l&&n(d)}}}function j$(x){let d,k,h,f,T;return f=new Ze({props:{code:`from transformers import AutoTokenizer, FunnelForPreTraining
import torch

tokenizer = AutoTokenizer.from_pretrained("funnel-transformer/small")
model = FunnelForPreTraining.from_pretrained("funnel-transformer/small")

inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
logits = model(**inputs).logits`,highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> AutoTokenizer, FunnelForPreTraining
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">import</span> torch

<span class="hljs-meta">&gt;&gt;&gt; </span>tokenizer = AutoTokenizer.from_pretrained(<span class="hljs-string">&quot;funnel-transformer/small&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>model = FunnelForPreTraining.from_pretrained(<span class="hljs-string">&quot;funnel-transformer/small&quot;</span>)

<span class="hljs-meta">&gt;&gt;&gt; </span>inputs = tokenizer(<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>logits = model(**inputs).logits`}}),{c(){d=s("p"),k=t("Examples:"),h=u(),w(f.$$.fragment)},l(l){d=r(l,"P",{});var c=a(d);k=o(c,"Examples:"),c.forEach(n),h=p(l),F(f.$$.fragment,l)},m(l,c){_(l,d,c),e(d,k),_(l,h,c),v(f,l,c),T=!0},p:Ge,i(l){T||($(f.$$.fragment,l),T=!0)},o(l){E(f.$$.fragment,l),T=!1},d(l){l&&n(d),l&&n(h),M(f,l)}}}function A$(x){let d,k,h,f,T;return{c(){d=s("p"),k=t("Although the recipe for forward pass needs to be defined within this function, one should call the "),h=s("code"),f=t("Module"),T=t(`
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(l){d=r(l,"P",{});var c=a(d);k=o(c,"Although the recipe for forward pass needs to be defined within this function, one should call the "),h=r(c,"CODE",{});var P=a(h);f=o(P,"Module"),P.forEach(n),T=o(c,`
instance afterwards instead of this since the former takes care of running the pre and post processing steps while
the latter silently ignores them.`),c.forEach(n)},m(l,c){_(l,d,c),e(d,k),e(d,h),e(h,f),e(d,T)},d(l){l&&n(d)}}}function O$(x){let d,k,h,f,T;return f=new Ze({props:{code:`from transformers import AutoTokenizer, FunnelForMaskedLM
import torch

tokenizer = AutoTokenizer.from_pretrained("funnel-transformer/small")
model = FunnelForMaskedLM.from_pretrained("funnel-transformer/small")

inputs = tokenizer("The capital of France is <mask>.", return_tensors="pt")

with torch.no_grad():
    logits = model(**inputs).logits

# retrieve index of <mask>
mask_token_index = (inputs.input_ids == tokenizer.mask_token_id)[0].nonzero(as_tuple=True)[0]

predicted_token_id = logits[0, mask_token_index].argmax(axis=-1)

labels = tokenizer("The capital of France is Paris.", return_tensors="pt")["input_ids"]
# mask labels of non-<mask> tokens
labels = torch.where(inputs.input_ids == tokenizer.mask_token_id, labels, -100)

outputs = model(**inputs, labels=labels)`,highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> AutoTokenizer, FunnelForMaskedLM
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">import</span> torch

<span class="hljs-meta">&gt;&gt;&gt; </span>tokenizer = AutoTokenizer.from_pretrained(<span class="hljs-string">&quot;funnel-transformer/small&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>model = FunnelForMaskedLM.from_pretrained(<span class="hljs-string">&quot;funnel-transformer/small&quot;</span>)

<span class="hljs-meta">&gt;&gt;&gt; </span>inputs = tokenizer(<span class="hljs-string">&quot;The capital of France is &lt;mask&gt;.&quot;</span>, return_tensors=<span class="hljs-string">&quot;pt&quot;</span>)

<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">with</span> torch.no_grad():
<span class="hljs-meta">... </span>    logits = model(**inputs).logits

<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-comment"># retrieve index of &lt;mask&gt;</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>mask_token_index = (inputs.input_ids == tokenizer.mask_token_id)[<span class="hljs-number">0</span>].nonzero(as_tuple=<span class="hljs-literal">True</span>)[<span class="hljs-number">0</span>]

<span class="hljs-meta">&gt;&gt;&gt; </span>predicted_token_id = logits[<span class="hljs-number">0</span>, mask_token_index].argmax(axis=-<span class="hljs-number">1</span>)

<span class="hljs-meta">&gt;&gt;&gt; </span>labels = tokenizer(<span class="hljs-string">&quot;The capital of France is Paris.&quot;</span>, return_tensors=<span class="hljs-string">&quot;pt&quot;</span>)[<span class="hljs-string">&quot;input_ids&quot;</span>]
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-comment"># mask labels of non-&lt;mask&gt; tokens</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>labels = torch.where(inputs.input_ids == tokenizer.mask_token_id, labels, -<span class="hljs-number">100</span>)

<span class="hljs-meta">&gt;&gt;&gt; </span>outputs = model(**inputs, labels=labels)`}}),{c(){d=s("p"),k=t("Example:"),h=u(),w(f.$$.fragment)},l(l){d=r(l,"P",{});var c=a(d);k=o(c,"Example:"),c.forEach(n),h=p(l),F(f.$$.fragment,l)},m(l,c){_(l,d,c),e(d,k),_(l,h,c),v(f,l,c),T=!0},p:Ge,i(l){T||($(f.$$.fragment,l),T=!0)},o(l){E(f.$$.fragment,l),T=!1},d(l){l&&n(d),l&&n(h),M(f,l)}}}function L$(x){let d,k,h,f,T;return{c(){d=s("p"),k=t("Although the recipe for forward pass needs to be defined within this function, one should call the "),h=s("code"),f=t("Module"),T=t(`
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(l){d=r(l,"P",{});var c=a(d);k=o(c,"Although the recipe for forward pass needs to be defined within this function, one should call the "),h=r(c,"CODE",{});var P=a(h);f=o(P,"Module"),P.forEach(n),T=o(c,`
instance afterwards instead of this since the former takes care of running the pre and post processing steps while
the latter silently ignores them.`),c.forEach(n)},m(l,c){_(l,d,c),e(d,k),e(d,h),e(h,f),e(d,T)},d(l){l&&n(d)}}}function D$(x){let d,k,h,f,T;return f=new Ze({props:{code:`import torch
from transformers import AutoTokenizer, FunnelForSequenceClassification

tokenizer = AutoTokenizer.from_pretrained("funnel-transformer/small-base")
model = FunnelForSequenceClassification.from_pretrained("funnel-transformer/small-base")

inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")

with torch.no_grad():
    logits = model(**inputs).logits

predicted_class_id = logits.argmax().item()

# To train a model on \`num_labels\` classes, you can pass \`num_labels=num_labels\` to \`.from_pretrained(...)\`
num_labels = len(model.config.id2label)
model = FunnelForSequenceClassification.from_pretrained("funnel-transformer/small-base", num_labels=num_labels)

labels = torch.tensor([1])
loss = model(**inputs, labels=labels).loss`,highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">import</span> torch
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> AutoTokenizer, FunnelForSequenceClassification

<span class="hljs-meta">&gt;&gt;&gt; </span>tokenizer = AutoTokenizer.from_pretrained(<span class="hljs-string">&quot;funnel-transformer/small-base&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>model = FunnelForSequenceClassification.from_pretrained(<span class="hljs-string">&quot;funnel-transformer/small-base&quot;</span>)

<span class="hljs-meta">&gt;&gt;&gt; </span>inputs = tokenizer(<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><span class="hljs-keyword">with</span> torch.no_grad():
<span class="hljs-meta">... </span>    logits = model(**inputs).logits

<span class="hljs-meta">&gt;&gt;&gt; </span>predicted_class_id = logits.argmax().item()

<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-comment"># To train a model on \`num_labels\` classes, you can pass \`num_labels=num_labels\` to \`.from_pretrained(...)\`</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>num_labels = <span class="hljs-built_in">len</span>(model.config.id2label)
<span class="hljs-meta">&gt;&gt;&gt; </span>model = FunnelForSequenceClassification.from_pretrained(<span class="hljs-string">&quot;funnel-transformer/small-base&quot;</span>, num_labels=num_labels)

<span class="hljs-meta">&gt;&gt;&gt; </span>labels = torch.tensor([<span class="hljs-number">1</span>])
<span class="hljs-meta">&gt;&gt;&gt; </span>loss = model(**inputs, labels=labels).loss`}}),{c(){d=s("p"),k=t("Example of single-label classification:"),h=u(),w(f.$$.fragment)},l(l){d=r(l,"P",{});var c=a(d);k=o(c,"Example of single-label classification:"),c.forEach(n),h=p(l),F(f.$$.fragment,l)},m(l,c){_(l,d,c),e(d,k),_(l,h,c),v(f,l,c),T=!0},p:Ge,i(l){T||($(f.$$.fragment,l),T=!0)},o(l){E(f.$$.fragment,l),T=!1},d(l){l&&n(d),l&&n(h),M(f,l)}}}function N$(x){let d,k,h,f,T;return f=new Ze({props:{code:`import torch
from transformers import AutoTokenizer, FunnelForSequenceClassification

tokenizer = AutoTokenizer.from_pretrained("funnel-transformer/small-base")
model = FunnelForSequenceClassification.from_pretrained("funnel-transformer/small-base", problem_type="multi_label_classification")

inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")

with torch.no_grad():
    logits = model(**inputs).logits

predicted_class_ids = torch.arange(0, logits.shape[-1])[torch.sigmoid(logits).squeeze(dim=0) > 0.5]

# To train a model on \`num_labels\` classes, you can pass \`num_labels=num_labels\` to \`.from_pretrained(...)\`
num_labels = len(model.config.id2label)
model = FunnelForSequenceClassification.from_pretrained(
    "funnel-transformer/small-base", num_labels=num_labels, problem_type="multi_label_classification"
)

labels = torch.sum(
    torch.nn.functional.one_hot(predicted_class_ids[None, :].clone(), num_classes=num_labels), dim=1
).to(torch.float)
loss = model(**inputs, labels=labels).loss`,highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">import</span> torch
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> AutoTokenizer, FunnelForSequenceClassification

<span class="hljs-meta">&gt;&gt;&gt; </span>tokenizer = AutoTokenizer.from_pretrained(<span class="hljs-string">&quot;funnel-transformer/small-base&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>model = FunnelForSequenceClassification.from_pretrained(<span class="hljs-string">&quot;funnel-transformer/small-base&quot;</span>, problem_type=<span class="hljs-string">&quot;multi_label_classification&quot;</span>)

<span class="hljs-meta">&gt;&gt;&gt; </span>inputs = tokenizer(<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><span class="hljs-keyword">with</span> torch.no_grad():
<span class="hljs-meta">... </span>    logits = model(**inputs).logits

<span class="hljs-meta">&gt;&gt;&gt; </span>predicted_class_ids = torch.arange(<span class="hljs-number">0</span>, logits.shape[-<span class="hljs-number">1</span>])[torch.sigmoid(logits).squeeze(dim=<span class="hljs-number">0</span>) &gt; <span class="hljs-number">0.5</span>]

<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-comment"># To train a model on \`num_labels\` classes, you can pass \`num_labels=num_labels\` to \`.from_pretrained(...)\`</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>num_labels = <span class="hljs-built_in">len</span>(model.config.id2label)
<span class="hljs-meta">&gt;&gt;&gt; </span>model = FunnelForSequenceClassification.from_pretrained(
<span class="hljs-meta">... </span>    <span class="hljs-string">&quot;funnel-transformer/small-base&quot;</span>, num_labels=num_labels, problem_type=<span class="hljs-string">&quot;multi_label_classification&quot;</span>
<span class="hljs-meta">... </span>)

<span class="hljs-meta">&gt;&gt;&gt; </span>labels = torch.<span class="hljs-built_in">sum</span>(
<span class="hljs-meta">... </span>    torch.nn.functional.one_hot(predicted_class_ids[<span class="hljs-literal">None</span>, :].clone(), num_classes=num_labels), dim=<span class="hljs-number">1</span>
<span class="hljs-meta">... </span>).to(torch.<span class="hljs-built_in">float</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>loss = model(**inputs, labels=labels).loss`}}),{c(){d=s("p"),k=t("Example of multi-label classification:"),h=u(),w(f.$$.fragment)},l(l){d=r(l,"P",{});var c=a(d);k=o(c,"Example of multi-label classification:"),c.forEach(n),h=p(l),F(f.$$.fragment,l)},m(l,c){_(l,d,c),e(d,k),_(l,h,c),v(f,l,c),T=!0},p:Ge,i(l){T||($(f.$$.fragment,l),T=!0)},o(l){E(f.$$.fragment,l),T=!1},d(l){l&&n(d),l&&n(h),M(f,l)}}}function I$(x){let d,k,h,f,T;return{c(){d=s("p"),k=t("Although the recipe for forward pass needs to be defined within this function, one should call the "),h=s("code"),f=t("Module"),T=t(`
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(l){d=r(l,"P",{});var c=a(d);k=o(c,"Although the recipe for forward pass needs to be defined within this function, one should call the "),h=r(c,"CODE",{});var P=a(h);f=o(P,"Module"),P.forEach(n),T=o(c,`
instance afterwards instead of this since the former takes care of running the pre and post processing steps while
the latter silently ignores them.`),c.forEach(n)},m(l,c){_(l,d,c),e(d,k),e(d,h),e(h,f),e(d,T)},d(l){l&&n(d)}}}function S$(x){let d,k,h,f,T;return f=new Ze({props:{code:`from transformers import AutoTokenizer, FunnelForMultipleChoice
import torch

tokenizer = AutoTokenizer.from_pretrained("funnel-transformer/small-base")
model = FunnelForMultipleChoice.from_pretrained("funnel-transformer/small-base")

prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
choice0 = "It is eaten with a fork and a knife."
choice1 = "It is eaten while held in the hand."
labels = torch.tensor(0).unsqueeze(0)  # choice0 is correct (according to Wikipedia ;)), batch size 1

encoding = tokenizer([prompt, prompt], [choice0, choice1], return_tensors="pt", padding=True)
outputs = model(**{k: v.unsqueeze(0) for k, v in encoding.items()}, labels=labels)  # batch size is 1

# the linear classifier still needs to be trained
loss = outputs.loss
logits = outputs.logits`,highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> AutoTokenizer, FunnelForMultipleChoice
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">import</span> torch

<span class="hljs-meta">&gt;&gt;&gt; </span>tokenizer = AutoTokenizer.from_pretrained(<span class="hljs-string">&quot;funnel-transformer/small-base&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>model = FunnelForMultipleChoice.from_pretrained(<span class="hljs-string">&quot;funnel-transformer/small-base&quot;</span>)

<span class="hljs-meta">&gt;&gt;&gt; </span>prompt = <span class="hljs-string">&quot;In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced.&quot;</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>choice0 = <span class="hljs-string">&quot;It is eaten with a fork and a knife.&quot;</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>choice1 = <span class="hljs-string">&quot;It is eaten while held in the hand.&quot;</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>labels = torch.tensor(<span class="hljs-number">0</span>).unsqueeze(<span class="hljs-number">0</span>)  <span class="hljs-comment"># choice0 is correct (according to Wikipedia ;)), batch size 1</span>

<span class="hljs-meta">&gt;&gt;&gt; </span>encoding = tokenizer([prompt, prompt], [choice0, choice1], return_tensors=<span class="hljs-string">&quot;pt&quot;</span>, padding=<span class="hljs-literal">True</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>outputs = model(**{k: v.unsqueeze(<span class="hljs-number">0</span>) <span class="hljs-keyword">for</span> k, v <span class="hljs-keyword">in</span> encoding.items()}, labels=labels)  <span class="hljs-comment"># batch size is 1</span>

<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-comment"># the linear classifier still needs to be trained</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>loss = outputs.loss
<span class="hljs-meta">&gt;&gt;&gt; </span>logits = outputs.logits`}}),{c(){d=s("p"),k=t("Example:"),h=u(),w(f.$$.fragment)},l(l){d=r(l,"P",{});var c=a(d);k=o(c,"Example:"),c.forEach(n),h=p(l),F(f.$$.fragment,l)},m(l,c){_(l,d,c),e(d,k),_(l,h,c),v(f,l,c),T=!0},p:Ge,i(l){T||($(f.$$.fragment,l),T=!0)},o(l){E(f.$$.fragment,l),T=!1},d(l){l&&n(d),l&&n(h),M(f,l)}}}function B$(x){let d,k,h,f,T;return{c(){d=s("p"),k=t("Although the recipe for forward pass needs to be defined within this function, one should call the "),h=s("code"),f=t("Module"),T=t(`
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(l){d=r(l,"P",{});var c=a(d);k=o(c,"Although the recipe for forward pass needs to be defined within this function, one should call the "),h=r(c,"CODE",{});var P=a(h);f=o(P,"Module"),P.forEach(n),T=o(c,`
instance afterwards instead of this since the former takes care of running the pre and post processing steps while
the latter silently ignores them.`),c.forEach(n)},m(l,c){_(l,d,c),e(d,k),e(d,h),e(h,f),e(d,T)},d(l){l&&n(d)}}}function W$(x){let d,k,h,f,T;return f=new Ze({props:{code:`from transformers import AutoTokenizer, FunnelForTokenClassification
import torch

tokenizer = AutoTokenizer.from_pretrained("funnel-transformer/small")
model = FunnelForTokenClassification.from_pretrained("funnel-transformer/small")

inputs = tokenizer(
    "HuggingFace is a company based in Paris and New York", add_special_tokens=False, return_tensors="pt"
)

with torch.no_grad():
    logits = model(**inputs).logits

predicted_token_class_ids = logits.argmax(-1)

# Note that tokens are classified rather then input words which means that
# there might be more predicted token classes than words.
# Multiple token classes might account for the same word
predicted_tokens_classes = [model.config.id2label[t.item()] for t in predicted_token_class_ids[0]]

labels = predicted_token_class_ids
loss = model(**inputs, labels=labels).loss`,highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> AutoTokenizer, FunnelForTokenClassification
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">import</span> torch

<span class="hljs-meta">&gt;&gt;&gt; </span>tokenizer = AutoTokenizer.from_pretrained(<span class="hljs-string">&quot;funnel-transformer/small&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>model = FunnelForTokenClassification.from_pretrained(<span class="hljs-string">&quot;funnel-transformer/small&quot;</span>)

<span class="hljs-meta">&gt;&gt;&gt; </span>inputs = tokenizer(
<span class="hljs-meta">... </span>    <span class="hljs-string">&quot;HuggingFace is a company based in Paris and New York&quot;</span>, add_special_tokens=<span class="hljs-literal">False</span>, return_tensors=<span class="hljs-string">&quot;pt&quot;</span>
<span class="hljs-meta">... </span>)

<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">with</span> torch.no_grad():
<span class="hljs-meta">... </span>    logits = model(**inputs).logits

<span class="hljs-meta">&gt;&gt;&gt; </span>predicted_token_class_ids = logits.argmax(-<span class="hljs-number">1</span>)

<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-comment"># Note that tokens are classified rather then input words which means that</span>
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-comment"># there might be more predicted token classes than words.</span>
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-comment"># Multiple token classes might account for the same word</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>predicted_tokens_classes = [model.config.id2label[t.item()] <span class="hljs-keyword">for</span> t <span class="hljs-keyword">in</span> predicted_token_class_ids[<span class="hljs-number">0</span>]]

<span class="hljs-meta">&gt;&gt;&gt; </span>labels = predicted_token_class_ids
<span class="hljs-meta">&gt;&gt;&gt; </span>loss = model(**inputs, labels=labels).loss`}}),{c(){d=s("p"),k=t("Example:"),h=u(),w(f.$$.fragment)},l(l){d=r(l,"P",{});var c=a(d);k=o(c,"Example:"),c.forEach(n),h=p(l),F(f.$$.fragment,l)},m(l,c){_(l,d,c),e(d,k),_(l,h,c),v(f,l,c),T=!0},p:Ge,i(l){T||($(f.$$.fragment,l),T=!0)},o(l){E(f.$$.fragment,l),T=!1},d(l){l&&n(d),l&&n(h),M(f,l)}}}function Q$(x){let d,k,h,f,T;return{c(){d=s("p"),k=t("Although the recipe for forward pass needs to be defined within this function, one should call the "),h=s("code"),f=t("Module"),T=t(`
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(l){d=r(l,"P",{});var c=a(d);k=o(c,"Although the recipe for forward pass needs to be defined within this function, one should call the "),h=r(c,"CODE",{});var P=a(h);f=o(P,"Module"),P.forEach(n),T=o(c,`
instance afterwards instead of this since the former takes care of running the pre and post processing steps while
the latter silently ignores them.`),c.forEach(n)},m(l,c){_(l,d,c),e(d,k),e(d,h),e(h,f),e(d,T)},d(l){l&&n(d)}}}function U$(x){let d,k,h,f,T;return f=new Ze({props:{code:`from transformers import AutoTokenizer, FunnelForQuestionAnswering
import torch

tokenizer = AutoTokenizer.from_pretrained("funnel-transformer/small")
model = FunnelForQuestionAnswering.from_pretrained("funnel-transformer/small")

question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"

inputs = tokenizer(question, text, return_tensors="pt")
with torch.no_grad():
    outputs = model(**inputs)

answer_start_index = outputs.start_logits.argmax()
answer_end_index = outputs.end_logits.argmax()

predict_answer_tokens = inputs.input_ids[0, answer_start_index : answer_end_index + 1]

# target is "nice puppet"
target_start_index = torch.tensor([14])
target_end_index = torch.tensor([15])

outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index)
loss = outputs.loss`,highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> AutoTokenizer, FunnelForQuestionAnswering
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">import</span> torch

<span class="hljs-meta">&gt;&gt;&gt; </span>tokenizer = AutoTokenizer.from_pretrained(<span class="hljs-string">&quot;funnel-transformer/small&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>model = FunnelForQuestionAnswering.from_pretrained(<span class="hljs-string">&quot;funnel-transformer/small&quot;</span>)

<span class="hljs-meta">&gt;&gt;&gt; </span>question, text = <span class="hljs-string">&quot;Who was Jim Henson?&quot;</span>, <span class="hljs-string">&quot;Jim Henson was a nice puppet&quot;</span>

<span class="hljs-meta">&gt;&gt;&gt; </span>inputs = tokenizer(question, text, return_tensors=<span class="hljs-string">&quot;pt&quot;</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-meta">&gt;&gt;&gt; </span>answer_start_index = outputs.start_logits.argmax()
<span class="hljs-meta">&gt;&gt;&gt; </span>answer_end_index = outputs.end_logits.argmax()

<span class="hljs-meta">&gt;&gt;&gt; </span>predict_answer_tokens = inputs.input_ids[<span class="hljs-number">0</span>, answer_start_index : answer_end_index + <span class="hljs-number">1</span>]

<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-comment"># target is &quot;nice puppet&quot;</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>target_start_index = torch.tensor([<span class="hljs-number">14</span>])
<span class="hljs-meta">&gt;&gt;&gt; </span>target_end_index = torch.tensor([<span class="hljs-number">15</span>])

<span class="hljs-meta">&gt;&gt;&gt; </span>outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index)
<span class="hljs-meta">&gt;&gt;&gt; </span>loss = outputs.loss`}}),{c(){d=s("p"),k=t("Example:"),h=u(),w(f.$$.fragment)},l(l){d=r(l,"P",{});var c=a(d);k=o(c,"Example:"),c.forEach(n),h=p(l),F(f.$$.fragment,l)},m(l,c){_(l,d,c),e(d,k),_(l,h,c),v(f,l,c),T=!0},p:Ge,i(l){T||($(f.$$.fragment,l),T=!0)},o(l){E(f.$$.fragment,l),T=!1},d(l){l&&n(d),l&&n(h),M(f,l)}}}function K$(x){let d,k,h,f,T,l,c,P,ke,he,I,re,ee,b,Te,K,ye,fe,B,be,ae,H,we,me,Q,Fe,ge,U,ue,ve,oe,C,A,_e,W,pe,$e,V,R,Ee,j,Me,Y,le,ze,G,de,qe,N,ce,Z,Pe,ne,O,xe,L,Ce,je;return{c(){d=s("p"),k=t("TensorFlow models and layers in "),h=s("code"),f=t("transformers"),T=t(" accept two formats as input:"),l=u(),c=s("ul"),P=s("li"),ke=t("having all inputs as keyword arguments (like PyTorch models), or"),he=u(),I=s("li"),re=t("having all inputs as a list, tuple or dict in the first positional argument."),ee=u(),b=s("p"),Te=t(`The reason the second format is supported is that Keras methods prefer this format when passing inputs to models
and layers. Because of this support, when using methods like `),K=s("code"),ye=t("model.fit()"),fe=t(` things should \u201Cjust work\u201D for you - just
pass your inputs and labels in any format that `),B=s("code"),be=t("model.fit()"),ae=t(` supports! If, however, you want to use the second
format outside of Keras methods like `),H=s("code"),we=t("fit()"),me=t(" and "),Q=s("code"),Fe=t("predict()"),ge=t(`, such as when creating your own layers or models with
the Keras `),U=s("code"),ue=t("Functional"),ve=t(` API, there are three possibilities you can use to gather all the input Tensors in the first
positional argument:`),oe=u(),C=s("ul"),A=s("li"),_e=t("a single Tensor with "),W=s("code"),pe=t("input_ids"),$e=t(" only and nothing else: "),V=s("code"),R=t("model(input_ids)"),Ee=u(),j=s("li"),Me=t(`a list of varying length with one or several input Tensors IN THE ORDER given in the docstring:
`),Y=s("code"),le=t("model([input_ids, attention_mask])"),ze=t(" or "),G=s("code"),de=t("model([input_ids, attention_mask, token_type_ids])"),qe=u(),N=s("li"),ce=t(`a dictionary with one or several input Tensors associated to the input names given in the docstring:
`),Z=s("code"),Pe=t('model({"input_ids": input_ids, "token_type_ids": token_type_ids})'),ne=u(),O=s("p"),xe=t(`Note that when creating models and layers with
`),L=s("a"),Ce=t("subclassing"),je=t(` then you don\u2019t need to worry
about any of this, as you can just pass inputs like you would to any other Python function!`),this.h()},l(g){d=r(g,"P",{});var z=a(d);k=o(z,"TensorFlow models and layers in "),h=r(z,"CODE",{});var Ie=a(h);f=o(Ie,"transformers"),Ie.forEach(n),T=o(z," accept two formats as input:"),z.forEach(n),l=p(g),c=r(g,"UL",{});var J=a(c);P=r(J,"LI",{});var Se=a(P);ke=o(Se,"having all inputs as keyword arguments (like PyTorch models), or"),Se.forEach(n),he=p(J),I=r(J,"LI",{});var Be=a(I);re=o(Be,"having all inputs as a list, tuple or dict in the first positional argument."),Be.forEach(n),J.forEach(n),ee=p(g),b=r(g,"P",{});var q=a(b);Te=o(q,`The reason the second format is supported is that Keras methods prefer this format when passing inputs to models
and layers. Because of this support, when using methods like `),K=r(q,"CODE",{});var Ae=a(K);ye=o(Ae,"model.fit()"),Ae.forEach(n),fe=o(q,` things should \u201Cjust work\u201D for you - just
pass your inputs and labels in any format that `),B=r(q,"CODE",{});var We=a(B);be=o(We,"model.fit()"),We.forEach(n),ae=o(q,` supports! If, however, you want to use the second
format outside of Keras methods like `),H=r(q,"CODE",{});var Le=a(H);we=o(Le,"fit()"),Le.forEach(n),me=o(q," and "),Q=r(q,"CODE",{});var Qe=a(Q);Fe=o(Qe,"predict()"),Qe.forEach(n),ge=o(q,`, such as when creating your own layers or models with
the Keras `),U=r(q,"CODE",{});var Ue=a(U);ue=o(Ue,"Functional"),Ue.forEach(n),ve=o(q,` API, there are three possibilities you can use to gather all the input Tensors in the first
positional argument:`),q.forEach(n),oe=p(g),C=r(g,"UL",{});var D=a(C);A=r(D,"LI",{});var X=a(A);_e=o(X,"a single Tensor with "),W=r(X,"CODE",{});var Ke=a(W);pe=o(Ke,"input_ids"),Ke.forEach(n),$e=o(X," only and nothing else: "),V=r(X,"CODE",{});var Ne=a(V);R=o(Ne,"model(input_ids)"),Ne.forEach(n),X.forEach(n),Ee=p(D),j=r(D,"LI",{});var S=a(j);Me=o(S,`a list of varying length with one or several input Tensors IN THE ORDER given in the docstring:
`),Y=r(S,"CODE",{});var Oe=a(Y);le=o(Oe,"model([input_ids, attention_mask])"),Oe.forEach(n),ze=o(S," or "),G=r(S,"CODE",{});var De=a(G);de=o(De,"model([input_ids, attention_mask, token_type_ids])"),De.forEach(n),S.forEach(n),qe=p(D),N=r(D,"LI",{});var ie=a(N);ce=o(ie,`a dictionary with one or several input Tensors associated to the input names given in the docstring:
`),Z=r(ie,"CODE",{});var Re=a(Z);Pe=o(Re,'model({"input_ids": input_ids, "token_type_ids": token_type_ids})'),Re.forEach(n),ie.forEach(n),D.forEach(n),ne=p(g),O=r(g,"P",{});var te=a(O);xe=o(te,`Note that when creating models and layers with
`),L=r(te,"A",{href:!0,rel:!0});var He=a(L);Ce=o(He,"subclassing"),He.forEach(n),je=o(te,` then you don\u2019t need to worry
about any of this, as you can just pass inputs like you would to any other Python function!`),te.forEach(n),this.h()},h(){m(L,"href","https://keras.io/guides/making_new_layers_and_models_via_subclassing/"),m(L,"rel","nofollow")},m(g,z){_(g,d,z),e(d,k),e(d,h),e(h,f),e(d,T),_(g,l,z),_(g,c,z),e(c,P),e(P,ke),e(c,he),e(c,I),e(I,re),_(g,ee,z),_(g,b,z),e(b,Te),e(b,K),e(K,ye),e(b,fe),e(b,B),e(B,be),e(b,ae),e(b,H),e(H,we),e(b,me),e(b,Q),e(Q,Fe),e(b,ge),e(b,U),e(U,ue),e(b,ve),_(g,oe,z),_(g,C,z),e(C,A),e(A,_e),e(A,W),e(W,pe),e(A,$e),e(A,V),e(V,R),e(C,Ee),e(C,j),e(j,Me),e(j,Y),e(Y,le),e(j,ze),e(j,G),e(G,de),e(C,qe),e(C,N),e(N,ce),e(N,Z),e(Z,Pe),_(g,ne,z),_(g,O,z),e(O,xe),e(O,L),e(L,Ce),e(O,je)},d(g){g&&n(d),g&&n(l),g&&n(c),g&&n(ee),g&&n(b),g&&n(oe),g&&n(C),g&&n(ne),g&&n(O)}}}function R$(x){let d,k,h,f,T;return{c(){d=s("p"),k=t("Although the recipe for forward pass needs to be defined within this function, one should call the "),h=s("code"),f=t("Module"),T=t(`
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(l){d=r(l,"P",{});var c=a(d);k=o(c,"Although the recipe for forward pass needs to be defined within this function, one should call the "),h=r(c,"CODE",{});var P=a(h);f=o(P,"Module"),P.forEach(n),T=o(c,`
instance afterwards instead of this since the former takes care of running the pre and post processing steps while
the latter silently ignores them.`),c.forEach(n)},m(l,c){_(l,d,c),e(d,k),e(d,h),e(h,f),e(d,T)},d(l){l&&n(d)}}}function H$(x){let d,k,h,f,T;return f=new Ze({props:{code:`from transformers import AutoTokenizer, TFFunnelBaseModel
import tensorflow as tf

tokenizer = AutoTokenizer.from_pretrained("funnel-transformer/small-base")
model = TFFunnelBaseModel.from_pretrained("funnel-transformer/small-base")

inputs = tokenizer("Hello, my dog is cute", return_tensors="tf")
outputs = model(inputs)

last_hidden_states = outputs.last_hidden_state`,highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> AutoTokenizer, TFFunnelBaseModel
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">import</span> tensorflow <span class="hljs-keyword">as</span> tf

<span class="hljs-meta">&gt;&gt;&gt; </span>tokenizer = AutoTokenizer.from_pretrained(<span class="hljs-string">&quot;funnel-transformer/small-base&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>model = TFFunnelBaseModel.from_pretrained(<span class="hljs-string">&quot;funnel-transformer/small-base&quot;</span>)

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

<span class="hljs-meta">&gt;&gt;&gt; </span>last_hidden_states = outputs.last_hidden_state`}}),{c(){d=s("p"),k=t("Example:"),h=u(),w(f.$$.fragment)},l(l){d=r(l,"P",{});var c=a(d);k=o(c,"Example:"),c.forEach(n),h=p(l),F(f.$$.fragment,l)},m(l,c){_(l,d,c),e(d,k),_(l,h,c),v(f,l,c),T=!0},p:Ge,i(l){T||($(f.$$.fragment,l),T=!0)},o(l){E(f.$$.fragment,l),T=!1},d(l){l&&n(d),l&&n(h),M(f,l)}}}function V$(x){let d,k,h,f,T,l,c,P,ke,he,I,re,ee,b,Te,K,ye,fe,B,be,ae,H,we,me,Q,Fe,ge,U,ue,ve,oe,C,A,_e,W,pe,$e,V,R,Ee,j,Me,Y,le,ze,G,de,qe,N,ce,Z,Pe,ne,O,xe,L,Ce,je;return{c(){d=s("p"),k=t("TensorFlow models and layers in "),h=s("code"),f=t("transformers"),T=t(" accept two formats as input:"),l=u(),c=s("ul"),P=s("li"),ke=t("having all inputs as keyword arguments (like PyTorch models), or"),he=u(),I=s("li"),re=t("having all inputs as a list, tuple or dict in the first positional argument."),ee=u(),b=s("p"),Te=t(`The reason the second format is supported is that Keras methods prefer this format when passing inputs to models
and layers. Because of this support, when using methods like `),K=s("code"),ye=t("model.fit()"),fe=t(` things should \u201Cjust work\u201D for you - just
pass your inputs and labels in any format that `),B=s("code"),be=t("model.fit()"),ae=t(` supports! If, however, you want to use the second
format outside of Keras methods like `),H=s("code"),we=t("fit()"),me=t(" and "),Q=s("code"),Fe=t("predict()"),ge=t(`, such as when creating your own layers or models with
the Keras `),U=s("code"),ue=t("Functional"),ve=t(` API, there are three possibilities you can use to gather all the input Tensors in the first
positional argument:`),oe=u(),C=s("ul"),A=s("li"),_e=t("a single Tensor with "),W=s("code"),pe=t("input_ids"),$e=t(" only and nothing else: "),V=s("code"),R=t("model(input_ids)"),Ee=u(),j=s("li"),Me=t(`a list of varying length with one or several input Tensors IN THE ORDER given in the docstring:
`),Y=s("code"),le=t("model([input_ids, attention_mask])"),ze=t(" or "),G=s("code"),de=t("model([input_ids, attention_mask, token_type_ids])"),qe=u(),N=s("li"),ce=t(`a dictionary with one or several input Tensors associated to the input names given in the docstring:
`),Z=s("code"),Pe=t('model({"input_ids": input_ids, "token_type_ids": token_type_ids})'),ne=u(),O=s("p"),xe=t(`Note that when creating models and layers with
`),L=s("a"),Ce=t("subclassing"),je=t(` then you don\u2019t need to worry
about any of this, as you can just pass inputs like you would to any other Python function!`),this.h()},l(g){d=r(g,"P",{});var z=a(d);k=o(z,"TensorFlow models and layers in "),h=r(z,"CODE",{});var Ie=a(h);f=o(Ie,"transformers"),Ie.forEach(n),T=o(z," accept two formats as input:"),z.forEach(n),l=p(g),c=r(g,"UL",{});var J=a(c);P=r(J,"LI",{});var Se=a(P);ke=o(Se,"having all inputs as keyword arguments (like PyTorch models), or"),Se.forEach(n),he=p(J),I=r(J,"LI",{});var Be=a(I);re=o(Be,"having all inputs as a list, tuple or dict in the first positional argument."),Be.forEach(n),J.forEach(n),ee=p(g),b=r(g,"P",{});var q=a(b);Te=o(q,`The reason the second format is supported is that Keras methods prefer this format when passing inputs to models
and layers. Because of this support, when using methods like `),K=r(q,"CODE",{});var Ae=a(K);ye=o(Ae,"model.fit()"),Ae.forEach(n),fe=o(q,` things should \u201Cjust work\u201D for you - just
pass your inputs and labels in any format that `),B=r(q,"CODE",{});var We=a(B);be=o(We,"model.fit()"),We.forEach(n),ae=o(q,` supports! If, however, you want to use the second
format outside of Keras methods like `),H=r(q,"CODE",{});var Le=a(H);we=o(Le,"fit()"),Le.forEach(n),me=o(q," and "),Q=r(q,"CODE",{});var Qe=a(Q);Fe=o(Qe,"predict()"),Qe.forEach(n),ge=o(q,`, such as when creating your own layers or models with
the Keras `),U=r(q,"CODE",{});var Ue=a(U);ue=o(Ue,"Functional"),Ue.forEach(n),ve=o(q,` API, there are three possibilities you can use to gather all the input Tensors in the first
positional argument:`),q.forEach(n),oe=p(g),C=r(g,"UL",{});var D=a(C);A=r(D,"LI",{});var X=a(A);_e=o(X,"a single Tensor with "),W=r(X,"CODE",{});var Ke=a(W);pe=o(Ke,"input_ids"),Ke.forEach(n),$e=o(X," only and nothing else: "),V=r(X,"CODE",{});var Ne=a(V);R=o(Ne,"model(input_ids)"),Ne.forEach(n),X.forEach(n),Ee=p(D),j=r(D,"LI",{});var S=a(j);Me=o(S,`a list of varying length with one or several input Tensors IN THE ORDER given in the docstring:
`),Y=r(S,"CODE",{});var Oe=a(Y);le=o(Oe,"model([input_ids, attention_mask])"),Oe.forEach(n),ze=o(S," or "),G=r(S,"CODE",{});var De=a(G);de=o(De,"model([input_ids, attention_mask, token_type_ids])"),De.forEach(n),S.forEach(n),qe=p(D),N=r(D,"LI",{});var ie=a(N);ce=o(ie,`a dictionary with one or several input Tensors associated to the input names given in the docstring:
`),Z=r(ie,"CODE",{});var Re=a(Z);Pe=o(Re,'model({"input_ids": input_ids, "token_type_ids": token_type_ids})'),Re.forEach(n),ie.forEach(n),D.forEach(n),ne=p(g),O=r(g,"P",{});var te=a(O);xe=o(te,`Note that when creating models and layers with
`),L=r(te,"A",{href:!0,rel:!0});var He=a(L);Ce=o(He,"subclassing"),He.forEach(n),je=o(te,` then you don\u2019t need to worry
about any of this, as you can just pass inputs like you would to any other Python function!`),te.forEach(n),this.h()},h(){m(L,"href","https://keras.io/guides/making_new_layers_and_models_via_subclassing/"),m(L,"rel","nofollow")},m(g,z){_(g,d,z),e(d,k),e(d,h),e(h,f),e(d,T),_(g,l,z),_(g,c,z),e(c,P),e(P,ke),e(c,he),e(c,I),e(I,re),_(g,ee,z),_(g,b,z),e(b,Te),e(b,K),e(K,ye),e(b,fe),e(b,B),e(B,be),e(b,ae),e(b,H),e(H,we),e(b,me),e(b,Q),e(Q,Fe),e(b,ge),e(b,U),e(U,ue),e(b,ve),_(g,oe,z),_(g,C,z),e(C,A),e(A,_e),e(A,W),e(W,pe),e(A,$e),e(A,V),e(V,R),e(C,Ee),e(C,j),e(j,Me),e(j,Y),e(Y,le),e(j,ze),e(j,G),e(G,de),e(C,qe),e(C,N),e(N,ce),e(N,Z),e(Z,Pe),_(g,ne,z),_(g,O,z),e(O,xe),e(O,L),e(L,Ce),e(O,je)},d(g){g&&n(d),g&&n(l),g&&n(c),g&&n(ee),g&&n(b),g&&n(oe),g&&n(C),g&&n(ne),g&&n(O)}}}function Y$(x){let d,k,h,f,T;return{c(){d=s("p"),k=t("Although the recipe for forward pass needs to be defined within this function, one should call the "),h=s("code"),f=t("Module"),T=t(`
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(l){d=r(l,"P",{});var c=a(d);k=o(c,"Although the recipe for forward pass needs to be defined within this function, one should call the "),h=r(c,"CODE",{});var P=a(h);f=o(P,"Module"),P.forEach(n),T=o(c,`
instance afterwards instead of this since the former takes care of running the pre and post processing steps while
the latter silently ignores them.`),c.forEach(n)},m(l,c){_(l,d,c),e(d,k),e(d,h),e(h,f),e(d,T)},d(l){l&&n(d)}}}function G$(x){let d,k,h,f,T;return f=new Ze({props:{code:`from transformers import AutoTokenizer, TFFunnelModel
import tensorflow as tf

tokenizer = AutoTokenizer.from_pretrained("funnel-transformer/small")
model = TFFunnelModel.from_pretrained("funnel-transformer/small")

inputs = tokenizer("Hello, my dog is cute", return_tensors="tf")
outputs = model(inputs)

last_hidden_states = outputs.last_hidden_state`,highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> AutoTokenizer, TFFunnelModel
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">import</span> tensorflow <span class="hljs-keyword">as</span> tf

<span class="hljs-meta">&gt;&gt;&gt; </span>tokenizer = AutoTokenizer.from_pretrained(<span class="hljs-string">&quot;funnel-transformer/small&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>model = TFFunnelModel.from_pretrained(<span class="hljs-string">&quot;funnel-transformer/small&quot;</span>)

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

<span class="hljs-meta">&gt;&gt;&gt; </span>last_hidden_states = outputs.last_hidden_state`}}),{c(){d=s("p"),k=t("Example:"),h=u(),w(f.$$.fragment)},l(l){d=r(l,"P",{});var c=a(d);k=o(c,"Example:"),c.forEach(n),h=p(l),F(f.$$.fragment,l)},m(l,c){_(l,d,c),e(d,k),_(l,h,c),v(f,l,c),T=!0},p:Ge,i(l){T||($(f.$$.fragment,l),T=!0)},o(l){E(f.$$.fragment,l),T=!1},d(l){l&&n(d),l&&n(h),M(f,l)}}}function Z$(x){let d,k,h,f,T,l,c,P,ke,he,I,re,ee,b,Te,K,ye,fe,B,be,ae,H,we,me,Q,Fe,ge,U,ue,ve,oe,C,A,_e,W,pe,$e,V,R,Ee,j,Me,Y,le,ze,G,de,qe,N,ce,Z,Pe,ne,O,xe,L,Ce,je;return{c(){d=s("p"),k=t("TensorFlow models and layers in "),h=s("code"),f=t("transformers"),T=t(" accept two formats as input:"),l=u(),c=s("ul"),P=s("li"),ke=t("having all inputs as keyword arguments (like PyTorch models), or"),he=u(),I=s("li"),re=t("having all inputs as a list, tuple or dict in the first positional argument."),ee=u(),b=s("p"),Te=t(`The reason the second format is supported is that Keras methods prefer this format when passing inputs to models
and layers. Because of this support, when using methods like `),K=s("code"),ye=t("model.fit()"),fe=t(` things should \u201Cjust work\u201D for you - just
pass your inputs and labels in any format that `),B=s("code"),be=t("model.fit()"),ae=t(` supports! If, however, you want to use the second
format outside of Keras methods like `),H=s("code"),we=t("fit()"),me=t(" and "),Q=s("code"),Fe=t("predict()"),ge=t(`, such as when creating your own layers or models with
the Keras `),U=s("code"),ue=t("Functional"),ve=t(` API, there are three possibilities you can use to gather all the input Tensors in the first
positional argument:`),oe=u(),C=s("ul"),A=s("li"),_e=t("a single Tensor with "),W=s("code"),pe=t("input_ids"),$e=t(" only and nothing else: "),V=s("code"),R=t("model(input_ids)"),Ee=u(),j=s("li"),Me=t(`a list of varying length with one or several input Tensors IN THE ORDER given in the docstring:
`),Y=s("code"),le=t("model([input_ids, attention_mask])"),ze=t(" or "),G=s("code"),de=t("model([input_ids, attention_mask, token_type_ids])"),qe=u(),N=s("li"),ce=t(`a dictionary with one or several input Tensors associated to the input names given in the docstring:
`),Z=s("code"),Pe=t('model({"input_ids": input_ids, "token_type_ids": token_type_ids})'),ne=u(),O=s("p"),xe=t(`Note that when creating models and layers with
`),L=s("a"),Ce=t("subclassing"),je=t(` then you don\u2019t need to worry
about any of this, as you can just pass inputs like you would to any other Python function!`),this.h()},l(g){d=r(g,"P",{});var z=a(d);k=o(z,"TensorFlow models and layers in "),h=r(z,"CODE",{});var Ie=a(h);f=o(Ie,"transformers"),Ie.forEach(n),T=o(z," accept two formats as input:"),z.forEach(n),l=p(g),c=r(g,"UL",{});var J=a(c);P=r(J,"LI",{});var Se=a(P);ke=o(Se,"having all inputs as keyword arguments (like PyTorch models), or"),Se.forEach(n),he=p(J),I=r(J,"LI",{});var Be=a(I);re=o(Be,"having all inputs as a list, tuple or dict in the first positional argument."),Be.forEach(n),J.forEach(n),ee=p(g),b=r(g,"P",{});var q=a(b);Te=o(q,`The reason the second format is supported is that Keras methods prefer this format when passing inputs to models
and layers. Because of this support, when using methods like `),K=r(q,"CODE",{});var Ae=a(K);ye=o(Ae,"model.fit()"),Ae.forEach(n),fe=o(q,` things should \u201Cjust work\u201D for you - just
pass your inputs and labels in any format that `),B=r(q,"CODE",{});var We=a(B);be=o(We,"model.fit()"),We.forEach(n),ae=o(q,` supports! If, however, you want to use the second
format outside of Keras methods like `),H=r(q,"CODE",{});var Le=a(H);we=o(Le,"fit()"),Le.forEach(n),me=o(q," and "),Q=r(q,"CODE",{});var Qe=a(Q);Fe=o(Qe,"predict()"),Qe.forEach(n),ge=o(q,`, such as when creating your own layers or models with
the Keras `),U=r(q,"CODE",{});var Ue=a(U);ue=o(Ue,"Functional"),Ue.forEach(n),ve=o(q,` API, there are three possibilities you can use to gather all the input Tensors in the first
positional argument:`),q.forEach(n),oe=p(g),C=r(g,"UL",{});var D=a(C);A=r(D,"LI",{});var X=a(A);_e=o(X,"a single Tensor with "),W=r(X,"CODE",{});var Ke=a(W);pe=o(Ke,"input_ids"),Ke.forEach(n),$e=o(X," only and nothing else: "),V=r(X,"CODE",{});var Ne=a(V);R=o(Ne,"model(input_ids)"),Ne.forEach(n),X.forEach(n),Ee=p(D),j=r(D,"LI",{});var S=a(j);Me=o(S,`a list of varying length with one or several input Tensors IN THE ORDER given in the docstring:
`),Y=r(S,"CODE",{});var Oe=a(Y);le=o(Oe,"model([input_ids, attention_mask])"),Oe.forEach(n),ze=o(S," or "),G=r(S,"CODE",{});var De=a(G);de=o(De,"model([input_ids, attention_mask, token_type_ids])"),De.forEach(n),S.forEach(n),qe=p(D),N=r(D,"LI",{});var ie=a(N);ce=o(ie,`a dictionary with one or several input Tensors associated to the input names given in the docstring:
`),Z=r(ie,"CODE",{});var Re=a(Z);Pe=o(Re,'model({"input_ids": input_ids, "token_type_ids": token_type_ids})'),Re.forEach(n),ie.forEach(n),D.forEach(n),ne=p(g),O=r(g,"P",{});var te=a(O);xe=o(te,`Note that when creating models and layers with
`),L=r(te,"A",{href:!0,rel:!0});var He=a(L);Ce=o(He,"subclassing"),He.forEach(n),je=o(te,` then you don\u2019t need to worry
about any of this, as you can just pass inputs like you would to any other Python function!`),te.forEach(n),this.h()},h(){m(L,"href","https://keras.io/guides/making_new_layers_and_models_via_subclassing/"),m(L,"rel","nofollow")},m(g,z){_(g,d,z),e(d,k),e(d,h),e(h,f),e(d,T),_(g,l,z),_(g,c,z),e(c,P),e(P,ke),e(c,he),e(c,I),e(I,re),_(g,ee,z),_(g,b,z),e(b,Te),e(b,K),e(K,ye),e(b,fe),e(b,B),e(B,be),e(b,ae),e(b,H),e(H,we),e(b,me),e(b,Q),e(Q,Fe),e(b,ge),e(b,U),e(U,ue),e(b,ve),_(g,oe,z),_(g,C,z),e(C,A),e(A,_e),e(A,W),e(W,pe),e(A,$e),e(A,V),e(V,R),e(C,Ee),e(C,j),e(j,Me),e(j,Y),e(Y,le),e(j,ze),e(j,G),e(G,de),e(C,qe),e(C,N),e(N,ce),e(N,Z),e(Z,Pe),_(g,ne,z),_(g,O,z),e(O,xe),e(O,L),e(L,Ce),e(O,je)},d(g){g&&n(d),g&&n(l),g&&n(c),g&&n(ee),g&&n(b),g&&n(oe),g&&n(C),g&&n(ne),g&&n(O)}}}function X$(x){let d,k,h,f,T;return{c(){d=s("p"),k=t("Although the recipe for forward pass needs to be defined within this function, one should call the "),h=s("code"),f=t("Module"),T=t(`
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(l){d=r(l,"P",{});var c=a(d);k=o(c,"Although the recipe for forward pass needs to be defined within this function, one should call the "),h=r(c,"CODE",{});var P=a(h);f=o(P,"Module"),P.forEach(n),T=o(c,`
instance afterwards instead of this since the former takes care of running the pre and post processing steps while
the latter silently ignores them.`),c.forEach(n)},m(l,c){_(l,d,c),e(d,k),e(d,h),e(h,f),e(d,T)},d(l){l&&n(d)}}}function J$(x){let d,k,h,f,T;return f=new Ze({props:{code:`from transformers import AutoTokenizer, TFFunnelForPreTraining
import torch

tokenizer = AutoTokenizer.from_pretrained("funnel-transformer/small")
model = TFFunnelForPreTraining.from_pretrained("funnel-transformer/small")

inputs = tokenizer("Hello, my dog is cute", return_tensors="tf")
logits = model(inputs).logits`,highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> AutoTokenizer, TFFunnelForPreTraining
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">import</span> torch

<span class="hljs-meta">&gt;&gt;&gt; </span>tokenizer = AutoTokenizer.from_pretrained(<span class="hljs-string">&quot;funnel-transformer/small&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>model = TFFunnelForPreTraining.from_pretrained(<span class="hljs-string">&quot;funnel-transformer/small&quot;</span>)

<span class="hljs-meta">&gt;&gt;&gt; </span>inputs = tokenizer(<span class="hljs-string">&quot;Hello, my dog is cute&quot;</span>, return_tensors=<span class="hljs-string">&quot;tf&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>logits = model(inputs).logits`}}),{c(){d=s("p"),k=t("Examples:"),h=u(),w(f.$$.fragment)},l(l){d=r(l,"P",{});var c=a(d);k=o(c,"Examples:"),c.forEach(n),h=p(l),F(f.$$.fragment,l)},m(l,c){_(l,d,c),e(d,k),_(l,h,c),v(f,l,c),T=!0},p:Ge,i(l){T||($(f.$$.fragment,l),T=!0)},o(l){E(f.$$.fragment,l),T=!1},d(l){l&&n(d),l&&n(h),M(f,l)}}}function e1(x){let d,k,h,f,T,l,c,P,ke,he,I,re,ee,b,Te,K,ye,fe,B,be,ae,H,we,me,Q,Fe,ge,U,ue,ve,oe,C,A,_e,W,pe,$e,V,R,Ee,j,Me,Y,le,ze,G,de,qe,N,ce,Z,Pe,ne,O,xe,L,Ce,je;return{c(){d=s("p"),k=t("TensorFlow models and layers in "),h=s("code"),f=t("transformers"),T=t(" accept two formats as input:"),l=u(),c=s("ul"),P=s("li"),ke=t("having all inputs as keyword arguments (like PyTorch models), or"),he=u(),I=s("li"),re=t("having all inputs as a list, tuple or dict in the first positional argument."),ee=u(),b=s("p"),Te=t(`The reason the second format is supported is that Keras methods prefer this format when passing inputs to models
and layers. Because of this support, when using methods like `),K=s("code"),ye=t("model.fit()"),fe=t(` things should \u201Cjust work\u201D for you - just
pass your inputs and labels in any format that `),B=s("code"),be=t("model.fit()"),ae=t(` supports! If, however, you want to use the second
format outside of Keras methods like `),H=s("code"),we=t("fit()"),me=t(" and "),Q=s("code"),Fe=t("predict()"),ge=t(`, such as when creating your own layers or models with
the Keras `),U=s("code"),ue=t("Functional"),ve=t(` API, there are three possibilities you can use to gather all the input Tensors in the first
positional argument:`),oe=u(),C=s("ul"),A=s("li"),_e=t("a single Tensor with "),W=s("code"),pe=t("input_ids"),$e=t(" only and nothing else: "),V=s("code"),R=t("model(input_ids)"),Ee=u(),j=s("li"),Me=t(`a list of varying length with one or several input Tensors IN THE ORDER given in the docstring:
`),Y=s("code"),le=t("model([input_ids, attention_mask])"),ze=t(" or "),G=s("code"),de=t("model([input_ids, attention_mask, token_type_ids])"),qe=u(),N=s("li"),ce=t(`a dictionary with one or several input Tensors associated to the input names given in the docstring:
`),Z=s("code"),Pe=t('model({"input_ids": input_ids, "token_type_ids": token_type_ids})'),ne=u(),O=s("p"),xe=t(`Note that when creating models and layers with
`),L=s("a"),Ce=t("subclassing"),je=t(` then you don\u2019t need to worry
about any of this, as you can just pass inputs like you would to any other Python function!`),this.h()},l(g){d=r(g,"P",{});var z=a(d);k=o(z,"TensorFlow models and layers in "),h=r(z,"CODE",{});var Ie=a(h);f=o(Ie,"transformers"),Ie.forEach(n),T=o(z," accept two formats as input:"),z.forEach(n),l=p(g),c=r(g,"UL",{});var J=a(c);P=r(J,"LI",{});var Se=a(P);ke=o(Se,"having all inputs as keyword arguments (like PyTorch models), or"),Se.forEach(n),he=p(J),I=r(J,"LI",{});var Be=a(I);re=o(Be,"having all inputs as a list, tuple or dict in the first positional argument."),Be.forEach(n),J.forEach(n),ee=p(g),b=r(g,"P",{});var q=a(b);Te=o(q,`The reason the second format is supported is that Keras methods prefer this format when passing inputs to models
and layers. Because of this support, when using methods like `),K=r(q,"CODE",{});var Ae=a(K);ye=o(Ae,"model.fit()"),Ae.forEach(n),fe=o(q,` things should \u201Cjust work\u201D for you - just
pass your inputs and labels in any format that `),B=r(q,"CODE",{});var We=a(B);be=o(We,"model.fit()"),We.forEach(n),ae=o(q,` supports! If, however, you want to use the second
format outside of Keras methods like `),H=r(q,"CODE",{});var Le=a(H);we=o(Le,"fit()"),Le.forEach(n),me=o(q," and "),Q=r(q,"CODE",{});var Qe=a(Q);Fe=o(Qe,"predict()"),Qe.forEach(n),ge=o(q,`, such as when creating your own layers or models with
the Keras `),U=r(q,"CODE",{});var Ue=a(U);ue=o(Ue,"Functional"),Ue.forEach(n),ve=o(q,` API, there are three possibilities you can use to gather all the input Tensors in the first
positional argument:`),q.forEach(n),oe=p(g),C=r(g,"UL",{});var D=a(C);A=r(D,"LI",{});var X=a(A);_e=o(X,"a single Tensor with "),W=r(X,"CODE",{});var Ke=a(W);pe=o(Ke,"input_ids"),Ke.forEach(n),$e=o(X," only and nothing else: "),V=r(X,"CODE",{});var Ne=a(V);R=o(Ne,"model(input_ids)"),Ne.forEach(n),X.forEach(n),Ee=p(D),j=r(D,"LI",{});var S=a(j);Me=o(S,`a list of varying length with one or several input Tensors IN THE ORDER given in the docstring:
`),Y=r(S,"CODE",{});var Oe=a(Y);le=o(Oe,"model([input_ids, attention_mask])"),Oe.forEach(n),ze=o(S," or "),G=r(S,"CODE",{});var De=a(G);de=o(De,"model([input_ids, attention_mask, token_type_ids])"),De.forEach(n),S.forEach(n),qe=p(D),N=r(D,"LI",{});var ie=a(N);ce=o(ie,`a dictionary with one or several input Tensors associated to the input names given in the docstring:
`),Z=r(ie,"CODE",{});var Re=a(Z);Pe=o(Re,'model({"input_ids": input_ids, "token_type_ids": token_type_ids})'),Re.forEach(n),ie.forEach(n),D.forEach(n),ne=p(g),O=r(g,"P",{});var te=a(O);xe=o(te,`Note that when creating models and layers with
`),L=r(te,"A",{href:!0,rel:!0});var He=a(L);Ce=o(He,"subclassing"),He.forEach(n),je=o(te,` then you don\u2019t need to worry
about any of this, as you can just pass inputs like you would to any other Python function!`),te.forEach(n),this.h()},h(){m(L,"href","https://keras.io/guides/making_new_layers_and_models_via_subclassing/"),m(L,"rel","nofollow")},m(g,z){_(g,d,z),e(d,k),e(d,h),e(h,f),e(d,T),_(g,l,z),_(g,c,z),e(c,P),e(P,ke),e(c,he),e(c,I),e(I,re),_(g,ee,z),_(g,b,z),e(b,Te),e(b,K),e(K,ye),e(b,fe),e(b,B),e(B,be),e(b,ae),e(b,H),e(H,we),e(b,me),e(b,Q),e(Q,Fe),e(b,ge),e(b,U),e(U,ue),e(b,ve),_(g,oe,z),_(g,C,z),e(C,A),e(A,_e),e(A,W),e(W,pe),e(A,$e),e(A,V),e(V,R),e(C,Ee),e(C,j),e(j,Me),e(j,Y),e(Y,le),e(j,ze),e(j,G),e(G,de),e(C,qe),e(C,N),e(N,ce),e(N,Z),e(Z,Pe),_(g,ne,z),_(g,O,z),e(O,xe),e(O,L),e(L,Ce),e(O,je)},d(g){g&&n(d),g&&n(l),g&&n(c),g&&n(ee),g&&n(b),g&&n(oe),g&&n(C),g&&n(ne),g&&n(O)}}}function n1(x){let d,k,h,f,T;return{c(){d=s("p"),k=t("Although the recipe for forward pass needs to be defined within this function, one should call the "),h=s("code"),f=t("Module"),T=t(`
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(l){d=r(l,"P",{});var c=a(d);k=o(c,"Although the recipe for forward pass needs to be defined within this function, one should call the "),h=r(c,"CODE",{});var P=a(h);f=o(P,"Module"),P.forEach(n),T=o(c,`
instance afterwards instead of this since the former takes care of running the pre and post processing steps while
the latter silently ignores them.`),c.forEach(n)},m(l,c){_(l,d,c),e(d,k),e(d,h),e(h,f),e(d,T)},d(l){l&&n(d)}}}function t1(x){let d,k,h,f,T;return f=new Ze({props:{code:`from transformers import AutoTokenizer, TFFunnelForMaskedLM
import tensorflow as tf

tokenizer = AutoTokenizer.from_pretrained("funnel-transformer/small")
model = TFFunnelForMaskedLM.from_pretrained("funnel-transformer/small")

inputs = tokenizer("The capital of France is [MASK].", return_tensors="tf")
logits = model(**inputs).logits

# retrieve index of [MASK]
mask_token_index = tf.where((inputs.input_ids == tokenizer.mask_token_id)[0])
selected_logits = tf.gather_nd(logits[0], indices=mask_token_index)

predicted_token_id = tf.math.argmax(selected_logits, axis=-1)`,highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> AutoTokenizer, TFFunnelForMaskedLM
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">import</span> tensorflow <span class="hljs-keyword">as</span> tf

<span class="hljs-meta">&gt;&gt;&gt; </span>tokenizer = AutoTokenizer.from_pretrained(<span class="hljs-string">&quot;funnel-transformer/small&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>model = TFFunnelForMaskedLM.from_pretrained(<span class="hljs-string">&quot;funnel-transformer/small&quot;</span>)

<span class="hljs-meta">&gt;&gt;&gt; </span>inputs = tokenizer(<span class="hljs-string">&quot;The capital of France is [MASK].&quot;</span>, return_tensors=<span class="hljs-string">&quot;tf&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>logits = model(**inputs).logits

<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-comment"># retrieve index of [MASK]</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>mask_token_index = tf.where((inputs.input_ids == tokenizer.mask_token_id)[<span class="hljs-number">0</span>])
<span class="hljs-meta">&gt;&gt;&gt; </span>selected_logits = tf.gather_nd(logits[<span class="hljs-number">0</span>], indices=mask_token_index)

<span class="hljs-meta">&gt;&gt;&gt; </span>predicted_token_id = tf.math.argmax(selected_logits, axis=-<span class="hljs-number">1</span>)`}}),{c(){d=s("p"),k=t("Example:"),h=u(),w(f.$$.fragment)},l(l){d=r(l,"P",{});var c=a(d);k=o(c,"Example:"),c.forEach(n),h=p(l),F(f.$$.fragment,l)},m(l,c){_(l,d,c),e(d,k),_(l,h,c),v(f,l,c),T=!0},p:Ge,i(l){T||($(f.$$.fragment,l),T=!0)},o(l){E(f.$$.fragment,l),T=!1},d(l){l&&n(d),l&&n(h),M(f,l)}}}function o1(x){let d,k;return d=new Ze({props:{code:`labels = tokenizer("The capital of France is Paris.", return_tensors="tf")["input_ids"]
# mask labels of non-[MASK] tokens
labels = tf.where(inputs.input_ids == tokenizer.mask_token_id, labels, -100)

outputs = model(**inputs, labels=labels)`,highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span>labels = tokenizer(<span class="hljs-string">&quot;The capital of France is Paris.&quot;</span>, return_tensors=<span class="hljs-string">&quot;tf&quot;</span>)[<span class="hljs-string">&quot;input_ids&quot;</span>]
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-comment"># mask labels of non-[MASK] tokens</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>labels = tf.where(inputs.input_ids == tokenizer.mask_token_id, labels, -<span class="hljs-number">100</span>)

<span class="hljs-meta">&gt;&gt;&gt; </span>outputs = model(**inputs, labels=labels)`}}),{c(){w(d.$$.fragment)},l(h){F(d.$$.fragment,h)},m(h,f){v(d,h,f),k=!0},p:Ge,i(h){k||($(d.$$.fragment,h),k=!0)},o(h){E(d.$$.fragment,h),k=!1},d(h){M(d,h)}}}function s1(x){let d,k,h,f,T,l,c,P,ke,he,I,re,ee,b,Te,K,ye,fe,B,be,ae,H,we,me,Q,Fe,ge,U,ue,ve,oe,C,A,_e,W,pe,$e,V,R,Ee,j,Me,Y,le,ze,G,de,qe,N,ce,Z,Pe,ne,O,xe,L,Ce,je;return{c(){d=s("p"),k=t("TensorFlow models and layers in "),h=s("code"),f=t("transformers"),T=t(" accept two formats as input:"),l=u(),c=s("ul"),P=s("li"),ke=t("having all inputs as keyword arguments (like PyTorch models), or"),he=u(),I=s("li"),re=t("having all inputs as a list, tuple or dict in the first positional argument."),ee=u(),b=s("p"),Te=t(`The reason the second format is supported is that Keras methods prefer this format when passing inputs to models
and layers. Because of this support, when using methods like `),K=s("code"),ye=t("model.fit()"),fe=t(` things should \u201Cjust work\u201D for you - just
pass your inputs and labels in any format that `),B=s("code"),be=t("model.fit()"),ae=t(` supports! If, however, you want to use the second
format outside of Keras methods like `),H=s("code"),we=t("fit()"),me=t(" and "),Q=s("code"),Fe=t("predict()"),ge=t(`, such as when creating your own layers or models with
the Keras `),U=s("code"),ue=t("Functional"),ve=t(` API, there are three possibilities you can use to gather all the input Tensors in the first
positional argument:`),oe=u(),C=s("ul"),A=s("li"),_e=t("a single Tensor with "),W=s("code"),pe=t("input_ids"),$e=t(" only and nothing else: "),V=s("code"),R=t("model(input_ids)"),Ee=u(),j=s("li"),Me=t(`a list of varying length with one or several input Tensors IN THE ORDER given in the docstring:
`),Y=s("code"),le=t("model([input_ids, attention_mask])"),ze=t(" or "),G=s("code"),de=t("model([input_ids, attention_mask, token_type_ids])"),qe=u(),N=s("li"),ce=t(`a dictionary with one or several input Tensors associated to the input names given in the docstring:
`),Z=s("code"),Pe=t('model({"input_ids": input_ids, "token_type_ids": token_type_ids})'),ne=u(),O=s("p"),xe=t(`Note that when creating models and layers with
`),L=s("a"),Ce=t("subclassing"),je=t(` then you don\u2019t need to worry
about any of this, as you can just pass inputs like you would to any other Python function!`),this.h()},l(g){d=r(g,"P",{});var z=a(d);k=o(z,"TensorFlow models and layers in "),h=r(z,"CODE",{});var Ie=a(h);f=o(Ie,"transformers"),Ie.forEach(n),T=o(z," accept two formats as input:"),z.forEach(n),l=p(g),c=r(g,"UL",{});var J=a(c);P=r(J,"LI",{});var Se=a(P);ke=o(Se,"having all inputs as keyword arguments (like PyTorch models), or"),Se.forEach(n),he=p(J),I=r(J,"LI",{});var Be=a(I);re=o(Be,"having all inputs as a list, tuple or dict in the first positional argument."),Be.forEach(n),J.forEach(n),ee=p(g),b=r(g,"P",{});var q=a(b);Te=o(q,`The reason the second format is supported is that Keras methods prefer this format when passing inputs to models
and layers. Because of this support, when using methods like `),K=r(q,"CODE",{});var Ae=a(K);ye=o(Ae,"model.fit()"),Ae.forEach(n),fe=o(q,` things should \u201Cjust work\u201D for you - just
pass your inputs and labels in any format that `),B=r(q,"CODE",{});var We=a(B);be=o(We,"model.fit()"),We.forEach(n),ae=o(q,` supports! If, however, you want to use the second
format outside of Keras methods like `),H=r(q,"CODE",{});var Le=a(H);we=o(Le,"fit()"),Le.forEach(n),me=o(q," and "),Q=r(q,"CODE",{});var Qe=a(Q);Fe=o(Qe,"predict()"),Qe.forEach(n),ge=o(q,`, such as when creating your own layers or models with
the Keras `),U=r(q,"CODE",{});var Ue=a(U);ue=o(Ue,"Functional"),Ue.forEach(n),ve=o(q,` API, there are three possibilities you can use to gather all the input Tensors in the first
positional argument:`),q.forEach(n),oe=p(g),C=r(g,"UL",{});var D=a(C);A=r(D,"LI",{});var X=a(A);_e=o(X,"a single Tensor with "),W=r(X,"CODE",{});var Ke=a(W);pe=o(Ke,"input_ids"),Ke.forEach(n),$e=o(X," only and nothing else: "),V=r(X,"CODE",{});var Ne=a(V);R=o(Ne,"model(input_ids)"),Ne.forEach(n),X.forEach(n),Ee=p(D),j=r(D,"LI",{});var S=a(j);Me=o(S,`a list of varying length with one or several input Tensors IN THE ORDER given in the docstring:
`),Y=r(S,"CODE",{});var Oe=a(Y);le=o(Oe,"model([input_ids, attention_mask])"),Oe.forEach(n),ze=o(S," or "),G=r(S,"CODE",{});var De=a(G);de=o(De,"model([input_ids, attention_mask, token_type_ids])"),De.forEach(n),S.forEach(n),qe=p(D),N=r(D,"LI",{});var ie=a(N);ce=o(ie,`a dictionary with one or several input Tensors associated to the input names given in the docstring:
`),Z=r(ie,"CODE",{});var Re=a(Z);Pe=o(Re,'model({"input_ids": input_ids, "token_type_ids": token_type_ids})'),Re.forEach(n),ie.forEach(n),D.forEach(n),ne=p(g),O=r(g,"P",{});var te=a(O);xe=o(te,`Note that when creating models and layers with
`),L=r(te,"A",{href:!0,rel:!0});var He=a(L);Ce=o(He,"subclassing"),He.forEach(n),je=o(te,` then you don\u2019t need to worry
about any of this, as you can just pass inputs like you would to any other Python function!`),te.forEach(n),this.h()},h(){m(L,"href","https://keras.io/guides/making_new_layers_and_models_via_subclassing/"),m(L,"rel","nofollow")},m(g,z){_(g,d,z),e(d,k),e(d,h),e(h,f),e(d,T),_(g,l,z),_(g,c,z),e(c,P),e(P,ke),e(c,he),e(c,I),e(I,re),_(g,ee,z),_(g,b,z),e(b,Te),e(b,K),e(K,ye),e(b,fe),e(b,B),e(B,be),e(b,ae),e(b,H),e(H,we),e(b,me),e(b,Q),e(Q,Fe),e(b,ge),e(b,U),e(U,ue),e(b,ve),_(g,oe,z),_(g,C,z),e(C,A),e(A,_e),e(A,W),e(W,pe),e(A,$e),e(A,V),e(V,R),e(C,Ee),e(C,j),e(j,Me),e(j,Y),e(Y,le),e(j,ze),e(j,G),e(G,de),e(C,qe),e(C,N),e(N,ce),e(N,Z),e(Z,Pe),_(g,ne,z),_(g,O,z),e(O,xe),e(O,L),e(L,Ce),e(O,je)},d(g){g&&n(d),g&&n(l),g&&n(c),g&&n(ee),g&&n(b),g&&n(oe),g&&n(C),g&&n(ne),g&&n(O)}}}function r1(x){let d,k,h,f,T;return{c(){d=s("p"),k=t("Although the recipe for forward pass needs to be defined within this function, one should call the "),h=s("code"),f=t("Module"),T=t(`
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(l){d=r(l,"P",{});var c=a(d);k=o(c,"Although the recipe for forward pass needs to be defined within this function, one should call the "),h=r(c,"CODE",{});var P=a(h);f=o(P,"Module"),P.forEach(n),T=o(c,`
instance afterwards instead of this since the former takes care of running the pre and post processing steps while
the latter silently ignores them.`),c.forEach(n)},m(l,c){_(l,d,c),e(d,k),e(d,h),e(h,f),e(d,T)},d(l){l&&n(d)}}}function a1(x){let d,k,h,f,T;return f=new Ze({props:{code:`from transformers import AutoTokenizer, TFFunnelForSequenceClassification
import tensorflow as tf

tokenizer = AutoTokenizer.from_pretrained("funnel-transformer/small-base")
model = TFFunnelForSequenceClassification.from_pretrained("funnel-transformer/small-base")

inputs = tokenizer("Hello, my dog is cute", return_tensors="tf")

logits = model(**inputs).logits

predicted_class_id = int(tf.math.argmax(logits, axis=-1)[0])`,highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> AutoTokenizer, TFFunnelForSequenceClassification
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">import</span> tensorflow <span class="hljs-keyword">as</span> tf

<span class="hljs-meta">&gt;&gt;&gt; </span>tokenizer = AutoTokenizer.from_pretrained(<span class="hljs-string">&quot;funnel-transformer/small-base&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>model = TFFunnelForSequenceClassification.from_pretrained(<span class="hljs-string">&quot;funnel-transformer/small-base&quot;</span>)

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

<span class="hljs-meta">&gt;&gt;&gt; </span>logits = model(**inputs).logits

<span class="hljs-meta">&gt;&gt;&gt; </span>predicted_class_id = <span class="hljs-built_in">int</span>(tf.math.argmax(logits, axis=-<span class="hljs-number">1</span>)[<span class="hljs-number">0</span>])`}}),{c(){d=s("p"),k=t("Example:"),h=u(),w(f.$$.fragment)},l(l){d=r(l,"P",{});var c=a(d);k=o(c,"Example:"),c.forEach(n),h=p(l),F(f.$$.fragment,l)},m(l,c){_(l,d,c),e(d,k),_(l,h,c),v(f,l,c),T=!0},p:Ge,i(l){T||($(f.$$.fragment,l),T=!0)},o(l){E(f.$$.fragment,l),T=!1},d(l){l&&n(d),l&&n(h),M(f,l)}}}function i1(x){let d,k;return d=new Ze({props:{code:'# To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`\nnum_labels = len(model.config.id2label)\nmodel = TFFunnelForSequenceClassification.from_pretrained("funnel-transformer/small-base", num_labels=num_labels)\n\nlabels = tf.constant(1)\nloss = model(**inputs, labels=labels).loss',highlighted:'<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-comment"># To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`</span>\n<span class="hljs-meta">&gt;&gt;&gt; </span>num_labels = <span class="hljs-built_in">len</span>(model.config.id2label)\n<span class="hljs-meta">&gt;&gt;&gt; </span>model = TFFunnelForSequenceClassification.from_pretrained(<span class="hljs-string">&quot;funnel-transformer/small-base&quot;</span>, num_labels=num_labels)\n\n<span class="hljs-meta">&gt;&gt;&gt; </span>labels = tf.constant(<span class="hljs-number">1</span>)\n<span class="hljs-meta">&gt;&gt;&gt; </span>loss = model(**inputs, labels=labels).loss'}}),{c(){w(d.$$.fragment)},l(h){F(d.$$.fragment,h)},m(h,f){v(d,h,f),k=!0},p:Ge,i(h){k||($(d.$$.fragment,h),k=!0)},o(h){E(d.$$.fragment,h),k=!1},d(h){M(d,h)}}}function l1(x){let d,k,h,f,T,l,c,P,ke,he,I,re,ee,b,Te,K,ye,fe,B,be,ae,H,we,me,Q,Fe,ge,U,ue,ve,oe,C,A,_e,W,pe,$e,V,R,Ee,j,Me,Y,le,ze,G,de,qe,N,ce,Z,Pe,ne,O,xe,L,Ce,je;return{c(){d=s("p"),k=t("TensorFlow models and layers in "),h=s("code"),f=t("transformers"),T=t(" accept two formats as input:"),l=u(),c=s("ul"),P=s("li"),ke=t("having all inputs as keyword arguments (like PyTorch models), or"),he=u(),I=s("li"),re=t("having all inputs as a list, tuple or dict in the first positional argument."),ee=u(),b=s("p"),Te=t(`The reason the second format is supported is that Keras methods prefer this format when passing inputs to models
and layers. Because of this support, when using methods like `),K=s("code"),ye=t("model.fit()"),fe=t(` things should \u201Cjust work\u201D for you - just
pass your inputs and labels in any format that `),B=s("code"),be=t("model.fit()"),ae=t(` supports! If, however, you want to use the second
format outside of Keras methods like `),H=s("code"),we=t("fit()"),me=t(" and "),Q=s("code"),Fe=t("predict()"),ge=t(`, such as when creating your own layers or models with
the Keras `),U=s("code"),ue=t("Functional"),ve=t(` API, there are three possibilities you can use to gather all the input Tensors in the first
positional argument:`),oe=u(),C=s("ul"),A=s("li"),_e=t("a single Tensor with "),W=s("code"),pe=t("input_ids"),$e=t(" only and nothing else: "),V=s("code"),R=t("model(input_ids)"),Ee=u(),j=s("li"),Me=t(`a list of varying length with one or several input Tensors IN THE ORDER given in the docstring:
`),Y=s("code"),le=t("model([input_ids, attention_mask])"),ze=t(" or "),G=s("code"),de=t("model([input_ids, attention_mask, token_type_ids])"),qe=u(),N=s("li"),ce=t(`a dictionary with one or several input Tensors associated to the input names given in the docstring:
`),Z=s("code"),Pe=t('model({"input_ids": input_ids, "token_type_ids": token_type_ids})'),ne=u(),O=s("p"),xe=t(`Note that when creating models and layers with
`),L=s("a"),Ce=t("subclassing"),je=t(` then you don\u2019t need to worry
about any of this, as you can just pass inputs like you would to any other Python function!`),this.h()},l(g){d=r(g,"P",{});var z=a(d);k=o(z,"TensorFlow models and layers in "),h=r(z,"CODE",{});var Ie=a(h);f=o(Ie,"transformers"),Ie.forEach(n),T=o(z," accept two formats as input:"),z.forEach(n),l=p(g),c=r(g,"UL",{});var J=a(c);P=r(J,"LI",{});var Se=a(P);ke=o(Se,"having all inputs as keyword arguments (like PyTorch models), or"),Se.forEach(n),he=p(J),I=r(J,"LI",{});var Be=a(I);re=o(Be,"having all inputs as a list, tuple or dict in the first positional argument."),Be.forEach(n),J.forEach(n),ee=p(g),b=r(g,"P",{});var q=a(b);Te=o(q,`The reason the second format is supported is that Keras methods prefer this format when passing inputs to models
and layers. Because of this support, when using methods like `),K=r(q,"CODE",{});var Ae=a(K);ye=o(Ae,"model.fit()"),Ae.forEach(n),fe=o(q,` things should \u201Cjust work\u201D for you - just
pass your inputs and labels in any format that `),B=r(q,"CODE",{});var We=a(B);be=o(We,"model.fit()"),We.forEach(n),ae=o(q,` supports! If, however, you want to use the second
format outside of Keras methods like `),H=r(q,"CODE",{});var Le=a(H);we=o(Le,"fit()"),Le.forEach(n),me=o(q," and "),Q=r(q,"CODE",{});var Qe=a(Q);Fe=o(Qe,"predict()"),Qe.forEach(n),ge=o(q,`, such as when creating your own layers or models with
the Keras `),U=r(q,"CODE",{});var Ue=a(U);ue=o(Ue,"Functional"),Ue.forEach(n),ve=o(q,` API, there are three possibilities you can use to gather all the input Tensors in the first
positional argument:`),q.forEach(n),oe=p(g),C=r(g,"UL",{});var D=a(C);A=r(D,"LI",{});var X=a(A);_e=o(X,"a single Tensor with "),W=r(X,"CODE",{});var Ke=a(W);pe=o(Ke,"input_ids"),Ke.forEach(n),$e=o(X," only and nothing else: "),V=r(X,"CODE",{});var Ne=a(V);R=o(Ne,"model(input_ids)"),Ne.forEach(n),X.forEach(n),Ee=p(D),j=r(D,"LI",{});var S=a(j);Me=o(S,`a list of varying length with one or several input Tensors IN THE ORDER given in the docstring:
`),Y=r(S,"CODE",{});var Oe=a(Y);le=o(Oe,"model([input_ids, attention_mask])"),Oe.forEach(n),ze=o(S," or "),G=r(S,"CODE",{});var De=a(G);de=o(De,"model([input_ids, attention_mask, token_type_ids])"),De.forEach(n),S.forEach(n),qe=p(D),N=r(D,"LI",{});var ie=a(N);ce=o(ie,`a dictionary with one or several input Tensors associated to the input names given in the docstring:
`),Z=r(ie,"CODE",{});var Re=a(Z);Pe=o(Re,'model({"input_ids": input_ids, "token_type_ids": token_type_ids})'),Re.forEach(n),ie.forEach(n),D.forEach(n),ne=p(g),O=r(g,"P",{});var te=a(O);xe=o(te,`Note that when creating models and layers with
`),L=r(te,"A",{href:!0,rel:!0});var He=a(L);Ce=o(He,"subclassing"),He.forEach(n),je=o(te,` then you don\u2019t need to worry
about any of this, as you can just pass inputs like you would to any other Python function!`),te.forEach(n),this.h()},h(){m(L,"href","https://keras.io/guides/making_new_layers_and_models_via_subclassing/"),m(L,"rel","nofollow")},m(g,z){_(g,d,z),e(d,k),e(d,h),e(h,f),e(d,T),_(g,l,z),_(g,c,z),e(c,P),e(P,ke),e(c,he),e(c,I),e(I,re),_(g,ee,z),_(g,b,z),e(b,Te),e(b,K),e(K,ye),e(b,fe),e(b,B),e(B,be),e(b,ae),e(b,H),e(H,we),e(b,me),e(b,Q),e(Q,Fe),e(b,ge),e(b,U),e(U,ue),e(b,ve),_(g,oe,z),_(g,C,z),e(C,A),e(A,_e),e(A,W),e(W,pe),e(A,$e),e(A,V),e(V,R),e(C,Ee),e(C,j),e(j,Me),e(j,Y),e(Y,le),e(j,ze),e(j,G),e(G,de),e(C,qe),e(C,N),e(N,ce),e(N,Z),e(Z,Pe),_(g,ne,z),_(g,O,z),e(O,xe),e(O,L),e(L,Ce),e(O,je)},d(g){g&&n(d),g&&n(l),g&&n(c),g&&n(ee),g&&n(b),g&&n(oe),g&&n(C),g&&n(ne),g&&n(O)}}}function d1(x){let d,k,h,f,T;return{c(){d=s("p"),k=t("Although the recipe for forward pass needs to be defined within this function, one should call the "),h=s("code"),f=t("Module"),T=t(`
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(l){d=r(l,"P",{});var c=a(d);k=o(c,"Although the recipe for forward pass needs to be defined within this function, one should call the "),h=r(c,"CODE",{});var P=a(h);f=o(P,"Module"),P.forEach(n),T=o(c,`
instance afterwards instead of this since the former takes care of running the pre and post processing steps while
the latter silently ignores them.`),c.forEach(n)},m(l,c){_(l,d,c),e(d,k),e(d,h),e(h,f),e(d,T)},d(l){l&&n(d)}}}function c1(x){let d,k,h,f,T;return f=new Ze({props:{code:`from transformers import AutoTokenizer, TFFunnelForMultipleChoice
import tensorflow as tf

tokenizer = AutoTokenizer.from_pretrained("funnel-transformer/small-base")
model = TFFunnelForMultipleChoice.from_pretrained("funnel-transformer/small-base")

prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
choice0 = "It is eaten with a fork and a knife."
choice1 = "It is eaten while held in the hand."

encoding = tokenizer([prompt, prompt], [choice0, choice1], return_tensors="tf", padding=True)
inputs = {k: tf.expand_dims(v, 0) for k, v in encoding.items()}
outputs = model(inputs)  # batch size is 1

# the linear classifier still needs to be trained
logits = outputs.logits`,highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> AutoTokenizer, TFFunnelForMultipleChoice
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">import</span> tensorflow <span class="hljs-keyword">as</span> tf

<span class="hljs-meta">&gt;&gt;&gt; </span>tokenizer = AutoTokenizer.from_pretrained(<span class="hljs-string">&quot;funnel-transformer/small-base&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>model = TFFunnelForMultipleChoice.from_pretrained(<span class="hljs-string">&quot;funnel-transformer/small-base&quot;</span>)

<span class="hljs-meta">&gt;&gt;&gt; </span>prompt = <span class="hljs-string">&quot;In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced.&quot;</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>choice0 = <span class="hljs-string">&quot;It is eaten with a fork and a knife.&quot;</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>choice1 = <span class="hljs-string">&quot;It is eaten while held in the hand.&quot;</span>

<span class="hljs-meta">&gt;&gt;&gt; </span>encoding = tokenizer([prompt, prompt], [choice0, choice1], return_tensors=<span class="hljs-string">&quot;tf&quot;</span>, padding=<span class="hljs-literal">True</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>inputs = {k: tf.expand_dims(v, <span class="hljs-number">0</span>) <span class="hljs-keyword">for</span> k, v <span class="hljs-keyword">in</span> encoding.items()}
<span class="hljs-meta">&gt;&gt;&gt; </span>outputs = model(inputs)  <span class="hljs-comment"># batch size is 1</span>

<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-comment"># the linear classifier still needs to be trained</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>logits = outputs.logits`}}),{c(){d=s("p"),k=t("Example:"),h=u(),w(f.$$.fragment)},l(l){d=r(l,"P",{});var c=a(d);k=o(c,"Example:"),c.forEach(n),h=p(l),F(f.$$.fragment,l)},m(l,c){_(l,d,c),e(d,k),_(l,h,c),v(f,l,c),T=!0},p:Ge,i(l){T||($(f.$$.fragment,l),T=!0)},o(l){E(f.$$.fragment,l),T=!1},d(l){l&&n(d),l&&n(h),M(f,l)}}}function u1(x){let d,k,h,f,T,l,c,P,ke,he,I,re,ee,b,Te,K,ye,fe,B,be,ae,H,we,me,Q,Fe,ge,U,ue,ve,oe,C,A,_e,W,pe,$e,V,R,Ee,j,Me,Y,le,ze,G,de,qe,N,ce,Z,Pe,ne,O,xe,L,Ce,je;return{c(){d=s("p"),k=t("TensorFlow models and layers in "),h=s("code"),f=t("transformers"),T=t(" accept two formats as input:"),l=u(),c=s("ul"),P=s("li"),ke=t("having all inputs as keyword arguments (like PyTorch models), or"),he=u(),I=s("li"),re=t("having all inputs as a list, tuple or dict in the first positional argument."),ee=u(),b=s("p"),Te=t(`The reason the second format is supported is that Keras methods prefer this format when passing inputs to models
and layers. Because of this support, when using methods like `),K=s("code"),ye=t("model.fit()"),fe=t(` things should \u201Cjust work\u201D for you - just
pass your inputs and labels in any format that `),B=s("code"),be=t("model.fit()"),ae=t(` supports! If, however, you want to use the second
format outside of Keras methods like `),H=s("code"),we=t("fit()"),me=t(" and "),Q=s("code"),Fe=t("predict()"),ge=t(`, such as when creating your own layers or models with
the Keras `),U=s("code"),ue=t("Functional"),ve=t(` API, there are three possibilities you can use to gather all the input Tensors in the first
positional argument:`),oe=u(),C=s("ul"),A=s("li"),_e=t("a single Tensor with "),W=s("code"),pe=t("input_ids"),$e=t(" only and nothing else: "),V=s("code"),R=t("model(input_ids)"),Ee=u(),j=s("li"),Me=t(`a list of varying length with one or several input Tensors IN THE ORDER given in the docstring:
`),Y=s("code"),le=t("model([input_ids, attention_mask])"),ze=t(" or "),G=s("code"),de=t("model([input_ids, attention_mask, token_type_ids])"),qe=u(),N=s("li"),ce=t(`a dictionary with one or several input Tensors associated to the input names given in the docstring:
`),Z=s("code"),Pe=t('model({"input_ids": input_ids, "token_type_ids": token_type_ids})'),ne=u(),O=s("p"),xe=t(`Note that when creating models and layers with
`),L=s("a"),Ce=t("subclassing"),je=t(` then you don\u2019t need to worry
about any of this, as you can just pass inputs like you would to any other Python function!`),this.h()},l(g){d=r(g,"P",{});var z=a(d);k=o(z,"TensorFlow models and layers in "),h=r(z,"CODE",{});var Ie=a(h);f=o(Ie,"transformers"),Ie.forEach(n),T=o(z," accept two formats as input:"),z.forEach(n),l=p(g),c=r(g,"UL",{});var J=a(c);P=r(J,"LI",{});var Se=a(P);ke=o(Se,"having all inputs as keyword arguments (like PyTorch models), or"),Se.forEach(n),he=p(J),I=r(J,"LI",{});var Be=a(I);re=o(Be,"having all inputs as a list, tuple or dict in the first positional argument."),Be.forEach(n),J.forEach(n),ee=p(g),b=r(g,"P",{});var q=a(b);Te=o(q,`The reason the second format is supported is that Keras methods prefer this format when passing inputs to models
and layers. Because of this support, when using methods like `),K=r(q,"CODE",{});var Ae=a(K);ye=o(Ae,"model.fit()"),Ae.forEach(n),fe=o(q,` things should \u201Cjust work\u201D for you - just
pass your inputs and labels in any format that `),B=r(q,"CODE",{});var We=a(B);be=o(We,"model.fit()"),We.forEach(n),ae=o(q,` supports! If, however, you want to use the second
format outside of Keras methods like `),H=r(q,"CODE",{});var Le=a(H);we=o(Le,"fit()"),Le.forEach(n),me=o(q," and "),Q=r(q,"CODE",{});var Qe=a(Q);Fe=o(Qe,"predict()"),Qe.forEach(n),ge=o(q,`, such as when creating your own layers or models with
the Keras `),U=r(q,"CODE",{});var Ue=a(U);ue=o(Ue,"Functional"),Ue.forEach(n),ve=o(q,` API, there are three possibilities you can use to gather all the input Tensors in the first
positional argument:`),q.forEach(n),oe=p(g),C=r(g,"UL",{});var D=a(C);A=r(D,"LI",{});var X=a(A);_e=o(X,"a single Tensor with "),W=r(X,"CODE",{});var Ke=a(W);pe=o(Ke,"input_ids"),Ke.forEach(n),$e=o(X," only and nothing else: "),V=r(X,"CODE",{});var Ne=a(V);R=o(Ne,"model(input_ids)"),Ne.forEach(n),X.forEach(n),Ee=p(D),j=r(D,"LI",{});var S=a(j);Me=o(S,`a list of varying length with one or several input Tensors IN THE ORDER given in the docstring:
`),Y=r(S,"CODE",{});var Oe=a(Y);le=o(Oe,"model([input_ids, attention_mask])"),Oe.forEach(n),ze=o(S," or "),G=r(S,"CODE",{});var De=a(G);de=o(De,"model([input_ids, attention_mask, token_type_ids])"),De.forEach(n),S.forEach(n),qe=p(D),N=r(D,"LI",{});var ie=a(N);ce=o(ie,`a dictionary with one or several input Tensors associated to the input names given in the docstring:
`),Z=r(ie,"CODE",{});var Re=a(Z);Pe=o(Re,'model({"input_ids": input_ids, "token_type_ids": token_type_ids})'),Re.forEach(n),ie.forEach(n),D.forEach(n),ne=p(g),O=r(g,"P",{});var te=a(O);xe=o(te,`Note that when creating models and layers with
`),L=r(te,"A",{href:!0,rel:!0});var He=a(L);Ce=o(He,"subclassing"),He.forEach(n),je=o(te,` then you don\u2019t need to worry
about any of this, as you can just pass inputs like you would to any other Python function!`),te.forEach(n),this.h()},h(){m(L,"href","https://keras.io/guides/making_new_layers_and_models_via_subclassing/"),m(L,"rel","nofollow")},m(g,z){_(g,d,z),e(d,k),e(d,h),e(h,f),e(d,T),_(g,l,z),_(g,c,z),e(c,P),e(P,ke),e(c,he),e(c,I),e(I,re),_(g,ee,z),_(g,b,z),e(b,Te),e(b,K),e(K,ye),e(b,fe),e(b,B),e(B,be),e(b,ae),e(b,H),e(H,we),e(b,me),e(b,Q),e(Q,Fe),e(b,ge),e(b,U),e(U,ue),e(b,ve),_(g,oe,z),_(g,C,z),e(C,A),e(A,_e),e(A,W),e(W,pe),e(A,$e),e(A,V),e(V,R),e(C,Ee),e(C,j),e(j,Me),e(j,Y),e(Y,le),e(j,ze),e(j,G),e(G,de),e(C,qe),e(C,N),e(N,ce),e(N,Z),e(Z,Pe),_(g,ne,z),_(g,O,z),e(O,xe),e(O,L),e(L,Ce),e(O,je)},d(g){g&&n(d),g&&n(l),g&&n(c),g&&n(ee),g&&n(b),g&&n(oe),g&&n(C),g&&n(ne),g&&n(O)}}}function p1(x){let d,k,h,f,T;return{c(){d=s("p"),k=t("Although the recipe for forward pass needs to be defined within this function, one should call the "),h=s("code"),f=t("Module"),T=t(`
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(l){d=r(l,"P",{});var c=a(d);k=o(c,"Although the recipe for forward pass needs to be defined within this function, one should call the "),h=r(c,"CODE",{});var P=a(h);f=o(P,"Module"),P.forEach(n),T=o(c,`
instance afterwards instead of this since the former takes care of running the pre and post processing steps while
the latter silently ignores them.`),c.forEach(n)},m(l,c){_(l,d,c),e(d,k),e(d,h),e(h,f),e(d,T)},d(l){l&&n(d)}}}function h1(x){let d,k,h,f,T;return f=new Ze({props:{code:`from transformers import AutoTokenizer, TFFunnelForTokenClassification
import tensorflow as tf

tokenizer = AutoTokenizer.from_pretrained("funnel-transformer/small")
model = TFFunnelForTokenClassification.from_pretrained("funnel-transformer/small")

inputs = tokenizer(
    "HuggingFace is a company based in Paris and New York", add_special_tokens=False, return_tensors="tf"
)

logits = model(**inputs).logits
predicted_token_class_ids = tf.math.argmax(logits, axis=-1)

# Note that tokens are classified rather then input words which means that
# there might be more predicted token classes than words.
# Multiple token classes might account for the same word
predicted_tokens_classes = [model.config.id2label[t] for t in predicted_token_class_ids[0].numpy().tolist()]`,highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> AutoTokenizer, TFFunnelForTokenClassification
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">import</span> tensorflow <span class="hljs-keyword">as</span> tf

<span class="hljs-meta">&gt;&gt;&gt; </span>tokenizer = AutoTokenizer.from_pretrained(<span class="hljs-string">&quot;funnel-transformer/small&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>model = TFFunnelForTokenClassification.from_pretrained(<span class="hljs-string">&quot;funnel-transformer/small&quot;</span>)

<span class="hljs-meta">&gt;&gt;&gt; </span>inputs = tokenizer(
<span class="hljs-meta">... </span>    <span class="hljs-string">&quot;HuggingFace is a company based in Paris and New York&quot;</span>, add_special_tokens=<span class="hljs-literal">False</span>, return_tensors=<span class="hljs-string">&quot;tf&quot;</span>
<span class="hljs-meta">... </span>)

<span class="hljs-meta">&gt;&gt;&gt; </span>logits = model(**inputs).logits
<span class="hljs-meta">&gt;&gt;&gt; </span>predicted_token_class_ids = tf.math.argmax(logits, axis=-<span class="hljs-number">1</span>)

<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-comment"># Note that tokens are classified rather then input words which means that</span>
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-comment"># there might be more predicted token classes than words.</span>
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-comment"># Multiple token classes might account for the same word</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>predicted_tokens_classes = [model.config.id2label[t] <span class="hljs-keyword">for</span> t <span class="hljs-keyword">in</span> predicted_token_class_ids[<span class="hljs-number">0</span>].numpy().tolist()]`}}),{c(){d=s("p"),k=t("Example:"),h=u(),w(f.$$.fragment)},l(l){d=r(l,"P",{});var c=a(d);k=o(c,"Example:"),c.forEach(n),h=p(l),F(f.$$.fragment,l)},m(l,c){_(l,d,c),e(d,k),_(l,h,c),v(f,l,c),T=!0},p:Ge,i(l){T||($(f.$$.fragment,l),T=!0)},o(l){E(f.$$.fragment,l),T=!1},d(l){l&&n(d),l&&n(h),M(f,l)}}}function f1(x){let d,k;return d=new Ze({props:{code:`labels = predicted_token_class_ids
loss = tf.math.reduce_mean(model(**inputs, labels=labels).loss)`,highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span>labels = predicted_token_class_ids
<span class="hljs-meta">&gt;&gt;&gt; </span>loss = tf.math.reduce_mean(model(**inputs, labels=labels).loss)`}}),{c(){w(d.$$.fragment)},l(h){F(d.$$.fragment,h)},m(h,f){v(d,h,f),k=!0},p:Ge,i(h){k||($(d.$$.fragment,h),k=!0)},o(h){E(d.$$.fragment,h),k=!1},d(h){M(d,h)}}}function m1(x){let d,k,h,f,T,l,c,P,ke,he,I,re,ee,b,Te,K,ye,fe,B,be,ae,H,we,me,Q,Fe,ge,U,ue,ve,oe,C,A,_e,W,pe,$e,V,R,Ee,j,Me,Y,le,ze,G,de,qe,N,ce,Z,Pe,ne,O,xe,L,Ce,je;return{c(){d=s("p"),k=t("TensorFlow models and layers in "),h=s("code"),f=t("transformers"),T=t(" accept two formats as input:"),l=u(),c=s("ul"),P=s("li"),ke=t("having all inputs as keyword arguments (like PyTorch models), or"),he=u(),I=s("li"),re=t("having all inputs as a list, tuple or dict in the first positional argument."),ee=u(),b=s("p"),Te=t(`The reason the second format is supported is that Keras methods prefer this format when passing inputs to models
and layers. Because of this support, when using methods like `),K=s("code"),ye=t("model.fit()"),fe=t(` things should \u201Cjust work\u201D for you - just
pass your inputs and labels in any format that `),B=s("code"),be=t("model.fit()"),ae=t(` supports! If, however, you want to use the second
format outside of Keras methods like `),H=s("code"),we=t("fit()"),me=t(" and "),Q=s("code"),Fe=t("predict()"),ge=t(`, such as when creating your own layers or models with
the Keras `),U=s("code"),ue=t("Functional"),ve=t(` API, there are three possibilities you can use to gather all the input Tensors in the first
positional argument:`),oe=u(),C=s("ul"),A=s("li"),_e=t("a single Tensor with "),W=s("code"),pe=t("input_ids"),$e=t(" only and nothing else: "),V=s("code"),R=t("model(input_ids)"),Ee=u(),j=s("li"),Me=t(`a list of varying length with one or several input Tensors IN THE ORDER given in the docstring:
`),Y=s("code"),le=t("model([input_ids, attention_mask])"),ze=t(" or "),G=s("code"),de=t("model([input_ids, attention_mask, token_type_ids])"),qe=u(),N=s("li"),ce=t(`a dictionary with one or several input Tensors associated to the input names given in the docstring:
`),Z=s("code"),Pe=t('model({"input_ids": input_ids, "token_type_ids": token_type_ids})'),ne=u(),O=s("p"),xe=t(`Note that when creating models and layers with
`),L=s("a"),Ce=t("subclassing"),je=t(` then you don\u2019t need to worry
about any of this, as you can just pass inputs like you would to any other Python function!`),this.h()},l(g){d=r(g,"P",{});var z=a(d);k=o(z,"TensorFlow models and layers in "),h=r(z,"CODE",{});var Ie=a(h);f=o(Ie,"transformers"),Ie.forEach(n),T=o(z," accept two formats as input:"),z.forEach(n),l=p(g),c=r(g,"UL",{});var J=a(c);P=r(J,"LI",{});var Se=a(P);ke=o(Se,"having all inputs as keyword arguments (like PyTorch models), or"),Se.forEach(n),he=p(J),I=r(J,"LI",{});var Be=a(I);re=o(Be,"having all inputs as a list, tuple or dict in the first positional argument."),Be.forEach(n),J.forEach(n),ee=p(g),b=r(g,"P",{});var q=a(b);Te=o(q,`The reason the second format is supported is that Keras methods prefer this format when passing inputs to models
and layers. Because of this support, when using methods like `),K=r(q,"CODE",{});var Ae=a(K);ye=o(Ae,"model.fit()"),Ae.forEach(n),fe=o(q,` things should \u201Cjust work\u201D for you - just
pass your inputs and labels in any format that `),B=r(q,"CODE",{});var We=a(B);be=o(We,"model.fit()"),We.forEach(n),ae=o(q,` supports! If, however, you want to use the second
format outside of Keras methods like `),H=r(q,"CODE",{});var Le=a(H);we=o(Le,"fit()"),Le.forEach(n),me=o(q," and "),Q=r(q,"CODE",{});var Qe=a(Q);Fe=o(Qe,"predict()"),Qe.forEach(n),ge=o(q,`, such as when creating your own layers or models with
the Keras `),U=r(q,"CODE",{});var Ue=a(U);ue=o(Ue,"Functional"),Ue.forEach(n),ve=o(q,` API, there are three possibilities you can use to gather all the input Tensors in the first
positional argument:`),q.forEach(n),oe=p(g),C=r(g,"UL",{});var D=a(C);A=r(D,"LI",{});var X=a(A);_e=o(X,"a single Tensor with "),W=r(X,"CODE",{});var Ke=a(W);pe=o(Ke,"input_ids"),Ke.forEach(n),$e=o(X," only and nothing else: "),V=r(X,"CODE",{});var Ne=a(V);R=o(Ne,"model(input_ids)"),Ne.forEach(n),X.forEach(n),Ee=p(D),j=r(D,"LI",{});var S=a(j);Me=o(S,`a list of varying length with one or several input Tensors IN THE ORDER given in the docstring:
`),Y=r(S,"CODE",{});var Oe=a(Y);le=o(Oe,"model([input_ids, attention_mask])"),Oe.forEach(n),ze=o(S," or "),G=r(S,"CODE",{});var De=a(G);de=o(De,"model([input_ids, attention_mask, token_type_ids])"),De.forEach(n),S.forEach(n),qe=p(D),N=r(D,"LI",{});var ie=a(N);ce=o(ie,`a dictionary with one or several input Tensors associated to the input names given in the docstring:
`),Z=r(ie,"CODE",{});var Re=a(Z);Pe=o(Re,'model({"input_ids": input_ids, "token_type_ids": token_type_ids})'),Re.forEach(n),ie.forEach(n),D.forEach(n),ne=p(g),O=r(g,"P",{});var te=a(O);xe=o(te,`Note that when creating models and layers with
`),L=r(te,"A",{href:!0,rel:!0});var He=a(L);Ce=o(He,"subclassing"),He.forEach(n),je=o(te,` then you don\u2019t need to worry
about any of this, as you can just pass inputs like you would to any other Python function!`),te.forEach(n),this.h()},h(){m(L,"href","https://keras.io/guides/making_new_layers_and_models_via_subclassing/"),m(L,"rel","nofollow")},m(g,z){_(g,d,z),e(d,k),e(d,h),e(h,f),e(d,T),_(g,l,z),_(g,c,z),e(c,P),e(P,ke),e(c,he),e(c,I),e(I,re),_(g,ee,z),_(g,b,z),e(b,Te),e(b,K),e(K,ye),e(b,fe),e(b,B),e(B,be),e(b,ae),e(b,H),e(H,we),e(b,me),e(b,Q),e(Q,Fe),e(b,ge),e(b,U),e(U,ue),e(b,ve),_(g,oe,z),_(g,C,z),e(C,A),e(A,_e),e(A,W),e(W,pe),e(A,$e),e(A,V),e(V,R),e(C,Ee),e(C,j),e(j,Me),e(j,Y),e(Y,le),e(j,ze),e(j,G),e(G,de),e(C,qe),e(C,N),e(N,ce),e(N,Z),e(Z,Pe),_(g,ne,z),_(g,O,z),e(O,xe),e(O,L),e(L,Ce),e(O,je)},d(g){g&&n(d),g&&n(l),g&&n(c),g&&n(ee),g&&n(b),g&&n(oe),g&&n(C),g&&n(ne),g&&n(O)}}}function g1(x){let d,k,h,f,T;return{c(){d=s("p"),k=t("Although the recipe for forward pass needs to be defined within this function, one should call the "),h=s("code"),f=t("Module"),T=t(`
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(l){d=r(l,"P",{});var c=a(d);k=o(c,"Although the recipe for forward pass needs to be defined within this function, one should call the "),h=r(c,"CODE",{});var P=a(h);f=o(P,"Module"),P.forEach(n),T=o(c,`
instance afterwards instead of this since the former takes care of running the pre and post processing steps while
the latter silently ignores them.`),c.forEach(n)},m(l,c){_(l,d,c),e(d,k),e(d,h),e(h,f),e(d,T)},d(l){l&&n(d)}}}function _1(x){let d,k,h,f,T;return f=new Ze({props:{code:`from transformers import AutoTokenizer, TFFunnelForQuestionAnswering
import tensorflow as tf

tokenizer = AutoTokenizer.from_pretrained("funnel-transformer/small")
model = TFFunnelForQuestionAnswering.from_pretrained("funnel-transformer/small")

question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"

inputs = tokenizer(question, text, return_tensors="tf")
outputs = model(**inputs)

answer_start_index = int(tf.math.argmax(outputs.start_logits, axis=-1)[0])
answer_end_index = int(tf.math.argmax(outputs.end_logits, axis=-1)[0])

predict_answer_tokens = inputs.input_ids[0, answer_start_index : answer_end_index + 1]`,highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> AutoTokenizer, TFFunnelForQuestionAnswering
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">import</span> tensorflow <span class="hljs-keyword">as</span> tf

<span class="hljs-meta">&gt;&gt;&gt; </span>tokenizer = AutoTokenizer.from_pretrained(<span class="hljs-string">&quot;funnel-transformer/small&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>model = TFFunnelForQuestionAnswering.from_pretrained(<span class="hljs-string">&quot;funnel-transformer/small&quot;</span>)

<span class="hljs-meta">&gt;&gt;&gt; </span>question, text = <span class="hljs-string">&quot;Who was Jim Henson?&quot;</span>, <span class="hljs-string">&quot;Jim Henson was a nice puppet&quot;</span>

<span class="hljs-meta">&gt;&gt;&gt; </span>inputs = tokenizer(question, text, return_tensors=<span class="hljs-string">&quot;tf&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>outputs = model(**inputs)

<span class="hljs-meta">&gt;&gt;&gt; </span>answer_start_index = <span class="hljs-built_in">int</span>(tf.math.argmax(outputs.start_logits, axis=-<span class="hljs-number">1</span>)[<span class="hljs-number">0</span>])
<span class="hljs-meta">&gt;&gt;&gt; </span>answer_end_index = <span class="hljs-built_in">int</span>(tf.math.argmax(outputs.end_logits, axis=-<span class="hljs-number">1</span>)[<span class="hljs-number">0</span>])

<span class="hljs-meta">&gt;&gt;&gt; </span>predict_answer_tokens = inputs.input_ids[<span class="hljs-number">0</span>, answer_start_index : answer_end_index + <span class="hljs-number">1</span>]`}}),{c(){d=s("p"),k=t("Example:"),h=u(),w(f.$$.fragment)},l(l){d=r(l,"P",{});var c=a(d);k=o(c,"Example:"),c.forEach(n),h=p(l),F(f.$$.fragment,l)},m(l,c){_(l,d,c),e(d,k),_(l,h,c),v(f,l,c),T=!0},p:Ge,i(l){T||($(f.$$.fragment,l),T=!0)},o(l){E(f.$$.fragment,l),T=!1},d(l){l&&n(d),l&&n(h),M(f,l)}}}function k1(x){let d,k;return d=new Ze({props:{code:`# target is "nice puppet"
target_start_index = tf.constant([14])
target_end_index = tf.constant([15])

outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index)
loss = tf.math.reduce_mean(outputs.loss)`,highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-comment"># target is &quot;nice puppet&quot;</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>target_start_index = tf.constant([<span class="hljs-number">14</span>])
<span class="hljs-meta">&gt;&gt;&gt; </span>target_end_index = tf.constant([<span class="hljs-number">15</span>])

<span class="hljs-meta">&gt;&gt;&gt; </span>outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index)
<span class="hljs-meta">&gt;&gt;&gt; </span>loss = tf.math.reduce_mean(outputs.loss)`}}),{c(){w(d.$$.fragment)},l(h){F(d.$$.fragment,h)},m(h,f){v(d,h,f),k=!0},p:Ge,i(h){k||($(d.$$.fragment,h),k=!0)},o(h){E(d.$$.fragment,h),k=!1},d(h){M(d,h)}}}function T1(x){let d,k,h,f,T,l,c,P,ke,he,I,re,ee,b,Te,K,ye,fe,B,be,ae,H,we,me,Q,Fe,ge,U,ue,ve,oe,C,A,_e,W,pe,$e,V,R,Ee,j,Me,Y,le,ze,G,de,qe,N,ce,Z,Pe,ne,O,xe,L,Ce,je,g,z,Ie,J,Se,Be,q,Ae,We,Le,Qe,Ue,D,X,Ke,Ne,S,Oe,De,ie,Re,te,He,Kc,Xn,zs,eh,Jn,nh,bi,th,oh,wi,sh,rh,qs,ah,ih,lh,dt,dh,Fi,ch,uh,vi,ph,hh,Rc,ct,no,jl,Ps,fh,Al,mh,Hc,en,xs,gh,Ol,_h,kh,Cs,Th,$i,yh,bh,wh,nt,js,Fh,Ll,vh,$h,As,Ei,Eh,Dl,Mh,zh,Mi,qh,Nl,Ph,xh,to,Os,Ch,Ls,jh,Il,Ah,Oh,Lh,Cn,Ds,Dh,Sl,Nh,Ih,oo,Sh,ut,Bh,Bl,Wh,Qh,Wl,Uh,Kh,Rh,zi,Ns,Vc,pt,so,Ql,Is,Hh,Ul,Vh,Yc,kn,Ss,Yh,Bs,Gh,Kl,Zh,Xh,Jh,Ws,ef,qi,nf,tf,of,tt,Qs,sf,Rl,rf,af,Us,Pi,lf,Hl,df,cf,xi,uf,Vl,pf,hf,jn,Ks,ff,Yl,mf,gf,ro,_f,ht,kf,Gl,Tf,yf,Zl,bf,wf,Gc,ft,ao,Xl,Rs,Ff,Jl,vf,Zc,mt,Hs,$f,Vs,Ef,Ci,Mf,zf,Xc,gt,Ys,qf,Gs,Pf,ji,xf,Cf,Jc,_t,io,ed,Zs,jf,nd,Af,eu,cn,Xs,Of,td,Lf,Df,Js,Nf,er,If,Sf,Bf,nr,Wf,Ai,Qf,Uf,Kf,tr,Rf,or,Hf,Vf,Yf,An,sr,Gf,kt,Zf,Oi,Xf,Jf,od,em,nm,tm,lo,om,co,nu,Tt,uo,sd,rr,sm,rd,rm,tu,un,ar,am,ad,im,lm,ir,dm,lr,cm,um,pm,dr,hm,Li,fm,mm,gm,cr,_m,ur,km,Tm,ym,On,pr,bm,yt,wm,Di,Fm,vm,id,$m,Em,Mm,po,zm,ho,ou,bt,fo,ld,hr,qm,dd,Pm,su,wt,fr,xm,Ln,mr,Cm,Ft,jm,Ni,Am,Om,cd,Lm,Dm,Nm,mo,Im,go,ru,vt,_o,ud,gr,Sm,pd,Bm,au,pn,_r,Wm,kr,Qm,hd,Um,Km,Rm,Tr,Hm,yr,Vm,Ym,Gm,br,Zm,Ii,Xm,Jm,eg,wr,ng,Fr,tg,og,sg,Dn,vr,rg,$t,ag,Si,ig,lg,fd,dg,cg,ug,ko,pg,To,iu,Et,yo,md,$r,hg,gd,fg,lu,hn,Er,mg,_d,gg,_g,Mr,kg,zr,Tg,yg,bg,qr,wg,Bi,Fg,vg,$g,Pr,Eg,xr,Mg,zg,qg,Tn,Cr,Pg,Mt,xg,Wi,Cg,jg,kd,Ag,Og,Lg,bo,Dg,wo,Ng,Fo,du,zt,vo,Td,jr,Ig,yd,Sg,cu,fn,Ar,Bg,bd,Wg,Qg,Or,Ug,Lr,Kg,Rg,Hg,Dr,Vg,Qi,Yg,Gg,Zg,Nr,Xg,Ir,Jg,e_,n_,Nn,Sr,t_,qt,o_,Ui,s_,r_,wd,a_,i_,l_,$o,d_,Eo,uu,Pt,Mo,Fd,Br,c_,vd,u_,pu,mn,Wr,p_,$d,h_,f_,Qr,m_,Ur,g_,__,k_,Kr,T_,Ki,y_,b_,w_,Rr,F_,Hr,v_,$_,E_,In,Vr,M_,xt,z_,Ri,q_,P_,Ed,x_,C_,j_,zo,A_,qo,hu,Ct,Po,Md,Yr,O_,zd,L_,fu,gn,Gr,D_,jt,N_,qd,I_,S_,Pd,B_,W_,Q_,Zr,U_,Xr,K_,R_,H_,Jr,V_,Hi,Y_,G_,Z_,ea,X_,na,J_,ek,nk,Sn,ta,tk,At,ok,Vi,sk,rk,xd,ak,ik,lk,xo,dk,Co,mu,Ot,jo,Cd,oa,ck,jd,uk,gu,nn,sa,pk,Ad,hk,fk,ra,mk,aa,gk,_k,kk,ia,Tk,Yi,yk,bk,wk,la,Fk,da,vk,$k,Ek,Ao,Mk,Bn,ca,zk,Lt,qk,Gi,Pk,xk,Od,Ck,jk,Ak,Oo,Ok,Lo,_u,Dt,Do,Ld,ua,Lk,Dd,Dk,ku,tn,pa,Nk,Nd,Ik,Sk,ha,Bk,fa,Wk,Qk,Uk,ma,Kk,Zi,Rk,Hk,Vk,ga,Yk,_a,Gk,Zk,Xk,No,Jk,Wn,ka,eT,Nt,nT,Xi,tT,oT,Id,sT,rT,aT,Io,iT,So,Tu,It,Bo,Sd,Ta,lT,Bd,dT,yu,on,ya,cT,Wd,uT,pT,ba,hT,wa,fT,mT,gT,Fa,_T,Ji,kT,TT,yT,va,bT,$a,wT,FT,vT,Wo,$T,Qn,Ea,ET,St,MT,el,zT,qT,Qd,PT,xT,CT,Qo,jT,Uo,bu,Bt,Ko,Ud,Ma,AT,Kd,OT,wu,sn,za,LT,qa,DT,Rd,NT,IT,ST,Pa,BT,xa,WT,QT,UT,Ca,KT,nl,RT,HT,VT,ja,YT,Aa,GT,ZT,XT,Ro,JT,yn,Oa,ey,Wt,ny,tl,ty,oy,Hd,sy,ry,ay,Ho,iy,Vo,ly,Yo,Fu,Qt,Go,Vd,La,dy,Yd,cy,vu,rn,Da,uy,Gd,py,hy,Na,fy,Ia,my,gy,_y,Sa,ky,ol,Ty,yy,by,Ba,wy,Wa,Fy,vy,$y,Zo,Ey,bn,Qa,My,Ut,zy,sl,qy,Py,Zd,xy,Cy,jy,Xo,Ay,Jo,Oy,es,$u,Kt,ns,Xd,Ua,Ly,Jd,Dy,Eu,an,Ka,Ny,ec,Iy,Sy,Ra,By,Ha,Wy,Qy,Uy,Va,Ky,rl,Ry,Hy,Vy,Ya,Yy,Ga,Gy,Zy,Xy,ts,Jy,Un,Za,eb,Rt,nb,al,tb,ob,nc,sb,rb,ab,os,ib,ss,Mu,Ht,rs,tc,Xa,lb,oc,db,zu,ln,Ja,cb,sc,ub,pb,ei,hb,ni,fb,mb,gb,ti,_b,il,kb,Tb,yb,oi,bb,si,wb,Fb,vb,as,$b,wn,ri,Eb,Vt,Mb,ll,zb,qb,rc,Pb,xb,Cb,is,jb,ls,Ab,ds,qu,Yt,cs,ac,ai,Ob,ic,Lb,Pu,dn,ii,Db,Gt,Nb,lc,Ib,Sb,dc,Bb,Wb,Qb,li,Ub,di,Kb,Rb,Hb,ci,Vb,dl,Yb,Gb,Zb,ui,Xb,pi,Jb,ew,nw,us,tw,Fn,hi,ow,Zt,sw,cl,rw,aw,cc,iw,lw,dw,ps,cw,hs,uw,fs,xu;return l=new Xe({}),b=new Xe({}),ie=new Xe({}),zs=new se({props:{name:"class transformers.FunnelConfig",anchor:"transformers.FunnelConfig",parameters:[{name:"vocab_size",val:" = 30522"},{name:"block_sizes",val:" = [4, 4, 4]"},{name:"block_repeats",val:" = None"},{name:"num_decoder_layers",val:" = 2"},{name:"d_model",val:" = 768"},{name:"n_head",val:" = 12"},{name:"d_head",val:" = 64"},{name:"d_inner",val:" = 3072"},{name:"hidden_act",val:" = 'gelu_new'"},{name:"hidden_dropout",val:" = 0.1"},{name:"attention_dropout",val:" = 0.1"},{name:"activation_dropout",val:" = 0.0"},{name:"type_vocab_size",val:" = 3"},{name:"initializer_range",val:" = 0.1"},{name:"initializer_std",val:" = None"},{name:"layer_norm_eps",val:" = 1e-09"},{name:"pooling_type",val:" = 'mean'"},{name:"attention_type",val:" = 'relative_shift'"},{name:"separate_cls",val:" = True"},{name:"truncate_seq",val:" = True"},{name:"pool_q_only",val:" = True"},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"transformers.FunnelConfig.vocab_size",description:`<strong>vocab_size</strong> (<code>int</code>, <em>optional</em>, defaults to 30522) &#x2014;
Vocabulary size of the Funnel transformer. Defines the number of different tokens that can be represented
by the <code>inputs_ids</code> passed when calling <a href="/docs/transformers/main/en/model_doc/funnel#transformers.FunnelModel">FunnelModel</a> or <a href="/docs/transformers/main/en/model_doc/funnel#transformers.TFFunnelModel">TFFunnelModel</a>.`,name:"vocab_size"},{anchor:"transformers.FunnelConfig.block_sizes",description:`<strong>block_sizes</strong> (<code>List[int]</code>, <em>optional</em>, defaults to <code>[4, 4, 4]</code>) &#x2014;
The sizes of the blocks used in the model.`,name:"block_sizes"},{anchor:"transformers.FunnelConfig.block_repeats",description:`<strong>block_repeats</strong> (<code>List[int]</code>, <em>optional</em>) &#x2014;
If passed along, each layer of each block is repeated the number of times indicated.`,name:"block_repeats"},{anchor:"transformers.FunnelConfig.num_decoder_layers",description:`<strong>num_decoder_layers</strong> (<code>int</code>, <em>optional</em>, defaults to 2) &#x2014;
The number of layers in the decoder (when not using the base model).`,name:"num_decoder_layers"},{anchor:"transformers.FunnelConfig.d_model",description:`<strong>d_model</strong> (<code>int</code>, <em>optional</em>, defaults to 768) &#x2014;
Dimensionality of the model&#x2019;s hidden states.`,name:"d_model"},{anchor:"transformers.FunnelConfig.n_head",description:`<strong>n_head</strong> (<code>int</code>, <em>optional</em>, defaults to 12) &#x2014;
Number of attention heads for each attention layer in the Transformer encoder.`,name:"n_head"},{anchor:"transformers.FunnelConfig.d_head",description:`<strong>d_head</strong> (<code>int</code>, <em>optional</em>, defaults to 64) &#x2014;
Dimensionality of the model&#x2019;s heads.`,name:"d_head"},{anchor:"transformers.FunnelConfig.d_inner",description:`<strong>d_inner</strong> (<code>int</code>, <em>optional</em>, defaults to 3072) &#x2014;
Inner dimension in the feed-forward blocks.`,name:"d_inner"},{anchor:"transformers.FunnelConfig.hidden_act",description:`<strong>hidden_act</strong> (<code>str</code> or <code>callable</code>, <em>optional</em>, defaults to <code>&quot;gelu_new&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;silu&quot;</code> and <code>&quot;gelu_new&quot;</code> are supported.`,name:"hidden_act"},{anchor:"transformers.FunnelConfig.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, encoder, and pooler.`,name:"hidden_dropout"},{anchor:"transformers.FunnelConfig.attention_dropout",description:`<strong>attention_dropout</strong> (<code>float</code>, <em>optional</em>, defaults to 0.1) &#x2014;
The dropout probability for the attention probabilities.`,name:"attention_dropout"},{anchor:"transformers.FunnelConfig.activation_dropout",description:`<strong>activation_dropout</strong> (<code>float</code>, <em>optional</em>, defaults to 0.0) &#x2014;
The dropout probability used between the two layers of the feed-forward blocks.`,name:"activation_dropout"},{anchor:"transformers.FunnelConfig.type_vocab_size",description:`<strong>type_vocab_size</strong> (<code>int</code>, <em>optional</em>, defaults to 3) &#x2014;
The vocabulary size of the <code>token_type_ids</code> passed when calling <a href="/docs/transformers/main/en/model_doc/funnel#transformers.FunnelModel">FunnelModel</a> or <a href="/docs/transformers/main/en/model_doc/funnel#transformers.TFFunnelModel">TFFunnelModel</a>.`,name:"type_vocab_size"},{anchor:"transformers.FunnelConfig.initializer_range",description:`<strong>initializer_range</strong> (<code>float</code>, <em>optional</em>, defaults to 0.1) &#x2014;
The upper bound of the <em>uniform initializer</em> for initializing all weight matrices in attention layers.`,name:"initializer_range"},{anchor:"transformers.FunnelConfig.initializer_std",description:`<strong>initializer_std</strong> (<code>float</code>, <em>optional</em>) &#x2014;
The standard deviation of the <em>normal initializer</em> for initializing the embedding matrix and the weight of
linear layers. Will default to 1 for the embedding matrix and the value given by Xavier initialization for
linear layers.`,name:"initializer_std"},{anchor:"transformers.FunnelConfig.layer_norm_eps",description:`<strong>layer_norm_eps</strong> (<code>float</code>, <em>optional</em>, defaults to 1e-9) &#x2014;
The epsilon used by the layer normalization layers.`,name:"layer_norm_eps"},{anchor:"transformers.FunnelConfig.pooling_type",description:`<strong>pooling_type</strong> (<code>str</code>, <em>optional</em>, defaults to <code>&quot;mean&quot;</code>) &#x2014;
Possible values are <code>&quot;mean&quot;</code> or <code>&quot;max&quot;</code>. The way pooling is performed at the beginning of each block.`,name:"pooling_type"},{anchor:"transformers.FunnelConfig.attention_type",description:`<strong>attention_type</strong> (<code>str</code>, <em>optional</em>, defaults to <code>&quot;relative_shift&quot;</code>) &#x2014;
Possible values are <code>&quot;relative_shift&quot;</code> or <code>&quot;factorized&quot;</code>. The former is faster on CPU/GPU while the latter
is faster on TPU.`,name:"attention_type"},{anchor:"transformers.FunnelConfig.separate_cls",description:`<strong>separate_cls</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>True</code>) &#x2014;
Whether or not to separate the cls token when applying pooling.`,name:"separate_cls"},{anchor:"transformers.FunnelConfig.truncate_seq",description:`<strong>truncate_seq</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>False</code>) &#x2014;
When using <code>separate_cls</code>, whether or not to truncate the last token when pooling, to avoid getting a
sequence length that is not a multiple of 2.`,name:"truncate_seq"},{anchor:"transformers.FunnelConfig.pool_q_only",description:`<strong>pool_q_only</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>False</code>) &#x2014;
Whether or not to apply the pooling only to the query or to query, key and values for the attention layers.`,name:"pool_q_only"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/funnel/configuration_funnel.py#L41"}}),Ps=new Xe({}),xs=new se({props:{name:"class transformers.FunnelTokenizer",anchor:"transformers.FunnelTokenizer",parameters:[{name:"vocab_file",val:""},{name:"do_lower_case",val:" = True"},{name:"do_basic_tokenize",val:" = True"},{name:"never_split",val:" = None"},{name:"unk_token",val:" = '<unk>'"},{name:"sep_token",val:" = '<sep>'"},{name:"pad_token",val:" = '<pad>'"},{name:"cls_token",val:" = '<cls>'"},{name:"mask_token",val:" = '<mask>'"},{name:"bos_token",val:" = '<s>'"},{name:"eos_token",val:" = '</s>'"},{name:"tokenize_chinese_chars",val:" = True"},{name:"strip_accents",val:" = None"},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"transformers.FunnelTokenizer.vocab_file",description:`<strong>vocab_file</strong> (<code>str</code>) &#x2014;
File containing the vocabulary.`,name:"vocab_file"},{anchor:"transformers.FunnelTokenizer.do_lower_case",description:`<strong>do_lower_case</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>True</code>) &#x2014;
Whether or not to lowercase the input when tokenizing.`,name:"do_lower_case"},{anchor:"transformers.FunnelTokenizer.do_basic_tokenize",description:`<strong>do_basic_tokenize</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>True</code>) &#x2014;
Whether or not to do basic tokenization before WordPiece.`,name:"do_basic_tokenize"},{anchor:"transformers.FunnelTokenizer.never_split",description:`<strong>never_split</strong> (<code>Iterable</code>, <em>optional</em>) &#x2014;
Collection of tokens which will never be split during tokenization. Only has an effect when
<code>do_basic_tokenize=True</code>`,name:"never_split"},{anchor:"transformers.FunnelTokenizer.unk_token",description:`<strong>unk_token</strong> (<code>str</code>, <em>optional</em>, defaults to <code>&quot;&lt;unk&gt;&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.FunnelTokenizer.sep_token",description:`<strong>sep_token</strong> (<code>str</code>, <em>optional</em>, defaults to <code>&quot;&lt;sep&gt;&quot;</code>) &#x2014;
The separator token, which is used when building a sequence from multiple sequences, e.g. two sequences for
sequence classification or for a text and a question for question answering. It is also used as the last
token of a sequence built with special tokens.`,name:"sep_token"},{anchor:"transformers.FunnelTokenizer.pad_token",description:`<strong>pad_token</strong> (<code>str</code>, <em>optional</em>, defaults to <code>&quot;&lt;pad&gt;&quot;</code>) &#x2014;
The token used for padding, for example when batching sequences of different lengths.`,name:"pad_token"},{anchor:"transformers.FunnelTokenizer.cls_token",description:`<strong>cls_token</strong> (<code>str</code>, <em>optional</em>, defaults to <code>&quot;&lt;cls&gt;&quot;</code>) &#x2014;
The classifier token which is used when doing sequence classification (classification of the whole sequence
instead of per-token classification). It is the first token of the sequence when built with special tokens.`,name:"cls_token"},{anchor:"transformers.FunnelTokenizer.mask_token",description:`<strong>mask_token</strong> (<code>str</code>, <em>optional</em>, defaults to <code>&quot;&lt;mask&gt;&quot;</code>) &#x2014;
The token used for masking values. This is the token used when training this model with masked language
modeling. This is the token which the model will try to predict.`,name:"mask_token"},{anchor:"transformers.FunnelTokenizer.bos_token",description:`<strong>bos_token</strong> (<code>str</code>, <code>optional</code>, defaults to <code>&quot;&lt;s&gt;&quot;</code>) &#x2014;
The beginning of sentence token.`,name:"bos_token"},{anchor:"transformers.FunnelTokenizer.eos_token",description:`<strong>eos_token</strong> (<code>str</code>, <code>optional</code>, defaults to <code>&quot;&lt;/s&gt;&quot;</code>) &#x2014;
The end of sentence token.`,name:"eos_token"},{anchor:"transformers.FunnelTokenizer.tokenize_chinese_chars",description:`<strong>tokenize_chinese_chars</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>True</code>) &#x2014;
Whether or not to tokenize Chinese characters.</p>
<p>This should likely be deactivated for Japanese (see this
<a href="https://github.com/huggingface/transformers/issues/328" rel="nofollow">issue</a>).`,name:"tokenize_chinese_chars"},{anchor:"transformers.FunnelTokenizer.strip_accents",description:`<strong>strip_accents</strong> (<code>bool</code>, <em>optional</em>) &#x2014;
Whether or not to strip all accents. If this option is not specified, then it will be determined by the
value for <code>lowercase</code> (as in the original BERT).`,name:"strip_accents"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/funnel/tokenization_funnel.py#L91"}}),js=new se({props:{name:"build_inputs_with_special_tokens",anchor:"transformers.FunnelTokenizer.build_inputs_with_special_tokens",parameters:[{name:"token_ids_0",val:": typing.List[int]"},{name:"token_ids_1",val:": typing.Optional[typing.List[int]] = None"}],parametersDescription:[{anchor:"transformers.FunnelTokenizer.build_inputs_with_special_tokens.token_ids_0",description:`<strong>token_ids_0</strong> (<code>List[int]</code>) &#x2014;
List of IDs to which the special tokens will be added.`,name:"token_ids_0"},{anchor:"transformers.FunnelTokenizer.build_inputs_with_special_tokens.token_ids_1",description:`<strong>token_ids_1</strong> (<code>List[int]</code>, <em>optional</em>) &#x2014;
Optional second list of IDs for sequence pairs.`,name:"token_ids_1"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/funnel/tokenization_funnel.py#L239",returnDescription:`
<p>List of <a href="../glossary#input-ids">input IDs</a> with the appropriate special tokens.</p>
`,returnType:`
<p><code>List[int]</code></p>
`}}),Os=new se({props:{name:"get_special_tokens_mask",anchor:"transformers.FunnelTokenizer.get_special_tokens_mask",parameters:[{name:"token_ids_0",val:": typing.List[int]"},{name:"token_ids_1",val:": typing.Optional[typing.List[int]] = None"},{name:"already_has_special_tokens",val:": bool = False"}],parametersDescription:[{anchor:"transformers.FunnelTokenizer.get_special_tokens_mask.token_ids_0",description:`<strong>token_ids_0</strong> (<code>List[int]</code>) &#x2014;
List of IDs.`,name:"token_ids_0"},{anchor:"transformers.FunnelTokenizer.get_special_tokens_mask.token_ids_1",description:`<strong>token_ids_1</strong> (<code>List[int]</code>, <em>optional</em>) &#x2014;
Optional second list of IDs for sequence pairs.`,name:"token_ids_1"},{anchor:"transformers.FunnelTokenizer.get_special_tokens_mask.already_has_special_tokens",description:`<strong>already_has_special_tokens</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>False</code>) &#x2014;
Whether or not the token list is already formatted with special tokens for the model.`,name:"already_has_special_tokens"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/funnel/tokenization_funnel.py#L265",returnDescription:`
<p>A list of integers in the range [0, 1]: 1 for a special token, 0 for a sequence token.</p>
`,returnType:`
<p><code>List[int]</code></p>
`}}),Ds=new se({props:{name:"create_token_type_ids_from_sequences",anchor:"transformers.FunnelTokenizer.create_token_type_ids_from_sequences",parameters:[{name:"token_ids_0",val:": typing.List[int]"},{name:"token_ids_1",val:": typing.Optional[typing.List[int]] = None"}],parametersDescription:[{anchor:"transformers.FunnelTokenizer.create_token_type_ids_from_sequences.token_ids_0",description:`<strong>token_ids_0</strong> (<code>List[int]</code>) &#x2014;
List of IDs.`,name:"token_ids_0"},{anchor:"transformers.FunnelTokenizer.create_token_type_ids_from_sequences.token_ids_1",description:`<strong>token_ids_1</strong> (<code>List[int]</code>, <em>optional</em>) &#x2014;
Optional second list of IDs for sequence pairs.`,name:"token_ids_1"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/funnel/tokenization_funnel.py#L293",returnDescription:`
<p>List of <a href="../glossary#token-type-ids">token type IDs</a> according to the given sequence(s).</p>
`,returnType:`
<p><code>List[int]</code></p>
`}}),oo=new Ye({props:{anchor:"transformers.FunnelTokenizer.create_token_type_ids_from_sequences.example",$$slots:{default:[E$]},$$scope:{ctx:x}}}),Ns=new se({props:{name:"save_vocabulary",anchor:"transformers.FunnelTokenizer.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/funnel/tokenization_funnel.py#L323"}}),Is=new Xe({}),Ss=new se({props:{name:"class transformers.FunnelTokenizerFast",anchor:"transformers.FunnelTokenizerFast",parameters:[{name:"vocab_file",val:" = None"},{name:"tokenizer_file",val:" = None"},{name:"do_lower_case",val:" = True"},{name:"unk_token",val:" = '<unk>'"},{name:"sep_token",val:" = '<sep>'"},{name:"pad_token",val:" = '<pad>'"},{name:"cls_token",val:" = '<cls>'"},{name:"mask_token",val:" = '<mask>'"},{name:"bos_token",val:" = '<s>'"},{name:"eos_token",val:" = '</s>'"},{name:"clean_text",val:" = True"},{name:"tokenize_chinese_chars",val:" = True"},{name:"strip_accents",val:" = None"},{name:"wordpieces_prefix",val:" = '##'"},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"transformers.FunnelTokenizerFast.vocab_file",description:`<strong>vocab_file</strong> (<code>str</code>) &#x2014;
File containing the vocabulary.`,name:"vocab_file"},{anchor:"transformers.FunnelTokenizerFast.do_lower_case",description:`<strong>do_lower_case</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>True</code>) &#x2014;
Whether or not to lowercase the input when tokenizing.`,name:"do_lower_case"},{anchor:"transformers.FunnelTokenizerFast.unk_token",description:`<strong>unk_token</strong> (<code>str</code>, <em>optional</em>, defaults to <code>&quot;&lt;unk&gt;&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.FunnelTokenizerFast.sep_token",description:`<strong>sep_token</strong> (<code>str</code>, <em>optional</em>, defaults to <code>&quot;&lt;sep&gt;&quot;</code>) &#x2014;
The separator token, which is used when building a sequence from multiple sequences, e.g. two sequences for
sequence classification or for a text and a question for question answering. It is also used as the last
token of a sequence built with special tokens.`,name:"sep_token"},{anchor:"transformers.FunnelTokenizerFast.pad_token",description:`<strong>pad_token</strong> (<code>str</code>, <em>optional</em>, defaults to <code>&quot;&lt;pad&gt;&quot;</code>) &#x2014;
The token used for padding, for example when batching sequences of different lengths.`,name:"pad_token"},{anchor:"transformers.FunnelTokenizerFast.cls_token",description:`<strong>cls_token</strong> (<code>str</code>, <em>optional</em>, defaults to <code>&quot;&lt;cls&gt;&quot;</code>) &#x2014;
The classifier token which is used when doing sequence classification (classification of the whole sequence
instead of per-token classification). It is the first token of the sequence when built with special tokens.`,name:"cls_token"},{anchor:"transformers.FunnelTokenizerFast.mask_token",description:`<strong>mask_token</strong> (<code>str</code>, <em>optional</em>, defaults to <code>&quot;&lt;mask&gt;&quot;</code>) &#x2014;
The token used for masking values. This is the token used when training this model with masked language
modeling. This is the token which the model will try to predict.`,name:"mask_token"},{anchor:"transformers.FunnelTokenizerFast.clean_text",description:`<strong>clean_text</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>True</code>) &#x2014;
Whether or not to clean the text before tokenization by removing any control characters and replacing all
whitespaces by the classic one.`,name:"clean_text"},{anchor:"transformers.FunnelTokenizerFast.tokenize_chinese_chars",description:`<strong>tokenize_chinese_chars</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>True</code>) &#x2014;
Whether or not to tokenize Chinese characters. This should likely be deactivated for Japanese (see <a href="https://github.com/huggingface/transformers/issues/328" rel="nofollow">this
issue</a>).`,name:"tokenize_chinese_chars"},{anchor:"transformers.FunnelTokenizerFast.bos_token",description:`<strong>bos_token</strong> (<code>str</code>, <code>optional</code>, defaults to <code>&quot;&lt;s&gt;&quot;</code>) &#x2014;
The beginning of sentence token.`,name:"bos_token"},{anchor:"transformers.FunnelTokenizerFast.eos_token",description:`<strong>eos_token</strong> (<code>str</code>, <code>optional</code>, defaults to <code>&quot;&lt;/s&gt;&quot;</code>) &#x2014;
The end of sentence token.`,name:"eos_token"},{anchor:"transformers.FunnelTokenizerFast.strip_accents",description:`<strong>strip_accents</strong> (<code>bool</code>, <em>optional</em>) &#x2014;
Whether or not to strip all accents. If this option is not specified, then it will be determined by the
value for <code>lowercase</code> (as in the original BERT).`,name:"strip_accents"},{anchor:"transformers.FunnelTokenizerFast.wordpieces_prefix",description:`<strong>wordpieces_prefix</strong> (<code>str</code>, <em>optional</em>, defaults to <code>&quot;##&quot;</code>) &#x2014;
The prefix for subwords.`,name:"wordpieces_prefix"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/funnel/tokenization_funnel_fast.py#L94"}}),Qs=new se({props:{name:"build_inputs_with_special_tokens",anchor:"transformers.FunnelTokenizerFast.build_inputs_with_special_tokens",parameters:[{name:"token_ids_0",val:""},{name:"token_ids_1",val:" = None"}],parametersDescription:[{anchor:"transformers.FunnelTokenizerFast.build_inputs_with_special_tokens.token_ids_0",description:`<strong>token_ids_0</strong> (<code>List[int]</code>) &#x2014;
List of IDs to which the special tokens will be added.`,name:"token_ids_0"},{anchor:"transformers.FunnelTokenizerFast.build_inputs_with_special_tokens.token_ids_1",description:`<strong>token_ids_1</strong> (<code>List[int]</code>, <em>optional</em>) &#x2014;
Optional second list of IDs for sequence pairs.`,name:"token_ids_1"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/funnel/tokenization_funnel_fast.py#L196",returnDescription:`
<p>List of <a href="../glossary#input-ids">input IDs</a> with the appropriate special tokens.</p>
`,returnType:`
<p><code>List[int]</code></p>
`}}),Ks=new se({props:{name:"create_token_type_ids_from_sequences",anchor:"transformers.FunnelTokenizerFast.create_token_type_ids_from_sequences",parameters:[{name:"token_ids_0",val:": typing.List[int]"},{name:"token_ids_1",val:": typing.Optional[typing.List[int]] = None"}],parametersDescription:[{anchor:"transformers.FunnelTokenizerFast.create_token_type_ids_from_sequences.token_ids_0",description:`<strong>token_ids_0</strong> (<code>List[int]</code>) &#x2014;
List of IDs.`,name:"token_ids_0"},{anchor:"transformers.FunnelTokenizerFast.create_token_type_ids_from_sequences.token_ids_1",description:`<strong>token_ids_1</strong> (<code>List[int]</code>, <em>optional</em>) &#x2014;
Optional second list of IDs for sequence pairs.`,name:"token_ids_1"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/funnel/tokenization_funnel_fast.py#L220",returnDescription:`
<p>List of <a href="../glossary#token-type-ids">token type IDs</a> according to the given sequence(s).</p>
`,returnType:`
<p><code>List[int]</code></p>
`}}),ro=new Ye({props:{anchor:"transformers.FunnelTokenizerFast.create_token_type_ids_from_sequences.example",$$slots:{default:[M$]},$$scope:{ctx:x}}}),Rs=new Xe({}),Hs=new se({props:{name:"class transformers.models.funnel.modeling_funnel.FunnelForPreTrainingOutput",anchor:"transformers.models.funnel.modeling_funnel.FunnelForPreTrainingOutput",parameters:[{name:"loss",val:": typing.Optional[torch.FloatTensor] = None"},{name:"logits",val:": FloatTensor = None"},{name:"hidden_states",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"}],parametersDescription:[{anchor:"transformers.models.funnel.modeling_funnel.FunnelForPreTrainingOutput.loss",description:`<strong>loss</strong> (<em>optional</em>, returned when <code>labels</code> is provided, <code>torch.FloatTensor</code> of shape <code>(1,)</code>) &#x2014;
Total loss of the ELECTRA-style objective.`,name:"loss"},{anchor:"transformers.models.funnel.modeling_funnel.FunnelForPreTrainingOutput.logits",description:`<strong>logits</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length)</code>) &#x2014;
Prediction scores of the head (scores for each token before SoftMax).`,name:"logits"},{anchor:"transformers.models.funnel.modeling_funnel.FunnelForPreTrainingOutput.hidden_states",description:`<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>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for the output of the embeddings + 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 initial embedding outputs.`,name:"hidden_states"},{anchor:"transformers.models.funnel.modeling_funnel.FunnelForPreTrainingOutput.attentions",description:`<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>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
heads.`,name:"attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/funnel/modeling_funnel.py#L833"}}),Ys=new se({props:{name:"class transformers.models.funnel.modeling_tf_funnel.TFFunnelForPreTrainingOutput",anchor:"transformers.models.funnel.modeling_tf_funnel.TFFunnelForPreTrainingOutput",parameters:[{name:"logits",val:": Tensor = None"},{name:"hidden_states",val:": typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = None"},{name:"attentions",val:": typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = None"}],parametersDescription:[{anchor:"transformers.models.funnel.modeling_tf_funnel.TFFunnelForPreTrainingOutput.logits",description:`<strong>logits</strong> (<code>tf.Tensor</code> of shape <code>(batch_size, sequence_length)</code>) &#x2014;
Prediction scores of the head (scores for each token before SoftMax).`,name:"logits"},{anchor:"transformers.models.funnel.modeling_tf_funnel.TFFunnelForPreTrainingOutput.hidden_states",description:`<strong>hidden_states</strong> (<code>tuple(tf.Tensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>tf.Tensor</code> (one for the output of the embeddings + 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 initial embedding outputs.`,name:"hidden_states"},{anchor:"transformers.models.funnel.modeling_tf_funnel.TFFunnelForPreTrainingOutput.attentions",description:`<strong>attentions</strong> (<code>tuple(tf.Tensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>tf.Tensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
heads.`,name:"attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/funnel/modeling_tf_funnel.py#L987"}}),Zs=new Xe({}),Xs=new se({props:{name:"class transformers.FunnelBaseModel",anchor:"transformers.FunnelBaseModel",parameters:[{name:"config",val:": FunnelConfig"}],parametersDescription:[{anchor:"transformers.FunnelBaseModel.config",description:`<strong>config</strong> (<a href="/docs/transformers/main/en/model_doc/funnel#transformers.FunnelConfig">FunnelConfig</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/funnel/modeling_funnel.py#L926"}}),sr=new se({props:{name:"forward",anchor:"transformers.FunnelBaseModel.forward",parameters:[{name:"input_ids",val:": typing.Optional[torch.Tensor] = None"},{name:"attention_mask",val:": typing.Optional[torch.Tensor] = None"},{name:"token_type_ids",val:": typing.Optional[torch.Tensor] = None"},{name:"position_ids",val:": typing.Optional[torch.Tensor] = None"},{name:"head_mask",val:": typing.Optional[torch.Tensor] = None"},{name:"inputs_embeds",val:": typing.Optional[torch.Tensor] = 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.FunnelBaseModel.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.</p>
<p>Indices can be obtained using <a href="/docs/transformers/main/en/model_doc/bert#transformers.BertTokenizer">BertTokenizer</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.FunnelBaseModel.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><a href="../glossary#attention-mask">What are attention masks?</a>`,name:"attention_mask"},{anchor:"transformers.FunnelBaseModel.forward.token_type_ids",description:`<strong>token_type_ids</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size, sequence_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.FunnelBaseModel.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.`,name:"inputs_embeds"},{anchor:"transformers.FunnelBaseModel.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.FunnelBaseModel.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.FunnelBaseModel.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/funnel/modeling_funnel.py#L942",returnDescription:`
<p>A <a
  href="/docs/transformers/main/en/main_classes/output#transformers.modeling_outputs.BaseModelOutput"
>transformers.modeling_outputs.BaseModelOutput</a> 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/main/en/model_doc/funnel#transformers.FunnelConfig"
>FunnelConfig</a>) and inputs.</p>
<ul>
<li>
<p><strong>last_hidden_state</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>) \u2014 Sequence of hidden-states at the output of the last layer of the model.</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>Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
heads.</p>
</li>
</ul>
`,returnType:`
<p><a
  href="/docs/transformers/main/en/main_classes/output#transformers.modeling_outputs.BaseModelOutput"
>transformers.modeling_outputs.BaseModelOutput</a> or <code>tuple(torch.FloatTensor)</code></p>
`}}),lo=new Ve({props:{$$slots:{default:[z$]},$$scope:{ctx:x}}}),co=new Ye({props:{anchor:"transformers.FunnelBaseModel.forward.example",$$slots:{default:[q$]},$$scope:{ctx:x}}}),rr=new Xe({}),ar=new se({props:{name:"class transformers.FunnelModel",anchor:"transformers.FunnelModel",parameters:[{name:"config",val:": FunnelConfig"}],parametersDescription:[{anchor:"transformers.FunnelModel.config",description:`<strong>config</strong> (<a href="/docs/transformers/main/en/model_doc/funnel#transformers.FunnelConfig">FunnelConfig</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/funnel/modeling_funnel.py#L1002"}}),pr=new se({props:{name:"forward",anchor:"transformers.FunnelModel.forward",parameters:[{name:"input_ids",val:": typing.Optional[torch.Tensor] = None"},{name:"attention_mask",val:": typing.Optional[torch.Tensor] = None"},{name:"token_type_ids",val:": typing.Optional[torch.Tensor] = None"},{name:"inputs_embeds",val:": typing.Optional[torch.Tensor] = 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.FunnelModel.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.</p>
<p>Indices can be obtained using <a href="/docs/transformers/main/en/model_doc/bert#transformers.BertTokenizer">BertTokenizer</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.FunnelModel.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><a href="../glossary#attention-mask">What are attention masks?</a>`,name:"attention_mask"},{anchor:"transformers.FunnelModel.forward.token_type_ids",description:`<strong>token_type_ids</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size, sequence_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.FunnelModel.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.`,name:"inputs_embeds"},{anchor:"transformers.FunnelModel.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.FunnelModel.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.FunnelModel.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/funnel/modeling_funnel.py#L1019",returnDescription:`
<p>A <a
  href="/docs/transformers/main/en/main_classes/output#transformers.modeling_outputs.BaseModelOutput"
>transformers.modeling_outputs.BaseModelOutput</a> 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/main/en/model_doc/funnel#transformers.FunnelConfig"
>FunnelConfig</a>) and inputs.</p>
<ul>
<li>
<p><strong>last_hidden_state</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>) \u2014 Sequence of hidden-states at the output of the last layer of the model.</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>Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
heads.</p>
</li>
</ul>
`,returnType:`
<p><a
  href="/docs/transformers/main/en/main_classes/output#transformers.modeling_outputs.BaseModelOutput"
>transformers.modeling_outputs.BaseModelOutput</a> or <code>tuple(torch.FloatTensor)</code></p>
`}}),po=new Ve({props:{$$slots:{default:[P$]},$$scope:{ctx:x}}}),ho=new Ye({props:{anchor:"transformers.FunnelModel.forward.example",$$slots:{default:[x$]},$$scope:{ctx:x}}}),hr=new Xe({}),fr=new se({props:{name:"class transformers.FunnelForPreTraining",anchor:"transformers.FunnelForPreTraining",parameters:[{name:"config",val:": FunnelConfig"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/funnel/modeling_funnel.py#L1109"}}),mr=new se({props:{name:"forward",anchor:"transformers.FunnelForPreTraining.forward",parameters:[{name:"input_ids",val:": typing.Optional[torch.Tensor] = None"},{name:"attention_mask",val:": typing.Optional[torch.Tensor] = None"},{name:"token_type_ids",val:": typing.Optional[torch.Tensor] = None"},{name:"inputs_embeds",val:": typing.Optional[torch.Tensor] = None"},{name:"labels",val:": typing.Optional[torch.Tensor] = 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.FunnelForPreTraining.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.</p>
<p>Indices can be obtained using <a href="/docs/transformers/main/en/model_doc/bert#transformers.BertTokenizer">BertTokenizer</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.FunnelForPreTraining.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><a href="../glossary#attention-mask">What are attention masks?</a>`,name:"attention_mask"},{anchor:"transformers.FunnelForPreTraining.forward.token_type_ids",description:`<strong>token_type_ids</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size, sequence_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.FunnelForPreTraining.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.`,name:"inputs_embeds"},{anchor:"transformers.FunnelForPreTraining.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.FunnelForPreTraining.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.FunnelForPreTraining.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.FunnelForPreTraining.forward.labels",description:`<strong>labels</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size, sequence_length)</code>, <em>optional</em>) &#x2014;
Labels for computing the ELECTRA-style loss. Input should be a sequence of tokens (see <code>input_ids</code>
docstring) Indices should be in <code>[0, 1]</code>:</p>
<ul>
<li>0 indicates the token is an original token,</li>
<li>1 indicates the token was replaced.</li>
</ul>`,name:"labels"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/funnel/modeling_funnel.py#L1118",returnDescription:`
<p>A <a
  href="/docs/transformers/main/en/model_doc/funnel#transformers.models.funnel.modeling_funnel.FunnelForPreTrainingOutput"
>transformers.models.funnel.modeling_funnel.FunnelForPreTrainingOutput</a> 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/main/en/model_doc/funnel#transformers.FunnelConfig"
>FunnelConfig</a>) and inputs.</p>
<ul>
<li>
<p><strong>loss</strong> (<em>optional</em>, returned when <code>labels</code> is provided, <code>torch.FloatTensor</code> of shape <code>(1,)</code>) \u2014 Total loss of the ELECTRA-style objective.</p>
</li>
<li>
<p><strong>logits</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length)</code>) \u2014 Prediction scores of the head (scores for each token before SoftMax).</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 + 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 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>Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
heads.</p>
</li>
</ul>
`,returnType:`
<p><a
  href="/docs/transformers/main/en/model_doc/funnel#transformers.models.funnel.modeling_funnel.FunnelForPreTrainingOutput"
>transformers.models.funnel.modeling_funnel.FunnelForPreTrainingOutput</a> or <code>tuple(torch.FloatTensor)</code></p>
`}}),mo=new Ve({props:{$$slots:{default:[C$]},$$scope:{ctx:x}}}),go=new Ye({props:{anchor:"transformers.FunnelForPreTraining.forward.example",$$slots:{default:[j$]},$$scope:{ctx:x}}}),gr=new Xe({}),_r=new se({props:{name:"class transformers.FunnelForMaskedLM",anchor:"transformers.FunnelForMaskedLM",parameters:[{name:"config",val:": FunnelConfig"}],parametersDescription:[{anchor:"transformers.FunnelForMaskedLM.config",description:`<strong>config</strong> (<a href="/docs/transformers/main/en/model_doc/funnel#transformers.FunnelConfig">FunnelConfig</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/funnel/modeling_funnel.py#L1192"}}),vr=new se({props:{name:"forward",anchor:"transformers.FunnelForMaskedLM.forward",parameters:[{name:"input_ids",val:": typing.Optional[torch.Tensor] = None"},{name:"attention_mask",val:": typing.Optional[torch.Tensor] = None"},{name:"token_type_ids",val:": typing.Optional[torch.Tensor] = None"},{name:"inputs_embeds",val:": typing.Optional[torch.Tensor] = None"},{name:"labels",val:": typing.Optional[torch.Tensor] = 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.FunnelForMaskedLM.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.</p>
<p>Indices can be obtained using <a href="/docs/transformers/main/en/model_doc/bert#transformers.BertTokenizer">BertTokenizer</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.FunnelForMaskedLM.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><a href="../glossary#attention-mask">What are attention masks?</a>`,name:"attention_mask"},{anchor:"transformers.FunnelForMaskedLM.forward.token_type_ids",description:`<strong>token_type_ids</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size, sequence_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.FunnelForMaskedLM.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.`,name:"inputs_embeds"},{anchor:"transformers.FunnelForMaskedLM.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.FunnelForMaskedLM.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.FunnelForMaskedLM.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.FunnelForMaskedLM.forward.labels",description:`<strong>labels</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size, sequence_length)</code>, <em>optional</em>) &#x2014;
Labels for computing the masked language modeling loss. Indices should be in <code>[-100, 0, ..., config.vocab_size]</code> (see <code>input_ids</code> docstring) Tokens with indices set to <code>-100</code> are ignored (masked), the
loss is only computed for the tokens with labels in <code>[0, ..., config.vocab_size]</code>`,name:"labels"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/funnel/modeling_funnel.py#L1210",returnDescription:`
<p>A <a
  href="/docs/transformers/main/en/main_classes/output#transformers.modeling_outputs.MaskedLMOutput"
>transformers.modeling_outputs.MaskedLMOutput</a> 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/main/en/model_doc/funnel#transformers.FunnelConfig"
>FunnelConfig</a>) and inputs.</p>
<ul>
<li>
<p><strong>loss</strong> (<code>torch.FloatTensor</code> of shape <code>(1,)</code>, <em>optional</em>, returned when <code>labels</code> is provided) \u2014 Masked language modeling (MLM) loss.</p>
</li>
<li>
<p><strong>logits</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, config.vocab_size)</code>) \u2014 Prediction scores of the language modeling head (scores for each vocabulary token before SoftMax).</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>Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
heads.</p>
</li>
</ul>
`,returnType:`
<p><a
  href="/docs/transformers/main/en/main_classes/output#transformers.modeling_outputs.MaskedLMOutput"
>transformers.modeling_outputs.MaskedLMOutput</a> or <code>tuple(torch.FloatTensor)</code></p>
`}}),ko=new Ve({props:{$$slots:{default:[A$]},$$scope:{ctx:x}}}),To=new Ye({props:{anchor:"transformers.FunnelForMaskedLM.forward.example",$$slots:{default:[O$]},$$scope:{ctx:x}}}),$r=new Xe({}),Er=new se({props:{name:"class transformers.FunnelForSequenceClassification",anchor:"transformers.FunnelForSequenceClassification",parameters:[{name:"config",val:": FunnelConfig"}],parametersDescription:[{anchor:"transformers.FunnelForSequenceClassification.config",description:`<strong>config</strong> (<a href="/docs/transformers/main/en/model_doc/funnel#transformers.FunnelConfig">FunnelConfig</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/funnel/modeling_funnel.py#L1273"}}),Cr=new se({props:{name:"forward",anchor:"transformers.FunnelForSequenceClassification.forward",parameters:[{name:"input_ids",val:": typing.Optional[torch.Tensor] = None"},{name:"attention_mask",val:": typing.Optional[torch.Tensor] = None"},{name:"token_type_ids",val:": typing.Optional[torch.Tensor] = None"},{name:"inputs_embeds",val:": typing.Optional[torch.Tensor] = None"},{name:"labels",val:": typing.Optional[torch.Tensor] = 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.FunnelForSequenceClassification.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.</p>
<p>Indices can be obtained using <a href="/docs/transformers/main/en/model_doc/bert#transformers.BertTokenizer">BertTokenizer</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.FunnelForSequenceClassification.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><a href="../glossary#attention-mask">What are attention masks?</a>`,name:"attention_mask"},{anchor:"transformers.FunnelForSequenceClassification.forward.token_type_ids",description:`<strong>token_type_ids</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size, sequence_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.FunnelForSequenceClassification.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.`,name:"inputs_embeds"},{anchor:"transformers.FunnelForSequenceClassification.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.FunnelForSequenceClassification.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.FunnelForSequenceClassification.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.FunnelForSequenceClassification.forward.labels",description:`<strong>labels</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size,)</code>, <em>optional</em>) &#x2014;
Labels for computing the sequence classification/regression loss. Indices should be in <code>[0, ..., config.num_labels - 1]</code>. If <code>config.num_labels == 1</code> a regression loss is computed (Mean-Square loss), If
<code>config.num_labels &gt; 1</code> a classification loss is computed (Cross-Entropy).`,name:"labels"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/funnel/modeling_funnel.py#L1284",returnDescription:`
<p>A <a
  href="/docs/transformers/main/en/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput"
>transformers.modeling_outputs.SequenceClassifierOutput</a> 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/main/en/model_doc/funnel#transformers.FunnelConfig"
>FunnelConfig</a>) and inputs.</p>
<ul>
<li>
<p><strong>loss</strong> (<code>torch.FloatTensor</code> of shape <code>(1,)</code>, <em>optional</em>, returned when <code>labels</code> is provided) \u2014 Classification (or regression if config.num_labels==1) loss.</p>
</li>
<li>
<p><strong>logits</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, config.num_labels)</code>) \u2014 Classification (or regression if config.num_labels==1) scores (before SoftMax).</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>Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
heads.</p>
</li>
</ul>
`,returnType:`
<p><a
  href="/docs/transformers/main/en/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput"
>transformers.modeling_outputs.SequenceClassifierOutput</a> or <code>tuple(torch.FloatTensor)</code></p>
`}}),bo=new Ve({props:{$$slots:{default:[L$]},$$scope:{ctx:x}}}),wo=new Ye({props:{anchor:"transformers.FunnelForSequenceClassification.forward.example",$$slots:{default:[D$]},$$scope:{ctx:x}}}),Fo=new Ye({props:{anchor:"transformers.FunnelForSequenceClassification.forward.example-2",$$slots:{default:[N$]},$$scope:{ctx:x}}}),jr=new Xe({}),Ar=new se({props:{name:"class transformers.FunnelForMultipleChoice",anchor:"transformers.FunnelForMultipleChoice",parameters:[{name:"config",val:": FunnelConfig"}],parametersDescription:[{anchor:"transformers.FunnelForMultipleChoice.config",description:`<strong>config</strong> (<a href="/docs/transformers/main/en/model_doc/funnel#transformers.FunnelConfig">FunnelConfig</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/funnel/modeling_funnel.py#L1365"}}),Sr=new se({props:{name:"forward",anchor:"transformers.FunnelForMultipleChoice.forward",parameters:[{name:"input_ids",val:": typing.Optional[torch.Tensor] = None"},{name:"attention_mask",val:": typing.Optional[torch.Tensor] = None"},{name:"token_type_ids",val:": typing.Optional[torch.Tensor] = None"},{name:"inputs_embeds",val:": typing.Optional[torch.Tensor] = None"},{name:"labels",val:": typing.Optional[torch.Tensor] = 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.FunnelForMultipleChoice.forward.input_ids",description:`<strong>input_ids</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size, num_choices, sequence_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/bert#transformers.BertTokenizer">BertTokenizer</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.FunnelForMultipleChoice.forward.attention_mask",description:`<strong>attention_mask</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, num_choices, 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.FunnelForMultipleChoice.forward.token_type_ids",description:`<strong>token_type_ids</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size, num_choices, sequence_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.FunnelForMultipleChoice.forward.inputs_embeds",description:`<strong>inputs_embeds</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, num_choices, 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.`,name:"inputs_embeds"},{anchor:"transformers.FunnelForMultipleChoice.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.FunnelForMultipleChoice.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.FunnelForMultipleChoice.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.FunnelForMultipleChoice.forward.labels",description:`<strong>labels</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size,)</code>, <em>optional</em>) &#x2014;
Labels for computing the multiple choice classification loss. Indices should be in <code>[0, ..., num_choices-1]</code> where <code>num_choices</code> is the size of the second dimension of the input tensors. (See
<code>input_ids</code> above)`,name:"labels"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/funnel/modeling_funnel.py#L1374",returnDescription:`
<p>A <a
  href="/docs/transformers/main/en/main_classes/output#transformers.modeling_outputs.MultipleChoiceModelOutput"
>transformers.modeling_outputs.MultipleChoiceModelOutput</a> 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/main/en/model_doc/funnel#transformers.FunnelConfig"
>FunnelConfig</a>) and inputs.</p>
<ul>
<li>
<p><strong>loss</strong> (<code>torch.FloatTensor</code> of shape <em>(1,)</em>, <em>optional</em>, returned when <code>labels</code> is provided) \u2014 Classification loss.</p>
</li>
<li>
<p><strong>logits</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, num_choices)</code>) \u2014 <em>num_choices</em> is the second dimension of the input tensors. (see <em>input_ids</em> above).</p>
<p>Classification scores (before SoftMax).</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>Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
heads.</p>
</li>
</ul>
`,returnType:`
<p><a
  href="/docs/transformers/main/en/main_classes/output#transformers.modeling_outputs.MultipleChoiceModelOutput"
>transformers.modeling_outputs.MultipleChoiceModelOutput</a> or <code>tuple(torch.FloatTensor)</code></p>
`}}),$o=new Ve({props:{$$slots:{default:[I$]},$$scope:{ctx:x}}}),Eo=new Ye({props:{anchor:"transformers.FunnelForMultipleChoice.forward.example",$$slots:{default:[S$]},$$scope:{ctx:x}}}),Br=new Xe({}),Wr=new se({props:{name:"class transformers.FunnelForTokenClassification",anchor:"transformers.FunnelForTokenClassification",parameters:[{name:"config",val:": FunnelConfig"}],parametersDescription:[{anchor:"transformers.FunnelForTokenClassification.config",description:`<strong>config</strong> (<a href="/docs/transformers/main/en/model_doc/funnel#transformers.FunnelConfig">FunnelConfig</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/funnel/modeling_funnel.py#L1448"}}),Vr=new se({props:{name:"forward",anchor:"transformers.FunnelForTokenClassification.forward",parameters:[{name:"input_ids",val:": typing.Optional[torch.Tensor] = None"},{name:"attention_mask",val:": typing.Optional[torch.Tensor] = None"},{name:"token_type_ids",val:": typing.Optional[torch.Tensor] = None"},{name:"inputs_embeds",val:": typing.Optional[torch.Tensor] = None"},{name:"labels",val:": typing.Optional[torch.Tensor] = 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.FunnelForTokenClassification.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.</p>
<p>Indices can be obtained using <a href="/docs/transformers/main/en/model_doc/bert#transformers.BertTokenizer">BertTokenizer</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.FunnelForTokenClassification.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><a href="../glossary#attention-mask">What are attention masks?</a>`,name:"attention_mask"},{anchor:"transformers.FunnelForTokenClassification.forward.token_type_ids",description:`<strong>token_type_ids</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size, sequence_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.FunnelForTokenClassification.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.`,name:"inputs_embeds"},{anchor:"transformers.FunnelForTokenClassification.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.FunnelForTokenClassification.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.FunnelForTokenClassification.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.FunnelForTokenClassification.forward.labels",description:`<strong>labels</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size, sequence_length)</code>, <em>optional</em>) &#x2014;
Labels for computing the token classification loss. Indices should be in <code>[0, ..., config.num_labels - 1]</code>.`,name:"labels"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/funnel/modeling_funnel.py#L1460",returnDescription:`
<p>A <a
  href="/docs/transformers/main/en/main_classes/output#transformers.modeling_outputs.TokenClassifierOutput"
>transformers.modeling_outputs.TokenClassifierOutput</a> 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/main/en/model_doc/funnel#transformers.FunnelConfig"
>FunnelConfig</a>) and inputs.</p>
<ul>
<li>
<p><strong>loss</strong> (<code>torch.FloatTensor</code> of shape <code>(1,)</code>, <em>optional</em>, returned when <code>labels</code> is provided)  \u2014 Classification loss.</p>
</li>
<li>
<p><strong>logits</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, config.num_labels)</code>) \u2014 Classification scores (before SoftMax).</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>Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
heads.</p>
</li>
</ul>
`,returnType:`
<p><a
  href="/docs/transformers/main/en/main_classes/output#transformers.modeling_outputs.TokenClassifierOutput"
>transformers.modeling_outputs.TokenClassifierOutput</a> or <code>tuple(torch.FloatTensor)</code></p>
`}}),zo=new Ve({props:{$$slots:{default:[B$]},$$scope:{ctx:x}}}),qo=new Ye({props:{anchor:"transformers.FunnelForTokenClassification.forward.example",$$slots:{default:[W$]},$$scope:{ctx:x}}}),Yr=new Xe({}),Gr=new se({props:{name:"class transformers.FunnelForQuestionAnswering",anchor:"transformers.FunnelForQuestionAnswering",parameters:[{name:"config",val:": FunnelConfig"}],parametersDescription:[{anchor:"transformers.FunnelForQuestionAnswering.config",description:`<strong>config</strong> (<a href="/docs/transformers/main/en/model_doc/funnel#transformers.FunnelConfig">FunnelConfig</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/funnel/modeling_funnel.py#L1521"}}),ta=new se({props:{name:"forward",anchor:"transformers.FunnelForQuestionAnswering.forward",parameters:[{name:"input_ids",val:": typing.Optional[torch.Tensor] = None"},{name:"attention_mask",val:": typing.Optional[torch.Tensor] = None"},{name:"token_type_ids",val:": typing.Optional[torch.Tensor] = None"},{name:"inputs_embeds",val:": typing.Optional[torch.Tensor] = None"},{name:"start_positions",val:": typing.Optional[torch.Tensor] = None"},{name:"end_positions",val:": typing.Optional[torch.Tensor] = 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.FunnelForQuestionAnswering.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.</p>
<p>Indices can be obtained using <a href="/docs/transformers/main/en/model_doc/bert#transformers.BertTokenizer">BertTokenizer</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.FunnelForQuestionAnswering.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><a href="../glossary#attention-mask">What are attention masks?</a>`,name:"attention_mask"},{anchor:"transformers.FunnelForQuestionAnswering.forward.token_type_ids",description:`<strong>token_type_ids</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size, sequence_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.FunnelForQuestionAnswering.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.`,name:"inputs_embeds"},{anchor:"transformers.FunnelForQuestionAnswering.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.FunnelForQuestionAnswering.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.FunnelForQuestionAnswering.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.FunnelForQuestionAnswering.forward.start_positions",description:`<strong>start_positions</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size,)</code>, <em>optional</em>) &#x2014;
Labels for position (index) of the start of the labelled span for computing the token classification loss.
Positions are clamped to the length of the sequence (<code>sequence_length</code>). Position outside of the sequence
are not taken into account for computing the loss.`,name:"start_positions"},{anchor:"transformers.FunnelForQuestionAnswering.forward.end_positions",description:`<strong>end_positions</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size,)</code>, <em>optional</em>) &#x2014;
Labels for position (index) of the end of the labelled span for computing the token classification loss.
Positions are clamped to the length of the sequence (<code>sequence_length</code>). Position outside of the sequence
are not taken into account for computing the loss.`,name:"end_positions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/funnel/modeling_funnel.py#L1532",returnDescription:`
<p>A <a
  href="/docs/transformers/main/en/main_classes/output#transformers.modeling_outputs.QuestionAnsweringModelOutput"
>transformers.modeling_outputs.QuestionAnsweringModelOutput</a> 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/main/en/model_doc/funnel#transformers.FunnelConfig"
>FunnelConfig</a>) and inputs.</p>
<ul>
<li>
<p><strong>loss</strong> (<code>torch.FloatTensor</code> of shape <code>(1,)</code>, <em>optional</em>, returned when <code>labels</code> is provided) \u2014 Total span extraction loss is the sum of a Cross-Entropy for the start and end positions.</p>
</li>
<li>
<p><strong>start_logits</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length)</code>) \u2014 Span-start scores (before SoftMax).</p>
</li>
<li>
<p><strong>end_logits</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length)</code>) \u2014 Span-end scores (before SoftMax).</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>Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
heads.</p>
</li>
</ul>
`,returnType:`
<p><a
  href="/docs/transformers/main/en/main_classes/output#transformers.modeling_outputs.QuestionAnsweringModelOutput"
>transformers.modeling_outputs.QuestionAnsweringModelOutput</a> or <code>tuple(torch.FloatTensor)</code></p>
`}}),xo=new Ve({props:{$$slots:{default:[Q$]},$$scope:{ctx:x}}}),Co=new Ye({props:{anchor:"transformers.FunnelForQuestionAnswering.forward.example",$$slots:{default:[U$]},$$scope:{ctx:x}}}),oa=new Xe({}),sa=new se({props:{name:"class transformers.TFFunnelBaseModel",anchor:"transformers.TFFunnelBaseModel",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"transformers.TFFunnelBaseModel.config",description:`<strong>config</strong> (<code>XxxConfig</code>) &#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/funnel/modeling_tf_funnel.py#L1109"}}),Ao=new Ve({props:{$$slots:{default:[K$]},$$scope:{ctx:x}}}),ca=new se({props:{name:"call",anchor:"transformers.TFFunnelBaseModel.call",parameters:[{name:"input_ids",val:": typing.Union[typing.List[tensorflow.python.framework.ops.Tensor], typing.List[numpy.ndarray], typing.List[keras.engine.keras_tensor.KerasTensor], typing.Dict[str, tensorflow.python.framework.ops.Tensor], typing.Dict[str, numpy.ndarray], typing.Dict[str, keras.engine.keras_tensor.KerasTensor], tensorflow.python.framework.ops.Tensor, numpy.ndarray, keras.engine.keras_tensor.KerasTensor, NoneType] = None"},{name:"attention_mask",val:": typing.Union[numpy.ndarray, tensorflow.python.framework.ops.Tensor, NoneType] = None"},{name:"token_type_ids",val:": typing.Union[numpy.ndarray, tensorflow.python.framework.ops.Tensor, NoneType] = None"},{name:"inputs_embeds",val:": typing.Union[numpy.ndarray, tensorflow.python.framework.ops.Tensor, NoneType] = 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:"training",val:": bool = False"}],parametersDescription:[{anchor:"transformers.TFFunnelBaseModel.call.input_ids",description:`<strong>input_ids</strong> (<code>Numpy array</code> or <code>tf.Tensor</code> of shape <code>(batch_size, sequence_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.__call__">PreTrainedTokenizer.<strong>call</strong>()</a> and
<a href="/docs/transformers/main/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode">PreTrainedTokenizer.encode()</a> for details.</p>
<p><a href="../glossary#input-ids">What are input IDs?</a>`,name:"input_ids"},{anchor:"transformers.TFFunnelBaseModel.call.attention_mask",description:`<strong>attention_mask</strong> (<code>Numpy array</code> or <code>tf.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"},{anchor:"transformers.TFFunnelBaseModel.call.token_type_ids",description:`<strong>token_type_ids</strong> (<code>Numpy array</code> or <code>tf.Tensor</code> of shape <code>(batch_size, sequence_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.TFFunnelBaseModel.call.inputs_embeds",description:`<strong>inputs_embeds</strong> (<code>tf.Tensor</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.`,name:"inputs_embeds"},{anchor:"transformers.TFFunnelBaseModel.call.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. This argument can be used only in eager mode, in graph mode the value in the
config will be used instead.`,name:"output_attentions"},{anchor:"transformers.TFFunnelBaseModel.call.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. This argument can be used only in eager mode, in graph mode the value in the config will be
used instead.`,name:"output_hidden_states"},{anchor:"transformers.TFFunnelBaseModel.call.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. This argument can be used in
eager mode, in graph mode the value will always be set to True.`,name:"return_dict"},{anchor:"transformers.TFFunnelBaseModel.call.training",description:`<strong>training</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>False</code>) &#x2014;
Whether or not to use the model in training mode (some modules like dropout modules have different
behaviors between training and evaluation).`,name:"training"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/funnel/modeling_tf_funnel.py#L1114",returnDescription:`
<p>A <a
  href="/docs/transformers/main/en/main_classes/output#transformers.modeling_tf_outputs.TFBaseModelOutput"
>transformers.modeling_tf_outputs.TFBaseModelOutput</a> or a tuple of <code>tf.Tensor</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/main/en/model_doc/funnel#transformers.FunnelConfig"
>FunnelConfig</a>) and inputs.</p>
<ul>
<li>
<p><strong>last_hidden_state</strong> (<code>tf.Tensor</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>) \u2014 Sequence of hidden-states at the output of the last layer of the model.</p>
</li>
<li>
<p><strong>hidden_states</strong> (<code>tuple(tf.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>tf.Tensor</code> (one for the output of the embeddings + 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 initial embedding outputs.</p>
</li>
<li>
<p><strong>attentions</strong> (<code>tuple(tf.Tensor)</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>tf.Tensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
heads.</p>
</li>
</ul>
`,returnType:`
<p><a
  href="/docs/transformers/main/en/main_classes/output#transformers.modeling_tf_outputs.TFBaseModelOutput"
>transformers.modeling_tf_outputs.TFBaseModelOutput</a> or <code>tuple(tf.Tensor)</code></p>
`}}),Oo=new Ve({props:{$$slots:{default:[R$]},$$scope:{ctx:x}}}),Lo=new Ye({props:{anchor:"transformers.TFFunnelBaseModel.call.example",$$slots:{default:[H$]},$$scope:{ctx:x}}}),ua=new Xe({}),pa=new se({props:{name:"class transformers.TFFunnelModel",anchor:"transformers.TFFunnelModel",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"transformers.TFFunnelModel.config",description:`<strong>config</strong> (<code>XxxConfig</code>) &#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/funnel/modeling_tf_funnel.py#L1157"}}),No=new Ve({props:{$$slots:{default:[V$]},$$scope:{ctx:x}}}),ka=new se({props:{name:"call",anchor:"transformers.TFFunnelModel.call",parameters:[{name:"input_ids",val:": typing.Union[typing.List[tensorflow.python.framework.ops.Tensor], typing.List[numpy.ndarray], typing.List[keras.engine.keras_tensor.KerasTensor], typing.Dict[str, tensorflow.python.framework.ops.Tensor], typing.Dict[str, numpy.ndarray], typing.Dict[str, keras.engine.keras_tensor.KerasTensor], tensorflow.python.framework.ops.Tensor, numpy.ndarray, keras.engine.keras_tensor.KerasTensor, NoneType] = None"},{name:"attention_mask",val:": typing.Union[numpy.ndarray, tensorflow.python.framework.ops.Tensor, NoneType] = None"},{name:"token_type_ids",val:": typing.Union[numpy.ndarray, tensorflow.python.framework.ops.Tensor, NoneType] = None"},{name:"inputs_embeds",val:": typing.Union[numpy.ndarray, tensorflow.python.framework.ops.Tensor, NoneType] = 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:"training",val:": bool = False"}],parametersDescription:[{anchor:"transformers.TFFunnelModel.call.input_ids",description:`<strong>input_ids</strong> (<code>Numpy array</code> or <code>tf.Tensor</code> of shape <code>(batch_size, sequence_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.__call__">PreTrainedTokenizer.<strong>call</strong>()</a> and
<a href="/docs/transformers/main/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode">PreTrainedTokenizer.encode()</a> for details.</p>
<p><a href="../glossary#input-ids">What are input IDs?</a>`,name:"input_ids"},{anchor:"transformers.TFFunnelModel.call.attention_mask",description:`<strong>attention_mask</strong> (<code>Numpy array</code> or <code>tf.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"},{anchor:"transformers.TFFunnelModel.call.token_type_ids",description:`<strong>token_type_ids</strong> (<code>Numpy array</code> or <code>tf.Tensor</code> of shape <code>(batch_size, sequence_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.TFFunnelModel.call.inputs_embeds",description:`<strong>inputs_embeds</strong> (<code>tf.Tensor</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.`,name:"inputs_embeds"},{anchor:"transformers.TFFunnelModel.call.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. This argument can be used only in eager mode, in graph mode the value in the
config will be used instead.`,name:"output_attentions"},{anchor:"transformers.TFFunnelModel.call.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. This argument can be used only in eager mode, in graph mode the value in the config will be
used instead.`,name:"output_hidden_states"},{anchor:"transformers.TFFunnelModel.call.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. This argument can be used in
eager mode, in graph mode the value will always be set to True.`,name:"return_dict"},{anchor:"transformers.TFFunnelModel.call.training",description:`<strong>training</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>False</code>) &#x2014;
Whether or not to use the model in training mode (some modules like dropout modules have different
behaviors between training and evaluation).`,name:"training"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/funnel/modeling_tf_funnel.py#L1162",returnDescription:`
<p>A <a
  href="/docs/transformers/main/en/main_classes/output#transformers.modeling_tf_outputs.TFBaseModelOutput"
>transformers.modeling_tf_outputs.TFBaseModelOutput</a> or a tuple of <code>tf.Tensor</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/main/en/model_doc/funnel#transformers.FunnelConfig"
>FunnelConfig</a>) and inputs.</p>
<ul>
<li>
<p><strong>last_hidden_state</strong> (<code>tf.Tensor</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>) \u2014 Sequence of hidden-states at the output of the last layer of the model.</p>
</li>
<li>
<p><strong>hidden_states</strong> (<code>tuple(tf.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>tf.Tensor</code> (one for the output of the embeddings + 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 initial embedding outputs.</p>
</li>
<li>
<p><strong>attentions</strong> (<code>tuple(tf.Tensor)</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>tf.Tensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
heads.</p>
</li>
</ul>
`,returnType:`
<p><a
  href="/docs/transformers/main/en/main_classes/output#transformers.modeling_tf_outputs.TFBaseModelOutput"
>transformers.modeling_tf_outputs.TFBaseModelOutput</a> or <code>tuple(tf.Tensor)</code></p>
`}}),Io=new Ve({props:{$$slots:{default:[Y$]},$$scope:{ctx:x}}}),So=new Ye({props:{anchor:"transformers.TFFunnelModel.call.example",$$slots:{default:[G$]},$$scope:{ctx:x}}}),Ta=new Xe({}),ya=new se({props:{name:"class transformers.TFFunnelForPreTraining",anchor:"transformers.TFFunnelForPreTraining",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"transformers.TFFunnelForPreTraining.config",description:`<strong>config</strong> (<code>XxxConfig</code>) &#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/funnel/modeling_tf_funnel.py#L1208"}}),Wo=new Ve({props:{$$slots:{default:[Z$]},$$scope:{ctx:x}}}),Ea=new se({props:{name:"call",anchor:"transformers.TFFunnelForPreTraining.call",parameters:[{name:"input_ids",val:": typing.Union[typing.List[tensorflow.python.framework.ops.Tensor], typing.List[numpy.ndarray], typing.List[keras.engine.keras_tensor.KerasTensor], typing.Dict[str, tensorflow.python.framework.ops.Tensor], typing.Dict[str, numpy.ndarray], typing.Dict[str, keras.engine.keras_tensor.KerasTensor], tensorflow.python.framework.ops.Tensor, numpy.ndarray, keras.engine.keras_tensor.KerasTensor, NoneType] = None"},{name:"attention_mask",val:": typing.Union[numpy.ndarray, tensorflow.python.framework.ops.Tensor, NoneType] = None"},{name:"token_type_ids",val:": typing.Union[numpy.ndarray, tensorflow.python.framework.ops.Tensor, NoneType] = None"},{name:"inputs_embeds",val:": typing.Union[numpy.ndarray, tensorflow.python.framework.ops.Tensor, NoneType] = 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:"training",val:": bool = False"},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"transformers.TFFunnelForPreTraining.call.input_ids",description:`<strong>input_ids</strong> (<code>Numpy array</code> or <code>tf.Tensor</code> of shape <code>(batch_size, sequence_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.__call__">PreTrainedTokenizer.<strong>call</strong>()</a> and
<a href="/docs/transformers/main/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode">PreTrainedTokenizer.encode()</a> for details.</p>
<p><a href="../glossary#input-ids">What are input IDs?</a>`,name:"input_ids"},{anchor:"transformers.TFFunnelForPreTraining.call.attention_mask",description:`<strong>attention_mask</strong> (<code>Numpy array</code> or <code>tf.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"},{anchor:"transformers.TFFunnelForPreTraining.call.token_type_ids",description:`<strong>token_type_ids</strong> (<code>Numpy array</code> or <code>tf.Tensor</code> of shape <code>(batch_size, sequence_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.TFFunnelForPreTraining.call.inputs_embeds",description:`<strong>inputs_embeds</strong> (<code>tf.Tensor</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.`,name:"inputs_embeds"},{anchor:"transformers.TFFunnelForPreTraining.call.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. This argument can be used only in eager mode, in graph mode the value in the
config will be used instead.`,name:"output_attentions"},{anchor:"transformers.TFFunnelForPreTraining.call.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. This argument can be used only in eager mode, in graph mode the value in the config will be
used instead.`,name:"output_hidden_states"},{anchor:"transformers.TFFunnelForPreTraining.call.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. This argument can be used in
eager mode, in graph mode the value will always be set to True.`,name:"return_dict"},{anchor:"transformers.TFFunnelForPreTraining.call.training",description:`<strong>training</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>False</code>) &#x2014;
Whether or not to use the model in training mode (some modules like dropout modules have different
behaviors between training and evaluation).`,name:"training"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/funnel/modeling_tf_funnel.py#L1215",returnDescription:`
<p>A <a
  href="/docs/transformers/main/en/model_doc/funnel#transformers.models.funnel.modeling_tf_funnel.TFFunnelForPreTrainingOutput"
>transformers.models.funnel.modeling_tf_funnel.TFFunnelForPreTrainingOutput</a> or a tuple of <code>tf.Tensor</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/main/en/model_doc/funnel#transformers.FunnelConfig"
>FunnelConfig</a>) and inputs.</p>
<ul>
<li>
<p><strong>logits</strong> (<code>tf.Tensor</code> of shape <code>(batch_size, sequence_length)</code>) \u2014 Prediction scores of the head (scores for each token before SoftMax).</p>
</li>
<li>
<p><strong>hidden_states</strong> (<code>tuple(tf.Tensor)</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>tf.Tensor</code> (one for the output of the embeddings + 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 initial embedding outputs.</p>
</li>
<li>
<p><strong>attentions</strong> (<code>tuple(tf.Tensor)</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>tf.Tensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
heads.</p>
</li>
</ul>
`,returnType:`
<p><a
  href="/docs/transformers/main/en/model_doc/funnel#transformers.models.funnel.modeling_tf_funnel.TFFunnelForPreTrainingOutput"
>transformers.models.funnel.modeling_tf_funnel.TFFunnelForPreTrainingOutput</a> or <code>tuple(tf.Tensor)</code></p>
`}}),Qo=new Ve({props:{$$slots:{default:[X$]},$$scope:{ctx:x}}}),Uo=new Ye({props:{anchor:"transformers.TFFunnelForPreTraining.call.example",$$slots:{default:[J$]},$$scope:{ctx:x}}}),Ma=new Xe({}),za=new se({props:{name:"class transformers.TFFunnelForMaskedLM",anchor:"transformers.TFFunnelForMaskedLM",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"transformers.TFFunnelForMaskedLM.config",description:`<strong>config</strong> (<code>XxxConfig</code>) &#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/funnel/modeling_tf_funnel.py#L1276"}}),Ro=new Ve({props:{$$slots:{default:[e1]},$$scope:{ctx:x}}}),Oa=new se({props:{name:"call",anchor:"transformers.TFFunnelForMaskedLM.call",parameters:[{name:"input_ids",val:": typing.Union[typing.List[tensorflow.python.framework.ops.Tensor], typing.List[numpy.ndarray], typing.List[keras.engine.keras_tensor.KerasTensor], typing.Dict[str, tensorflow.python.framework.ops.Tensor], typing.Dict[str, numpy.ndarray], typing.Dict[str, keras.engine.keras_tensor.KerasTensor], tensorflow.python.framework.ops.Tensor, numpy.ndarray, keras.engine.keras_tensor.KerasTensor, NoneType] = None"},{name:"attention_mask",val:": typing.Union[numpy.ndarray, tensorflow.python.framework.ops.Tensor, NoneType] = None"},{name:"token_type_ids",val:": typing.Union[numpy.ndarray, tensorflow.python.framework.ops.Tensor, NoneType] = None"},{name:"inputs_embeds",val:": typing.Union[numpy.ndarray, tensorflow.python.framework.ops.Tensor, NoneType] = 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.Union[numpy.ndarray, tensorflow.python.framework.ops.Tensor, NoneType] = None"},{name:"training",val:": bool = False"}],parametersDescription:[{anchor:"transformers.TFFunnelForMaskedLM.call.input_ids",description:`<strong>input_ids</strong> (<code>Numpy array</code> or <code>tf.Tensor</code> of shape <code>(batch_size, sequence_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.__call__">PreTrainedTokenizer.<strong>call</strong>()</a> and
<a href="/docs/transformers/main/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode">PreTrainedTokenizer.encode()</a> for details.</p>
<p><a href="../glossary#input-ids">What are input IDs?</a>`,name:"input_ids"},{anchor:"transformers.TFFunnelForMaskedLM.call.attention_mask",description:`<strong>attention_mask</strong> (<code>Numpy array</code> or <code>tf.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"},{anchor:"transformers.TFFunnelForMaskedLM.call.token_type_ids",description:`<strong>token_type_ids</strong> (<code>Numpy array</code> or <code>tf.Tensor</code> of shape <code>(batch_size, sequence_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.TFFunnelForMaskedLM.call.inputs_embeds",description:`<strong>inputs_embeds</strong> (<code>tf.Tensor</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.`,name:"inputs_embeds"},{anchor:"transformers.TFFunnelForMaskedLM.call.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. This argument can be used only in eager mode, in graph mode the value in the
config will be used instead.`,name:"output_attentions"},{anchor:"transformers.TFFunnelForMaskedLM.call.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. This argument can be used only in eager mode, in graph mode the value in the config will be
used instead.`,name:"output_hidden_states"},{anchor:"transformers.TFFunnelForMaskedLM.call.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. This argument can be used in
eager mode, in graph mode the value will always be set to True.`,name:"return_dict"},{anchor:"transformers.TFFunnelForMaskedLM.call.training",description:`<strong>training</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>False</code>) &#x2014;
Whether or not to use the model in training mode (some modules like dropout modules have different
behaviors between training and evaluation).`,name:"training"},{anchor:"transformers.TFFunnelForMaskedLM.call.labels",description:`<strong>labels</strong> (<code>tf.Tensor</code> of shape <code>(batch_size, sequence_length)</code>, <em>optional</em>) &#x2014;
Labels for computing the masked language modeling loss. Indices should be in <code>[-100, 0, ..., config.vocab_size]</code> (see <code>input_ids</code> docstring) Tokens with indices set to <code>-100</code> are ignored (masked), the
loss is only computed for the tokens with labels in <code>[0, ..., config.vocab_size]</code>`,name:"labels"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/funnel/modeling_tf_funnel.py#L1290",returnDescription:`
<p>A <a
  href="/docs/transformers/main/en/main_classes/output#transformers.modeling_tf_outputs.TFMaskedLMOutput"
>transformers.modeling_tf_outputs.TFMaskedLMOutput</a> or a tuple of <code>tf.Tensor</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/main/en/model_doc/funnel#transformers.FunnelConfig"
>FunnelConfig</a>) and inputs.</p>
<ul>
<li>
<p><strong>loss</strong> (<code>tf.Tensor</code> of shape <code>(n,)</code>, <em>optional</em>, where n is the number of non-masked labels, returned when <code>labels</code> is provided) \u2014 Masked language modeling (MLM) loss.</p>
</li>
<li>
<p><strong>logits</strong> (<code>tf.Tensor</code> of shape <code>(batch_size, sequence_length, config.vocab_size)</code>) \u2014 Prediction scores of the language modeling head (scores for each vocabulary token before SoftMax).</p>
</li>
<li>
<p><strong>hidden_states</strong> (<code>tuple(tf.Tensor)</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>tf.Tensor</code> (one for the output of the embeddings + 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 initial embedding outputs.</p>
</li>
<li>
<p><strong>attentions</strong> (<code>tuple(tf.Tensor)</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>tf.Tensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
heads.</p>
</li>
</ul>
`,returnType:`
<p><a
  href="/docs/transformers/main/en/main_classes/output#transformers.modeling_tf_outputs.TFMaskedLMOutput"
>transformers.modeling_tf_outputs.TFMaskedLMOutput</a> or <code>tuple(tf.Tensor)</code></p>
`}}),Ho=new Ve({props:{$$slots:{default:[n1]},$$scope:{ctx:x}}}),Vo=new Ye({props:{anchor:"transformers.TFFunnelForMaskedLM.call.example",$$slots:{default:[t1]},$$scope:{ctx:x}}}),Yo=new Ye({props:{anchor:"transformers.TFFunnelForMaskedLM.call.example-2",$$slots:{default:[o1]},$$scope:{ctx:x}}}),La=new Xe({}),Da=new se({props:{name:"class transformers.TFFunnelForSequenceClassification",anchor:"transformers.TFFunnelForSequenceClassification",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"transformers.TFFunnelForSequenceClassification.config",description:`<strong>config</strong> (<code>XxxConfig</code>) &#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/funnel/modeling_tf_funnel.py#L1354"}}),Zo=new Ve({props:{$$slots:{default:[s1]},$$scope:{ctx:x}}}),Qa=new se({props:{name:"call",anchor:"transformers.TFFunnelForSequenceClassification.call",parameters:[{name:"input_ids",val:": typing.Union[typing.List[tensorflow.python.framework.ops.Tensor], typing.List[numpy.ndarray], typing.List[keras.engine.keras_tensor.KerasTensor], typing.Dict[str, tensorflow.python.framework.ops.Tensor], typing.Dict[str, numpy.ndarray], typing.Dict[str, keras.engine.keras_tensor.KerasTensor], tensorflow.python.framework.ops.Tensor, numpy.ndarray, keras.engine.keras_tensor.KerasTensor, NoneType] = None"},{name:"attention_mask",val:": typing.Union[numpy.ndarray, tensorflow.python.framework.ops.Tensor, NoneType] = None"},{name:"token_type_ids",val:": typing.Union[numpy.ndarray, tensorflow.python.framework.ops.Tensor, NoneType] = None"},{name:"inputs_embeds",val:": typing.Union[numpy.ndarray, tensorflow.python.framework.ops.Tensor, NoneType] = 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.Union[numpy.ndarray, tensorflow.python.framework.ops.Tensor, NoneType] = None"},{name:"training",val:": bool = False"}],parametersDescription:[{anchor:"transformers.TFFunnelForSequenceClassification.call.input_ids",description:`<strong>input_ids</strong> (<code>Numpy array</code> or <code>tf.Tensor</code> of shape <code>(batch_size, sequence_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.__call__">PreTrainedTokenizer.<strong>call</strong>()</a> and
<a href="/docs/transformers/main/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode">PreTrainedTokenizer.encode()</a> for details.</p>
<p><a href="../glossary#input-ids">What are input IDs?</a>`,name:"input_ids"},{anchor:"transformers.TFFunnelForSequenceClassification.call.attention_mask",description:`<strong>attention_mask</strong> (<code>Numpy array</code> or <code>tf.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"},{anchor:"transformers.TFFunnelForSequenceClassification.call.token_type_ids",description:`<strong>token_type_ids</strong> (<code>Numpy array</code> or <code>tf.Tensor</code> of shape <code>(batch_size, sequence_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.TFFunnelForSequenceClassification.call.inputs_embeds",description:`<strong>inputs_embeds</strong> (<code>tf.Tensor</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.`,name:"inputs_embeds"},{anchor:"transformers.TFFunnelForSequenceClassification.call.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. This argument can be used only in eager mode, in graph mode the value in the
config will be used instead.`,name:"output_attentions"},{anchor:"transformers.TFFunnelForSequenceClassification.call.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. This argument can be used only in eager mode, in graph mode the value in the config will be
used instead.`,name:"output_hidden_states"},{anchor:"transformers.TFFunnelForSequenceClassification.call.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. This argument can be used in
eager mode, in graph mode the value will always be set to True.`,name:"return_dict"},{anchor:"transformers.TFFunnelForSequenceClassification.call.training",description:`<strong>training</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>False</code>) &#x2014;
Whether or not to use the model in training mode (some modules like dropout modules have different
behaviors between training and evaluation).`,name:"training"},{anchor:"transformers.TFFunnelForSequenceClassification.call.labels",description:`<strong>labels</strong> (<code>tf.Tensor</code> of shape <code>(batch_size,)</code>, <em>optional</em>) &#x2014;
Labels for computing the sequence classification/regression loss. Indices should be in <code>[0, ..., config.num_labels - 1]</code>. If <code>config.num_labels == 1</code> a regression loss is computed (Mean-Square loss), If
<code>config.num_labels &gt; 1</code> a classification loss is computed (Cross-Entropy).`,name:"labels"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/funnel/modeling_tf_funnel.py#L1362",returnDescription:`
<p>A <a
  href="/docs/transformers/main/en/main_classes/output#transformers.modeling_tf_outputs.TFSequenceClassifierOutput"
>transformers.modeling_tf_outputs.TFSequenceClassifierOutput</a> or a tuple of <code>tf.Tensor</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/main/en/model_doc/funnel#transformers.FunnelConfig"
>FunnelConfig</a>) and inputs.</p>
<ul>
<li>
<p><strong>loss</strong> (<code>tf.Tensor</code> of shape <code>(batch_size, )</code>, <em>optional</em>, returned when <code>labels</code> is provided) \u2014 Classification (or regression if config.num_labels==1) loss.</p>
</li>
<li>
<p><strong>logits</strong> (<code>tf.Tensor</code> of shape <code>(batch_size, config.num_labels)</code>) \u2014 Classification (or regression if config.num_labels==1) scores (before SoftMax).</p>
</li>
<li>
<p><strong>hidden_states</strong> (<code>tuple(tf.Tensor)</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>tf.Tensor</code> (one for the output of the embeddings + 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 initial embedding outputs.</p>
</li>
<li>
<p><strong>attentions</strong> (<code>tuple(tf.Tensor)</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>tf.Tensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
heads.</p>
</li>
</ul>
`,returnType:`
<p><a
  href="/docs/transformers/main/en/main_classes/output#transformers.modeling_tf_outputs.TFSequenceClassifierOutput"
>transformers.modeling_tf_outputs.TFSequenceClassifierOutput</a> or <code>tuple(tf.Tensor)</code></p>
`}}),Xo=new Ve({props:{$$slots:{default:[r1]},$$scope:{ctx:x}}}),Jo=new Ye({props:{anchor:"transformers.TFFunnelForSequenceClassification.call.example",$$slots:{default:[a1]},$$scope:{ctx:x}}}),es=new Ye({props:{anchor:"transformers.TFFunnelForSequenceClassification.call.example-2",$$slots:{default:[i1]},$$scope:{ctx:x}}}),Ua=new Xe({}),Ka=new se({props:{name:"class transformers.TFFunnelForMultipleChoice",anchor:"transformers.TFFunnelForMultipleChoice",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"transformers.TFFunnelForMultipleChoice.config",description:`<strong>config</strong> (<code>XxxConfig</code>) &#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/funnel/modeling_tf_funnel.py#L1429"}}),ts=new Ve({props:{$$slots:{default:[l1]},$$scope:{ctx:x}}}),Za=new se({props:{name:"call",anchor:"transformers.TFFunnelForMultipleChoice.call",parameters:[{name:"input_ids",val:": typing.Union[typing.List[tensorflow.python.framework.ops.Tensor], typing.List[numpy.ndarray], typing.List[keras.engine.keras_tensor.KerasTensor], typing.Dict[str, tensorflow.python.framework.ops.Tensor], typing.Dict[str, numpy.ndarray], typing.Dict[str, keras.engine.keras_tensor.KerasTensor], tensorflow.python.framework.ops.Tensor, numpy.ndarray, keras.engine.keras_tensor.KerasTensor, NoneType] = None"},{name:"attention_mask",val:": typing.Union[numpy.ndarray, tensorflow.python.framework.ops.Tensor, NoneType] = None"},{name:"token_type_ids",val:": typing.Union[numpy.ndarray, tensorflow.python.framework.ops.Tensor, NoneType] = None"},{name:"inputs_embeds",val:": typing.Union[numpy.ndarray, tensorflow.python.framework.ops.Tensor, NoneType] = 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.Union[numpy.ndarray, tensorflow.python.framework.ops.Tensor, NoneType] = None"},{name:"training",val:": bool = False"}],parametersDescription:[{anchor:"transformers.TFFunnelForMultipleChoice.call.input_ids",description:`<strong>input_ids</strong> (<code>Numpy array</code> or <code>tf.Tensor</code> of shape <code>(batch_size, num_choices, sequence_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.__call__">PreTrainedTokenizer.<strong>call</strong>()</a> and
<a href="/docs/transformers/main/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode">PreTrainedTokenizer.encode()</a> for details.</p>
<p><a href="../glossary#input-ids">What are input IDs?</a>`,name:"input_ids"},{anchor:"transformers.TFFunnelForMultipleChoice.call.attention_mask",description:`<strong>attention_mask</strong> (<code>Numpy array</code> or <code>tf.Tensor</code> of shape <code>(batch_size, num_choices, 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.TFFunnelForMultipleChoice.call.token_type_ids",description:`<strong>token_type_ids</strong> (<code>Numpy array</code> or <code>tf.Tensor</code> of shape <code>(batch_size, num_choices, sequence_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.TFFunnelForMultipleChoice.call.inputs_embeds",description:`<strong>inputs_embeds</strong> (<code>tf.Tensor</code> of shape <code>(batch_size, num_choices, 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.`,name:"inputs_embeds"},{anchor:"transformers.TFFunnelForMultipleChoice.call.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. This argument can be used only in eager mode, in graph mode the value in the
config will be used instead.`,name:"output_attentions"},{anchor:"transformers.TFFunnelForMultipleChoice.call.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. This argument can be used only in eager mode, in graph mode the value in the config will be
used instead.`,name:"output_hidden_states"},{anchor:"transformers.TFFunnelForMultipleChoice.call.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. This argument can be used in
eager mode, in graph mode the value will always be set to True.`,name:"return_dict"},{anchor:"transformers.TFFunnelForMultipleChoice.call.training",description:`<strong>training</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>False</code>) &#x2014;
Whether or not to use the model in training mode (some modules like dropout modules have different
behaviors between training and evaluation).`,name:"training"},{anchor:"transformers.TFFunnelForMultipleChoice.call.labels",description:`<strong>labels</strong> (<code>tf.Tensor</code> of shape <code>(batch_size,)</code>, <em>optional</em>) &#x2014;
Labels for computing the multiple choice classification loss. Indices should be in <code>[0, ..., num_choices]</code>
where <code>num_choices</code> is the size of the second dimension of the input tensors. (See <code>input_ids</code> above)`,name:"labels"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/funnel/modeling_tf_funnel.py#L1446",returnDescription:`
<p>A <a
  href="/docs/transformers/main/en/main_classes/output#transformers.modeling_tf_outputs.TFMultipleChoiceModelOutput"
>transformers.modeling_tf_outputs.TFMultipleChoiceModelOutput</a> or a tuple of <code>tf.Tensor</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/main/en/model_doc/funnel#transformers.FunnelConfig"
>FunnelConfig</a>) and inputs.</p>
<ul>
<li>
<p><strong>loss</strong> (<code>tf.Tensor</code> of shape <em>(batch_size, )</em>, <em>optional</em>, returned when <code>labels</code> is provided) \u2014 Classification loss.</p>
</li>
<li>
<p><strong>logits</strong> (<code>tf.Tensor</code> of shape <code>(batch_size, num_choices)</code>) \u2014 <em>num_choices</em> is the second dimension of the input tensors. (see <em>input_ids</em> above).</p>
<p>Classification scores (before SoftMax).</p>
</li>
<li>
<p><strong>hidden_states</strong> (<code>tuple(tf.Tensor)</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>tf.Tensor</code> (one for the output of the embeddings + 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 initial embedding outputs.</p>
</li>
<li>
<p><strong>attentions</strong> (<code>tuple(tf.Tensor)</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>tf.Tensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
heads.</p>
</li>
</ul>
`,returnType:`
<p><a
  href="/docs/transformers/main/en/main_classes/output#transformers.modeling_tf_outputs.TFMultipleChoiceModelOutput"
>transformers.modeling_tf_outputs.TFMultipleChoiceModelOutput</a> or <code>tuple(tf.Tensor)</code></p>
`}}),os=new Ve({props:{$$slots:{default:[d1]},$$scope:{ctx:x}}}),ss=new Ye({props:{anchor:"transformers.TFFunnelForMultipleChoice.call.example",$$slots:{default:[c1]},$$scope:{ctx:x}}}),Xa=new Xe({}),Ja=new se({props:{name:"class transformers.TFFunnelForTokenClassification",anchor:"transformers.TFFunnelForTokenClassification",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"transformers.TFFunnelForTokenClassification.config",description:`<strong>config</strong> (<code>XxxConfig</code>) &#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/funnel/modeling_tf_funnel.py#L1544"}}),as=new Ve({props:{$$slots:{default:[u1]},$$scope:{ctx:x}}}),ri=new se({props:{name:"call",anchor:"transformers.TFFunnelForTokenClassification.call",parameters:[{name:"input_ids",val:": typing.Union[typing.List[tensorflow.python.framework.ops.Tensor], typing.List[numpy.ndarray], typing.List[keras.engine.keras_tensor.KerasTensor], typing.Dict[str, tensorflow.python.framework.ops.Tensor], typing.Dict[str, numpy.ndarray], typing.Dict[str, keras.engine.keras_tensor.KerasTensor], tensorflow.python.framework.ops.Tensor, numpy.ndarray, keras.engine.keras_tensor.KerasTensor, NoneType] = None"},{name:"attention_mask",val:": typing.Union[numpy.ndarray, tensorflow.python.framework.ops.Tensor, NoneType] = None"},{name:"token_type_ids",val:": typing.Union[numpy.ndarray, tensorflow.python.framework.ops.Tensor, NoneType] = None"},{name:"inputs_embeds",val:": typing.Union[numpy.ndarray, tensorflow.python.framework.ops.Tensor, NoneType] = 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.Union[numpy.ndarray, tensorflow.python.framework.ops.Tensor, NoneType] = None"},{name:"training",val:": bool = False"}],parametersDescription:[{anchor:"transformers.TFFunnelForTokenClassification.call.input_ids",description:`<strong>input_ids</strong> (<code>Numpy array</code> or <code>tf.Tensor</code> of shape <code>(batch_size, sequence_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.__call__">PreTrainedTokenizer.<strong>call</strong>()</a> and
<a href="/docs/transformers/main/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode">PreTrainedTokenizer.encode()</a> for details.</p>
<p><a href="../glossary#input-ids">What are input IDs?</a>`,name:"input_ids"},{anchor:"transformers.TFFunnelForTokenClassification.call.attention_mask",description:`<strong>attention_mask</strong> (<code>Numpy array</code> or <code>tf.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"},{anchor:"transformers.TFFunnelForTokenClassification.call.token_type_ids",description:`<strong>token_type_ids</strong> (<code>Numpy array</code> or <code>tf.Tensor</code> of shape <code>(batch_size, sequence_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.TFFunnelForTokenClassification.call.inputs_embeds",description:`<strong>inputs_embeds</strong> (<code>tf.Tensor</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.`,name:"inputs_embeds"},{anchor:"transformers.TFFunnelForTokenClassification.call.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. This argument can be used only in eager mode, in graph mode the value in the
config will be used instead.`,name:"output_attentions"},{anchor:"transformers.TFFunnelForTokenClassification.call.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. This argument can be used only in eager mode, in graph mode the value in the config will be
used instead.`,name:"output_hidden_states"},{anchor:"transformers.TFFunnelForTokenClassification.call.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. This argument can be used in
eager mode, in graph mode the value will always be set to True.`,name:"return_dict"},{anchor:"transformers.TFFunnelForTokenClassification.call.training",description:`<strong>training</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>False</code>) &#x2014;
Whether or not to use the model in training mode (some modules like dropout modules have different
behaviors between training and evaluation).`,name:"training"},{anchor:"transformers.TFFunnelForTokenClassification.call.labels",description:`<strong>labels</strong> (<code>tf.Tensor</code> of shape <code>(batch_size, sequence_length)</code>, <em>optional</em>) &#x2014;
Labels for computing the token classification loss. Indices should be in <code>[0, ..., config.num_labels - 1]</code>.`,name:"labels"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/funnel/modeling_tf_funnel.py#L1555",returnDescription:`
<p>A <a
  href="/docs/transformers/main/en/main_classes/output#transformers.modeling_tf_outputs.TFTokenClassifierOutput"
>transformers.modeling_tf_outputs.TFTokenClassifierOutput</a> or a tuple of <code>tf.Tensor</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/main/en/model_doc/funnel#transformers.FunnelConfig"
>FunnelConfig</a>) and inputs.</p>
<ul>
<li>
<p><strong>loss</strong> (<code>tf.Tensor</code> of shape <code>(n,)</code>, <em>optional</em>, where n is the number of unmasked labels, returned when <code>labels</code> is provided)  \u2014 Classification loss.</p>
</li>
<li>
<p><strong>logits</strong> (<code>tf.Tensor</code> of shape <code>(batch_size, sequence_length, config.num_labels)</code>) \u2014 Classification scores (before SoftMax).</p>
</li>
<li>
<p><strong>hidden_states</strong> (<code>tuple(tf.Tensor)</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>tf.Tensor</code> (one for the output of the embeddings + 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 initial embedding outputs.</p>
</li>
<li>
<p><strong>attentions</strong> (<code>tuple(tf.Tensor)</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>tf.Tensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
heads.</p>
</li>
</ul>
`,returnType:`
<p><a
  href="/docs/transformers/main/en/main_classes/output#transformers.modeling_tf_outputs.TFTokenClassifierOutput"
>transformers.modeling_tf_outputs.TFTokenClassifierOutput</a> or <code>tuple(tf.Tensor)</code></p>
`}}),is=new Ve({props:{$$slots:{default:[p1]},$$scope:{ctx:x}}}),ls=new Ye({props:{anchor:"transformers.TFFunnelForTokenClassification.call.example",$$slots:{default:[h1]},$$scope:{ctx:x}}}),ds=new Ye({props:{anchor:"transformers.TFFunnelForTokenClassification.call.example-2",$$slots:{default:[f1]},$$scope:{ctx:x}}}),ai=new Xe({}),ii=new se({props:{name:"class transformers.TFFunnelForQuestionAnswering",anchor:"transformers.TFFunnelForQuestionAnswering",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"transformers.TFFunnelForQuestionAnswering.config",description:`<strong>config</strong> (<code>XxxConfig</code>) &#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/funnel/modeling_tf_funnel.py#L1621"}}),us=new Ve({props:{$$slots:{default:[m1]},$$scope:{ctx:x}}}),hi=new se({props:{name:"call",anchor:"transformers.TFFunnelForQuestionAnswering.call",parameters:[{name:"input_ids",val:": typing.Union[typing.List[tensorflow.python.framework.ops.Tensor], typing.List[numpy.ndarray], typing.List[keras.engine.keras_tensor.KerasTensor], typing.Dict[str, tensorflow.python.framework.ops.Tensor], typing.Dict[str, numpy.ndarray], typing.Dict[str, keras.engine.keras_tensor.KerasTensor], tensorflow.python.framework.ops.Tensor, numpy.ndarray, keras.engine.keras_tensor.KerasTensor, NoneType] = None"},{name:"attention_mask",val:": typing.Union[numpy.ndarray, tensorflow.python.framework.ops.Tensor, NoneType] = None"},{name:"token_type_ids",val:": typing.Union[numpy.ndarray, tensorflow.python.framework.ops.Tensor, NoneType] = None"},{name:"inputs_embeds",val:": typing.Union[numpy.ndarray, tensorflow.python.framework.ops.Tensor, NoneType] = 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:"start_positions",val:": typing.Union[numpy.ndarray, tensorflow.python.framework.ops.Tensor, NoneType] = None"},{name:"end_positions",val:": typing.Union[numpy.ndarray, tensorflow.python.framework.ops.Tensor, NoneType] = None"},{name:"training",val:": bool = False"}],parametersDescription:[{anchor:"transformers.TFFunnelForQuestionAnswering.call.input_ids",description:`<strong>input_ids</strong> (<code>Numpy array</code> or <code>tf.Tensor</code> of shape <code>(batch_size, sequence_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.__call__">PreTrainedTokenizer.<strong>call</strong>()</a> and
<a href="/docs/transformers/main/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode">PreTrainedTokenizer.encode()</a> for details.</p>
<p><a href="../glossary#input-ids">What are input IDs?</a>`,name:"input_ids"},{anchor:"transformers.TFFunnelForQuestionAnswering.call.attention_mask",description:`<strong>attention_mask</strong> (<code>Numpy array</code> or <code>tf.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"},{anchor:"transformers.TFFunnelForQuestionAnswering.call.token_type_ids",description:`<strong>token_type_ids</strong> (<code>Numpy array</code> or <code>tf.Tensor</code> of shape <code>(batch_size, sequence_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.TFFunnelForQuestionAnswering.call.inputs_embeds",description:`<strong>inputs_embeds</strong> (<code>tf.Tensor</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.`,name:"inputs_embeds"},{anchor:"transformers.TFFunnelForQuestionAnswering.call.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. This argument can be used only in eager mode, in graph mode the value in the
config will be used instead.`,name:"output_attentions"},{anchor:"transformers.TFFunnelForQuestionAnswering.call.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. This argument can be used only in eager mode, in graph mode the value in the config will be
used instead.`,name:"output_hidden_states"},{anchor:"transformers.TFFunnelForQuestionAnswering.call.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. This argument can be used in
eager mode, in graph mode the value will always be set to True.`,name:"return_dict"},{anchor:"transformers.TFFunnelForQuestionAnswering.call.training",description:`<strong>training</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>False</code>) &#x2014;
Whether or not to use the model in training mode (some modules like dropout modules have different
behaviors between training and evaluation).`,name:"training"},{anchor:"transformers.TFFunnelForQuestionAnswering.call.start_positions",description:`<strong>start_positions</strong> (<code>tf.Tensor</code> of shape <code>(batch_size,)</code>, <em>optional</em>) &#x2014;
Labels for position (index) of the start of the labelled span for computing the token classification loss.
Positions are clamped to the length of the sequence (<code>sequence_length</code>). Position outside of the sequence
are not taken into account for computing the loss.`,name:"start_positions"},{anchor:"transformers.TFFunnelForQuestionAnswering.call.end_positions",description:`<strong>end_positions</strong> (<code>tf.Tensor</code> of shape <code>(batch_size,)</code>, <em>optional</em>) &#x2014;
Labels for position (index) of the end of the labelled span for computing the token classification loss.
Positions are clamped to the length of the sequence (<code>sequence_length</code>). Position outside of the sequence
are not taken into account for computing the loss.`,name:"end_positions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/funnel/modeling_tf_funnel.py#L1631",returnDescription:`
<p>A <a
  href="/docs/transformers/main/en/main_classes/output#transformers.modeling_tf_outputs.TFQuestionAnsweringModelOutput"
>transformers.modeling_tf_outputs.TFQuestionAnsweringModelOutput</a> or a tuple of <code>tf.Tensor</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/main/en/model_doc/funnel#transformers.FunnelConfig"
>FunnelConfig</a>) and inputs.</p>
<ul>
<li>
<p><strong>loss</strong> (<code>tf.Tensor</code> of shape <code>(batch_size, )</code>, <em>optional</em>, returned when <code>start_positions</code> and <code>end_positions</code> are provided) \u2014 Total span extraction loss is the sum of a Cross-Entropy for the start and end positions.</p>
</li>
<li>
<p><strong>start_logits</strong> (<code>tf.Tensor</code> of shape <code>(batch_size, sequence_length)</code>) \u2014 Span-start scores (before SoftMax).</p>
</li>
<li>
<p><strong>end_logits</strong> (<code>tf.Tensor</code> of shape <code>(batch_size, sequence_length)</code>) \u2014 Span-end scores (before SoftMax).</p>
</li>
<li>
<p><strong>hidden_states</strong> (<code>tuple(tf.Tensor)</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>tf.Tensor</code> (one for the output of the embeddings + 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 initial embedding outputs.</p>
</li>
<li>
<p><strong>attentions</strong> (<code>tuple(tf.Tensor)</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>tf.Tensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
heads.</p>
</li>
</ul>
`,returnType:`
<p><a
  href="/docs/transformers/main/en/main_classes/output#transformers.modeling_tf_outputs.TFQuestionAnsweringModelOutput"
>transformers.modeling_tf_outputs.TFQuestionAnsweringModelOutput</a> or <code>tuple(tf.Tensor)</code></p>
`}}),ps=new Ve({props:{$$slots:{default:[g1]},$$scope:{ctx:x}}}),hs=new Ye({props:{anchor:"transformers.TFFunnelForQuestionAnswering.call.example",$$slots:{default:[_1]},$$scope:{ctx:x}}}),fs=new Ye({props:{anchor:"transformers.TFFunnelForQuestionAnswering.call.example-2",$$slots:{default:[k1]},$$scope:{ctx:x}}}),{c(){d=s("meta"),k=u(),h=s("h1"),f=s("a"),T=s("span"),w(l.$$.fragment),c=u(),P=s("span"),ke=t("Funnel Transformer"),he=u(),I=s("h2"),re=s("a"),ee=s("span"),w(b.$$.fragment),Te=u(),K=s("span"),ye=t("Overview"),fe=u(),B=s("p"),be=t("The Funnel Transformer model was proposed in the paper "),ae=s("a"),H=t(`Funnel-Transformer: Filtering out Sequential Redundancy for
Efficient Language Processing`),we=t(`. It is a bidirectional transformer model, like
BERT, but with a pooling operation after each block of layers, a bit like in traditional convolutional neural networks
(CNN) in computer vision.`),me=u(),Q=s("p"),Fe=t("The abstract from the paper is the following:"),ge=u(),U=s("p"),ue=s("em"),ve=t(`With the success of language pretraining, it is highly desirable to develop more efficient architectures of good
scalability that can exploit the abundant unlabeled data at a lower cost. To improve the efficiency, we examine the
much-overlooked redundancy in maintaining a full-length token-level presentation, especially for tasks that only
require a single-vector presentation of the sequence. With this intuition, we propose Funnel-Transformer which
gradually compresses the sequence of hidden states to a shorter one and hence reduces the computation cost. More
importantly, by re-investing the saved FLOPs from length reduction in constructing a deeper or wider model, we further
improve the model capacity. In addition, to perform token-level predictions as required by common pretraining
objectives, Funnel-Transformer is able to recover a deep representation for each token from the reduced hidden sequence
via a decoder. Empirically, with comparable or fewer FLOPs, Funnel-Transformer outperforms the standard Transformer on
a wide variety of sequence-level prediction tasks, including text classification, language understanding, and reading
comprehension.`),oe=u(),C=s("p"),A=t("Tips:"),_e=u(),W=s("ul"),pe=s("li"),$e=t(`Since Funnel Transformer uses pooling, the sequence length of the hidden states changes after each block of layers.
The base model therefore has a final sequence length that is a quarter of the original one. This model can be used
directly for tasks that just require a sentence summary (like sequence classification or multiple choice). For other
tasks, the full model is used; this full model has a decoder that upsamples the final hidden states to the same
sequence length as the input.`),V=u(),R=s("li"),Ee=t(`The Funnel Transformer checkpoints are all available with a full version and a base version. The first ones should be
used for `),j=s("a"),Me=t("FunnelModel"),Y=t(", "),le=s("a"),ze=t("FunnelForPreTraining"),G=t(`,
`),de=s("a"),qe=t("FunnelForMaskedLM"),N=t(", "),ce=s("a"),Z=t("FunnelForTokenClassification"),Pe=t(` and
class:`),ne=s("em"),O=t("~transformers.FunnelForQuestionAnswering"),xe=t(`. The second ones should be used for
`),L=s("a"),Ce=t("FunnelBaseModel"),je=t(", "),g=s("a"),z=t("FunnelForSequenceClassification"),Ie=t(` and
`),J=s("a"),Se=t("FunnelForMultipleChoice"),Be=t("."),q=u(),Ae=s("p"),We=t("This model was contributed by "),Le=s("a"),Qe=t("sgugger"),Ue=t(". The original code can be found "),D=s("a"),X=t("here"),Ke=t("."),Ne=u(),S=s("h2"),Oe=s("a"),De=s("span"),w(ie.$$.fragment),Re=u(),te=s("span"),He=t("FunnelConfig"),Kc=u(),Xn=s("div"),w(zs.$$.fragment),eh=u(),Jn=s("p"),nh=t("This is the configuration class to store the configuration of a "),bi=s("a"),th=t("FunnelModel"),oh=t(" or a "),wi=s("a"),sh=t("TFBertModel"),rh=t(`. It is used to
instantiate a Funnel Transformer 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 Funnel
Transformer `),qs=s("a"),ah=t("funnel-transformer/small"),ih=t(" architecture."),lh=u(),dt=s("p"),dh=t("Configuration objects inherit from "),Fi=s("a"),ch=t("PretrainedConfig"),uh=t(` and can be used to control the model outputs. Read the
documentation from `),vi=s("a"),ph=t("PretrainedConfig"),hh=t(" for more information."),Rc=u(),ct=s("h2"),no=s("a"),jl=s("span"),w(Ps.$$.fragment),fh=u(),Al=s("span"),mh=t("FunnelTokenizer"),Hc=u(),en=s("div"),w(xs.$$.fragment),gh=u(),Ol=s("p"),_h=t("Construct a Funnel Transformer tokenizer. Based on WordPiece."),kh=u(),Cs=s("p"),Th=t("This tokenizer inherits from "),$i=s("a"),yh=t("PreTrainedTokenizer"),bh=t(` which contains most of the main methods. Users should refer to
this superclass for more information regarding those methods.`),wh=u(),nt=s("div"),w(js.$$.fragment),Fh=u(),Ll=s("p"),vh=t(`Build model inputs from a sequence or a pair of sequence for sequence classification tasks by concatenating and
adding special tokens. A BERT sequence has the following format:`),$h=u(),As=s("ul"),Ei=s("li"),Eh=t("single sequence: "),Dl=s("code"),Mh=t("[CLS] X [SEP]"),zh=u(),Mi=s("li"),qh=t("pair of sequences: "),Nl=s("code"),Ph=t("[CLS] A [SEP] B [SEP]"),xh=u(),to=s("div"),w(Os.$$.fragment),Ch=u(),Ls=s("p"),jh=t(`Retrieve sequence ids from a token list that has no special tokens added. This method is called when adding
special tokens using the tokenizer `),Il=s("code"),Ah=t("prepare_for_model"),Oh=t(" method."),Lh=u(),Cn=s("div"),w(Ds.$$.fragment),Dh=u(),Sl=s("p"),Nh=t("Create a mask from the two sequences passed to be used in a sequence-pair classification task. A Funnel"),Ih=u(),w(oo.$$.fragment),Sh=u(),ut=s("p"),Bh=t("If "),Bl=s("code"),Wh=t("token_ids_1"),Qh=t(" is "),Wl=s("code"),Uh=t("None"),Kh=t(", this method only returns the first portion of the mask (0s)."),Rh=u(),zi=s("div"),w(Ns.$$.fragment),Vc=u(),pt=s("h2"),so=s("a"),Ql=s("span"),w(Is.$$.fragment),Hh=u(),Ul=s("span"),Vh=t("FunnelTokenizerFast"),Yc=u(),kn=s("div"),w(Ss.$$.fragment),Yh=u(),Bs=s("p"),Gh=t("Construct a \u201Cfast\u201D Funnel Transformer tokenizer (backed by HuggingFace\u2019s "),Kl=s("em"),Zh=t("tokenizers"),Xh=t(" library). Based on WordPiece."),Jh=u(),Ws=s("p"),ef=t("This tokenizer inherits from "),qi=s("a"),nf=t("PreTrainedTokenizerFast"),tf=t(` which contains most of the main methods. Users should
refer to this superclass for more information regarding those methods.`),of=u(),tt=s("div"),w(Qs.$$.fragment),sf=u(),Rl=s("p"),rf=t(`Build model inputs from a sequence or a pair of sequence for sequence classification tasks by concatenating and
adding special tokens. A Funnel sequence has the following format:`),af=u(),Us=s("ul"),Pi=s("li"),lf=t("single sequence: "),Hl=s("code"),df=t("[CLS] X [SEP]"),cf=u(),xi=s("li"),uf=t("pair of sequences: "),Vl=s("code"),pf=t("[CLS] A [SEP] B [SEP]"),hf=u(),jn=s("div"),w(Ks.$$.fragment),ff=u(),Yl=s("p"),mf=t("Create a mask from the two sequences passed to be used in a sequence-pair classification task. A Funnel"),gf=u(),w(ro.$$.fragment),_f=u(),ht=s("p"),kf=t("If "),Gl=s("code"),Tf=t("token_ids_1"),yf=t(" is "),Zl=s("code"),bf=t("None"),wf=t(", this method only returns the first portion of the mask (0s)."),Gc=u(),ft=s("h2"),ao=s("a"),Xl=s("span"),w(Rs.$$.fragment),Ff=u(),Jl=s("span"),vf=t("Funnel specific outputs"),Zc=u(),mt=s("div"),w(Hs.$$.fragment),$f=u(),Vs=s("p"),Ef=t("Output type of "),Ci=s("a"),Mf=t("FunnelForPreTraining"),zf=t("."),Xc=u(),gt=s("div"),w(Ys.$$.fragment),qf=u(),Gs=s("p"),Pf=t("Output type of "),ji=s("a"),xf=t("FunnelForPreTraining"),Cf=t("."),Jc=u(),_t=s("h2"),io=s("a"),ed=s("span"),w(Zs.$$.fragment),jf=u(),nd=s("span"),Af=t("FunnelBaseModel"),eu=u(),cn=s("div"),w(Xs.$$.fragment),Of=u(),td=s("p"),Lf=t(`The base Funnel Transformer Model transformer outputting raw hidden-states without upsampling head (also called
decoder) or any task-specific head on top.`),Df=u(),Js=s("p"),Nf=t("The Funnel Transformer model was proposed in "),er=s("a"),If=t(`Funnel-Transformer: Filtering out Sequential Redundancy for Efficient
Language Processing`),Sf=t(" by Zihang Dai, Guokun Lai, Yiming Yang, Quoc V. Le."),Bf=u(),nr=s("p"),Wf=t("This model inherits from "),Ai=s("a"),Qf=t("PreTrainedModel"),Uf=t(`. 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.)`),Kf=u(),tr=s("p"),Rf=t("This model is also a PyTorch "),or=s("a"),Hf=t("torch.nn.Module"),Vf=t(` subclass.
Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
and behavior.`),Yf=u(),An=s("div"),w(sr.$$.fragment),Gf=u(),kt=s("p"),Zf=t("The "),Oi=s("a"),Xf=t("FunnelBaseModel"),Jf=t(" forward method, overrides the "),od=s("code"),em=t("__call__"),nm=t(" special method."),tm=u(),w(lo.$$.fragment),om=u(),w(co.$$.fragment),nu=u(),Tt=s("h2"),uo=s("a"),sd=s("span"),w(rr.$$.fragment),sm=u(),rd=s("span"),rm=t("FunnelModel"),tu=u(),un=s("div"),w(ar.$$.fragment),am=u(),ad=s("p"),im=t("The bare Funnel Transformer Model transformer outputting raw hidden-states without any specific head on top."),lm=u(),ir=s("p"),dm=t("The Funnel Transformer model was proposed in "),lr=s("a"),cm=t(`Funnel-Transformer: Filtering out Sequential Redundancy for Efficient
Language Processing`),um=t(" by Zihang Dai, Guokun Lai, Yiming Yang, Quoc V. Le."),pm=u(),dr=s("p"),hm=t("This model inherits from "),Li=s("a"),fm=t("PreTrainedModel"),mm=t(`. 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.)`),gm=u(),cr=s("p"),_m=t("This model is also a PyTorch "),ur=s("a"),km=t("torch.nn.Module"),Tm=t(` subclass.
Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
and behavior.`),ym=u(),On=s("div"),w(pr.$$.fragment),bm=u(),yt=s("p"),wm=t("The "),Di=s("a"),Fm=t("FunnelModel"),vm=t(" forward method, overrides the "),id=s("code"),$m=t("__call__"),Em=t(" special method."),Mm=u(),w(po.$$.fragment),zm=u(),w(ho.$$.fragment),ou=u(),bt=s("h2"),fo=s("a"),ld=s("span"),w(hr.$$.fragment),qm=u(),dd=s("span"),Pm=t("FunnelModelForPreTraining"),su=u(),wt=s("div"),w(fr.$$.fragment),xm=u(),Ln=s("div"),w(mr.$$.fragment),Cm=u(),Ft=s("p"),jm=t("The "),Ni=s("a"),Am=t("FunnelForPreTraining"),Om=t(" forward method, overrides the "),cd=s("code"),Lm=t("__call__"),Dm=t(" special method."),Nm=u(),w(mo.$$.fragment),Im=u(),w(go.$$.fragment),ru=u(),vt=s("h2"),_o=s("a"),ud=s("span"),w(gr.$$.fragment),Sm=u(),pd=s("span"),Bm=t("FunnelForMaskedLM"),au=u(),pn=s("div"),w(_r.$$.fragment),Wm=u(),kr=s("p"),Qm=t("Funnel Transformer Model with a "),hd=s("code"),Um=t("language modeling"),Km=t(" head on top."),Rm=u(),Tr=s("p"),Hm=t("The Funnel Transformer model was proposed in "),yr=s("a"),Vm=t(`Funnel-Transformer: Filtering out Sequential Redundancy for Efficient
Language Processing`),Ym=t(" by Zihang Dai, Guokun Lai, Yiming Yang, Quoc V. Le."),Gm=u(),br=s("p"),Zm=t("This model inherits from "),Ii=s("a"),Xm=t("PreTrainedModel"),Jm=t(`. 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.)`),eg=u(),wr=s("p"),ng=t("This model is also a PyTorch "),Fr=s("a"),tg=t("torch.nn.Module"),og=t(` subclass.
Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
and behavior.`),sg=u(),Dn=s("div"),w(vr.$$.fragment),rg=u(),$t=s("p"),ag=t("The "),Si=s("a"),ig=t("FunnelForMaskedLM"),lg=t(" forward method, overrides the "),fd=s("code"),dg=t("__call__"),cg=t(" special method."),ug=u(),w(ko.$$.fragment),pg=u(),w(To.$$.fragment),iu=u(),Et=s("h2"),yo=s("a"),md=s("span"),w($r.$$.fragment),hg=u(),gd=s("span"),fg=t("FunnelForSequenceClassification"),lu=u(),hn=s("div"),w(Er.$$.fragment),mg=u(),_d=s("p"),gg=t(`Funnel Transformer Model with a sequence classification/regression head on top (two linear layer on top of the
first timestep of the last hidden state) e.g. for GLUE tasks.`),_g=u(),Mr=s("p"),kg=t("The Funnel Transformer model was proposed in "),zr=s("a"),Tg=t(`Funnel-Transformer: Filtering out Sequential Redundancy for Efficient
Language Processing`),yg=t(" by Zihang Dai, Guokun Lai, Yiming Yang, Quoc V. Le."),bg=u(),qr=s("p"),wg=t("This model inherits from "),Bi=s("a"),Fg=t("PreTrainedModel"),vg=t(`. 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.)`),$g=u(),Pr=s("p"),Eg=t("This model is also a PyTorch "),xr=s("a"),Mg=t("torch.nn.Module"),zg=t(` subclass.
Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
and behavior.`),qg=u(),Tn=s("div"),w(Cr.$$.fragment),Pg=u(),Mt=s("p"),xg=t("The "),Wi=s("a"),Cg=t("FunnelForSequenceClassification"),jg=t(" forward method, overrides the "),kd=s("code"),Ag=t("__call__"),Og=t(" special method."),Lg=u(),w(bo.$$.fragment),Dg=u(),w(wo.$$.fragment),Ng=u(),w(Fo.$$.fragment),du=u(),zt=s("h2"),vo=s("a"),Td=s("span"),w(jr.$$.fragment),Ig=u(),yd=s("span"),Sg=t("FunnelForMultipleChoice"),cu=u(),fn=s("div"),w(Ar.$$.fragment),Bg=u(),bd=s("p"),Wg=t(`Funnel Transformer Model with a multiple choice classification head on top (two linear layer on top of the first
timestep of the last hidden state, and a softmax) e.g. for RocStories/SWAG tasks.`),Qg=u(),Or=s("p"),Ug=t("The Funnel Transformer model was proposed in "),Lr=s("a"),Kg=t(`Funnel-Transformer: Filtering out Sequential Redundancy for Efficient
Language Processing`),Rg=t(" by Zihang Dai, Guokun Lai, Yiming Yang, Quoc V. Le."),Hg=u(),Dr=s("p"),Vg=t("This model inherits from "),Qi=s("a"),Yg=t("PreTrainedModel"),Gg=t(`. 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.)`),Zg=u(),Nr=s("p"),Xg=t("This model is also a PyTorch "),Ir=s("a"),Jg=t("torch.nn.Module"),e_=t(` subclass.
Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
and behavior.`),n_=u(),Nn=s("div"),w(Sr.$$.fragment),t_=u(),qt=s("p"),o_=t("The "),Ui=s("a"),s_=t("FunnelForMultipleChoice"),r_=t(" forward method, overrides the "),wd=s("code"),a_=t("__call__"),i_=t(" special method."),l_=u(),w($o.$$.fragment),d_=u(),w(Eo.$$.fragment),uu=u(),Pt=s("h2"),Mo=s("a"),Fd=s("span"),w(Br.$$.fragment),c_=u(),vd=s("span"),u_=t("FunnelForTokenClassification"),pu=u(),mn=s("div"),w(Wr.$$.fragment),p_=u(),$d=s("p"),h_=t(`Funnel Transformer Model with a token classification head on top (a linear layer on top of the hidden-states
output) e.g. for Named-Entity-Recognition (NER) tasks.`),f_=u(),Qr=s("p"),m_=t("The Funnel Transformer model was proposed in "),Ur=s("a"),g_=t(`Funnel-Transformer: Filtering out Sequential Redundancy for Efficient
Language Processing`),__=t(" by Zihang Dai, Guokun Lai, Yiming Yang, Quoc V. Le."),k_=u(),Kr=s("p"),T_=t("This model inherits from "),Ki=s("a"),y_=t("PreTrainedModel"),b_=t(`. 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.)`),w_=u(),Rr=s("p"),F_=t("This model is also a PyTorch "),Hr=s("a"),v_=t("torch.nn.Module"),$_=t(` subclass.
Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
and behavior.`),E_=u(),In=s("div"),w(Vr.$$.fragment),M_=u(),xt=s("p"),z_=t("The "),Ri=s("a"),q_=t("FunnelForTokenClassification"),P_=t(" forward method, overrides the "),Ed=s("code"),x_=t("__call__"),C_=t(" special method."),j_=u(),w(zo.$$.fragment),A_=u(),w(qo.$$.fragment),hu=u(),Ct=s("h2"),Po=s("a"),Md=s("span"),w(Yr.$$.fragment),O_=u(),zd=s("span"),L_=t("FunnelForQuestionAnswering"),fu=u(),gn=s("div"),w(Gr.$$.fragment),D_=u(),jt=s("p"),N_=t(`Funnel Transformer Model with a span classification head on top for extractive question-answering tasks like SQuAD
(a linear layer on top of the hidden-states output to compute `),qd=s("code"),I_=t("span start logits"),S_=t(" and "),Pd=s("code"),B_=t("span end logits"),W_=t(")."),Q_=u(),Zr=s("p"),U_=t("The Funnel Transformer model was proposed in "),Xr=s("a"),K_=t(`Funnel-Transformer: Filtering out Sequential Redundancy for Efficient
Language Processing`),R_=t(" by Zihang Dai, Guokun Lai, Yiming Yang, Quoc V. Le."),H_=u(),Jr=s("p"),V_=t("This model inherits from "),Hi=s("a"),Y_=t("PreTrainedModel"),G_=t(`. 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.)`),Z_=u(),ea=s("p"),X_=t("This model is also a PyTorch "),na=s("a"),J_=t("torch.nn.Module"),ek=t(` subclass.
Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
and behavior.`),nk=u(),Sn=s("div"),w(ta.$$.fragment),tk=u(),At=s("p"),ok=t("The "),Vi=s("a"),sk=t("FunnelForQuestionAnswering"),rk=t(" forward method, overrides the "),xd=s("code"),ak=t("__call__"),ik=t(" special method."),lk=u(),w(xo.$$.fragment),dk=u(),w(Co.$$.fragment),mu=u(),Ot=s("h2"),jo=s("a"),Cd=s("span"),w(oa.$$.fragment),ck=u(),jd=s("span"),uk=t("TFFunnelBaseModel"),gu=u(),nn=s("div"),w(sa.$$.fragment),pk=u(),Ad=s("p"),hk=t(`The base Funnel Transformer Model transformer outputting raw hidden-states without upsampling head (also called
decoder) or any task-specific head on top.`),fk=u(),ra=s("p"),mk=t("The Funnel Transformer model was proposed in "),aa=s("a"),gk=t(`Funnel-Transformer: Filtering out Sequential Redundancy for Efficient
Language Processing`),_k=t(" by Zihang Dai, Guokun Lai, Yiming Yang, Quoc V. Le."),kk=u(),ia=s("p"),Tk=t("This model inherits from "),Yi=s("a"),yk=t("TFPreTrainedModel"),bk=t(`. 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.)`),wk=u(),la=s("p"),Fk=t("This model is also a "),da=s("a"),vk=t("tf.keras.Model"),$k=t(` subclass. Use it
as a regular TF 2.0 Keras Model and refer to the TF 2.0 documentation for all matter related to general usage and
behavior.`),Ek=u(),w(Ao.$$.fragment),Mk=u(),Bn=s("div"),w(ca.$$.fragment),zk=u(),Lt=s("p"),qk=t("The "),Gi=s("a"),Pk=t("TFFunnelBaseModel"),xk=t(" forward method, overrides the "),Od=s("code"),Ck=t("__call__"),jk=t(" special method."),Ak=u(),w(Oo.$$.fragment),Ok=u(),w(Lo.$$.fragment),_u=u(),Dt=s("h2"),Do=s("a"),Ld=s("span"),w(ua.$$.fragment),Lk=u(),Dd=s("span"),Dk=t("TFFunnelModel"),ku=u(),tn=s("div"),w(pa.$$.fragment),Nk=u(),Nd=s("p"),Ik=t("The bare Funnel Transformer Model transformer outputting raw hidden-states without any specific head on top."),Sk=u(),ha=s("p"),Bk=t("The Funnel Transformer model was proposed in "),fa=s("a"),Wk=t(`Funnel-Transformer: Filtering out Sequential Redundancy for Efficient
Language Processing`),Qk=t(" by Zihang Dai, Guokun Lai, Yiming Yang, Quoc V. Le."),Uk=u(),ma=s("p"),Kk=t("This model inherits from "),Zi=s("a"),Rk=t("TFPreTrainedModel"),Hk=t(`. 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.)`),Vk=u(),ga=s("p"),Yk=t("This model is also a "),_a=s("a"),Gk=t("tf.keras.Model"),Zk=t(` subclass. Use it
as a regular TF 2.0 Keras Model and refer to the TF 2.0 documentation for all matter related to general usage and
behavior.`),Xk=u(),w(No.$$.fragment),Jk=u(),Wn=s("div"),w(ka.$$.fragment),eT=u(),Nt=s("p"),nT=t("The "),Xi=s("a"),tT=t("TFFunnelModel"),oT=t(" forward method, overrides the "),Id=s("code"),sT=t("__call__"),rT=t(" special method."),aT=u(),w(Io.$$.fragment),iT=u(),w(So.$$.fragment),Tu=u(),It=s("h2"),Bo=s("a"),Sd=s("span"),w(Ta.$$.fragment),lT=u(),Bd=s("span"),dT=t("TFFunnelModelForPreTraining"),yu=u(),on=s("div"),w(ya.$$.fragment),cT=u(),Wd=s("p"),uT=t("Funnel model with a binary classification head on top as used during pretraining for identifying generated tokens."),pT=u(),ba=s("p"),hT=t("The Funnel Transformer model was proposed in "),wa=s("a"),fT=t(`Funnel-Transformer: Filtering out Sequential Redundancy for Efficient
Language Processing`),mT=t(" by Zihang Dai, Guokun Lai, Yiming Yang, Quoc V. Le."),gT=u(),Fa=s("p"),_T=t("This model inherits from "),Ji=s("a"),kT=t("TFPreTrainedModel"),TT=t(`. 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.)`),yT=u(),va=s("p"),bT=t("This model is also a "),$a=s("a"),wT=t("tf.keras.Model"),FT=t(` subclass. Use it
as a regular TF 2.0 Keras Model and refer to the TF 2.0 documentation for all matter related to general usage and
behavior.`),vT=u(),w(Wo.$$.fragment),$T=u(),Qn=s("div"),w(Ea.$$.fragment),ET=u(),St=s("p"),MT=t("The "),el=s("a"),zT=t("TFFunnelForPreTraining"),qT=t(" forward method, overrides the "),Qd=s("code"),PT=t("__call__"),xT=t(" special method."),CT=u(),w(Qo.$$.fragment),jT=u(),w(Uo.$$.fragment),bu=u(),Bt=s("h2"),Ko=s("a"),Ud=s("span"),w(Ma.$$.fragment),AT=u(),Kd=s("span"),OT=t("TFFunnelForMaskedLM"),wu=u(),sn=s("div"),w(za.$$.fragment),LT=u(),qa=s("p"),DT=t("Funnel Model with a "),Rd=s("code"),NT=t("language modeling"),IT=t(" head on top."),ST=u(),Pa=s("p"),BT=t("The Funnel Transformer model was proposed in "),xa=s("a"),WT=t(`Funnel-Transformer: Filtering out Sequential Redundancy for Efficient
Language Processing`),QT=t(" by Zihang Dai, Guokun Lai, Yiming Yang, Quoc V. Le."),UT=u(),Ca=s("p"),KT=t("This model inherits from "),nl=s("a"),RT=t("TFPreTrainedModel"),HT=t(`. 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.)`),VT=u(),ja=s("p"),YT=t("This model is also a "),Aa=s("a"),GT=t("tf.keras.Model"),ZT=t(` subclass. Use it
as a regular TF 2.0 Keras Model and refer to the TF 2.0 documentation for all matter related to general usage and
behavior.`),XT=u(),w(Ro.$$.fragment),JT=u(),yn=s("div"),w(Oa.$$.fragment),ey=u(),Wt=s("p"),ny=t("The "),tl=s("a"),ty=t("TFFunnelForMaskedLM"),oy=t(" forward method, overrides the "),Hd=s("code"),sy=t("__call__"),ry=t(" special method."),ay=u(),w(Ho.$$.fragment),iy=u(),w(Vo.$$.fragment),ly=u(),w(Yo.$$.fragment),Fu=u(),Qt=s("h2"),Go=s("a"),Vd=s("span"),w(La.$$.fragment),dy=u(),Yd=s("span"),cy=t("TFFunnelForSequenceClassification"),vu=u(),rn=s("div"),w(Da.$$.fragment),uy=u(),Gd=s("p"),py=t(`Funnel Model transformer with a sequence classification/regression head on top (a linear layer on top of the pooled
output) e.g. for GLUE tasks.`),hy=u(),Na=s("p"),fy=t("The Funnel Transformer model was proposed in "),Ia=s("a"),my=t(`Funnel-Transformer: Filtering out Sequential Redundancy for Efficient
Language Processing`),gy=t(" by Zihang Dai, Guokun Lai, Yiming Yang, Quoc V. Le."),_y=u(),Sa=s("p"),ky=t("This model inherits from "),ol=s("a"),Ty=t("TFPreTrainedModel"),yy=t(`. 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.)`),by=u(),Ba=s("p"),wy=t("This model is also a "),Wa=s("a"),Fy=t("tf.keras.Model"),vy=t(` subclass. Use it
as a regular TF 2.0 Keras Model and refer to the TF 2.0 documentation for all matter related to general usage and
behavior.`),$y=u(),w(Zo.$$.fragment),Ey=u(),bn=s("div"),w(Qa.$$.fragment),My=u(),Ut=s("p"),zy=t("The "),sl=s("a"),qy=t("TFFunnelForSequenceClassification"),Py=t(" forward method, overrides the "),Zd=s("code"),xy=t("__call__"),Cy=t(" special method."),jy=u(),w(Xo.$$.fragment),Ay=u(),w(Jo.$$.fragment),Oy=u(),w(es.$$.fragment),$u=u(),Kt=s("h2"),ns=s("a"),Xd=s("span"),w(Ua.$$.fragment),Ly=u(),Jd=s("span"),Dy=t("TFFunnelForMultipleChoice"),Eu=u(),an=s("div"),w(Ka.$$.fragment),Ny=u(),ec=s("p"),Iy=t(`Funnel Model with a multiple choice classification head on top (a linear layer on top of the pooled output and a
softmax) e.g. for RocStories/SWAG tasks.`),Sy=u(),Ra=s("p"),By=t("The Funnel Transformer model was proposed in "),Ha=s("a"),Wy=t(`Funnel-Transformer: Filtering out Sequential Redundancy for Efficient
Language Processing`),Qy=t(" by Zihang Dai, Guokun Lai, Yiming Yang, Quoc V. Le."),Uy=u(),Va=s("p"),Ky=t("This model inherits from "),rl=s("a"),Ry=t("TFPreTrainedModel"),Hy=t(`. 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.)`),Vy=u(),Ya=s("p"),Yy=t("This model is also a "),Ga=s("a"),Gy=t("tf.keras.Model"),Zy=t(` subclass. Use it
as a regular TF 2.0 Keras Model and refer to the TF 2.0 documentation for all matter related to general usage and
behavior.`),Xy=u(),w(ts.$$.fragment),Jy=u(),Un=s("div"),w(Za.$$.fragment),eb=u(),Rt=s("p"),nb=t("The "),al=s("a"),tb=t("TFFunnelForMultipleChoice"),ob=t(" forward method, overrides the "),nc=s("code"),sb=t("__call__"),rb=t(" special method."),ab=u(),w(os.$$.fragment),ib=u(),w(ss.$$.fragment),Mu=u(),Ht=s("h2"),rs=s("a"),tc=s("span"),w(Xa.$$.fragment),lb=u(),oc=s("span"),db=t("TFFunnelForTokenClassification"),zu=u(),ln=s("div"),w(Ja.$$.fragment),cb=u(),sc=s("p"),ub=t(`Funnel Model with a token classification head on top (a linear layer on top of the hidden-states output) e.g. for
Named-Entity-Recognition (NER) tasks.`),pb=u(),ei=s("p"),hb=t("The Funnel Transformer model was proposed in "),ni=s("a"),fb=t(`Funnel-Transformer: Filtering out Sequential Redundancy for Efficient
Language Processing`),mb=t(" by Zihang Dai, Guokun Lai, Yiming Yang, Quoc V. Le."),gb=u(),ti=s("p"),_b=t("This model inherits from "),il=s("a"),kb=t("TFPreTrainedModel"),Tb=t(`. 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.)`),yb=u(),oi=s("p"),bb=t("This model is also a "),si=s("a"),wb=t("tf.keras.Model"),Fb=t(` subclass. Use it
as a regular TF 2.0 Keras Model and refer to the TF 2.0 documentation for all matter related to general usage and
behavior.`),vb=u(),w(as.$$.fragment),$b=u(),wn=s("div"),w(ri.$$.fragment),Eb=u(),Vt=s("p"),Mb=t("The "),ll=s("a"),zb=t("TFFunnelForTokenClassification"),qb=t(" forward method, overrides the "),rc=s("code"),Pb=t("__call__"),xb=t(" special method."),Cb=u(),w(is.$$.fragment),jb=u(),w(ls.$$.fragment),Ab=u(),w(ds.$$.fragment),qu=u(),Yt=s("h2"),cs=s("a"),ac=s("span"),w(ai.$$.fragment),Ob=u(),ic=s("span"),Lb=t("TFFunnelForQuestionAnswering"),Pu=u(),dn=s("div"),w(ii.$$.fragment),Db=u(),Gt=s("p"),Nb=t(`Funnel Model with a span classification head on top for extractive question-answering tasks like SQuAD (a linear
layers on top of the hidden-states output to compute `),lc=s("code"),Ib=t("span start logits"),Sb=t(" and "),dc=s("code"),Bb=t("span end logits"),Wb=t(")."),Qb=u(),li=s("p"),Ub=t("The Funnel Transformer model was proposed in "),di=s("a"),Kb=t(`Funnel-Transformer: Filtering out Sequential Redundancy for Efficient
Language Processing`),Rb=t(" by Zihang Dai, Guokun Lai, Yiming Yang, Quoc V. Le."),Hb=u(),ci=s("p"),Vb=t("This model inherits from "),dl=s("a"),Yb=t("TFPreTrainedModel"),Gb=t(`. 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.)`),Zb=u(),ui=s("p"),Xb=t("This model is also a "),pi=s("a"),Jb=t("tf.keras.Model"),ew=t(` subclass. Use it
as a regular TF 2.0 Keras Model and refer to the TF 2.0 documentation for all matter related to general usage and
behavior.`),nw=u(),w(us.$$.fragment),tw=u(),Fn=s("div"),w(hi.$$.fragment),ow=u(),Zt=s("p"),sw=t("The "),cl=s("a"),rw=t("TFFunnelForQuestionAnswering"),aw=t(" forward method, overrides the "),cc=s("code"),iw=t("__call__"),lw=t(" special method."),dw=u(),w(ps.$$.fragment),cw=u(),w(hs.$$.fragment),uw=u(),w(fs.$$.fragment),this.h()},l(i){const y=v$('[data-svelte="svelte-1phssyn"]',document.head);d=r(y,"META",{name:!0,content:!0}),y.forEach(n),k=p(i),h=r(i,"H1",{class:!0});var fi=a(h);f=r(fi,"A",{id:!0,class:!0,href:!0});var uc=a(f);T=r(uc,"SPAN",{});var pc=a(T);F(l.$$.fragment,pc),pc.forEach(n),uc.forEach(n),c=p(fi),P=r(fi,"SPAN",{});var hc=a(P);ke=o(hc,"Funnel Transformer"),hc.forEach(n),fi.forEach(n),he=p(i),I=r(i,"H2",{class:!0});var mi=a(I);re=r(mi,"A",{id:!0,class:!0,href:!0});var fc=a(re);ee=r(fc,"SPAN",{});var mc=a(ee);F(b.$$.fragment,mc),mc.forEach(n),fc.forEach(n),Te=p(mi),K=r(mi,"SPAN",{});var gc=a(K);ye=o(gc,"Overview"),gc.forEach(n),mi.forEach(n),fe=p(i),B=r(i,"P",{});var gi=a(B);be=o(gi,"The Funnel Transformer model was proposed in the paper "),ae=r(gi,"A",{href:!0,rel:!0});var _c=a(ae);H=o(_c,`Funnel-Transformer: Filtering out Sequential Redundancy for
Efficient Language Processing`),_c.forEach(n),we=o(gi,`. It is a bidirectional transformer model, like
BERT, but with a pooling operation after each block of layers, a bit like in traditional convolutional neural networks
(CNN) in computer vision.`),gi.forEach(n),me=p(i),Q=r(i,"P",{});var kc=a(Q);Fe=o(kc,"The abstract from the paper is the following:"),kc.forEach(n),ge=p(i),U=r(i,"P",{});var Tc=a(U);ue=r(Tc,"EM",{});var yc=a(ue);ve=o(yc,`With the success of language pretraining, it is highly desirable to develop more efficient architectures of good
scalability that can exploit the abundant unlabeled data at a lower cost. To improve the efficiency, we examine the
much-overlooked redundancy in maintaining a full-length token-level presentation, especially for tasks that only
require a single-vector presentation of the sequence. With this intuition, we propose Funnel-Transformer which
gradually compresses the sequence of hidden states to a shorter one and hence reduces the computation cost. More
importantly, by re-investing the saved FLOPs from length reduction in constructing a deeper or wider model, we further
improve the model capacity. In addition, to perform token-level predictions as required by common pretraining
objectives, Funnel-Transformer is able to recover a deep representation for each token from the reduced hidden sequence
via a decoder. Empirically, with comparable or fewer FLOPs, Funnel-Transformer outperforms the standard Transformer on
a wide variety of sequence-level prediction tasks, including text classification, language understanding, and reading
comprehension.`),yc.forEach(n),Tc.forEach(n),oe=p(i),C=r(i,"P",{});var bc=a(C);A=o(bc,"Tips:"),bc.forEach(n),_e=p(i),W=r(i,"UL",{});var _i=a(W);pe=r(_i,"LI",{});var wc=a(pe);$e=o(wc,`Since Funnel Transformer uses pooling, the sequence length of the hidden states changes after each block of layers.
The base model therefore has a final sequence length that is a quarter of the original one. This model can be used
directly for tasks that just require a sentence summary (like sequence classification or multiple choice). For other
tasks, the full model is used; this full model has a decoder that upsamples the final hidden states to the same
sequence length as the input.`),wc.forEach(n),V=p(_i),R=r(_i,"LI",{});var Je=a(R);Ee=o(Je,`The Funnel Transformer checkpoints are all available with a full version and a base version. The first ones should be
used for `),j=r(Je,"A",{href:!0});var Fc=a(j);Me=o(Fc,"FunnelModel"),Fc.forEach(n),Y=o(Je,", "),le=r(Je,"A",{href:!0});var vc=a(le);ze=o(vc,"FunnelForPreTraining"),vc.forEach(n),G=o(Je,`,
`),de=r(Je,"A",{href:!0});var $c=a(de);qe=o($c,"FunnelForMaskedLM"),$c.forEach(n),N=o(Je,", "),ce=r(Je,"A",{href:!0});var Ec=a(ce);Z=o(Ec,"FunnelForTokenClassification"),Ec.forEach(n),Pe=o(Je,` and
class:`),ne=r(Je,"EM",{});var Mc=a(ne);O=o(Mc,"~transformers.FunnelForQuestionAnswering"),Mc.forEach(n),xe=o(Je,`. The second ones should be used for
`),L=r(Je,"A",{href:!0});var zc=a(L);Ce=o(zc,"FunnelBaseModel"),zc.forEach(n),je=o(Je,", "),g=r(Je,"A",{href:!0});var qc=a(g);z=o(qc,"FunnelForSequenceClassification"),qc.forEach(n),Ie=o(Je,` and
`),J=r(Je,"A",{href:!0});var Pc=a(J);Se=o(Pc,"FunnelForMultipleChoice"),Pc.forEach(n),Be=o(Je,"."),Je.forEach(n),_i.forEach(n),q=p(i),Ae=r(i,"P",{});var Xt=a(Ae);We=o(Xt,"This model was contributed by "),Le=r(Xt,"A",{href:!0,rel:!0});var xc=a(Le);Qe=o(xc,"sgugger"),xc.forEach(n),Ue=o(Xt,". The original code can be found "),D=r(Xt,"A",{href:!0,rel:!0});var Cc=a(D);X=o(Cc,"here"),Cc.forEach(n),Ke=o(Xt,"."),Xt.forEach(n),Ne=p(i),S=r(i,"H2",{class:!0});var ki=a(S);Oe=r(ki,"A",{id:!0,class:!0,href:!0});var jc=a(Oe);De=r(jc,"SPAN",{});var Ac=a(De);F(ie.$$.fragment,Ac),Ac.forEach(n),jc.forEach(n),Re=p(ki),te=r(ki,"SPAN",{});var Oc=a(te);He=o(Oc,"FunnelConfig"),Oc.forEach(n),ki.forEach(n),Kc=p(i),Xn=r(i,"DIV",{class:!0});var Jt=a(Xn);F(zs.$$.fragment,Jt),eh=p(Jt),Jn=r(Jt,"P",{});var et=a(Jn);nh=o(et,"This is the configuration class to store the configuration of a "),bi=r(et,"A",{href:!0});var Lc=a(bi);th=o(Lc,"FunnelModel"),Lc.forEach(n),oh=o(et," or a "),wi=r(et,"A",{href:!0});var Dc=a(wi);sh=o(Dc,"TFBertModel"),Dc.forEach(n),rh=o(et,`. It is used to
instantiate a Funnel Transformer 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 Funnel
Transformer `),qs=r(et,"A",{href:!0,rel:!0});var Nc=a(qs);ah=o(Nc,"funnel-transformer/small"),Nc.forEach(n),ih=o(et," architecture."),et.forEach(n),lh=p(Jt),dt=r(Jt,"P",{});var eo=a(dt);dh=o(eo,"Configuration objects inherit from "),Fi=r(eo,"A",{href:!0});var Ic=a(Fi);ch=o(Ic,"PretrainedConfig"),Ic.forEach(n),uh=o(eo,` and can be used to control the model outputs. Read the
documentation from `),vi=r(eo,"A",{href:!0});var Sc=a(vi);ph=o(Sc,"PretrainedConfig"),Sc.forEach(n),hh=o(eo," for more information."),eo.forEach(n),Jt.forEach(n),Rc=p(i),ct=r(i,"H2",{class:!0});var Ti=a(ct);no=r(Ti,"A",{id:!0,class:!0,href:!0});var Bc=a(no);jl=r(Bc,"SPAN",{});var Wc=a(jl);F(Ps.$$.fragment,Wc),Wc.forEach(n),Bc.forEach(n),fh=p(Ti),Al=r(Ti,"SPAN",{});var Qc=a(Al);mh=o(Qc,"FunnelTokenizer"),Qc.forEach(n),Ti.forEach(n),Hc=p(i),en=r(i,"DIV",{class:!0});var _n=a(en);F(xs.$$.fragment,_n),gh=p(_n),Ol=r(_n,"P",{});var Uc=a(Ol);_h=o(Uc,"Construct a Funnel Transformer tokenizer. Based on WordPiece."),Uc.forEach(n),kh=p(_n),Cs=r(_n,"P",{});var yi=a(Cs);Th=o(yi,"This tokenizer inherits from "),$i=r(yi,"A",{href:!0});var gw=a($i);yh=o(gw,"PreTrainedTokenizer"),gw.forEach(n),bh=o(yi,` which contains most of the main methods. Users should refer to
this superclass for more information regarding those methods.`),yi.forEach(n),wh=p(_n),nt=r(_n,"DIV",{class:!0});var ul=a(nt);F(js.$$.fragment,ul),Fh=p(ul),Ll=r(ul,"P",{});var _w=a(Ll);vh=o(_w,`Build model inputs from a sequence or a pair of sequence for sequence classification tasks by concatenating and
adding special tokens. A BERT sequence has the following format:`),_w.forEach(n),$h=p(ul),As=r(ul,"UL",{});var Cu=a(As);Ei=r(Cu,"LI",{});var pw=a(Ei);Eh=o(pw,"single sequence: "),Dl=r(pw,"CODE",{});var kw=a(Dl);Mh=o(kw,"[CLS] X [SEP]"),kw.forEach(n),pw.forEach(n),zh=p(Cu),Mi=r(Cu,"LI",{});var hw=a(Mi);qh=o(hw,"pair of sequences: "),Nl=r(hw,"CODE",{});var Tw=a(Nl);Ph=o(Tw,"[CLS] A [SEP] B [SEP]"),Tw.forEach(n),hw.forEach(n),Cu.forEach(n),ul.forEach(n),xh=p(_n),to=r(_n,"DIV",{class:!0});var ju=a(to);F(Os.$$.fragment,ju),Ch=p(ju),Ls=r(ju,"P",{});var Au=a(Ls);jh=o(Au,`Retrieve sequence ids from a token list that has no special tokens added. This method is called when adding
special tokens using the tokenizer `),Il=r(Au,"CODE",{});var yw=a(Il);Ah=o(yw,"prepare_for_model"),yw.forEach(n),Oh=o(Au," method."),Au.forEach(n),ju.forEach(n),Lh=p(_n),Cn=r(_n,"DIV",{class:!0});var ms=a(Cn);F(Ds.$$.fragment,ms),Dh=p(ms),Sl=r(ms,"P",{});var bw=a(Sl);Nh=o(bw,"Create a mask from the two sequences passed to be used in a sequence-pair classification task. A Funnel"),bw.forEach(n),Ih=p(ms),F(oo.$$.fragment,ms),Sh=p(ms),ut=r(ms,"P",{});var pl=a(ut);Bh=o(pl,"If "),Bl=r(pl,"CODE",{});var ww=a(Bl);Wh=o(ww,"token_ids_1"),ww.forEach(n),Qh=o(pl," is "),Wl=r(pl,"CODE",{});var Fw=a(Wl);Uh=o(Fw,"None"),Fw.forEach(n),Kh=o(pl,", this method only returns the first portion of the mask (0s)."),pl.forEach(n),ms.forEach(n),Rh=p(_n),zi=r(_n,"DIV",{class:!0});var vw=a(zi);F(Ns.$$.fragment,vw),vw.forEach(n),_n.forEach(n),Vc=p(i),pt=r(i,"H2",{class:!0});var Ou=a(pt);so=r(Ou,"A",{id:!0,class:!0,href:!0});var $w=a(so);Ql=r($w,"SPAN",{});var Ew=a(Ql);F(Is.$$.fragment,Ew),Ew.forEach(n),$w.forEach(n),Hh=p(Ou),Ul=r(Ou,"SPAN",{});var Mw=a(Ul);Vh=o(Mw,"FunnelTokenizerFast"),Mw.forEach(n),Ou.forEach(n),Yc=p(i),kn=r(i,"DIV",{class:!0});var ot=a(kn);F(Ss.$$.fragment,ot),Yh=p(ot),Bs=r(ot,"P",{});var Lu=a(Bs);Gh=o(Lu,"Construct a \u201Cfast\u201D Funnel Transformer tokenizer (backed by HuggingFace\u2019s "),Kl=r(Lu,"EM",{});var zw=a(Kl);Zh=o(zw,"tokenizers"),zw.forEach(n),Xh=o(Lu," library). Based on WordPiece."),Lu.forEach(n),Jh=p(ot),Ws=r(ot,"P",{});var Du=a(Ws);ef=o(Du,"This tokenizer inherits from "),qi=r(Du,"A",{href:!0});var qw=a(qi);nf=o(qw,"PreTrainedTokenizerFast"),qw.forEach(n),tf=o(Du,` which contains most of the main methods. Users should
refer to this superclass for more information regarding those methods.`),Du.forEach(n),of=p(ot),tt=r(ot,"DIV",{class:!0});var hl=a(tt);F(Qs.$$.fragment,hl),sf=p(hl),Rl=r(hl,"P",{});var Pw=a(Rl);rf=o(Pw,`Build model inputs from a sequence or a pair of sequence for sequence classification tasks by concatenating and
adding special tokens. A Funnel sequence has the following format:`),Pw.forEach(n),af=p(hl),Us=r(hl,"UL",{});var Nu=a(Us);Pi=r(Nu,"LI",{});var fw=a(Pi);lf=o(fw,"single sequence: "),Hl=r(fw,"CODE",{});var xw=a(Hl);df=o(xw,"[CLS] X [SEP]"),xw.forEach(n),fw.forEach(n),cf=p(Nu),xi=r(Nu,"LI",{});var mw=a(xi);uf=o(mw,"pair of sequences: "),Vl=r(mw,"CODE",{});var Cw=a(Vl);pf=o(Cw,"[CLS] A [SEP] B [SEP]"),Cw.forEach(n),mw.forEach(n),Nu.forEach(n),hl.forEach(n),hf=p(ot),jn=r(ot,"DIV",{class:!0});var gs=a(jn);F(Ks.$$.fragment,gs),ff=p(gs),Yl=r(gs,"P",{});var jw=a(Yl);mf=o(jw,"Create a mask from the two sequences passed to be used in a sequence-pair classification task. A Funnel"),jw.forEach(n),gf=p(gs),F(ro.$$.fragment,gs),_f=p(gs),ht=r(gs,"P",{});var fl=a(ht);kf=o(fl,"If "),Gl=r(fl,"CODE",{});var Aw=a(Gl);Tf=o(Aw,"token_ids_1"),Aw.forEach(n),yf=o(fl," is "),Zl=r(fl,"CODE",{});var Ow=a(Zl);bf=o(Ow,"None"),Ow.forEach(n),wf=o(fl,", this method only returns the first portion of the mask (0s)."),fl.forEach(n),gs.forEach(n),ot.forEach(n),Gc=p(i),ft=r(i,"H2",{class:!0});var Iu=a(ft);ao=r(Iu,"A",{id:!0,class:!0,href:!0});var Lw=a(ao);Xl=r(Lw,"SPAN",{});var Dw=a(Xl);F(Rs.$$.fragment,Dw),Dw.forEach(n),Lw.forEach(n),Ff=p(Iu),Jl=r(Iu,"SPAN",{});var Nw=a(Jl);vf=o(Nw,"Funnel specific outputs"),Nw.forEach(n),Iu.forEach(n),Zc=p(i),mt=r(i,"DIV",{class:!0});var Su=a(mt);F(Hs.$$.fragment,Su),$f=p(Su),Vs=r(Su,"P",{});var Bu=a(Vs);Ef=o(Bu,"Output type of "),Ci=r(Bu,"A",{href:!0});var Iw=a(Ci);Mf=o(Iw,"FunnelForPreTraining"),Iw.forEach(n),zf=o(Bu,"."),Bu.forEach(n),Su.forEach(n),Xc=p(i),gt=r(i,"DIV",{class:!0});var Wu=a(gt);F(Ys.$$.fragment,Wu),qf=p(Wu),Gs=r(Wu,"P",{});var Qu=a(Gs);Pf=o(Qu,"Output type of "),ji=r(Qu,"A",{href:!0});var Sw=a(ji);xf=o(Sw,"FunnelForPreTraining"),Sw.forEach(n),Cf=o(Qu,"."),Qu.forEach(n),Wu.forEach(n),Jc=p(i),_t=r(i,"H2",{class:!0});var Uu=a(_t);io=r(Uu,"A",{id:!0,class:!0,href:!0});var Bw=a(io);ed=r(Bw,"SPAN",{});var Ww=a(ed);F(Zs.$$.fragment,Ww),Ww.forEach(n),Bw.forEach(n),jf=p(Uu),nd=r(Uu,"SPAN",{});var Qw=a(nd);Af=o(Qw,"FunnelBaseModel"),Qw.forEach(n),Uu.forEach(n),eu=p(i),cn=r(i,"DIV",{class:!0});var Kn=a(cn);F(Xs.$$.fragment,Kn),Of=p(Kn),td=r(Kn,"P",{});var Uw=a(td);Lf=o(Uw,`The base Funnel Transformer Model transformer outputting raw hidden-states without upsampling head (also called
decoder) or any task-specific head on top.`),Uw.forEach(n),Df=p(Kn),Js=r(Kn,"P",{});var Ku=a(Js);Nf=o(Ku,"The Funnel Transformer model was proposed in "),er=r(Ku,"A",{href:!0,rel:!0});var Kw=a(er);If=o(Kw,`Funnel-Transformer: Filtering out Sequential Redundancy for Efficient
Language Processing`),Kw.forEach(n),Sf=o(Ku," by Zihang Dai, Guokun Lai, Yiming Yang, Quoc V. Le."),Ku.forEach(n),Bf=p(Kn),nr=r(Kn,"P",{});var Ru=a(nr);Wf=o(Ru,"This model inherits from "),Ai=r(Ru,"A",{href:!0});var Rw=a(Ai);Qf=o(Rw,"PreTrainedModel"),Rw.forEach(n),Uf=o(Ru,`. 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.)`),Ru.forEach(n),Kf=p(Kn),tr=r(Kn,"P",{});var Hu=a(tr);Rf=o(Hu,"This model is also a PyTorch "),or=r(Hu,"A",{href:!0,rel:!0});var Hw=a(or);Hf=o(Hw,"torch.nn.Module"),Hw.forEach(n),Vf=o(Hu,` subclass.
Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
and behavior.`),Hu.forEach(n),Yf=p(Kn),An=r(Kn,"DIV",{class:!0});var _s=a(An);F(sr.$$.fragment,_s),Gf=p(_s),kt=r(_s,"P",{});var ml=a(kt);Zf=o(ml,"The "),Oi=r(ml,"A",{href:!0});var Vw=a(Oi);Xf=o(Vw,"FunnelBaseModel"),Vw.forEach(n),Jf=o(ml," forward method, overrides the "),od=r(ml,"CODE",{});var Yw=a(od);em=o(Yw,"__call__"),Yw.forEach(n),nm=o(ml," special method."),ml.forEach(n),tm=p(_s),F(lo.$$.fragment,_s),om=p(_s),F(co.$$.fragment,_s),_s.forEach(n),Kn.forEach(n),nu=p(i),Tt=r(i,"H2",{class:!0});var Vu=a(Tt);uo=r(Vu,"A",{id:!0,class:!0,href:!0});var Gw=a(uo);sd=r(Gw,"SPAN",{});var Zw=a(sd);F(rr.$$.fragment,Zw),Zw.forEach(n),Gw.forEach(n),sm=p(Vu),rd=r(Vu,"SPAN",{});var Xw=a(rd);rm=o(Xw,"FunnelModel"),Xw.forEach(n),Vu.forEach(n),tu=p(i),un=r(i,"DIV",{class:!0});var Rn=a(un);F(ar.$$.fragment,Rn),am=p(Rn),ad=r(Rn,"P",{});var Jw=a(ad);im=o(Jw,"The bare Funnel Transformer Model transformer outputting raw hidden-states without any specific head on top."),Jw.forEach(n),lm=p(Rn),ir=r(Rn,"P",{});var Yu=a(ir);dm=o(Yu,"The Funnel Transformer model was proposed in "),lr=r(Yu,"A",{href:!0,rel:!0});var eF=a(lr);cm=o(eF,`Funnel-Transformer: Filtering out Sequential Redundancy for Efficient
Language Processing`),eF.forEach(n),um=o(Yu," by Zihang Dai, Guokun Lai, Yiming Yang, Quoc V. Le."),Yu.forEach(n),pm=p(Rn),dr=r(Rn,"P",{});var Gu=a(dr);hm=o(Gu,"This model inherits from "),Li=r(Gu,"A",{href:!0});var nF=a(Li);fm=o(nF,"PreTrainedModel"),nF.forEach(n),mm=o(Gu,`. 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.)`),Gu.forEach(n),gm=p(Rn),cr=r(Rn,"P",{});var Zu=a(cr);_m=o(Zu,"This model is also a PyTorch "),ur=r(Zu,"A",{href:!0,rel:!0});var tF=a(ur);km=o(tF,"torch.nn.Module"),tF.forEach(n),Tm=o(Zu,` subclass.
Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
and behavior.`),Zu.forEach(n),ym=p(Rn),On=r(Rn,"DIV",{class:!0});var ks=a(On);F(pr.$$.fragment,ks),bm=p(ks),yt=r(ks,"P",{});var gl=a(yt);wm=o(gl,"The "),Di=r(gl,"A",{href:!0});var oF=a(Di);Fm=o(oF,"FunnelModel"),oF.forEach(n),vm=o(gl," forward method, overrides the "),id=r(gl,"CODE",{});var sF=a(id);$m=o(sF,"__call__"),sF.forEach(n),Em=o(gl," special method."),gl.forEach(n),Mm=p(ks),F(po.$$.fragment,ks),zm=p(ks),F(ho.$$.fragment,ks),ks.forEach(n),Rn.forEach(n),ou=p(i),bt=r(i,"H2",{class:!0});var Xu=a(bt);fo=r(Xu,"A",{id:!0,class:!0,href:!0});var rF=a(fo);ld=r(rF,"SPAN",{});var aF=a(ld);F(hr.$$.fragment,aF),aF.forEach(n),rF.forEach(n),qm=p(Xu),dd=r(Xu,"SPAN",{});var iF=a(dd);Pm=o(iF,"FunnelModelForPreTraining"),iF.forEach(n),Xu.forEach(n),su=p(i),wt=r(i,"DIV",{class:!0});var Ju=a(wt);F(fr.$$.fragment,Ju),xm=p(Ju),Ln=r(Ju,"DIV",{class:!0});var Ts=a(Ln);F(mr.$$.fragment,Ts),Cm=p(Ts),Ft=r(Ts,"P",{});var _l=a(Ft);jm=o(_l,"The "),Ni=r(_l,"A",{href:!0});var lF=a(Ni);Am=o(lF,"FunnelForPreTraining"),lF.forEach(n),Om=o(_l," forward method, overrides the "),cd=r(_l,"CODE",{});var dF=a(cd);Lm=o(dF,"__call__"),dF.forEach(n),Dm=o(_l," special method."),_l.forEach(n),Nm=p(Ts),F(mo.$$.fragment,Ts),Im=p(Ts),F(go.$$.fragment,Ts),Ts.forEach(n),Ju.forEach(n),ru=p(i),vt=r(i,"H2",{class:!0});var ep=a(vt);_o=r(ep,"A",{id:!0,class:!0,href:!0});var cF=a(_o);ud=r(cF,"SPAN",{});var uF=a(ud);F(gr.$$.fragment,uF),uF.forEach(n),cF.forEach(n),Sm=p(ep),pd=r(ep,"SPAN",{});var pF=a(pd);Bm=o(pF,"FunnelForMaskedLM"),pF.forEach(n),ep.forEach(n),au=p(i),pn=r(i,"DIV",{class:!0});var Hn=a(pn);F(_r.$$.fragment,Hn),Wm=p(Hn),kr=r(Hn,"P",{});var np=a(kr);Qm=o(np,"Funnel Transformer Model with a "),hd=r(np,"CODE",{});var hF=a(hd);Um=o(hF,"language modeling"),hF.forEach(n),Km=o(np," head on top."),np.forEach(n),Rm=p(Hn),Tr=r(Hn,"P",{});var tp=a(Tr);Hm=o(tp,"The Funnel Transformer model was proposed in "),yr=r(tp,"A",{href:!0,rel:!0});var fF=a(yr);Vm=o(fF,`Funnel-Transformer: Filtering out Sequential Redundancy for Efficient
Language Processing`),fF.forEach(n),Ym=o(tp," by Zihang Dai, Guokun Lai, Yiming Yang, Quoc V. Le."),tp.forEach(n),Gm=p(Hn),br=r(Hn,"P",{});var op=a(br);Zm=o(op,"This model inherits from "),Ii=r(op,"A",{href:!0});var mF=a(Ii);Xm=o(mF,"PreTrainedModel"),mF.forEach(n),Jm=o(op,`. 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.)`),op.forEach(n),eg=p(Hn),wr=r(Hn,"P",{});var sp=a(wr);ng=o(sp,"This model is also a PyTorch "),Fr=r(sp,"A",{href:!0,rel:!0});var gF=a(Fr);tg=o(gF,"torch.nn.Module"),gF.forEach(n),og=o(sp,` subclass.
Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
and behavior.`),sp.forEach(n),sg=p(Hn),Dn=r(Hn,"DIV",{class:!0});var ys=a(Dn);F(vr.$$.fragment,ys),rg=p(ys),$t=r(ys,"P",{});var kl=a($t);ag=o(kl,"The "),Si=r(kl,"A",{href:!0});var _F=a(Si);ig=o(_F,"FunnelForMaskedLM"),_F.forEach(n),lg=o(kl," forward method, overrides the "),fd=r(kl,"CODE",{});var kF=a(fd);dg=o(kF,"__call__"),kF.forEach(n),cg=o(kl," special method."),kl.forEach(n),ug=p(ys),F(ko.$$.fragment,ys),pg=p(ys),F(To.$$.fragment,ys),ys.forEach(n),Hn.forEach(n),iu=p(i),Et=r(i,"H2",{class:!0});var rp=a(Et);yo=r(rp,"A",{id:!0,class:!0,href:!0});var TF=a(yo);md=r(TF,"SPAN",{});var yF=a(md);F($r.$$.fragment,yF),yF.forEach(n),TF.forEach(n),hg=p(rp),gd=r(rp,"SPAN",{});var bF=a(gd);fg=o(bF,"FunnelForSequenceClassification"),bF.forEach(n),rp.forEach(n),lu=p(i),hn=r(i,"DIV",{class:!0});var Vn=a(hn);F(Er.$$.fragment,Vn),mg=p(Vn),_d=r(Vn,"P",{});var wF=a(_d);gg=o(wF,`Funnel Transformer Model with a sequence classification/regression head on top (two linear layer on top of the
first timestep of the last hidden state) e.g. for GLUE tasks.`),wF.forEach(n),_g=p(Vn),Mr=r(Vn,"P",{});var ap=a(Mr);kg=o(ap,"The Funnel Transformer model was proposed in "),zr=r(ap,"A",{href:!0,rel:!0});var FF=a(zr);Tg=o(FF,`Funnel-Transformer: Filtering out Sequential Redundancy for Efficient
Language Processing`),FF.forEach(n),yg=o(ap," by Zihang Dai, Guokun Lai, Yiming Yang, Quoc V. Le."),ap.forEach(n),bg=p(Vn),qr=r(Vn,"P",{});var ip=a(qr);wg=o(ip,"This model inherits from "),Bi=r(ip,"A",{href:!0});var vF=a(Bi);Fg=o(vF,"PreTrainedModel"),vF.forEach(n),vg=o(ip,`. 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.)`),ip.forEach(n),$g=p(Vn),Pr=r(Vn,"P",{});var lp=a(Pr);Eg=o(lp,"This model is also a PyTorch "),xr=r(lp,"A",{href:!0,rel:!0});var $F=a(xr);Mg=o($F,"torch.nn.Module"),$F.forEach(n),zg=o(lp,` subclass.
Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
and behavior.`),lp.forEach(n),qg=p(Vn),Tn=r(Vn,"DIV",{class:!0});var st=a(Tn);F(Cr.$$.fragment,st),Pg=p(st),Mt=r(st,"P",{});var Tl=a(Mt);xg=o(Tl,"The "),Wi=r(Tl,"A",{href:!0});var EF=a(Wi);Cg=o(EF,"FunnelForSequenceClassification"),EF.forEach(n),jg=o(Tl," forward method, overrides the "),kd=r(Tl,"CODE",{});var MF=a(kd);Ag=o(MF,"__call__"),MF.forEach(n),Og=o(Tl," special method."),Tl.forEach(n),Lg=p(st),F(bo.$$.fragment,st),Dg=p(st),F(wo.$$.fragment,st),Ng=p(st),F(Fo.$$.fragment,st),st.forEach(n),Vn.forEach(n),du=p(i),zt=r(i,"H2",{class:!0});var dp=a(zt);vo=r(dp,"A",{id:!0,class:!0,href:!0});var zF=a(vo);Td=r(zF,"SPAN",{});var qF=a(Td);F(jr.$$.fragment,qF),qF.forEach(n),zF.forEach(n),Ig=p(dp),yd=r(dp,"SPAN",{});var PF=a(yd);Sg=o(PF,"FunnelForMultipleChoice"),PF.forEach(n),dp.forEach(n),cu=p(i),fn=r(i,"DIV",{class:!0});var Yn=a(fn);F(Ar.$$.fragment,Yn),Bg=p(Yn),bd=r(Yn,"P",{});var xF=a(bd);Wg=o(xF,`Funnel Transformer Model with a multiple choice classification head on top (two linear layer on top of the first
timestep of the last hidden state, and a softmax) e.g. for RocStories/SWAG tasks.`),xF.forEach(n),Qg=p(Yn),Or=r(Yn,"P",{});var cp=a(Or);Ug=o(cp,"The Funnel Transformer model was proposed in "),Lr=r(cp,"A",{href:!0,rel:!0});var CF=a(Lr);Kg=o(CF,`Funnel-Transformer: Filtering out Sequential Redundancy for Efficient
Language Processing`),CF.forEach(n),Rg=o(cp," by Zihang Dai, Guokun Lai, Yiming Yang, Quoc V. Le."),cp.forEach(n),Hg=p(Yn),Dr=r(Yn,"P",{});var up=a(Dr);Vg=o(up,"This model inherits from "),Qi=r(up,"A",{href:!0});var jF=a(Qi);Yg=o(jF,"PreTrainedModel"),jF.forEach(n),Gg=o(up,`. 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.)`),up.forEach(n),Zg=p(Yn),Nr=r(Yn,"P",{});var pp=a(Nr);Xg=o(pp,"This model is also a PyTorch "),Ir=r(pp,"A",{href:!0,rel:!0});var AF=a(Ir);Jg=o(AF,"torch.nn.Module"),AF.forEach(n),e_=o(pp,` subclass.
Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
and behavior.`),pp.forEach(n),n_=p(Yn),Nn=r(Yn,"DIV",{class:!0});var bs=a(Nn);F(Sr.$$.fragment,bs),t_=p(bs),qt=r(bs,"P",{});var yl=a(qt);o_=o(yl,"The "),Ui=r(yl,"A",{href:!0});var OF=a(Ui);s_=o(OF,"FunnelForMultipleChoice"),OF.forEach(n),r_=o(yl," forward method, overrides the "),wd=r(yl,"CODE",{});var LF=a(wd);a_=o(LF,"__call__"),LF.forEach(n),i_=o(yl," special method."),yl.forEach(n),l_=p(bs),F($o.$$.fragment,bs),d_=p(bs),F(Eo.$$.fragment,bs),bs.forEach(n),Yn.forEach(n),uu=p(i),Pt=r(i,"H2",{class:!0});var hp=a(Pt);Mo=r(hp,"A",{id:!0,class:!0,href:!0});var DF=a(Mo);Fd=r(DF,"SPAN",{});var NF=a(Fd);F(Br.$$.fragment,NF),NF.forEach(n),DF.forEach(n),c_=p(hp),vd=r(hp,"SPAN",{});var IF=a(vd);u_=o(IF,"FunnelForTokenClassification"),IF.forEach(n),hp.forEach(n),pu=p(i),mn=r(i,"DIV",{class:!0});var Gn=a(mn);F(Wr.$$.fragment,Gn),p_=p(Gn),$d=r(Gn,"P",{});var SF=a($d);h_=o(SF,`Funnel Transformer Model with a token classification head on top (a linear layer on top of the hidden-states
output) e.g. for Named-Entity-Recognition (NER) tasks.`),SF.forEach(n),f_=p(Gn),Qr=r(Gn,"P",{});var fp=a(Qr);m_=o(fp,"The Funnel Transformer model was proposed in "),Ur=r(fp,"A",{href:!0,rel:!0});var BF=a(Ur);g_=o(BF,`Funnel-Transformer: Filtering out Sequential Redundancy for Efficient
Language Processing`),BF.forEach(n),__=o(fp," by Zihang Dai, Guokun Lai, Yiming Yang, Quoc V. Le."),fp.forEach(n),k_=p(Gn),Kr=r(Gn,"P",{});var mp=a(Kr);T_=o(mp,"This model inherits from "),Ki=r(mp,"A",{href:!0});var WF=a(Ki);y_=o(WF,"PreTrainedModel"),WF.forEach(n),b_=o(mp,`. 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.)`),mp.forEach(n),w_=p(Gn),Rr=r(Gn,"P",{});var gp=a(Rr);F_=o(gp,"This model is also a PyTorch "),Hr=r(gp,"A",{href:!0,rel:!0});var QF=a(Hr);v_=o(QF,"torch.nn.Module"),QF.forEach(n),$_=o(gp,` subclass.
Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
and behavior.`),gp.forEach(n),E_=p(Gn),In=r(Gn,"DIV",{class:!0});var ws=a(In);F(Vr.$$.fragment,ws),M_=p(ws),xt=r(ws,"P",{});var bl=a(xt);z_=o(bl,"The "),Ri=r(bl,"A",{href:!0});var UF=a(Ri);q_=o(UF,"FunnelForTokenClassification"),UF.forEach(n),P_=o(bl," forward method, overrides the "),Ed=r(bl,"CODE",{});var KF=a(Ed);x_=o(KF,"__call__"),KF.forEach(n),C_=o(bl," special method."),bl.forEach(n),j_=p(ws),F(zo.$$.fragment,ws),A_=p(ws),F(qo.$$.fragment,ws),ws.forEach(n),Gn.forEach(n),hu=p(i),Ct=r(i,"H2",{class:!0});var _p=a(Ct);Po=r(_p,"A",{id:!0,class:!0,href:!0});var RF=a(Po);Md=r(RF,"SPAN",{});var HF=a(Md);F(Yr.$$.fragment,HF),HF.forEach(n),RF.forEach(n),O_=p(_p),zd=r(_p,"SPAN",{});var VF=a(zd);L_=o(VF,"FunnelForQuestionAnswering"),VF.forEach(n),_p.forEach(n),fu=p(i),gn=r(i,"DIV",{class:!0});var Zn=a(gn);F(Gr.$$.fragment,Zn),D_=p(Zn),jt=r(Zn,"P",{});var wl=a(jt);N_=o(wl,`Funnel Transformer Model with a span classification head on top for extractive question-answering tasks like SQuAD
(a linear layer on top of the hidden-states output to compute `),qd=r(wl,"CODE",{});var YF=a(qd);I_=o(YF,"span start logits"),YF.forEach(n),S_=o(wl," and "),Pd=r(wl,"CODE",{});var GF=a(Pd);B_=o(GF,"span end logits"),GF.forEach(n),W_=o(wl,")."),wl.forEach(n),Q_=p(Zn),Zr=r(Zn,"P",{});var kp=a(Zr);U_=o(kp,"The Funnel Transformer model was proposed in "),Xr=r(kp,"A",{href:!0,rel:!0});var ZF=a(Xr);K_=o(ZF,`Funnel-Transformer: Filtering out Sequential Redundancy for Efficient
Language Processing`),ZF.forEach(n),R_=o(kp," by Zihang Dai, Guokun Lai, Yiming Yang, Quoc V. Le."),kp.forEach(n),H_=p(Zn),Jr=r(Zn,"P",{});var Tp=a(Jr);V_=o(Tp,"This model inherits from "),Hi=r(Tp,"A",{href:!0});var XF=a(Hi);Y_=o(XF,"PreTrainedModel"),XF.forEach(n),G_=o(Tp,`. 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.)`),Tp.forEach(n),Z_=p(Zn),ea=r(Zn,"P",{});var yp=a(ea);X_=o(yp,"This model is also a PyTorch "),na=r(yp,"A",{href:!0,rel:!0});var JF=a(na);J_=o(JF,"torch.nn.Module"),JF.forEach(n),ek=o(yp,` subclass.
Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
and behavior.`),yp.forEach(n),nk=p(Zn),Sn=r(Zn,"DIV",{class:!0});var Fs=a(Sn);F(ta.$$.fragment,Fs),tk=p(Fs),At=r(Fs,"P",{});var Fl=a(At);ok=o(Fl,"The "),Vi=r(Fl,"A",{href:!0});var ev=a(Vi);sk=o(ev,"FunnelForQuestionAnswering"),ev.forEach(n),rk=o(Fl," forward method, overrides the "),xd=r(Fl,"CODE",{});var nv=a(xd);ak=o(nv,"__call__"),nv.forEach(n),ik=o(Fl," special method."),Fl.forEach(n),lk=p(Fs),F(xo.$$.fragment,Fs),dk=p(Fs),F(Co.$$.fragment,Fs),Fs.forEach(n),Zn.forEach(n),mu=p(i),Ot=r(i,"H2",{class:!0});var bp=a(Ot);jo=r(bp,"A",{id:!0,class:!0,href:!0});var tv=a(jo);Cd=r(tv,"SPAN",{});var ov=a(Cd);F(oa.$$.fragment,ov),ov.forEach(n),tv.forEach(n),ck=p(bp),jd=r(bp,"SPAN",{});var sv=a(jd);uk=o(sv,"TFFunnelBaseModel"),sv.forEach(n),bp.forEach(n),gu=p(i),nn=r(i,"DIV",{class:!0});var vn=a(nn);F(sa.$$.fragment,vn),pk=p(vn),Ad=r(vn,"P",{});var rv=a(Ad);hk=o(rv,`The base Funnel Transformer Model transformer outputting raw hidden-states without upsampling head (also called
decoder) or any task-specific head on top.`),rv.forEach(n),fk=p(vn),ra=r(vn,"P",{});var wp=a(ra);mk=o(wp,"The Funnel Transformer model was proposed in "),aa=r(wp,"A",{href:!0,rel:!0});var av=a(aa);gk=o(av,`Funnel-Transformer: Filtering out Sequential Redundancy for Efficient
Language Processing`),av.forEach(n),_k=o(wp," by Zihang Dai, Guokun Lai, Yiming Yang, Quoc V. Le."),wp.forEach(n),kk=p(vn),ia=r(vn,"P",{});var Fp=a(ia);Tk=o(Fp,"This model inherits from "),Yi=r(Fp,"A",{href:!0});var iv=a(Yi);yk=o(iv,"TFPreTrainedModel"),iv.forEach(n),bk=o(Fp,`. 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.)`),Fp.forEach(n),wk=p(vn),la=r(vn,"P",{});var vp=a(la);Fk=o(vp,"This model is also a "),da=r(vp,"A",{href:!0,rel:!0});var lv=a(da);vk=o(lv,"tf.keras.Model"),lv.forEach(n),$k=o(vp,` subclass. Use it
as a regular TF 2.0 Keras Model and refer to the TF 2.0 documentation for all matter related to general usage and
behavior.`),vp.forEach(n),Ek=p(vn),F(Ao.$$.fragment,vn),Mk=p(vn),Bn=r(vn,"DIV",{class:!0});var vs=a(Bn);F(ca.$$.fragment,vs),zk=p(vs),Lt=r(vs,"P",{});var vl=a(Lt);qk=o(vl,"The "),Gi=r(vl,"A",{href:!0});var dv=a(Gi);Pk=o(dv,"TFFunnelBaseModel"),dv.forEach(n),xk=o(vl," forward method, overrides the "),Od=r(vl,"CODE",{});var cv=a(Od);Ck=o(cv,"__call__"),cv.forEach(n),jk=o(vl," special method."),vl.forEach(n),Ak=p(vs),F(Oo.$$.fragment,vs),Ok=p(vs),F(Lo.$$.fragment,vs),vs.forEach(n),vn.forEach(n),_u=p(i),Dt=r(i,"H2",{class:!0});var $p=a(Dt);Do=r($p,"A",{id:!0,class:!0,href:!0});var uv=a(Do);Ld=r(uv,"SPAN",{});var pv=a(Ld);F(ua.$$.fragment,pv),pv.forEach(n),uv.forEach(n),Lk=p($p),Dd=r($p,"SPAN",{});var hv=a(Dd);Dk=o(hv,"TFFunnelModel"),hv.forEach(n),$p.forEach(n),ku=p(i),tn=r(i,"DIV",{class:!0});var $n=a(tn);F(pa.$$.fragment,$n),Nk=p($n),Nd=r($n,"P",{});var fv=a(Nd);Ik=o(fv,"The bare Funnel Transformer Model transformer outputting raw hidden-states without any specific head on top."),fv.forEach(n),Sk=p($n),ha=r($n,"P",{});var Ep=a(ha);Bk=o(Ep,"The Funnel Transformer model was proposed in "),fa=r(Ep,"A",{href:!0,rel:!0});var mv=a(fa);Wk=o(mv,`Funnel-Transformer: Filtering out Sequential Redundancy for Efficient
Language Processing`),mv.forEach(n),Qk=o(Ep," by Zihang Dai, Guokun Lai, Yiming Yang, Quoc V. Le."),Ep.forEach(n),Uk=p($n),ma=r($n,"P",{});var Mp=a(ma);Kk=o(Mp,"This model inherits from "),Zi=r(Mp,"A",{href:!0});var gv=a(Zi);Rk=o(gv,"TFPreTrainedModel"),gv.forEach(n),Hk=o(Mp,`. 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.)`),Mp.forEach(n),Vk=p($n),ga=r($n,"P",{});var zp=a(ga);Yk=o(zp,"This model is also a "),_a=r(zp,"A",{href:!0,rel:!0});var _v=a(_a);Gk=o(_v,"tf.keras.Model"),_v.forEach(n),Zk=o(zp,` subclass. Use it
as a regular TF 2.0 Keras Model and refer to the TF 2.0 documentation for all matter related to general usage and
behavior.`),zp.forEach(n),Xk=p($n),F(No.$$.fragment,$n),Jk=p($n),Wn=r($n,"DIV",{class:!0});var $s=a(Wn);F(ka.$$.fragment,$s),eT=p($s),Nt=r($s,"P",{});var $l=a(Nt);nT=o($l,"The "),Xi=r($l,"A",{href:!0});var kv=a(Xi);tT=o(kv,"TFFunnelModel"),kv.forEach(n),oT=o($l," forward method, overrides the "),Id=r($l,"CODE",{});var Tv=a(Id);sT=o(Tv,"__call__"),Tv.forEach(n),rT=o($l," special method."),$l.forEach(n),aT=p($s),F(Io.$$.fragment,$s),iT=p($s),F(So.$$.fragment,$s),$s.forEach(n),$n.forEach(n),Tu=p(i),It=r(i,"H2",{class:!0});var qp=a(It);Bo=r(qp,"A",{id:!0,class:!0,href:!0});var yv=a(Bo);Sd=r(yv,"SPAN",{});var bv=a(Sd);F(Ta.$$.fragment,bv),bv.forEach(n),yv.forEach(n),lT=p(qp),Bd=r(qp,"SPAN",{});var wv=a(Bd);dT=o(wv,"TFFunnelModelForPreTraining"),wv.forEach(n),qp.forEach(n),yu=p(i),on=r(i,"DIV",{class:!0});var En=a(on);F(ya.$$.fragment,En),cT=p(En),Wd=r(En,"P",{});var Fv=a(Wd);uT=o(Fv,"Funnel model with a binary classification head on top as used during pretraining for identifying generated tokens."),Fv.forEach(n),pT=p(En),ba=r(En,"P",{});var Pp=a(ba);hT=o(Pp,"The Funnel Transformer model was proposed in "),wa=r(Pp,"A",{href:!0,rel:!0});var vv=a(wa);fT=o(vv,`Funnel-Transformer: Filtering out Sequential Redundancy for Efficient
Language Processing`),vv.forEach(n),mT=o(Pp," by Zihang Dai, Guokun Lai, Yiming Yang, Quoc V. Le."),Pp.forEach(n),gT=p(En),Fa=r(En,"P",{});var xp=a(Fa);_T=o(xp,"This model inherits from "),Ji=r(xp,"A",{href:!0});var $v=a(Ji);kT=o($v,"TFPreTrainedModel"),$v.forEach(n),TT=o(xp,`. 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.)`),xp.forEach(n),yT=p(En),va=r(En,"P",{});var Cp=a(va);bT=o(Cp,"This model is also a "),$a=r(Cp,"A",{href:!0,rel:!0});var Ev=a($a);wT=o(Ev,"tf.keras.Model"),Ev.forEach(n),FT=o(Cp,` subclass. Use it
as a regular TF 2.0 Keras Model and refer to the TF 2.0 documentation for all matter related to general usage and
behavior.`),Cp.forEach(n),vT=p(En),F(Wo.$$.fragment,En),$T=p(En),Qn=r(En,"DIV",{class:!0});var Es=a(Qn);F(Ea.$$.fragment,Es),ET=p(Es),St=r(Es,"P",{});var El=a(St);MT=o(El,"The "),el=r(El,"A",{href:!0});var Mv=a(el);zT=o(Mv,"TFFunnelForPreTraining"),Mv.forEach(n),qT=o(El," forward method, overrides the "),Qd=r(El,"CODE",{});var zv=a(Qd);PT=o(zv,"__call__"),zv.forEach(n),xT=o(El," special method."),El.forEach(n),CT=p(Es),F(Qo.$$.fragment,Es),jT=p(Es),F(Uo.$$.fragment,Es),Es.forEach(n),En.forEach(n),bu=p(i),Bt=r(i,"H2",{class:!0});var jp=a(Bt);Ko=r(jp,"A",{id:!0,class:!0,href:!0});var qv=a(Ko);Ud=r(qv,"SPAN",{});var Pv=a(Ud);F(Ma.$$.fragment,Pv),Pv.forEach(n),qv.forEach(n),AT=p(jp),Kd=r(jp,"SPAN",{});var xv=a(Kd);OT=o(xv,"TFFunnelForMaskedLM"),xv.forEach(n),jp.forEach(n),wu=p(i),sn=r(i,"DIV",{class:!0});var Mn=a(sn);F(za.$$.fragment,Mn),LT=p(Mn),qa=r(Mn,"P",{});var Ap=a(qa);DT=o(Ap,"Funnel Model with a "),Rd=r(Ap,"CODE",{});var Cv=a(Rd);NT=o(Cv,"language modeling"),Cv.forEach(n),IT=o(Ap," head on top."),Ap.forEach(n),ST=p(Mn),Pa=r(Mn,"P",{});var Op=a(Pa);BT=o(Op,"The Funnel Transformer model was proposed in "),xa=r(Op,"A",{href:!0,rel:!0});var jv=a(xa);WT=o(jv,`Funnel-Transformer: Filtering out Sequential Redundancy for Efficient
Language Processing`),jv.forEach(n),QT=o(Op," by Zihang Dai, Guokun Lai, Yiming Yang, Quoc V. Le."),Op.forEach(n),UT=p(Mn),Ca=r(Mn,"P",{});var Lp=a(Ca);KT=o(Lp,"This model inherits from "),nl=r(Lp,"A",{href:!0});var Av=a(nl);RT=o(Av,"TFPreTrainedModel"),Av.forEach(n),HT=o(Lp,`. 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.)`),Lp.forEach(n),VT=p(Mn),ja=r(Mn,"P",{});var Dp=a(ja);YT=o(Dp,"This model is also a "),Aa=r(Dp,"A",{href:!0,rel:!0});var Ov=a(Aa);GT=o(Ov,"tf.keras.Model"),Ov.forEach(n),ZT=o(Dp,` subclass. Use it
as a regular TF 2.0 Keras Model and refer to the TF 2.0 documentation for all matter related to general usage and
behavior.`),Dp.forEach(n),XT=p(Mn),F(Ro.$$.fragment,Mn),JT=p(Mn),yn=r(Mn,"DIV",{class:!0});var rt=a(yn);F(Oa.$$.fragment,rt),ey=p(rt),Wt=r(rt,"P",{});var Ml=a(Wt);ny=o(Ml,"The "),tl=r(Ml,"A",{href:!0});var Lv=a(tl);ty=o(Lv,"TFFunnelForMaskedLM"),Lv.forEach(n),oy=o(Ml," forward method, overrides the "),Hd=r(Ml,"CODE",{});var Dv=a(Hd);sy=o(Dv,"__call__"),Dv.forEach(n),ry=o(Ml," special method."),Ml.forEach(n),ay=p(rt),F(Ho.$$.fragment,rt),iy=p(rt),F(Vo.$$.fragment,rt),ly=p(rt),F(Yo.$$.fragment,rt),rt.forEach(n),Mn.forEach(n),Fu=p(i),Qt=r(i,"H2",{class:!0});var Np=a(Qt);Go=r(Np,"A",{id:!0,class:!0,href:!0});var Nv=a(Go);Vd=r(Nv,"SPAN",{});var Iv=a(Vd);F(La.$$.fragment,Iv),Iv.forEach(n),Nv.forEach(n),dy=p(Np),Yd=r(Np,"SPAN",{});var Sv=a(Yd);cy=o(Sv,"TFFunnelForSequenceClassification"),Sv.forEach(n),Np.forEach(n),vu=p(i),rn=r(i,"DIV",{class:!0});var zn=a(rn);F(Da.$$.fragment,zn),uy=p(zn),Gd=r(zn,"P",{});var Bv=a(Gd);py=o(Bv,`Funnel Model transformer with a sequence classification/regression head on top (a linear layer on top of the pooled
output) e.g. for GLUE tasks.`),Bv.forEach(n),hy=p(zn),Na=r(zn,"P",{});var Ip=a(Na);fy=o(Ip,"The Funnel Transformer model was proposed in "),Ia=r(Ip,"A",{href:!0,rel:!0});var Wv=a(Ia);my=o(Wv,`Funnel-Transformer: Filtering out Sequential Redundancy for Efficient
Language Processing`),Wv.forEach(n),gy=o(Ip," by Zihang Dai, Guokun Lai, Yiming Yang, Quoc V. Le."),Ip.forEach(n),_y=p(zn),Sa=r(zn,"P",{});var Sp=a(Sa);ky=o(Sp,"This model inherits from "),ol=r(Sp,"A",{href:!0});var Qv=a(ol);Ty=o(Qv,"TFPreTrainedModel"),Qv.forEach(n),yy=o(Sp,`. 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.)`),Sp.forEach(n),by=p(zn),Ba=r(zn,"P",{});var Bp=a(Ba);wy=o(Bp,"This model is also a "),Wa=r(Bp,"A",{href:!0,rel:!0});var Uv=a(Wa);Fy=o(Uv,"tf.keras.Model"),Uv.forEach(n),vy=o(Bp,` subclass. Use it
as a regular TF 2.0 Keras Model and refer to the TF 2.0 documentation for all matter related to general usage and
behavior.`),Bp.forEach(n),$y=p(zn),F(Zo.$$.fragment,zn),Ey=p(zn),bn=r(zn,"DIV",{class:!0});var at=a(bn);F(Qa.$$.fragment,at),My=p(at),Ut=r(at,"P",{});var zl=a(Ut);zy=o(zl,"The "),sl=r(zl,"A",{href:!0});var Kv=a(sl);qy=o(Kv,"TFFunnelForSequenceClassification"),Kv.forEach(n),Py=o(zl," forward method, overrides the "),Zd=r(zl,"CODE",{});var Rv=a(Zd);xy=o(Rv,"__call__"),Rv.forEach(n),Cy=o(zl," special method."),zl.forEach(n),jy=p(at),F(Xo.$$.fragment,at),Ay=p(at),F(Jo.$$.fragment,at),Oy=p(at),F(es.$$.fragment,at),at.forEach(n),zn.forEach(n),$u=p(i),Kt=r(i,"H2",{class:!0});var Wp=a(Kt);ns=r(Wp,"A",{id:!0,class:!0,href:!0});var Hv=a(ns);Xd=r(Hv,"SPAN",{});var Vv=a(Xd);F(Ua.$$.fragment,Vv),Vv.forEach(n),Hv.forEach(n),Ly=p(Wp),Jd=r(Wp,"SPAN",{});var Yv=a(Jd);Dy=o(Yv,"TFFunnelForMultipleChoice"),Yv.forEach(n),Wp.forEach(n),Eu=p(i),an=r(i,"DIV",{class:!0});var qn=a(an);F(Ka.$$.fragment,qn),Ny=p(qn),ec=r(qn,"P",{});var Gv=a(ec);Iy=o(Gv,`Funnel Model with a multiple choice classification head on top (a linear layer on top of the pooled output and a
softmax) e.g. for RocStories/SWAG tasks.`),Gv.forEach(n),Sy=p(qn),Ra=r(qn,"P",{});var Qp=a(Ra);By=o(Qp,"The Funnel Transformer model was proposed in "),Ha=r(Qp,"A",{href:!0,rel:!0});var Zv=a(Ha);Wy=o(Zv,`Funnel-Transformer: Filtering out Sequential Redundancy for Efficient
Language Processing`),Zv.forEach(n),Qy=o(Qp," by Zihang Dai, Guokun Lai, Yiming Yang, Quoc V. Le."),Qp.forEach(n),Uy=p(qn),Va=r(qn,"P",{});var Up=a(Va);Ky=o(Up,"This model inherits from "),rl=r(Up,"A",{href:!0});var Xv=a(rl);Ry=o(Xv,"TFPreTrainedModel"),Xv.forEach(n),Hy=o(Up,`. 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.)`),Up.forEach(n),Vy=p(qn),Ya=r(qn,"P",{});var Kp=a(Ya);Yy=o(Kp,"This model is also a "),Ga=r(Kp,"A",{href:!0,rel:!0});var Jv=a(Ga);Gy=o(Jv,"tf.keras.Model"),Jv.forEach(n),Zy=o(Kp,` subclass. Use it
as a regular TF 2.0 Keras Model and refer to the TF 2.0 documentation for all matter related to general usage and
behavior.`),Kp.forEach(n),Xy=p(qn),F(ts.$$.fragment,qn),Jy=p(qn),Un=r(qn,"DIV",{class:!0});var Ms=a(Un);F(Za.$$.fragment,Ms),eb=p(Ms),Rt=r(Ms,"P",{});var ql=a(Rt);nb=o(ql,"The "),al=r(ql,"A",{href:!0});var e$=a(al);tb=o(e$,"TFFunnelForMultipleChoice"),e$.forEach(n),ob=o(ql," forward method, overrides the "),nc=r(ql,"CODE",{});var n$=a(nc);sb=o(n$,"__call__"),n$.forEach(n),rb=o(ql," special method."),ql.forEach(n),ab=p(Ms),F(os.$$.fragment,Ms),ib=p(Ms),F(ss.$$.fragment,Ms),Ms.forEach(n),qn.forEach(n),Mu=p(i),Ht=r(i,"H2",{class:!0});var Rp=a(Ht);rs=r(Rp,"A",{id:!0,class:!0,href:!0});var t$=a(rs);tc=r(t$,"SPAN",{});var o$=a(tc);F(Xa.$$.fragment,o$),o$.forEach(n),t$.forEach(n),lb=p(Rp),oc=r(Rp,"SPAN",{});var s$=a(oc);db=o(s$,"TFFunnelForTokenClassification"),s$.forEach(n),Rp.forEach(n),zu=p(i),ln=r(i,"DIV",{class:!0});var Pn=a(ln);F(Ja.$$.fragment,Pn),cb=p(Pn),sc=r(Pn,"P",{});var r$=a(sc);ub=o(r$,`Funnel Model with a token classification head on top (a linear layer on top of the hidden-states output) e.g. for
Named-Entity-Recognition (NER) tasks.`),r$.forEach(n),pb=p(Pn),ei=r(Pn,"P",{});var Hp=a(ei);hb=o(Hp,"The Funnel Transformer model was proposed in "),ni=r(Hp,"A",{href:!0,rel:!0});var a$=a(ni);fb=o(a$,`Funnel-Transformer: Filtering out Sequential Redundancy for Efficient
Language Processing`),a$.forEach(n),mb=o(Hp," by Zihang Dai, Guokun Lai, Yiming Yang, Quoc V. Le."),Hp.forEach(n),gb=p(Pn),ti=r(Pn,"P",{});var Vp=a(ti);_b=o(Vp,"This model inherits from "),il=r(Vp,"A",{href:!0});var i$=a(il);kb=o(i$,"TFPreTrainedModel"),i$.forEach(n),Tb=o(Vp,`. 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.)`),Vp.forEach(n),yb=p(Pn),oi=r(Pn,"P",{});var Yp=a(oi);bb=o(Yp,"This model is also a "),si=r(Yp,"A",{href:!0,rel:!0});var l$=a(si);wb=o(l$,"tf.keras.Model"),l$.forEach(n),Fb=o(Yp,` subclass. Use it
as a regular TF 2.0 Keras Model and refer to the TF 2.0 documentation for all matter related to general usage and
behavior.`),Yp.forEach(n),vb=p(Pn),F(as.$$.fragment,Pn),$b=p(Pn),wn=r(Pn,"DIV",{class:!0});var it=a(wn);F(ri.$$.fragment,it),Eb=p(it),Vt=r(it,"P",{});var Pl=a(Vt);Mb=o(Pl,"The "),ll=r(Pl,"A",{href:!0});var d$=a(ll);zb=o(d$,"TFFunnelForTokenClassification"),d$.forEach(n),qb=o(Pl," forward method, overrides the "),rc=r(Pl,"CODE",{});var c$=a(rc);Pb=o(c$,"__call__"),c$.forEach(n),xb=o(Pl," special method."),Pl.forEach(n),Cb=p(it),F(is.$$.fragment,it),jb=p(it),F(ls.$$.fragment,it),Ab=p(it),F(ds.$$.fragment,it),it.forEach(n),Pn.forEach(n),qu=p(i),Yt=r(i,"H2",{class:!0});var Gp=a(Yt);cs=r(Gp,"A",{id:!0,class:!0,href:!0});var u$=a(cs);ac=r(u$,"SPAN",{});var p$=a(ac);F(ai.$$.fragment,p$),p$.forEach(n),u$.forEach(n),Ob=p(Gp),ic=r(Gp,"SPAN",{});var h$=a(ic);Lb=o(h$,"TFFunnelForQuestionAnswering"),h$.forEach(n),Gp.forEach(n),Pu=p(i),dn=r(i,"DIV",{class:!0});var xn=a(dn);F(ii.$$.fragment,xn),Db=p(xn),Gt=r(xn,"P",{});var xl=a(Gt);Nb=o(xl,`Funnel Model with a span classification head on top for extractive question-answering tasks like SQuAD (a linear
layers on top of the hidden-states output to compute `),lc=r(xl,"CODE",{});var f$=a(lc);Ib=o(f$,"span start logits"),f$.forEach(n),Sb=o(xl," and "),dc=r(xl,"CODE",{});var m$=a(dc);Bb=o(m$,"span end logits"),m$.forEach(n),Wb=o(xl,")."),xl.forEach(n),Qb=p(xn),li=r(xn,"P",{});var Zp=a(li);Ub=o(Zp,"The Funnel Transformer model was proposed in "),di=r(Zp,"A",{href:!0,rel:!0});var g$=a(di);Kb=o(g$,`Funnel-Transformer: Filtering out Sequential Redundancy for Efficient
Language Processing`),g$.forEach(n),Rb=o(Zp," by Zihang Dai, Guokun Lai, Yiming Yang, Quoc V. Le."),Zp.forEach(n),Hb=p(xn),ci=r(xn,"P",{});var Xp=a(ci);Vb=o(Xp,"This model inherits from "),dl=r(Xp,"A",{href:!0});var _$=a(dl);Yb=o(_$,"TFPreTrainedModel"),_$.forEach(n),Gb=o(Xp,`. 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.)`),Xp.forEach(n),Zb=p(xn),ui=r(xn,"P",{});var Jp=a(ui);Xb=o(Jp,"This model is also a "),pi=r(Jp,"A",{href:!0,rel:!0});var k$=a(pi);Jb=o(k$,"tf.keras.Model"),k$.forEach(n),ew=o(Jp,` subclass. Use it
as a regular TF 2.0 Keras Model and refer to the TF 2.0 documentation for all matter related to general usage and
behavior.`),Jp.forEach(n),nw=p(xn),F(us.$$.fragment,xn),tw=p(xn),Fn=r(xn,"DIV",{class:!0});var lt=a(Fn);F(hi.$$.fragment,lt),ow=p(lt),Zt=r(lt,"P",{});var Cl=a(Zt);sw=o(Cl,"The "),cl=r(Cl,"A",{href:!0});var T$=a(cl);rw=o(T$,"TFFunnelForQuestionAnswering"),T$.forEach(n),aw=o(Cl," forward method, overrides the "),cc=r(Cl,"CODE",{});var y$=a(cc);iw=o(y$,"__call__"),y$.forEach(n),lw=o(Cl," special method."),Cl.forEach(n),dw=p(lt),F(ps.$$.fragment,lt),cw=p(lt),F(hs.$$.fragment,lt),uw=p(lt),F(fs.$$.fragment,lt),lt.forEach(n),xn.forEach(n),this.h()},h(){m(d,"name","hf:doc:metadata"),m(d,"content",JSON.stringify(y1)),m(f,"id","funnel-transformer"),m(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"),m(f,"href","#funnel-transformer"),m(h,"class","relative group"),m(re,"id","overview"),m(re,"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"),m(re,"href","#overview"),m(I,"class","relative group"),m(ae,"href","https://arxiv.org/abs/2006.03236"),m(ae,"rel","nofollow"),m(j,"href","/docs/transformers/main/en/model_doc/funnel#transformers.FunnelModel"),m(le,"href","/docs/transformers/main/en/model_doc/funnel#transformers.FunnelForPreTraining"),m(de,"href","/docs/transformers/main/en/model_doc/funnel#transformers.FunnelForMaskedLM"),m(ce,"href","/docs/transformers/main/en/model_doc/funnel#transformers.FunnelForTokenClassification"),m(L,"href","/docs/transformers/main/en/model_doc/funnel#transformers.FunnelBaseModel"),m(g,"href","/docs/transformers/main/en/model_doc/funnel#transformers.FunnelForSequenceClassification"),m(J,"href","/docs/transformers/main/en/model_doc/funnel#transformers.FunnelForMultipleChoice"),m(Le,"href","https://huggingface.co/sgugger"),m(Le,"rel","nofollow"),m(D,"href","https://github.com/laiguokun/Funnel-Transformer"),m(D,"rel","nofollow"),m(Oe,"id","transformers.FunnelConfig"),m(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"),m(Oe,"href","#transformers.FunnelConfig"),m(S,"class","relative group"),m(bi,"href","/docs/transformers/main/en/model_doc/funnel#transformers.FunnelModel"),m(wi,"href","/docs/transformers/main/en/model_doc/bert#transformers.TFBertModel"),m(qs,"href","https://huggingface.co/funnel-transformer/small"),m(qs,"rel","nofollow"),m(Fi,"href","/docs/transformers/main/en/main_classes/configuration#transformers.PretrainedConfig"),m(vi,"href","/docs/transformers/main/en/main_classes/configuration#transformers.PretrainedConfig"),m(Xn,"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,"id","transformers.FunnelTokenizer"),m(no,"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"),m(no,"href","#transformers.FunnelTokenizer"),m(ct,"class","relative group"),m($i,"href","/docs/transformers/main/en/main_classes/tokenizer#transformers.PreTrainedTokenizer"),m(nt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),m(to,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),m(Cn,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),m(zi,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),m(en,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),m(so,"id","transformers.FunnelTokenizerFast"),m(so,"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"),m(so,"href","#transformers.FunnelTokenizerFast"),m(pt,"class","relative group"),m(qi,"href","/docs/transformers/main/en/main_classes/tokenizer#transformers.PreTrainedTokenizerFast"),m(tt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),m(jn,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),m(kn,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),m(ao,"id","transformers.models.funnel.modeling_funnel.FunnelForPreTrainingOutput"),m(ao,"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"),m(ao,"href","#transformers.models.funnel.modeling_funnel.FunnelForPreTrainingOutput"),m(ft,"class","relative group"),m(Ci,"href","/docs/transformers/main/en/model_doc/funnel#transformers.FunnelForPreTraining"),m(mt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),m(ji,"href","/docs/transformers/main/en/model_doc/funnel#transformers.FunnelForPreTraining"),m(gt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),m(io,"id","transformers.FunnelBaseModel"),m(io,"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"),m(io,"href","#transformers.FunnelBaseModel"),m(_t,"class","relative group"),m(er,"href","https://arxiv.org/abs/2006.03236"),m(er,"rel","nofollow"),m(Ai,"href","/docs/transformers/main/en/main_classes/model#transformers.PreTrainedModel"),m(or,"href","https://pytorch.org/docs/stable/nn.html#torch.nn.Module"),m(or,"rel","nofollow"),m(Oi,"href","/docs/transformers/main/en/model_doc/funnel#transformers.FunnelBaseModel"),m(An,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),m(cn,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),m(uo,"id","transformers.FunnelModel"),m(uo,"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"),m(uo,"href","#transformers.FunnelModel"),m(Tt,"class","relative group"),m(lr,"href","https://arxiv.org/abs/2006.03236"),m(lr,"rel","nofollow"),m(Li,"href","/docs/transformers/main/en/main_classes/model#transformers.PreTrainedModel"),m(ur,"href","https://pytorch.org/docs/stable/nn.html#torch.nn.Module"),m(ur,"rel","nofollow"),m(Di,"href","/docs/transformers/main/en/model_doc/funnel#transformers.FunnelModel"),m(On,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),m(un,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),m(fo,"id","transformers.FunnelForPreTraining"),m(fo,"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"),m(fo,"href","#transformers.FunnelForPreTraining"),m(bt,"class","relative group"),m(Ni,"href","/docs/transformers/main/en/model_doc/funnel#transformers.FunnelForPreTraining"),m(Ln,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),m(wt,"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,"id","transformers.FunnelForMaskedLM"),m(_o,"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"),m(_o,"href","#transformers.FunnelForMaskedLM"),m(vt,"class","relative group"),m(yr,"href","https://arxiv.org/abs/2006.03236"),m(yr,"rel","nofollow"),m(Ii,"href","/docs/transformers/main/en/main_classes/model#transformers.PreTrainedModel"),m(Fr,"href","https://pytorch.org/docs/stable/nn.html#torch.nn.Module"),m(Fr,"rel","nofollow"),m(Si,"href","/docs/transformers/main/en/model_doc/funnel#transformers.FunnelForMaskedLM"),m(Dn,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),m(pn,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),m(yo,"id","transformers.FunnelForSequenceClassification"),m(yo,"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"),m(yo,"href","#transformers.FunnelForSequenceClassification"),m(Et,"class","relative group"),m(zr,"href","https://arxiv.org/abs/2006.03236"),m(zr,"rel","nofollow"),m(Bi,"href","/docs/transformers/main/en/main_classes/model#transformers.PreTrainedModel"),m(xr,"href","https://pytorch.org/docs/stable/nn.html#torch.nn.Module"),m(xr,"rel","nofollow"),m(Wi,"href","/docs/transformers/main/en/model_doc/funnel#transformers.FunnelForSequenceClassification"),m(Tn,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),m(hn,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),m(vo,"id","transformers.FunnelForMultipleChoice"),m(vo,"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"),m(vo,"href","#transformers.FunnelForMultipleChoice"),m(zt,"class","relative group"),m(Lr,"href","https://arxiv.org/abs/2006.03236"),m(Lr,"rel","nofollow"),m(Qi,"href","/docs/transformers/main/en/main_classes/model#transformers.PreTrainedModel"),m(Ir,"href","https://pytorch.org/docs/stable/nn.html#torch.nn.Module"),m(Ir,"rel","nofollow"),m(Ui,"href","/docs/transformers/main/en/model_doc/funnel#transformers.FunnelForMultipleChoice"),m(Nn,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),m(fn,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),m(Mo,"id","transformers.FunnelForTokenClassification"),m(Mo,"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"),m(Mo,"href","#transformers.FunnelForTokenClassification"),m(Pt,"class","relative group"),m(Ur,"href","https://arxiv.org/abs/2006.03236"),m(Ur,"rel","nofollow"),m(Ki,"href","/docs/transformers/main/en/main_classes/model#transformers.PreTrainedModel"),m(Hr,"href","https://pytorch.org/docs/stable/nn.html#torch.nn.Module"),m(Hr,"rel","nofollow"),m(Ri,"href","/docs/transformers/main/en/model_doc/funnel#transformers.FunnelForTokenClassification"),m(In,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),m(mn,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),m(Po,"id","transformers.FunnelForQuestionAnswering"),m(Po,"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"),m(Po,"href","#transformers.FunnelForQuestionAnswering"),m(Ct,"class","relative group"),m(Xr,"href","https://arxiv.org/abs/2006.03236"),m(Xr,"rel","nofollow"),m(Hi,"href","/docs/transformers/main/en/main_classes/model#transformers.PreTrainedModel"),m(na,"href","https://pytorch.org/docs/stable/nn.html#torch.nn.Module"),m(na,"rel","nofollow"),m(Vi,"href","/docs/transformers/main/en/model_doc/funnel#transformers.FunnelForQuestionAnswering"),m(Sn,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),m(gn,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),m(jo,"id","transformers.TFFunnelBaseModel"),m(jo,"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"),m(jo,"href","#transformers.TFFunnelBaseModel"),m(Ot,"class","relative group"),m(aa,"href","https://arxiv.org/abs/2006.03236"),m(aa,"rel","nofollow"),m(Yi,"href","/docs/transformers/main/en/main_classes/model#transformers.TFPreTrainedModel"),m(da,"href","https://www.tensorflow.org/api_docs/python/tf/keras/Model"),m(da,"rel","nofollow"),m(Gi,"href","/docs/transformers/main/en/model_doc/funnel#transformers.TFFunnelBaseModel"),m(Bn,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),m(nn,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),m(Do,"id","transformers.TFFunnelModel"),m(Do,"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"),m(Do,"href","#transformers.TFFunnelModel"),m(Dt,"class","relative group"),m(fa,"href","https://arxiv.org/abs/2006.03236"),m(fa,"rel","nofollow"),m(Zi,"href","/docs/transformers/main/en/main_classes/model#transformers.TFPreTrainedModel"),m(_a,"href","https://www.tensorflow.org/api_docs/python/tf/keras/Model"),m(_a,"rel","nofollow"),m(Xi,"href","/docs/transformers/main/en/model_doc/funnel#transformers.TFFunnelModel"),m(Wn,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),m(tn,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),m(Bo,"id","transformers.TFFunnelForPreTraining"),m(Bo,"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"),m(Bo,"href","#transformers.TFFunnelForPreTraining"),m(It,"class","relative group"),m(wa,"href","https://arxiv.org/abs/2006.03236"),m(wa,"rel","nofollow"),m(Ji,"href","/docs/transformers/main/en/main_classes/model#transformers.TFPreTrainedModel"),m($a,"href","https://www.tensorflow.org/api_docs/python/tf/keras/Model"),m($a,"rel","nofollow"),m(el,"href","/docs/transformers/main/en/model_doc/funnel#transformers.TFFunnelForPreTraining"),m(Qn,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),m(on,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),m(Ko,"id","transformers.TFFunnelForMaskedLM"),m(Ko,"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"),m(Ko,"href","#transformers.TFFunnelForMaskedLM"),m(Bt,"class","relative group"),m(xa,"href","https://arxiv.org/abs/2006.03236"),m(xa,"rel","nofollow"),m(nl,"href","/docs/transformers/main/en/main_classes/model#transformers.TFPreTrainedModel"),m(Aa,"href","https://www.tensorflow.org/api_docs/python/tf/keras/Model"),m(Aa,"rel","nofollow"),m(tl,"href","/docs/transformers/main/en/model_doc/funnel#transformers.TFFunnelForMaskedLM"),m(yn,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),m(sn,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),m(Go,"id","transformers.TFFunnelForSequenceClassification"),m(Go,"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"),m(Go,"href","#transformers.TFFunnelForSequenceClassification"),m(Qt,"class","relative group"),m(Ia,"href","https://arxiv.org/abs/2006.03236"),m(Ia,"rel","nofollow"),m(ol,"href","/docs/transformers/main/en/main_classes/model#transformers.TFPreTrainedModel"),m(Wa,"href","https://www.tensorflow.org/api_docs/python/tf/keras/Model"),m(Wa,"rel","nofollow"),m(sl,"href","/docs/transformers/main/en/model_doc/funnel#transformers.TFFunnelForSequenceClassification"),m(bn,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),m(rn,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),m(ns,"id","transformers.TFFunnelForMultipleChoice"),m(ns,"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"),m(ns,"href","#transformers.TFFunnelForMultipleChoice"),m(Kt,"class","relative group"),m(Ha,"href","https://arxiv.org/abs/2006.03236"),m(Ha,"rel","nofollow"),m(rl,"href","/docs/transformers/main/en/main_classes/model#transformers.TFPreTrainedModel"),m(Ga,"href","https://www.tensorflow.org/api_docs/python/tf/keras/Model"),m(Ga,"rel","nofollow"),m(al,"href","/docs/transformers/main/en/model_doc/funnel#transformers.TFFunnelForMultipleChoice"),m(Un,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),m(an,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),m(rs,"id","transformers.TFFunnelForTokenClassification"),m(rs,"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"),m(rs,"href","#transformers.TFFunnelForTokenClassification"),m(Ht,"class","relative group"),m(ni,"href","https://arxiv.org/abs/2006.03236"),m(ni,"rel","nofollow"),m(il,"href","/docs/transformers/main/en/main_classes/model#transformers.TFPreTrainedModel"),m(si,"href","https://www.tensorflow.org/api_docs/python/tf/keras/Model"),m(si,"rel","nofollow"),m(ll,"href","/docs/transformers/main/en/model_doc/funnel#transformers.TFFunnelForTokenClassification"),m(wn,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),m(ln,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),m(cs,"id","transformers.TFFunnelForQuestionAnswering"),m(cs,"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"),m(cs,"href","#transformers.TFFunnelForQuestionAnswering"),m(Yt,"class","relative group"),m(di,"href","https://arxiv.org/abs/2006.03236"),m(di,"rel","nofollow"),m(dl,"href","/docs/transformers/main/en/main_classes/model#transformers.TFPreTrainedModel"),m(pi,"href","https://www.tensorflow.org/api_docs/python/tf/keras/Model"),m(pi,"rel","nofollow"),m(cl,"href","/docs/transformers/main/en/model_doc/funnel#transformers.TFFunnelForQuestionAnswering"),m(Fn,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),m(dn,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8")},m(i,y){e(document.head,d),_(i,k,y),_(i,h,y),e(h,f),e(f,T),v(l,T,null),e(h,c),e(h,P),e(P,ke),_(i,he,y),_(i,I,y),e(I,re),e(re,ee),v(b,ee,null),e(I,Te),e(I,K),e(K,ye),_(i,fe,y),_(i,B,y),e(B,be),e(B,ae),e(ae,H),e(B,we),_(i,me,y),_(i,Q,y),e(Q,Fe),_(i,ge,y),_(i,U,y),e(U,ue),e(ue,ve),_(i,oe,y),_(i,C,y),e(C,A),_(i,_e,y),_(i,W,y),e(W,pe),e(pe,$e),e(W,V),e(W,R),e(R,Ee),e(R,j),e(j,Me),e(R,Y),e(R,le),e(le,ze),e(R,G),e(R,de),e(de,qe),e(R,N),e(R,ce),e(ce,Z),e(R,Pe),e(R,ne),e(ne,O),e(R,xe),e(R,L),e(L,Ce),e(R,je),e(R,g),e(g,z),e(R,Ie),e(R,J),e(J,Se),e(R,Be),_(i,q,y),_(i,Ae,y),e(Ae,We),e(Ae,Le),e(Le,Qe),e(Ae,Ue),e(Ae,D),e(D,X),e(Ae,Ke),_(i,Ne,y),_(i,S,y),e(S,Oe),e(Oe,De),v(ie,De,null),e(S,Re),e(S,te),e(te,He),_(i,Kc,y),_(i,Xn,y),v(zs,Xn,null),e(Xn,eh),e(Xn,Jn),e(Jn,nh),e(Jn,bi),e(bi,th),e(Jn,oh),e(Jn,wi),e(wi,sh),e(Jn,rh),e(Jn,qs),e(qs,ah),e(Jn,ih),e(Xn,lh),e(Xn,dt),e(dt,dh),e(dt,Fi),e(Fi,ch),e(dt,uh),e(dt,vi),e(vi,ph),e(dt,hh),_(i,Rc,y),_(i,ct,y),e(ct,no),e(no,jl),v(Ps,jl,null),e(ct,fh),e(ct,Al),e(Al,mh),_(i,Hc,y),_(i,en,y),v(xs,en,null),e(en,gh),e(en,Ol),e(Ol,_h),e(en,kh),e(en,Cs),e(Cs,Th),e(Cs,$i),e($i,yh),e(Cs,bh),e(en,wh),e(en,nt),v(js,nt,null),e(nt,Fh),e(nt,Ll),e(Ll,vh),e(nt,$h),e(nt,As),e(As,Ei),e(Ei,Eh),e(Ei,Dl),e(Dl,Mh),e(As,zh),e(As,Mi),e(Mi,qh),e(Mi,Nl),e(Nl,Ph),e(en,xh),e(en,to),v(Os,to,null),e(to,Ch),e(to,Ls),e(Ls,jh),e(Ls,Il),e(Il,Ah),e(Ls,Oh),e(en,Lh),e(en,Cn),v(Ds,Cn,null),e(Cn,Dh),e(Cn,Sl),e(Sl,Nh),e(Cn,Ih),v(oo,Cn,null),e(Cn,Sh),e(Cn,ut),e(ut,Bh),e(ut,Bl),e(Bl,Wh),e(ut,Qh),e(ut,Wl),e(Wl,Uh),e(ut,Kh),e(en,Rh),e(en,zi),v(Ns,zi,null),_(i,Vc,y),_(i,pt,y),e(pt,so),e(so,Ql),v(Is,Ql,null),e(pt,Hh),e(pt,Ul),e(Ul,Vh),_(i,Yc,y),_(i,kn,y),v(Ss,kn,null),e(kn,Yh),e(kn,Bs),e(Bs,Gh),e(Bs,Kl),e(Kl,Zh),e(Bs,Xh),e(kn,Jh),e(kn,Ws),e(Ws,ef),e(Ws,qi),e(qi,nf),e(Ws,tf),e(kn,of),e(kn,tt),v(Qs,tt,null),e(tt,sf),e(tt,Rl),e(Rl,rf),e(tt,af),e(tt,Us),e(Us,Pi),e(Pi,lf),e(Pi,Hl),e(Hl,df),e(Us,cf),e(Us,xi),e(xi,uf),e(xi,Vl),e(Vl,pf),e(kn,hf),e(kn,jn),v(Ks,jn,null),e(jn,ff),e(jn,Yl),e(Yl,mf),e(jn,gf),v(ro,jn,null),e(jn,_f),e(jn,ht),e(ht,kf),e(ht,Gl),e(Gl,Tf),e(ht,yf),e(ht,Zl),e(Zl,bf),e(ht,wf),_(i,Gc,y),_(i,ft,y),e(ft,ao),e(ao,Xl),v(Rs,Xl,null),e(ft,Ff),e(ft,Jl),e(Jl,vf),_(i,Zc,y),_(i,mt,y),v(Hs,mt,null),e(mt,$f),e(mt,Vs),e(Vs,Ef),e(Vs,Ci),e(Ci,Mf),e(Vs,zf),_(i,Xc,y),_(i,gt,y),v(Ys,gt,null),e(gt,qf),e(gt,Gs),e(Gs,Pf),e(Gs,ji),e(ji,xf),e(Gs,Cf),_(i,Jc,y),_(i,_t,y),e(_t,io),e(io,ed),v(Zs,ed,null),e(_t,jf),e(_t,nd),e(nd,Af),_(i,eu,y),_(i,cn,y),v(Xs,cn,null),e(cn,Of),e(cn,td),e(td,Lf),e(cn,Df),e(cn,Js),e(Js,Nf),e(Js,er),e(er,If),e(Js,Sf),e(cn,Bf),e(cn,nr),e(nr,Wf),e(nr,Ai),e(Ai,Qf),e(nr,Uf),e(cn,Kf),e(cn,tr),e(tr,Rf),e(tr,or),e(or,Hf),e(tr,Vf),e(cn,Yf),e(cn,An),v(sr,An,null),e(An,Gf),e(An,kt),e(kt,Zf),e(kt,Oi),e(Oi,Xf),e(kt,Jf),e(kt,od),e(od,em),e(kt,nm),e(An,tm),v(lo,An,null),e(An,om),v(co,An,null),_(i,nu,y),_(i,Tt,y),e(Tt,uo),e(uo,sd),v(rr,sd,null),e(Tt,sm),e(Tt,rd),e(rd,rm),_(i,tu,y),_(i,un,y),v(ar,un,null),e(un,am),e(un,ad),e(ad,im),e(un,lm),e(un,ir),e(ir,dm),e(ir,lr),e(lr,cm),e(ir,um),e(un,pm),e(un,dr),e(dr,hm),e(dr,Li),e(Li,fm),e(dr,mm),e(un,gm),e(un,cr),e(cr,_m),e(cr,ur),e(ur,km),e(cr,Tm),e(un,ym),e(un,On),v(pr,On,null),e(On,bm),e(On,yt),e(yt,wm),e(yt,Di),e(Di,Fm),e(yt,vm),e(yt,id),e(id,$m),e(yt,Em),e(On,Mm),v(po,On,null),e(On,zm),v(ho,On,null),_(i,ou,y),_(i,bt,y),e(bt,fo),e(fo,ld),v(hr,ld,null),e(bt,qm),e(bt,dd),e(dd,Pm),_(i,su,y),_(i,wt,y),v(fr,wt,null),e(wt,xm),e(wt,Ln),v(mr,Ln,null),e(Ln,Cm),e(Ln,Ft),e(Ft,jm),e(Ft,Ni),e(Ni,Am),e(Ft,Om),e(Ft,cd),e(cd,Lm),e(Ft,Dm),e(Ln,Nm),v(mo,Ln,null),e(Ln,Im),v(go,Ln,null),_(i,ru,y),_(i,vt,y),e(vt,_o),e(_o,ud),v(gr,ud,null),e(vt,Sm),e(vt,pd),e(pd,Bm),_(i,au,y),_(i,pn,y),v(_r,pn,null),e(pn,Wm),e(pn,kr),e(kr,Qm),e(kr,hd),e(hd,Um),e(kr,Km),e(pn,Rm),e(pn,Tr),e(Tr,Hm),e(Tr,yr),e(yr,Vm),e(Tr,Ym),e(pn,Gm),e(pn,br),e(br,Zm),e(br,Ii),e(Ii,Xm),e(br,Jm),e(pn,eg),e(pn,wr),e(wr,ng),e(wr,Fr),e(Fr,tg),e(wr,og),e(pn,sg),e(pn,Dn),v(vr,Dn,null),e(Dn,rg),e(Dn,$t),e($t,ag),e($t,Si),e(Si,ig),e($t,lg),e($t,fd),e(fd,dg),e($t,cg),e(Dn,ug),v(ko,Dn,null),e(Dn,pg),v(To,Dn,null),_(i,iu,y),_(i,Et,y),e(Et,yo),e(yo,md),v($r,md,null),e(Et,hg),e(Et,gd),e(gd,fg),_(i,lu,y),_(i,hn,y),v(Er,hn,null),e(hn,mg),e(hn,_d),e(_d,gg),e(hn,_g),e(hn,Mr),e(Mr,kg),e(Mr,zr),e(zr,Tg),e(Mr,yg),e(hn,bg),e(hn,qr),e(qr,wg),e(qr,Bi),e(Bi,Fg),e(qr,vg),e(hn,$g),e(hn,Pr),e(Pr,Eg),e(Pr,xr),e(xr,Mg),e(Pr,zg),e(hn,qg),e(hn,Tn),v(Cr,Tn,null),e(Tn,Pg),e(Tn,Mt),e(Mt,xg),e(Mt,Wi),e(Wi,Cg),e(Mt,jg),e(Mt,kd),e(kd,Ag),e(Mt,Og),e(Tn,Lg),v(bo,Tn,null),e(Tn,Dg),v(wo,Tn,null),e(Tn,Ng),v(Fo,Tn,null),_(i,du,y),_(i,zt,y),e(zt,vo),e(vo,Td),v(jr,Td,null),e(zt,Ig),e(zt,yd),e(yd,Sg),_(i,cu,y),_(i,fn,y),v(Ar,fn,null),e(fn,Bg),e(fn,bd),e(bd,Wg),e(fn,Qg),e(fn,Or),e(Or,Ug),e(Or,Lr),e(Lr,Kg),e(Or,Rg),e(fn,Hg),e(fn,Dr),e(Dr,Vg),e(Dr,Qi),e(Qi,Yg),e(Dr,Gg),e(fn,Zg),e(fn,Nr),e(Nr,Xg),e(Nr,Ir),e(Ir,Jg),e(Nr,e_),e(fn,n_),e(fn,Nn),v(Sr,Nn,null),e(Nn,t_),e(Nn,qt),e(qt,o_),e(qt,Ui),e(Ui,s_),e(qt,r_),e(qt,wd),e(wd,a_),e(qt,i_),e(Nn,l_),v($o,Nn,null),e(Nn,d_),v(Eo,Nn,null),_(i,uu,y),_(i,Pt,y),e(Pt,Mo),e(Mo,Fd),v(Br,Fd,null),e(Pt,c_),e(Pt,vd),e(vd,u_),_(i,pu,y),_(i,mn,y),v(Wr,mn,null),e(mn,p_),e(mn,$d),e($d,h_),e(mn,f_),e(mn,Qr),e(Qr,m_),e(Qr,Ur),e(Ur,g_),e(Qr,__),e(mn,k_),e(mn,Kr),e(Kr,T_),e(Kr,Ki),e(Ki,y_),e(Kr,b_),e(mn,w_),e(mn,Rr),e(Rr,F_),e(Rr,Hr),e(Hr,v_),e(Rr,$_),e(mn,E_),e(mn,In),v(Vr,In,null),e(In,M_),e(In,xt),e(xt,z_),e(xt,Ri),e(Ri,q_),e(xt,P_),e(xt,Ed),e(Ed,x_),e(xt,C_),e(In,j_),v(zo,In,null),e(In,A_),v(qo,In,null),_(i,hu,y),_(i,Ct,y),e(Ct,Po),e(Po,Md),v(Yr,Md,null),e(Ct,O_),e(Ct,zd),e(zd,L_),_(i,fu,y),_(i,gn,y),v(Gr,gn,null),e(gn,D_),e(gn,jt),e(jt,N_),e(jt,qd),e(qd,I_),e(jt,S_),e(jt,Pd),e(Pd,B_),e(jt,W_),e(gn,Q_),e(gn,Zr),e(Zr,U_),e(Zr,Xr),e(Xr,K_),e(Zr,R_),e(gn,H_),e(gn,Jr),e(Jr,V_),e(Jr,Hi),e(Hi,Y_),e(Jr,G_),e(gn,Z_),e(gn,ea),e(ea,X_),e(ea,na),e(na,J_),e(ea,ek),e(gn,nk),e(gn,Sn),v(ta,Sn,null),e(Sn,tk),e(Sn,At),e(At,ok),e(At,Vi),e(Vi,sk),e(At,rk),e(At,xd),e(xd,ak),e(At,ik),e(Sn,lk),v(xo,Sn,null),e(Sn,dk),v(Co,Sn,null),_(i,mu,y),_(i,Ot,y),e(Ot,jo),e(jo,Cd),v(oa,Cd,null),e(Ot,ck),e(Ot,jd),e(jd,uk),_(i,gu,y),_(i,nn,y),v(sa,nn,null),e(nn,pk),e(nn,Ad),e(Ad,hk),e(nn,fk),e(nn,ra),e(ra,mk),e(ra,aa),e(aa,gk),e(ra,_k),e(nn,kk),e(nn,ia),e(ia,Tk),e(ia,Yi),e(Yi,yk),e(ia,bk),e(nn,wk),e(nn,la),e(la,Fk),e(la,da),e(da,vk),e(la,$k),e(nn,Ek),v(Ao,nn,null),e(nn,Mk),e(nn,Bn),v(ca,Bn,null),e(Bn,zk),e(Bn,Lt),e(Lt,qk),e(Lt,Gi),e(Gi,Pk),e(Lt,xk),e(Lt,Od),e(Od,Ck),e(Lt,jk),e(Bn,Ak),v(Oo,Bn,null),e(Bn,Ok),v(Lo,Bn,null),_(i,_u,y),_(i,Dt,y),e(Dt,Do),e(Do,Ld),v(ua,Ld,null),e(Dt,Lk),e(Dt,Dd),e(Dd,Dk),_(i,ku,y),_(i,tn,y),v(pa,tn,null),e(tn,Nk),e(tn,Nd),e(Nd,Ik),e(tn,Sk),e(tn,ha),e(ha,Bk),e(ha,fa),e(fa,Wk),e(ha,Qk),e(tn,Uk),e(tn,ma),e(ma,Kk),e(ma,Zi),e(Zi,Rk),e(ma,Hk),e(tn,Vk),e(tn,ga),e(ga,Yk),e(ga,_a),e(_a,Gk),e(ga,Zk),e(tn,Xk),v(No,tn,null),e(tn,Jk),e(tn,Wn),v(ka,Wn,null),e(Wn,eT),e(Wn,Nt),e(Nt,nT),e(Nt,Xi),e(Xi,tT),e(Nt,oT),e(Nt,Id),e(Id,sT),e(Nt,rT),e(Wn,aT),v(Io,Wn,null),e(Wn,iT),v(So,Wn,null),_(i,Tu,y),_(i,It,y),e(It,Bo),e(Bo,Sd),v(Ta,Sd,null),e(It,lT),e(It,Bd),e(Bd,dT),_(i,yu,y),_(i,on,y),v(ya,on,null),e(on,cT),e(on,Wd),e(Wd,uT),e(on,pT),e(on,ba),e(ba,hT),e(ba,wa),e(wa,fT),e(ba,mT),e(on,gT),e(on,Fa),e(Fa,_T),e(Fa,Ji),e(Ji,kT),e(Fa,TT),e(on,yT),e(on,va),e(va,bT),e(va,$a),e($a,wT),e(va,FT),e(on,vT),v(Wo,on,null),e(on,$T),e(on,Qn),v(Ea,Qn,null),e(Qn,ET),e(Qn,St),e(St,MT),e(St,el),e(el,zT),e(St,qT),e(St,Qd),e(Qd,PT),e(St,xT),e(Qn,CT),v(Qo,Qn,null),e(Qn,jT),v(Uo,Qn,null),_(i,bu,y),_(i,Bt,y),e(Bt,Ko),e(Ko,Ud),v(Ma,Ud,null),e(Bt,AT),e(Bt,Kd),e(Kd,OT),_(i,wu,y),_(i,sn,y),v(za,sn,null),e(sn,LT),e(sn,qa),e(qa,DT),e(qa,Rd),e(Rd,NT),e(qa,IT),e(sn,ST),e(sn,Pa),e(Pa,BT),e(Pa,xa),e(xa,WT),e(Pa,QT),e(sn,UT),e(sn,Ca),e(Ca,KT),e(Ca,nl),e(nl,RT),e(Ca,HT),e(sn,VT),e(sn,ja),e(ja,YT),e(ja,Aa),e(Aa,GT),e(ja,ZT),e(sn,XT),v(Ro,sn,null),e(sn,JT),e(sn,yn),v(Oa,yn,null),e(yn,ey),e(yn,Wt),e(Wt,ny),e(Wt,tl),e(tl,ty),e(Wt,oy),e(Wt,Hd),e(Hd,sy),e(Wt,ry),e(yn,ay),v(Ho,yn,null),e(yn,iy),v(Vo,yn,null),e(yn,ly),v(Yo,yn,null),_(i,Fu,y),_(i,Qt,y),e(Qt,Go),e(Go,Vd),v(La,Vd,null),e(Qt,dy),e(Qt,Yd),e(Yd,cy),_(i,vu,y),_(i,rn,y),v(Da,rn,null),e(rn,uy),e(rn,Gd),e(Gd,py),e(rn,hy),e(rn,Na),e(Na,fy),e(Na,Ia),e(Ia,my),e(Na,gy),e(rn,_y),e(rn,Sa),e(Sa,ky),e(Sa,ol),e(ol,Ty),e(Sa,yy),e(rn,by),e(rn,Ba),e(Ba,wy),e(Ba,Wa),e(Wa,Fy),e(Ba,vy),e(rn,$y),v(Zo,rn,null),e(rn,Ey),e(rn,bn),v(Qa,bn,null),e(bn,My),e(bn,Ut),e(Ut,zy),e(Ut,sl),e(sl,qy),e(Ut,Py),e(Ut,Zd),e(Zd,xy),e(Ut,Cy),e(bn,jy),v(Xo,bn,null),e(bn,Ay),v(Jo,bn,null),e(bn,Oy),v(es,bn,null),_(i,$u,y),_(i,Kt,y),e(Kt,ns),e(ns,Xd),v(Ua,Xd,null),e(Kt,Ly),e(Kt,Jd),e(Jd,Dy),_(i,Eu,y),_(i,an,y),v(Ka,an,null),e(an,Ny),e(an,ec),e(ec,Iy),e(an,Sy),e(an,Ra),e(Ra,By),e(Ra,Ha),e(Ha,Wy),e(Ra,Qy),e(an,Uy),e(an,Va),e(Va,Ky),e(Va,rl),e(rl,Ry),e(Va,Hy),e(an,Vy),e(an,Ya),e(Ya,Yy),e(Ya,Ga),e(Ga,Gy),e(Ya,Zy),e(an,Xy),v(ts,an,null),e(an,Jy),e(an,Un),v(Za,Un,null),e(Un,eb),e(Un,Rt),e(Rt,nb),e(Rt,al),e(al,tb),e(Rt,ob),e(Rt,nc),e(nc,sb),e(Rt,rb),e(Un,ab),v(os,Un,null),e(Un,ib),v(ss,Un,null),_(i,Mu,y),_(i,Ht,y),e(Ht,rs),e(rs,tc),v(Xa,tc,null),e(Ht,lb),e(Ht,oc),e(oc,db),_(i,zu,y),_(i,ln,y),v(Ja,ln,null),e(ln,cb),e(ln,sc),e(sc,ub),e(ln,pb),e(ln,ei),e(ei,hb),e(ei,ni),e(ni,fb),e(ei,mb),e(ln,gb),e(ln,ti),e(ti,_b),e(ti,il),e(il,kb),e(ti,Tb),e(ln,yb),e(ln,oi),e(oi,bb),e(oi,si),e(si,wb),e(oi,Fb),e(ln,vb),v(as,ln,null),e(ln,$b),e(ln,wn),v(ri,wn,null),e(wn,Eb),e(wn,Vt),e(Vt,Mb),e(Vt,ll),e(ll,zb),e(Vt,qb),e(Vt,rc),e(rc,Pb),e(Vt,xb),e(wn,Cb),v(is,wn,null),e(wn,jb),v(ls,wn,null),e(wn,Ab),v(ds,wn,null),_(i,qu,y),_(i,Yt,y),e(Yt,cs),e(cs,ac),v(ai,ac,null),e(Yt,Ob),e(Yt,ic),e(ic,Lb),_(i,Pu,y),_(i,dn,y),v(ii,dn,null),e(dn,Db),e(dn,Gt),e(Gt,Nb),e(Gt,lc),e(lc,Ib),e(Gt,Sb),e(Gt,dc),e(dc,Bb),e(Gt,Wb),e(dn,Qb),e(dn,li),e(li,Ub),e(li,di),e(di,Kb),e(li,Rb),e(dn,Hb),e(dn,ci),e(ci,Vb),e(ci,dl),e(dl,Yb),e(ci,Gb),e(dn,Zb),e(dn,ui),e(ui,Xb),e(ui,pi),e(pi,Jb),e(ui,ew),e(dn,nw),v(us,dn,null),e(dn,tw),e(dn,Fn),v(hi,Fn,null),e(Fn,ow),e(Fn,Zt),e(Zt,sw),e(Zt,cl),e(cl,rw),e(Zt,aw),e(Zt,cc),e(cc,iw),e(Zt,lw),e(Fn,dw),v(ps,Fn,null),e(Fn,cw),v(hs,Fn,null),e(Fn,uw),v(fs,Fn,null),xu=!0},p(i,[y]){const fi={};y&2&&(fi.$$scope={dirty:y,ctx:i}),oo.$set(fi);const uc={};y&2&&(uc.$$scope={dirty:y,ctx:i}),ro.$set(uc);const pc={};y&2&&(pc.$$scope={dirty:y,ctx:i}),lo.$set(pc);const hc={};y&2&&(hc.$$scope={dirty:y,ctx:i}),co.$set(hc);const mi={};y&2&&(mi.$$scope={dirty:y,ctx:i}),po.$set(mi);const fc={};y&2&&(fc.$$scope={dirty:y,ctx:i}),ho.$set(fc);const mc={};y&2&&(mc.$$scope={dirty:y,ctx:i}),mo.$set(mc);const gc={};y&2&&(gc.$$scope={dirty:y,ctx:i}),go.$set(gc);const gi={};y&2&&(gi.$$scope={dirty:y,ctx:i}),ko.$set(gi);const _c={};y&2&&(_c.$$scope={dirty:y,ctx:i}),To.$set(_c);const kc={};y&2&&(kc.$$scope={dirty:y,ctx:i}),bo.$set(kc);const Tc={};y&2&&(Tc.$$scope={dirty:y,ctx:i}),wo.$set(Tc);const yc={};y&2&&(yc.$$scope={dirty:y,ctx:i}),Fo.$set(yc);const bc={};y&2&&(bc.$$scope={dirty:y,ctx:i}),$o.$set(bc);const _i={};y&2&&(_i.$$scope={dirty:y,ctx:i}),Eo.$set(_i);const wc={};y&2&&(wc.$$scope={dirty:y,ctx:i}),zo.$set(wc);const Je={};y&2&&(Je.$$scope={dirty:y,ctx:i}),qo.$set(Je);const Fc={};y&2&&(Fc.$$scope={dirty:y,ctx:i}),xo.$set(Fc);const vc={};y&2&&(vc.$$scope={dirty:y,ctx:i}),Co.$set(vc);const $c={};y&2&&($c.$$scope={dirty:y,ctx:i}),Ao.$set($c);const Ec={};y&2&&(Ec.$$scope={dirty:y,ctx:i}),Oo.$set(Ec);const Mc={};y&2&&(Mc.$$scope={dirty:y,ctx:i}),Lo.$set(Mc);const zc={};y&2&&(zc.$$scope={dirty:y,ctx:i}),No.$set(zc);const qc={};y&2&&(qc.$$scope={dirty:y,ctx:i}),Io.$set(qc);const Pc={};y&2&&(Pc.$$scope={dirty:y,ctx:i}),So.$set(Pc);const Xt={};y&2&&(Xt.$$scope={dirty:y,ctx:i}),Wo.$set(Xt);const xc={};y&2&&(xc.$$scope={dirty:y,ctx:i}),Qo.$set(xc);const Cc={};y&2&&(Cc.$$scope={dirty:y,ctx:i}),Uo.$set(Cc);const ki={};y&2&&(ki.$$scope={dirty:y,ctx:i}),Ro.$set(ki);const jc={};y&2&&(jc.$$scope={dirty:y,ctx:i}),Ho.$set(jc);const Ac={};y&2&&(Ac.$$scope={dirty:y,ctx:i}),Vo.$set(Ac);const Oc={};y&2&&(Oc.$$scope={dirty:y,ctx:i}),Yo.$set(Oc);const Jt={};y&2&&(Jt.$$scope={dirty:y,ctx:i}),Zo.$set(Jt);const et={};y&2&&(et.$$scope={dirty:y,ctx:i}),Xo.$set(et);const Lc={};y&2&&(Lc.$$scope={dirty:y,ctx:i}),Jo.$set(Lc);const Dc={};y&2&&(Dc.$$scope={dirty:y,ctx:i}),es.$set(Dc);const Nc={};y&2&&(Nc.$$scope={dirty:y,ctx:i}),ts.$set(Nc);const eo={};y&2&&(eo.$$scope={dirty:y,ctx:i}),os.$set(eo);const Ic={};y&2&&(Ic.$$scope={dirty:y,ctx:i}),ss.$set(Ic);const Sc={};y&2&&(Sc.$$scope={dirty:y,ctx:i}),as.$set(Sc);const Ti={};y&2&&(Ti.$$scope={dirty:y,ctx:i}),is.$set(Ti);const Bc={};y&2&&(Bc.$$scope={dirty:y,ctx:i}),ls.$set(Bc);const Wc={};y&2&&(Wc.$$scope={dirty:y,ctx:i}),ds.$set(Wc);const Qc={};y&2&&(Qc.$$scope={dirty:y,ctx:i}),us.$set(Qc);const _n={};y&2&&(_n.$$scope={dirty:y,ctx:i}),ps.$set(_n);const Uc={};y&2&&(Uc.$$scope={dirty:y,ctx:i}),hs.$set(Uc);const yi={};y&2&&(yi.$$scope={dirty:y,ctx:i}),fs.$set(yi)},i(i){xu||($(l.$$.fragment,i),$(b.$$.fragment,i),$(ie.$$.fragment,i),$(zs.$$.fragment,i),$(Ps.$$.fragment,i),$(xs.$$.fragment,i),$(js.$$.fragment,i),$(Os.$$.fragment,i),$(Ds.$$.fragment,i),$(oo.$$.fragment,i),$(Ns.$$.fragment,i),$(Is.$$.fragment,i),$(Ss.$$.fragment,i),$(Qs.$$.fragment,i),$(Ks.$$.fragment,i),$(ro.$$.fragment,i),$(Rs.$$.fragment,i),$(Hs.$$.fragment,i),$(Ys.$$.fragment,i),$(Zs.$$.fragment,i),$(Xs.$$.fragment,i),$(sr.$$.fragment,i),$(lo.$$.fragment,i),$(co.$$.fragment,i),$(rr.$$.fragment,i),$(ar.$$.fragment,i),$(pr.$$.fragment,i),$(po.$$.fragment,i),$(ho.$$.fragment,i),$(hr.$$.fragment,i),$(fr.$$.fragment,i),$(mr.$$.fragment,i),$(mo.$$.fragment,i),$(go.$$.fragment,i),$(gr.$$.fragment,i),$(_r.$$.fragment,i),$(vr.$$.fragment,i),$(ko.$$.fragment,i),$(To.$$.fragment,i),$($r.$$.fragment,i),$(Er.$$.fragment,i),$(Cr.$$.fragment,i),$(bo.$$.fragment,i),$(wo.$$.fragment,i),$(Fo.$$.fragment,i),$(jr.$$.fragment,i),$(Ar.$$.fragment,i),$(Sr.$$.fragment,i),$($o.$$.fragment,i),$(Eo.$$.fragment,i),$(Br.$$.fragment,i),$(Wr.$$.fragment,i),$(Vr.$$.fragment,i),$(zo.$$.fragment,i),$(qo.$$.fragment,i),$(Yr.$$.fragment,i),$(Gr.$$.fragment,i),$(ta.$$.fragment,i),$(xo.$$.fragment,i),$(Co.$$.fragment,i),$(oa.$$.fragment,i),$(sa.$$.fragment,i),$(Ao.$$.fragment,i),$(ca.$$.fragment,i),$(Oo.$$.fragment,i),$(Lo.$$.fragment,i),$(ua.$$.fragment,i),$(pa.$$.fragment,i),$(No.$$.fragment,i),$(ka.$$.fragment,i),$(Io.$$.fragment,i),$(So.$$.fragment,i),$(Ta.$$.fragment,i),$(ya.$$.fragment,i),$(Wo.$$.fragment,i),$(Ea.$$.fragment,i),$(Qo.$$.fragment,i),$(Uo.$$.fragment,i),$(Ma.$$.fragment,i),$(za.$$.fragment,i),$(Ro.$$.fragment,i),$(Oa.$$.fragment,i),$(Ho.$$.fragment,i),$(Vo.$$.fragment,i),$(Yo.$$.fragment,i),$(La.$$.fragment,i),$(Da.$$.fragment,i),$(Zo.$$.fragment,i),$(Qa.$$.fragment,i),$(Xo.$$.fragment,i),$(Jo.$$.fragment,i),$(es.$$.fragment,i),$(Ua.$$.fragment,i),$(Ka.$$.fragment,i),$(ts.$$.fragment,i),$(Za.$$.fragment,i),$(os.$$.fragment,i),$(ss.$$.fragment,i),$(Xa.$$.fragment,i),$(Ja.$$.fragment,i),$(as.$$.fragment,i),$(ri.$$.fragment,i),$(is.$$.fragment,i),$(ls.$$.fragment,i),$(ds.$$.fragment,i),$(ai.$$.fragment,i),$(ii.$$.fragment,i),$(us.$$.fragment,i),$(hi.$$.fragment,i),$(ps.$$.fragment,i),$(hs.$$.fragment,i),$(fs.$$.fragment,i),xu=!0)},o(i){E(l.$$.fragment,i),E(b.$$.fragment,i),E(ie.$$.fragment,i),E(zs.$$.fragment,i),E(Ps.$$.fragment,i),E(xs.$$.fragment,i),E(js.$$.fragment,i),E(Os.$$.fragment,i),E(Ds.$$.fragment,i),E(oo.$$.fragment,i),E(Ns.$$.fragment,i),E(Is.$$.fragment,i),E(Ss.$$.fragment,i),E(Qs.$$.fragment,i),E(Ks.$$.fragment,i),E(ro.$$.fragment,i),E(Rs.$$.fragment,i),E(Hs.$$.fragment,i),E(Ys.$$.fragment,i),E(Zs.$$.fragment,i),E(Xs.$$.fragment,i),E(sr.$$.fragment,i),E(lo.$$.fragment,i),E(co.$$.fragment,i),E(rr.$$.fragment,i),E(ar.$$.fragment,i),E(pr.$$.fragment,i),E(po.$$.fragment,i),E(ho.$$.fragment,i),E(hr.$$.fragment,i),E(fr.$$.fragment,i),E(mr.$$.fragment,i),E(mo.$$.fragment,i),E(go.$$.fragment,i),E(gr.$$.fragment,i),E(_r.$$.fragment,i),E(vr.$$.fragment,i),E(ko.$$.fragment,i),E(To.$$.fragment,i),E($r.$$.fragment,i),E(Er.$$.fragment,i),E(Cr.$$.fragment,i),E(bo.$$.fragment,i),E(wo.$$.fragment,i),E(Fo.$$.fragment,i),E(jr.$$.fragment,i),E(Ar.$$.fragment,i),E(Sr.$$.fragment,i),E($o.$$.fragment,i),E(Eo.$$.fragment,i),E(Br.$$.fragment,i),E(Wr.$$.fragment,i),E(Vr.$$.fragment,i),E(zo.$$.fragment,i),E(qo.$$.fragment,i),E(Yr.$$.fragment,i),E(Gr.$$.fragment,i),E(ta.$$.fragment,i),E(xo.$$.fragment,i),E(Co.$$.fragment,i),E(oa.$$.fragment,i),E(sa.$$.fragment,i),E(Ao.$$.fragment,i),E(ca.$$.fragment,i),E(Oo.$$.fragment,i),E(Lo.$$.fragment,i),E(ua.$$.fragment,i),E(pa.$$.fragment,i),E(No.$$.fragment,i),E(ka.$$.fragment,i),E(Io.$$.fragment,i),E(So.$$.fragment,i),E(Ta.$$.fragment,i),E(ya.$$.fragment,i),E(Wo.$$.fragment,i),E(Ea.$$.fragment,i),E(Qo.$$.fragment,i),E(Uo.$$.fragment,i),E(Ma.$$.fragment,i),E(za.$$.fragment,i),E(Ro.$$.fragment,i),E(Oa.$$.fragment,i),E(Ho.$$.fragment,i),E(Vo.$$.fragment,i),E(Yo.$$.fragment,i),E(La.$$.fragment,i),E(Da.$$.fragment,i),E(Zo.$$.fragment,i),E(Qa.$$.fragment,i),E(Xo.$$.fragment,i),E(Jo.$$.fragment,i),E(es.$$.fragment,i),E(Ua.$$.fragment,i),E(Ka.$$.fragment,i),E(ts.$$.fragment,i),E(Za.$$.fragment,i),E(os.$$.fragment,i),E(ss.$$.fragment,i),E(Xa.$$.fragment,i),E(Ja.$$.fragment,i),E(as.$$.fragment,i),E(ri.$$.fragment,i),E(is.$$.fragment,i),E(ls.$$.fragment,i),E(ds.$$.fragment,i),E(ai.$$.fragment,i),E(ii.$$.fragment,i),E(us.$$.fragment,i),E(hi.$$.fragment,i),E(ps.$$.fragment,i),E(hs.$$.fragment,i),E(fs.$$.fragment,i),xu=!1},d(i){n(d),i&&n(k),i&&n(h),M(l),i&&n(he),i&&n(I),M(b),i&&n(fe),i&&n(B),i&&n(me),i&&n(Q),i&&n(ge),i&&n(U),i&&n(oe),i&&n(C),i&&n(_e),i&&n(W),i&&n(q),i&&n(Ae),i&&n(Ne),i&&n(S),M(ie),i&&n(Kc),i&&n(Xn),M(zs),i&&n(Rc),i&&n(ct),M(Ps),i&&n(Hc),i&&n(en),M(xs),M(js),M(Os),M(Ds),M(oo),M(Ns),i&&n(Vc),i&&n(pt),M(Is),i&&n(Yc),i&&n(kn),M(Ss),M(Qs),M(Ks),M(ro),i&&n(Gc),i&&n(ft),M(Rs),i&&n(Zc),i&&n(mt),M(Hs),i&&n(Xc),i&&n(gt),M(Ys),i&&n(Jc),i&&n(_t),M(Zs),i&&n(eu),i&&n(cn),M(Xs),M(sr),M(lo),M(co),i&&n(nu),i&&n(Tt),M(rr),i&&n(tu),i&&n(un),M(ar),M(pr),M(po),M(ho),i&&n(ou),i&&n(bt),M(hr),i&&n(su),i&&n(wt),M(fr),M(mr),M(mo),M(go),i&&n(ru),i&&n(vt),M(gr),i&&n(au),i&&n(pn),M(_r),M(vr),M(ko),M(To),i&&n(iu),i&&n(Et),M($r),i&&n(lu),i&&n(hn),M(Er),M(Cr),M(bo),M(wo),M(Fo),i&&n(du),i&&n(zt),M(jr),i&&n(cu),i&&n(fn),M(Ar),M(Sr),M($o),M(Eo),i&&n(uu),i&&n(Pt),M(Br),i&&n(pu),i&&n(mn),M(Wr),M(Vr),M(zo),M(qo),i&&n(hu),i&&n(Ct),M(Yr),i&&n(fu),i&&n(gn),M(Gr),M(ta),M(xo),M(Co),i&&n(mu),i&&n(Ot),M(oa),i&&n(gu),i&&n(nn),M(sa),M(Ao),M(ca),M(Oo),M(Lo),i&&n(_u),i&&n(Dt),M(ua),i&&n(ku),i&&n(tn),M(pa),M(No),M(ka),M(Io),M(So),i&&n(Tu),i&&n(It),M(Ta),i&&n(yu),i&&n(on),M(ya),M(Wo),M(Ea),M(Qo),M(Uo),i&&n(bu),i&&n(Bt),M(Ma),i&&n(wu),i&&n(sn),M(za),M(Ro),M(Oa),M(Ho),M(Vo),M(Yo),i&&n(Fu),i&&n(Qt),M(La),i&&n(vu),i&&n(rn),M(Da),M(Zo),M(Qa),M(Xo),M(Jo),M(es),i&&n($u),i&&n(Kt),M(Ua),i&&n(Eu),i&&n(an),M(Ka),M(ts),M(Za),M(os),M(ss),i&&n(Mu),i&&n(Ht),M(Xa),i&&n(zu),i&&n(ln),M(Ja),M(as),M(ri),M(is),M(ls),M(ds),i&&n(qu),i&&n(Yt),M(ai),i&&n(Pu),i&&n(dn),M(ii),M(us),M(hi),M(ps),M(hs),M(fs)}}}const y1={local:"funnel-transformer",sections:[{local:"overview",title:"Overview"},{local:"transformers.FunnelConfig",title:"FunnelConfig"},{local:"transformers.FunnelTokenizer",title:"FunnelTokenizer"},{local:"transformers.FunnelTokenizerFast",title:"FunnelTokenizerFast"},{local:"transformers.models.funnel.modeling_funnel.FunnelForPreTrainingOutput",title:"Funnel specific outputs"},{local:"transformers.FunnelBaseModel",title:"FunnelBaseModel"},{local:"transformers.FunnelModel",title:"FunnelModel"},{local:"transformers.FunnelForPreTraining",title:"FunnelModelForPreTraining"},{local:"transformers.FunnelForMaskedLM",title:"FunnelForMaskedLM"},{local:"transformers.FunnelForSequenceClassification",title:"FunnelForSequenceClassification"},{local:"transformers.FunnelForMultipleChoice",title:"FunnelForMultipleChoice"},{local:"transformers.FunnelForTokenClassification",title:"FunnelForTokenClassification"},{local:"transformers.FunnelForQuestionAnswering",title:"FunnelForQuestionAnswering"},{local:"transformers.TFFunnelBaseModel",title:"TFFunnelBaseModel"},{local:"transformers.TFFunnelModel",title:"TFFunnelModel"},{local:"transformers.TFFunnelForPreTraining",title:"TFFunnelModelForPreTraining"},{local:"transformers.TFFunnelForMaskedLM",title:"TFFunnelForMaskedLM"},{local:"transformers.TFFunnelForSequenceClassification",title:"TFFunnelForSequenceClassification"},{local:"transformers.TFFunnelForMultipleChoice",title:"TFFunnelForMultipleChoice"},{local:"transformers.TFFunnelForTokenClassification",title:"TFFunnelForTokenClassification"},{local:"transformers.TFFunnelForQuestionAnswering",title:"TFFunnelForQuestionAnswering"}],title:"Funnel Transformer"};function b1(x){return $$(()=>{new URLSearchParams(window.location.search).get("fw")}),[]}class z1 extends b${constructor(d){super();w$(this,d,b1,T1,F$,{})}}export{z1 as default,y1 as metadata};
