import{S as Jz,i as Gz,s as Xz,e as r,k as p,w,t as o,M as Yz,c as a,d as t,m as h,a as i,x as T,h as s,b as c,G as e,g,y,q as $,o as F,B as D,v as Zz,L as Pe}from"../../chunks/vendor-hf-doc-builder.js";import{T as Se}from"../../chunks/Tip-hf-doc-builder.js";import{D as R}from"../../chunks/Docstring-hf-doc-builder.js";import{C as Le}from"../../chunks/CodeBlock-hf-doc-builder.js";import{I as Ne}from"../../chunks/IconCopyLink-hf-doc-builder.js";import{E as qe}from"../../chunks/ExampleCodeBlock-hf-doc-builder.js";import{P as k_}from"../../chunks/PipelineTag-hf-doc-builder.js";function e3(x){let d,k,f,m,b;return m=new Le({props:{code:`from transformers import DistilBertConfig, DistilBertModel

# Initializing a DistilBERT configuration
configuration = DistilBertConfig()

# Initializing a model (with random weights) from the configuration
model = DistilBertModel(configuration)

# Accessing the model configuration
configuration = model.config`,highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> DistilBertConfig, DistilBertModel

<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-comment"># Initializing a DistilBERT configuration</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>configuration = DistilBertConfig()

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

<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-comment"># Accessing the model configuration</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>configuration = model.config`}}),{c(){d=r("p"),k=o("Examples:"),f=p(),w(m.$$.fragment)},l(l){d=a(l,"P",{});var u=i(d);k=s(u,"Examples:"),u.forEach(t),f=h(l),T(m.$$.fragment,l)},m(l,u){g(l,d,u),e(d,k),g(l,f,u),y(m,l,u),b=!0},p:Pe,i(l){b||($(m.$$.fragment,l),b=!0)},o(l){F(m.$$.fragment,l),b=!1},d(l){l&&t(d),l&&t(f),D(m,l)}}}function t3(x){let d,k,f,m,b;return m=new Le({props:{code:`0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1
| first sequence    | second sequence |`,highlighted:`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"> 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=r("p"),k=o("pair mask has the following format:"),f=p(),w(m.$$.fragment)},l(l){d=a(l,"P",{});var u=i(d);k=s(u,"pair mask has the following format:"),u.forEach(t),f=h(l),T(m.$$.fragment,l)},m(l,u){g(l,d,u),e(d,k),g(l,f,u),y(m,l,u),b=!0},p:Pe,i(l){b||($(m.$$.fragment,l),b=!0)},o(l){F(m.$$.fragment,l),b=!1},d(l){l&&t(d),l&&t(f),D(m,l)}}}function o3(x){let d,k,f,m,b;return m=new Le({props:{code:`0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1
| first sequence    | second sequence |`,highlighted:`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"> 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=r("p"),k=o("pair mask has the following format:"),f=p(),w(m.$$.fragment)},l(l){d=a(l,"P",{});var u=i(d);k=s(u,"pair mask has the following format:"),u.forEach(t),f=h(l),T(m.$$.fragment,l)},m(l,u){g(l,d,u),e(d,k),g(l,f,u),y(m,l,u),b=!0},p:Pe,i(l){b||($(m.$$.fragment,l),b=!0)},o(l){F(m.$$.fragment,l),b=!1},d(l){l&&t(d),l&&t(f),D(m,l)}}}function s3(x){let d,k,f,m,b;return{c(){d=r("p"),k=o("Although the recipe for forward pass needs to be defined within this function, one should call the "),f=r("code"),m=o("Module"),b=o(`
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=a(l,"P",{});var u=i(d);k=s(u,"Although the recipe for forward pass needs to be defined within this function, one should call the "),f=a(u,"CODE",{});var M=i(f);m=s(M,"Module"),M.forEach(t),b=s(u,`
instance afterwards instead of this since the former takes care of running the pre and post processing steps while
the latter silently ignores them.`),u.forEach(t)},m(l,u){g(l,d,u),e(d,k),e(d,f),e(f,m),e(d,b)},d(l){l&&t(d)}}}function n3(x){let d,k,f,m,b;return m=new Le({props:{code:`from transformers import AutoTokenizer, DistilBertModel
import torch

tokenizer = AutoTokenizer.from_pretrained("distilbert-base-uncased")
model = DistilBertModel.from_pretrained("distilbert-base-uncased")

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, DistilBertModel
<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;distilbert-base-uncased&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>model = DistilBertModel.from_pretrained(<span class="hljs-string">&quot;distilbert-base-uncased&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=r("p"),k=o("Example:"),f=p(),w(m.$$.fragment)},l(l){d=a(l,"P",{});var u=i(d);k=s(u,"Example:"),u.forEach(t),f=h(l),T(m.$$.fragment,l)},m(l,u){g(l,d,u),e(d,k),g(l,f,u),y(m,l,u),b=!0},p:Pe,i(l){b||($(m.$$.fragment,l),b=!0)},o(l){F(m.$$.fragment,l),b=!1},d(l){l&&t(d),l&&t(f),D(m,l)}}}function r3(x){let d,k,f,m,b;return{c(){d=r("p"),k=o("Although the recipe for forward pass needs to be defined within this function, one should call the "),f=r("code"),m=o("Module"),b=o(`
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=a(l,"P",{});var u=i(d);k=s(u,"Although the recipe for forward pass needs to be defined within this function, one should call the "),f=a(u,"CODE",{});var M=i(f);m=s(M,"Module"),M.forEach(t),b=s(u,`
instance afterwards instead of this since the former takes care of running the pre and post processing steps while
the latter silently ignores them.`),u.forEach(t)},m(l,u){g(l,d,u),e(d,k),e(d,f),e(f,m),e(d,b)},d(l){l&&t(d)}}}function a3(x){let d,k,f,m,b;return m=new Le({props:{code:`from transformers import AutoTokenizer, DistilBertForMaskedLM
import torch

tokenizer = AutoTokenizer.from_pretrained("distilbert-base-uncased")
model = DistilBertForMaskedLM.from_pretrained("distilbert-base-uncased")

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, DistilBertForMaskedLM
<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;distilbert-base-uncased&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>model = DistilBertForMaskedLM.from_pretrained(<span class="hljs-string">&quot;distilbert-base-uncased&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;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 [MASK]</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-[MASK] 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=r("p"),k=o("Example:"),f=p(),w(m.$$.fragment)},l(l){d=a(l,"P",{});var u=i(d);k=s(u,"Example:"),u.forEach(t),f=h(l),T(m.$$.fragment,l)},m(l,u){g(l,d,u),e(d,k),g(l,f,u),y(m,l,u),b=!0},p:Pe,i(l){b||($(m.$$.fragment,l),b=!0)},o(l){F(m.$$.fragment,l),b=!1},d(l){l&&t(d),l&&t(f),D(m,l)}}}function i3(x){let d,k,f,m,b;return{c(){d=r("p"),k=o("Although the recipe for forward pass needs to be defined within this function, one should call the "),f=r("code"),m=o("Module"),b=o(`
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=a(l,"P",{});var u=i(d);k=s(u,"Although the recipe for forward pass needs to be defined within this function, one should call the "),f=a(u,"CODE",{});var M=i(f);m=s(M,"Module"),M.forEach(t),b=s(u,`
instance afterwards instead of this since the former takes care of running the pre and post processing steps while
the latter silently ignores them.`),u.forEach(t)},m(l,u){g(l,d,u),e(d,k),e(d,f),e(f,m),e(d,b)},d(l){l&&t(d)}}}function l3(x){let d,k,f,m,b;return m=new Le({props:{code:`import torch
from transformers import AutoTokenizer, DistilBertForSequenceClassification

tokenizer = AutoTokenizer.from_pretrained("distilbert-base-uncased")
model = DistilBertForSequenceClassification.from_pretrained("distilbert-base-uncased")

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 = DistilBertForSequenceClassification.from_pretrained("distilbert-base-uncased", 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, DistilBertForSequenceClassification

<span class="hljs-meta">&gt;&gt;&gt; </span>tokenizer = AutoTokenizer.from_pretrained(<span class="hljs-string">&quot;distilbert-base-uncased&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>model = DistilBertForSequenceClassification.from_pretrained(<span class="hljs-string">&quot;distilbert-base-uncased&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 = DistilBertForSequenceClassification.from_pretrained(<span class="hljs-string">&quot;distilbert-base-uncased&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=r("p"),k=o("Example of single-label classification:"),f=p(),w(m.$$.fragment)},l(l){d=a(l,"P",{});var u=i(d);k=s(u,"Example of single-label classification:"),u.forEach(t),f=h(l),T(m.$$.fragment,l)},m(l,u){g(l,d,u),e(d,k),g(l,f,u),y(m,l,u),b=!0},p:Pe,i(l){b||($(m.$$.fragment,l),b=!0)},o(l){F(m.$$.fragment,l),b=!1},d(l){l&&t(d),l&&t(f),D(m,l)}}}function d3(x){let d,k,f,m,b;return m=new Le({props:{code:`import torch
from transformers import AutoTokenizer, DistilBertForSequenceClassification

tokenizer = AutoTokenizer.from_pretrained("distilbert-base-uncased")
model = DistilBertForSequenceClassification.from_pretrained("distilbert-base-uncased", 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 = DistilBertForSequenceClassification.from_pretrained(
    "distilbert-base-uncased", 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, DistilBertForSequenceClassification

<span class="hljs-meta">&gt;&gt;&gt; </span>tokenizer = AutoTokenizer.from_pretrained(<span class="hljs-string">&quot;distilbert-base-uncased&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>model = DistilBertForSequenceClassification.from_pretrained(<span class="hljs-string">&quot;distilbert-base-uncased&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 = DistilBertForSequenceClassification.from_pretrained(
<span class="hljs-meta">... </span>    <span class="hljs-string">&quot;distilbert-base-uncased&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=r("p"),k=o("Example of multi-label classification:"),f=p(),w(m.$$.fragment)},l(l){d=a(l,"P",{});var u=i(d);k=s(u,"Example of multi-label classification:"),u.forEach(t),f=h(l),T(m.$$.fragment,l)},m(l,u){g(l,d,u),e(d,k),g(l,f,u),y(m,l,u),b=!0},p:Pe,i(l){b||($(m.$$.fragment,l),b=!0)},o(l){F(m.$$.fragment,l),b=!1},d(l){l&&t(d),l&&t(f),D(m,l)}}}function c3(x){let d,k,f,m,b;return{c(){d=r("p"),k=o("Although the recipe for forward pass needs to be defined within this function, one should call the "),f=r("code"),m=o("Module"),b=o(`
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=a(l,"P",{});var u=i(d);k=s(u,"Although the recipe for forward pass needs to be defined within this function, one should call the "),f=a(u,"CODE",{});var M=i(f);m=s(M,"Module"),M.forEach(t),b=s(u,`
instance afterwards instead of this since the former takes care of running the pre and post processing steps while
the latter silently ignores them.`),u.forEach(t)},m(l,u){g(l,d,u),e(d,k),e(d,f),e(f,m),e(d,b)},d(l){l&&t(d)}}}function p3(x){let d,k,f,m,b;return m=new Le({props:{code:`from transformers import AutoTokenizer, DistilBertForMultipleChoice
import torch

tokenizer = AutoTokenizer.from_pretrained("distilbert-base-cased")
model = DistilBertForMultipleChoice.from_pretrained("distilbert-base-cased")

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, choice0], [prompt, 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, DistilBertForMultipleChoice
<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;distilbert-base-cased&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>model = DistilBertForMultipleChoice.from_pretrained(<span class="hljs-string">&quot;distilbert-base-cased&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, choice0], [prompt, 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=r("p"),k=o("Examples:"),f=p(),w(m.$$.fragment)},l(l){d=a(l,"P",{});var u=i(d);k=s(u,"Examples:"),u.forEach(t),f=h(l),T(m.$$.fragment,l)},m(l,u){g(l,d,u),e(d,k),g(l,f,u),y(m,l,u),b=!0},p:Pe,i(l){b||($(m.$$.fragment,l),b=!0)},o(l){F(m.$$.fragment,l),b=!1},d(l){l&&t(d),l&&t(f),D(m,l)}}}function h3(x){let d,k,f,m,b;return{c(){d=r("p"),k=o("Although the recipe for forward pass needs to be defined within this function, one should call the "),f=r("code"),m=o("Module"),b=o(`
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=a(l,"P",{});var u=i(d);k=s(u,"Although the recipe for forward pass needs to be defined within this function, one should call the "),f=a(u,"CODE",{});var M=i(f);m=s(M,"Module"),M.forEach(t),b=s(u,`
instance afterwards instead of this since the former takes care of running the pre and post processing steps while
the latter silently ignores them.`),u.forEach(t)},m(l,u){g(l,d,u),e(d,k),e(d,f),e(f,m),e(d,b)},d(l){l&&t(d)}}}function u3(x){let d,k,f,m,b;return m=new Le({props:{code:`from transformers import AutoTokenizer, DistilBertForTokenClassification
import torch

tokenizer = AutoTokenizer.from_pretrained("distilbert-base-uncased")
model = DistilBertForTokenClassification.from_pretrained("distilbert-base-uncased")

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, DistilBertForTokenClassification
<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;distilbert-base-uncased&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>model = DistilBertForTokenClassification.from_pretrained(<span class="hljs-string">&quot;distilbert-base-uncased&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=r("p"),k=o("Example:"),f=p(),w(m.$$.fragment)},l(l){d=a(l,"P",{});var u=i(d);k=s(u,"Example:"),u.forEach(t),f=h(l),T(m.$$.fragment,l)},m(l,u){g(l,d,u),e(d,k),g(l,f,u),y(m,l,u),b=!0},p:Pe,i(l){b||($(m.$$.fragment,l),b=!0)},o(l){F(m.$$.fragment,l),b=!1},d(l){l&&t(d),l&&t(f),D(m,l)}}}function f3(x){let d,k,f,m,b;return{c(){d=r("p"),k=o("Although the recipe for forward pass needs to be defined within this function, one should call the "),f=r("code"),m=o("Module"),b=o(`
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=a(l,"P",{});var u=i(d);k=s(u,"Although the recipe for forward pass needs to be defined within this function, one should call the "),f=a(u,"CODE",{});var M=i(f);m=s(M,"Module"),M.forEach(t),b=s(u,`
instance afterwards instead of this since the former takes care of running the pre and post processing steps while
the latter silently ignores them.`),u.forEach(t)},m(l,u){g(l,d,u),e(d,k),e(d,f),e(f,m),e(d,b)},d(l){l&&t(d)}}}function m3(x){let d,k,f,m,b;return m=new Le({props:{code:`from transformers import AutoTokenizer, DistilBertForQuestionAnswering
import torch

tokenizer = AutoTokenizer.from_pretrained("distilbert-base-uncased")
model = DistilBertForQuestionAnswering.from_pretrained("distilbert-base-uncased")

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

tokenizer = AutoTokenizer.from_pretrained("distilbert-base-uncased")
model = TFDistilBertModel.from_pretrained("distilbert-base-uncased")

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

tokenizer = AutoTokenizer.from_pretrained("distilbert-base-uncased")
model = TFDistilBertForMaskedLM.from_pretrained("distilbert-base-uncased")

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

tokenizer = AutoTokenizer.from_pretrained("distilbert-base-uncased")
model = TFDistilBertForSequenceClassification.from_pretrained("distilbert-base-uncased")

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

tokenizer = AutoTokenizer.from_pretrained("distilbert-base-uncased")
model = TFDistilBertForMultipleChoice.from_pretrained("distilbert-base-uncased")

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

tokenizer = AutoTokenizer.from_pretrained("distilbert-base-uncased")
model = TFDistilBertForTokenClassification.from_pretrained("distilbert-base-uncased")

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

tokenizer = AutoTokenizer.from_pretrained("distilbert-base-uncased")
model = TFDistilBertForQuestionAnswering.from_pretrained("distilbert-base-uncased")

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, TFDistilBertForQuestionAnswering
<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;distilbert-base-uncased&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>model = TFDistilBertForQuestionAnswering.from_pretrained(<span class="hljs-string">&quot;distilbert-base-uncased&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=r("p"),k=o("Example:"),f=p(),w(m.$$.fragment)},l(l){d=a(l,"P",{});var u=i(d);k=s(u,"Example:"),u.forEach(t),f=h(l),T(m.$$.fragment,l)},m(l,u){g(l,d,u),e(d,k),g(l,f,u),y(m,l,u),b=!0},p:Pe,i(l){b||($(m.$$.fragment,l),b=!0)},o(l){F(m.$$.fragment,l),b=!1},d(l){l&&t(d),l&&t(f),D(m,l)}}}function L3(x){let d,k;return d=new Le({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(f){T(d.$$.fragment,f)},m(f,m){y(d,f,m),k=!0},p:Pe,i(f){k||($(d.$$.fragment,f),k=!0)},o(f){F(d.$$.fragment,f),k=!1},d(f){D(d,f)}}}function O3(x){let d,k,f,m,b;return{c(){d=r("p"),k=o("Although the recipe for forward pass needs to be defined within this function, one should call the "),f=r("code"),m=o("Module"),b=o(`
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=a(l,"P",{});var u=i(d);k=s(u,"Although the recipe for forward pass needs to be defined within this function, one should call the "),f=a(u,"CODE",{});var M=i(f);m=s(M,"Module"),M.forEach(t),b=s(u,`
instance afterwards instead of this since the former takes care of running the pre and post processing steps while
the latter silently ignores them.`),u.forEach(t)},m(l,u){g(l,d,u),e(d,k),e(d,f),e(f,m),e(d,b)},d(l){l&&t(d)}}}function I3(x){let d,k,f,m,b;return m=new Le({props:{code:`from transformers import AutoTokenizer, FlaxDistilBertModel

tokenizer = AutoTokenizer.from_pretrained("distilbert-base-uncased")
model = FlaxDistilBertModel.from_pretrained("distilbert-base-uncased")

inputs = tokenizer("Hello, my dog is cute", return_tensors="jax")
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, FlaxDistilBertModel

<span class="hljs-meta">&gt;&gt;&gt; </span>tokenizer = AutoTokenizer.from_pretrained(<span class="hljs-string">&quot;distilbert-base-uncased&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>model = FlaxDistilBertModel.from_pretrained(<span class="hljs-string">&quot;distilbert-base-uncased&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;jax&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=r("p"),k=o("Example:"),f=p(),w(m.$$.fragment)},l(l){d=a(l,"P",{});var u=i(d);k=s(u,"Example:"),u.forEach(t),f=h(l),T(m.$$.fragment,l)},m(l,u){g(l,d,u),e(d,k),g(l,f,u),y(m,l,u),b=!0},p:Pe,i(l){b||($(m.$$.fragment,l),b=!0)},o(l){F(m.$$.fragment,l),b=!1},d(l){l&&t(d),l&&t(f),D(m,l)}}}function S3(x){let d,k,f,m,b;return{c(){d=r("p"),k=o("Although the recipe for forward pass needs to be defined within this function, one should call the "),f=r("code"),m=o("Module"),b=o(`
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=a(l,"P",{});var u=i(d);k=s(u,"Although the recipe for forward pass needs to be defined within this function, one should call the "),f=a(u,"CODE",{});var M=i(f);m=s(M,"Module"),M.forEach(t),b=s(u,`
instance afterwards instead of this since the former takes care of running the pre and post processing steps while
the latter silently ignores them.`),u.forEach(t)},m(l,u){g(l,d,u),e(d,k),e(d,f),e(f,m),e(d,b)},d(l){l&&t(d)}}}function N3(x){let d,k,f,m,b;return m=new Le({props:{code:`from transformers import AutoTokenizer, FlaxDistilBertForMaskedLM

tokenizer = AutoTokenizer.from_pretrained("distilbert-base-uncased")
model = FlaxDistilBertForMaskedLM.from_pretrained("distilbert-base-uncased")

inputs = tokenizer("The capital of France is [MASK].", return_tensors="jax")

outputs = model(**inputs)
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, FlaxDistilBertForMaskedLM

<span class="hljs-meta">&gt;&gt;&gt; </span>tokenizer = AutoTokenizer.from_pretrained(<span class="hljs-string">&quot;distilbert-base-uncased&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>model = FlaxDistilBertForMaskedLM.from_pretrained(<span class="hljs-string">&quot;distilbert-base-uncased&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;jax&quot;</span>)

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

tokenizer = AutoTokenizer.from_pretrained("distilbert-base-uncased")
model = FlaxDistilBertForSequenceClassification.from_pretrained("distilbert-base-uncased")

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

outputs = model(**inputs)
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, FlaxDistilBertForSequenceClassification

<span class="hljs-meta">&gt;&gt;&gt; </span>tokenizer = AutoTokenizer.from_pretrained(<span class="hljs-string">&quot;distilbert-base-uncased&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>model = FlaxDistilBertForSequenceClassification.from_pretrained(<span class="hljs-string">&quot;distilbert-base-uncased&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;jax&quot;</span>)

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

tokenizer = AutoTokenizer.from_pretrained("distilbert-base-uncased")
model = FlaxDistilBertForMultipleChoice.from_pretrained("distilbert-base-uncased")

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="jax", padding=True)
outputs = model(**{k: v[None, :] for k, v in encoding.items()})

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, FlaxDistilBertForMultipleChoice

<span class="hljs-meta">&gt;&gt;&gt; </span>tokenizer = AutoTokenizer.from_pretrained(<span class="hljs-string">&quot;distilbert-base-uncased&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>model = FlaxDistilBertForMultipleChoice.from_pretrained(<span class="hljs-string">&quot;distilbert-base-uncased&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;jax&quot;</span>, padding=<span class="hljs-literal">True</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>outputs = model(**{k: v[<span class="hljs-literal">None</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>logits = outputs.logits`}}),{c(){d=r("p"),k=o("Example:"),f=p(),w(m.$$.fragment)},l(l){d=a(l,"P",{});var u=i(d);k=s(u,"Example:"),u.forEach(t),f=h(l),T(m.$$.fragment,l)},m(l,u){g(l,d,u),e(d,k),g(l,f,u),y(m,l,u),b=!0},p:Pe,i(l){b||($(m.$$.fragment,l),b=!0)},o(l){F(m.$$.fragment,l),b=!1},d(l){l&&t(d),l&&t(f),D(m,l)}}}function H3(x){let d,k,f,m,b;return{c(){d=r("p"),k=o("Although the recipe for forward pass needs to be defined within this function, one should call the "),f=r("code"),m=o("Module"),b=o(`
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=a(l,"P",{});var u=i(d);k=s(u,"Although the recipe for forward pass needs to be defined within this function, one should call the "),f=a(u,"CODE",{});var M=i(f);m=s(M,"Module"),M.forEach(t),b=s(u,`
instance afterwards instead of this since the former takes care of running the pre and post processing steps while
the latter silently ignores them.`),u.forEach(t)},m(l,u){g(l,d,u),e(d,k),e(d,f),e(f,m),e(d,b)},d(l){l&&t(d)}}}function K3(x){let d,k,f,m,b;return m=new Le({props:{code:`from transformers import AutoTokenizer, FlaxDistilBertForTokenClassification

tokenizer = AutoTokenizer.from_pretrained("distilbert-base-uncased")
model = FlaxDistilBertForTokenClassification.from_pretrained("distilbert-base-uncased")

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

outputs = model(**inputs)
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, FlaxDistilBertForTokenClassification

<span class="hljs-meta">&gt;&gt;&gt; </span>tokenizer = AutoTokenizer.from_pretrained(<span class="hljs-string">&quot;distilbert-base-uncased&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>model = FlaxDistilBertForTokenClassification.from_pretrained(<span class="hljs-string">&quot;distilbert-base-uncased&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;jax&quot;</span>)

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

tokenizer = AutoTokenizer.from_pretrained("distilbert-base-uncased")
model = FlaxDistilBertForQuestionAnswering.from_pretrained("distilbert-base-uncased")

question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"
inputs = tokenizer(question, text, return_tensors="jax")

outputs = model(**inputs)
start_scores = outputs.start_logits
end_scores = outputs.end_logits`,highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> AutoTokenizer, FlaxDistilBertForQuestionAnswering

<span class="hljs-meta">&gt;&gt;&gt; </span>tokenizer = AutoTokenizer.from_pretrained(<span class="hljs-string">&quot;distilbert-base-uncased&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>model = FlaxDistilBertForQuestionAnswering.from_pretrained(<span class="hljs-string">&quot;distilbert-base-uncased&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;jax&quot;</span>)

<span class="hljs-meta">&gt;&gt;&gt; </span>outputs = model(**inputs)
<span class="hljs-meta">&gt;&gt;&gt; </span>start_scores = outputs.start_logits
<span class="hljs-meta">&gt;&gt;&gt; </span>end_scores = outputs.end_logits`}}),{c(){d=r("p"),k=o("Example:"),f=p(),w(m.$$.fragment)},l(l){d=a(l,"P",{});var u=i(d);k=s(u,"Example:"),u.forEach(t),f=h(l),T(m.$$.fragment,l)},m(l,u){g(l,d,u),e(d,k),g(l,f,u),y(m,l,u),b=!0},p:Pe,i(l){b||($(m.$$.fragment,l),b=!0)},o(l){F(m.$$.fragment,l),b=!1},d(l){l&&t(d),l&&t(f),D(m,l)}}}function G3(x){let d,k,f,m,b,l,u,M,be,ue,I,re,oe,E,ke,Q,ve,fe,L,we,ae,K,Te,ie,V,ye,de,J,$e,me,ee,C,q,le,H,Fe,ge,U,De,_e,A,se,G,ce,Ee,X,pe,xe,S,he,Y,Be,ne,j,Me,P,ze,Ce,v,B,He,Z,Ke,Ve,z,Je,Ge,Oe,Xe,Ye,O,N,je,Re,W,Ze,We,Ae,Qe,te,et,Uf,zr,Qf,Ie,Cr,v_,Ar,w_,T_,y_,jr,$_,qr,F_,D_,E_,Pr,x_,Lr,B_,M_,z_,Or,C_,Ir,A_,j_,q_,Sr,P_,Nr,L_,O_,I_,Rr,S_,Wr,N_,R_,W_,Ur,U_,Qr,Q_,H_,K_,mo,tc,V_,J_,Hr,G_,X_,Kr,Y_,Z_,eb,go,oc,tb,ob,Vr,sb,nb,Jr,rb,ab,ib,_o,sc,lb,db,Gr,cb,pb,Xr,hb,ub,Hf,Yr,Kf,jt,bo,nc,fb,mb,Zr,gb,_b,ea,bb,kb,vb,ko,rc,wb,Tb,ta,yb,$b,oa,Fb,Db,Eb,qs,ac,xb,Bb,sa,Mb,zb,Cb,ic,na,Ab,jb,Vf,ra,Jf,qt,vo,lc,qb,Pb,aa,Lb,Ob,ia,Ib,Sb,Nb,wo,dc,Rb,Wb,la,Ub,Qb,da,Hb,Kb,Vb,To,cc,Jb,Gb,ca,Xb,Yb,pa,Zb,ek,tk,pc,ha,ok,sk,Gf,ua,Xf,Pt,yo,hc,nk,rk,fa,ak,ik,ma,lk,dk,ck,$o,uc,pk,hk,ga,uk,fk,_a,mk,gk,_k,Ps,fc,bk,kk,ba,vk,wk,Tk,mc,ka,yk,$k,Yf,gc,Pp,Fk,Zf,Ls,Fo,_c,Dk,Ek,va,xk,Bk,wa,Mk,zk,Ck,Do,bc,Ak,jk,Ta,qk,Pk,ya,Lk,Ok,em,kc,Ik,tm,Eo,$a,Sk,Fa,Nk,Rk,Wk,Da,Uk,Ea,Qk,Hk,Kk,xa,Vk,Ba,Jk,Gk,om,vc,Xk,sm,Os,Ma,Yk,za,Zk,ev,tv,Ca,ov,Aa,sv,nv,nm,wc,rv,rm,xo,ja,av,qa,iv,lv,dv,Pa,cv,La,pv,hv,uv,Oa,fv,Ia,mv,gv,am,Uo,Is,Lp,Sa,_v,Op,bv,im,At,Na,kv,no,vv,Tc,wv,Tv,yc,yv,$v,Ra,Fv,Dv,Ev,Qo,xv,$c,Bv,Mv,Fc,zv,Cv,Av,Ss,lm,Ho,Ns,Ip,Wa,jv,Sp,qv,dm,tt,Ua,Pv,Np,Lv,Ov,Qa,Iv,Dc,Sv,Nv,Rv,Bo,Ha,Wv,Rp,Uv,Qv,Ka,Ec,Hv,Wp,Kv,Vv,xc,Jv,Up,Gv,Xv,Rs,Va,Yv,Qp,Zv,ew,Lt,Ja,tw,Hp,ow,sw,Ws,nw,Ko,rw,Kp,aw,iw,Vp,lw,dw,cw,Us,Ga,pw,Xa,hw,Jp,uw,fw,cm,Vo,Qs,Gp,Ya,mw,Xp,gw,pm,ft,Za,_w,ei,bw,Yp,kw,vw,ww,ti,Tw,Bc,yw,$w,Fw,Mo,oi,Dw,Zp,Ew,xw,si,Mc,Bw,eh,Mw,zw,zc,Cw,th,Aw,jw,Ot,ni,qw,oh,Pw,Lw,Hs,Ow,Jo,Iw,sh,Sw,Nw,nh,Rw,Ww,hm,Go,Ks,rh,ri,Uw,ah,Qw,um,mt,ai,Hw,ih,Kw,Vw,ii,Jw,Cc,Gw,Xw,Yw,li,Zw,di,eT,tT,oT,It,ci,sT,Xo,nT,Ac,rT,aT,lh,iT,lT,dT,Vs,cT,Js,fm,Yo,Gs,dh,pi,pT,ch,hT,mm,gt,hi,uT,ui,fT,ph,mT,gT,_T,fi,bT,jc,kT,vT,wT,mi,TT,gi,yT,$T,FT,St,_i,DT,Zo,ET,qc,xT,BT,hh,MT,zT,CT,Xs,AT,Ys,gm,es,Zs,uh,bi,jT,fh,qT,_m,_t,ki,PT,mh,LT,OT,vi,IT,Pc,ST,NT,RT,wi,WT,Ti,UT,QT,HT,wt,yi,KT,ts,VT,Lc,JT,GT,gh,XT,YT,ZT,en,ey,tn,ty,on,bm,os,sn,_h,$i,oy,bh,sy,km,bt,Fi,ny,kh,ry,ay,Di,iy,Oc,ly,dy,cy,Ei,py,xi,hy,uy,fy,Nt,Bi,my,ss,gy,Ic,_y,by,vh,ky,vy,wy,nn,Ty,rn,vm,ns,an,wh,Mi,yy,Th,$y,wm,kt,zi,Fy,yh,Dy,Ey,Ci,xy,Sc,By,My,zy,Ai,Cy,ji,Ay,jy,qy,Rt,qi,Py,rs,Ly,Nc,Oy,Iy,$h,Sy,Ny,Ry,ln,Wy,dn,Tm,as,cn,Fh,Pi,Uy,Dh,Qy,ym,vt,Li,Hy,is,Ky,Eh,Vy,Jy,xh,Gy,Xy,Yy,Oi,Zy,Rc,e$,t$,o$,Ii,s$,Si,n$,r$,a$,Wt,Ni,i$,ls,l$,Wc,d$,c$,Bh,p$,h$,u$,pn,f$,hn,$m,ds,un,Mh,Ri,m$,zh,g$,Fm,lt,Wi,_$,Ch,b$,k$,Ui,v$,Uc,w$,T$,y$,Qi,$$,Hi,F$,D$,E$,fn,x$,Ut,Ki,B$,cs,M$,Qc,z$,C$,Ah,A$,j$,q$,mn,P$,gn,Dm,ps,_n,jh,Vi,L$,qh,O$,Em,dt,Ji,I$,Gi,S$,Ph,N$,R$,W$,Xi,U$,Hc,Q$,H$,K$,Yi,V$,Zi,J$,G$,X$,bn,Y$,Tt,el,Z$,hs,e1,Kc,t1,o1,Lh,s1,n1,r1,kn,a1,vn,i1,wn,xm,us,Tn,Oh,tl,l1,Ih,d1,Bm,ct,ol,c1,Sh,p1,h1,sl,u1,Vc,f1,m1,g1,nl,_1,rl,b1,k1,v1,yn,w1,yt,al,T1,fs,y1,Jc,$1,F1,Nh,D1,E1,x1,$n,B1,Fn,M1,Dn,Mm,ms,En,Rh,il,z1,Wh,C1,zm,pt,ll,A1,Uh,j1,q1,dl,P1,Gc,L1,O1,I1,cl,S1,pl,N1,R1,W1,xn,U1,Qt,hl,Q1,gs,H1,Xc,K1,V1,Qh,J1,G1,X1,Bn,Y1,Mn,Cm,_s,zn,Hh,ul,Z1,Kh,e2,Am,ht,fl,t2,Vh,o2,s2,ml,n2,Yc,r2,a2,i2,gl,l2,_l,d2,c2,p2,Cn,h2,$t,bl,u2,bs,f2,Zc,m2,g2,Jh,_2,b2,k2,An,v2,jn,w2,qn,jm,ks,Pn,Gh,kl,T2,Xh,y2,qm,ut,vl,$2,vs,F2,Yh,D2,E2,Zh,x2,B2,M2,wl,z2,ep,C2,A2,j2,Tl,q2,yl,P2,L2,O2,Ln,I2,Ft,$l,S2,ws,N2,tp,R2,W2,eu,U2,Q2,H2,On,K2,In,V2,Sn,Pm,Ts,Nn,tu,Fl,J2,ou,G2,Lm,ot,Dl,X2,su,Y2,Z2,El,eF,op,tF,oF,sF,xl,nF,Bl,rF,aF,iF,nu,lF,dF,ro,ru,Ml,cF,pF,au,zl,hF,uF,iu,Cl,fF,mF,lu,Al,gF,_F,Ht,jl,bF,ys,kF,du,vF,wF,cu,TF,yF,$F,Rn,FF,Wn,Om,$s,Un,pu,ql,DF,hu,EF,Im,st,Pl,xF,Ll,BF,uu,MF,zF,CF,Ol,AF,sp,jF,qF,PF,Il,LF,Sl,OF,IF,SF,fu,NF,RF,ao,mu,Nl,WF,UF,gu,Rl,QF,HF,_u,Wl,KF,VF,bu,Ul,JF,GF,Kt,Ql,XF,Fs,YF,ku,ZF,eD,vu,tD,oD,sD,Qn,nD,Hn,Sm,Ds,Kn,wu,Hl,rD,Tu,aD,Nm,nt,Kl,iD,yu,lD,dD,Vl,cD,np,pD,hD,uD,Jl,fD,Gl,mD,gD,_D,$u,bD,kD,io,Fu,Xl,vD,wD,Du,Yl,TD,yD,Eu,Zl,$D,FD,xu,ed,DD,ED,Vt,td,xD,Es,BD,Bu,MD,zD,Mu,CD,AD,jD,Vn,qD,Jn,Rm,xs,Gn,zu,od,PD,Cu,LD,Wm,rt,sd,OD,Au,ID,SD,nd,ND,rp,RD,WD,UD,rd,QD,ad,HD,KD,VD,ju,JD,GD,lo,qu,id,XD,YD,Pu,ld,ZD,e0,Lu,dd,t0,o0,Ou,cd,s0,n0,Jt,pd,r0,Bs,a0,Iu,i0,l0,Su,d0,c0,p0,Xn,h0,Yn,Um,Ms,Zn,Nu,hd,u0,Ru,f0,Qm,at,ud,m0,Wu,g0,_0,fd,b0,ap,k0,v0,w0,md,T0,gd,y0,$0,F0,Uu,D0,E0,co,Qu,_d,x0,B0,Hu,bd,M0,z0,Ku,kd,C0,A0,Vu,vd,j0,q0,Gt,wd,P0,zs,L0,Ju,O0,I0,Gu,S0,N0,R0,er,W0,tr,Hm,Cs,or,Xu,Td,U0,Yu,Q0,Km,it,yd,H0,As,K0,Zu,V0,J0,ef,G0,X0,Y0,$d,Z0,ip,eE,tE,oE,Fd,sE,Dd,nE,rE,aE,tf,iE,lE,po,of,Ed,dE,cE,sf,xd,pE,hE,nf,Bd,uE,fE,rf,Md,mE,gE,Xt,zd,_E,js,bE,af,kE,vE,lf,wE,TE,yE,sr,$E,nr,Vm;return l=new Ne({}),E=new Ne({}),W=new Ne({}),zr=new k_({props:{pipeline:"text-classification"}}),Yr=new k_({props:{pipeline:"token-classification"}}),ra=new k_({props:{pipeline:"fill-mask"}}),ua=new k_({props:{pipeline:"question-answering"}}),Sa=new Ne({}),Na=new R({props:{name:"class transformers.DistilBertConfig",anchor:"transformers.DistilBertConfig",parameters:[{name:"vocab_size",val:" = 30522"},{name:"max_position_embeddings",val:" = 512"},{name:"sinusoidal_pos_embds",val:" = False"},{name:"n_layers",val:" = 6"},{name:"n_heads",val:" = 12"},{name:"dim",val:" = 768"},{name:"hidden_dim",val:" = 3072"},{name:"dropout",val:" = 0.1"},{name:"attention_dropout",val:" = 0.1"},{name:"activation",val:" = 'gelu'"},{name:"initializer_range",val:" = 0.02"},{name:"qa_dropout",val:" = 0.1"},{name:"seq_classif_dropout",val:" = 0.2"},{name:"pad_token_id",val:" = 0"},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"transformers.DistilBertConfig.vocab_size",description:`<strong>vocab_size</strong> (<code>int</code>, <em>optional</em>, defaults to 30522) &#x2014;
Vocabulary size of the DistilBERT model. 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/distilbert#transformers.DistilBertModel">DistilBertModel</a> or <a href="/docs/transformers/main/en/model_doc/distilbert#transformers.TFDistilBertModel">TFDistilBertModel</a>.`,name:"vocab_size"},{anchor:"transformers.DistilBertConfig.max_position_embeddings",description:`<strong>max_position_embeddings</strong> (<code>int</code>, <em>optional</em>, defaults to 512) &#x2014;
The maximum sequence length that this model might ever be used with. Typically set this to something large
just in case (e.g., 512 or 1024 or 2048).`,name:"max_position_embeddings"},{anchor:"transformers.DistilBertConfig.sinusoidal_pos_embds",description:`<strong>sinusoidal_pos_embds</strong> (<code>boolean</code>, <em>optional</em>, defaults to <code>False</code>) &#x2014;
Whether to use sinusoidal positional embeddings.`,name:"sinusoidal_pos_embds"},{anchor:"transformers.DistilBertConfig.n_layers",description:`<strong>n_layers</strong> (<code>int</code>, <em>optional</em>, defaults to 6) &#x2014;
Number of hidden layers in the Transformer encoder.`,name:"n_layers"},{anchor:"transformers.DistilBertConfig.n_heads",description:`<strong>n_heads</strong> (<code>int</code>, <em>optional</em>, defaults to 12) &#x2014;
Number of attention heads for each attention layer in the Transformer encoder.`,name:"n_heads"},{anchor:"transformers.DistilBertConfig.dim",description:`<strong>dim</strong> (<code>int</code>, <em>optional</em>, defaults to 768) &#x2014;
Dimensionality of the encoder layers and the pooler layer.`,name:"dim"},{anchor:"transformers.DistilBertConfig.hidden_dim",description:`<strong>hidden_dim</strong> (<code>int</code>, <em>optional</em>, defaults to 3072) &#x2014;
The size of the &#x201C;intermediate&#x201D; (often named feed-forward) layer in the Transformer encoder.`,name:"hidden_dim"},{anchor:"transformers.DistilBertConfig.dropout",description:`<strong>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:"dropout"},{anchor:"transformers.DistilBertConfig.attention_dropout",description:`<strong>attention_dropout</strong> (<code>float</code>, <em>optional</em>, defaults to 0.1) &#x2014;
The dropout ratio for the attention probabilities.`,name:"attention_dropout"},{anchor:"transformers.DistilBertConfig.activation",description:`<strong>activation</strong> (<code>str</code> or <code>Callable</code>, <em>optional</em>, defaults to <code>&quot;gelu&quot;</code>) &#x2014;
The non-linear activation function (function or string) in the encoder and pooler. If string, <code>&quot;gelu&quot;</code>,
<code>&quot;relu&quot;</code>, <code>&quot;silu&quot;</code> and <code>&quot;gelu_new&quot;</code> are supported.`,name:"activation"},{anchor:"transformers.DistilBertConfig.initializer_range",description:`<strong>initializer_range</strong> (<code>float</code>, <em>optional</em>, defaults to 0.02) &#x2014;
The standard deviation of the truncated_normal_initializer for initializing all weight matrices.`,name:"initializer_range"},{anchor:"transformers.DistilBertConfig.qa_dropout",description:`<strong>qa_dropout</strong> (<code>float</code>, <em>optional</em>, defaults to 0.1) &#x2014;
The dropout probabilities used in the question answering model <a href="/docs/transformers/main/en/model_doc/distilbert#transformers.DistilBertForQuestionAnswering">DistilBertForQuestionAnswering</a>.`,name:"qa_dropout"},{anchor:"transformers.DistilBertConfig.seq_classif_dropout",description:`<strong>seq_classif_dropout</strong> (<code>float</code>, <em>optional</em>, defaults to 0.2) &#x2014;
The dropout probabilities used in the sequence classification and the multiple choice model
<a href="/docs/transformers/main/en/model_doc/distilbert#transformers.DistilBertForSequenceClassification">DistilBertForSequenceClassification</a>.`,name:"seq_classif_dropout"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/distilbert/configuration_distilbert.py#L45"}}),Ss=new qe({props:{anchor:"transformers.DistilBertConfig.example",$$slots:{default:[e3]},$$scope:{ctx:x}}}),Wa=new Ne({}),Ua=new R({props:{name:"class transformers.DistilBertTokenizer",anchor:"transformers.DistilBertTokenizer",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:"tokenize_chinese_chars",val:" = True"},{name:"strip_accents",val:" = None"},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"transformers.DistilBertTokenizer.vocab_file",description:`<strong>vocab_file</strong> (<code>str</code>) &#x2014;
File containing the vocabulary.`,name:"vocab_file"},{anchor:"transformers.DistilBertTokenizer.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.DistilBertTokenizer.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.DistilBertTokenizer.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.DistilBertTokenizer.unk_token",description:`<strong>unk_token</strong> (<code>str</code>, <em>optional</em>, defaults to <code>&quot;[UNK]&quot;</code>) &#x2014;
The unknown token. A token that is not in the vocabulary cannot be converted to an ID and is set to be this
token instead.`,name:"unk_token"},{anchor:"transformers.DistilBertTokenizer.sep_token",description:`<strong>sep_token</strong> (<code>str</code>, <em>optional</em>, defaults to <code>&quot;[SEP]&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.DistilBertTokenizer.pad_token",description:`<strong>pad_token</strong> (<code>str</code>, <em>optional</em>, defaults to <code>&quot;[PAD]&quot;</code>) &#x2014;
The token used for padding, for example when batching sequences of different lengths.`,name:"pad_token"},{anchor:"transformers.DistilBertTokenizer.cls_token",description:`<strong>cls_token</strong> (<code>str</code>, <em>optional</em>, defaults to <code>&quot;[CLS]&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.DistilBertTokenizer.mask_token",description:`<strong>mask_token</strong> (<code>str</code>, <em>optional</em>, defaults to <code>&quot;[MASK]&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.DistilBertTokenizer.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.DistilBertTokenizer.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/distilbert/tokenization_distilbert.py#L89"}}),Ha=new R({props:{name:"build_inputs_with_special_tokens",anchor:"transformers.DistilBertTokenizer.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.DistilBertTokenizer.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.DistilBertTokenizer.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/distilbert/tokenization_distilbert.py#L229",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>
`}}),Va=new R({props:{name:"convert_tokens_to_string",anchor:"transformers.DistilBertTokenizer.convert_tokens_to_string",parameters:[{name:"tokens",val:""}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/distilbert/tokenization_distilbert.py#L223"}}),Ja=new R({props:{name:"create_token_type_ids_from_sequences",anchor:"transformers.DistilBertTokenizer.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.DistilBertTokenizer.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.DistilBertTokenizer.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/distilbert/tokenization_distilbert.py#L284",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>
`}}),Ws=new qe({props:{anchor:"transformers.DistilBertTokenizer.create_token_type_ids_from_sequences.example",$$slots:{default:[t3]},$$scope:{ctx:x}}}),Ga=new R({props:{name:"get_special_tokens_mask",anchor:"transformers.DistilBertTokenizer.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.DistilBertTokenizer.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.DistilBertTokenizer.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.DistilBertTokenizer.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/distilbert/tokenization_distilbert.py#L255",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>
`}}),Ya=new Ne({}),Za=new R({props:{name:"class transformers.DistilBertTokenizerFast",anchor:"transformers.DistilBertTokenizerFast",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:"tokenize_chinese_chars",val:" = True"},{name:"strip_accents",val:" = None"},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"transformers.DistilBertTokenizerFast.vocab_file",description:`<strong>vocab_file</strong> (<code>str</code>) &#x2014;
File containing the vocabulary.`,name:"vocab_file"},{anchor:"transformers.DistilBertTokenizerFast.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.DistilBertTokenizerFast.unk_token",description:`<strong>unk_token</strong> (<code>str</code>, <em>optional</em>, defaults to <code>&quot;[UNK]&quot;</code>) &#x2014;
The unknown token. A token that is not in the vocabulary cannot be converted to an ID and is set to be this
token instead.`,name:"unk_token"},{anchor:"transformers.DistilBertTokenizerFast.sep_token",description:`<strong>sep_token</strong> (<code>str</code>, <em>optional</em>, defaults to <code>&quot;[SEP]&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.DistilBertTokenizerFast.pad_token",description:`<strong>pad_token</strong> (<code>str</code>, <em>optional</em>, defaults to <code>&quot;[PAD]&quot;</code>) &#x2014;
The token used for padding, for example when batching sequences of different lengths.`,name:"pad_token"},{anchor:"transformers.DistilBertTokenizerFast.cls_token",description:`<strong>cls_token</strong> (<code>str</code>, <em>optional</em>, defaults to <code>&quot;[CLS]&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.DistilBertTokenizerFast.mask_token",description:`<strong>mask_token</strong> (<code>str</code>, <em>optional</em>, defaults to <code>&quot;[MASK]&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.DistilBertTokenizerFast.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.DistilBertTokenizerFast.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.DistilBertTokenizerFast.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.DistilBertTokenizerFast.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/distilbert/tokenization_distilbert_fast.py#L84"}}),oi=new R({props:{name:"build_inputs_with_special_tokens",anchor:"transformers.DistilBertTokenizerFast.build_inputs_with_special_tokens",parameters:[{name:"token_ids_0",val:""},{name:"token_ids_1",val:" = None"}],parametersDescription:[{anchor:"transformers.DistilBertTokenizerFast.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.DistilBertTokenizerFast.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/distilbert/tokenization_distilbert_fast.py#L174",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>
`}}),ni=new R({props:{name:"create_token_type_ids_from_sequences",anchor:"transformers.DistilBertTokenizerFast.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.DistilBertTokenizerFast.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.DistilBertTokenizerFast.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/distilbert/tokenization_distilbert_fast.py#L199",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>
`}}),Hs=new qe({props:{anchor:"transformers.DistilBertTokenizerFast.create_token_type_ids_from_sequences.example",$$slots:{default:[o3]},$$scope:{ctx:x}}}),ri=new Ne({}),ai=new R({props:{name:"class transformers.DistilBertModel",anchor:"transformers.DistilBertModel",parameters:[{name:"config",val:": PretrainedConfig"}],parametersDescription:[{anchor:"transformers.DistilBertModel.config",description:`<strong>config</strong> (<a href="/docs/transformers/main/en/model_doc/distilbert#transformers.DistilBertConfig">DistilBertConfig</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/distilbert/modeling_distilbert.py#L466"}}),ci=new R({props:{name:"forward",anchor:"transformers.DistilBertModel.forward",parameters:[{name:"input_ids",val:": typing.Optional[torch.Tensor] = None"},{name:"attention_mask",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.DistilBertModel.forward.input_ids",description:`<strong>input_ids</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size, num_choices)</code>) &#x2014;
Indices of input sequence tokens in the vocabulary.</p>
<p>Indices can be obtained using <a href="/docs/transformers/main/en/model_doc/auto#transformers.AutoTokenizer">AutoTokenizer</a>. See <a href="/docs/transformers/main/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode">PreTrainedTokenizer.encode()</a> and
<a href="/docs/transformers/main/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__">PreTrainedTokenizer.<strong>call</strong>()</a> for details.</p>
<p><a href="../glossary#input-ids">What are input IDs?</a>`,name:"input_ids"},{anchor:"transformers.DistilBertModel.forward.attention_mask",description:`<strong>attention_mask</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, num_choices)</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.DistilBertModel.forward.head_mask",description:`<strong>head_mask</strong> (<code>torch.FloatTensor</code> of shape <code>(num_heads,)</code> or <code>(num_layers, num_heads)</code>, <em>optional</em>) &#x2014;
Mask to nullify selected heads of the self-attention modules. Mask values selected in <code>[0, 1]</code>:</p>
<ul>
<li>1 indicates the head is <strong>not masked</strong>,</li>
<li>0 indicates the head is <strong>masked</strong>.</li>
</ul>`,name:"head_mask"},{anchor:"transformers.DistilBertModel.forward.inputs_embeds",description:`<strong>inputs_embeds</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, num_choices, 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.DistilBertModel.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.DistilBertModel.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.DistilBertModel.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/distilbert/modeling_distilbert.py#L538",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/distilbert#transformers.DistilBertConfig"
>DistilBertConfig</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>
`}}),Vs=new Se({props:{$$slots:{default:[s3]},$$scope:{ctx:x}}}),Js=new qe({props:{anchor:"transformers.DistilBertModel.forward.example",$$slots:{default:[n3]},$$scope:{ctx:x}}}),pi=new Ne({}),hi=new R({props:{name:"class transformers.DistilBertForMaskedLM",anchor:"transformers.DistilBertForMaskedLM",parameters:[{name:"config",val:": PretrainedConfig"}],parametersDescription:[{anchor:"transformers.DistilBertForMaskedLM.config",description:`<strong>config</strong> (<a href="/docs/transformers/main/en/model_doc/distilbert#transformers.DistilBertConfig">DistilBertConfig</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/distilbert/modeling_distilbert.py#L593"}}),_i=new R({props:{name:"forward",anchor:"transformers.DistilBertForMaskedLM.forward",parameters:[{name:"input_ids",val:": typing.Optional[torch.Tensor] = None"},{name:"attention_mask",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:"labels",val:": typing.Optional[torch.LongTensor] = None"},{name:"output_attentions",val:": typing.Optional[bool] = None"},{name:"output_hidden_states",val:": typing.Optional[bool] = None"},{name:"return_dict",val:": typing.Optional[bool] = None"}],parametersDescription:[{anchor:"transformers.DistilBertForMaskedLM.forward.input_ids",description:`<strong>input_ids</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size, num_choices)</code>) &#x2014;
Indices of input sequence tokens in the vocabulary.</p>
<p>Indices can be obtained using <a href="/docs/transformers/main/en/model_doc/auto#transformers.AutoTokenizer">AutoTokenizer</a>. See <a href="/docs/transformers/main/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode">PreTrainedTokenizer.encode()</a> and
<a href="/docs/transformers/main/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__">PreTrainedTokenizer.<strong>call</strong>()</a> for details.</p>
<p><a href="../glossary#input-ids">What are input IDs?</a>`,name:"input_ids"},{anchor:"transformers.DistilBertForMaskedLM.forward.attention_mask",description:`<strong>attention_mask</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, num_choices)</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.DistilBertForMaskedLM.forward.head_mask",description:`<strong>head_mask</strong> (<code>torch.FloatTensor</code> of shape <code>(num_heads,)</code> or <code>(num_layers, num_heads)</code>, <em>optional</em>) &#x2014;
Mask to nullify selected heads of the self-attention modules. Mask values selected in <code>[0, 1]</code>:</p>
<ul>
<li>1 indicates the head is <strong>not masked</strong>,</li>
<li>0 indicates the head is <strong>masked</strong>.</li>
</ul>`,name:"head_mask"},{anchor:"transformers.DistilBertForMaskedLM.forward.inputs_embeds",description:`<strong>inputs_embeds</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, num_choices, 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.DistilBertForMaskedLM.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.DistilBertForMaskedLM.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.DistilBertForMaskedLM.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.DistilBertForMaskedLM.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/distilbert/modeling_distilbert.py#L637",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/distilbert#transformers.DistilBertConfig"
>DistilBertConfig</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>
`}}),Xs=new Se({props:{$$slots:{default:[r3]},$$scope:{ctx:x}}}),Ys=new qe({props:{anchor:"transformers.DistilBertForMaskedLM.forward.example",$$slots:{default:[a3]},$$scope:{ctx:x}}}),bi=new Ne({}),ki=new R({props:{name:"class transformers.DistilBertForSequenceClassification",anchor:"transformers.DistilBertForSequenceClassification",parameters:[{name:"config",val:": PretrainedConfig"}],parametersDescription:[{anchor:"transformers.DistilBertForSequenceClassification.config",description:`<strong>config</strong> (<a href="/docs/transformers/main/en/model_doc/distilbert#transformers.DistilBertConfig">DistilBertConfig</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/distilbert/modeling_distilbert.py#L700"}}),yi=new R({props:{name:"forward",anchor:"transformers.DistilBertForSequenceClassification.forward",parameters:[{name:"input_ids",val:": typing.Optional[torch.Tensor] = None"},{name:"attention_mask",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:"labels",val:": typing.Optional[torch.LongTensor] = None"},{name:"output_attentions",val:": typing.Optional[bool] = None"},{name:"output_hidden_states",val:": typing.Optional[bool] = None"},{name:"return_dict",val:": typing.Optional[bool] = None"}],parametersDescription:[{anchor:"transformers.DistilBertForSequenceClassification.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/auto#transformers.AutoTokenizer">AutoTokenizer</a>. See <a href="/docs/transformers/main/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode">PreTrainedTokenizer.encode()</a> and
<a href="/docs/transformers/main/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__">PreTrainedTokenizer.<strong>call</strong>()</a> for details.</p>
<p><a href="../glossary#input-ids">What are input IDs?</a>`,name:"input_ids"},{anchor:"transformers.DistilBertForSequenceClassification.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.DistilBertForSequenceClassification.forward.head_mask",description:`<strong>head_mask</strong> (<code>torch.FloatTensor</code> of shape <code>(num_heads,)</code> or <code>(num_layers, num_heads)</code>, <em>optional</em>) &#x2014;
Mask to nullify selected heads of the self-attention modules. Mask values selected in <code>[0, 1]</code>:</p>
<ul>
<li>1 indicates the head is <strong>not masked</strong>,</li>
<li>0 indicates the head is <strong>masked</strong>.</li>
</ul>`,name:"head_mask"},{anchor:"transformers.DistilBertForSequenceClassification.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.DistilBertForSequenceClassification.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.DistilBertForSequenceClassification.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.DistilBertForSequenceClassification.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.DistilBertForSequenceClassification.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/distilbert/modeling_distilbert.py#L734",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/distilbert#transformers.DistilBertConfig"
>DistilBertConfig</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>
`}}),en=new Se({props:{$$slots:{default:[i3]},$$scope:{ctx:x}}}),tn=new qe({props:{anchor:"transformers.DistilBertForSequenceClassification.forward.example",$$slots:{default:[l3]},$$scope:{ctx:x}}}),on=new qe({props:{anchor:"transformers.DistilBertForSequenceClassification.forward.example-2",$$slots:{default:[d3]},$$scope:{ctx:x}}}),$i=new Ne({}),Fi=new R({props:{name:"class transformers.DistilBertForMultipleChoice",anchor:"transformers.DistilBertForMultipleChoice",parameters:[{name:"config",val:": PretrainedConfig"}],parametersDescription:[{anchor:"transformers.DistilBertForMultipleChoice.config",description:`<strong>config</strong> (<a href="/docs/transformers/main/en/model_doc/distilbert#transformers.DistilBertConfig">DistilBertConfig</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/distilbert/modeling_distilbert.py#L1029"}}),Bi=new R({props:{name:"forward",anchor:"transformers.DistilBertForMultipleChoice.forward",parameters:[{name:"input_ids",val:": typing.Optional[torch.Tensor] = None"},{name:"attention_mask",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:"labels",val:": typing.Optional[torch.LongTensor] = None"},{name:"output_attentions",val:": typing.Optional[bool] = None"},{name:"output_hidden_states",val:": typing.Optional[bool] = None"},{name:"return_dict",val:": typing.Optional[bool] = None"}],parametersDescription:[{anchor:"transformers.DistilBertForMultipleChoice.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/auto#transformers.AutoTokenizer">AutoTokenizer</a>. See <a href="/docs/transformers/main/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode">PreTrainedTokenizer.encode()</a> and
<a href="/docs/transformers/main/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__">PreTrainedTokenizer.<strong>call</strong>()</a> for details.</p>
<p><a href="../glossary#input-ids">What are input IDs?</a>`,name:"input_ids"},{anchor:"transformers.DistilBertForMultipleChoice.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.DistilBertForMultipleChoice.forward.head_mask",description:`<strong>head_mask</strong> (<code>torch.FloatTensor</code> of shape <code>(num_heads,)</code> or <code>(num_layers, num_heads)</code>, <em>optional</em>) &#x2014;
Mask to nullify selected heads of the self-attention modules. Mask values selected in <code>[0, 1]</code>:</p>
<ul>
<li>1 indicates the head is <strong>not masked</strong>,</li>
<li>0 indicates the head is <strong>masked</strong>.</li>
</ul>`,name:"head_mask"},{anchor:"transformers.DistilBertForMultipleChoice.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.DistilBertForMultipleChoice.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.DistilBertForMultipleChoice.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.DistilBertForMultipleChoice.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.DistilBertForMultipleChoice.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/distilbert/modeling_distilbert.py#L1061",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/distilbert#transformers.DistilBertConfig"
>DistilBertConfig</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>
`}}),nn=new Se({props:{$$slots:{default:[c3]},$$scope:{ctx:x}}}),rn=new qe({props:{anchor:"transformers.DistilBertForMultipleChoice.forward.example",$$slots:{default:[p3]},$$scope:{ctx:x}}}),Mi=new Ne({}),zi=new R({props:{name:"class transformers.DistilBertForTokenClassification",anchor:"transformers.DistilBertForTokenClassification",parameters:[{name:"config",val:": PretrainedConfig"}],parametersDescription:[{anchor:"transformers.DistilBertForTokenClassification.config",description:`<strong>config</strong> (<a href="/docs/transformers/main/en/model_doc/distilbert#transformers.DistilBertConfig">DistilBertConfig</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/distilbert/modeling_distilbert.py#L935"}}),qi=new R({props:{name:"forward",anchor:"transformers.DistilBertForTokenClassification.forward",parameters:[{name:"input_ids",val:": typing.Optional[torch.Tensor] = None"},{name:"attention_mask",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:"labels",val:": typing.Optional[torch.LongTensor] = None"},{name:"output_attentions",val:": typing.Optional[bool] = None"},{name:"output_hidden_states",val:": typing.Optional[bool] = None"},{name:"return_dict",val:": typing.Optional[bool] = None"}],parametersDescription:[{anchor:"transformers.DistilBertForTokenClassification.forward.input_ids",description:`<strong>input_ids</strong> (<code>torch.LongTensor</code> of shape <code>({0})</code>) &#x2014;
Indices of input sequence tokens in the vocabulary.</p>
<p>Indices can be obtained using <a href="/docs/transformers/main/en/model_doc/auto#transformers.AutoTokenizer">AutoTokenizer</a>. See <a href="/docs/transformers/main/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode">PreTrainedTokenizer.encode()</a> and
<a href="/docs/transformers/main/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__">PreTrainedTokenizer.<strong>call</strong>()</a> for details.</p>
<p><a href="../glossary#input-ids">What are input IDs?</a>`,name:"input_ids"},{anchor:"transformers.DistilBertForTokenClassification.forward.attention_mask",description:`<strong>attention_mask</strong> (<code>torch.FloatTensor</code> of shape <code>({0})</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.DistilBertForTokenClassification.forward.head_mask",description:`<strong>head_mask</strong> (<code>torch.FloatTensor</code> of shape <code>(num_heads,)</code> or <code>(num_layers, num_heads)</code>, <em>optional</em>) &#x2014;
Mask to nullify selected heads of the self-attention modules. Mask values selected in <code>[0, 1]</code>:</p>
<ul>
<li>1 indicates the head is <strong>not masked</strong>,</li>
<li>0 indicates the head is <strong>masked</strong>.</li>
</ul>`,name:"head_mask"},{anchor:"transformers.DistilBertForTokenClassification.forward.inputs_embeds",description:`<strong>inputs_embeds</strong> (<code>torch.FloatTensor</code> of shape <code>({0}, 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.DistilBertForTokenClassification.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.DistilBertForTokenClassification.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.DistilBertForTokenClassification.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.DistilBertForTokenClassification.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/distilbert/modeling_distilbert.py#L967",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/distilbert#transformers.DistilBertConfig"
>DistilBertConfig</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>
`}}),ln=new Se({props:{$$slots:{default:[h3]},$$scope:{ctx:x}}}),dn=new qe({props:{anchor:"transformers.DistilBertForTokenClassification.forward.example",$$slots:{default:[u3]},$$scope:{ctx:x}}}),Pi=new Ne({}),Li=new R({props:{name:"class transformers.DistilBertForQuestionAnswering",anchor:"transformers.DistilBertForQuestionAnswering",parameters:[{name:"config",val:": PretrainedConfig"}],parametersDescription:[{anchor:"transformers.DistilBertForQuestionAnswering.config",description:`<strong>config</strong> (<a href="/docs/transformers/main/en/model_doc/distilbert#transformers.DistilBertConfig">DistilBertConfig</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/distilbert/modeling_distilbert.py#L817"}}),Ni=new R({props:{name:"forward",anchor:"transformers.DistilBertForQuestionAnswering.forward",parameters:[{name:"input_ids",val:": typing.Optional[torch.Tensor] = None"},{name:"attention_mask",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:"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.DistilBertForQuestionAnswering.forward.input_ids",description:`<strong>input_ids</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size, num_choices)</code>) &#x2014;
Indices of input sequence tokens in the vocabulary.</p>
<p>Indices can be obtained using <a href="/docs/transformers/main/en/model_doc/auto#transformers.AutoTokenizer">AutoTokenizer</a>. See <a href="/docs/transformers/main/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode">PreTrainedTokenizer.encode()</a> and
<a href="/docs/transformers/main/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__">PreTrainedTokenizer.<strong>call</strong>()</a> for details.</p>
<p><a href="../glossary#input-ids">What are input IDs?</a>`,name:"input_ids"},{anchor:"transformers.DistilBertForQuestionAnswering.forward.attention_mask",description:`<strong>attention_mask</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, num_choices)</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.DistilBertForQuestionAnswering.forward.head_mask",description:`<strong>head_mask</strong> (<code>torch.FloatTensor</code> of shape <code>(num_heads,)</code> or <code>(num_layers, num_heads)</code>, <em>optional</em>) &#x2014;
Mask to nullify selected heads of the self-attention modules. Mask values selected in <code>[0, 1]</code>:</p>
<ul>
<li>1 indicates the head is <strong>not masked</strong>,</li>
<li>0 indicates the head is <strong>masked</strong>.</li>
</ul>`,name:"head_mask"},{anchor:"transformers.DistilBertForQuestionAnswering.forward.inputs_embeds",description:`<strong>inputs_embeds</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, num_choices, 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.DistilBertForQuestionAnswering.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.DistilBertForQuestionAnswering.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.DistilBertForQuestionAnswering.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.DistilBertForQuestionAnswering.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.DistilBertForQuestionAnswering.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/distilbert/modeling_distilbert.py#L851",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/distilbert#transformers.DistilBertConfig"
>DistilBertConfig</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>
`}}),pn=new Se({props:{$$slots:{default:[f3]},$$scope:{ctx:x}}}),hn=new qe({props:{anchor:"transformers.DistilBertForQuestionAnswering.forward.example",$$slots:{default:[m3]},$$scope:{ctx:x}}}),Ri=new Ne({}),Wi=new R({props:{name:"class transformers.TFDistilBertModel",anchor:"transformers.TFDistilBertModel",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"transformers.TFDistilBertModel.config",description:`<strong>config</strong> (<a href="/docs/transformers/main/en/model_doc/distilbert#transformers.DistilBertConfig">DistilBertConfig</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/distilbert/modeling_tf_distilbert.py#L536"}}),fn=new Se({props:{$$slots:{default:[g3]},$$scope:{ctx:x}}}),Ki=new R({props:{name:"call",anchor:"transformers.TFDistilBertModel.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:"head_mask",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:": typing.Optional[bool] = False"}],parametersDescription:[{anchor:"transformers.TFDistilBertModel.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.TFDistilBertModel.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.TFDistilBertModel.call.head_mask",description:`<strong>head_mask</strong> (<code>Numpy array</code> or <code>tf.Tensor</code> of shape <code>(num_heads,)</code> or <code>(num_layers, num_heads)</code>, <em>optional</em>) &#x2014;
Mask to nullify selected heads of the self-attention modules. Mask values selected in <code>[0, 1]</code>:</p>
<ul>
<li>1 indicates the head is <strong>not masked</strong>,</li>
<li>0 indicates the head is <strong>masked</strong>.</li>
</ul>`,name:"head_mask"},{anchor:"transformers.TFDistilBertModel.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.TFDistilBertModel.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.TFDistilBertModel.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.TFDistilBertModel.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.TFDistilBertModel.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/distilbert/modeling_tf_distilbert.py#L541",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/distilbert#transformers.DistilBertConfig"
>DistilBertConfig</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>
`}}),mn=new Se({props:{$$slots:{default:[_3]},$$scope:{ctx:x}}}),gn=new qe({props:{anchor:"transformers.TFDistilBertModel.call.example",$$slots:{default:[b3]},$$scope:{ctx:x}}}),Vi=new Ne({}),Ji=new R({props:{name:"class transformers.TFDistilBertForMaskedLM",anchor:"transformers.TFDistilBertForMaskedLM",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"transformers.TFDistilBertForMaskedLM.config",description:`<strong>config</strong> (<a href="/docs/transformers/main/en/model_doc/distilbert#transformers.DistilBertConfig">DistilBertConfig</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/distilbert/modeling_tf_distilbert.py#L622"}}),bn=new Se({props:{$$slots:{default:[k3]},$$scope:{ctx:x}}}),el=new R({props:{name:"call",anchor:"transformers.TFDistilBertForMaskedLM.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:"head_mask",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:": typing.Optional[bool] = False"}],parametersDescription:[{anchor:"transformers.TFDistilBertForMaskedLM.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.TFDistilBertForMaskedLM.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.TFDistilBertForMaskedLM.call.head_mask",description:`<strong>head_mask</strong> (<code>Numpy array</code> or <code>tf.Tensor</code> of shape <code>(num_heads,)</code> or <code>(num_layers, num_heads)</code>, <em>optional</em>) &#x2014;
Mask to nullify selected heads of the self-attention modules. Mask values selected in <code>[0, 1]</code>:</p>
<ul>
<li>1 indicates the head is <strong>not masked</strong>,</li>
<li>0 indicates the head is <strong>masked</strong>.</li>
</ul>`,name:"head_mask"},{anchor:"transformers.TFDistilBertForMaskedLM.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.TFDistilBertForMaskedLM.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.TFDistilBertForMaskedLM.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.TFDistilBertForMaskedLM.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.TFDistilBertForMaskedLM.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.TFDistilBertForMaskedLM.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/distilbert/modeling_tf_distilbert.py#L642",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/distilbert#transformers.DistilBertConfig"
>DistilBertConfig</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>
`}}),kn=new Se({props:{$$slots:{default:[v3]},$$scope:{ctx:x}}}),vn=new qe({props:{anchor:"transformers.TFDistilBertForMaskedLM.call.example",$$slots:{default:[w3]},$$scope:{ctx:x}}}),wn=new qe({props:{anchor:"transformers.TFDistilBertForMaskedLM.call.example-2",$$slots:{default:[T3]},$$scope:{ctx:x}}}),tl=new Ne({}),ol=new R({props:{name:"class transformers.TFDistilBertForSequenceClassification",anchor:"transformers.TFDistilBertForSequenceClassification",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"transformers.TFDistilBertForSequenceClassification.config",description:`<strong>config</strong> (<a href="/docs/transformers/main/en/model_doc/distilbert#transformers.DistilBertConfig">DistilBertConfig</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/distilbert/modeling_tf_distilbert.py#L711"}}),yn=new Se({props:{$$slots:{default:[y3]},$$scope:{ctx:x}}}),al=new R({props:{name:"call",anchor:"transformers.TFDistilBertForSequenceClassification.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:"head_mask",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:": typing.Optional[bool] = False"}],parametersDescription:[{anchor:"transformers.TFDistilBertForSequenceClassification.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.TFDistilBertForSequenceClassification.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.TFDistilBertForSequenceClassification.call.head_mask",description:`<strong>head_mask</strong> (<code>Numpy array</code> or <code>tf.Tensor</code> of shape <code>(num_heads,)</code> or <code>(num_layers, num_heads)</code>, <em>optional</em>) &#x2014;
Mask to nullify selected heads of the self-attention modules. Mask values selected in <code>[0, 1]</code>:</p>
<ul>
<li>1 indicates the head is <strong>not masked</strong>,</li>
<li>0 indicates the head is <strong>masked</strong>.</li>
</ul>`,name:"head_mask"},{anchor:"transformers.TFDistilBertForSequenceClassification.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.TFDistilBertForSequenceClassification.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.TFDistilBertForSequenceClassification.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.TFDistilBertForSequenceClassification.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.TFDistilBertForSequenceClassification.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.TFDistilBertForSequenceClassification.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/distilbert/modeling_tf_distilbert.py#L728",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/distilbert#transformers.DistilBertConfig"
>DistilBertConfig</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>
`}}),$n=new Se({props:{$$slots:{default:[$3]},$$scope:{ctx:x}}}),Fn=new qe({props:{anchor:"transformers.TFDistilBertForSequenceClassification.call.example",$$slots:{default:[F3]},$$scope:{ctx:x}}}),Dn=new qe({props:{anchor:"transformers.TFDistilBertForSequenceClassification.call.example-2",$$slots:{default:[D3]},$$scope:{ctx:x}}}),il=new Ne({}),ll=new R({props:{name:"class transformers.TFDistilBertForMultipleChoice",anchor:"transformers.TFDistilBertForMultipleChoice",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"transformers.TFDistilBertForMultipleChoice.config",description:`<strong>config</strong> (<a href="/docs/transformers/main/en/model_doc/distilbert#transformers.DistilBertConfig">DistilBertConfig</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/distilbert/modeling_tf_distilbert.py#L872"}}),xn=new Se({props:{$$slots:{default:[E3]},$$scope:{ctx:x}}}),hl=new R({props:{name:"call",anchor:"transformers.TFDistilBertForMultipleChoice.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:"head_mask",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:": typing.Optional[bool] = False"}],parametersDescription:[{anchor:"transformers.TFDistilBertForMultipleChoice.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.TFDistilBertForMultipleChoice.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.TFDistilBertForMultipleChoice.call.head_mask",description:`<strong>head_mask</strong> (<code>Numpy array</code> or <code>tf.Tensor</code> of shape <code>(num_heads,)</code> or <code>(num_layers, num_heads)</code>, <em>optional</em>) &#x2014;
Mask to nullify selected heads of the self-attention modules. Mask values selected in <code>[0, 1]</code>:</p>
<ul>
<li>1 indicates the head is <strong>not masked</strong>,</li>
<li>0 indicates the head is <strong>masked</strong>.</li>
</ul>`,name:"head_mask"},{anchor:"transformers.TFDistilBertForMultipleChoice.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.TFDistilBertForMultipleChoice.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.TFDistilBertForMultipleChoice.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.TFDistilBertForMultipleChoice.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.TFDistilBertForMultipleChoice.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.TFDistilBertForMultipleChoice.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/distilbert/modeling_tf_distilbert.py#L898",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/distilbert#transformers.DistilBertConfig"
>DistilBertConfig</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>
`}}),Bn=new Se({props:{$$slots:{default:[x3]},$$scope:{ctx:x}}}),Mn=new qe({props:{anchor:"transformers.TFDistilBertForMultipleChoice.call.example",$$slots:{default:[B3]},$$scope:{ctx:x}}}),ul=new Ne({}),fl=new R({props:{name:"class transformers.TFDistilBertForTokenClassification",anchor:"transformers.TFDistilBertForTokenClassification",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"transformers.TFDistilBertForTokenClassification.config",description:`<strong>config</strong> (<a href="/docs/transformers/main/en/model_doc/distilbert#transformers.DistilBertConfig">DistilBertConfig</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/distilbert/modeling_tf_distilbert.py#L797"}}),Cn=new Se({props:{$$slots:{default:[M3]},$$scope:{ctx:x}}}),bl=new R({props:{name:"call",anchor:"transformers.TFDistilBertForTokenClassification.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:"head_mask",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:": typing.Optional[bool] = False"}],parametersDescription:[{anchor:"transformers.TFDistilBertForTokenClassification.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.TFDistilBertForTokenClassification.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.TFDistilBertForTokenClassification.call.head_mask",description:`<strong>head_mask</strong> (<code>Numpy array</code> or <code>tf.Tensor</code> of shape <code>(num_heads,)</code> or <code>(num_layers, num_heads)</code>, <em>optional</em>) &#x2014;
Mask to nullify selected heads of the self-attention modules. Mask values selected in <code>[0, 1]</code>:</p>
<ul>
<li>1 indicates the head is <strong>not masked</strong>,</li>
<li>0 indicates the head is <strong>masked</strong>.</li>
</ul>`,name:"head_mask"},{anchor:"transformers.TFDistilBertForTokenClassification.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.TFDistilBertForTokenClassification.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.TFDistilBertForTokenClassification.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.TFDistilBertForTokenClassification.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.TFDistilBertForTokenClassification.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.TFDistilBertForTokenClassification.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/distilbert/modeling_tf_distilbert.py#L808",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/distilbert#transformers.DistilBertConfig"
>DistilBertConfig</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>
`}}),An=new Se({props:{$$slots:{default:[z3]},$$scope:{ctx:x}}}),jn=new qe({props:{anchor:"transformers.TFDistilBertForTokenClassification.call.example",$$slots:{default:[C3]},$$scope:{ctx:x}}}),qn=new qe({props:{anchor:"transformers.TFDistilBertForTokenClassification.call.example-2",$$slots:{default:[A3]},$$scope:{ctx:x}}}),kl=new Ne({}),vl=new R({props:{name:"class transformers.TFDistilBertForQuestionAnswering",anchor:"transformers.TFDistilBertForQuestionAnswering",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"transformers.TFDistilBertForQuestionAnswering.config",description:`<strong>config</strong> (<a href="/docs/transformers/main/en/model_doc/distilbert#transformers.DistilBertConfig">DistilBertConfig</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/distilbert/modeling_tf_distilbert.py#L996"}}),Ln=new Se({props:{$$slots:{default:[j3]},$$scope:{ctx:x}}}),$l=new R({props:{name:"call",anchor:"transformers.TFDistilBertForQuestionAnswering.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:"head_mask",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:": typing.Optional[bool] = False"}],parametersDescription:[{anchor:"transformers.TFDistilBertForQuestionAnswering.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.TFDistilBertForQuestionAnswering.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.TFDistilBertForQuestionAnswering.call.head_mask",description:`<strong>head_mask</strong> (<code>Numpy array</code> or <code>tf.Tensor</code> of shape <code>(num_heads,)</code> or <code>(num_layers, num_heads)</code>, <em>optional</em>) &#x2014;
Mask to nullify selected heads of the self-attention modules. Mask values selected in <code>[0, 1]</code>:</p>
<ul>
<li>1 indicates the head is <strong>not masked</strong>,</li>
<li>0 indicates the head is <strong>masked</strong>.</li>
</ul>`,name:"head_mask"},{anchor:"transformers.TFDistilBertForQuestionAnswering.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.TFDistilBertForQuestionAnswering.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.TFDistilBertForQuestionAnswering.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.TFDistilBertForQuestionAnswering.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.TFDistilBertForQuestionAnswering.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.TFDistilBertForQuestionAnswering.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.TFDistilBertForQuestionAnswering.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/distilbert/modeling_tf_distilbert.py#L1007",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/distilbert#transformers.DistilBertConfig"
>DistilBertConfig</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>
`}}),On=new Se({props:{$$slots:{default:[q3]},$$scope:{ctx:x}}}),In=new qe({props:{anchor:"transformers.TFDistilBertForQuestionAnswering.call.example",$$slots:{default:[P3]},$$scope:{ctx:x}}}),Sn=new qe({props:{anchor:"transformers.TFDistilBertForQuestionAnswering.call.example-2",$$slots:{default:[L3]},$$scope:{ctx:x}}}),Fl=new Ne({}),Dl=new R({props:{name:"class transformers.FlaxDistilBertModel",anchor:"transformers.FlaxDistilBertModel",parameters:[{name:"config",val:": DistilBertConfig"},{name:"input_shape",val:": typing.Tuple = (1, 1)"},{name:"seed",val:": int = 0"},{name:"dtype",val:": dtype = <class 'jax.numpy.float32'>"},{name:"_do_init",val:": bool = True"},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"transformers.FlaxDistilBertModel.config",description:`<strong>config</strong> (<a href="/docs/transformers/main/en/model_doc/distilbert#transformers.DistilBertConfig">DistilBertConfig</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/distilbert/modeling_flax_distilbert.py#L534"}}),jl=new R({props:{name:"__call__",anchor:"transformers.FlaxDistilBertModel.__call__",parameters:[{name:"input_ids",val:""},{name:"attention_mask",val:" = None"},{name:"head_mask",val:" = None"},{name:"params",val:": dict = None"},{name:"dropout_rng",val:": PRNGKey = None"},{name:"train",val:": bool = False"},{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.FlaxDistilBertModel.__call__.input_ids",description:`<strong>input_ids</strong> (<code>numpy.ndarray</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.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.FlaxDistilBertModel.__call__.attention_mask",description:`<strong>attention_mask</strong> (<code>numpy.ndarray</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.FlaxDistilBertModel.__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.`,name:"output_attentions"},{anchor:"transformers.FlaxDistilBertModel.__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.`,name:"output_hidden_states"},{anchor:"transformers.FlaxDistilBertModel.__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.`,name:"return_dict"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/distilbert/modeling_flax_distilbert.py#L457"}}),Rn=new Se({props:{$$slots:{default:[O3]},$$scope:{ctx:x}}}),Wn=new qe({props:{anchor:"transformers.FlaxDistilBertModel.__call__.example",$$slots:{default:[I3]},$$scope:{ctx:x}}}),ql=new Ne({}),Pl=new R({props:{name:"class transformers.FlaxDistilBertForMaskedLM",anchor:"transformers.FlaxDistilBertForMaskedLM",parameters:[{name:"config",val:": DistilBertConfig"},{name:"input_shape",val:": typing.Tuple = (1, 1)"},{name:"seed",val:": int = 0"},{name:"dtype",val:": dtype = <class 'jax.numpy.float32'>"},{name:"_do_init",val:": bool = True"},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"transformers.FlaxDistilBertForMaskedLM.config",description:`<strong>config</strong> (<a href="/docs/transformers/main/en/model_doc/distilbert#transformers.DistilBertConfig">DistilBertConfig</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/distilbert/modeling_flax_distilbert.py#L607"}}),Ql=new R({props:{name:"__call__",anchor:"transformers.FlaxDistilBertForMaskedLM.__call__",parameters:[{name:"input_ids",val:""},{name:"attention_mask",val:" = None"},{name:"head_mask",val:" = None"},{name:"params",val:": dict = None"},{name:"dropout_rng",val:": PRNGKey = None"},{name:"train",val:": bool = False"},{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.FlaxDistilBertForMaskedLM.__call__.input_ids",description:`<strong>input_ids</strong> (<code>numpy.ndarray</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.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.FlaxDistilBertForMaskedLM.__call__.attention_mask",description:`<strong>attention_mask</strong> (<code>numpy.ndarray</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.FlaxDistilBertForMaskedLM.__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.`,name:"output_attentions"},{anchor:"transformers.FlaxDistilBertForMaskedLM.__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.`,name:"output_hidden_states"},{anchor:"transformers.FlaxDistilBertForMaskedLM.__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.`,name:"return_dict"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/distilbert/modeling_flax_distilbert.py#L457",returnDescription:`
<p>A <a
  href="/docs/transformers/main/en/main_classes/output#transformers.modeling_flax_outputs.FlaxMaskedLMOutput"
>transformers.modeling_flax_outputs.FlaxMaskedLMOutput</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/distilbert#transformers.DistilBertConfig"
>DistilBertConfig</a>) and inputs.</p>
<ul>
<li>
<p><strong>logits</strong> (<code>jnp.ndarray</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(jnp.ndarray)</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>jnp.ndarray</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(jnp.ndarray)</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>jnp.ndarray</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_flax_outputs.FlaxMaskedLMOutput"
>transformers.modeling_flax_outputs.FlaxMaskedLMOutput</a> or <code>tuple(torch.FloatTensor)</code></p>
`}}),Qn=new Se({props:{$$slots:{default:[S3]},$$scope:{ctx:x}}}),Hn=new qe({props:{anchor:"transformers.FlaxDistilBertForMaskedLM.__call__.example",$$slots:{default:[N3]},$$scope:{ctx:x}}}),Hl=new Ne({}),Kl=new R({props:{name:"class transformers.FlaxDistilBertForSequenceClassification",anchor:"transformers.FlaxDistilBertForSequenceClassification",parameters:[{name:"config",val:": DistilBertConfig"},{name:"input_shape",val:": typing.Tuple = (1, 1)"},{name:"seed",val:": int = 0"},{name:"dtype",val:": dtype = <class 'jax.numpy.float32'>"},{name:"_do_init",val:": bool = True"},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"transformers.FlaxDistilBertForSequenceClassification.config",description:`<strong>config</strong> (<a href="/docs/transformers/main/en/model_doc/distilbert#transformers.DistilBertConfig">DistilBertConfig</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/distilbert/modeling_flax_distilbert.py#L674"}}),td=new R({props:{name:"__call__",anchor:"transformers.FlaxDistilBertForSequenceClassification.__call__",parameters:[{name:"input_ids",val:""},{name:"attention_mask",val:" = None"},{name:"head_mask",val:" = None"},{name:"params",val:": dict = None"},{name:"dropout_rng",val:": PRNGKey = None"},{name:"train",val:": bool = False"},{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.FlaxDistilBertForSequenceClassification.__call__.input_ids",description:`<strong>input_ids</strong> (<code>numpy.ndarray</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.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.FlaxDistilBertForSequenceClassification.__call__.attention_mask",description:`<strong>attention_mask</strong> (<code>numpy.ndarray</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.FlaxDistilBertForSequenceClassification.__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.`,name:"output_attentions"},{anchor:"transformers.FlaxDistilBertForSequenceClassification.__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.`,name:"output_hidden_states"},{anchor:"transformers.FlaxDistilBertForSequenceClassification.__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.`,name:"return_dict"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/distilbert/modeling_flax_distilbert.py#L457",returnDescription:`
<p>A <a
  href="/docs/transformers/main/en/main_classes/output#transformers.modeling_flax_outputs.FlaxSequenceClassifierOutput"
>transformers.modeling_flax_outputs.FlaxSequenceClassifierOutput</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/distilbert#transformers.DistilBertConfig"
>DistilBertConfig</a>) and inputs.</p>
<ul>
<li>
<p><strong>logits</strong> (<code>jnp.ndarray</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(jnp.ndarray)</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>jnp.ndarray</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(jnp.ndarray)</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>jnp.ndarray</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_flax_outputs.FlaxSequenceClassifierOutput"
>transformers.modeling_flax_outputs.FlaxSequenceClassifierOutput</a> or <code>tuple(torch.FloatTensor)</code></p>
`}}),Vn=new Se({props:{$$slots:{default:[R3]},$$scope:{ctx:x}}}),Jn=new qe({props:{anchor:"transformers.FlaxDistilBertForSequenceClassification.__call__.example",$$slots:{default:[W3]},$$scope:{ctx:x}}}),od=new Ne({}),sd=new R({props:{name:"class transformers.FlaxDistilBertForMultipleChoice",anchor:"transformers.FlaxDistilBertForMultipleChoice",parameters:[{name:"config",val:": DistilBertConfig"},{name:"input_shape",val:": typing.Tuple = (1, 1)"},{name:"seed",val:": int = 0"},{name:"dtype",val:": dtype = <class 'jax.numpy.float32'>"},{name:"_do_init",val:": bool = True"},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"transformers.FlaxDistilBertForMultipleChoice.config",description:`<strong>config</strong> (<a href="/docs/transformers/main/en/model_doc/distilbert#transformers.DistilBertConfig">DistilBertConfig</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/distilbert/modeling_flax_distilbert.py#L753"}}),pd=new R({props:{name:"__call__",anchor:"transformers.FlaxDistilBertForMultipleChoice.__call__",parameters:[{name:"input_ids",val:""},{name:"attention_mask",val:" = None"},{name:"head_mask",val:" = None"},{name:"params",val:": dict = None"},{name:"dropout_rng",val:": PRNGKey = None"},{name:"train",val:": bool = False"},{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.FlaxDistilBertForMultipleChoice.__call__.input_ids",description:`<strong>input_ids</strong> (<code>numpy.ndarray</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.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.FlaxDistilBertForMultipleChoice.__call__.attention_mask",description:`<strong>attention_mask</strong> (<code>numpy.ndarray</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.FlaxDistilBertForMultipleChoice.__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.`,name:"output_attentions"},{anchor:"transformers.FlaxDistilBertForMultipleChoice.__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.`,name:"output_hidden_states"},{anchor:"transformers.FlaxDistilBertForMultipleChoice.__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.`,name:"return_dict"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/distilbert/modeling_flax_distilbert.py#L457",returnDescription:`
<p>A <a
  href="/docs/transformers/main/en/main_classes/output#transformers.modeling_flax_outputs.FlaxMultipleChoiceModelOutput"
>transformers.modeling_flax_outputs.FlaxMultipleChoiceModelOutput</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/distilbert#transformers.DistilBertConfig"
>DistilBertConfig</a>) and inputs.</p>
<ul>
<li>
<p><strong>logits</strong> (<code>jnp.ndarray</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(jnp.ndarray)</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>jnp.ndarray</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(jnp.ndarray)</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>jnp.ndarray</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_flax_outputs.FlaxMultipleChoiceModelOutput"
>transformers.modeling_flax_outputs.FlaxMultipleChoiceModelOutput</a> or <code>tuple(torch.FloatTensor)</code></p>
`}}),Xn=new Se({props:{$$slots:{default:[U3]},$$scope:{ctx:x}}}),Yn=new qe({props:{anchor:"transformers.FlaxDistilBertForMultipleChoice.__call__.example",$$slots:{default:[Q3]},$$scope:{ctx:x}}}),hd=new Ne({}),ud=new R({props:{name:"class transformers.FlaxDistilBertForTokenClassification",anchor:"transformers.FlaxDistilBertForTokenClassification",parameters:[{name:"config",val:": DistilBertConfig"},{name:"input_shape",val:": typing.Tuple = (1, 1)"},{name:"seed",val:": int = 0"},{name:"dtype",val:": dtype = <class 'jax.numpy.float32'>"},{name:"_do_init",val:": bool = True"},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"transformers.FlaxDistilBertForTokenClassification.config",description:`<strong>config</strong> (<a href="/docs/transformers/main/en/model_doc/distilbert#transformers.DistilBertConfig">DistilBertConfig</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/distilbert/modeling_flax_distilbert.py#L818"}}),wd=new R({props:{name:"__call__",anchor:"transformers.FlaxDistilBertForTokenClassification.__call__",parameters:[{name:"input_ids",val:""},{name:"attention_mask",val:" = None"},{name:"head_mask",val:" = None"},{name:"params",val:": dict = None"},{name:"dropout_rng",val:": PRNGKey = None"},{name:"train",val:": bool = False"},{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.FlaxDistilBertForTokenClassification.__call__.input_ids",description:`<strong>input_ids</strong> (<code>numpy.ndarray</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.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.FlaxDistilBertForTokenClassification.__call__.attention_mask",description:`<strong>attention_mask</strong> (<code>numpy.ndarray</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.FlaxDistilBertForTokenClassification.__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.`,name:"output_attentions"},{anchor:"transformers.FlaxDistilBertForTokenClassification.__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.`,name:"output_hidden_states"},{anchor:"transformers.FlaxDistilBertForTokenClassification.__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.`,name:"return_dict"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/distilbert/modeling_flax_distilbert.py#L457",returnDescription:`
<p>A <a
  href="/docs/transformers/main/en/main_classes/output#transformers.modeling_flax_outputs.FlaxTokenClassifierOutput"
>transformers.modeling_flax_outputs.FlaxTokenClassifierOutput</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/distilbert#transformers.DistilBertConfig"
>DistilBertConfig</a>) and inputs.</p>
<ul>
<li>
<p><strong>logits</strong> (<code>jnp.ndarray</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(jnp.ndarray)</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>jnp.ndarray</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(jnp.ndarray)</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>jnp.ndarray</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_flax_outputs.FlaxTokenClassifierOutput"
>transformers.modeling_flax_outputs.FlaxTokenClassifierOutput</a> or <code>tuple(torch.FloatTensor)</code></p>
`}}),er=new Se({props:{$$slots:{default:[H3]},$$scope:{ctx:x}}}),tr=new qe({props:{anchor:"transformers.FlaxDistilBertForTokenClassification.__call__.example",$$slots:{default:[K3]},$$scope:{ctx:x}}}),Td=new Ne({}),yd=new R({props:{name:"class transformers.FlaxDistilBertForQuestionAnswering",anchor:"transformers.FlaxDistilBertForQuestionAnswering",parameters:[{name:"config",val:": DistilBertConfig"},{name:"input_shape",val:": typing.Tuple = (1, 1)"},{name:"seed",val:": int = 0"},{name:"dtype",val:": dtype = <class 'jax.numpy.float32'>"},{name:"_do_init",val:": bool = True"},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"transformers.FlaxDistilBertForQuestionAnswering.config",description:`<strong>config</strong> (<a href="/docs/transformers/main/en/model_doc/distilbert#transformers.DistilBertConfig">DistilBertConfig</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/distilbert/modeling_flax_distilbert.py#L887"}}),zd=new R({props:{name:"__call__",anchor:"transformers.FlaxDistilBertForQuestionAnswering.__call__",parameters:[{name:"input_ids",val:""},{name:"attention_mask",val:" = None"},{name:"head_mask",val:" = None"},{name:"params",val:": dict = None"},{name:"dropout_rng",val:": PRNGKey = None"},{name:"train",val:": bool = False"},{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.FlaxDistilBertForQuestionAnswering.__call__.input_ids",description:`<strong>input_ids</strong> (<code>numpy.ndarray</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.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.FlaxDistilBertForQuestionAnswering.__call__.attention_mask",description:`<strong>attention_mask</strong> (<code>numpy.ndarray</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.FlaxDistilBertForQuestionAnswering.__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.`,name:"output_attentions"},{anchor:"transformers.FlaxDistilBertForQuestionAnswering.__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.`,name:"output_hidden_states"},{anchor:"transformers.FlaxDistilBertForQuestionAnswering.__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.`,name:"return_dict"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/distilbert/modeling_flax_distilbert.py#L457",returnDescription:`
<p>A <a
  href="/docs/transformers/main/en/main_classes/output#transformers.modeling_flax_outputs.FlaxQuestionAnsweringModelOutput"
>transformers.modeling_flax_outputs.FlaxQuestionAnsweringModelOutput</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/distilbert#transformers.DistilBertConfig"
>DistilBertConfig</a>) and inputs.</p>
<ul>
<li>
<p><strong>start_logits</strong> (<code>jnp.ndarray</code> of shape <code>(batch_size, sequence_length)</code>) \u2014 Span-start scores (before SoftMax).</p>
</li>
<li>
<p><strong>end_logits</strong> (<code>jnp.ndarray</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(jnp.ndarray)</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>jnp.ndarray</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(jnp.ndarray)</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>jnp.ndarray</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_flax_outputs.FlaxQuestionAnsweringModelOutput"
>transformers.modeling_flax_outputs.FlaxQuestionAnsweringModelOutput</a> or <code>tuple(torch.FloatTensor)</code></p>
`}}),sr=new Se({props:{$$slots:{default:[V3]},$$scope:{ctx:x}}}),nr=new qe({props:{anchor:"transformers.FlaxDistilBertForQuestionAnswering.__call__.example",$$slots:{default:[J3]},$$scope:{ctx:x}}}),{c(){d=r("meta"),k=p(),f=r("h1"),m=r("a"),b=r("span"),w(l.$$.fragment),u=p(),M=r("span"),be=o("DistilBERT"),ue=p(),I=r("h2"),re=r("a"),oe=r("span"),w(E.$$.fragment),ke=p(),Q=r("span"),ve=o("Overview"),fe=p(),L=r("p"),we=o("The DistilBERT model was proposed in the blog post "),ae=r("a"),K=o(`Smaller, faster, cheaper, lighter: Introducing DistilBERT, a
distilled version of BERT`),Te=o(", and the paper "),ie=r("a"),V=o(`DistilBERT, a
distilled version of BERT: smaller, faster, cheaper and lighter`),ye=o(`. DistilBERT is a
small, fast, cheap and light Transformer model trained by distilling BERT base. It has 40% less parameters than
`),de=r("em"),J=o("bert-base-uncased"),$e=o(`, runs 60% faster while preserving over 95% of BERT\u2019s performances as measured on the GLUE language
understanding benchmark.`),me=p(),ee=r("p"),C=o("The abstract from the paper is the following:"),q=p(),le=r("p"),H=r("em"),Fe=o(`As Transfer Learning from large-scale pre-trained models becomes more prevalent in Natural Language Processing (NLP),
operating these large models in on-the-edge and/or under constrained computational training or inference budgets
remains challenging. In this work, we propose a method to pre-train a smaller general-purpose language representation
model, called DistilBERT, which can then be fine-tuned with good performances on a wide range of tasks like its larger
counterparts. While most prior work investigated the use of distillation for building task-specific models, we leverage
knowledge distillation during the pretraining phase and show that it is possible to reduce the size of a BERT model by
40%, while retaining 97% of its language understanding capabilities and being 60% faster. To leverage the inductive
biases learned by larger models during pretraining, we introduce a triple loss combining language modeling,
distillation and cosine-distance losses. Our smaller, faster and lighter model is cheaper to pre-train and we
demonstrate its capabilities for on-device computations in a proof-of-concept experiment and a comparative on-device
study.`),ge=p(),U=r("p"),De=o("Tips:"),_e=p(),A=r("ul"),se=r("li"),G=o("DistilBERT doesn\u2019t have "),ce=r("code"),Ee=o("token_type_ids"),X=o(`, you don\u2019t need to indicate which token belongs to which segment. Just
separate your segments with the separation token `),pe=r("code"),xe=o("tokenizer.sep_token"),S=o(" (or "),he=r("code"),Y=o("[SEP]"),Be=o(")."),ne=p(),j=r("li"),Me=o("DistilBERT doesn\u2019t have options to select the input positions ("),P=r("code"),ze=o("position_ids"),Ce=o(` input). This could be added if
necessary though, just let us know if you need this option.`),v=p(),B=r("p"),He=o("This model was contributed by "),Z=r("a"),Ke=o("victorsanh"),Ve=o(`. This model jax version was
contributed by `),z=r("a"),Je=o("kamalkraj"),Ge=o(". The original code can be found "),Oe=r("a"),Xe=o("here"),Ye=o("."),O=p(),N=r("h2"),je=r("a"),Re=r("span"),w(W.$$.fragment),Ze=p(),We=r("span"),Ae=o("Resources"),Qe=p(),te=r("p"),et=o("A list of official Hugging Face and community (indicated by \u{1F30E}) resources to help you get started with DistilBERT. If you\u2019re interested in submitting a resource to be included here, please feel free to open a Pull Request and we\u2019ll review it! The resource should ideally demonstrate something new instead of duplicating an existing resource."),Uf=p(),w(zr.$$.fragment),Qf=p(),Ie=r("ul"),Cr=r("li"),v_=o("A blog post on "),Ar=r("a"),w_=o("Getting Started with Sentiment Analysis using Python"),T_=o(" with DistilBERT."),y_=p(),jr=r("li"),$_=o("A blog post on how to "),qr=r("a"),F_=o("train DistilBERT with Blurr for sequence classification"),D_=o("."),E_=p(),Pr=r("li"),x_=o("A blog post on how to use "),Lr=r("a"),B_=o("Ray to tune DistilBERT hyperparameters"),M_=o("."),z_=p(),Or=r("li"),C_=o("A blog post on how to "),Ir=r("a"),A_=o("train DistilBERT with Hugging Face and Amazon SageMaker"),j_=o("."),q_=p(),Sr=r("li"),P_=o("A notebook on how to "),Nr=r("a"),L_=o("finetune DistilBERT for multi-label classification"),O_=o(". \u{1F30E}"),I_=p(),Rr=r("li"),S_=o("A notebook on how to "),Wr=r("a"),N_=o("finetune DistilBERT for multiclass classification with PyTorch"),R_=o(". \u{1F30E}"),W_=p(),Ur=r("li"),U_=o("A notebook on how to "),Qr=r("a"),Q_=o("finetune DistilBERT for text classification in TensorFlow"),H_=o(". \u{1F30E}"),K_=p(),mo=r("li"),tc=r("a"),V_=o("DistilBertForSequenceClassification"),J_=o(" is supported by this "),Hr=r("a"),G_=o("example script"),X_=o(" and "),Kr=r("a"),Y_=o("notebook"),Z_=o("."),eb=p(),go=r("li"),oc=r("a"),tb=o("TFDistilBertForSequenceClassification"),ob=o(" is supported by this "),Vr=r("a"),sb=o("example script"),nb=o(" and "),Jr=r("a"),rb=o("notebook"),ab=o("."),ib=p(),_o=r("li"),sc=r("a"),lb=o("FlaxDistilBertForSequenceClassification"),db=o(" is supported by this "),Gr=r("a"),cb=o("example script"),pb=o(" and "),Xr=r("a"),hb=o("notebook"),ub=o("."),Hf=p(),w(Yr.$$.fragment),Kf=p(),jt=r("ul"),bo=r("li"),nc=r("a"),fb=o("DistilBertForTokenClassification"),mb=o(" is supported by this "),Zr=r("a"),gb=o("example script"),_b=o(" and "),ea=r("a"),bb=o("notebook"),kb=o("."),vb=p(),ko=r("li"),rc=r("a"),wb=o("TFDistilBertForTokenClassification"),Tb=o(" is supported by this "),ta=r("a"),yb=o("example script"),$b=o(" and "),oa=r("a"),Fb=o("notebook"),Db=o("."),Eb=p(),qs=r("li"),ac=r("a"),xb=o("FlaxDistilBertForTokenClassification"),Bb=o(" is supported by this "),sa=r("a"),Mb=o("example script"),zb=o("."),Cb=p(),ic=r("li"),na=r("a"),Ab=o("Token classification"),jb=o(" chapter of the \u{1F917} Hugging Face Course."),Vf=p(),w(ra.$$.fragment),Jf=p(),qt=r("ul"),vo=r("li"),lc=r("a"),qb=o("DistilBertForMaskedLM"),Pb=o(" is supported by this "),aa=r("a"),Lb=o("example script"),Ob=o(" and "),ia=r("a"),Ib=o("notebook"),Sb=o("."),Nb=p(),wo=r("li"),dc=r("a"),Rb=o("TFDistilBertForMaskedLM"),Wb=o(" is supported by this "),la=r("a"),Ub=o("example script"),Qb=o(" and "),da=r("a"),Hb=o("notebook"),Kb=o("."),Vb=p(),To=r("li"),cc=r("a"),Jb=o("FlaxDistilBertForMaskedLM"),Gb=o(" is supported by this "),ca=r("a"),Xb=o("example script"),Yb=o(" and "),pa=r("a"),Zb=o("notebook"),ek=o("."),tk=p(),pc=r("li"),ha=r("a"),ok=o("Masked language modeling"),sk=o(" chapter of the \u{1F917} Hugging Face Course."),Gf=p(),w(ua.$$.fragment),Xf=p(),Pt=r("ul"),yo=r("li"),hc=r("a"),nk=o("DistilBertForQuestionAnswering"),rk=o(" is supported by this "),fa=r("a"),ak=o("example script"),ik=o(" and "),ma=r("a"),lk=o("notebook"),dk=o("."),ck=p(),$o=r("li"),uc=r("a"),pk=o("TFDistilBertForQuestionAnswering"),hk=o(" is supported by this "),ga=r("a"),uk=o("example script"),fk=o(" and "),_a=r("a"),mk=o("notebook"),gk=o("."),_k=p(),Ps=r("li"),fc=r("a"),bk=o("FlaxDistilBertForQuestionAnswering"),kk=o(" is supported by this "),ba=r("a"),vk=o("example script"),wk=o("."),Tk=p(),mc=r("li"),ka=r("a"),yk=o("Question answering"),$k=o(" chapter of the \u{1F917} Hugging Face Course."),Yf=p(),gc=r("p"),Pp=r("strong"),Fk=o("Multiple choice"),Zf=p(),Ls=r("ul"),Fo=r("li"),_c=r("a"),Dk=o("DistilBertForMultipleChoice"),Ek=o(" is supported by this "),va=r("a"),xk=o("example script"),Bk=o(" and "),wa=r("a"),Mk=o("notebook"),zk=o("."),Ck=p(),Do=r("li"),bc=r("a"),Ak=o("TFDistilBertForMultipleChoice"),jk=o(" is supported by this "),Ta=r("a"),qk=o("example script"),Pk=o(" and "),ya=r("a"),Lk=o("notebook"),Ok=o("."),em=p(),kc=r("p"),Ik=o("\u2697\uFE0F Optimization"),tm=p(),Eo=r("ul"),$a=r("li"),Sk=o("A blog post on how to "),Fa=r("a"),Nk=o("quantize DistilBERT with \u{1F917} Optimum and Intel"),Rk=o("."),Wk=p(),Da=r("li"),Uk=o("A blog post on how "),Ea=r("a"),Qk=o("Optimizing Transformers for GPUs with \u{1F917} Optimum"),Hk=o("."),Kk=p(),xa=r("li"),Vk=o("A blog post on "),Ba=r("a"),Jk=o("Optimizing Transformers with Hugging Face Optimum"),Gk=o("."),om=p(),vc=r("p"),Xk=o("\u26A1\uFE0F Inference"),sm=p(),Os=r("ul"),Ma=r("li"),Yk=o("A blog post on how to "),za=r("a"),Zk=o("Accelerate BERT inference with Hugging Face Transformers and AWS Inferentia"),ev=o(" with DistilBERT."),tv=p(),Ca=r("li"),ov=o("A blog post on "),Aa=r("a"),sv=o("Serverless Inference with Hugging Face\u2019s Transformers, DistilBERT and Amazon SageMaker"),nv=o("."),nm=p(),wc=r("p"),rv=o("\u{1F680} Deploy"),rm=p(),xo=r("ul"),ja=r("li"),av=o("A blog post on how to "),qa=r("a"),iv=o("deploy DistilBERT on Google Cloud"),lv=o("."),dv=p(),Pa=r("li"),cv=o("A blog post on how to "),La=r("a"),pv=o("deploy DistilBERT with Amazon SageMaker"),hv=o("."),uv=p(),Oa=r("li"),fv=o("A blog post on how to "),Ia=r("a"),mv=o("Deploy BERT with Hugging Face Transformers, Amazon SageMaker and Terraform module"),gv=o("."),am=p(),Uo=r("h2"),Is=r("a"),Lp=r("span"),w(Sa.$$.fragment),_v=p(),Op=r("span"),bv=o("DistilBertConfig"),im=p(),At=r("div"),w(Na.$$.fragment),kv=p(),no=r("p"),vv=o("This is the configuration class to store the configuration of a "),Tc=r("a"),wv=o("DistilBertModel"),Tv=o(" or a "),yc=r("a"),yv=o("TFDistilBertModel"),$v=o(`. It
is used to instantiate a DistilBERT 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 DistilBERT
`),Ra=r("a"),Fv=o("distilbert-base-uncased"),Dv=o(" architecture."),Ev=p(),Qo=r("p"),xv=o("Configuration objects inherit from "),$c=r("a"),Bv=o("PretrainedConfig"),Mv=o(` and can be used to control the model outputs. Read the
documentation from `),Fc=r("a"),zv=o("PretrainedConfig"),Cv=o(" for more information."),Av=p(),w(Ss.$$.fragment),lm=p(),Ho=r("h2"),Ns=r("a"),Ip=r("span"),w(Wa.$$.fragment),jv=p(),Sp=r("span"),qv=o("DistilBertTokenizer"),dm=p(),tt=r("div"),w(Ua.$$.fragment),Pv=p(),Np=r("p"),Lv=o("Construct a DistilBERT tokenizer. Based on WordPiece."),Ov=p(),Qa=r("p"),Iv=o("This tokenizer inherits from "),Dc=r("a"),Sv=o("PreTrainedTokenizer"),Nv=o(` which contains most of the main methods. Users should refer to
this superclass for more information regarding those methods.`),Rv=p(),Bo=r("div"),w(Ha.$$.fragment),Wv=p(),Rp=r("p"),Uv=o(`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:`),Qv=p(),Ka=r("ul"),Ec=r("li"),Hv=o("single sequence: "),Wp=r("code"),Kv=o("[CLS] X [SEP]"),Vv=p(),xc=r("li"),Jv=o("pair of sequences: "),Up=r("code"),Gv=o("[CLS] A [SEP] B [SEP]"),Xv=p(),Rs=r("div"),w(Va.$$.fragment),Yv=p(),Qp=r("p"),Zv=o("Converts a sequence of tokens (string) in a single string."),ew=p(),Lt=r("div"),w(Ja.$$.fragment),tw=p(),Hp=r("p"),ow=o("Create a mask from the two sequences passed to be used in a sequence-pair classification task. A BERT sequence"),sw=p(),w(Ws.$$.fragment),nw=p(),Ko=r("p"),rw=o("If "),Kp=r("code"),aw=o("token_ids_1"),iw=o(" is "),Vp=r("code"),lw=o("None"),dw=o(", this method only returns the first portion of the mask (0s)."),cw=p(),Us=r("div"),w(Ga.$$.fragment),pw=p(),Xa=r("p"),hw=o(`Retrieve sequence ids from a token list that has no special tokens added. This method is called when adding
special tokens using the tokenizer `),Jp=r("code"),uw=o("prepare_for_model"),fw=o(" method."),cm=p(),Vo=r("h2"),Qs=r("a"),Gp=r("span"),w(Ya.$$.fragment),mw=p(),Xp=r("span"),gw=o("DistilBertTokenizerFast"),pm=p(),ft=r("div"),w(Za.$$.fragment),_w=p(),ei=r("p"),bw=o("Construct a \u201Cfast\u201D DistilBERT tokenizer (backed by HuggingFace\u2019s "),Yp=r("em"),kw=o("tokenizers"),vw=o(" library). Based on WordPiece."),ww=p(),ti=r("p"),Tw=o("This tokenizer inherits from "),Bc=r("a"),yw=o("PreTrainedTokenizerFast"),$w=o(` which contains most of the main methods. Users should
refer to this superclass for more information regarding those methods.`),Fw=p(),Mo=r("div"),w(oi.$$.fragment),Dw=p(),Zp=r("p"),Ew=o(`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:`),xw=p(),si=r("ul"),Mc=r("li"),Bw=o("single sequence: "),eh=r("code"),Mw=o("[CLS] X [SEP]"),zw=p(),zc=r("li"),Cw=o("pair of sequences: "),th=r("code"),Aw=o("[CLS] A [SEP] B [SEP]"),jw=p(),Ot=r("div"),w(ni.$$.fragment),qw=p(),oh=r("p"),Pw=o("Create a mask from the two sequences passed to be used in a sequence-pair classification task. A BERT sequence"),Lw=p(),w(Hs.$$.fragment),Ow=p(),Jo=r("p"),Iw=o("If "),sh=r("code"),Sw=o("token_ids_1"),Nw=o(" is "),nh=r("code"),Rw=o("None"),Ww=o(", this method only returns the first portion of the mask (0s)."),hm=p(),Go=r("h2"),Ks=r("a"),rh=r("span"),w(ri.$$.fragment),Uw=p(),ah=r("span"),Qw=o("DistilBertModel"),um=p(),mt=r("div"),w(ai.$$.fragment),Hw=p(),ih=r("p"),Kw=o("The bare DistilBERT encoder/transformer outputting raw hidden-states without any specific head on top."),Vw=p(),ii=r("p"),Jw=o("This model inherits from "),Cc=r("a"),Gw=o("PreTrainedModel"),Xw=o(`. 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.)`),Yw=p(),li=r("p"),Zw=o("This model is also a PyTorch "),di=r("a"),eT=o("torch.nn.Module"),tT=o(` subclass.
Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
and behavior.`),oT=p(),It=r("div"),w(ci.$$.fragment),sT=p(),Xo=r("p"),nT=o("The "),Ac=r("a"),rT=o("DistilBertModel"),aT=o(" forward method, overrides the "),lh=r("code"),iT=o("__call__"),lT=o(" special method."),dT=p(),w(Vs.$$.fragment),cT=p(),w(Js.$$.fragment),fm=p(),Yo=r("h2"),Gs=r("a"),dh=r("span"),w(pi.$$.fragment),pT=p(),ch=r("span"),hT=o("DistilBertForMaskedLM"),mm=p(),gt=r("div"),w(hi.$$.fragment),uT=p(),ui=r("p"),fT=o("DistilBert Model with a "),ph=r("code"),mT=o("masked language modeling"),gT=o(" head on top."),_T=p(),fi=r("p"),bT=o("This model inherits from "),jc=r("a"),kT=o("PreTrainedModel"),vT=o(`. 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.)`),wT=p(),mi=r("p"),TT=o("This model is also a PyTorch "),gi=r("a"),yT=o("torch.nn.Module"),$T=o(` subclass.
Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
and behavior.`),FT=p(),St=r("div"),w(_i.$$.fragment),DT=p(),Zo=r("p"),ET=o("The "),qc=r("a"),xT=o("DistilBertForMaskedLM"),BT=o(" forward method, overrides the "),hh=r("code"),MT=o("__call__"),zT=o(" special method."),CT=p(),w(Xs.$$.fragment),AT=p(),w(Ys.$$.fragment),gm=p(),es=r("h2"),Zs=r("a"),uh=r("span"),w(bi.$$.fragment),jT=p(),fh=r("span"),qT=o("DistilBertForSequenceClassification"),_m=p(),_t=r("div"),w(ki.$$.fragment),PT=p(),mh=r("p"),LT=o(`DistilBert Model transformer with a sequence classification/regression head on top (a linear layer on top of the
pooled output) e.g. for GLUE tasks.`),OT=p(),vi=r("p"),IT=o("This model inherits from "),Pc=r("a"),ST=o("PreTrainedModel"),NT=o(`. 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.)`),RT=p(),wi=r("p"),WT=o("This model is also a PyTorch "),Ti=r("a"),UT=o("torch.nn.Module"),QT=o(` subclass.
Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
and behavior.`),HT=p(),wt=r("div"),w(yi.$$.fragment),KT=p(),ts=r("p"),VT=o("The "),Lc=r("a"),JT=o("DistilBertForSequenceClassification"),GT=o(" forward method, overrides the "),gh=r("code"),XT=o("__call__"),YT=o(" special method."),ZT=p(),w(en.$$.fragment),ey=p(),w(tn.$$.fragment),ty=p(),w(on.$$.fragment),bm=p(),os=r("h2"),sn=r("a"),_h=r("span"),w($i.$$.fragment),oy=p(),bh=r("span"),sy=o("DistilBertForMultipleChoice"),km=p(),bt=r("div"),w(Fi.$$.fragment),ny=p(),kh=r("p"),ry=o(`DistilBert 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.`),ay=p(),Di=r("p"),iy=o("This model inherits from "),Oc=r("a"),ly=o("PreTrainedModel"),dy=o(`. 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.)`),cy=p(),Ei=r("p"),py=o("This model is also a PyTorch "),xi=r("a"),hy=o("torch.nn.Module"),uy=o(` subclass.
Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
and behavior.`),fy=p(),Nt=r("div"),w(Bi.$$.fragment),my=p(),ss=r("p"),gy=o("The "),Ic=r("a"),_y=o("DistilBertForMultipleChoice"),by=o(" forward method, overrides the "),vh=r("code"),ky=o("__call__"),vy=o(" special method."),wy=p(),w(nn.$$.fragment),Ty=p(),w(rn.$$.fragment),vm=p(),ns=r("h2"),an=r("a"),wh=r("span"),w(Mi.$$.fragment),yy=p(),Th=r("span"),$y=o("DistilBertForTokenClassification"),wm=p(),kt=r("div"),w(zi.$$.fragment),Fy=p(),yh=r("p"),Dy=o(`DistilBert 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.`),Ey=p(),Ci=r("p"),xy=o("This model inherits from "),Sc=r("a"),By=o("PreTrainedModel"),My=o(`. 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.)`),zy=p(),Ai=r("p"),Cy=o("This model is also a PyTorch "),ji=r("a"),Ay=o("torch.nn.Module"),jy=o(` subclass.
Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
and behavior.`),qy=p(),Rt=r("div"),w(qi.$$.fragment),Py=p(),rs=r("p"),Ly=o("The "),Nc=r("a"),Oy=o("DistilBertForTokenClassification"),Iy=o(" forward method, overrides the "),$h=r("code"),Sy=o("__call__"),Ny=o(" special method."),Ry=p(),w(ln.$$.fragment),Wy=p(),w(dn.$$.fragment),Tm=p(),as=r("h2"),cn=r("a"),Fh=r("span"),w(Pi.$$.fragment),Uy=p(),Dh=r("span"),Qy=o("DistilBertForQuestionAnswering"),ym=p(),vt=r("div"),w(Li.$$.fragment),Hy=p(),is=r("p"),Ky=o(`DistilBert 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 `),Eh=r("code"),Vy=o("span start logits"),Jy=o(" and "),xh=r("code"),Gy=o("span end logits"),Xy=o(")."),Yy=p(),Oi=r("p"),Zy=o("This model inherits from "),Rc=r("a"),e$=o("PreTrainedModel"),t$=o(`. 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.)`),o$=p(),Ii=r("p"),s$=o("This model is also a PyTorch "),Si=r("a"),n$=o("torch.nn.Module"),r$=o(` subclass.
Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
and behavior.`),a$=p(),Wt=r("div"),w(Ni.$$.fragment),i$=p(),ls=r("p"),l$=o("The "),Wc=r("a"),d$=o("DistilBertForQuestionAnswering"),c$=o(" forward method, overrides the "),Bh=r("code"),p$=o("__call__"),h$=o(" special method."),u$=p(),w(pn.$$.fragment),f$=p(),w(hn.$$.fragment),$m=p(),ds=r("h2"),un=r("a"),Mh=r("span"),w(Ri.$$.fragment),m$=p(),zh=r("span"),g$=o("TFDistilBertModel"),Fm=p(),lt=r("div"),w(Wi.$$.fragment),_$=p(),Ch=r("p"),b$=o("The bare DistilBERT encoder/transformer outputting raw hidden-states without any specific head on top."),k$=p(),Ui=r("p"),v$=o("This model inherits from "),Uc=r("a"),w$=o("TFPreTrainedModel"),T$=o(`. 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.)`),y$=p(),Qi=r("p"),$$=o("This model is also a "),Hi=r("a"),F$=o("tf.keras.Model"),D$=o(` 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.`),E$=p(),w(fn.$$.fragment),x$=p(),Ut=r("div"),w(Ki.$$.fragment),B$=p(),cs=r("p"),M$=o("The "),Qc=r("a"),z$=o("TFDistilBertModel"),C$=o(" forward method, overrides the "),Ah=r("code"),A$=o("__call__"),j$=o(" special method."),q$=p(),w(mn.$$.fragment),P$=p(),w(gn.$$.fragment),Dm=p(),ps=r("h2"),_n=r("a"),jh=r("span"),w(Vi.$$.fragment),L$=p(),qh=r("span"),O$=o("TFDistilBertForMaskedLM"),Em=p(),dt=r("div"),w(Ji.$$.fragment),I$=p(),Gi=r("p"),S$=o("DistilBert Model with a "),Ph=r("code"),N$=o("masked language modeling"),R$=o(" head on top."),W$=p(),Xi=r("p"),U$=o("This model inherits from "),Hc=r("a"),Q$=o("TFPreTrainedModel"),H$=o(`. 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.)`),K$=p(),Yi=r("p"),V$=o("This model is also a "),Zi=r("a"),J$=o("tf.keras.Model"),G$=o(` 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.`),X$=p(),w(bn.$$.fragment),Y$=p(),Tt=r("div"),w(el.$$.fragment),Z$=p(),hs=r("p"),e1=o("The "),Kc=r("a"),t1=o("TFDistilBertForMaskedLM"),o1=o(" forward method, overrides the "),Lh=r("code"),s1=o("__call__"),n1=o(" special method."),r1=p(),w(kn.$$.fragment),a1=p(),w(vn.$$.fragment),i1=p(),w(wn.$$.fragment),xm=p(),us=r("h2"),Tn=r("a"),Oh=r("span"),w(tl.$$.fragment),l1=p(),Ih=r("span"),d1=o("TFDistilBertForSequenceClassification"),Bm=p(),ct=r("div"),w(ol.$$.fragment),c1=p(),Sh=r("p"),p1=o(`DistilBert Model transformer with a sequence classification/regression head on top (a linear layer on top of the
pooled output) e.g. for GLUE tasks.`),h1=p(),sl=r("p"),u1=o("This model inherits from "),Vc=r("a"),f1=o("TFPreTrainedModel"),m1=o(`. 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.)`),g1=p(),nl=r("p"),_1=o("This model is also a "),rl=r("a"),b1=o("tf.keras.Model"),k1=o(` 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.`),v1=p(),w(yn.$$.fragment),w1=p(),yt=r("div"),w(al.$$.fragment),T1=p(),fs=r("p"),y1=o("The "),Jc=r("a"),$1=o("TFDistilBertForSequenceClassification"),F1=o(" forward method, overrides the "),Nh=r("code"),D1=o("__call__"),E1=o(" special method."),x1=p(),w($n.$$.fragment),B1=p(),w(Fn.$$.fragment),M1=p(),w(Dn.$$.fragment),Mm=p(),ms=r("h2"),En=r("a"),Rh=r("span"),w(il.$$.fragment),z1=p(),Wh=r("span"),C1=o("TFDistilBertForMultipleChoice"),zm=p(),pt=r("div"),w(ll.$$.fragment),A1=p(),Uh=r("p"),j1=o(`DistilBert 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.`),q1=p(),dl=r("p"),P1=o("This model inherits from "),Gc=r("a"),L1=o("TFPreTrainedModel"),O1=o(`. 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.)`),I1=p(),cl=r("p"),S1=o("This model is also a "),pl=r("a"),N1=o("tf.keras.Model"),R1=o(` 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.`),W1=p(),w(xn.$$.fragment),U1=p(),Qt=r("div"),w(hl.$$.fragment),Q1=p(),gs=r("p"),H1=o("The "),Xc=r("a"),K1=o("TFDistilBertForMultipleChoice"),V1=o(" forward method, overrides the "),Qh=r("code"),J1=o("__call__"),G1=o(" special method."),X1=p(),w(Bn.$$.fragment),Y1=p(),w(Mn.$$.fragment),Cm=p(),_s=r("h2"),zn=r("a"),Hh=r("span"),w(ul.$$.fragment),Z1=p(),Kh=r("span"),e2=o("TFDistilBertForTokenClassification"),Am=p(),ht=r("div"),w(fl.$$.fragment),t2=p(),Vh=r("p"),o2=o(`DistilBert 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.`),s2=p(),ml=r("p"),n2=o("This model inherits from "),Yc=r("a"),r2=o("TFPreTrainedModel"),a2=o(`. 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.)`),i2=p(),gl=r("p"),l2=o("This model is also a "),_l=r("a"),d2=o("tf.keras.Model"),c2=o(` 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.`),p2=p(),w(Cn.$$.fragment),h2=p(),$t=r("div"),w(bl.$$.fragment),u2=p(),bs=r("p"),f2=o("The "),Zc=r("a"),m2=o("TFDistilBertForTokenClassification"),g2=o(" forward method, overrides the "),Jh=r("code"),_2=o("__call__"),b2=o(" special method."),k2=p(),w(An.$$.fragment),v2=p(),w(jn.$$.fragment),w2=p(),w(qn.$$.fragment),jm=p(),ks=r("h2"),Pn=r("a"),Gh=r("span"),w(kl.$$.fragment),T2=p(),Xh=r("span"),y2=o("TFDistilBertForQuestionAnswering"),qm=p(),ut=r("div"),w(vl.$$.fragment),$2=p(),vs=r("p"),F2=o(`DistilBert 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 `),Yh=r("code"),D2=o("span start logits"),E2=o(" and "),Zh=r("code"),x2=o("span end logits"),B2=o(")."),M2=p(),wl=r("p"),z2=o("This model inherits from "),ep=r("a"),C2=o("TFPreTrainedModel"),A2=o(`. 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.)`),j2=p(),Tl=r("p"),q2=o("This model is also a "),yl=r("a"),P2=o("tf.keras.Model"),L2=o(` 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.`),O2=p(),w(Ln.$$.fragment),I2=p(),Ft=r("div"),w($l.$$.fragment),S2=p(),ws=r("p"),N2=o("The "),tp=r("a"),R2=o("TFDistilBertForQuestionAnswering"),W2=o(" forward method, overrides the "),eu=r("code"),U2=o("__call__"),Q2=o(" special method."),H2=p(),w(On.$$.fragment),K2=p(),w(In.$$.fragment),V2=p(),w(Sn.$$.fragment),Pm=p(),Ts=r("h2"),Nn=r("a"),tu=r("span"),w(Fl.$$.fragment),J2=p(),ou=r("span"),G2=o("FlaxDistilBertModel"),Lm=p(),ot=r("div"),w(Dl.$$.fragment),X2=p(),su=r("p"),Y2=o("The bare DistilBert Model transformer outputting raw hidden-states without any specific head on top."),Z2=p(),El=r("p"),eF=o("This model inherits from "),op=r("a"),tF=o("FlaxPreTrainedModel"),oF=o(`. Check the superclass documentation for the generic methods the
library implements for all its model (such as downloading, saving and converting weights from PyTorch models)`),sF=p(),xl=r("p"),nF=o("This model is also a Flax Linen "),Bl=r("a"),rF=o("flax.linen.Module"),aF=o(`
subclass. Use it as a regular Flax linen Module and refer to the Flax documentation for all matter related to
general usage and behavior.`),iF=p(),nu=r("p"),lF=o("Finally, this model supports inherent JAX features such as:"),dF=p(),ro=r("ul"),ru=r("li"),Ml=r("a"),cF=o("Just-In-Time (JIT) compilation"),pF=p(),au=r("li"),zl=r("a"),hF=o("Automatic Differentiation"),uF=p(),iu=r("li"),Cl=r("a"),fF=o("Vectorization"),mF=p(),lu=r("li"),Al=r("a"),gF=o("Parallelization"),_F=p(),Ht=r("div"),w(jl.$$.fragment),bF=p(),ys=r("p"),kF=o("The "),du=r("code"),vF=o("FlaxDistilBertPreTrainedModel"),wF=o(" forward method, overrides the "),cu=r("code"),TF=o("__call__"),yF=o(" special method."),$F=p(),w(Rn.$$.fragment),FF=p(),w(Wn.$$.fragment),Om=p(),$s=r("h2"),Un=r("a"),pu=r("span"),w(ql.$$.fragment),DF=p(),hu=r("span"),EF=o("FlaxDistilBertForMaskedLM"),Im=p(),st=r("div"),w(Pl.$$.fragment),xF=p(),Ll=r("p"),BF=o("DistilBert Model with a "),uu=r("code"),MF=o("language modeling"),zF=o(" head on top."),CF=p(),Ol=r("p"),AF=o("This model inherits from "),sp=r("a"),jF=o("FlaxPreTrainedModel"),qF=o(`. Check the superclass documentation for the generic methods the
library implements for all its model (such as downloading, saving and converting weights from PyTorch models)`),PF=p(),Il=r("p"),LF=o("This model is also a Flax Linen "),Sl=r("a"),OF=o("flax.linen.Module"),IF=o(`
subclass. Use it as a regular Flax linen Module and refer to the Flax documentation for all matter related to
general usage and behavior.`),SF=p(),fu=r("p"),NF=o("Finally, this model supports inherent JAX features such as:"),RF=p(),ao=r("ul"),mu=r("li"),Nl=r("a"),WF=o("Just-In-Time (JIT) compilation"),UF=p(),gu=r("li"),Rl=r("a"),QF=o("Automatic Differentiation"),HF=p(),_u=r("li"),Wl=r("a"),KF=o("Vectorization"),VF=p(),bu=r("li"),Ul=r("a"),JF=o("Parallelization"),GF=p(),Kt=r("div"),w(Ql.$$.fragment),XF=p(),Fs=r("p"),YF=o("The "),ku=r("code"),ZF=o("FlaxDistilBertPreTrainedModel"),eD=o(" forward method, overrides the "),vu=r("code"),tD=o("__call__"),oD=o(" special method."),sD=p(),w(Qn.$$.fragment),nD=p(),w(Hn.$$.fragment),Sm=p(),Ds=r("h2"),Kn=r("a"),wu=r("span"),w(Hl.$$.fragment),rD=p(),Tu=r("span"),aD=o("FlaxDistilBertForSequenceClassification"),Nm=p(),nt=r("div"),w(Kl.$$.fragment),iD=p(),yu=r("p"),lD=o(`DistilBert Model transformer with a sequence classification/regression head on top (a linear layer on top of the
pooled output) e.g. for GLUE tasks.`),dD=p(),Vl=r("p"),cD=o("This model inherits from "),np=r("a"),pD=o("FlaxPreTrainedModel"),hD=o(`. Check the superclass documentation for the generic methods the
library implements for all its model (such as downloading, saving and converting weights from PyTorch models)`),uD=p(),Jl=r("p"),fD=o("This model is also a Flax Linen "),Gl=r("a"),mD=o("flax.linen.Module"),gD=o(`
subclass. Use it as a regular Flax linen Module and refer to the Flax documentation for all matter related to
general usage and behavior.`),_D=p(),$u=r("p"),bD=o("Finally, this model supports inherent JAX features such as:"),kD=p(),io=r("ul"),Fu=r("li"),Xl=r("a"),vD=o("Just-In-Time (JIT) compilation"),wD=p(),Du=r("li"),Yl=r("a"),TD=o("Automatic Differentiation"),yD=p(),Eu=r("li"),Zl=r("a"),$D=o("Vectorization"),FD=p(),xu=r("li"),ed=r("a"),DD=o("Parallelization"),ED=p(),Vt=r("div"),w(td.$$.fragment),xD=p(),Es=r("p"),BD=o("The "),Bu=r("code"),MD=o("FlaxDistilBertPreTrainedModel"),zD=o(" forward method, overrides the "),Mu=r("code"),CD=o("__call__"),AD=o(" special method."),jD=p(),w(Vn.$$.fragment),qD=p(),w(Jn.$$.fragment),Rm=p(),xs=r("h2"),Gn=r("a"),zu=r("span"),w(od.$$.fragment),PD=p(),Cu=r("span"),LD=o("FlaxDistilBertForMultipleChoice"),Wm=p(),rt=r("div"),w(sd.$$.fragment),OD=p(),Au=r("p"),ID=o(`DistilBert 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.`),SD=p(),nd=r("p"),ND=o("This model inherits from "),rp=r("a"),RD=o("FlaxPreTrainedModel"),WD=o(`. Check the superclass documentation for the generic methods the
library implements for all its model (such as downloading, saving and converting weights from PyTorch models)`),UD=p(),rd=r("p"),QD=o("This model is also a Flax Linen "),ad=r("a"),HD=o("flax.linen.Module"),KD=o(`
subclass. Use it as a regular Flax linen Module and refer to the Flax documentation for all matter related to
general usage and behavior.`),VD=p(),ju=r("p"),JD=o("Finally, this model supports inherent JAX features such as:"),GD=p(),lo=r("ul"),qu=r("li"),id=r("a"),XD=o("Just-In-Time (JIT) compilation"),YD=p(),Pu=r("li"),ld=r("a"),ZD=o("Automatic Differentiation"),e0=p(),Lu=r("li"),dd=r("a"),t0=o("Vectorization"),o0=p(),Ou=r("li"),cd=r("a"),s0=o("Parallelization"),n0=p(),Jt=r("div"),w(pd.$$.fragment),r0=p(),Bs=r("p"),a0=o("The "),Iu=r("code"),i0=o("FlaxDistilBertPreTrainedModel"),l0=o(" forward method, overrides the "),Su=r("code"),d0=o("__call__"),c0=o(" special method."),p0=p(),w(Xn.$$.fragment),h0=p(),w(Yn.$$.fragment),Um=p(),Ms=r("h2"),Zn=r("a"),Nu=r("span"),w(hd.$$.fragment),u0=p(),Ru=r("span"),f0=o("FlaxDistilBertForTokenClassification"),Qm=p(),at=r("div"),w(ud.$$.fragment),m0=p(),Wu=r("p"),g0=o(`DistilBert 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.`),_0=p(),fd=r("p"),b0=o("This model inherits from "),ap=r("a"),k0=o("FlaxPreTrainedModel"),v0=o(`. Check the superclass documentation for the generic methods the
library implements for all its model (such as downloading, saving and converting weights from PyTorch models)`),w0=p(),md=r("p"),T0=o("This model is also a Flax Linen "),gd=r("a"),y0=o("flax.linen.Module"),$0=o(`
subclass. Use it as a regular Flax linen Module and refer to the Flax documentation for all matter related to
general usage and behavior.`),F0=p(),Uu=r("p"),D0=o("Finally, this model supports inherent JAX features such as:"),E0=p(),co=r("ul"),Qu=r("li"),_d=r("a"),x0=o("Just-In-Time (JIT) compilation"),B0=p(),Hu=r("li"),bd=r("a"),M0=o("Automatic Differentiation"),z0=p(),Ku=r("li"),kd=r("a"),C0=o("Vectorization"),A0=p(),Vu=r("li"),vd=r("a"),j0=o("Parallelization"),q0=p(),Gt=r("div"),w(wd.$$.fragment),P0=p(),zs=r("p"),L0=o("The "),Ju=r("code"),O0=o("FlaxDistilBertPreTrainedModel"),I0=o(" forward method, overrides the "),Gu=r("code"),S0=o("__call__"),N0=o(" special method."),R0=p(),w(er.$$.fragment),W0=p(),w(tr.$$.fragment),Hm=p(),Cs=r("h2"),or=r("a"),Xu=r("span"),w(Td.$$.fragment),U0=p(),Yu=r("span"),Q0=o("FlaxDistilBertForQuestionAnswering"),Km=p(),it=r("div"),w(yd.$$.fragment),H0=p(),As=r("p"),K0=o(`DistilBert 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 `),Zu=r("code"),V0=o("span start logits"),J0=o(" and "),ef=r("code"),G0=o("span end logits"),X0=o(")."),Y0=p(),$d=r("p"),Z0=o("This model inherits from "),ip=r("a"),eE=o("FlaxPreTrainedModel"),tE=o(`. Check the superclass documentation for the generic methods the
library implements for all its model (such as downloading, saving and converting weights from PyTorch models)`),oE=p(),Fd=r("p"),sE=o("This model is also a Flax Linen "),Dd=r("a"),nE=o("flax.linen.Module"),rE=o(`
subclass. Use it as a regular Flax linen Module and refer to the Flax documentation for all matter related to
general usage and behavior.`),aE=p(),tf=r("p"),iE=o("Finally, this model supports inherent JAX features such as:"),lE=p(),po=r("ul"),of=r("li"),Ed=r("a"),dE=o("Just-In-Time (JIT) compilation"),cE=p(),sf=r("li"),xd=r("a"),pE=o("Automatic Differentiation"),hE=p(),nf=r("li"),Bd=r("a"),uE=o("Vectorization"),fE=p(),rf=r("li"),Md=r("a"),mE=o("Parallelization"),gE=p(),Xt=r("div"),w(zd.$$.fragment),_E=p(),js=r("p"),bE=o("The "),af=r("code"),kE=o("FlaxDistilBertPreTrainedModel"),vE=o(" forward method, overrides the "),lf=r("code"),wE=o("__call__"),TE=o(" special method."),yE=p(),w(sr.$$.fragment),$E=p(),w(nr.$$.fragment),this.h()},l(n){const _=Yz('[data-svelte="svelte-1phssyn"]',document.head);d=a(_,"META",{name:!0,content:!0}),_.forEach(t),k=h(n),f=a(n,"H1",{class:!0});var Cd=i(f);m=a(Cd,"A",{id:!0,class:!0,href:!0});var df=i(m);b=a(df,"SPAN",{});var cf=i(b);T(l.$$.fragment,cf),cf.forEach(t),df.forEach(t),u=h(Cd),M=a(Cd,"SPAN",{});var pf=i(M);be=s(pf,"DistilBERT"),pf.forEach(t),Cd.forEach(t),ue=h(n),I=a(n,"H2",{class:!0});var Ad=i(I);re=a(Ad,"A",{id:!0,class:!0,href:!0});var hf=i(re);oe=a(hf,"SPAN",{});var uf=i(oe);T(E.$$.fragment,uf),uf.forEach(t),hf.forEach(t),ke=h(Ad),Q=a(Ad,"SPAN",{});var ff=i(Q);ve=s(ff,"Overview"),ff.forEach(t),Ad.forEach(t),fe=h(n),L=a(n,"P",{});var ho=i(L);we=s(ho,"The DistilBERT model was proposed in the blog post "),ae=a(ho,"A",{href:!0,rel:!0});var mf=i(ae);K=s(mf,`Smaller, faster, cheaper, lighter: Introducing DistilBERT, a
distilled version of BERT`),mf.forEach(t),Te=s(ho,", and the paper "),ie=a(ho,"A",{href:!0,rel:!0});var gf=i(ie);V=s(gf,`DistilBERT, a
distilled version of BERT: smaller, faster, cheaper and lighter`),gf.forEach(t),ye=s(ho,`. DistilBERT is a
small, fast, cheap and light Transformer model trained by distilling BERT base. It has 40% less parameters than
`),de=a(ho,"EM",{});var _f=i(de);J=s(_f,"bert-base-uncased"),_f.forEach(t),$e=s(ho,`, runs 60% faster while preserving over 95% of BERT\u2019s performances as measured on the GLUE language
understanding benchmark.`),ho.forEach(t),me=h(n),ee=a(n,"P",{});var bf=i(ee);C=s(bf,"The abstract from the paper is the following:"),bf.forEach(t),q=h(n),le=a(n,"P",{});var kf=i(le);H=a(kf,"EM",{});var vf=i(H);Fe=s(vf,`As Transfer Learning from large-scale pre-trained models becomes more prevalent in Natural Language Processing (NLP),
operating these large models in on-the-edge and/or under constrained computational training or inference budgets
remains challenging. In this work, we propose a method to pre-train a smaller general-purpose language representation
model, called DistilBERT, which can then be fine-tuned with good performances on a wide range of tasks like its larger
counterparts. While most prior work investigated the use of distillation for building task-specific models, we leverage
knowledge distillation during the pretraining phase and show that it is possible to reduce the size of a BERT model by
40%, while retaining 97% of its language understanding capabilities and being 60% faster. To leverage the inductive
biases learned by larger models during pretraining, we introduce a triple loss combining language modeling,
distillation and cosine-distance losses. Our smaller, faster and lighter model is cheaper to pre-train and we
demonstrate its capabilities for on-device computations in a proof-of-concept experiment and a comparative on-device
study.`),vf.forEach(t),kf.forEach(t),ge=h(n),U=a(n,"P",{});var wf=i(U);De=s(wf,"Tips:"),wf.forEach(t),_e=h(n),A=a(n,"UL",{});var jd=i(A);se=a(jd,"LI",{});var uo=i(se);G=s(uo,"DistilBERT doesn\u2019t have "),ce=a(uo,"CODE",{});var Tf=i(ce);Ee=s(Tf,"token_type_ids"),Tf.forEach(t),X=s(uo,`, you don\u2019t need to indicate which token belongs to which segment. Just
separate your segments with the separation token `),pe=a(uo,"CODE",{});var yf=i(pe);xe=s(yf,"tokenizer.sep_token"),yf.forEach(t),S=s(uo," (or "),he=a(uo,"CODE",{});var $f=i(he);Y=s($f,"[SEP]"),$f.forEach(t),Be=s(uo,")."),uo.forEach(t),ne=h(jd),j=a(jd,"LI",{});var qd=i(j);Me=s(qd,"DistilBERT doesn\u2019t have options to select the input positions ("),P=a(qd,"CODE",{});var Ff=i(P);ze=s(Ff,"position_ids"),Ff.forEach(t),Ce=s(qd,` input). This could be added if
necessary though, just let us know if you need this option.`),qd.forEach(t),jd.forEach(t),v=h(n),B=a(n,"P",{});var fo=i(B);He=s(fo,"This model was contributed by "),Z=a(fo,"A",{href:!0,rel:!0});var Df=i(Z);Ke=s(Df,"victorsanh"),Df.forEach(t),Ve=s(fo,`. This model jax version was
contributed by `),z=a(fo,"A",{href:!0,rel:!0});var Ef=i(z);Je=s(Ef,"kamalkraj"),Ef.forEach(t),Ge=s(fo,". The original code can be found "),Oe=a(fo,"A",{href:!0,rel:!0});var xf=i(Oe);Xe=s(xf,"here"),xf.forEach(t),Ye=s(fo,"."),fo.forEach(t),O=h(n),N=a(n,"H2",{class:!0});var Pd=i(N);je=a(Pd,"A",{id:!0,class:!0,href:!0});var Bf=i(je);Re=a(Bf,"SPAN",{});var Mf=i(Re);T(W.$$.fragment,Mf),Mf.forEach(t),Bf.forEach(t),Ze=h(Pd),We=a(Pd,"SPAN",{});var zf=i(We);Ae=s(zf,"Resources"),zf.forEach(t),Pd.forEach(t),Qe=h(n),te=a(n,"P",{});var Cf=i(te);et=s(Cf,"A list of official Hugging Face and community (indicated by \u{1F30E}) resources to help you get started with DistilBERT. If you\u2019re interested in submitting a resource to be included here, please feel free to open a Pull Request and we\u2019ll review it! The resource should ideally demonstrate something new instead of duplicating an existing resource."),Cf.forEach(t),Uf=h(n),T(zr.$$.fragment,n),Qf=h(n),Ie=a(n,"UL",{});var Ue=i(Ie);Cr=a(Ue,"LI",{});var Ld=i(Cr);v_=s(Ld,"A blog post on "),Ar=a(Ld,"A",{href:!0,rel:!0});var Af=i(Ar);w_=s(Af,"Getting Started with Sentiment Analysis using Python"),Af.forEach(t),T_=s(Ld," with DistilBERT."),Ld.forEach(t),y_=h(Ue),jr=a(Ue,"LI",{});var Od=i(jr);$_=s(Od,"A blog post on how to "),qr=a(Od,"A",{href:!0,rel:!0});var jf=i(qr);F_=s(jf,"train DistilBERT with Blurr for sequence classification"),jf.forEach(t),D_=s(Od,"."),Od.forEach(t),E_=h(Ue),Pr=a(Ue,"LI",{});var Id=i(Pr);x_=s(Id,"A blog post on how to use "),Lr=a(Id,"A",{href:!0,rel:!0});var qf=i(Lr);B_=s(qf,"Ray to tune DistilBERT hyperparameters"),qf.forEach(t),M_=s(Id,"."),Id.forEach(t),z_=h(Ue),Or=a(Ue,"LI",{});var Sd=i(Or);C_=s(Sd,"A blog post on how to "),Ir=a(Sd,"A",{href:!0,rel:!0});var Pf=i(Ir);A_=s(Pf,"train DistilBERT with Hugging Face and Amazon SageMaker"),Pf.forEach(t),j_=s(Sd,"."),Sd.forEach(t),q_=h(Ue),Sr=a(Ue,"LI",{});var Nd=i(Sr);P_=s(Nd,"A notebook on how to "),Nr=a(Nd,"A",{href:!0,rel:!0});var Lf=i(Nr);L_=s(Lf,"finetune DistilBERT for multi-label classification"),Lf.forEach(t),O_=s(Nd,". \u{1F30E}"),Nd.forEach(t),I_=h(Ue),Rr=a(Ue,"LI",{});var Rd=i(Rr);S_=s(Rd,"A notebook on how to "),Wr=a(Rd,"A",{href:!0,rel:!0});var Of=i(Wr);N_=s(Of,"finetune DistilBERT for multiclass classification with PyTorch"),Of.forEach(t),R_=s(Rd,". \u{1F30E}"),Rd.forEach(t),W_=h(Ue),Ur=a(Ue,"LI",{});var Wd=i(Ur);U_=s(Wd,"A notebook on how to "),Qr=a(Wd,"A",{href:!0,rel:!0});var If=i(Qr);Q_=s(If,"finetune DistilBERT for text classification in TensorFlow"),If.forEach(t),H_=s(Wd,". \u{1F30E}"),Wd.forEach(t),K_=h(Ue),mo=a(Ue,"LI",{});var zo=i(mo);tc=a(zo,"A",{href:!0});var Sf=i(tc);V_=s(Sf,"DistilBertForSequenceClassification"),Sf.forEach(t),J_=s(zo," is supported by this "),Hr=a(zo,"A",{href:!0,rel:!0});var Nf=i(Hr);G_=s(Nf,"example script"),Nf.forEach(t),X_=s(zo," and "),Kr=a(zo,"A",{href:!0,rel:!0});var CE=i(Kr);Y_=s(CE,"notebook"),CE.forEach(t),Z_=s(zo,"."),zo.forEach(t),eb=h(Ue),go=a(Ue,"LI",{});var Ud=i(go);oc=a(Ud,"A",{href:!0});var AE=i(oc);tb=s(AE,"TFDistilBertForSequenceClassification"),AE.forEach(t),ob=s(Ud," is supported by this "),Vr=a(Ud,"A",{href:!0,rel:!0});var jE=i(Vr);sb=s(jE,"example script"),jE.forEach(t),nb=s(Ud," and "),Jr=a(Ud,"A",{href:!0,rel:!0});var qE=i(Jr);rb=s(qE,"notebook"),qE.forEach(t),ab=s(Ud,"."),Ud.forEach(t),ib=h(Ue),_o=a(Ue,"LI",{});var Qd=i(_o);sc=a(Qd,"A",{href:!0});var PE=i(sc);lb=s(PE,"FlaxDistilBertForSequenceClassification"),PE.forEach(t),db=s(Qd," is supported by this "),Gr=a(Qd,"A",{href:!0,rel:!0});var LE=i(Gr);cb=s(LE,"example script"),LE.forEach(t),pb=s(Qd," and "),Xr=a(Qd,"A",{href:!0,rel:!0});var OE=i(Xr);hb=s(OE,"notebook"),OE.forEach(t),ub=s(Qd,"."),Qd.forEach(t),Ue.forEach(t),Hf=h(n),T(Yr.$$.fragment,n),Kf=h(n),jt=a(n,"UL",{});var rr=i(jt);bo=a(rr,"LI",{});var Hd=i(bo);nc=a(Hd,"A",{href:!0});var IE=i(nc);fb=s(IE,"DistilBertForTokenClassification"),IE.forEach(t),mb=s(Hd," is supported by this "),Zr=a(Hd,"A",{href:!0,rel:!0});var SE=i(Zr);gb=s(SE,"example script"),SE.forEach(t),_b=s(Hd," and "),ea=a(Hd,"A",{href:!0,rel:!0});var NE=i(ea);bb=s(NE,"notebook"),NE.forEach(t),kb=s(Hd,"."),Hd.forEach(t),vb=h(rr),ko=a(rr,"LI",{});var Kd=i(ko);rc=a(Kd,"A",{href:!0});var RE=i(rc);wb=s(RE,"TFDistilBertForTokenClassification"),RE.forEach(t),Tb=s(Kd," is supported by this "),ta=a(Kd,"A",{href:!0,rel:!0});var WE=i(ta);yb=s(WE,"example script"),WE.forEach(t),$b=s(Kd," and "),oa=a(Kd,"A",{href:!0,rel:!0});var UE=i(oa);Fb=s(UE,"notebook"),UE.forEach(t),Db=s(Kd,"."),Kd.forEach(t),Eb=h(rr),qs=a(rr,"LI",{});var Rf=i(qs);ac=a(Rf,"A",{href:!0});var QE=i(ac);xb=s(QE,"FlaxDistilBertForTokenClassification"),QE.forEach(t),Bb=s(Rf," is supported by this "),sa=a(Rf,"A",{href:!0,rel:!0});var HE=i(sa);Mb=s(HE,"example script"),HE.forEach(t),zb=s(Rf,"."),Rf.forEach(t),Cb=h(rr),ic=a(rr,"LI",{});var FE=i(ic);na=a(FE,"A",{href:!0,rel:!0});var KE=i(na);Ab=s(KE,"Token classification"),KE.forEach(t),jb=s(FE," chapter of the \u{1F917} Hugging Face Course."),FE.forEach(t),rr.forEach(t),Vf=h(n),T(ra.$$.fragment,n),Jf=h(n),qt=a(n,"UL",{});var ar=i(qt);vo=a(ar,"LI",{});var Vd=i(vo);lc=a(Vd,"A",{href:!0});var VE=i(lc);qb=s(VE,"DistilBertForMaskedLM"),VE.forEach(t),Pb=s(Vd," is supported by this "),aa=a(Vd,"A",{href:!0,rel:!0});var JE=i(aa);Lb=s(JE,"example script"),JE.forEach(t),Ob=s(Vd," and "),ia=a(Vd,"A",{href:!0,rel:!0});var GE=i(ia);Ib=s(GE,"notebook"),GE.forEach(t),Sb=s(Vd,"."),Vd.forEach(t),Nb=h(ar),wo=a(ar,"LI",{});var Jd=i(wo);dc=a(Jd,"A",{href:!0});var XE=i(dc);Rb=s(XE,"TFDistilBertForMaskedLM"),XE.forEach(t),Wb=s(Jd," is supported by this "),la=a(Jd,"A",{href:!0,rel:!0});var YE=i(la);Ub=s(YE,"example script"),YE.forEach(t),Qb=s(Jd," and "),da=a(Jd,"A",{href:!0,rel:!0});var ZE=i(da);Hb=s(ZE,"notebook"),ZE.forEach(t),Kb=s(Jd,"."),Jd.forEach(t),Vb=h(ar),To=a(ar,"LI",{});var Gd=i(To);cc=a(Gd,"A",{href:!0});var ex=i(cc);Jb=s(ex,"FlaxDistilBertForMaskedLM"),ex.forEach(t),Gb=s(Gd," is supported by this "),ca=a(Gd,"A",{href:!0,rel:!0});var tx=i(ca);Xb=s(tx,"example script"),tx.forEach(t),Yb=s(Gd," and "),pa=a(Gd,"A",{href:!0,rel:!0});var ox=i(pa);Zb=s(ox,"notebook"),ox.forEach(t),ek=s(Gd,"."),Gd.forEach(t),tk=h(ar),pc=a(ar,"LI",{});var DE=i(pc);ha=a(DE,"A",{href:!0,rel:!0});var sx=i(ha);ok=s(sx,"Masked language modeling"),sx.forEach(t),sk=s(DE," chapter of the \u{1F917} Hugging Face Course."),DE.forEach(t),ar.forEach(t),Gf=h(n),T(ua.$$.fragment,n),Xf=h(n),Pt=a(n,"UL",{});var ir=i(Pt);yo=a(ir,"LI",{});var Xd=i(yo);hc=a(Xd,"A",{href:!0});var nx=i(hc);nk=s(nx,"DistilBertForQuestionAnswering"),nx.forEach(t),rk=s(Xd," is supported by this "),fa=a(Xd,"A",{href:!0,rel:!0});var rx=i(fa);ak=s(rx,"example script"),rx.forEach(t),ik=s(Xd," and "),ma=a(Xd,"A",{href:!0,rel:!0});var ax=i(ma);lk=s(ax,"notebook"),ax.forEach(t),dk=s(Xd,"."),Xd.forEach(t),ck=h(ir),$o=a(ir,"LI",{});var Yd=i($o);uc=a(Yd,"A",{href:!0});var ix=i(uc);pk=s(ix,"TFDistilBertForQuestionAnswering"),ix.forEach(t),hk=s(Yd," is supported by this "),ga=a(Yd,"A",{href:!0,rel:!0});var lx=i(ga);uk=s(lx,"example script"),lx.forEach(t),fk=s(Yd," and "),_a=a(Yd,"A",{href:!0,rel:!0});var dx=i(_a);mk=s(dx,"notebook"),dx.forEach(t),gk=s(Yd,"."),Yd.forEach(t),_k=h(ir),Ps=a(ir,"LI",{});var Wf=i(Ps);fc=a(Wf,"A",{href:!0});var cx=i(fc);bk=s(cx,"FlaxDistilBertForQuestionAnswering"),cx.forEach(t),kk=s(Wf," is supported by this "),ba=a(Wf,"A",{href:!0,rel:!0});var px=i(ba);vk=s(px,"example script"),px.forEach(t),wk=s(Wf,"."),Wf.forEach(t),Tk=h(ir),mc=a(ir,"LI",{});var EE=i(mc);ka=a(EE,"A",{href:!0,rel:!0});var hx=i(ka);yk=s(hx,"Question answering"),hx.forEach(t),$k=s(EE," chapter of the \u{1F917} Hugging Face Course."),EE.forEach(t),ir.forEach(t),Yf=h(n),gc=a(n,"P",{});var ux=i(gc);Pp=a(ux,"STRONG",{});var fx=i(Pp);Fk=s(fx,"Multiple choice"),fx.forEach(t),ux.forEach(t),Zf=h(n),Ls=a(n,"UL",{});var Jm=i(Ls);Fo=a(Jm,"LI",{});var Zd=i(Fo);_c=a(Zd,"A",{href:!0});var mx=i(_c);Dk=s(mx,"DistilBertForMultipleChoice"),mx.forEach(t),Ek=s(Zd," is supported by this "),va=a(Zd,"A",{href:!0,rel:!0});var gx=i(va);xk=s(gx,"example script"),gx.forEach(t),Bk=s(Zd," and "),wa=a(Zd,"A",{href:!0,rel:!0});var _x=i(wa);Mk=s(_x,"notebook"),_x.forEach(t),zk=s(Zd,"."),Zd.forEach(t),Ck=h(Jm),Do=a(Jm,"LI",{});var ec=i(Do);bc=a(ec,"A",{href:!0});var bx=i(bc);Ak=s(bx,"TFDistilBertForMultipleChoice"),bx.forEach(t),jk=s(ec," is supported by this "),Ta=a(ec,"A",{href:!0,rel:!0});var kx=i(Ta);qk=s(kx,"example script"),kx.forEach(t),Pk=s(ec," and "),ya=a(ec,"A",{href:!0,rel:!0});var vx=i(ya);Lk=s(vx,"notebook"),vx.forEach(t),Ok=s(ec,"."),ec.forEach(t),Jm.forEach(t),em=h(n),kc=a(n,"P",{});var wx=i(kc);Ik=s(wx,"\u2697\uFE0F Optimization"),wx.forEach(t),tm=h(n),Eo=a(n,"UL",{});var lp=i(Eo);$a=a(lp,"LI",{});var Gm=i($a);Sk=s(Gm,"A blog post on how to "),Fa=a(Gm,"A",{href:!0,rel:!0});var Tx=i(Fa);Nk=s(Tx,"quantize DistilBERT with \u{1F917} Optimum and Intel"),Tx.forEach(t),Rk=s(Gm,"."),Gm.forEach(t),Wk=h(lp),Da=a(lp,"LI",{});var Xm=i(Da);Uk=s(Xm,"A blog post on how "),Ea=a(Xm,"A",{href:!0,rel:!0});var yx=i(Ea);Qk=s(yx,"Optimizing Transformers for GPUs with \u{1F917} Optimum"),yx.forEach(t),Hk=s(Xm,"."),Xm.forEach(t),Kk=h(lp),xa=a(lp,"LI",{});var Ym=i(xa);Vk=s(Ym,"A blog post on "),Ba=a(Ym,"A",{href:!0,rel:!0});var $x=i(Ba);Jk=s($x,"Optimizing Transformers with Hugging Face Optimum"),$x.forEach(t),Gk=s(Ym,"."),Ym.forEach(t),lp.forEach(t),om=h(n),vc=a(n,"P",{});var Fx=i(vc);Xk=s(Fx,"\u26A1\uFE0F Inference"),Fx.forEach(t),sm=h(n),Os=a(n,"UL",{});var Zm=i(Os);Ma=a(Zm,"LI",{});var eg=i(Ma);Yk=s(eg,"A blog post on how to "),za=a(eg,"A",{href:!0,rel:!0});var Dx=i(za);Zk=s(Dx,"Accelerate BERT inference with Hugging Face Transformers and AWS Inferentia"),Dx.forEach(t),ev=s(eg," with DistilBERT."),eg.forEach(t),tv=h(Zm),Ca=a(Zm,"LI",{});var tg=i(Ca);ov=s(tg,"A blog post on "),Aa=a(tg,"A",{href:!0,rel:!0});var Ex=i(Aa);sv=s(Ex,"Serverless Inference with Hugging Face\u2019s Transformers, DistilBERT and Amazon SageMaker"),Ex.forEach(t),nv=s(tg,"."),tg.forEach(t),Zm.forEach(t),nm=h(n),wc=a(n,"P",{});var xx=i(wc);rv=s(xx,"\u{1F680} Deploy"),xx.forEach(t),rm=h(n),xo=a(n,"UL",{});var dp=i(xo);ja=a(dp,"LI",{});var og=i(ja);av=s(og,"A blog post on how to "),qa=a(og,"A",{href:!0,rel:!0});var Bx=i(qa);iv=s(Bx,"deploy DistilBERT on Google Cloud"),Bx.forEach(t),lv=s(og,"."),og.forEach(t),dv=h(dp),Pa=a(dp,"LI",{});var sg=i(Pa);cv=s(sg,"A blog post on how to "),La=a(sg,"A",{href:!0,rel:!0});var Mx=i(La);pv=s(Mx,"deploy DistilBERT with Amazon SageMaker"),Mx.forEach(t),hv=s(sg,"."),sg.forEach(t),uv=h(dp),Oa=a(dp,"LI",{});var ng=i(Oa);fv=s(ng,"A blog post on how to "),Ia=a(ng,"A",{href:!0,rel:!0});var zx=i(Ia);mv=s(zx,"Deploy BERT with Hugging Face Transformers, Amazon SageMaker and Terraform module"),zx.forEach(t),gv=s(ng,"."),ng.forEach(t),dp.forEach(t),am=h(n),Uo=a(n,"H2",{class:!0});var rg=i(Uo);Is=a(rg,"A",{id:!0,class:!0,href:!0});var Cx=i(Is);Lp=a(Cx,"SPAN",{});var Ax=i(Lp);T(Sa.$$.fragment,Ax),Ax.forEach(t),Cx.forEach(t),_v=h(rg),Op=a(rg,"SPAN",{});var jx=i(Op);bv=s(jx,"DistilBertConfig"),jx.forEach(t),rg.forEach(t),im=h(n),At=a(n,"DIV",{class:!0});var lr=i(At);T(Na.$$.fragment,lr),kv=h(lr),no=a(lr,"P",{});var dr=i(no);vv=s(dr,"This is the configuration class to store the configuration of a "),Tc=a(dr,"A",{href:!0});var qx=i(Tc);wv=s(qx,"DistilBertModel"),qx.forEach(t),Tv=s(dr," or a "),yc=a(dr,"A",{href:!0});var Px=i(yc);yv=s(Px,"TFDistilBertModel"),Px.forEach(t),$v=s(dr,`. It
is used to instantiate a DistilBERT 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 DistilBERT
`),Ra=a(dr,"A",{href:!0,rel:!0});var Lx=i(Ra);Fv=s(Lx,"distilbert-base-uncased"),Lx.forEach(t),Dv=s(dr," architecture."),dr.forEach(t),Ev=h(lr),Qo=a(lr,"P",{});var cp=i(Qo);xv=s(cp,"Configuration objects inherit from "),$c=a(cp,"A",{href:!0});var Ox=i($c);Bv=s(Ox,"PretrainedConfig"),Ox.forEach(t),Mv=s(cp,` and can be used to control the model outputs. Read the
documentation from `),Fc=a(cp,"A",{href:!0});var Ix=i(Fc);zv=s(Ix,"PretrainedConfig"),Ix.forEach(t),Cv=s(cp," for more information."),cp.forEach(t),Av=h(lr),T(Ss.$$.fragment,lr),lr.forEach(t),lm=h(n),Ho=a(n,"H2",{class:!0});var ag=i(Ho);Ns=a(ag,"A",{id:!0,class:!0,href:!0});var Sx=i(Ns);Ip=a(Sx,"SPAN",{});var Nx=i(Ip);T(Wa.$$.fragment,Nx),Nx.forEach(t),Sx.forEach(t),jv=h(ag),Sp=a(ag,"SPAN",{});var Rx=i(Sp);qv=s(Rx,"DistilBertTokenizer"),Rx.forEach(t),ag.forEach(t),dm=h(n),tt=a(n,"DIV",{class:!0});var Dt=i(tt);T(Ua.$$.fragment,Dt),Pv=h(Dt),Np=a(Dt,"P",{});var Wx=i(Np);Lv=s(Wx,"Construct a DistilBERT tokenizer. Based on WordPiece."),Wx.forEach(t),Ov=h(Dt),Qa=a(Dt,"P",{});var ig=i(Qa);Iv=s(ig,"This tokenizer inherits from "),Dc=a(ig,"A",{href:!0});var Ux=i(Dc);Sv=s(Ux,"PreTrainedTokenizer"),Ux.forEach(t),Nv=s(ig,` which contains most of the main methods. Users should refer to
this superclass for more information regarding those methods.`),ig.forEach(t),Rv=h(Dt),Bo=a(Dt,"DIV",{class:!0});var pp=i(Bo);T(Ha.$$.fragment,pp),Wv=h(pp),Rp=a(pp,"P",{});var Qx=i(Rp);Uv=s(Qx,`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:`),Qx.forEach(t),Qv=h(pp),Ka=a(pp,"UL",{});var lg=i(Ka);Ec=a(lg,"LI",{});var xE=i(Ec);Hv=s(xE,"single sequence: "),Wp=a(xE,"CODE",{});var Hx=i(Wp);Kv=s(Hx,"[CLS] X [SEP]"),Hx.forEach(t),xE.forEach(t),Vv=h(lg),xc=a(lg,"LI",{});var BE=i(xc);Jv=s(BE,"pair of sequences: "),Up=a(BE,"CODE",{});var Kx=i(Up);Gv=s(Kx,"[CLS] A [SEP] B [SEP]"),Kx.forEach(t),BE.forEach(t),lg.forEach(t),pp.forEach(t),Xv=h(Dt),Rs=a(Dt,"DIV",{class:!0});var dg=i(Rs);T(Va.$$.fragment,dg),Yv=h(dg),Qp=a(dg,"P",{});var Vx=i(Qp);Zv=s(Vx,"Converts a sequence of tokens (string) in a single string."),Vx.forEach(t),dg.forEach(t),ew=h(Dt),Lt=a(Dt,"DIV",{class:!0});var cr=i(Lt);T(Ja.$$.fragment,cr),tw=h(cr),Hp=a(cr,"P",{});var Jx=i(Hp);ow=s(Jx,"Create a mask from the two sequences passed to be used in a sequence-pair classification task. A BERT sequence"),Jx.forEach(t),sw=h(cr),T(Ws.$$.fragment,cr),nw=h(cr),Ko=a(cr,"P",{});var hp=i(Ko);rw=s(hp,"If "),Kp=a(hp,"CODE",{});var Gx=i(Kp);aw=s(Gx,"token_ids_1"),Gx.forEach(t),iw=s(hp," is "),Vp=a(hp,"CODE",{});var Xx=i(Vp);lw=s(Xx,"None"),Xx.forEach(t),dw=s(hp,", this method only returns the first portion of the mask (0s)."),hp.forEach(t),cr.forEach(t),cw=h(Dt),Us=a(Dt,"DIV",{class:!0});var cg=i(Us);T(Ga.$$.fragment,cg),pw=h(cg),Xa=a(cg,"P",{});var pg=i(Xa);hw=s(pg,`Retrieve sequence ids from a token list that has no special tokens added. This method is called when adding
special tokens using the tokenizer `),Jp=a(pg,"CODE",{});var Yx=i(Jp);uw=s(Yx,"prepare_for_model"),Yx.forEach(t),fw=s(pg," method."),pg.forEach(t),cg.forEach(t),Dt.forEach(t),cm=h(n),Vo=a(n,"H2",{class:!0});var hg=i(Vo);Qs=a(hg,"A",{id:!0,class:!0,href:!0});var Zx=i(Qs);Gp=a(Zx,"SPAN",{});var eB=i(Gp);T(Ya.$$.fragment,eB),eB.forEach(t),Zx.forEach(t),mw=h(hg),Xp=a(hg,"SPAN",{});var tB=i(Xp);gw=s(tB,"DistilBertTokenizerFast"),tB.forEach(t),hg.forEach(t),pm=h(n),ft=a(n,"DIV",{class:!0});var Co=i(ft);T(Za.$$.fragment,Co),_w=h(Co),ei=a(Co,"P",{});var ug=i(ei);bw=s(ug,"Construct a \u201Cfast\u201D DistilBERT tokenizer (backed by HuggingFace\u2019s "),Yp=a(ug,"EM",{});var oB=i(Yp);kw=s(oB,"tokenizers"),oB.forEach(t),vw=s(ug," library). Based on WordPiece."),ug.forEach(t),ww=h(Co),ti=a(Co,"P",{});var fg=i(ti);Tw=s(fg,"This tokenizer inherits from "),Bc=a(fg,"A",{href:!0});var sB=i(Bc);yw=s(sB,"PreTrainedTokenizerFast"),sB.forEach(t),$w=s(fg,` which contains most of the main methods. Users should
refer to this superclass for more information regarding those methods.`),fg.forEach(t),Fw=h(Co),Mo=a(Co,"DIV",{class:!0});var up=i(Mo);T(oi.$$.fragment,up),Dw=h(up),Zp=a(up,"P",{});var nB=i(Zp);Ew=s(nB,`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:`),nB.forEach(t),xw=h(up),si=a(up,"UL",{});var mg=i(si);Mc=a(mg,"LI",{});var ME=i(Mc);Bw=s(ME,"single sequence: "),eh=a(ME,"CODE",{});var rB=i(eh);Mw=s(rB,"[CLS] X [SEP]"),rB.forEach(t),ME.forEach(t),zw=h(mg),zc=a(mg,"LI",{});var zE=i(zc);Cw=s(zE,"pair of sequences: "),th=a(zE,"CODE",{});var aB=i(th);Aw=s(aB,"[CLS] A [SEP] B [SEP]"),aB.forEach(t),zE.forEach(t),mg.forEach(t),up.forEach(t),jw=h(Co),Ot=a(Co,"DIV",{class:!0});var pr=i(Ot);T(ni.$$.fragment,pr),qw=h(pr),oh=a(pr,"P",{});var iB=i(oh);Pw=s(iB,"Create a mask from the two sequences passed to be used in a sequence-pair classification task. A BERT sequence"),iB.forEach(t),Lw=h(pr),T(Hs.$$.fragment,pr),Ow=h(pr),Jo=a(pr,"P",{});var fp=i(Jo);Iw=s(fp,"If "),sh=a(fp,"CODE",{});var lB=i(sh);Sw=s(lB,"token_ids_1"),lB.forEach(t),Nw=s(fp," is "),nh=a(fp,"CODE",{});var dB=i(nh);Rw=s(dB,"None"),dB.forEach(t),Ww=s(fp,", this method only returns the first portion of the mask (0s)."),fp.forEach(t),pr.forEach(t),Co.forEach(t),hm=h(n),Go=a(n,"H2",{class:!0});var gg=i(Go);Ks=a(gg,"A",{id:!0,class:!0,href:!0});var cB=i(Ks);rh=a(cB,"SPAN",{});var pB=i(rh);T(ri.$$.fragment,pB),pB.forEach(t),cB.forEach(t),Uw=h(gg),ah=a(gg,"SPAN",{});var hB=i(ah);Qw=s(hB,"DistilBertModel"),hB.forEach(t),gg.forEach(t),um=h(n),mt=a(n,"DIV",{class:!0});var Ao=i(mt);T(ai.$$.fragment,Ao),Hw=h(Ao),ih=a(Ao,"P",{});var uB=i(ih);Kw=s(uB,"The bare DistilBERT encoder/transformer outputting raw hidden-states without any specific head on top."),uB.forEach(t),Vw=h(Ao),ii=a(Ao,"P",{});var _g=i(ii);Jw=s(_g,"This model inherits from "),Cc=a(_g,"A",{href:!0});var fB=i(Cc);Gw=s(fB,"PreTrainedModel"),fB.forEach(t),Xw=s(_g,`. 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.forEach(t),Yw=h(Ao),li=a(Ao,"P",{});var bg=i(li);Zw=s(bg,"This model is also a PyTorch "),di=a(bg,"A",{href:!0,rel:!0});var mB=i(di);eT=s(mB,"torch.nn.Module"),mB.forEach(t),tT=s(bg,` subclass.
Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
and behavior.`),bg.forEach(t),oT=h(Ao),It=a(Ao,"DIV",{class:!0});var hr=i(It);T(ci.$$.fragment,hr),sT=h(hr),Xo=a(hr,"P",{});var mp=i(Xo);nT=s(mp,"The "),Ac=a(mp,"A",{href:!0});var gB=i(Ac);rT=s(gB,"DistilBertModel"),gB.forEach(t),aT=s(mp," forward method, overrides the "),lh=a(mp,"CODE",{});var _B=i(lh);iT=s(_B,"__call__"),_B.forEach(t),lT=s(mp," special method."),mp.forEach(t),dT=h(hr),T(Vs.$$.fragment,hr),cT=h(hr),T(Js.$$.fragment,hr),hr.forEach(t),Ao.forEach(t),fm=h(n),Yo=a(n,"H2",{class:!0});var kg=i(Yo);Gs=a(kg,"A",{id:!0,class:!0,href:!0});var bB=i(Gs);dh=a(bB,"SPAN",{});var kB=i(dh);T(pi.$$.fragment,kB),kB.forEach(t),bB.forEach(t),pT=h(kg),ch=a(kg,"SPAN",{});var vB=i(ch);hT=s(vB,"DistilBertForMaskedLM"),vB.forEach(t),kg.forEach(t),mm=h(n),gt=a(n,"DIV",{class:!0});var jo=i(gt);T(hi.$$.fragment,jo),uT=h(jo),ui=a(jo,"P",{});var vg=i(ui);fT=s(vg,"DistilBert Model with a "),ph=a(vg,"CODE",{});var wB=i(ph);mT=s(wB,"masked language modeling"),wB.forEach(t),gT=s(vg," head on top."),vg.forEach(t),_T=h(jo),fi=a(jo,"P",{});var wg=i(fi);bT=s(wg,"This model inherits from "),jc=a(wg,"A",{href:!0});var TB=i(jc);kT=s(TB,"PreTrainedModel"),TB.forEach(t),vT=s(wg,`. 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.)`),wg.forEach(t),wT=h(jo),mi=a(jo,"P",{});var Tg=i(mi);TT=s(Tg,"This model is also a PyTorch "),gi=a(Tg,"A",{href:!0,rel:!0});var yB=i(gi);yT=s(yB,"torch.nn.Module"),yB.forEach(t),$T=s(Tg,` subclass.
Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
and behavior.`),Tg.forEach(t),FT=h(jo),St=a(jo,"DIV",{class:!0});var ur=i(St);T(_i.$$.fragment,ur),DT=h(ur),Zo=a(ur,"P",{});var gp=i(Zo);ET=s(gp,"The "),qc=a(gp,"A",{href:!0});var $B=i(qc);xT=s($B,"DistilBertForMaskedLM"),$B.forEach(t),BT=s(gp," forward method, overrides the "),hh=a(gp,"CODE",{});var FB=i(hh);MT=s(FB,"__call__"),FB.forEach(t),zT=s(gp," special method."),gp.forEach(t),CT=h(ur),T(Xs.$$.fragment,ur),AT=h(ur),T(Ys.$$.fragment,ur),ur.forEach(t),jo.forEach(t),gm=h(n),es=a(n,"H2",{class:!0});var yg=i(es);Zs=a(yg,"A",{id:!0,class:!0,href:!0});var DB=i(Zs);uh=a(DB,"SPAN",{});var EB=i(uh);T(bi.$$.fragment,EB),EB.forEach(t),DB.forEach(t),jT=h(yg),fh=a(yg,"SPAN",{});var xB=i(fh);qT=s(xB,"DistilBertForSequenceClassification"),xB.forEach(t),yg.forEach(t),_m=h(n),_t=a(n,"DIV",{class:!0});var qo=i(_t);T(ki.$$.fragment,qo),PT=h(qo),mh=a(qo,"P",{});var BB=i(mh);LT=s(BB,`DistilBert Model transformer with a sequence classification/regression head on top (a linear layer on top of the
pooled output) e.g. for GLUE tasks.`),BB.forEach(t),OT=h(qo),vi=a(qo,"P",{});var $g=i(vi);IT=s($g,"This model inherits from "),Pc=a($g,"A",{href:!0});var MB=i(Pc);ST=s(MB,"PreTrainedModel"),MB.forEach(t),NT=s($g,`. 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.forEach(t),RT=h(qo),wi=a(qo,"P",{});var Fg=i(wi);WT=s(Fg,"This model is also a PyTorch "),Ti=a(Fg,"A",{href:!0,rel:!0});var zB=i(Ti);UT=s(zB,"torch.nn.Module"),zB.forEach(t),QT=s(Fg,` subclass.
Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
and behavior.`),Fg.forEach(t),HT=h(qo),wt=a(qo,"DIV",{class:!0});var Po=i(wt);T(yi.$$.fragment,Po),KT=h(Po),ts=a(Po,"P",{});var _p=i(ts);VT=s(_p,"The "),Lc=a(_p,"A",{href:!0});var CB=i(Lc);JT=s(CB,"DistilBertForSequenceClassification"),CB.forEach(t),GT=s(_p," forward method, overrides the "),gh=a(_p,"CODE",{});var AB=i(gh);XT=s(AB,"__call__"),AB.forEach(t),YT=s(_p," special method."),_p.forEach(t),ZT=h(Po),T(en.$$.fragment,Po),ey=h(Po),T(tn.$$.fragment,Po),ty=h(Po),T(on.$$.fragment,Po),Po.forEach(t),qo.forEach(t),bm=h(n),os=a(n,"H2",{class:!0});var Dg=i(os);sn=a(Dg,"A",{id:!0,class:!0,href:!0});var jB=i(sn);_h=a(jB,"SPAN",{});var qB=i(_h);T($i.$$.fragment,qB),qB.forEach(t),jB.forEach(t),oy=h(Dg),bh=a(Dg,"SPAN",{});var PB=i(bh);sy=s(PB,"DistilBertForMultipleChoice"),PB.forEach(t),Dg.forEach(t),km=h(n),bt=a(n,"DIV",{class:!0});var Lo=i(bt);T(Fi.$$.fragment,Lo),ny=h(Lo),kh=a(Lo,"P",{});var LB=i(kh);ry=s(LB,`DistilBert 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.`),LB.forEach(t),ay=h(Lo),Di=a(Lo,"P",{});var Eg=i(Di);iy=s(Eg,"This model inherits from "),Oc=a(Eg,"A",{href:!0});var OB=i(Oc);ly=s(OB,"PreTrainedModel"),OB.forEach(t),dy=s(Eg,`. 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.forEach(t),cy=h(Lo),Ei=a(Lo,"P",{});var xg=i(Ei);py=s(xg,"This model is also a PyTorch "),xi=a(xg,"A",{href:!0,rel:!0});var IB=i(xi);hy=s(IB,"torch.nn.Module"),IB.forEach(t),uy=s(xg,` subclass.
Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
and behavior.`),xg.forEach(t),fy=h(Lo),Nt=a(Lo,"DIV",{class:!0});var fr=i(Nt);T(Bi.$$.fragment,fr),my=h(fr),ss=a(fr,"P",{});var bp=i(ss);gy=s(bp,"The "),Ic=a(bp,"A",{href:!0});var SB=i(Ic);_y=s(SB,"DistilBertForMultipleChoice"),SB.forEach(t),by=s(bp," forward method, overrides the "),vh=a(bp,"CODE",{});var NB=i(vh);ky=s(NB,"__call__"),NB.forEach(t),vy=s(bp," special method."),bp.forEach(t),wy=h(fr),T(nn.$$.fragment,fr),Ty=h(fr),T(rn.$$.fragment,fr),fr.forEach(t),Lo.forEach(t),vm=h(n),ns=a(n,"H2",{class:!0});var Bg=i(ns);an=a(Bg,"A",{id:!0,class:!0,href:!0});var RB=i(an);wh=a(RB,"SPAN",{});var WB=i(wh);T(Mi.$$.fragment,WB),WB.forEach(t),RB.forEach(t),yy=h(Bg),Th=a(Bg,"SPAN",{});var UB=i(Th);$y=s(UB,"DistilBertForTokenClassification"),UB.forEach(t),Bg.forEach(t),wm=h(n),kt=a(n,"DIV",{class:!0});var Oo=i(kt);T(zi.$$.fragment,Oo),Fy=h(Oo),yh=a(Oo,"P",{});var QB=i(yh);Dy=s(QB,`DistilBert 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.`),QB.forEach(t),Ey=h(Oo),Ci=a(Oo,"P",{});var Mg=i(Ci);xy=s(Mg,"This model inherits from "),Sc=a(Mg,"A",{href:!0});var HB=i(Sc);By=s(HB,"PreTrainedModel"),HB.forEach(t),My=s(Mg,`. 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.)`),Mg.forEach(t),zy=h(Oo),Ai=a(Oo,"P",{});var zg=i(Ai);Cy=s(zg,"This model is also a PyTorch "),ji=a(zg,"A",{href:!0,rel:!0});var KB=i(ji);Ay=s(KB,"torch.nn.Module"),KB.forEach(t),jy=s(zg,` subclass.
Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
and behavior.`),zg.forEach(t),qy=h(Oo),Rt=a(Oo,"DIV",{class:!0});var mr=i(Rt);T(qi.$$.fragment,mr),Py=h(mr),rs=a(mr,"P",{});var kp=i(rs);Ly=s(kp,"The "),Nc=a(kp,"A",{href:!0});var VB=i(Nc);Oy=s(VB,"DistilBertForTokenClassification"),VB.forEach(t),Iy=s(kp," forward method, overrides the "),$h=a(kp,"CODE",{});var JB=i($h);Sy=s(JB,"__call__"),JB.forEach(t),Ny=s(kp," special method."),kp.forEach(t),Ry=h(mr),T(ln.$$.fragment,mr),Wy=h(mr),T(dn.$$.fragment,mr),mr.forEach(t),Oo.forEach(t),Tm=h(n),as=a(n,"H2",{class:!0});var Cg=i(as);cn=a(Cg,"A",{id:!0,class:!0,href:!0});var GB=i(cn);Fh=a(GB,"SPAN",{});var XB=i(Fh);T(Pi.$$.fragment,XB),XB.forEach(t),GB.forEach(t),Uy=h(Cg),Dh=a(Cg,"SPAN",{});var YB=i(Dh);Qy=s(YB,"DistilBertForQuestionAnswering"),YB.forEach(t),Cg.forEach(t),ym=h(n),vt=a(n,"DIV",{class:!0});var Io=i(vt);T(Li.$$.fragment,Io),Hy=h(Io),is=a(Io,"P",{});var vp=i(is);Ky=s(vp,`DistilBert 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 `),Eh=a(vp,"CODE",{});var ZB=i(Eh);Vy=s(ZB,"span start logits"),ZB.forEach(t),Jy=s(vp," and "),xh=a(vp,"CODE",{});var e4=i(xh);Gy=s(e4,"span end logits"),e4.forEach(t),Xy=s(vp,")."),vp.forEach(t),Yy=h(Io),Oi=a(Io,"P",{});var Ag=i(Oi);Zy=s(Ag,"This model inherits from "),Rc=a(Ag,"A",{href:!0});var t4=i(Rc);e$=s(t4,"PreTrainedModel"),t4.forEach(t),t$=s(Ag,`. 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.)`),Ag.forEach(t),o$=h(Io),Ii=a(Io,"P",{});var jg=i(Ii);s$=s(jg,"This model is also a PyTorch "),Si=a(jg,"A",{href:!0,rel:!0});var o4=i(Si);n$=s(o4,"torch.nn.Module"),o4.forEach(t),r$=s(jg,` subclass.
Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
and behavior.`),jg.forEach(t),a$=h(Io),Wt=a(Io,"DIV",{class:!0});var gr=i(Wt);T(Ni.$$.fragment,gr),i$=h(gr),ls=a(gr,"P",{});var wp=i(ls);l$=s(wp,"The "),Wc=a(wp,"A",{href:!0});var s4=i(Wc);d$=s(s4,"DistilBertForQuestionAnswering"),s4.forEach(t),c$=s(wp," forward method, overrides the "),Bh=a(wp,"CODE",{});var n4=i(Bh);p$=s(n4,"__call__"),n4.forEach(t),h$=s(wp," special method."),wp.forEach(t),u$=h(gr),T(pn.$$.fragment,gr),f$=h(gr),T(hn.$$.fragment,gr),gr.forEach(t),Io.forEach(t),$m=h(n),ds=a(n,"H2",{class:!0});var qg=i(ds);un=a(qg,"A",{id:!0,class:!0,href:!0});var r4=i(un);Mh=a(r4,"SPAN",{});var a4=i(Mh);T(Ri.$$.fragment,a4),a4.forEach(t),r4.forEach(t),m$=h(qg),zh=a(qg,"SPAN",{});var i4=i(zh);g$=s(i4,"TFDistilBertModel"),i4.forEach(t),qg.forEach(t),Fm=h(n),lt=a(n,"DIV",{class:!0});var Yt=i(lt);T(Wi.$$.fragment,Yt),_$=h(Yt),Ch=a(Yt,"P",{});var l4=i(Ch);b$=s(l4,"The bare DistilBERT encoder/transformer outputting raw hidden-states without any specific head on top."),l4.forEach(t),k$=h(Yt),Ui=a(Yt,"P",{});var Pg=i(Ui);v$=s(Pg,"This model inherits from "),Uc=a(Pg,"A",{href:!0});var d4=i(Uc);w$=s(d4,"TFPreTrainedModel"),d4.forEach(t),T$=s(Pg,`. 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.)`),Pg.forEach(t),y$=h(Yt),Qi=a(Yt,"P",{});var Lg=i(Qi);$$=s(Lg,"This model is also a "),Hi=a(Lg,"A",{href:!0,rel:!0});var c4=i(Hi);F$=s(c4,"tf.keras.Model"),c4.forEach(t),D$=s(Lg,` 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.`),Lg.forEach(t),E$=h(Yt),T(fn.$$.fragment,Yt),x$=h(Yt),Ut=a(Yt,"DIV",{class:!0});var _r=i(Ut);T(Ki.$$.fragment,_r),B$=h(_r),cs=a(_r,"P",{});var Tp=i(cs);M$=s(Tp,"The "),Qc=a(Tp,"A",{href:!0});var p4=i(Qc);z$=s(p4,"TFDistilBertModel"),p4.forEach(t),C$=s(Tp," forward method, overrides the "),Ah=a(Tp,"CODE",{});var h4=i(Ah);A$=s(h4,"__call__"),h4.forEach(t),j$=s(Tp," special method."),Tp.forEach(t),q$=h(_r),T(mn.$$.fragment,_r),P$=h(_r),T(gn.$$.fragment,_r),_r.forEach(t),Yt.forEach(t),Dm=h(n),ps=a(n,"H2",{class:!0});var Og=i(ps);_n=a(Og,"A",{id:!0,class:!0,href:!0});var u4=i(_n);jh=a(u4,"SPAN",{});var f4=i(jh);T(Vi.$$.fragment,f4),f4.forEach(t),u4.forEach(t),L$=h(Og),qh=a(Og,"SPAN",{});var m4=i(qh);O$=s(m4,"TFDistilBertForMaskedLM"),m4.forEach(t),Og.forEach(t),Em=h(n),dt=a(n,"DIV",{class:!0});var Zt=i(dt);T(Ji.$$.fragment,Zt),I$=h(Zt),Gi=a(Zt,"P",{});var Ig=i(Gi);S$=s(Ig,"DistilBert Model with a "),Ph=a(Ig,"CODE",{});var g4=i(Ph);N$=s(g4,"masked language modeling"),g4.forEach(t),R$=s(Ig," head on top."),Ig.forEach(t),W$=h(Zt),Xi=a(Zt,"P",{});var Sg=i(Xi);U$=s(Sg,"This model inherits from "),Hc=a(Sg,"A",{href:!0});var _4=i(Hc);Q$=s(_4,"TFPreTrainedModel"),_4.forEach(t),H$=s(Sg,`. 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.)`),Sg.forEach(t),K$=h(Zt),Yi=a(Zt,"P",{});var Ng=i(Yi);V$=s(Ng,"This model is also a "),Zi=a(Ng,"A",{href:!0,rel:!0});var b4=i(Zi);J$=s(b4,"tf.keras.Model"),b4.forEach(t),G$=s(Ng,` 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.`),Ng.forEach(t),X$=h(Zt),T(bn.$$.fragment,Zt),Y$=h(Zt),Tt=a(Zt,"DIV",{class:!0});var So=i(Tt);T(el.$$.fragment,So),Z$=h(So),hs=a(So,"P",{});var yp=i(hs);e1=s(yp,"The "),Kc=a(yp,"A",{href:!0});var k4=i(Kc);t1=s(k4,"TFDistilBertForMaskedLM"),k4.forEach(t),o1=s(yp," forward method, overrides the "),Lh=a(yp,"CODE",{});var v4=i(Lh);s1=s(v4,"__call__"),v4.forEach(t),n1=s(yp," special method."),yp.forEach(t),r1=h(So),T(kn.$$.fragment,So),a1=h(So),T(vn.$$.fragment,So),i1=h(So),T(wn.$$.fragment,So),So.forEach(t),Zt.forEach(t),xm=h(n),us=a(n,"H2",{class:!0});var Rg=i(us);Tn=a(Rg,"A",{id:!0,class:!0,href:!0});var w4=i(Tn);Oh=a(w4,"SPAN",{});var T4=i(Oh);T(tl.$$.fragment,T4),T4.forEach(t),w4.forEach(t),l1=h(Rg),Ih=a(Rg,"SPAN",{});var y4=i(Ih);d1=s(y4,"TFDistilBertForSequenceClassification"),y4.forEach(t),Rg.forEach(t),Bm=h(n),ct=a(n,"DIV",{class:!0});var eo=i(ct);T(ol.$$.fragment,eo),c1=h(eo),Sh=a(eo,"P",{});var $4=i(Sh);p1=s($4,`DistilBert Model transformer with a sequence classification/regression head on top (a linear layer on top of the
pooled output) e.g. for GLUE tasks.`),$4.forEach(t),h1=h(eo),sl=a(eo,"P",{});var Wg=i(sl);u1=s(Wg,"This model inherits from "),Vc=a(Wg,"A",{href:!0});var F4=i(Vc);f1=s(F4,"TFPreTrainedModel"),F4.forEach(t),m1=s(Wg,`. 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.)`),Wg.forEach(t),g1=h(eo),nl=a(eo,"P",{});var Ug=i(nl);_1=s(Ug,"This model is also a "),rl=a(Ug,"A",{href:!0,rel:!0});var D4=i(rl);b1=s(D4,"tf.keras.Model"),D4.forEach(t),k1=s(Ug,` 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.`),Ug.forEach(t),v1=h(eo),T(yn.$$.fragment,eo),w1=h(eo),yt=a(eo,"DIV",{class:!0});var No=i(yt);T(al.$$.fragment,No),T1=h(No),fs=a(No,"P",{});var $p=i(fs);y1=s($p,"The "),Jc=a($p,"A",{href:!0});var E4=i(Jc);$1=s(E4,"TFDistilBertForSequenceClassification"),E4.forEach(t),F1=s($p," forward method, overrides the "),Nh=a($p,"CODE",{});var x4=i(Nh);D1=s(x4,"__call__"),x4.forEach(t),E1=s($p," special method."),$p.forEach(t),x1=h(No),T($n.$$.fragment,No),B1=h(No),T(Fn.$$.fragment,No),M1=h(No),T(Dn.$$.fragment,No),No.forEach(t),eo.forEach(t),Mm=h(n),ms=a(n,"H2",{class:!0});var Qg=i(ms);En=a(Qg,"A",{id:!0,class:!0,href:!0});var B4=i(En);Rh=a(B4,"SPAN",{});var M4=i(Rh);T(il.$$.fragment,M4),M4.forEach(t),B4.forEach(t),z1=h(Qg),Wh=a(Qg,"SPAN",{});var z4=i(Wh);C1=s(z4,"TFDistilBertForMultipleChoice"),z4.forEach(t),Qg.forEach(t),zm=h(n),pt=a(n,"DIV",{class:!0});var to=i(pt);T(ll.$$.fragment,to),A1=h(to),Uh=a(to,"P",{});var C4=i(Uh);j1=s(C4,`DistilBert 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.`),C4.forEach(t),q1=h(to),dl=a(to,"P",{});var Hg=i(dl);P1=s(Hg,"This model inherits from "),Gc=a(Hg,"A",{href:!0});var A4=i(Gc);L1=s(A4,"TFPreTrainedModel"),A4.forEach(t),O1=s(Hg,`. 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.)`),Hg.forEach(t),I1=h(to),cl=a(to,"P",{});var Kg=i(cl);S1=s(Kg,"This model is also a "),pl=a(Kg,"A",{href:!0,rel:!0});var j4=i(pl);N1=s(j4,"tf.keras.Model"),j4.forEach(t),R1=s(Kg,` 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.`),Kg.forEach(t),W1=h(to),T(xn.$$.fragment,to),U1=h(to),Qt=a(to,"DIV",{class:!0});var br=i(Qt);T(hl.$$.fragment,br),Q1=h(br),gs=a(br,"P",{});var Fp=i(gs);H1=s(Fp,"The "),Xc=a(Fp,"A",{href:!0});var q4=i(Xc);K1=s(q4,"TFDistilBertForMultipleChoice"),q4.forEach(t),V1=s(Fp," forward method, overrides the "),Qh=a(Fp,"CODE",{});var P4=i(Qh);J1=s(P4,"__call__"),P4.forEach(t),G1=s(Fp," special method."),Fp.forEach(t),X1=h(br),T(Bn.$$.fragment,br),Y1=h(br),T(Mn.$$.fragment,br),br.forEach(t),to.forEach(t),Cm=h(n),_s=a(n,"H2",{class:!0});var Vg=i(_s);zn=a(Vg,"A",{id:!0,class:!0,href:!0});var L4=i(zn);Hh=a(L4,"SPAN",{});var O4=i(Hh);T(ul.$$.fragment,O4),O4.forEach(t),L4.forEach(t),Z1=h(Vg),Kh=a(Vg,"SPAN",{});var I4=i(Kh);e2=s(I4,"TFDistilBertForTokenClassification"),I4.forEach(t),Vg.forEach(t),Am=h(n),ht=a(n,"DIV",{class:!0});var oo=i(ht);T(fl.$$.fragment,oo),t2=h(oo),Vh=a(oo,"P",{});var S4=i(Vh);o2=s(S4,`DistilBert 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.`),S4.forEach(t),s2=h(oo),ml=a(oo,"P",{});var Jg=i(ml);n2=s(Jg,"This model inherits from "),Yc=a(Jg,"A",{href:!0});var N4=i(Yc);r2=s(N4,"TFPreTrainedModel"),N4.forEach(t),a2=s(Jg,`. 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.)`),Jg.forEach(t),i2=h(oo),gl=a(oo,"P",{});var Gg=i(gl);l2=s(Gg,"This model is also a "),_l=a(Gg,"A",{href:!0,rel:!0});var R4=i(_l);d2=s(R4,"tf.keras.Model"),R4.forEach(t),c2=s(Gg,` 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.`),Gg.forEach(t),p2=h(oo),T(Cn.$$.fragment,oo),h2=h(oo),$t=a(oo,"DIV",{class:!0});var Ro=i($t);T(bl.$$.fragment,Ro),u2=h(Ro),bs=a(Ro,"P",{});var Dp=i(bs);f2=s(Dp,"The "),Zc=a(Dp,"A",{href:!0});var W4=i(Zc);m2=s(W4,"TFDistilBertForTokenClassification"),W4.forEach(t),g2=s(Dp," forward method, overrides the "),Jh=a(Dp,"CODE",{});var U4=i(Jh);_2=s(U4,"__call__"),U4.forEach(t),b2=s(Dp," special method."),Dp.forEach(t),k2=h(Ro),T(An.$$.fragment,Ro),v2=h(Ro),T(jn.$$.fragment,Ro),w2=h(Ro),T(qn.$$.fragment,Ro),Ro.forEach(t),oo.forEach(t),jm=h(n),ks=a(n,"H2",{class:!0});var Xg=i(ks);Pn=a(Xg,"A",{id:!0,class:!0,href:!0});var Q4=i(Pn);Gh=a(Q4,"SPAN",{});var H4=i(Gh);T(kl.$$.fragment,H4),H4.forEach(t),Q4.forEach(t),T2=h(Xg),Xh=a(Xg,"SPAN",{});var K4=i(Xh);y2=s(K4,"TFDistilBertForQuestionAnswering"),K4.forEach(t),Xg.forEach(t),qm=h(n),ut=a(n,"DIV",{class:!0});var so=i(ut);T(vl.$$.fragment,so),$2=h(so),vs=a(so,"P",{});var Ep=i(vs);F2=s(Ep,`DistilBert 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 `),Yh=a(Ep,"CODE",{});var V4=i(Yh);D2=s(V4,"span start logits"),V4.forEach(t),E2=s(Ep," and "),Zh=a(Ep,"CODE",{});var J4=i(Zh);x2=s(J4,"span end logits"),J4.forEach(t),B2=s(Ep,")."),Ep.forEach(t),M2=h(so),wl=a(so,"P",{});var Yg=i(wl);z2=s(Yg,"This model inherits from "),ep=a(Yg,"A",{href:!0});var G4=i(ep);C2=s(G4,"TFPreTrainedModel"),G4.forEach(t),A2=s(Yg,`. 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.)`),Yg.forEach(t),j2=h(so),Tl=a(so,"P",{});var Zg=i(Tl);q2=s(Zg,"This model is also a "),yl=a(Zg,"A",{href:!0,rel:!0});var X4=i(yl);P2=s(X4,"tf.keras.Model"),X4.forEach(t),L2=s(Zg,` 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.`),Zg.forEach(t),O2=h(so),T(Ln.$$.fragment,so),I2=h(so),Ft=a(so,"DIV",{class:!0});var Wo=i(Ft);T($l.$$.fragment,Wo),S2=h(Wo),ws=a(Wo,"P",{});var xp=i(ws);N2=s(xp,"The "),tp=a(xp,"A",{href:!0});var Y4=i(tp);R2=s(Y4,"TFDistilBertForQuestionAnswering"),Y4.forEach(t),W2=s(xp," forward method, overrides the "),eu=a(xp,"CODE",{});var Z4=i(eu);U2=s(Z4,"__call__"),Z4.forEach(t),Q2=s(xp," special method."),xp.forEach(t),H2=h(Wo),T(On.$$.fragment,Wo),K2=h(Wo),T(In.$$.fragment,Wo),V2=h(Wo),T(Sn.$$.fragment,Wo),Wo.forEach(t),so.forEach(t),Pm=h(n),Ts=a(n,"H2",{class:!0});var e_=i(Ts);Nn=a(e_,"A",{id:!0,class:!0,href:!0});var eM=i(Nn);tu=a(eM,"SPAN",{});var tM=i(tu);T(Fl.$$.fragment,tM),tM.forEach(t),eM.forEach(t),J2=h(e_),ou=a(e_,"SPAN",{});var oM=i(ou);G2=s(oM,"FlaxDistilBertModel"),oM.forEach(t),e_.forEach(t),Lm=h(n),ot=a(n,"DIV",{class:!0});var Et=i(ot);T(Dl.$$.fragment,Et),X2=h(Et),su=a(Et,"P",{});var sM=i(su);Y2=s(sM,"The bare DistilBert Model transformer outputting raw hidden-states without any specific head on top."),sM.forEach(t),Z2=h(Et),El=a(Et,"P",{});var t_=i(El);eF=s(t_,"This model inherits from "),op=a(t_,"A",{href:!0});var nM=i(op);tF=s(nM,"FlaxPreTrainedModel"),nM.forEach(t),oF=s(t_,`. Check the superclass documentation for the generic methods the
library implements for all its model (such as downloading, saving and converting weights from PyTorch models)`),t_.forEach(t),sF=h(Et),xl=a(Et,"P",{});var o_=i(xl);nF=s(o_,"This model is also a Flax Linen "),Bl=a(o_,"A",{href:!0,rel:!0});var rM=i(Bl);rF=s(rM,"flax.linen.Module"),rM.forEach(t),aF=s(o_,`
subclass. Use it as a regular Flax linen Module and refer to the Flax documentation for all matter related to
general usage and behavior.`),o_.forEach(t),iF=h(Et),nu=a(Et,"P",{});var aM=i(nu);lF=s(aM,"Finally, this model supports inherent JAX features such as:"),aM.forEach(t),dF=h(Et),ro=a(Et,"UL",{});var kr=i(ro);ru=a(kr,"LI",{});var iM=i(ru);Ml=a(iM,"A",{href:!0,rel:!0});var lM=i(Ml);cF=s(lM,"Just-In-Time (JIT) compilation"),lM.forEach(t),iM.forEach(t),pF=h(kr),au=a(kr,"LI",{});var dM=i(au);zl=a(dM,"A",{href:!0,rel:!0});var cM=i(zl);hF=s(cM,"Automatic Differentiation"),cM.forEach(t),dM.forEach(t),uF=h(kr),iu=a(kr,"LI",{});var pM=i(iu);Cl=a(pM,"A",{href:!0,rel:!0});var hM=i(Cl);fF=s(hM,"Vectorization"),hM.forEach(t),pM.forEach(t),mF=h(kr),lu=a(kr,"LI",{});var uM=i(lu);Al=a(uM,"A",{href:!0,rel:!0});var fM=i(Al);gF=s(fM,"Parallelization"),fM.forEach(t),uM.forEach(t),kr.forEach(t),_F=h(Et),Ht=a(Et,"DIV",{class:!0});var vr=i(Ht);T(jl.$$.fragment,vr),bF=h(vr),ys=a(vr,"P",{});var Bp=i(ys);kF=s(Bp,"The "),du=a(Bp,"CODE",{});var mM=i(du);vF=s(mM,"FlaxDistilBertPreTrainedModel"),mM.forEach(t),wF=s(Bp," forward method, overrides the "),cu=a(Bp,"CODE",{});var gM=i(cu);TF=s(gM,"__call__"),gM.forEach(t),yF=s(Bp," special method."),Bp.forEach(t),$F=h(vr),T(Rn.$$.fragment,vr),FF=h(vr),T(Wn.$$.fragment,vr),vr.forEach(t),Et.forEach(t),Om=h(n),$s=a(n,"H2",{class:!0});var s_=i($s);Un=a(s_,"A",{id:!0,class:!0,href:!0});var _M=i(Un);pu=a(_M,"SPAN",{});var bM=i(pu);T(ql.$$.fragment,bM),bM.forEach(t),_M.forEach(t),DF=h(s_),hu=a(s_,"SPAN",{});var kM=i(hu);EF=s(kM,"FlaxDistilBertForMaskedLM"),kM.forEach(t),s_.forEach(t),Im=h(n),st=a(n,"DIV",{class:!0});var xt=i(st);T(Pl.$$.fragment,xt),xF=h(xt),Ll=a(xt,"P",{});var n_=i(Ll);BF=s(n_,"DistilBert Model with a "),uu=a(n_,"CODE",{});var vM=i(uu);MF=s(vM,"language modeling"),vM.forEach(t),zF=s(n_," head on top."),n_.forEach(t),CF=h(xt),Ol=a(xt,"P",{});var r_=i(Ol);AF=s(r_,"This model inherits from "),sp=a(r_,"A",{href:!0});var wM=i(sp);jF=s(wM,"FlaxPreTrainedModel"),wM.forEach(t),qF=s(r_,`. Check the superclass documentation for the generic methods the
library implements for all its model (such as downloading, saving and converting weights from PyTorch models)`),r_.forEach(t),PF=h(xt),Il=a(xt,"P",{});var a_=i(Il);LF=s(a_,"This model is also a Flax Linen "),Sl=a(a_,"A",{href:!0,rel:!0});var TM=i(Sl);OF=s(TM,"flax.linen.Module"),TM.forEach(t),IF=s(a_,`
subclass. Use it as a regular Flax linen Module and refer to the Flax documentation for all matter related to
general usage and behavior.`),a_.forEach(t),SF=h(xt),fu=a(xt,"P",{});var yM=i(fu);NF=s(yM,"Finally, this model supports inherent JAX features such as:"),yM.forEach(t),RF=h(xt),ao=a(xt,"UL",{});var wr=i(ao);mu=a(wr,"LI",{});var $M=i(mu);Nl=a($M,"A",{href:!0,rel:!0});var FM=i(Nl);WF=s(FM,"Just-In-Time (JIT) compilation"),FM.forEach(t),$M.forEach(t),UF=h(wr),gu=a(wr,"LI",{});var DM=i(gu);Rl=a(DM,"A",{href:!0,rel:!0});var EM=i(Rl);QF=s(EM,"Automatic Differentiation"),EM.forEach(t),DM.forEach(t),HF=h(wr),_u=a(wr,"LI",{});var xM=i(_u);Wl=a(xM,"A",{href:!0,rel:!0});var BM=i(Wl);KF=s(BM,"Vectorization"),BM.forEach(t),xM.forEach(t),VF=h(wr),bu=a(wr,"LI",{});var MM=i(bu);Ul=a(MM,"A",{href:!0,rel:!0});var zM=i(Ul);JF=s(zM,"Parallelization"),zM.forEach(t),MM.forEach(t),wr.forEach(t),GF=h(xt),Kt=a(xt,"DIV",{class:!0});var Tr=i(Kt);T(Ql.$$.fragment,Tr),XF=h(Tr),Fs=a(Tr,"P",{});var Mp=i(Fs);YF=s(Mp,"The "),ku=a(Mp,"CODE",{});var CM=i(ku);ZF=s(CM,"FlaxDistilBertPreTrainedModel"),CM.forEach(t),eD=s(Mp," forward method, overrides the "),vu=a(Mp,"CODE",{});var AM=i(vu);tD=s(AM,"__call__"),AM.forEach(t),oD=s(Mp," special method."),Mp.forEach(t),sD=h(Tr),T(Qn.$$.fragment,Tr),nD=h(Tr),T(Hn.$$.fragment,Tr),Tr.forEach(t),xt.forEach(t),Sm=h(n),Ds=a(n,"H2",{class:!0});var i_=i(Ds);Kn=a(i_,"A",{id:!0,class:!0,href:!0});var jM=i(Kn);wu=a(jM,"SPAN",{});var qM=i(wu);T(Hl.$$.fragment,qM),qM.forEach(t),jM.forEach(t),rD=h(i_),Tu=a(i_,"SPAN",{});var PM=i(Tu);aD=s(PM,"FlaxDistilBertForSequenceClassification"),PM.forEach(t),i_.forEach(t),Nm=h(n),nt=a(n,"DIV",{class:!0});var Bt=i(nt);T(Kl.$$.fragment,Bt),iD=h(Bt),yu=a(Bt,"P",{});var LM=i(yu);lD=s(LM,`DistilBert Model transformer with a sequence classification/regression head on top (a linear layer on top of the
pooled output) e.g. for GLUE tasks.`),LM.forEach(t),dD=h(Bt),Vl=a(Bt,"P",{});var l_=i(Vl);cD=s(l_,"This model inherits from "),np=a(l_,"A",{href:!0});var OM=i(np);pD=s(OM,"FlaxPreTrainedModel"),OM.forEach(t),hD=s(l_,`. Check the superclass documentation for the generic methods the
library implements for all its model (such as downloading, saving and converting weights from PyTorch models)`),l_.forEach(t),uD=h(Bt),Jl=a(Bt,"P",{});var d_=i(Jl);fD=s(d_,"This model is also a Flax Linen "),Gl=a(d_,"A",{href:!0,rel:!0});var IM=i(Gl);mD=s(IM,"flax.linen.Module"),IM.forEach(t),gD=s(d_,`
subclass. Use it as a regular Flax linen Module and refer to the Flax documentation for all matter related to
general usage and behavior.`),d_.forEach(t),_D=h(Bt),$u=a(Bt,"P",{});var SM=i($u);bD=s(SM,"Finally, this model supports inherent JAX features such as:"),SM.forEach(t),kD=h(Bt),io=a(Bt,"UL",{});var yr=i(io);Fu=a(yr,"LI",{});var NM=i(Fu);Xl=a(NM,"A",{href:!0,rel:!0});var RM=i(Xl);vD=s(RM,"Just-In-Time (JIT) compilation"),RM.forEach(t),NM.forEach(t),wD=h(yr),Du=a(yr,"LI",{});var WM=i(Du);Yl=a(WM,"A",{href:!0,rel:!0});var UM=i(Yl);TD=s(UM,"Automatic Differentiation"),UM.forEach(t),WM.forEach(t),yD=h(yr),Eu=a(yr,"LI",{});var QM=i(Eu);Zl=a(QM,"A",{href:!0,rel:!0});var HM=i(Zl);$D=s(HM,"Vectorization"),HM.forEach(t),QM.forEach(t),FD=h(yr),xu=a(yr,"LI",{});var KM=i(xu);ed=a(KM,"A",{href:!0,rel:!0});var VM=i(ed);DD=s(VM,"Parallelization"),VM.forEach(t),KM.forEach(t),yr.forEach(t),ED=h(Bt),Vt=a(Bt,"DIV",{class:!0});var $r=i(Vt);T(td.$$.fragment,$r),xD=h($r),Es=a($r,"P",{});var zp=i(Es);BD=s(zp,"The "),Bu=a(zp,"CODE",{});var JM=i(Bu);MD=s(JM,"FlaxDistilBertPreTrainedModel"),JM.forEach(t),zD=s(zp," forward method, overrides the "),Mu=a(zp,"CODE",{});var GM=i(Mu);CD=s(GM,"__call__"),GM.forEach(t),AD=s(zp," special method."),zp.forEach(t),jD=h($r),T(Vn.$$.fragment,$r),qD=h($r),T(Jn.$$.fragment,$r),$r.forEach(t),Bt.forEach(t),Rm=h(n),xs=a(n,"H2",{class:!0});var c_=i(xs);Gn=a(c_,"A",{id:!0,class:!0,href:!0});var XM=i(Gn);zu=a(XM,"SPAN",{});var YM=i(zu);T(od.$$.fragment,YM),YM.forEach(t),XM.forEach(t),PD=h(c_),Cu=a(c_,"SPAN",{});var ZM=i(Cu);LD=s(ZM,"FlaxDistilBertForMultipleChoice"),ZM.forEach(t),c_.forEach(t),Wm=h(n),rt=a(n,"DIV",{class:!0});var Mt=i(rt);T(sd.$$.fragment,Mt),OD=h(Mt),Au=a(Mt,"P",{});var ez=i(Au);ID=s(ez,`DistilBert 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.`),ez.forEach(t),SD=h(Mt),nd=a(Mt,"P",{});var p_=i(nd);ND=s(p_,"This model inherits from "),rp=a(p_,"A",{href:!0});var tz=i(rp);RD=s(tz,"FlaxPreTrainedModel"),tz.forEach(t),WD=s(p_,`. Check the superclass documentation for the generic methods the
library implements for all its model (such as downloading, saving and converting weights from PyTorch models)`),p_.forEach(t),UD=h(Mt),rd=a(Mt,"P",{});var h_=i(rd);QD=s(h_,"This model is also a Flax Linen "),ad=a(h_,"A",{href:!0,rel:!0});var oz=i(ad);HD=s(oz,"flax.linen.Module"),oz.forEach(t),KD=s(h_,`
subclass. Use it as a regular Flax linen Module and refer to the Flax documentation for all matter related to
general usage and behavior.`),h_.forEach(t),VD=h(Mt),ju=a(Mt,"P",{});var sz=i(ju);JD=s(sz,"Finally, this model supports inherent JAX features such as:"),sz.forEach(t),GD=h(Mt),lo=a(Mt,"UL",{});var Fr=i(lo);qu=a(Fr,"LI",{});var nz=i(qu);id=a(nz,"A",{href:!0,rel:!0});var rz=i(id);XD=s(rz,"Just-In-Time (JIT) compilation"),rz.forEach(t),nz.forEach(t),YD=h(Fr),Pu=a(Fr,"LI",{});var az=i(Pu);ld=a(az,"A",{href:!0,rel:!0});var iz=i(ld);ZD=s(iz,"Automatic Differentiation"),iz.forEach(t),az.forEach(t),e0=h(Fr),Lu=a(Fr,"LI",{});var lz=i(Lu);dd=a(lz,"A",{href:!0,rel:!0});var dz=i(dd);t0=s(dz,"Vectorization"),dz.forEach(t),lz.forEach(t),o0=h(Fr),Ou=a(Fr,"LI",{});var cz=i(Ou);cd=a(cz,"A",{href:!0,rel:!0});var pz=i(cd);s0=s(pz,"Parallelization"),pz.forEach(t),cz.forEach(t),Fr.forEach(t),n0=h(Mt),Jt=a(Mt,"DIV",{class:!0});var Dr=i(Jt);T(pd.$$.fragment,Dr),r0=h(Dr),Bs=a(Dr,"P",{});var Cp=i(Bs);a0=s(Cp,"The "),Iu=a(Cp,"CODE",{});var hz=i(Iu);i0=s(hz,"FlaxDistilBertPreTrainedModel"),hz.forEach(t),l0=s(Cp," forward method, overrides the "),Su=a(Cp,"CODE",{});var uz=i(Su);d0=s(uz,"__call__"),uz.forEach(t),c0=s(Cp," special method."),Cp.forEach(t),p0=h(Dr),T(Xn.$$.fragment,Dr),h0=h(Dr),T(Yn.$$.fragment,Dr),Dr.forEach(t),Mt.forEach(t),Um=h(n),Ms=a(n,"H2",{class:!0});var u_=i(Ms);Zn=a(u_,"A",{id:!0,class:!0,href:!0});var fz=i(Zn);Nu=a(fz,"SPAN",{});var mz=i(Nu);T(hd.$$.fragment,mz),mz.forEach(t),fz.forEach(t),u0=h(u_),Ru=a(u_,"SPAN",{});var gz=i(Ru);f0=s(gz,"FlaxDistilBertForTokenClassification"),gz.forEach(t),u_.forEach(t),Qm=h(n),at=a(n,"DIV",{class:!0});var zt=i(at);T(ud.$$.fragment,zt),m0=h(zt),Wu=a(zt,"P",{});var _z=i(Wu);g0=s(_z,`DistilBert 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.`),_z.forEach(t),_0=h(zt),fd=a(zt,"P",{});var f_=i(fd);b0=s(f_,"This model inherits from "),ap=a(f_,"A",{href:!0});var bz=i(ap);k0=s(bz,"FlaxPreTrainedModel"),bz.forEach(t),v0=s(f_,`. Check the superclass documentation for the generic methods the
library implements for all its model (such as downloading, saving and converting weights from PyTorch models)`),f_.forEach(t),w0=h(zt),md=a(zt,"P",{});var m_=i(md);T0=s(m_,"This model is also a Flax Linen "),gd=a(m_,"A",{href:!0,rel:!0});var kz=i(gd);y0=s(kz,"flax.linen.Module"),kz.forEach(t),$0=s(m_,`
subclass. Use it as a regular Flax linen Module and refer to the Flax documentation for all matter related to
general usage and behavior.`),m_.forEach(t),F0=h(zt),Uu=a(zt,"P",{});var vz=i(Uu);D0=s(vz,"Finally, this model supports inherent JAX features such as:"),vz.forEach(t),E0=h(zt),co=a(zt,"UL",{});var Er=i(co);Qu=a(Er,"LI",{});var wz=i(Qu);_d=a(wz,"A",{href:!0,rel:!0});var Tz=i(_d);x0=s(Tz,"Just-In-Time (JIT) compilation"),Tz.forEach(t),wz.forEach(t),B0=h(Er),Hu=a(Er,"LI",{});var yz=i(Hu);bd=a(yz,"A",{href:!0,rel:!0});var $z=i(bd);M0=s($z,"Automatic Differentiation"),$z.forEach(t),yz.forEach(t),z0=h(Er),Ku=a(Er,"LI",{});var Fz=i(Ku);kd=a(Fz,"A",{href:!0,rel:!0});var Dz=i(kd);C0=s(Dz,"Vectorization"),Dz.forEach(t),Fz.forEach(t),A0=h(Er),Vu=a(Er,"LI",{});var Ez=i(Vu);vd=a(Ez,"A",{href:!0,rel:!0});var xz=i(vd);j0=s(xz,"Parallelization"),xz.forEach(t),Ez.forEach(t),Er.forEach(t),q0=h(zt),Gt=a(zt,"DIV",{class:!0});var xr=i(Gt);T(wd.$$.fragment,xr),P0=h(xr),zs=a(xr,"P",{});var Ap=i(zs);L0=s(Ap,"The "),Ju=a(Ap,"CODE",{});var Bz=i(Ju);O0=s(Bz,"FlaxDistilBertPreTrainedModel"),Bz.forEach(t),I0=s(Ap," forward method, overrides the "),Gu=a(Ap,"CODE",{});var Mz=i(Gu);S0=s(Mz,"__call__"),Mz.forEach(t),N0=s(Ap," special method."),Ap.forEach(t),R0=h(xr),T(er.$$.fragment,xr),W0=h(xr),T(tr.$$.fragment,xr),xr.forEach(t),zt.forEach(t),Hm=h(n),Cs=a(n,"H2",{class:!0});var g_=i(Cs);or=a(g_,"A",{id:!0,class:!0,href:!0});var zz=i(or);Xu=a(zz,"SPAN",{});var Cz=i(Xu);T(Td.$$.fragment,Cz),Cz.forEach(t),zz.forEach(t),U0=h(g_),Yu=a(g_,"SPAN",{});var Az=i(Yu);Q0=s(Az,"FlaxDistilBertForQuestionAnswering"),Az.forEach(t),g_.forEach(t),Km=h(n),it=a(n,"DIV",{class:!0});var Ct=i(it);T(yd.$$.fragment,Ct),H0=h(Ct),As=a(Ct,"P",{});var jp=i(As);K0=s(jp,`DistilBert 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 `),Zu=a(jp,"CODE",{});var jz=i(Zu);V0=s(jz,"span start logits"),jz.forEach(t),J0=s(jp," and "),ef=a(jp,"CODE",{});var qz=i(ef);G0=s(qz,"span end logits"),qz.forEach(t),X0=s(jp,")."),jp.forEach(t),Y0=h(Ct),$d=a(Ct,"P",{});var __=i($d);Z0=s(__,"This model inherits from "),ip=a(__,"A",{href:!0});var Pz=i(ip);eE=s(Pz,"FlaxPreTrainedModel"),Pz.forEach(t),tE=s(__,`. Check the superclass documentation for the generic methods the
library implements for all its model (such as downloading, saving and converting weights from PyTorch models)`),__.forEach(t),oE=h(Ct),Fd=a(Ct,"P",{});var b_=i(Fd);sE=s(b_,"This model is also a Flax Linen "),Dd=a(b_,"A",{href:!0,rel:!0});var Lz=i(Dd);nE=s(Lz,"flax.linen.Module"),Lz.forEach(t),rE=s(b_,`
subclass. Use it as a regular Flax linen Module and refer to the Flax documentation for all matter related to
general usage and behavior.`),b_.forEach(t),aE=h(Ct),tf=a(Ct,"P",{});var Oz=i(tf);iE=s(Oz,"Finally, this model supports inherent JAX features such as:"),Oz.forEach(t),lE=h(Ct),po=a(Ct,"UL",{});var Br=i(po);of=a(Br,"LI",{});var Iz=i(of);Ed=a(Iz,"A",{href:!0,rel:!0});var Sz=i(Ed);dE=s(Sz,"Just-In-Time (JIT) compilation"),Sz.forEach(t),Iz.forEach(t),cE=h(Br),sf=a(Br,"LI",{});var Nz=i(sf);xd=a(Nz,"A",{href:!0,rel:!0});var Rz=i(xd);pE=s(Rz,"Automatic Differentiation"),Rz.forEach(t),Nz.forEach(t),hE=h(Br),nf=a(Br,"LI",{});var Wz=i(nf);Bd=a(Wz,"A",{href:!0,rel:!0});var Uz=i(Bd);uE=s(Uz,"Vectorization"),Uz.forEach(t),Wz.forEach(t),fE=h(Br),rf=a(Br,"LI",{});var Qz=i(rf);Md=a(Qz,"A",{href:!0,rel:!0});var Hz=i(Md);mE=s(Hz,"Parallelization"),Hz.forEach(t),Qz.forEach(t),Br.forEach(t),gE=h(Ct),Xt=a(Ct,"DIV",{class:!0});var Mr=i(Xt);T(zd.$$.fragment,Mr),_E=h(Mr),js=a(Mr,"P",{});var qp=i(js);bE=s(qp,"The "),af=a(qp,"CODE",{});var Kz=i(af);kE=s(Kz,"FlaxDistilBertPreTrainedModel"),Kz.forEach(t),vE=s(qp," forward method, overrides the "),lf=a(qp,"CODE",{});var Vz=i(lf);wE=s(Vz,"__call__"),Vz.forEach(t),TE=s(qp," special method."),qp.forEach(t),yE=h(Mr),T(sr.$$.fragment,Mr),$E=h(Mr),T(nr.$$.fragment,Mr),Mr.forEach(t),Ct.forEach(t),this.h()},h(){c(d,"name","hf:doc:metadata"),c(d,"content",JSON.stringify(X3)),c(m,"id","distilbert"),c(m,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),c(m,"href","#distilbert"),c(f,"class","relative group"),c(re,"id","overview"),c(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"),c(re,"href","#overview"),c(I,"class","relative group"),c(ae,"href","https://medium.com/huggingface/distilbert-8cf3380435b5"),c(ae,"rel","nofollow"),c(ie,"href","https://arxiv.org/abs/1910.01108"),c(ie,"rel","nofollow"),c(Z,"href","https://huggingface.co/victorsanh"),c(Z,"rel","nofollow"),c(z,"href","https://huggingface.co/kamalkraj"),c(z,"rel","nofollow"),c(Oe,"href","https://github.com/huggingface/transformers/tree/main/examples/research_projects/distillation"),c(Oe,"rel","nofollow"),c(je,"id","resources"),c(je,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),c(je,"href","#resources"),c(N,"class","relative group"),c(Ar,"href","https://huggingface.co/blog/sentiment-analysis-python"),c(Ar,"rel","nofollow"),c(qr,"href","https://huggingface.co/blog/fastai"),c(qr,"rel","nofollow"),c(Lr,"href","https://huggingface.co/blog/ray-tune"),c(Lr,"rel","nofollow"),c(Ir,"href","https://huggingface.co/blog/the-partnership-amazon-sagemaker-and-hugging-face"),c(Ir,"rel","nofollow"),c(Nr,"href","https://colab.research.google.com/github/DhavalTaunk08/Transformers_scripts/blob/master/Transformers_multilabel_distilbert.ipynb"),c(Nr,"rel","nofollow"),c(Wr,"href","https://colab.research.google.com/github/abhimishra91/transformers-tutorials/blob/master/transformers_multiclass_classification.ipynb"),c(Wr,"rel","nofollow"),c(Qr,"href","https://colab.research.google.com/github/peterbayerle/huggingface_notebook/blob/main/distilbert_tf.ipynb"),c(Qr,"rel","nofollow"),c(tc,"href","/docs/transformers/main/en/model_doc/distilbert#transformers.DistilBertForSequenceClassification"),c(Hr,"href","https://github.com/huggingface/transformers/tree/main/examples/pytorch/text-classification"),c(Hr,"rel","nofollow"),c(Kr,"href","https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/text_classification.ipynb"),c(Kr,"rel","nofollow"),c(oc,"href","/docs/transformers/main/en/model_doc/distilbert#transformers.TFDistilBertForSequenceClassification"),c(Vr,"href","https://github.com/huggingface/transformers/tree/main/examples/tensorflow/text-classification"),c(Vr,"rel","nofollow"),c(Jr,"href","https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/text_classification-tf.ipynb"),c(Jr,"rel","nofollow"),c(sc,"href","/docs/transformers/main/en/model_doc/distilbert#transformers.FlaxDistilBertForSequenceClassification"),c(Gr,"href","https://github.com/huggingface/transformers/tree/main/examples/flax/text-classification"),c(Gr,"rel","nofollow"),c(Xr,"href","https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/text_classification_flax.ipynb"),c(Xr,"rel","nofollow"),c(nc,"href","/docs/transformers/main/en/model_doc/distilbert#transformers.DistilBertForTokenClassification"),c(Zr,"href","https://github.com/huggingface/transformers/tree/main/examples/pytorch/token-classification"),c(Zr,"rel","nofollow"),c(ea,"href","https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/token_classification.ipynb"),c(ea,"rel","nofollow"),c(rc,"href","/docs/transformers/main/en/model_doc/distilbert#transformers.TFDistilBertForTokenClassification"),c(ta,"href","https://github.com/huggingface/transformers/tree/main/examples/tensorflow/token-classification"),c(ta,"rel","nofollow"),c(oa,"href","https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/token_classification-tf.ipynb"),c(oa,"rel","nofollow"),c(ac,"href","/docs/transformers/main/en/model_doc/distilbert#transformers.FlaxDistilBertForTokenClassification"),c(sa,"href","https://github.com/huggingface/transformers/tree/main/examples/flax/token-classification"),c(sa,"rel","nofollow"),c(na,"href","https://huggingface.co/course/chapter7/2?fw=pt"),c(na,"rel","nofollow"),c(lc,"href","/docs/transformers/main/en/model_doc/distilbert#transformers.DistilBertForMaskedLM"),c(aa,"href","https://github.com/huggingface/transformers/tree/main/examples/pytorch/language-modeling#robertabertdistilbert-and-masked-language-modeling"),c(aa,"rel","nofollow"),c(ia,"href","https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/language_modeling.ipynb"),c(ia,"rel","nofollow"),c(dc,"href","/docs/transformers/main/en/model_doc/distilbert#transformers.TFDistilBertForMaskedLM"),c(la,"href","https://github.com/huggingface/transformers/tree/main/examples/tensorflow/language-modeling#run_mlmpy"),c(la,"rel","nofollow"),c(da,"href","https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/language_modeling-tf.ipynb"),c(da,"rel","nofollow"),c(cc,"href","/docs/transformers/main/en/model_doc/distilbert#transformers.FlaxDistilBertForMaskedLM"),c(ca,"href","https://github.com/huggingface/transformers/tree/main/examples/flax/language-modeling#masked-language-modeling"),c(ca,"rel","nofollow"),c(pa,"href","https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/masked_language_modeling_flax.ipynb"),c(pa,"rel","nofollow"),c(ha,"href","https://huggingface.co/course/chapter7/3?fw=pt"),c(ha,"rel","nofollow"),c(hc,"href","/docs/transformers/main/en/model_doc/distilbert#transformers.DistilBertForQuestionAnswering"),c(fa,"href","https://github.com/huggingface/transformers/tree/main/examples/pytorch/question-answering"),c(fa,"rel","nofollow"),c(ma,"href","https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/question_answering.ipynb"),c(ma,"rel","nofollow"),c(uc,"href","/docs/transformers/main/en/model_doc/distilbert#transformers.TFDistilBertForQuestionAnswering"),c(ga,"href","https://github.com/huggingface/transformers/tree/main/examples/tensorflow/question-answering"),c(ga,"rel","nofollow"),c(_a,"href","https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/question_answering-tf.ipynb"),c(_a,"rel","nofollow"),c(fc,"href","/docs/transformers/main/en/model_doc/distilbert#transformers.FlaxDistilBertForQuestionAnswering"),c(ba,"href","https://github.com/huggingface/transformers/tree/main/examples/flax/question-answering"),c(ba,"rel","nofollow"),c(ka,"href","https://huggingface.co/course/chapter7/7?fw=pt"),c(ka,"rel","nofollow"),c(_c,"href","/docs/transformers/main/en/model_doc/distilbert#transformers.DistilBertForMultipleChoice"),c(va,"href","https://github.com/huggingface/transformers/tree/main/examples/pytorch/multiple-choice"),c(va,"rel","nofollow"),c(wa,"href","https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/multiple_choice.ipynb"),c(wa,"rel","nofollow"),c(bc,"href","/docs/transformers/main/en/model_doc/distilbert#transformers.TFDistilBertForMultipleChoice"),c(Ta,"href","https://github.com/huggingface/transformers/tree/main/examples/tensorflow/multiple-choice"),c(Ta,"rel","nofollow"),c(ya,"href","https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/multiple_choice-tf.ipynb"),c(ya,"rel","nofollow"),c(Fa,"href","https://huggingface.co/blog/intel"),c(Fa,"rel","nofollow"),c(Ea,"href","https://www.philschmid.de/optimizing-transformers-with-optimum-gpu"),c(Ea,"rel","nofollow"),c(Ba,"href","https://www.philschmid.de/optimizing-transformers-with-optimum"),c(Ba,"rel","nofollow"),c(za,"href","https://huggingface.co/blog/bert-inferentia-sagemaker"),c(za,"rel","nofollow"),c(Aa,"href","https://www.philschmid.de/sagemaker-serverless-huggingface-distilbert"),c(Aa,"rel","nofollow"),c(qa,"href","https://huggingface.co/blog/how-to-deploy-a-pipeline-to-google-clouds"),c(qa,"rel","nofollow"),c(La,"href","https://huggingface.co/blog/deploy-hugging-face-models-easily-with-amazon-sagemaker"),c(La,"rel","nofollow"),c(Ia,"href","https://www.philschmid.de/terraform-huggingface-amazon-sagemaker"),c(Ia,"rel","nofollow"),c(Is,"id","transformers.DistilBertConfig"),c(Is,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),c(Is,"href","#transformers.DistilBertConfig"),c(Uo,"class","relative group"),c(Tc,"href","/docs/transformers/main/en/model_doc/distilbert#transformers.DistilBertModel"),c(yc,"href","/docs/transformers/main/en/model_doc/distilbert#transformers.TFDistilBertModel"),c(Ra,"href","https://huggingface.co/distilbert-base-uncased"),c(Ra,"rel","nofollow"),c($c,"href","/docs/transformers/main/en/main_classes/configuration#transformers.PretrainedConfig"),c(Fc,"href","/docs/transformers/main/en/main_classes/configuration#transformers.PretrainedConfig"),c(At,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),c(Ns,"id","transformers.DistilBertTokenizer"),c(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"),c(Ns,"href","#transformers.DistilBertTokenizer"),c(Ho,"class","relative group"),c(Dc,"href","/docs/transformers/main/en/main_classes/tokenizer#transformers.PreTrainedTokenizer"),c(Bo,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),c(Rs,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),c(Lt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),c(Us,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),c(tt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),c(Qs,"id","transformers.DistilBertTokenizerFast"),c(Qs,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),c(Qs,"href","#transformers.DistilBertTokenizerFast"),c(Vo,"class","relative group"),c(Bc,"href","/docs/transformers/main/en/main_classes/tokenizer#transformers.PreTrainedTokenizerFast"),c(Mo,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),c(Ot,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),c(ft,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),c(Ks,"id","transformers.DistilBertModel"),c(Ks,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),c(Ks,"href","#transformers.DistilBertModel"),c(Go,"class","relative group"),c(Cc,"href","/docs/transformers/main/en/main_classes/model#transformers.PreTrainedModel"),c(di,"href","https://pytorch.org/docs/stable/nn.html#torch.nn.Module"),c(di,"rel","nofollow"),c(Ac,"href","/docs/transformers/main/en/model_doc/distilbert#transformers.DistilBertModel"),c(It,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),c(mt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),c(Gs,"id","transformers.DistilBertForMaskedLM"),c(Gs,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),c(Gs,"href","#transformers.DistilBertForMaskedLM"),c(Yo,"class","relative group"),c(jc,"href","/docs/transformers/main/en/main_classes/model#transformers.PreTrainedModel"),c(gi,"href","https://pytorch.org/docs/stable/nn.html#torch.nn.Module"),c(gi,"rel","nofollow"),c(qc,"href","/docs/transformers/main/en/model_doc/distilbert#transformers.DistilBertForMaskedLM"),c(St,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),c(gt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),c(Zs,"id","transformers.DistilBertForSequenceClassification"),c(Zs,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),c(Zs,"href","#transformers.DistilBertForSequenceClassification"),c(es,"class","relative group"),c(Pc,"href","/docs/transformers/main/en/main_classes/model#transformers.PreTrainedModel"),c(Ti,"href","https://pytorch.org/docs/stable/nn.html#torch.nn.Module"),c(Ti,"rel","nofollow"),c(Lc,"href","/docs/transformers/main/en/model_doc/distilbert#transformers.DistilBertForSequenceClassification"),c(wt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),c(_t,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),c(sn,"id","transformers.DistilBertForMultipleChoice"),c(sn,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),c(sn,"href","#transformers.DistilBertForMultipleChoice"),c(os,"class","relative group"),c(Oc,"href","/docs/transformers/main/en/main_classes/model#transformers.PreTrainedModel"),c(xi,"href","https://pytorch.org/docs/stable/nn.html#torch.nn.Module"),c(xi,"rel","nofollow"),c(Ic,"href","/docs/transformers/main/en/model_doc/distilbert#transformers.DistilBertForMultipleChoice"),c(Nt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),c(bt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),c(an,"id","transformers.DistilBertForTokenClassification"),c(an,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),c(an,"href","#transformers.DistilBertForTokenClassification"),c(ns,"class","relative group"),c(Sc,"href","/docs/transformers/main/en/main_classes/model#transformers.PreTrainedModel"),c(ji,"href","https://pytorch.org/docs/stable/nn.html#torch.nn.Module"),c(ji,"rel","nofollow"),c(Nc,"href","/docs/transformers/main/en/model_doc/distilbert#transformers.DistilBertForTokenClassification"),c(Rt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),c(kt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),c(cn,"id","transformers.DistilBertForQuestionAnswering"),c(cn,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),c(cn,"href","#transformers.DistilBertForQuestionAnswering"),c(as,"class","relative group"),c(Rc,"href","/docs/transformers/main/en/main_classes/model#transformers.PreTrainedModel"),c(Si,"href","https://pytorch.org/docs/stable/nn.html#torch.nn.Module"),c(Si,"rel","nofollow"),c(Wc,"href","/docs/transformers/main/en/model_doc/distilbert#transformers.DistilBertForQuestionAnswering"),c(Wt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),c(vt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),c(un,"id","transformers.TFDistilBertModel"),c(un,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),c(un,"href","#transformers.TFDistilBertModel"),c(ds,"class","relative group"),c(Uc,"href","/docs/transformers/main/en/main_classes/model#transformers.TFPreTrainedModel"),c(Hi,"href","https://www.tensorflow.org/api_docs/python/tf/keras/Model"),c(Hi,"rel","nofollow"),c(Qc,"href","/docs/transformers/main/en/model_doc/distilbert#transformers.TFDistilBertModel"),c(Ut,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),c(lt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),c(_n,"id","transformers.TFDistilBertForMaskedLM"),c(_n,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),c(_n,"href","#transformers.TFDistilBertForMaskedLM"),c(ps,"class","relative group"),c(Hc,"href","/docs/transformers/main/en/main_classes/model#transformers.TFPreTrainedModel"),c(Zi,"href","https://www.tensorflow.org/api_docs/python/tf/keras/Model"),c(Zi,"rel","nofollow"),c(Kc,"href","/docs/transformers/main/en/model_doc/distilbert#transformers.TFDistilBertForMaskedLM"),c(Tt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),c(dt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),c(Tn,"id","transformers.TFDistilBertForSequenceClassification"),c(Tn,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),c(Tn,"href","#transformers.TFDistilBertForSequenceClassification"),c(us,"class","relative group"),c(Vc,"href","/docs/transformers/main/en/main_classes/model#transformers.TFPreTrainedModel"),c(rl,"href","https://www.tensorflow.org/api_docs/python/tf/keras/Model"),c(rl,"rel","nofollow"),c(Jc,"href","/docs/transformers/main/en/model_doc/distilbert#transformers.TFDistilBertForSequenceClassification"),c(yt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),c(ct,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),c(En,"id","transformers.TFDistilBertForMultipleChoice"),c(En,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),c(En,"href","#transformers.TFDistilBertForMultipleChoice"),c(ms,"class","relative group"),c(Gc,"href","/docs/transformers/main/en/main_classes/model#transformers.TFPreTrainedModel"),c(pl,"href","https://www.tensorflow.org/api_docs/python/tf/keras/Model"),c(pl,"rel","nofollow"),c(Xc,"href","/docs/transformers/main/en/model_doc/distilbert#transformers.TFDistilBertForMultipleChoice"),c(Qt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),c(pt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),c(zn,"id","transformers.TFDistilBertForTokenClassification"),c(zn,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),c(zn,"href","#transformers.TFDistilBertForTokenClassification"),c(_s,"class","relative group"),c(Yc,"href","/docs/transformers/main/en/main_classes/model#transformers.TFPreTrainedModel"),c(_l,"href","https://www.tensorflow.org/api_docs/python/tf/keras/Model"),c(_l,"rel","nofollow"),c(Zc,"href","/docs/transformers/main/en/model_doc/distilbert#transformers.TFDistilBertForTokenClassification"),c($t,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),c(ht,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),c(Pn,"id","transformers.TFDistilBertForQuestionAnswering"),c(Pn,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),c(Pn,"href","#transformers.TFDistilBertForQuestionAnswering"),c(ks,"class","relative group"),c(ep,"href","/docs/transformers/main/en/main_classes/model#transformers.TFPreTrainedModel"),c(yl,"href","https://www.tensorflow.org/api_docs/python/tf/keras/Model"),c(yl,"rel","nofollow"),c(tp,"href","/docs/transformers/main/en/model_doc/distilbert#transformers.TFDistilBertForQuestionAnswering"),c(Ft,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),c(ut,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),c(Nn,"id","transformers.FlaxDistilBertModel"),c(Nn,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),c(Nn,"href","#transformers.FlaxDistilBertModel"),c(Ts,"class","relative group"),c(op,"href","/docs/transformers/main/en/main_classes/model#transformers.FlaxPreTrainedModel"),c(Bl,"href","https://flax.readthedocs.io/en/latest/flax.linen.html#module"),c(Bl,"rel","nofollow"),c(Ml,"href","https://jax.readthedocs.io/en/latest/jax.html#just-in-time-compilation-jit"),c(Ml,"rel","nofollow"),c(zl,"href","https://jax.readthedocs.io/en/latest/jax.html#automatic-differentiation"),c(zl,"rel","nofollow"),c(Cl,"href","https://jax.readthedocs.io/en/latest/jax.html#vectorization-vmap"),c(Cl,"rel","nofollow"),c(Al,"href","https://jax.readthedocs.io/en/latest/jax.html#parallelization-pmap"),c(Al,"rel","nofollow"),c(Ht,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),c(ot,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),c(Un,"id","transformers.FlaxDistilBertForMaskedLM"),c(Un,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),c(Un,"href","#transformers.FlaxDistilBertForMaskedLM"),c($s,"class","relative group"),c(sp,"href","/docs/transformers/main/en/main_classes/model#transformers.FlaxPreTrainedModel"),c(Sl,"href","https://flax.readthedocs.io/en/latest/flax.linen.html#module"),c(Sl,"rel","nofollow"),c(Nl,"href","https://jax.readthedocs.io/en/latest/jax.html#just-in-time-compilation-jit"),c(Nl,"rel","nofollow"),c(Rl,"href","https://jax.readthedocs.io/en/latest/jax.html#automatic-differentiation"),c(Rl,"rel","nofollow"),c(Wl,"href","https://jax.readthedocs.io/en/latest/jax.html#vectorization-vmap"),c(Wl,"rel","nofollow"),c(Ul,"href","https://jax.readthedocs.io/en/latest/jax.html#parallelization-pmap"),c(Ul,"rel","nofollow"),c(Kt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),c(st,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),c(Kn,"id","transformers.FlaxDistilBertForSequenceClassification"),c(Kn,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),c(Kn,"href","#transformers.FlaxDistilBertForSequenceClassification"),c(Ds,"class","relative group"),c(np,"href","/docs/transformers/main/en/main_classes/model#transformers.FlaxPreTrainedModel"),c(Gl,"href","https://flax.readthedocs.io/en/latest/flax.linen.html#module"),c(Gl,"rel","nofollow"),c(Xl,"href","https://jax.readthedocs.io/en/latest/jax.html#just-in-time-compilation-jit"),c(Xl,"rel","nofollow"),c(Yl,"href","https://jax.readthedocs.io/en/latest/jax.html#automatic-differentiation"),c(Yl,"rel","nofollow"),c(Zl,"href","https://jax.readthedocs.io/en/latest/jax.html#vectorization-vmap"),c(Zl,"rel","nofollow"),c(ed,"href","https://jax.readthedocs.io/en/latest/jax.html#parallelization-pmap"),c(ed,"rel","nofollow"),c(Vt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),c(nt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),c(Gn,"id","transformers.FlaxDistilBertForMultipleChoice"),c(Gn,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),c(Gn,"href","#transformers.FlaxDistilBertForMultipleChoice"),c(xs,"class","relative group"),c(rp,"href","/docs/transformers/main/en/main_classes/model#transformers.FlaxPreTrainedModel"),c(ad,"href","https://flax.readthedocs.io/en/latest/flax.linen.html#module"),c(ad,"rel","nofollow"),c(id,"href","https://jax.readthedocs.io/en/latest/jax.html#just-in-time-compilation-jit"),c(id,"rel","nofollow"),c(ld,"href","https://jax.readthedocs.io/en/latest/jax.html#automatic-differentiation"),c(ld,"rel","nofollow"),c(dd,"href","https://jax.readthedocs.io/en/latest/jax.html#vectorization-vmap"),c(dd,"rel","nofollow"),c(cd,"href","https://jax.readthedocs.io/en/latest/jax.html#parallelization-pmap"),c(cd,"rel","nofollow"),c(Jt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),c(rt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),c(Zn,"id","transformers.FlaxDistilBertForTokenClassification"),c(Zn,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),c(Zn,"href","#transformers.FlaxDistilBertForTokenClassification"),c(Ms,"class","relative group"),c(ap,"href","/docs/transformers/main/en/main_classes/model#transformers.FlaxPreTrainedModel"),c(gd,"href","https://flax.readthedocs.io/en/latest/flax.linen.html#module"),c(gd,"rel","nofollow"),c(_d,"href","https://jax.readthedocs.io/en/latest/jax.html#just-in-time-compilation-jit"),c(_d,"rel","nofollow"),c(bd,"href","https://jax.readthedocs.io/en/latest/jax.html#automatic-differentiation"),c(bd,"rel","nofollow"),c(kd,"href","https://jax.readthedocs.io/en/latest/jax.html#vectorization-vmap"),c(kd,"rel","nofollow"),c(vd,"href","https://jax.readthedocs.io/en/latest/jax.html#parallelization-pmap"),c(vd,"rel","nofollow"),c(Gt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),c(at,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),c(or,"id","transformers.FlaxDistilBertForQuestionAnswering"),c(or,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),c(or,"href","#transformers.FlaxDistilBertForQuestionAnswering"),c(Cs,"class","relative group"),c(ip,"href","/docs/transformers/main/en/main_classes/model#transformers.FlaxPreTrainedModel"),c(Dd,"href","https://flax.readthedocs.io/en/latest/flax.linen.html#module"),c(Dd,"rel","nofollow"),c(Ed,"href","https://jax.readthedocs.io/en/latest/jax.html#just-in-time-compilation-jit"),c(Ed,"rel","nofollow"),c(xd,"href","https://jax.readthedocs.io/en/latest/jax.html#automatic-differentiation"),c(xd,"rel","nofollow"),c(Bd,"href","https://jax.readthedocs.io/en/latest/jax.html#vectorization-vmap"),c(Bd,"rel","nofollow"),c(Md,"href","https://jax.readthedocs.io/en/latest/jax.html#parallelization-pmap"),c(Md,"rel","nofollow"),c(Xt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),c(it,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8")},m(n,_){e(document.head,d),g(n,k,_),g(n,f,_),e(f,m),e(m,b),y(l,b,null),e(f,u),e(f,M),e(M,be),g(n,ue,_),g(n,I,_),e(I,re),e(re,oe),y(E,oe,null),e(I,ke),e(I,Q),e(Q,ve),g(n,fe,_),g(n,L,_),e(L,we),e(L,ae),e(ae,K),e(L,Te),e(L,ie),e(ie,V),e(L,ye),e(L,de),e(de,J),e(L,$e),g(n,me,_),g(n,ee,_),e(ee,C),g(n,q,_),g(n,le,_),e(le,H),e(H,Fe),g(n,ge,_),g(n,U,_),e(U,De),g(n,_e,_),g(n,A,_),e(A,se),e(se,G),e(se,ce),e(ce,Ee),e(se,X),e(se,pe),e(pe,xe),e(se,S),e(se,he),e(he,Y),e(se,Be),e(A,ne),e(A,j),e(j,Me),e(j,P),e(P,ze),e(j,Ce),g(n,v,_),g(n,B,_),e(B,He),e(B,Z),e(Z,Ke),e(B,Ve),e(B,z),e(z,Je),e(B,Ge),e(B,Oe),e(Oe,Xe),e(B,Ye),g(n,O,_),g(n,N,_),e(N,je),e(je,Re),y(W,Re,null),e(N,Ze),e(N,We),e(We,Ae),g(n,Qe,_),g(n,te,_),e(te,et),g(n,Uf,_),y(zr,n,_),g(n,Qf,_),g(n,Ie,_),e(Ie,Cr),e(Cr,v_),e(Cr,Ar),e(Ar,w_),e(Cr,T_),e(Ie,y_),e(Ie,jr),e(jr,$_),e(jr,qr),e(qr,F_),e(jr,D_),e(Ie,E_),e(Ie,Pr),e(Pr,x_),e(Pr,Lr),e(Lr,B_),e(Pr,M_),e(Ie,z_),e(Ie,Or),e(Or,C_),e(Or,Ir),e(Ir,A_),e(Or,j_),e(Ie,q_),e(Ie,Sr),e(Sr,P_),e(Sr,Nr),e(Nr,L_),e(Sr,O_),e(Ie,I_),e(Ie,Rr),e(Rr,S_),e(Rr,Wr),e(Wr,N_),e(Rr,R_),e(Ie,W_),e(Ie,Ur),e(Ur,U_),e(Ur,Qr),e(Qr,Q_),e(Ur,H_),e(Ie,K_),e(Ie,mo),e(mo,tc),e(tc,V_),e(mo,J_),e(mo,Hr),e(Hr,G_),e(mo,X_),e(mo,Kr),e(Kr,Y_),e(mo,Z_),e(Ie,eb),e(Ie,go),e(go,oc),e(oc,tb),e(go,ob),e(go,Vr),e(Vr,sb),e(go,nb),e(go,Jr),e(Jr,rb),e(go,ab),e(Ie,ib),e(Ie,_o),e(_o,sc),e(sc,lb),e(_o,db),e(_o,Gr),e(Gr,cb),e(_o,pb),e(_o,Xr),e(Xr,hb),e(_o,ub),g(n,Hf,_),y(Yr,n,_),g(n,Kf,_),g(n,jt,_),e(jt,bo),e(bo,nc),e(nc,fb),e(bo,mb),e(bo,Zr),e(Zr,gb),e(bo,_b),e(bo,ea),e(ea,bb),e(bo,kb),e(jt,vb),e(jt,ko),e(ko,rc),e(rc,wb),e(ko,Tb),e(ko,ta),e(ta,yb),e(ko,$b),e(ko,oa),e(oa,Fb),e(ko,Db),e(jt,Eb),e(jt,qs),e(qs,ac),e(ac,xb),e(qs,Bb),e(qs,sa),e(sa,Mb),e(qs,zb),e(jt,Cb),e(jt,ic),e(ic,na),e(na,Ab),e(ic,jb),g(n,Vf,_),y(ra,n,_),g(n,Jf,_),g(n,qt,_),e(qt,vo),e(vo,lc),e(lc,qb),e(vo,Pb),e(vo,aa),e(aa,Lb),e(vo,Ob),e(vo,ia),e(ia,Ib),e(vo,Sb),e(qt,Nb),e(qt,wo),e(wo,dc),e(dc,Rb),e(wo,Wb),e(wo,la),e(la,Ub),e(wo,Qb),e(wo,da),e(da,Hb),e(wo,Kb),e(qt,Vb),e(qt,To),e(To,cc),e(cc,Jb),e(To,Gb),e(To,ca),e(ca,Xb),e(To,Yb),e(To,pa),e(pa,Zb),e(To,ek),e(qt,tk),e(qt,pc),e(pc,ha),e(ha,ok),e(pc,sk),g(n,Gf,_),y(ua,n,_),g(n,Xf,_),g(n,Pt,_),e(Pt,yo),e(yo,hc),e(hc,nk),e(yo,rk),e(yo,fa),e(fa,ak),e(yo,ik),e(yo,ma),e(ma,lk),e(yo,dk),e(Pt,ck),e(Pt,$o),e($o,uc),e(uc,pk),e($o,hk),e($o,ga),e(ga,uk),e($o,fk),e($o,_a),e(_a,mk),e($o,gk),e(Pt,_k),e(Pt,Ps),e(Ps,fc),e(fc,bk),e(Ps,kk),e(Ps,ba),e(ba,vk),e(Ps,wk),e(Pt,Tk),e(Pt,mc),e(mc,ka),e(ka,yk),e(mc,$k),g(n,Yf,_),g(n,gc,_),e(gc,Pp),e(Pp,Fk),g(n,Zf,_),g(n,Ls,_),e(Ls,Fo),e(Fo,_c),e(_c,Dk),e(Fo,Ek),e(Fo,va),e(va,xk),e(Fo,Bk),e(Fo,wa),e(wa,Mk),e(Fo,zk),e(Ls,Ck),e(Ls,Do),e(Do,bc),e(bc,Ak),e(Do,jk),e(Do,Ta),e(Ta,qk),e(Do,Pk),e(Do,ya),e(ya,Lk),e(Do,Ok),g(n,em,_),g(n,kc,_),e(kc,Ik),g(n,tm,_),g(n,Eo,_),e(Eo,$a),e($a,Sk),e($a,Fa),e(Fa,Nk),e($a,Rk),e(Eo,Wk),e(Eo,Da),e(Da,Uk),e(Da,Ea),e(Ea,Qk),e(Da,Hk),e(Eo,Kk),e(Eo,xa),e(xa,Vk),e(xa,Ba),e(Ba,Jk),e(xa,Gk),g(n,om,_),g(n,vc,_),e(vc,Xk),g(n,sm,_),g(n,Os,_),e(Os,Ma),e(Ma,Yk),e(Ma,za),e(za,Zk),e(Ma,ev),e(Os,tv),e(Os,Ca),e(Ca,ov),e(Ca,Aa),e(Aa,sv),e(Ca,nv),g(n,nm,_),g(n,wc,_),e(wc,rv),g(n,rm,_),g(n,xo,_),e(xo,ja),e(ja,av),e(ja,qa),e(qa,iv),e(ja,lv),e(xo,dv),e(xo,Pa),e(Pa,cv),e(Pa,La),e(La,pv),e(Pa,hv),e(xo,uv),e(xo,Oa),e(Oa,fv),e(Oa,Ia),e(Ia,mv),e(Oa,gv),g(n,am,_),g(n,Uo,_),e(Uo,Is),e(Is,Lp),y(Sa,Lp,null),e(Uo,_v),e(Uo,Op),e(Op,bv),g(n,im,_),g(n,At,_),y(Na,At,null),e(At,kv),e(At,no),e(no,vv),e(no,Tc),e(Tc,wv),e(no,Tv),e(no,yc),e(yc,yv),e(no,$v),e(no,Ra),e(Ra,Fv),e(no,Dv),e(At,Ev),e(At,Qo),e(Qo,xv),e(Qo,$c),e($c,Bv),e(Qo,Mv),e(Qo,Fc),e(Fc,zv),e(Qo,Cv),e(At,Av),y(Ss,At,null),g(n,lm,_),g(n,Ho,_),e(Ho,Ns),e(Ns,Ip),y(Wa,Ip,null),e(Ho,jv),e(Ho,Sp),e(Sp,qv),g(n,dm,_),g(n,tt,_),y(Ua,tt,null),e(tt,Pv),e(tt,Np),e(Np,Lv),e(tt,Ov),e(tt,Qa),e(Qa,Iv),e(Qa,Dc),e(Dc,Sv),e(Qa,Nv),e(tt,Rv),e(tt,Bo),y(Ha,Bo,null),e(Bo,Wv),e(Bo,Rp),e(Rp,Uv),e(Bo,Qv),e(Bo,Ka),e(Ka,Ec),e(Ec,Hv),e(Ec,Wp),e(Wp,Kv),e(Ka,Vv),e(Ka,xc),e(xc,Jv),e(xc,Up),e(Up,Gv),e(tt,Xv),e(tt,Rs),y(Va,Rs,null),e(Rs,Yv),e(Rs,Qp),e(Qp,Zv),e(tt,ew),e(tt,Lt),y(Ja,Lt,null),e(Lt,tw),e(Lt,Hp),e(Hp,ow),e(Lt,sw),y(Ws,Lt,null),e(Lt,nw),e(Lt,Ko),e(Ko,rw),e(Ko,Kp),e(Kp,aw),e(Ko,iw),e(Ko,Vp),e(Vp,lw),e(Ko,dw),e(tt,cw),e(tt,Us),y(Ga,Us,null),e(Us,pw),e(Us,Xa),e(Xa,hw),e(Xa,Jp),e(Jp,uw),e(Xa,fw),g(n,cm,_),g(n,Vo,_),e(Vo,Qs),e(Qs,Gp),y(Ya,Gp,null),e(Vo,mw),e(Vo,Xp),e(Xp,gw),g(n,pm,_),g(n,ft,_),y(Za,ft,null),e(ft,_w),e(ft,ei),e(ei,bw),e(ei,Yp),e(Yp,kw),e(ei,vw),e(ft,ww),e(ft,ti),e(ti,Tw),e(ti,Bc),e(Bc,yw),e(ti,$w),e(ft,Fw),e(ft,Mo),y(oi,Mo,null),e(Mo,Dw),e(Mo,Zp),e(Zp,Ew),e(Mo,xw),e(Mo,si),e(si,Mc),e(Mc,Bw),e(Mc,eh),e(eh,Mw),e(si,zw),e(si,zc),e(zc,Cw),e(zc,th),e(th,Aw),e(ft,jw),e(ft,Ot),y(ni,Ot,null),e(Ot,qw),e(Ot,oh),e(oh,Pw),e(Ot,Lw),y(Hs,Ot,null),e(Ot,Ow),e(Ot,Jo),e(Jo,Iw),e(Jo,sh),e(sh,Sw),e(Jo,Nw),e(Jo,nh),e(nh,Rw),e(Jo,Ww),g(n,hm,_),g(n,Go,_),e(Go,Ks),e(Ks,rh),y(ri,rh,null),e(Go,Uw),e(Go,ah),e(ah,Qw),g(n,um,_),g(n,mt,_),y(ai,mt,null),e(mt,Hw),e(mt,ih),e(ih,Kw),e(mt,Vw),e(mt,ii),e(ii,Jw),e(ii,Cc),e(Cc,Gw),e(ii,Xw),e(mt,Yw),e(mt,li),e(li,Zw),e(li,di),e(di,eT),e(li,tT),e(mt,oT),e(mt,It),y(ci,It,null),e(It,sT),e(It,Xo),e(Xo,nT),e(Xo,Ac),e(Ac,rT),e(Xo,aT),e(Xo,lh),e(lh,iT),e(Xo,lT),e(It,dT),y(Vs,It,null),e(It,cT),y(Js,It,null),g(n,fm,_),g(n,Yo,_),e(Yo,Gs),e(Gs,dh),y(pi,dh,null),e(Yo,pT),e(Yo,ch),e(ch,hT),g(n,mm,_),g(n,gt,_),y(hi,gt,null),e(gt,uT),e(gt,ui),e(ui,fT),e(ui,ph),e(ph,mT),e(ui,gT),e(gt,_T),e(gt,fi),e(fi,bT),e(fi,jc),e(jc,kT),e(fi,vT),e(gt,wT),e(gt,mi),e(mi,TT),e(mi,gi),e(gi,yT),e(mi,$T),e(gt,FT),e(gt,St),y(_i,St,null),e(St,DT),e(St,Zo),e(Zo,ET),e(Zo,qc),e(qc,xT),e(Zo,BT),e(Zo,hh),e(hh,MT),e(Zo,zT),e(St,CT),y(Xs,St,null),e(St,AT),y(Ys,St,null),g(n,gm,_),g(n,es,_),e(es,Zs),e(Zs,uh),y(bi,uh,null),e(es,jT),e(es,fh),e(fh,qT),g(n,_m,_),g(n,_t,_),y(ki,_t,null),e(_t,PT),e(_t,mh),e(mh,LT),e(_t,OT),e(_t,vi),e(vi,IT),e(vi,Pc),e(Pc,ST),e(vi,NT),e(_t,RT),e(_t,wi),e(wi,WT),e(wi,Ti),e(Ti,UT),e(wi,QT),e(_t,HT),e(_t,wt),y(yi,wt,null),e(wt,KT),e(wt,ts),e(ts,VT),e(ts,Lc),e(Lc,JT),e(ts,GT),e(ts,gh),e(gh,XT),e(ts,YT),e(wt,ZT),y(en,wt,null),e(wt,ey),y(tn,wt,null),e(wt,ty),y(on,wt,null),g(n,bm,_),g(n,os,_),e(os,sn),e(sn,_h),y($i,_h,null),e(os,oy),e(os,bh),e(bh,sy),g(n,km,_),g(n,bt,_),y(Fi,bt,null),e(bt,ny),e(bt,kh),e(kh,ry),e(bt,ay),e(bt,Di),e(Di,iy),e(Di,Oc),e(Oc,ly),e(Di,dy),e(bt,cy),e(bt,Ei),e(Ei,py),e(Ei,xi),e(xi,hy),e(Ei,uy),e(bt,fy),e(bt,Nt),y(Bi,Nt,null),e(Nt,my),e(Nt,ss),e(ss,gy),e(ss,Ic),e(Ic,_y),e(ss,by),e(ss,vh),e(vh,ky),e(ss,vy),e(Nt,wy),y(nn,Nt,null),e(Nt,Ty),y(rn,Nt,null),g(n,vm,_),g(n,ns,_),e(ns,an),e(an,wh),y(Mi,wh,null),e(ns,yy),e(ns,Th),e(Th,$y),g(n,wm,_),g(n,kt,_),y(zi,kt,null),e(kt,Fy),e(kt,yh),e(yh,Dy),e(kt,Ey),e(kt,Ci),e(Ci,xy),e(Ci,Sc),e(Sc,By),e(Ci,My),e(kt,zy),e(kt,Ai),e(Ai,Cy),e(Ai,ji),e(ji,Ay),e(Ai,jy),e(kt,qy),e(kt,Rt),y(qi,Rt,null),e(Rt,Py),e(Rt,rs),e(rs,Ly),e(rs,Nc),e(Nc,Oy),e(rs,Iy),e(rs,$h),e($h,Sy),e(rs,Ny),e(Rt,Ry),y(ln,Rt,null),e(Rt,Wy),y(dn,Rt,null),g(n,Tm,_),g(n,as,_),e(as,cn),e(cn,Fh),y(Pi,Fh,null),e(as,Uy),e(as,Dh),e(Dh,Qy),g(n,ym,_),g(n,vt,_),y(Li,vt,null),e(vt,Hy),e(vt,is),e(is,Ky),e(is,Eh),e(Eh,Vy),e(is,Jy),e(is,xh),e(xh,Gy),e(is,Xy),e(vt,Yy),e(vt,Oi),e(Oi,Zy),e(Oi,Rc),e(Rc,e$),e(Oi,t$),e(vt,o$),e(vt,Ii),e(Ii,s$),e(Ii,Si),e(Si,n$),e(Ii,r$),e(vt,a$),e(vt,Wt),y(Ni,Wt,null),e(Wt,i$),e(Wt,ls),e(ls,l$),e(ls,Wc),e(Wc,d$),e(ls,c$),e(ls,Bh),e(Bh,p$),e(ls,h$),e(Wt,u$),y(pn,Wt,null),e(Wt,f$),y(hn,Wt,null),g(n,$m,_),g(n,ds,_),e(ds,un),e(un,Mh),y(Ri,Mh,null),e(ds,m$),e(ds,zh),e(zh,g$),g(n,Fm,_),g(n,lt,_),y(Wi,lt,null),e(lt,_$),e(lt,Ch),e(Ch,b$),e(lt,k$),e(lt,Ui),e(Ui,v$),e(Ui,Uc),e(Uc,w$),e(Ui,T$),e(lt,y$),e(lt,Qi),e(Qi,$$),e(Qi,Hi),e(Hi,F$),e(Qi,D$),e(lt,E$),y(fn,lt,null),e(lt,x$),e(lt,Ut),y(Ki,Ut,null),e(Ut,B$),e(Ut,cs),e(cs,M$),e(cs,Qc),e(Qc,z$),e(cs,C$),e(cs,Ah),e(Ah,A$),e(cs,j$),e(Ut,q$),y(mn,Ut,null),e(Ut,P$),y(gn,Ut,null),g(n,Dm,_),g(n,ps,_),e(ps,_n),e(_n,jh),y(Vi,jh,null),e(ps,L$),e(ps,qh),e(qh,O$),g(n,Em,_),g(n,dt,_),y(Ji,dt,null),e(dt,I$),e(dt,Gi),e(Gi,S$),e(Gi,Ph),e(Ph,N$),e(Gi,R$),e(dt,W$),e(dt,Xi),e(Xi,U$),e(Xi,Hc),e(Hc,Q$),e(Xi,H$),e(dt,K$),e(dt,Yi),e(Yi,V$),e(Yi,Zi),e(Zi,J$),e(Yi,G$),e(dt,X$),y(bn,dt,null),e(dt,Y$),e(dt,Tt),y(el,Tt,null),e(Tt,Z$),e(Tt,hs),e(hs,e1),e(hs,Kc),e(Kc,t1),e(hs,o1),e(hs,Lh),e(Lh,s1),e(hs,n1),e(Tt,r1),y(kn,Tt,null),e(Tt,a1),y(vn,Tt,null),e(Tt,i1),y(wn,Tt,null),g(n,xm,_),g(n,us,_),e(us,Tn),e(Tn,Oh),y(tl,Oh,null),e(us,l1),e(us,Ih),e(Ih,d1),g(n,Bm,_),g(n,ct,_),y(ol,ct,null),e(ct,c1),e(ct,Sh),e(Sh,p1),e(ct,h1),e(ct,sl),e(sl,u1),e(sl,Vc),e(Vc,f1),e(sl,m1),e(ct,g1),e(ct,nl),e(nl,_1),e(nl,rl),e(rl,b1),e(nl,k1),e(ct,v1),y(yn,ct,null),e(ct,w1),e(ct,yt),y(al,yt,null),e(yt,T1),e(yt,fs),e(fs,y1),e(fs,Jc),e(Jc,$1),e(fs,F1),e(fs,Nh),e(Nh,D1),e(fs,E1),e(yt,x1),y($n,yt,null),e(yt,B1),y(Fn,yt,null),e(yt,M1),y(Dn,yt,null),g(n,Mm,_),g(n,ms,_),e(ms,En),e(En,Rh),y(il,Rh,null),e(ms,z1),e(ms,Wh),e(Wh,C1),g(n,zm,_),g(n,pt,_),y(ll,pt,null),e(pt,A1),e(pt,Uh),e(Uh,j1),e(pt,q1),e(pt,dl),e(dl,P1),e(dl,Gc),e(Gc,L1),e(dl,O1),e(pt,I1),e(pt,cl),e(cl,S1),e(cl,pl),e(pl,N1),e(cl,R1),e(pt,W1),y(xn,pt,null),e(pt,U1),e(pt,Qt),y(hl,Qt,null),e(Qt,Q1),e(Qt,gs),e(gs,H1),e(gs,Xc),e(Xc,K1),e(gs,V1),e(gs,Qh),e(Qh,J1),e(gs,G1),e(Qt,X1),y(Bn,Qt,null),e(Qt,Y1),y(Mn,Qt,null),g(n,Cm,_),g(n,_s,_),e(_s,zn),e(zn,Hh),y(ul,Hh,null),e(_s,Z1),e(_s,Kh),e(Kh,e2),g(n,Am,_),g(n,ht,_),y(fl,ht,null),e(ht,t2),e(ht,Vh),e(Vh,o2),e(ht,s2),e(ht,ml),e(ml,n2),e(ml,Yc),e(Yc,r2),e(ml,a2),e(ht,i2),e(ht,gl),e(gl,l2),e(gl,_l),e(_l,d2),e(gl,c2),e(ht,p2),y(Cn,ht,null),e(ht,h2),e(ht,$t),y(bl,$t,null),e($t,u2),e($t,bs),e(bs,f2),e(bs,Zc),e(Zc,m2),e(bs,g2),e(bs,Jh),e(Jh,_2),e(bs,b2),e($t,k2),y(An,$t,null),e($t,v2),y(jn,$t,null),e($t,w2),y(qn,$t,null),g(n,jm,_),g(n,ks,_),e(ks,Pn),e(Pn,Gh),y(kl,Gh,null),e(ks,T2),e(ks,Xh),e(Xh,y2),g(n,qm,_),g(n,ut,_),y(vl,ut,null),e(ut,$2),e(ut,vs),e(vs,F2),e(vs,Yh),e(Yh,D2),e(vs,E2),e(vs,Zh),e(Zh,x2),e(vs,B2),e(ut,M2),e(ut,wl),e(wl,z2),e(wl,ep),e(ep,C2),e(wl,A2),e(ut,j2),e(ut,Tl),e(Tl,q2),e(Tl,yl),e(yl,P2),e(Tl,L2),e(ut,O2),y(Ln,ut,null),e(ut,I2),e(ut,Ft),y($l,Ft,null),e(Ft,S2),e(Ft,ws),e(ws,N2),e(ws,tp),e(tp,R2),e(ws,W2),e(ws,eu),e(eu,U2),e(ws,Q2),e(Ft,H2),y(On,Ft,null),e(Ft,K2),y(In,Ft,null),e(Ft,V2),y(Sn,Ft,null),g(n,Pm,_),g(n,Ts,_),e(Ts,Nn),e(Nn,tu),y(Fl,tu,null),e(Ts,J2),e(Ts,ou),e(ou,G2),g(n,Lm,_),g(n,ot,_),y(Dl,ot,null),e(ot,X2),e(ot,su),e(su,Y2),e(ot,Z2),e(ot,El),e(El,eF),e(El,op),e(op,tF),e(El,oF),e(ot,sF),e(ot,xl),e(xl,nF),e(xl,Bl),e(Bl,rF),e(xl,aF),e(ot,iF),e(ot,nu),e(nu,lF),e(ot,dF),e(ot,ro),e(ro,ru),e(ru,Ml),e(Ml,cF),e(ro,pF),e(ro,au),e(au,zl),e(zl,hF),e(ro,uF),e(ro,iu),e(iu,Cl),e(Cl,fF),e(ro,mF),e(ro,lu),e(lu,Al),e(Al,gF),e(ot,_F),e(ot,Ht),y(jl,Ht,null),e(Ht,bF),e(Ht,ys),e(ys,kF),e(ys,du),e(du,vF),e(ys,wF),e(ys,cu),e(cu,TF),e(ys,yF),e(Ht,$F),y(Rn,Ht,null),e(Ht,FF),y(Wn,Ht,null),g(n,Om,_),g(n,$s,_),e($s,Un),e(Un,pu),y(ql,pu,null),e($s,DF),e($s,hu),e(hu,EF),g(n,Im,_),g(n,st,_),y(Pl,st,null),e(st,xF),e(st,Ll),e(Ll,BF),e(Ll,uu),e(uu,MF),e(Ll,zF),e(st,CF),e(st,Ol),e(Ol,AF),e(Ol,sp),e(sp,jF),e(Ol,qF),e(st,PF),e(st,Il),e(Il,LF),e(Il,Sl),e(Sl,OF),e(Il,IF),e(st,SF),e(st,fu),e(fu,NF),e(st,RF),e(st,ao),e(ao,mu),e(mu,Nl),e(Nl,WF),e(ao,UF),e(ao,gu),e(gu,Rl),e(Rl,QF),e(ao,HF),e(ao,_u),e(_u,Wl),e(Wl,KF),e(ao,VF),e(ao,bu),e(bu,Ul),e(Ul,JF),e(st,GF),e(st,Kt),y(Ql,Kt,null),e(Kt,XF),e(Kt,Fs),e(Fs,YF),e(Fs,ku),e(ku,ZF),e(Fs,eD),e(Fs,vu),e(vu,tD),e(Fs,oD),e(Kt,sD),y(Qn,Kt,null),e(Kt,nD),y(Hn,Kt,null),g(n,Sm,_),g(n,Ds,_),e(Ds,Kn),e(Kn,wu),y(Hl,wu,null),e(Ds,rD),e(Ds,Tu),e(Tu,aD),g(n,Nm,_),g(n,nt,_),y(Kl,nt,null),e(nt,iD),e(nt,yu),e(yu,lD),e(nt,dD),e(nt,Vl),e(Vl,cD),e(Vl,np),e(np,pD),e(Vl,hD),e(nt,uD),e(nt,Jl),e(Jl,fD),e(Jl,Gl),e(Gl,mD),e(Jl,gD),e(nt,_D),e(nt,$u),e($u,bD),e(nt,kD),e(nt,io),e(io,Fu),e(Fu,Xl),e(Xl,vD),e(io,wD),e(io,Du),e(Du,Yl),e(Yl,TD),e(io,yD),e(io,Eu),e(Eu,Zl),e(Zl,$D),e(io,FD),e(io,xu),e(xu,ed),e(ed,DD),e(nt,ED),e(nt,Vt),y(td,Vt,null),e(Vt,xD),e(Vt,Es),e(Es,BD),e(Es,Bu),e(Bu,MD),e(Es,zD),e(Es,Mu),e(Mu,CD),e(Es,AD),e(Vt,jD),y(Vn,Vt,null),e(Vt,qD),y(Jn,Vt,null),g(n,Rm,_),g(n,xs,_),e(xs,Gn),e(Gn,zu),y(od,zu,null),e(xs,PD),e(xs,Cu),e(Cu,LD),g(n,Wm,_),g(n,rt,_),y(sd,rt,null),e(rt,OD),e(rt,Au),e(Au,ID),e(rt,SD),e(rt,nd),e(nd,ND),e(nd,rp),e(rp,RD),e(nd,WD),e(rt,UD),e(rt,rd),e(rd,QD),e(rd,ad),e(ad,HD),e(rd,KD),e(rt,VD),e(rt,ju),e(ju,JD),e(rt,GD),e(rt,lo),e(lo,qu),e(qu,id),e(id,XD),e(lo,YD),e(lo,Pu),e(Pu,ld),e(ld,ZD),e(lo,e0),e(lo,Lu),e(Lu,dd),e(dd,t0),e(lo,o0),e(lo,Ou),e(Ou,cd),e(cd,s0),e(rt,n0),e(rt,Jt),y(pd,Jt,null),e(Jt,r0),e(Jt,Bs),e(Bs,a0),e(Bs,Iu),e(Iu,i0),e(Bs,l0),e(Bs,Su),e(Su,d0),e(Bs,c0),e(Jt,p0),y(Xn,Jt,null),e(Jt,h0),y(Yn,Jt,null),g(n,Um,_),g(n,Ms,_),e(Ms,Zn),e(Zn,Nu),y(hd,Nu,null),e(Ms,u0),e(Ms,Ru),e(Ru,f0),g(n,Qm,_),g(n,at,_),y(ud,at,null),e(at,m0),e(at,Wu),e(Wu,g0),e(at,_0),e(at,fd),e(fd,b0),e(fd,ap),e(ap,k0),e(fd,v0),e(at,w0),e(at,md),e(md,T0),e(md,gd),e(gd,y0),e(md,$0),e(at,F0),e(at,Uu),e(Uu,D0),e(at,E0),e(at,co),e(co,Qu),e(Qu,_d),e(_d,x0),e(co,B0),e(co,Hu),e(Hu,bd),e(bd,M0),e(co,z0),e(co,Ku),e(Ku,kd),e(kd,C0),e(co,A0),e(co,Vu),e(Vu,vd),e(vd,j0),e(at,q0),e(at,Gt),y(wd,Gt,null),e(Gt,P0),e(Gt,zs),e(zs,L0),e(zs,Ju),e(Ju,O0),e(zs,I0),e(zs,Gu),e(Gu,S0),e(zs,N0),e(Gt,R0),y(er,Gt,null),e(Gt,W0),y(tr,Gt,null),g(n,Hm,_),g(n,Cs,_),e(Cs,or),e(or,Xu),y(Td,Xu,null),e(Cs,U0),e(Cs,Yu),e(Yu,Q0),g(n,Km,_),g(n,it,_),y(yd,it,null),e(it,H0),e(it,As),e(As,K0),e(As,Zu),e(Zu,V0),e(As,J0),e(As,ef),e(ef,G0),e(As,X0),e(it,Y0),e(it,$d),e($d,Z0),e($d,ip),e(ip,eE),e($d,tE),e(it,oE),e(it,Fd),e(Fd,sE),e(Fd,Dd),e(Dd,nE),e(Fd,rE),e(it,aE),e(it,tf),e(tf,iE),e(it,lE),e(it,po),e(po,of),e(of,Ed),e(Ed,dE),e(po,cE),e(po,sf),e(sf,xd),e(xd,pE),e(po,hE),e(po,nf),e(nf,Bd),e(Bd,uE),e(po,fE),e(po,rf),e(rf,Md),e(Md,mE),e(it,gE),e(it,Xt),y(zd,Xt,null),e(Xt,_E),e(Xt,js),e(js,bE),e(js,af),e(af,kE),e(js,vE),e(js,lf),e(lf,wE),e(js,TE),e(Xt,yE),y(sr,Xt,null),e(Xt,$E),y(nr,Xt,null),Vm=!0},p(n,[_]){const Cd={};_&2&&(Cd.$$scope={dirty:_,ctx:n}),Ss.$set(Cd);const df={};_&2&&(df.$$scope={dirty:_,ctx:n}),Ws.$set(df);const cf={};_&2&&(cf.$$scope={dirty:_,ctx:n}),Hs.$set(cf);const pf={};_&2&&(pf.$$scope={dirty:_,ctx:n}),Vs.$set(pf);const Ad={};_&2&&(Ad.$$scope={dirty:_,ctx:n}),Js.$set(Ad);const hf={};_&2&&(hf.$$scope={dirty:_,ctx:n}),Xs.$set(hf);const uf={};_&2&&(uf.$$scope={dirty:_,ctx:n}),Ys.$set(uf);const ff={};_&2&&(ff.$$scope={dirty:_,ctx:n}),en.$set(ff);const ho={};_&2&&(ho.$$scope={dirty:_,ctx:n}),tn.$set(ho);const mf={};_&2&&(mf.$$scope={dirty:_,ctx:n}),on.$set(mf);const gf={};_&2&&(gf.$$scope={dirty:_,ctx:n}),nn.$set(gf);const _f={};_&2&&(_f.$$scope={dirty:_,ctx:n}),rn.$set(_f);const bf={};_&2&&(bf.$$scope={dirty:_,ctx:n}),ln.$set(bf);const kf={};_&2&&(kf.$$scope={dirty:_,ctx:n}),dn.$set(kf);const vf={};_&2&&(vf.$$scope={dirty:_,ctx:n}),pn.$set(vf);const wf={};_&2&&(wf.$$scope={dirty:_,ctx:n}),hn.$set(wf);const jd={};_&2&&(jd.$$scope={dirty:_,ctx:n}),fn.$set(jd);const uo={};_&2&&(uo.$$scope={dirty:_,ctx:n}),mn.$set(uo);const Tf={};_&2&&(Tf.$$scope={dirty:_,ctx:n}),gn.$set(Tf);const yf={};_&2&&(yf.$$scope={dirty:_,ctx:n}),bn.$set(yf);const $f={};_&2&&($f.$$scope={dirty:_,ctx:n}),kn.$set($f);const qd={};_&2&&(qd.$$scope={dirty:_,ctx:n}),vn.$set(qd);const Ff={};_&2&&(Ff.$$scope={dirty:_,ctx:n}),wn.$set(Ff);const fo={};_&2&&(fo.$$scope={dirty:_,ctx:n}),yn.$set(fo);const Df={};_&2&&(Df.$$scope={dirty:_,ctx:n}),$n.$set(Df);const Ef={};_&2&&(Ef.$$scope={dirty:_,ctx:n}),Fn.$set(Ef);const xf={};_&2&&(xf.$$scope={dirty:_,ctx:n}),Dn.$set(xf);const Pd={};_&2&&(Pd.$$scope={dirty:_,ctx:n}),xn.$set(Pd);const Bf={};_&2&&(Bf.$$scope={dirty:_,ctx:n}),Bn.$set(Bf);const Mf={};_&2&&(Mf.$$scope={dirty:_,ctx:n}),Mn.$set(Mf);const zf={};_&2&&(zf.$$scope={dirty:_,ctx:n}),Cn.$set(zf);const Cf={};_&2&&(Cf.$$scope={dirty:_,ctx:n}),An.$set(Cf);const Ue={};_&2&&(Ue.$$scope={dirty:_,ctx:n}),jn.$set(Ue);const Ld={};_&2&&(Ld.$$scope={dirty:_,ctx:n}),qn.$set(Ld);const Af={};_&2&&(Af.$$scope={dirty:_,ctx:n}),Ln.$set(Af);const Od={};_&2&&(Od.$$scope={dirty:_,ctx:n}),On.$set(Od);const jf={};_&2&&(jf.$$scope={dirty:_,ctx:n}),In.$set(jf);const Id={};_&2&&(Id.$$scope={dirty:_,ctx:n}),Sn.$set(Id);const qf={};_&2&&(qf.$$scope={dirty:_,ctx:n}),Rn.$set(qf);const Sd={};_&2&&(Sd.$$scope={dirty:_,ctx:n}),Wn.$set(Sd);const Pf={};_&2&&(Pf.$$scope={dirty:_,ctx:n}),Qn.$set(Pf);const Nd={};_&2&&(Nd.$$scope={dirty:_,ctx:n}),Hn.$set(Nd);const Lf={};_&2&&(Lf.$$scope={dirty:_,ctx:n}),Vn.$set(Lf);const Rd={};_&2&&(Rd.$$scope={dirty:_,ctx:n}),Jn.$set(Rd);const Of={};_&2&&(Of.$$scope={dirty:_,ctx:n}),Xn.$set(Of);const Wd={};_&2&&(Wd.$$scope={dirty:_,ctx:n}),Yn.$set(Wd);const If={};_&2&&(If.$$scope={dirty:_,ctx:n}),er.$set(If);const zo={};_&2&&(zo.$$scope={dirty:_,ctx:n}),tr.$set(zo);const Sf={};_&2&&(Sf.$$scope={dirty:_,ctx:n}),sr.$set(Sf);const Nf={};_&2&&(Nf.$$scope={dirty:_,ctx:n}),nr.$set(Nf)},i(n){Vm||($(l.$$.fragment,n),$(E.$$.fragment,n),$(W.$$.fragment,n),$(zr.$$.fragment,n),$(Yr.$$.fragment,n),$(ra.$$.fragment,n),$(ua.$$.fragment,n),$(Sa.$$.fragment,n),$(Na.$$.fragment,n),$(Ss.$$.fragment,n),$(Wa.$$.fragment,n),$(Ua.$$.fragment,n),$(Ha.$$.fragment,n),$(Va.$$.fragment,n),$(Ja.$$.fragment,n),$(Ws.$$.fragment,n),$(Ga.$$.fragment,n),$(Ya.$$.fragment,n),$(Za.$$.fragment,n),$(oi.$$.fragment,n),$(ni.$$.fragment,n),$(Hs.$$.fragment,n),$(ri.$$.fragment,n),$(ai.$$.fragment,n),$(ci.$$.fragment,n),$(Vs.$$.fragment,n),$(Js.$$.fragment,n),$(pi.$$.fragment,n),$(hi.$$.fragment,n),$(_i.$$.fragment,n),$(Xs.$$.fragment,n),$(Ys.$$.fragment,n),$(bi.$$.fragment,n),$(ki.$$.fragment,n),$(yi.$$.fragment,n),$(en.$$.fragment,n),$(tn.$$.fragment,n),$(on.$$.fragment,n),$($i.$$.fragment,n),$(Fi.$$.fragment,n),$(Bi.$$.fragment,n),$(nn.$$.fragment,n),$(rn.$$.fragment,n),$(Mi.$$.fragment,n),$(zi.$$.fragment,n),$(qi.$$.fragment,n),$(ln.$$.fragment,n),$(dn.$$.fragment,n),$(Pi.$$.fragment,n),$(Li.$$.fragment,n),$(Ni.$$.fragment,n),$(pn.$$.fragment,n),$(hn.$$.fragment,n),$(Ri.$$.fragment,n),$(Wi.$$.fragment,n),$(fn.$$.fragment,n),$(Ki.$$.fragment,n),$(mn.$$.fragment,n),$(gn.$$.fragment,n),$(Vi.$$.fragment,n),$(Ji.$$.fragment,n),$(bn.$$.fragment,n),$(el.$$.fragment,n),$(kn.$$.fragment,n),$(vn.$$.fragment,n),$(wn.$$.fragment,n),$(tl.$$.fragment,n),$(ol.$$.fragment,n),$(yn.$$.fragment,n),$(al.$$.fragment,n),$($n.$$.fragment,n),$(Fn.$$.fragment,n),$(Dn.$$.fragment,n),$(il.$$.fragment,n),$(ll.$$.fragment,n),$(xn.$$.fragment,n),$(hl.$$.fragment,n),$(Bn.$$.fragment,n),$(Mn.$$.fragment,n),$(ul.$$.fragment,n),$(fl.$$.fragment,n),$(Cn.$$.fragment,n),$(bl.$$.fragment,n),$(An.$$.fragment,n),$(jn.$$.fragment,n),$(qn.$$.fragment,n),$(kl.$$.fragment,n),$(vl.$$.fragment,n),$(Ln.$$.fragment,n),$($l.$$.fragment,n),$(On.$$.fragment,n),$(In.$$.fragment,n),$(Sn.$$.fragment,n),$(Fl.$$.fragment,n),$(Dl.$$.fragment,n),$(jl.$$.fragment,n),$(Rn.$$.fragment,n),$(Wn.$$.fragment,n),$(ql.$$.fragment,n),$(Pl.$$.fragment,n),$(Ql.$$.fragment,n),$(Qn.$$.fragment,n),$(Hn.$$.fragment,n),$(Hl.$$.fragment,n),$(Kl.$$.fragment,n),$(td.$$.fragment,n),$(Vn.$$.fragment,n),$(Jn.$$.fragment,n),$(od.$$.fragment,n),$(sd.$$.fragment,n),$(pd.$$.fragment,n),$(Xn.$$.fragment,n),$(Yn.$$.fragment,n),$(hd.$$.fragment,n),$(ud.$$.fragment,n),$(wd.$$.fragment,n),$(er.$$.fragment,n),$(tr.$$.fragment,n),$(Td.$$.fragment,n),$(yd.$$.fragment,n),$(zd.$$.fragment,n),$(sr.$$.fragment,n),$(nr.$$.fragment,n),Vm=!0)},o(n){F(l.$$.fragment,n),F(E.$$.fragment,n),F(W.$$.fragment,n),F(zr.$$.fragment,n),F(Yr.$$.fragment,n),F(ra.$$.fragment,n),F(ua.$$.fragment,n),F(Sa.$$.fragment,n),F(Na.$$.fragment,n),F(Ss.$$.fragment,n),F(Wa.$$.fragment,n),F(Ua.$$.fragment,n),F(Ha.$$.fragment,n),F(Va.$$.fragment,n),F(Ja.$$.fragment,n),F(Ws.$$.fragment,n),F(Ga.$$.fragment,n),F(Ya.$$.fragment,n),F(Za.$$.fragment,n),F(oi.$$.fragment,n),F(ni.$$.fragment,n),F(Hs.$$.fragment,n),F(ri.$$.fragment,n),F(ai.$$.fragment,n),F(ci.$$.fragment,n),F(Vs.$$.fragment,n),F(Js.$$.fragment,n),F(pi.$$.fragment,n),F(hi.$$.fragment,n),F(_i.$$.fragment,n),F(Xs.$$.fragment,n),F(Ys.$$.fragment,n),F(bi.$$.fragment,n),F(ki.$$.fragment,n),F(yi.$$.fragment,n),F(en.$$.fragment,n),F(tn.$$.fragment,n),F(on.$$.fragment,n),F($i.$$.fragment,n),F(Fi.$$.fragment,n),F(Bi.$$.fragment,n),F(nn.$$.fragment,n),F(rn.$$.fragment,n),F(Mi.$$.fragment,n),F(zi.$$.fragment,n),F(qi.$$.fragment,n),F(ln.$$.fragment,n),F(dn.$$.fragment,n),F(Pi.$$.fragment,n),F(Li.$$.fragment,n),F(Ni.$$.fragment,n),F(pn.$$.fragment,n),F(hn.$$.fragment,n),F(Ri.$$.fragment,n),F(Wi.$$.fragment,n),F(fn.$$.fragment,n),F(Ki.$$.fragment,n),F(mn.$$.fragment,n),F(gn.$$.fragment,n),F(Vi.$$.fragment,n),F(Ji.$$.fragment,n),F(bn.$$.fragment,n),F(el.$$.fragment,n),F(kn.$$.fragment,n),F(vn.$$.fragment,n),F(wn.$$.fragment,n),F(tl.$$.fragment,n),F(ol.$$.fragment,n),F(yn.$$.fragment,n),F(al.$$.fragment,n),F($n.$$.fragment,n),F(Fn.$$.fragment,n),F(Dn.$$.fragment,n),F(il.$$.fragment,n),F(ll.$$.fragment,n),F(xn.$$.fragment,n),F(hl.$$.fragment,n),F(Bn.$$.fragment,n),F(Mn.$$.fragment,n),F(ul.$$.fragment,n),F(fl.$$.fragment,n),F(Cn.$$.fragment,n),F(bl.$$.fragment,n),F(An.$$.fragment,n),F(jn.$$.fragment,n),F(qn.$$.fragment,n),F(kl.$$.fragment,n),F(vl.$$.fragment,n),F(Ln.$$.fragment,n),F($l.$$.fragment,n),F(On.$$.fragment,n),F(In.$$.fragment,n),F(Sn.$$.fragment,n),F(Fl.$$.fragment,n),F(Dl.$$.fragment,n),F(jl.$$.fragment,n),F(Rn.$$.fragment,n),F(Wn.$$.fragment,n),F(ql.$$.fragment,n),F(Pl.$$.fragment,n),F(Ql.$$.fragment,n),F(Qn.$$.fragment,n),F(Hn.$$.fragment,n),F(Hl.$$.fragment,n),F(Kl.$$.fragment,n),F(td.$$.fragment,n),F(Vn.$$.fragment,n),F(Jn.$$.fragment,n),F(od.$$.fragment,n),F(sd.$$.fragment,n),F(pd.$$.fragment,n),F(Xn.$$.fragment,n),F(Yn.$$.fragment,n),F(hd.$$.fragment,n),F(ud.$$.fragment,n),F(wd.$$.fragment,n),F(er.$$.fragment,n),F(tr.$$.fragment,n),F(Td.$$.fragment,n),F(yd.$$.fragment,n),F(zd.$$.fragment,n),F(sr.$$.fragment,n),F(nr.$$.fragment,n),Vm=!1},d(n){t(d),n&&t(k),n&&t(f),D(l),n&&t(ue),n&&t(I),D(E),n&&t(fe),n&&t(L),n&&t(me),n&&t(ee),n&&t(q),n&&t(le),n&&t(ge),n&&t(U),n&&t(_e),n&&t(A),n&&t(v),n&&t(B),n&&t(O),n&&t(N),D(W),n&&t(Qe),n&&t(te),n&&t(Uf),D(zr,n),n&&t(Qf),n&&t(Ie),n&&t(Hf),D(Yr,n),n&&t(Kf),n&&t(jt),n&&t(Vf),D(ra,n),n&&t(Jf),n&&t(qt),n&&t(Gf),D(ua,n),n&&t(Xf),n&&t(Pt),n&&t(Yf),n&&t(gc),n&&t(Zf),n&&t(Ls),n&&t(em),n&&t(kc),n&&t(tm),n&&t(Eo),n&&t(om),n&&t(vc),n&&t(sm),n&&t(Os),n&&t(nm),n&&t(wc),n&&t(rm),n&&t(xo),n&&t(am),n&&t(Uo),D(Sa),n&&t(im),n&&t(At),D(Na),D(Ss),n&&t(lm),n&&t(Ho),D(Wa),n&&t(dm),n&&t(tt),D(Ua),D(Ha),D(Va),D(Ja),D(Ws),D(Ga),n&&t(cm),n&&t(Vo),D(Ya),n&&t(pm),n&&t(ft),D(Za),D(oi),D(ni),D(Hs),n&&t(hm),n&&t(Go),D(ri),n&&t(um),n&&t(mt),D(ai),D(ci),D(Vs),D(Js),n&&t(fm),n&&t(Yo),D(pi),n&&t(mm),n&&t(gt),D(hi),D(_i),D(Xs),D(Ys),n&&t(gm),n&&t(es),D(bi),n&&t(_m),n&&t(_t),D(ki),D(yi),D(en),D(tn),D(on),n&&t(bm),n&&t(os),D($i),n&&t(km),n&&t(bt),D(Fi),D(Bi),D(nn),D(rn),n&&t(vm),n&&t(ns),D(Mi),n&&t(wm),n&&t(kt),D(zi),D(qi),D(ln),D(dn),n&&t(Tm),n&&t(as),D(Pi),n&&t(ym),n&&t(vt),D(Li),D(Ni),D(pn),D(hn),n&&t($m),n&&t(ds),D(Ri),n&&t(Fm),n&&t(lt),D(Wi),D(fn),D(Ki),D(mn),D(gn),n&&t(Dm),n&&t(ps),D(Vi),n&&t(Em),n&&t(dt),D(Ji),D(bn),D(el),D(kn),D(vn),D(wn),n&&t(xm),n&&t(us),D(tl),n&&t(Bm),n&&t(ct),D(ol),D(yn),D(al),D($n),D(Fn),D(Dn),n&&t(Mm),n&&t(ms),D(il),n&&t(zm),n&&t(pt),D(ll),D(xn),D(hl),D(Bn),D(Mn),n&&t(Cm),n&&t(_s),D(ul),n&&t(Am),n&&t(ht),D(fl),D(Cn),D(bl),D(An),D(jn),D(qn),n&&t(jm),n&&t(ks),D(kl),n&&t(qm),n&&t(ut),D(vl),D(Ln),D($l),D(On),D(In),D(Sn),n&&t(Pm),n&&t(Ts),D(Fl),n&&t(Lm),n&&t(ot),D(Dl),D(jl),D(Rn),D(Wn),n&&t(Om),n&&t($s),D(ql),n&&t(Im),n&&t(st),D(Pl),D(Ql),D(Qn),D(Hn),n&&t(Sm),n&&t(Ds),D(Hl),n&&t(Nm),n&&t(nt),D(Kl),D(td),D(Vn),D(Jn),n&&t(Rm),n&&t(xs),D(od),n&&t(Wm),n&&t(rt),D(sd),D(pd),D(Xn),D(Yn),n&&t(Um),n&&t(Ms),D(hd),n&&t(Qm),n&&t(at),D(ud),D(wd),D(er),D(tr),n&&t(Hm),n&&t(Cs),D(Td),n&&t(Km),n&&t(it),D(yd),D(zd),D(sr),D(nr)}}}const X3={local:"distilbert",sections:[{local:"overview",title:"Overview"},{local:"resources",title:"Resources"},{local:"transformers.DistilBertConfig",title:"DistilBertConfig"},{local:"transformers.DistilBertTokenizer",title:"DistilBertTokenizer"},{local:"transformers.DistilBertTokenizerFast",title:"DistilBertTokenizerFast"},{local:"transformers.DistilBertModel",title:"DistilBertModel"},{local:"transformers.DistilBertForMaskedLM",title:"DistilBertForMaskedLM"},{local:"transformers.DistilBertForSequenceClassification",title:"DistilBertForSequenceClassification"},{local:"transformers.DistilBertForMultipleChoice",title:"DistilBertForMultipleChoice"},{local:"transformers.DistilBertForTokenClassification",title:"DistilBertForTokenClassification"},{local:"transformers.DistilBertForQuestionAnswering",title:"DistilBertForQuestionAnswering"},{local:"transformers.TFDistilBertModel",title:"TFDistilBertModel"},{local:"transformers.TFDistilBertForMaskedLM",title:"TFDistilBertForMaskedLM"},{local:"transformers.TFDistilBertForSequenceClassification",title:"TFDistilBertForSequenceClassification"},{local:"transformers.TFDistilBertForMultipleChoice",title:"TFDistilBertForMultipleChoice"},{local:"transformers.TFDistilBertForTokenClassification",title:"TFDistilBertForTokenClassification"},{local:"transformers.TFDistilBertForQuestionAnswering",title:"TFDistilBertForQuestionAnswering"},{local:"transformers.FlaxDistilBertModel",title:"FlaxDistilBertModel"},{local:"transformers.FlaxDistilBertForMaskedLM",title:"FlaxDistilBertForMaskedLM"},{local:"transformers.FlaxDistilBertForSequenceClassification",title:"FlaxDistilBertForSequenceClassification"},{local:"transformers.FlaxDistilBertForMultipleChoice",title:"FlaxDistilBertForMultipleChoice"},{local:"transformers.FlaxDistilBertForTokenClassification",title:"FlaxDistilBertForTokenClassification"},{local:"transformers.FlaxDistilBertForQuestionAnswering",title:"FlaxDistilBertForQuestionAnswering"}],title:"DistilBERT"};function Y3(x){return Zz(()=>{new URLSearchParams(window.location.search).get("fw")}),[]}class aC extends Jz{constructor(d){super();Gz(this,d,Y3,G3,Xz,{})}}export{aC as default,X3 as metadata};
