import{S as l3,i as d3,s as c3,e as n,k as p,w,t as o,M as p3,c as r,d as t,m as h,a,x as T,h as s,b as c,N as i3,G as e,g,y,q as $,o as F,B as D,v as h3,L as Pe}from"../../chunks/vendor-hf-doc-builder.js";import{T as Ie}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 Se}from"../../chunks/IconCopyLink-hf-doc-builder.js";import{E as qe}from"../../chunks/ExampleCodeBlock-hf-doc-builder.js";import{P as V_}from"../../chunks/PipelineTag-hf-doc-builder.js";function u3(x){let d,v,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=n("p"),v=o("Examples:"),f=p(),w(m.$$.fragment)},l(l){d=r(l,"P",{});var u=a(d);v=s(u,"Examples:"),u.forEach(t),f=h(l),T(m.$$.fragment,l)},m(l,u){g(l,d,u),e(d,v),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,v,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=n("p"),v=o("pair mask has the following format:"),f=p(),w(m.$$.fragment)},l(l){d=r(l,"P",{});var u=a(d);v=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,v),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,v,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=n("p"),v=o("pair mask has the following format:"),f=p(),w(m.$$.fragment)},l(l){d=r(l,"P",{});var u=a(d);v=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,v),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,v,f,m,b;return{c(){d=n("p"),v=o("Although the recipe for forward pass needs to be defined within this function, one should call the "),f=n("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=r(l,"P",{});var u=a(d);v=s(u,"Although the recipe for forward pass needs to be defined within this function, one should call the "),f=r(u,"CODE",{});var B=a(f);m=s(B,"Module"),B.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,v),e(d,f),e(f,m),e(d,b)},d(l){l&&t(d)}}}function _3(x){let d,v,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=n("p"),v=o("Example:"),f=p(),w(m.$$.fragment)},l(l){d=r(l,"P",{});var u=a(d);v=s(u,"Example:"),u.forEach(t),f=h(l),T(m.$$.fragment,l)},m(l,u){g(l,d,u),e(d,v),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 b3(x){let d,v,f,m,b;return{c(){d=n("p"),v=o("Although the recipe for forward pass needs to be defined within this function, one should call the "),f=n("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=r(l,"P",{});var u=a(d);v=s(u,"Although the recipe for forward pass needs to be defined within this function, one should call the "),f=r(u,"CODE",{});var B=a(f);m=s(B,"Module"),B.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,v),e(d,f),e(f,m),e(d,b)},d(l){l&&t(d)}}}function v3(x){let d,v,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=n("p"),v=o("Example:"),f=p(),w(m.$$.fragment)},l(l){d=r(l,"P",{});var u=a(d);v=s(u,"Example:"),u.forEach(t),f=h(l),T(m.$$.fragment,l)},m(l,u){g(l,d,u),e(d,v),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,v,f,m,b;return{c(){d=n("p"),v=o("Although the recipe for forward pass needs to be defined within this function, one should call the "),f=n("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=r(l,"P",{});var u=a(d);v=s(u,"Although the recipe for forward pass needs to be defined within this function, one should call the "),f=r(u,"CODE",{});var B=a(f);m=s(B,"Module"),B.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,v),e(d,f),e(f,m),e(d,b)},d(l){l&&t(d)}}}function w3(x){let d,v,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=n("p"),v=o("Example of single-label classification:"),f=p(),w(m.$$.fragment)},l(l){d=r(l,"P",{});var u=a(d);v=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,v),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,v,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=n("p"),v=o("Example of multi-label classification:"),f=p(),w(m.$$.fragment)},l(l){d=r(l,"P",{});var u=a(d);v=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,v),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 y3(x){let d,v,f,m,b;return{c(){d=n("p"),v=o("Although the recipe for forward pass needs to be defined within this function, one should call the "),f=n("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=r(l,"P",{});var u=a(d);v=s(u,"Although the recipe for forward pass needs to be defined within this function, one should call the "),f=r(u,"CODE",{});var B=a(f);m=s(B,"Module"),B.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,v),e(d,f),e(f,m),e(d,b)},d(l){l&&t(d)}}}function $3(x){let d,v,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=n("p"),v=o("Examples:"),f=p(),w(m.$$.fragment)},l(l){d=r(l,"P",{});var u=a(d);v=s(u,"Examples:"),u.forEach(t),f=h(l),T(m.$$.fragment,l)},m(l,u){g(l,d,u),e(d,v),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,v,f,m,b;return{c(){d=n("p"),v=o("Although the recipe for forward pass needs to be defined within this function, one should call the "),f=n("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=r(l,"P",{});var u=a(d);v=s(u,"Although the recipe for forward pass needs to be defined within this function, one should call the "),f=r(u,"CODE",{});var B=a(f);m=s(B,"Module"),B.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,v),e(d,f),e(f,m),e(d,b)},d(l){l&&t(d)}}}function D3(x){let d,v,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=n("p"),v=o("Example:"),f=p(),w(m.$$.fragment)},l(l){d=r(l,"P",{});var u=a(d);v=s(u,"Example:"),u.forEach(t),f=h(l),T(m.$$.fragment,l)},m(l,u){g(l,d,u),e(d,v),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 E3(x){let d,v,f,m,b;return{c(){d=n("p"),v=o("Although the recipe for forward pass needs to be defined within this function, one should call the "),f=n("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=r(l,"P",{});var u=a(d);v=s(u,"Although the recipe for forward pass needs to be defined within this function, one should call the "),f=r(u,"CODE",{});var B=a(f);m=s(B,"Module"),B.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,v),e(d,f),e(f,m),e(d,b)},d(l){l&&t(d)}}}function x3(x){let d,v,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=n("p"),v=o("Example:"),f=p(),w(m.$$.fragment)},l(l){d=r(l,"P",{});var u=a(d);v=s(u,"Example:"),u.forEach(t),f=h(l),T(m.$$.fragment,l)},m(l,u){g(l,d,u),e(d,v),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 B3(x){let d,v,f,m,b,l,u,B,we,_e,S,ce,Z,E,Te,W,pe,Ae,J,oe,ie,Q,le,ye,H,$e,be,O,Fe,de,se,C,A,De,X,fe,Ee,Y,ve,he,q,ke,U,me,xe,G,ue,Be,I,te,K,ee,ne,j,Me,P,ge,ze;return{c(){d=n("p"),v=o("TensorFlow models and layers in "),f=n("code"),m=o("transformers"),b=o(" accept two formats as input:"),l=p(),u=n("ul"),B=n("li"),we=o("having all inputs as keyword arguments (like PyTorch models), or"),_e=p(),S=n("li"),ce=o("having all inputs as a list, tuple or dict in the first positional argument."),Z=p(),E=n("p"),Te=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 `),W=n("code"),pe=o("model.fit()"),Ae=o(` things should \u201Cjust work\u201D for you - just
pass your inputs and labels in any format that `),J=n("code"),oe=o("model.fit()"),ie=o(` supports! If, however, you want to use the second
format outside of Keras methods like `),Q=n("code"),le=o("fit()"),ye=o(" and "),H=n("code"),$e=o("predict()"),be=o(`, such as when creating your own layers or models with
the Keras `),O=n("code"),Fe=o("Functional"),de=o(` API, there are three possibilities you can use to gather all the input Tensors in the first
positional argument:`),se=p(),C=n("ul"),A=n("li"),De=o("a single Tensor with "),X=n("code"),fe=o("input_ids"),Ee=o(" only and nothing else: "),Y=n("code"),ve=o("model(input_ids)"),he=p(),q=n("li"),ke=o(`a list of varying length with one or several input Tensors IN THE ORDER given in the docstring:
`),U=n("code"),me=o("model([input_ids, attention_mask])"),xe=o(" or "),G=n("code"),ue=o("model([input_ids, attention_mask, token_type_ids])"),Be=p(),I=n("li"),te=o(`a dictionary with one or several input Tensors associated to the input names given in the docstring:
`),K=n("code"),ee=o('model({"input_ids": input_ids, "token_type_ids": token_type_ids})'),ne=p(),j=n("p"),Me=o(`Note that when creating models and layers with
`),P=n("a"),ge=o("subclassing"),ze=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(k){d=r(k,"P",{});var M=a(d);v=s(M,"TensorFlow models and layers in "),f=r(M,"CODE",{});var Qe=a(f);m=s(Qe,"transformers"),Qe.forEach(t),b=s(M," accept two formats as input:"),M.forEach(t),l=h(k),u=r(k,"UL",{});var re=a(u);B=r(re,"LI",{});var He=a(B);we=s(He,"having all inputs as keyword arguments (like PyTorch models), or"),He.forEach(t),_e=h(re),S=r(re,"LI",{});var Ne=a(S);ce=s(Ne,"having all inputs as a list, tuple or dict in the first positional argument."),Ne.forEach(t),re.forEach(t),Z=h(k),E=r(k,"P",{});var z=a(E);Te=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 `),W=r(z,"CODE",{});var Ke=a(W);pe=s(Ke,"model.fit()"),Ke.forEach(t),Ae=s(z,` things should \u201Cjust work\u201D for you - just
pass your inputs and labels in any format that `),J=r(z,"CODE",{});var Re=a(J);oe=s(Re,"model.fit()"),Re.forEach(t),ie=s(z,` supports! If, however, you want to use the second
format outside of Keras methods like `),Q=r(z,"CODE",{});var Ve=a(Q);le=s(Ve,"fit()"),Ve.forEach(t),ye=s(z," and "),H=r(z,"CODE",{});var Je=a(H);$e=s(Je,"predict()"),Je.forEach(t),be=s(z,`, such as when creating your own layers or models with
the Keras `),O=r(z,"CODE",{});var Ge=a(O);Fe=s(Ge,"Functional"),Ge.forEach(t),de=s(z,` API, there are three possibilities you can use to gather all the input Tensors in the first
positional argument:`),z.forEach(t),se=h(k),C=r(k,"UL",{});var L=a(C);A=r(L,"LI",{});var V=a(A);De=s(V,"a single Tensor with "),X=r(V,"CODE",{});var Xe=a(X);fe=s(Xe,"input_ids"),Xe.forEach(t),Ee=s(V," only and nothing else: "),Y=r(V,"CODE",{});var Ye=a(Y);ve=s(Ye,"model(input_ids)"),Ye.forEach(t),V.forEach(t),he=h(L),q=r(L,"LI",{});var N=a(q);ke=s(N,`a list of varying length with one or several input Tensors IN THE ORDER given in the docstring:
`),U=r(N,"CODE",{});var We=a(U);me=s(We,"model([input_ids, attention_mask])"),We.forEach(t),xe=s(N," or "),G=r(N,"CODE",{});var Ze=a(G);ue=s(Ze,"model([input_ids, attention_mask, token_type_ids])"),Ze.forEach(t),N.forEach(t),Be=h(L),I=r(L,"LI",{});var Ce=a(I);te=s(Ce,`a dictionary with one or several input Tensors associated to the input names given in the docstring:
`),K=r(Ce,"CODE",{});var Ue=a(K);ee=s(Ue,'model({"input_ids": input_ids, "token_type_ids": token_type_ids})'),Ue.forEach(t),Ce.forEach(t),L.forEach(t),ne=h(k),j=r(k,"P",{});var ae=a(j);Me=s(ae,`Note that when creating models and layers with
`),P=r(ae,"A",{href:!0,rel:!0});var et=a(P);ge=s(et,"subclassing"),et.forEach(t),ze=s(ae,` 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!`),ae.forEach(t),this.h()},h(){c(P,"href","https://keras.io/guides/making_new_layers_and_models_via_subclassing/"),c(P,"rel","nofollow")},m(k,M){g(k,d,M),e(d,v),e(d,f),e(f,m),e(d,b),g(k,l,M),g(k,u,M),e(u,B),e(B,we),e(u,_e),e(u,S),e(S,ce),g(k,Z,M),g(k,E,M),e(E,Te),e(E,W),e(W,pe),e(E,Ae),e(E,J),e(J,oe),e(E,ie),e(E,Q),e(Q,le),e(E,ye),e(E,H),e(H,$e),e(E,be),e(E,O),e(O,Fe),e(E,de),g(k,se,M),g(k,C,M),e(C,A),e(A,De),e(A,X),e(X,fe),e(A,Ee),e(A,Y),e(Y,ve),e(C,he),e(C,q),e(q,ke),e(q,U),e(U,me),e(q,xe),e(q,G),e(G,ue),e(C,Be),e(C,I),e(I,te),e(I,K),e(K,ee),g(k,ne,M),g(k,j,M),e(j,Me),e(j,P),e(P,ge),e(j,ze)},d(k){k&&t(d),k&&t(l),k&&t(u),k&&t(Z),k&&t(E),k&&t(se),k&&t(C),k&&t(ne),k&&t(j)}}}function M3(x){let d,v,f,m,b;return{c(){d=n("p"),v=o("Although the recipe for forward pass needs to be defined within this function, one should call the "),f=n("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=r(l,"P",{});var u=a(d);v=s(u,"Although the recipe for forward pass needs to be defined within this function, one should call the "),f=r(u,"CODE",{});var B=a(f);m=s(B,"Module"),B.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,v),e(d,f),e(f,m),e(d,b)},d(l){l&&t(d)}}}function z3(x){let d,v,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=n("p"),v=o("Example:"),f=p(),w(m.$$.fragment)},l(l){d=r(l,"P",{});var u=a(d);v=s(u,"Example:"),u.forEach(t),f=h(l),T(m.$$.fragment,l)},m(l,u){g(l,d,u),e(d,v),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,v,f,m,b,l,u,B,we,_e,S,ce,Z,E,Te,W,pe,Ae,J,oe,ie,Q,le,ye,H,$e,be,O,Fe,de,se,C,A,De,X,fe,Ee,Y,ve,he,q,ke,U,me,xe,G,ue,Be,I,te,K,ee,ne,j,Me,P,ge,ze;return{c(){d=n("p"),v=o("TensorFlow models and layers in "),f=n("code"),m=o("transformers"),b=o(" accept two formats as input:"),l=p(),u=n("ul"),B=n("li"),we=o("having all inputs as keyword arguments (like PyTorch models), or"),_e=p(),S=n("li"),ce=o("having all inputs as a list, tuple or dict in the first positional argument."),Z=p(),E=n("p"),Te=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 `),W=n("code"),pe=o("model.fit()"),Ae=o(` things should \u201Cjust work\u201D for you - just
pass your inputs and labels in any format that `),J=n("code"),oe=o("model.fit()"),ie=o(` supports! If, however, you want to use the second
format outside of Keras methods like `),Q=n("code"),le=o("fit()"),ye=o(" and "),H=n("code"),$e=o("predict()"),be=o(`, such as when creating your own layers or models with
the Keras `),O=n("code"),Fe=o("Functional"),de=o(` API, there are three possibilities you can use to gather all the input Tensors in the first
positional argument:`),se=p(),C=n("ul"),A=n("li"),De=o("a single Tensor with "),X=n("code"),fe=o("input_ids"),Ee=o(" only and nothing else: "),Y=n("code"),ve=o("model(input_ids)"),he=p(),q=n("li"),ke=o(`a list of varying length with one or several input Tensors IN THE ORDER given in the docstring:
`),U=n("code"),me=o("model([input_ids, attention_mask])"),xe=o(" or "),G=n("code"),ue=o("model([input_ids, attention_mask, token_type_ids])"),Be=p(),I=n("li"),te=o(`a dictionary with one or several input Tensors associated to the input names given in the docstring:
`),K=n("code"),ee=o('model({"input_ids": input_ids, "token_type_ids": token_type_ids})'),ne=p(),j=n("p"),Me=o(`Note that when creating models and layers with
`),P=n("a"),ge=o("subclassing"),ze=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(k){d=r(k,"P",{});var M=a(d);v=s(M,"TensorFlow models and layers in "),f=r(M,"CODE",{});var Qe=a(f);m=s(Qe,"transformers"),Qe.forEach(t),b=s(M," accept two formats as input:"),M.forEach(t),l=h(k),u=r(k,"UL",{});var re=a(u);B=r(re,"LI",{});var He=a(B);we=s(He,"having all inputs as keyword arguments (like PyTorch models), or"),He.forEach(t),_e=h(re),S=r(re,"LI",{});var Ne=a(S);ce=s(Ne,"having all inputs as a list, tuple or dict in the first positional argument."),Ne.forEach(t),re.forEach(t),Z=h(k),E=r(k,"P",{});var z=a(E);Te=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 `),W=r(z,"CODE",{});var Ke=a(W);pe=s(Ke,"model.fit()"),Ke.forEach(t),Ae=s(z,` things should \u201Cjust work\u201D for you - just
pass your inputs and labels in any format that `),J=r(z,"CODE",{});var Re=a(J);oe=s(Re,"model.fit()"),Re.forEach(t),ie=s(z,` supports! If, however, you want to use the second
format outside of Keras methods like `),Q=r(z,"CODE",{});var Ve=a(Q);le=s(Ve,"fit()"),Ve.forEach(t),ye=s(z," and "),H=r(z,"CODE",{});var Je=a(H);$e=s(Je,"predict()"),Je.forEach(t),be=s(z,`, such as when creating your own layers or models with
the Keras `),O=r(z,"CODE",{});var Ge=a(O);Fe=s(Ge,"Functional"),Ge.forEach(t),de=s(z,` API, there are three possibilities you can use to gather all the input Tensors in the first
positional argument:`),z.forEach(t),se=h(k),C=r(k,"UL",{});var L=a(C);A=r(L,"LI",{});var V=a(A);De=s(V,"a single Tensor with "),X=r(V,"CODE",{});var Xe=a(X);fe=s(Xe,"input_ids"),Xe.forEach(t),Ee=s(V," only and nothing else: "),Y=r(V,"CODE",{});var Ye=a(Y);ve=s(Ye,"model(input_ids)"),Ye.forEach(t),V.forEach(t),he=h(L),q=r(L,"LI",{});var N=a(q);ke=s(N,`a list of varying length with one or several input Tensors IN THE ORDER given in the docstring:
`),U=r(N,"CODE",{});var We=a(U);me=s(We,"model([input_ids, attention_mask])"),We.forEach(t),xe=s(N," or "),G=r(N,"CODE",{});var Ze=a(G);ue=s(Ze,"model([input_ids, attention_mask, token_type_ids])"),Ze.forEach(t),N.forEach(t),Be=h(L),I=r(L,"LI",{});var Ce=a(I);te=s(Ce,`a dictionary with one or several input Tensors associated to the input names given in the docstring:
`),K=r(Ce,"CODE",{});var Ue=a(K);ee=s(Ue,'model({"input_ids": input_ids, "token_type_ids": token_type_ids})'),Ue.forEach(t),Ce.forEach(t),L.forEach(t),ne=h(k),j=r(k,"P",{});var ae=a(j);Me=s(ae,`Note that when creating models and layers with
`),P=r(ae,"A",{href:!0,rel:!0});var et=a(P);ge=s(et,"subclassing"),et.forEach(t),ze=s(ae,` 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!`),ae.forEach(t),this.h()},h(){c(P,"href","https://keras.io/guides/making_new_layers_and_models_via_subclassing/"),c(P,"rel","nofollow")},m(k,M){g(k,d,M),e(d,v),e(d,f),e(f,m),e(d,b),g(k,l,M),g(k,u,M),e(u,B),e(B,we),e(u,_e),e(u,S),e(S,ce),g(k,Z,M),g(k,E,M),e(E,Te),e(E,W),e(W,pe),e(E,Ae),e(E,J),e(J,oe),e(E,ie),e(E,Q),e(Q,le),e(E,ye),e(E,H),e(H,$e),e(E,be),e(E,O),e(O,Fe),e(E,de),g(k,se,M),g(k,C,M),e(C,A),e(A,De),e(A,X),e(X,fe),e(A,Ee),e(A,Y),e(Y,ve),e(C,he),e(C,q),e(q,ke),e(q,U),e(U,me),e(q,xe),e(q,G),e(G,ue),e(C,Be),e(C,I),e(I,te),e(I,K),e(K,ee),g(k,ne,M),g(k,j,M),e(j,Me),e(j,P),e(P,ge),e(j,ze)},d(k){k&&t(d),k&&t(l),k&&t(u),k&&t(Z),k&&t(E),k&&t(se),k&&t(C),k&&t(ne),k&&t(j)}}}function A3(x){let d,v,f,m,b;return{c(){d=n("p"),v=o("Although the recipe for forward pass needs to be defined within this function, one should call the "),f=n("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=r(l,"P",{});var u=a(d);v=s(u,"Although the recipe for forward pass needs to be defined within this function, one should call the "),f=r(u,"CODE",{});var B=a(f);m=s(B,"Module"),B.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,v),e(d,f),e(f,m),e(d,b)},d(l){l&&t(d)}}}function j3(x){let d,v,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=n("p"),v=o("Example:"),f=p(),w(m.$$.fragment)},l(l){d=r(l,"P",{});var u=a(d);v=s(u,"Example:"),u.forEach(t),f=h(l),T(m.$$.fragment,l)},m(l,u){g(l,d,u),e(d,v),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 q3(x){let d,v;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),v=!0},p:Pe,i(f){v||($(d.$$.fragment,f),v=!0)},o(f){F(d.$$.fragment,f),v=!1},d(f){D(d,f)}}}function P3(x){let d,v,f,m,b,l,u,B,we,_e,S,ce,Z,E,Te,W,pe,Ae,J,oe,ie,Q,le,ye,H,$e,be,O,Fe,de,se,C,A,De,X,fe,Ee,Y,ve,he,q,ke,U,me,xe,G,ue,Be,I,te,K,ee,ne,j,Me,P,ge,ze;return{c(){d=n("p"),v=o("TensorFlow models and layers in "),f=n("code"),m=o("transformers"),b=o(" accept two formats as input:"),l=p(),u=n("ul"),B=n("li"),we=o("having all inputs as keyword arguments (like PyTorch models), or"),_e=p(),S=n("li"),ce=o("having all inputs as a list, tuple or dict in the first positional argument."),Z=p(),E=n("p"),Te=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 `),W=n("code"),pe=o("model.fit()"),Ae=o(` things should \u201Cjust work\u201D for you - just
pass your inputs and labels in any format that `),J=n("code"),oe=o("model.fit()"),ie=o(` supports! If, however, you want to use the second
format outside of Keras methods like `),Q=n("code"),le=o("fit()"),ye=o(" and "),H=n("code"),$e=o("predict()"),be=o(`, such as when creating your own layers or models with
the Keras `),O=n("code"),Fe=o("Functional"),de=o(` API, there are three possibilities you can use to gather all the input Tensors in the first
positional argument:`),se=p(),C=n("ul"),A=n("li"),De=o("a single Tensor with "),X=n("code"),fe=o("input_ids"),Ee=o(" only and nothing else: "),Y=n("code"),ve=o("model(input_ids)"),he=p(),q=n("li"),ke=o(`a list of varying length with one or several input Tensors IN THE ORDER given in the docstring:
`),U=n("code"),me=o("model([input_ids, attention_mask])"),xe=o(" or "),G=n("code"),ue=o("model([input_ids, attention_mask, token_type_ids])"),Be=p(),I=n("li"),te=o(`a dictionary with one or several input Tensors associated to the input names given in the docstring:
`),K=n("code"),ee=o('model({"input_ids": input_ids, "token_type_ids": token_type_ids})'),ne=p(),j=n("p"),Me=o(`Note that when creating models and layers with
`),P=n("a"),ge=o("subclassing"),ze=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(k){d=r(k,"P",{});var M=a(d);v=s(M,"TensorFlow models and layers in "),f=r(M,"CODE",{});var Qe=a(f);m=s(Qe,"transformers"),Qe.forEach(t),b=s(M," accept two formats as input:"),M.forEach(t),l=h(k),u=r(k,"UL",{});var re=a(u);B=r(re,"LI",{});var He=a(B);we=s(He,"having all inputs as keyword arguments (like PyTorch models), or"),He.forEach(t),_e=h(re),S=r(re,"LI",{});var Ne=a(S);ce=s(Ne,"having all inputs as a list, tuple or dict in the first positional argument."),Ne.forEach(t),re.forEach(t),Z=h(k),E=r(k,"P",{});var z=a(E);Te=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 `),W=r(z,"CODE",{});var Ke=a(W);pe=s(Ke,"model.fit()"),Ke.forEach(t),Ae=s(z,` things should \u201Cjust work\u201D for you - just
pass your inputs and labels in any format that `),J=r(z,"CODE",{});var Re=a(J);oe=s(Re,"model.fit()"),Re.forEach(t),ie=s(z,` supports! If, however, you want to use the second
format outside of Keras methods like `),Q=r(z,"CODE",{});var Ve=a(Q);le=s(Ve,"fit()"),Ve.forEach(t),ye=s(z," and "),H=r(z,"CODE",{});var Je=a(H);$e=s(Je,"predict()"),Je.forEach(t),be=s(z,`, such as when creating your own layers or models with
the Keras `),O=r(z,"CODE",{});var Ge=a(O);Fe=s(Ge,"Functional"),Ge.forEach(t),de=s(z,` API, there are three possibilities you can use to gather all the input Tensors in the first
positional argument:`),z.forEach(t),se=h(k),C=r(k,"UL",{});var L=a(C);A=r(L,"LI",{});var V=a(A);De=s(V,"a single Tensor with "),X=r(V,"CODE",{});var Xe=a(X);fe=s(Xe,"input_ids"),Xe.forEach(t),Ee=s(V," only and nothing else: "),Y=r(V,"CODE",{});var Ye=a(Y);ve=s(Ye,"model(input_ids)"),Ye.forEach(t),V.forEach(t),he=h(L),q=r(L,"LI",{});var N=a(q);ke=s(N,`a list of varying length with one or several input Tensors IN THE ORDER given in the docstring:
`),U=r(N,"CODE",{});var We=a(U);me=s(We,"model([input_ids, attention_mask])"),We.forEach(t),xe=s(N," or "),G=r(N,"CODE",{});var Ze=a(G);ue=s(Ze,"model([input_ids, attention_mask, token_type_ids])"),Ze.forEach(t),N.forEach(t),Be=h(L),I=r(L,"LI",{});var Ce=a(I);te=s(Ce,`a dictionary with one or several input Tensors associated to the input names given in the docstring:
`),K=r(Ce,"CODE",{});var Ue=a(K);ee=s(Ue,'model({"input_ids": input_ids, "token_type_ids": token_type_ids})'),Ue.forEach(t),Ce.forEach(t),L.forEach(t),ne=h(k),j=r(k,"P",{});var ae=a(j);Me=s(ae,`Note that when creating models and layers with
`),P=r(ae,"A",{href:!0,rel:!0});var et=a(P);ge=s(et,"subclassing"),et.forEach(t),ze=s(ae,` 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!`),ae.forEach(t),this.h()},h(){c(P,"href","https://keras.io/guides/making_new_layers_and_models_via_subclassing/"),c(P,"rel","nofollow")},m(k,M){g(k,d,M),e(d,v),e(d,f),e(f,m),e(d,b),g(k,l,M),g(k,u,M),e(u,B),e(B,we),e(u,_e),e(u,S),e(S,ce),g(k,Z,M),g(k,E,M),e(E,Te),e(E,W),e(W,pe),e(E,Ae),e(E,J),e(J,oe),e(E,ie),e(E,Q),e(Q,le),e(E,ye),e(E,H),e(H,$e),e(E,be),e(E,O),e(O,Fe),e(E,de),g(k,se,M),g(k,C,M),e(C,A),e(A,De),e(A,X),e(X,fe),e(A,Ee),e(A,Y),e(Y,ve),e(C,he),e(C,q),e(q,ke),e(q,U),e(U,me),e(q,xe),e(q,G),e(G,ue),e(C,Be),e(C,I),e(I,te),e(I,K),e(K,ee),g(k,ne,M),g(k,j,M),e(j,Me),e(j,P),e(P,ge),e(j,ze)},d(k){k&&t(d),k&&t(l),k&&t(u),k&&t(Z),k&&t(E),k&&t(se),k&&t(C),k&&t(ne),k&&t(j)}}}function L3(x){let d,v,f,m,b;return{c(){d=n("p"),v=o("Although the recipe for forward pass needs to be defined within this function, one should call the "),f=n("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=r(l,"P",{});var u=a(d);v=s(u,"Although the recipe for forward pass needs to be defined within this function, one should call the "),f=r(u,"CODE",{});var B=a(f);m=s(B,"Module"),B.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,v),e(d,f),e(f,m),e(d,b)},d(l){l&&t(d)}}}function O3(x){let d,v,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=n("p"),v=o("Example:"),f=p(),w(m.$$.fragment)},l(l){d=r(l,"P",{});var u=a(d);v=s(u,"Example:"),u.forEach(t),f=h(l),T(m.$$.fragment,l)},m(l,u){g(l,d,u),e(d,v),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,v;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),v=!0},p:Pe,i(f){v||($(d.$$.fragment,f),v=!0)},o(f){F(d.$$.fragment,f),v=!1},d(f){D(d,f)}}}function S3(x){let d,v,f,m,b,l,u,B,we,_e,S,ce,Z,E,Te,W,pe,Ae,J,oe,ie,Q,le,ye,H,$e,be,O,Fe,de,se,C,A,De,X,fe,Ee,Y,ve,he,q,ke,U,me,xe,G,ue,Be,I,te,K,ee,ne,j,Me,P,ge,ze;return{c(){d=n("p"),v=o("TensorFlow models and layers in "),f=n("code"),m=o("transformers"),b=o(" accept two formats as input:"),l=p(),u=n("ul"),B=n("li"),we=o("having all inputs as keyword arguments (like PyTorch models), or"),_e=p(),S=n("li"),ce=o("having all inputs as a list, tuple or dict in the first positional argument."),Z=p(),E=n("p"),Te=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 `),W=n("code"),pe=o("model.fit()"),Ae=o(` things should \u201Cjust work\u201D for you - just
pass your inputs and labels in any format that `),J=n("code"),oe=o("model.fit()"),ie=o(` supports! If, however, you want to use the second
format outside of Keras methods like `),Q=n("code"),le=o("fit()"),ye=o(" and "),H=n("code"),$e=o("predict()"),be=o(`, such as when creating your own layers or models with
the Keras `),O=n("code"),Fe=o("Functional"),de=o(` API, there are three possibilities you can use to gather all the input Tensors in the first
positional argument:`),se=p(),C=n("ul"),A=n("li"),De=o("a single Tensor with "),X=n("code"),fe=o("input_ids"),Ee=o(" only and nothing else: "),Y=n("code"),ve=o("model(input_ids)"),he=p(),q=n("li"),ke=o(`a list of varying length with one or several input Tensors IN THE ORDER given in the docstring:
`),U=n("code"),me=o("model([input_ids, attention_mask])"),xe=o(" or "),G=n("code"),ue=o("model([input_ids, attention_mask, token_type_ids])"),Be=p(),I=n("li"),te=o(`a dictionary with one or several input Tensors associated to the input names given in the docstring:
`),K=n("code"),ee=o('model({"input_ids": input_ids, "token_type_ids": token_type_ids})'),ne=p(),j=n("p"),Me=o(`Note that when creating models and layers with
`),P=n("a"),ge=o("subclassing"),ze=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(k){d=r(k,"P",{});var M=a(d);v=s(M,"TensorFlow models and layers in "),f=r(M,"CODE",{});var Qe=a(f);m=s(Qe,"transformers"),Qe.forEach(t),b=s(M," accept two formats as input:"),M.forEach(t),l=h(k),u=r(k,"UL",{});var re=a(u);B=r(re,"LI",{});var He=a(B);we=s(He,"having all inputs as keyword arguments (like PyTorch models), or"),He.forEach(t),_e=h(re),S=r(re,"LI",{});var Ne=a(S);ce=s(Ne,"having all inputs as a list, tuple or dict in the first positional argument."),Ne.forEach(t),re.forEach(t),Z=h(k),E=r(k,"P",{});var z=a(E);Te=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 `),W=r(z,"CODE",{});var Ke=a(W);pe=s(Ke,"model.fit()"),Ke.forEach(t),Ae=s(z,` things should \u201Cjust work\u201D for you - just
pass your inputs and labels in any format that `),J=r(z,"CODE",{});var Re=a(J);oe=s(Re,"model.fit()"),Re.forEach(t),ie=s(z,` supports! If, however, you want to use the second
format outside of Keras methods like `),Q=r(z,"CODE",{});var Ve=a(Q);le=s(Ve,"fit()"),Ve.forEach(t),ye=s(z," and "),H=r(z,"CODE",{});var Je=a(H);$e=s(Je,"predict()"),Je.forEach(t),be=s(z,`, such as when creating your own layers or models with
the Keras `),O=r(z,"CODE",{});var Ge=a(O);Fe=s(Ge,"Functional"),Ge.forEach(t),de=s(z,` API, there are three possibilities you can use to gather all the input Tensors in the first
positional argument:`),z.forEach(t),se=h(k),C=r(k,"UL",{});var L=a(C);A=r(L,"LI",{});var V=a(A);De=s(V,"a single Tensor with "),X=r(V,"CODE",{});var Xe=a(X);fe=s(Xe,"input_ids"),Xe.forEach(t),Ee=s(V," only and nothing else: "),Y=r(V,"CODE",{});var Ye=a(Y);ve=s(Ye,"model(input_ids)"),Ye.forEach(t),V.forEach(t),he=h(L),q=r(L,"LI",{});var N=a(q);ke=s(N,`a list of varying length with one or several input Tensors IN THE ORDER given in the docstring:
`),U=r(N,"CODE",{});var We=a(U);me=s(We,"model([input_ids, attention_mask])"),We.forEach(t),xe=s(N," or "),G=r(N,"CODE",{});var Ze=a(G);ue=s(Ze,"model([input_ids, attention_mask, token_type_ids])"),Ze.forEach(t),N.forEach(t),Be=h(L),I=r(L,"LI",{});var Ce=a(I);te=s(Ce,`a dictionary with one or several input Tensors associated to the input names given in the docstring:
`),K=r(Ce,"CODE",{});var Ue=a(K);ee=s(Ue,'model({"input_ids": input_ids, "token_type_ids": token_type_ids})'),Ue.forEach(t),Ce.forEach(t),L.forEach(t),ne=h(k),j=r(k,"P",{});var ae=a(j);Me=s(ae,`Note that when creating models and layers with
`),P=r(ae,"A",{href:!0,rel:!0});var et=a(P);ge=s(et,"subclassing"),et.forEach(t),ze=s(ae,` 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!`),ae.forEach(t),this.h()},h(){c(P,"href","https://keras.io/guides/making_new_layers_and_models_via_subclassing/"),c(P,"rel","nofollow")},m(k,M){g(k,d,M),e(d,v),e(d,f),e(f,m),e(d,b),g(k,l,M),g(k,u,M),e(u,B),e(B,we),e(u,_e),e(u,S),e(S,ce),g(k,Z,M),g(k,E,M),e(E,Te),e(E,W),e(W,pe),e(E,Ae),e(E,J),e(J,oe),e(E,ie),e(E,Q),e(Q,le),e(E,ye),e(E,H),e(H,$e),e(E,be),e(E,O),e(O,Fe),e(E,de),g(k,se,M),g(k,C,M),e(C,A),e(A,De),e(A,X),e(X,fe),e(A,Ee),e(A,Y),e(Y,ve),e(C,he),e(C,q),e(q,ke),e(q,U),e(U,me),e(q,xe),e(q,G),e(G,ue),e(C,Be),e(C,I),e(I,te),e(I,K),e(K,ee),g(k,ne,M),g(k,j,M),e(j,Me),e(j,P),e(P,ge),e(j,ze)},d(k){k&&t(d),k&&t(l),k&&t(u),k&&t(Z),k&&t(E),k&&t(se),k&&t(C),k&&t(ne),k&&t(j)}}}function N3(x){let d,v,f,m,b;return{c(){d=n("p"),v=o("Although the recipe for forward pass needs to be defined within this function, one should call the "),f=n("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=r(l,"P",{});var u=a(d);v=s(u,"Although the recipe for forward pass needs to be defined within this function, one should call the "),f=r(u,"CODE",{});var B=a(f);m=s(B,"Module"),B.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,v),e(d,f),e(f,m),e(d,b)},d(l){l&&t(d)}}}function R3(x){let d,v,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=n("p"),v=o("Example:"),f=p(),w(m.$$.fragment)},l(l){d=r(l,"P",{});var u=a(d);v=s(u,"Example:"),u.forEach(t),f=h(l),T(m.$$.fragment,l)},m(l,u){g(l,d,u),e(d,v),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 W3(x){let d,v,f,m,b,l,u,B,we,_e,S,ce,Z,E,Te,W,pe,Ae,J,oe,ie,Q,le,ye,H,$e,be,O,Fe,de,se,C,A,De,X,fe,Ee,Y,ve,he,q,ke,U,me,xe,G,ue,Be,I,te,K,ee,ne,j,Me,P,ge,ze;return{c(){d=n("p"),v=o("TensorFlow models and layers in "),f=n("code"),m=o("transformers"),b=o(" accept two formats as input:"),l=p(),u=n("ul"),B=n("li"),we=o("having all inputs as keyword arguments (like PyTorch models), or"),_e=p(),S=n("li"),ce=o("having all inputs as a list, tuple or dict in the first positional argument."),Z=p(),E=n("p"),Te=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 `),W=n("code"),pe=o("model.fit()"),Ae=o(` things should \u201Cjust work\u201D for you - just
pass your inputs and labels in any format that `),J=n("code"),oe=o("model.fit()"),ie=o(` supports! If, however, you want to use the second
format outside of Keras methods like `),Q=n("code"),le=o("fit()"),ye=o(" and "),H=n("code"),$e=o("predict()"),be=o(`, such as when creating your own layers or models with
the Keras `),O=n("code"),Fe=o("Functional"),de=o(` API, there are three possibilities you can use to gather all the input Tensors in the first
positional argument:`),se=p(),C=n("ul"),A=n("li"),De=o("a single Tensor with "),X=n("code"),fe=o("input_ids"),Ee=o(" only and nothing else: "),Y=n("code"),ve=o("model(input_ids)"),he=p(),q=n("li"),ke=o(`a list of varying length with one or several input Tensors IN THE ORDER given in the docstring:
`),U=n("code"),me=o("model([input_ids, attention_mask])"),xe=o(" or "),G=n("code"),ue=o("model([input_ids, attention_mask, token_type_ids])"),Be=p(),I=n("li"),te=o(`a dictionary with one or several input Tensors associated to the input names given in the docstring:
`),K=n("code"),ee=o('model({"input_ids": input_ids, "token_type_ids": token_type_ids})'),ne=p(),j=n("p"),Me=o(`Note that when creating models and layers with
`),P=n("a"),ge=o("subclassing"),ze=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(k){d=r(k,"P",{});var M=a(d);v=s(M,"TensorFlow models and layers in "),f=r(M,"CODE",{});var Qe=a(f);m=s(Qe,"transformers"),Qe.forEach(t),b=s(M," accept two formats as input:"),M.forEach(t),l=h(k),u=r(k,"UL",{});var re=a(u);B=r(re,"LI",{});var He=a(B);we=s(He,"having all inputs as keyword arguments (like PyTorch models), or"),He.forEach(t),_e=h(re),S=r(re,"LI",{});var Ne=a(S);ce=s(Ne,"having all inputs as a list, tuple or dict in the first positional argument."),Ne.forEach(t),re.forEach(t),Z=h(k),E=r(k,"P",{});var z=a(E);Te=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 `),W=r(z,"CODE",{});var Ke=a(W);pe=s(Ke,"model.fit()"),Ke.forEach(t),Ae=s(z,` things should \u201Cjust work\u201D for you - just
pass your inputs and labels in any format that `),J=r(z,"CODE",{});var Re=a(J);oe=s(Re,"model.fit()"),Re.forEach(t),ie=s(z,` supports! If, however, you want to use the second
format outside of Keras methods like `),Q=r(z,"CODE",{});var Ve=a(Q);le=s(Ve,"fit()"),Ve.forEach(t),ye=s(z," and "),H=r(z,"CODE",{});var Je=a(H);$e=s(Je,"predict()"),Je.forEach(t),be=s(z,`, such as when creating your own layers or models with
the Keras `),O=r(z,"CODE",{});var Ge=a(O);Fe=s(Ge,"Functional"),Ge.forEach(t),de=s(z,` API, there are three possibilities you can use to gather all the input Tensors in the first
positional argument:`),z.forEach(t),se=h(k),C=r(k,"UL",{});var L=a(C);A=r(L,"LI",{});var V=a(A);De=s(V,"a single Tensor with "),X=r(V,"CODE",{});var Xe=a(X);fe=s(Xe,"input_ids"),Xe.forEach(t),Ee=s(V," only and nothing else: "),Y=r(V,"CODE",{});var Ye=a(Y);ve=s(Ye,"model(input_ids)"),Ye.forEach(t),V.forEach(t),he=h(L),q=r(L,"LI",{});var N=a(q);ke=s(N,`a list of varying length with one or several input Tensors IN THE ORDER given in the docstring:
`),U=r(N,"CODE",{});var We=a(U);me=s(We,"model([input_ids, attention_mask])"),We.forEach(t),xe=s(N," or "),G=r(N,"CODE",{});var Ze=a(G);ue=s(Ze,"model([input_ids, attention_mask, token_type_ids])"),Ze.forEach(t),N.forEach(t),Be=h(L),I=r(L,"LI",{});var Ce=a(I);te=s(Ce,`a dictionary with one or several input Tensors associated to the input names given in the docstring:
`),K=r(Ce,"CODE",{});var Ue=a(K);ee=s(Ue,'model({"input_ids": input_ids, "token_type_ids": token_type_ids})'),Ue.forEach(t),Ce.forEach(t),L.forEach(t),ne=h(k),j=r(k,"P",{});var ae=a(j);Me=s(ae,`Note that when creating models and layers with
`),P=r(ae,"A",{href:!0,rel:!0});var et=a(P);ge=s(et,"subclassing"),et.forEach(t),ze=s(ae,` 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!`),ae.forEach(t),this.h()},h(){c(P,"href","https://keras.io/guides/making_new_layers_and_models_via_subclassing/"),c(P,"rel","nofollow")},m(k,M){g(k,d,M),e(d,v),e(d,f),e(f,m),e(d,b),g(k,l,M),g(k,u,M),e(u,B),e(B,we),e(u,_e),e(u,S),e(S,ce),g(k,Z,M),g(k,E,M),e(E,Te),e(E,W),e(W,pe),e(E,Ae),e(E,J),e(J,oe),e(E,ie),e(E,Q),e(Q,le),e(E,ye),e(E,H),e(H,$e),e(E,be),e(E,O),e(O,Fe),e(E,de),g(k,se,M),g(k,C,M),e(C,A),e(A,De),e(A,X),e(X,fe),e(A,Ee),e(A,Y),e(Y,ve),e(C,he),e(C,q),e(q,ke),e(q,U),e(U,me),e(q,xe),e(q,G),e(G,ue),e(C,Be),e(C,I),e(I,te),e(I,K),e(K,ee),g(k,ne,M),g(k,j,M),e(j,Me),e(j,P),e(P,ge),e(j,ze)},d(k){k&&t(d),k&&t(l),k&&t(u),k&&t(Z),k&&t(E),k&&t(se),k&&t(C),k&&t(ne),k&&t(j)}}}function U3(x){let d,v,f,m,b;return{c(){d=n("p"),v=o("Although the recipe for forward pass needs to be defined within this function, one should call the "),f=n("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=r(l,"P",{});var u=a(d);v=s(u,"Although the recipe for forward pass needs to be defined within this function, one should call the "),f=r(u,"CODE",{});var B=a(f);m=s(B,"Module"),B.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,v),e(d,f),e(f,m),e(d,b)},d(l){l&&t(d)}}}function Q3(x){let d,v,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=n("p"),v=o("Example:"),f=p(),w(m.$$.fragment)},l(l){d=r(l,"P",{});var u=a(d);v=s(u,"Example:"),u.forEach(t),f=h(l),T(m.$$.fragment,l)},m(l,u){g(l,d,u),e(d,v),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,v;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),v=!0},p:Pe,i(f){v||($(d.$$.fragment,f),v=!0)},o(f){F(d.$$.fragment,f),v=!1},d(f){D(d,f)}}}function K3(x){let d,v,f,m,b,l,u,B,we,_e,S,ce,Z,E,Te,W,pe,Ae,J,oe,ie,Q,le,ye,H,$e,be,O,Fe,de,se,C,A,De,X,fe,Ee,Y,ve,he,q,ke,U,me,xe,G,ue,Be,I,te,K,ee,ne,j,Me,P,ge,ze;return{c(){d=n("p"),v=o("TensorFlow models and layers in "),f=n("code"),m=o("transformers"),b=o(" accept two formats as input:"),l=p(),u=n("ul"),B=n("li"),we=o("having all inputs as keyword arguments (like PyTorch models), or"),_e=p(),S=n("li"),ce=o("having all inputs as a list, tuple or dict in the first positional argument."),Z=p(),E=n("p"),Te=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 `),W=n("code"),pe=o("model.fit()"),Ae=o(` things should \u201Cjust work\u201D for you - just
pass your inputs and labels in any format that `),J=n("code"),oe=o("model.fit()"),ie=o(` supports! If, however, you want to use the second
format outside of Keras methods like `),Q=n("code"),le=o("fit()"),ye=o(" and "),H=n("code"),$e=o("predict()"),be=o(`, such as when creating your own layers or models with
the Keras `),O=n("code"),Fe=o("Functional"),de=o(` API, there are three possibilities you can use to gather all the input Tensors in the first
positional argument:`),se=p(),C=n("ul"),A=n("li"),De=o("a single Tensor with "),X=n("code"),fe=o("input_ids"),Ee=o(" only and nothing else: "),Y=n("code"),ve=o("model(input_ids)"),he=p(),q=n("li"),ke=o(`a list of varying length with one or several input Tensors IN THE ORDER given in the docstring:
`),U=n("code"),me=o("model([input_ids, attention_mask])"),xe=o(" or "),G=n("code"),ue=o("model([input_ids, attention_mask, token_type_ids])"),Be=p(),I=n("li"),te=o(`a dictionary with one or several input Tensors associated to the input names given in the docstring:
`),K=n("code"),ee=o('model({"input_ids": input_ids, "token_type_ids": token_type_ids})'),ne=p(),j=n("p"),Me=o(`Note that when creating models and layers with
`),P=n("a"),ge=o("subclassing"),ze=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(k){d=r(k,"P",{});var M=a(d);v=s(M,"TensorFlow models and layers in "),f=r(M,"CODE",{});var Qe=a(f);m=s(Qe,"transformers"),Qe.forEach(t),b=s(M," accept two formats as input:"),M.forEach(t),l=h(k),u=r(k,"UL",{});var re=a(u);B=r(re,"LI",{});var He=a(B);we=s(He,"having all inputs as keyword arguments (like PyTorch models), or"),He.forEach(t),_e=h(re),S=r(re,"LI",{});var Ne=a(S);ce=s(Ne,"having all inputs as a list, tuple or dict in the first positional argument."),Ne.forEach(t),re.forEach(t),Z=h(k),E=r(k,"P",{});var z=a(E);Te=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 `),W=r(z,"CODE",{});var Ke=a(W);pe=s(Ke,"model.fit()"),Ke.forEach(t),Ae=s(z,` things should \u201Cjust work\u201D for you - just
pass your inputs and labels in any format that `),J=r(z,"CODE",{});var Re=a(J);oe=s(Re,"model.fit()"),Re.forEach(t),ie=s(z,` supports! If, however, you want to use the second
format outside of Keras methods like `),Q=r(z,"CODE",{});var Ve=a(Q);le=s(Ve,"fit()"),Ve.forEach(t),ye=s(z," and "),H=r(z,"CODE",{});var Je=a(H);$e=s(Je,"predict()"),Je.forEach(t),be=s(z,`, such as when creating your own layers or models with
the Keras `),O=r(z,"CODE",{});var Ge=a(O);Fe=s(Ge,"Functional"),Ge.forEach(t),de=s(z,` API, there are three possibilities you can use to gather all the input Tensors in the first
positional argument:`),z.forEach(t),se=h(k),C=r(k,"UL",{});var L=a(C);A=r(L,"LI",{});var V=a(A);De=s(V,"a single Tensor with "),X=r(V,"CODE",{});var Xe=a(X);fe=s(Xe,"input_ids"),Xe.forEach(t),Ee=s(V," only and nothing else: "),Y=r(V,"CODE",{});var Ye=a(Y);ve=s(Ye,"model(input_ids)"),Ye.forEach(t),V.forEach(t),he=h(L),q=r(L,"LI",{});var N=a(q);ke=s(N,`a list of varying length with one or several input Tensors IN THE ORDER given in the docstring:
`),U=r(N,"CODE",{});var We=a(U);me=s(We,"model([input_ids, attention_mask])"),We.forEach(t),xe=s(N," or "),G=r(N,"CODE",{});var Ze=a(G);ue=s(Ze,"model([input_ids, attention_mask, token_type_ids])"),Ze.forEach(t),N.forEach(t),Be=h(L),I=r(L,"LI",{});var Ce=a(I);te=s(Ce,`a dictionary with one or several input Tensors associated to the input names given in the docstring:
`),K=r(Ce,"CODE",{});var Ue=a(K);ee=s(Ue,'model({"input_ids": input_ids, "token_type_ids": token_type_ids})'),Ue.forEach(t),Ce.forEach(t),L.forEach(t),ne=h(k),j=r(k,"P",{});var ae=a(j);Me=s(ae,`Note that when creating models and layers with
`),P=r(ae,"A",{href:!0,rel:!0});var et=a(P);ge=s(et,"subclassing"),et.forEach(t),ze=s(ae,` 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!`),ae.forEach(t),this.h()},h(){c(P,"href","https://keras.io/guides/making_new_layers_and_models_via_subclassing/"),c(P,"rel","nofollow")},m(k,M){g(k,d,M),e(d,v),e(d,f),e(f,m),e(d,b),g(k,l,M),g(k,u,M),e(u,B),e(B,we),e(u,_e),e(u,S),e(S,ce),g(k,Z,M),g(k,E,M),e(E,Te),e(E,W),e(W,pe),e(E,Ae),e(E,J),e(J,oe),e(E,ie),e(E,Q),e(Q,le),e(E,ye),e(E,H),e(H,$e),e(E,be),e(E,O),e(O,Fe),e(E,de),g(k,se,M),g(k,C,M),e(C,A),e(A,De),e(A,X),e(X,fe),e(A,Ee),e(A,Y),e(Y,ve),e(C,he),e(C,q),e(q,ke),e(q,U),e(U,me),e(q,xe),e(q,G),e(G,ue),e(C,Be),e(C,I),e(I,te),e(I,K),e(K,ee),g(k,ne,M),g(k,j,M),e(j,Me),e(j,P),e(P,ge),e(j,ze)},d(k){k&&t(d),k&&t(l),k&&t(u),k&&t(Z),k&&t(E),k&&t(se),k&&t(C),k&&t(ne),k&&t(j)}}}function V3(x){let d,v,f,m,b;return{c(){d=n("p"),v=o("Although the recipe for forward pass needs to be defined within this function, one should call the "),f=n("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=r(l,"P",{});var u=a(d);v=s(u,"Although the recipe for forward pass needs to be defined within this function, one should call the "),f=r(u,"CODE",{});var B=a(f);m=s(B,"Module"),B.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,v),e(d,f),e(f,m),e(d,b)},d(l){l&&t(d)}}}function J3(x){let d,v,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=n("p"),v=o("Example:"),f=p(),w(m.$$.fragment)},l(l){d=r(l,"P",{});var u=a(d);v=s(u,"Example:"),u.forEach(t),f=h(l),T(m.$$.fragment,l)},m(l,u){g(l,d,u),e(d,v),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,v;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),v=!0},p:Pe,i(f){v||($(d.$$.fragment,f),v=!0)},o(f){F(d.$$.fragment,f),v=!1},d(f){D(d,f)}}}function X3(x){let d,v,f,m,b;return{c(){d=n("p"),v=o("Although the recipe for forward pass needs to be defined within this function, one should call the "),f=n("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=r(l,"P",{});var u=a(d);v=s(u,"Although the recipe for forward pass needs to be defined within this function, one should call the "),f=r(u,"CODE",{});var B=a(f);m=s(B,"Module"),B.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,v),e(d,f),e(f,m),e(d,b)},d(l){l&&t(d)}}}function Y3(x){let d,v,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=n("p"),v=o("Example:"),f=p(),w(m.$$.fragment)},l(l){d=r(l,"P",{});var u=a(d);v=s(u,"Example:"),u.forEach(t),f=h(l),T(m.$$.fragment,l)},m(l,u){g(l,d,u),e(d,v),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 Z3(x){let d,v,f,m,b;return{c(){d=n("p"),v=o("Although the recipe for forward pass needs to be defined within this function, one should call the "),f=n("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=r(l,"P",{});var u=a(d);v=s(u,"Although the recipe for forward pass needs to be defined within this function, one should call the "),f=r(u,"CODE",{});var B=a(f);m=s(B,"Module"),B.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,v),e(d,f),e(f,m),e(d,b)},d(l){l&&t(d)}}}function eC(x){let d,v,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=n("p"),v=o("Example:"),f=p(),w(m.$$.fragment)},l(l){d=r(l,"P",{});var u=a(d);v=s(u,"Example:"),u.forEach(t),f=h(l),T(m.$$.fragment,l)},m(l,u){g(l,d,u),e(d,v),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 tC(x){let d,v,f,m,b;return{c(){d=n("p"),v=o("Although the recipe for forward pass needs to be defined within this function, one should call the "),f=n("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=r(l,"P",{});var u=a(d);v=s(u,"Although the recipe for forward pass needs to be defined within this function, one should call the "),f=r(u,"CODE",{});var B=a(f);m=s(B,"Module"),B.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,v),e(d,f),e(f,m),e(d,b)},d(l){l&&t(d)}}}function oC(x){let d,v,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=n("p"),v=o("Example:"),f=p(),w(m.$$.fragment)},l(l){d=r(l,"P",{});var u=a(d);v=s(u,"Example:"),u.forEach(t),f=h(l),T(m.$$.fragment,l)},m(l,u){g(l,d,u),e(d,v),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 sC(x){let d,v,f,m,b;return{c(){d=n("p"),v=o("Although the recipe for forward pass needs to be defined within this function, one should call the "),f=n("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=r(l,"P",{});var u=a(d);v=s(u,"Although the recipe for forward pass needs to be defined within this function, one should call the "),f=r(u,"CODE",{});var B=a(f);m=s(B,"Module"),B.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,v),e(d,f),e(f,m),e(d,b)},d(l){l&&t(d)}}}function nC(x){let d,v,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=n("p"),v=o("Example:"),f=p(),w(m.$$.fragment)},l(l){d=r(l,"P",{});var u=a(d);v=s(u,"Example:"),u.forEach(t),f=h(l),T(m.$$.fragment,l)},m(l,u){g(l,d,u),e(d,v),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 rC(x){let d,v,f,m,b;return{c(){d=n("p"),v=o("Although the recipe for forward pass needs to be defined within this function, one should call the "),f=n("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=r(l,"P",{});var u=a(d);v=s(u,"Although the recipe for forward pass needs to be defined within this function, one should call the "),f=r(u,"CODE",{});var B=a(f);m=s(B,"Module"),B.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,v),e(d,f),e(f,m),e(d,b)},d(l){l&&t(d)}}}function aC(x){let d,v,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=n("p"),v=o("Example:"),f=p(),w(m.$$.fragment)},l(l){d=r(l,"P",{});var u=a(d);v=s(u,"Example:"),u.forEach(t),f=h(l),T(m.$$.fragment,l)},m(l,u){g(l,d,u),e(d,v),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 iC(x){let d,v,f,m,b;return{c(){d=n("p"),v=o("Although the recipe for forward pass needs to be defined within this function, one should call the "),f=n("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=r(l,"P",{});var u=a(d);v=s(u,"Although the recipe for forward pass needs to be defined within this function, one should call the "),f=r(u,"CODE",{});var B=a(f);m=s(B,"Module"),B.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,v),e(d,f),e(f,m),e(d,b)},d(l){l&&t(d)}}}function lC(x){let d,v,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=n("p"),v=o("Example:"),f=p(),w(m.$$.fragment)},l(l){d=r(l,"P",{});var u=a(d);v=s(u,"Example:"),u.forEach(t),f=h(l),T(m.$$.fragment,l)},m(l,u){g(l,d,u),e(d,v),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 dC(x){let d,v,f,m,b,l,u,B,we,_e,S,ce,Z,E,Te,W,pe,Ae,J,oe,ie,Q,le,ye,H,$e,be,O,Fe,de,se,C,A,De,X,fe,Ee,Y,ve,he,q,ke,U,me,xe,G,ue,Be,I,te,K,ee,ne,j,Me,P,ge,ze,k,M,Qe,re,He,Ne,z,Ke,Re,Ve,Je,Ge,L,V,Xe,Ye,N,We,Ze,Ce,Ue,ae,et,Jp,J_,um,Lt,G_,qr,X_,Y_,Pr,Z_,eb,Lr,tb,ob,fm,Vo,Rs,Gp,Or,sb,Xp,nb,mm,ic,rb,gm,Ir,_m,je,Sr,ab,Nr,ib,lb,db,Rr,cb,Wr,pb,hb,ub,Ur,fb,Qr,mb,gb,_b,Hr,bb,Kr,vb,kb,wb,Vr,Tb,Jr,yb,$b,Fb,Gr,Db,Xr,Eb,xb,Bb,Yr,Mb,Zr,zb,Cb,Ab,go,lc,jb,qb,ea,Pb,Lb,ta,Ob,Ib,Sb,_o,dc,Nb,Rb,oa,Wb,Ub,sa,Qb,Hb,Kb,bo,cc,Vb,Jb,na,Gb,Xb,ra,Yb,Zb,ev,Yp,pc,tv,bm,aa,vm,wt,vo,hc,ov,sv,ia,nv,rv,la,av,iv,lv,ko,uc,dv,cv,da,pv,hv,ca,uv,fv,mv,Ws,fc,gv,_v,pa,bv,vv,kv,mc,ha,wv,Tv,yv,Zp,gc,$v,km,ua,wm,Tt,wo,_c,Fv,Dv,fa,Ev,xv,ma,Bv,Mv,zv,To,bc,Cv,Av,ga,jv,qv,_a,Pv,Lv,Ov,yo,vc,Iv,Sv,ba,Nv,Rv,va,Wv,Uv,Qv,kc,ka,Hv,Kv,Vv,eh,wc,Jv,Tm,wa,ym,yt,$o,Tc,Gv,Xv,Ta,Yv,Zv,ya,ek,tk,ok,Fo,yc,sk,nk,$a,rk,ak,Fa,ik,lk,dk,Us,$c,ck,pk,Da,hk,uk,fk,Fc,Ea,mk,gk,_k,th,Dc,bk,$m,Ec,oh,vk,Fm,Do,Eo,xc,kk,wk,xa,Tk,yk,Ba,$k,Fk,Dk,xo,Bc,Ek,xk,Ma,Bk,Mk,za,zk,Ck,Ak,sh,Mc,jk,Dm,zc,qk,Em,Bo,Ca,Pk,Aa,Lk,Ok,Ik,ja,Sk,qa,Nk,Rk,Wk,Pa,Uk,La,Qk,Hk,xm,Cc,Kk,Bm,Qs,Oa,Vk,Ia,Jk,Gk,Xk,Sa,Yk,Na,Zk,ew,Mm,Ac,tw,zm,Mo,Ra,ow,Wa,sw,nw,rw,Ua,aw,Qa,iw,lw,dw,Ha,cw,Ka,pw,hw,Cm,Jo,Hs,nh,Va,uw,rh,fw,Am,Pt,Ja,mw,ro,gw,jc,_w,bw,qc,vw,kw,Ga,ww,Tw,yw,Go,$w,Pc,Fw,Dw,Lc,Ew,xw,Bw,Ks,jm,Xo,Vs,ah,Xa,Mw,ih,zw,qm,tt,Ya,Cw,lh,Aw,jw,Za,qw,Oc,Pw,Lw,Ow,zo,ei,Iw,dh,Sw,Nw,ti,Ic,Rw,ch,Ww,Uw,Sc,Qw,ph,Hw,Kw,Js,oi,Vw,hh,Jw,Gw,Ot,si,Xw,uh,Yw,Zw,Gs,e1,Yo,t1,fh,o1,s1,mh,n1,r1,a1,Xs,ni,i1,ri,l1,gh,d1,c1,Pm,Zo,Ys,_h,ai,p1,bh,h1,Lm,ft,ii,u1,li,f1,vh,m1,g1,_1,di,b1,Nc,v1,k1,w1,Co,ci,T1,kh,y1,$1,pi,Rc,F1,wh,D1,E1,Wc,x1,Th,B1,M1,It,hi,z1,yh,C1,A1,Zs,j1,es,q1,$h,P1,L1,Fh,O1,I1,Om,ts,en,Dh,ui,S1,Eh,N1,Im,mt,fi,R1,xh,W1,U1,mi,Q1,Uc,H1,K1,V1,gi,J1,_i,G1,X1,Y1,St,bi,Z1,os,eT,Qc,tT,oT,Bh,sT,nT,rT,tn,aT,on,Sm,ss,sn,Mh,vi,iT,zh,lT,Nm,gt,ki,dT,wi,cT,Ch,pT,hT,uT,Ti,fT,Hc,mT,gT,_T,yi,bT,$i,vT,kT,wT,Nt,Fi,TT,ns,yT,Kc,$T,FT,Ah,DT,ET,xT,nn,BT,rn,Rm,rs,an,jh,Di,MT,qh,zT,Wm,_t,Ei,CT,Ph,AT,jT,xi,qT,Vc,PT,LT,OT,Bi,IT,Mi,ST,NT,RT,$t,zi,WT,as,UT,Jc,QT,HT,Lh,KT,VT,JT,ln,GT,dn,XT,cn,Um,is,pn,Oh,Ci,YT,Ih,ZT,Qm,bt,Ai,ey,Sh,ty,oy,ji,sy,Gc,ny,ry,ay,qi,iy,Pi,ly,dy,cy,Rt,Li,py,ls,hy,Xc,uy,fy,Nh,my,gy,_y,hn,by,un,Hm,ds,fn,Rh,Oi,vy,Wh,ky,Km,vt,Ii,wy,Uh,Ty,yy,Si,$y,Yc,Fy,Dy,Ey,Ni,xy,Ri,By,My,zy,Wt,Wi,Cy,cs,Ay,Zc,jy,qy,Qh,Py,Ly,Oy,mn,Iy,gn,Vm,ps,_n,Hh,Ui,Sy,Kh,Ny,Jm,kt,Qi,Ry,hs,Wy,Vh,Uy,Qy,Jh,Hy,Ky,Vy,Hi,Jy,ep,Gy,Xy,Yy,Ki,Zy,Vi,e$,t$,o$,Ut,Ji,s$,us,n$,tp,r$,a$,Gh,i$,l$,d$,bn,c$,vn,Gm,fs,kn,Xh,Gi,p$,Yh,h$,Xm,lt,Xi,u$,Zh,f$,m$,Yi,g$,op,_$,b$,v$,Zi,k$,el,w$,T$,y$,wn,$$,Qt,tl,F$,ms,D$,sp,E$,x$,eu,B$,M$,z$,Tn,C$,yn,Ym,gs,$n,tu,ol,A$,ou,j$,Zm,dt,sl,q$,nl,P$,su,L$,O$,I$,rl,S$,np,N$,R$,W$,al,U$,il,Q$,H$,K$,Fn,V$,Ft,ll,J$,_s,G$,rp,X$,Y$,nu,Z$,e2,t2,Dn,o2,En,s2,xn,eg,bs,Bn,ru,dl,n2,au,r2,tg,ct,cl,a2,iu,i2,l2,pl,d2,ap,c2,p2,h2,hl,u2,ul,f2,m2,g2,Mn,_2,Dt,fl,b2,vs,v2,ip,k2,w2,lu,T2,y2,$2,zn,F2,Cn,D2,An,og,ks,jn,du,ml,E2,cu,x2,sg,pt,gl,B2,pu,M2,z2,_l,C2,lp,A2,j2,q2,bl,P2,vl,L2,O2,I2,qn,S2,Ht,kl,N2,ws,R2,dp,W2,U2,hu,Q2,H2,K2,Pn,V2,Ln,ng,Ts,On,uu,wl,J2,fu,G2,rg,ht,Tl,X2,mu,Y2,Z2,yl,eF,cp,tF,oF,sF,$l,nF,Fl,rF,aF,iF,In,lF,Et,Dl,dF,ys,cF,pp,pF,hF,gu,uF,fF,mF,Sn,gF,Nn,_F,Rn,ag,$s,Wn,_u,El,bF,bu,vF,ig,ut,xl,kF,Fs,wF,vu,TF,yF,ku,$F,FF,DF,Bl,EF,hp,xF,BF,MF,Ml,zF,zl,CF,AF,jF,Un,qF,xt,Cl,PF,Ds,LF,up,OF,IF,wu,SF,NF,RF,Qn,WF,Hn,UF,Kn,lg,Es,Vn,Tu,Al,QF,yu,HF,dg,ot,jl,KF,$u,VF,JF,ql,GF,fp,XF,YF,ZF,Pl,e0,Ll,t0,o0,s0,Fu,n0,r0,ao,Du,Ol,a0,i0,Eu,Il,l0,d0,xu,Sl,c0,p0,Bu,Nl,h0,u0,Kt,Rl,f0,xs,m0,Mu,g0,_0,zu,b0,v0,k0,Jn,w0,Gn,cg,Bs,Xn,Cu,Wl,T0,Au,y0,pg,st,Ul,$0,Ql,F0,ju,D0,E0,x0,Hl,B0,mp,M0,z0,C0,Kl,A0,Vl,j0,q0,P0,qu,L0,O0,io,Pu,Jl,I0,S0,Lu,Gl,N0,R0,Ou,Xl,W0,U0,Iu,Yl,Q0,H0,Vt,Zl,K0,Ms,V0,Su,J0,G0,Nu,X0,Y0,Z0,Yn,eD,Zn,hg,zs,er,Ru,ed,tD,Wu,oD,ug,nt,td,sD,Uu,nD,rD,od,aD,gp,iD,lD,dD,sd,cD,nd,pD,hD,uD,Qu,fD,mD,lo,Hu,rd,gD,_D,Ku,ad,bD,vD,Vu,id,kD,wD,Ju,ld,TD,yD,Jt,dd,$D,Cs,FD,Gu,DD,ED,Xu,xD,BD,MD,tr,zD,or,fg,As,sr,Yu,cd,CD,Zu,AD,mg,rt,pd,jD,ef,qD,PD,hd,LD,_p,OD,ID,SD,ud,ND,fd,RD,WD,UD,tf,QD,HD,co,of,md,KD,VD,sf,gd,JD,GD,nf,_d,XD,YD,rf,bd,ZD,e4,Gt,vd,t4,js,o4,af,s4,n4,lf,r4,a4,i4,nr,l4,rr,gg,qs,ar,df,kd,d4,cf,c4,_g,at,wd,p4,pf,h4,u4,Td,f4,bp,m4,g4,_4,yd,b4,$d,v4,k4,w4,hf,T4,y4,po,uf,Fd,$4,F4,ff,Dd,D4,E4,mf,Ed,x4,B4,gf,xd,M4,z4,Xt,Bd,C4,Ps,A4,_f,j4,q4,bf,P4,L4,O4,ir,I4,lr,bg,Ls,dr,vf,Md,S4,kf,N4,vg,it,zd,R4,Os,W4,wf,U4,Q4,Tf,H4,K4,V4,Cd,J4,vp,G4,X4,Y4,Ad,Z4,jd,eE,tE,oE,yf,sE,nE,ho,$f,qd,rE,aE,Ff,Pd,iE,lE,Df,Ld,dE,cE,Ef,Od,pE,hE,Yt,Id,uE,Is,fE,xf,mE,gE,Bf,_E,bE,vE,cr,kE,pr,kg;return l=new Se({}),le=new Se({}),Or=new Se({}),Ir=new V_({props:{pipeline:"text-classification"}}),aa=new V_({props:{pipeline:"token-classification"}}),ua=new V_({props:{pipeline:"fill-mask"}}),wa=new V_({props:{pipeline:"question-answering"}}),Va=new Se({}),Ja=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/v4.27.1/en/model_doc/distilbert#transformers.DistilBertModel">DistilBertModel</a> or <a href="/docs/transformers/v4.27.1/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/v4.27.1/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/v4.27.1/en/model_doc/distilbert#transformers.DistilBertForSequenceClassification">DistilBertForSequenceClassification</a>.`,name:"seq_classif_dropout"}],source:"https://github.com/huggingface/transformers/blob/v4.27.1/src/transformers/models/distilbert/configuration_distilbert.py#L45"}}),Ks=new qe({props:{anchor:"transformers.DistilBertConfig.example",$$slots:{default:[u3]},$$scope:{ctx:x}}}),Xa=new Se({}),Ya=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/v4.27.1/src/transformers/models/distilbert/tokenization_distilbert.py#L89"}}),ei=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/v4.27.1/src/transformers/models/distilbert/tokenization_distilbert.py#L228",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>
`}}),oi=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/v4.27.1/src/transformers/models/distilbert/tokenization_distilbert.py#L222"}}),si=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/v4.27.1/src/transformers/models/distilbert/tokenization_distilbert.py#L283",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>
`}}),Gs=new qe({props:{anchor:"transformers.DistilBertTokenizer.create_token_type_ids_from_sequences.example",$$slots:{default:[f3]},$$scope:{ctx:x}}}),ni=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/v4.27.1/src/transformers/models/distilbert/tokenization_distilbert.py#L254",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>
`}}),ai=new Se({}),ii=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/v4.27.1/src/transformers/models/distilbert/tokenization_distilbert_fast.py#L84"}}),ci=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/v4.27.1/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>
`}}),hi=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/v4.27.1/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>
`}}),Zs=new qe({props:{anchor:"transformers.DistilBertTokenizerFast.create_token_type_ids_from_sequences.example",$$slots:{default:[m3]},$$scope:{ctx:x}}}),ui=new Se({}),fi=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/v4.27.1/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/v4.27.1/en/main_classes/model#transformers.PreTrainedModel.from_pretrained">from_pretrained()</a> method to load the model weights.`,name:"config"}],source:"https://github.com/huggingface/transformers/blob/v4.27.1/src/transformers/models/distilbert/modeling_distilbert.py#L470"}}),bi=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/v4.27.1/en/model_doc/auto#transformers.AutoTokenizer">AutoTokenizer</a>. See <a href="/docs/transformers/v4.27.1/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode">PreTrainedTokenizer.encode()</a> and
<a href="/docs/transformers/v4.27.1/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/v4.27.1/en/main_classes/output#transformers.utils.ModelOutput">ModelOutput</a> instead of a plain tuple.`,name:"return_dict"}],source:"https://github.com/huggingface/transformers/blob/v4.27.1/src/transformers/models/distilbert/modeling_distilbert.py#L542",returnDescription:`
<p>A <a
  href="/docs/transformers/v4.27.1/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/v4.27.1/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/v4.27.1/en/main_classes/output#transformers.modeling_outputs.BaseModelOutput"
>transformers.modeling_outputs.BaseModelOutput</a> or <code>tuple(torch.FloatTensor)</code></p>
`}}),tn=new Ie({props:{$$slots:{default:[g3]},$$scope:{ctx:x}}}),on=new qe({props:{anchor:"transformers.DistilBertModel.forward.example",$$slots:{default:[_3]},$$scope:{ctx:x}}}),vi=new Se({}),ki=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/v4.27.1/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/v4.27.1/en/main_classes/model#transformers.PreTrainedModel.from_pretrained">from_pretrained()</a> method to load the model weights.`,name:"config"}],source:"https://github.com/huggingface/transformers/blob/v4.27.1/src/transformers/models/distilbert/modeling_distilbert.py#L597"}}),Fi=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/v4.27.1/en/model_doc/auto#transformers.AutoTokenizer">AutoTokenizer</a>. See <a href="/docs/transformers/v4.27.1/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode">PreTrainedTokenizer.encode()</a> and
<a href="/docs/transformers/v4.27.1/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/v4.27.1/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/v4.27.1/src/transformers/models/distilbert/modeling_distilbert.py#L641",returnDescription:`
<p>A <a
  href="/docs/transformers/v4.27.1/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/v4.27.1/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/v4.27.1/en/main_classes/output#transformers.modeling_outputs.MaskedLMOutput"
>transformers.modeling_outputs.MaskedLMOutput</a> or <code>tuple(torch.FloatTensor)</code></p>
`}}),nn=new Ie({props:{$$slots:{default:[b3]},$$scope:{ctx:x}}}),rn=new qe({props:{anchor:"transformers.DistilBertForMaskedLM.forward.example",$$slots:{default:[v3]},$$scope:{ctx:x}}}),Di=new Se({}),Ei=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/v4.27.1/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/v4.27.1/en/main_classes/model#transformers.PreTrainedModel.from_pretrained">from_pretrained()</a> method to load the model weights.`,name:"config"}],source:"https://github.com/huggingface/transformers/blob/v4.27.1/src/transformers/models/distilbert/modeling_distilbert.py#L704"}}),zi=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/v4.27.1/en/model_doc/auto#transformers.AutoTokenizer">AutoTokenizer</a>. See <a href="/docs/transformers/v4.27.1/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode">PreTrainedTokenizer.encode()</a> and
<a href="/docs/transformers/v4.27.1/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/v4.27.1/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/v4.27.1/src/transformers/models/distilbert/modeling_distilbert.py#L738",returnDescription:`
<p>A <a
  href="/docs/transformers/v4.27.1/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/v4.27.1/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/v4.27.1/en/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput"
>transformers.modeling_outputs.SequenceClassifierOutput</a> or <code>tuple(torch.FloatTensor)</code></p>
`}}),ln=new Ie({props:{$$slots:{default:[k3]},$$scope:{ctx:x}}}),dn=new qe({props:{anchor:"transformers.DistilBertForSequenceClassification.forward.example",$$slots:{default:[w3]},$$scope:{ctx:x}}}),cn=new qe({props:{anchor:"transformers.DistilBertForSequenceClassification.forward.example-2",$$slots:{default:[T3]},$$scope:{ctx:x}}}),Ci=new Se({}),Ai=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/v4.27.1/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/v4.27.1/en/main_classes/model#transformers.PreTrainedModel.from_pretrained">from_pretrained()</a> method to load the model weights.`,name:"config"}],source:"https://github.com/huggingface/transformers/blob/v4.27.1/src/transformers/models/distilbert/modeling_distilbert.py#L1033"}}),Li=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/v4.27.1/en/model_doc/auto#transformers.AutoTokenizer">AutoTokenizer</a>. See <a href="/docs/transformers/v4.27.1/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode">PreTrainedTokenizer.encode()</a> and
<a href="/docs/transformers/v4.27.1/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/v4.27.1/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/v4.27.1/src/transformers/models/distilbert/modeling_distilbert.py#L1065",returnDescription:`
<p>A <a
  href="/docs/transformers/v4.27.1/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/v4.27.1/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/v4.27.1/en/main_classes/output#transformers.modeling_outputs.MultipleChoiceModelOutput"
>transformers.modeling_outputs.MultipleChoiceModelOutput</a> or <code>tuple(torch.FloatTensor)</code></p>
`}}),hn=new Ie({props:{$$slots:{default:[y3]},$$scope:{ctx:x}}}),un=new qe({props:{anchor:"transformers.DistilBertForMultipleChoice.forward.example",$$slots:{default:[$3]},$$scope:{ctx:x}}}),Oi=new Se({}),Ii=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/v4.27.1/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/v4.27.1/en/main_classes/model#transformers.PreTrainedModel.from_pretrained">from_pretrained()</a> method to load the model weights.`,name:"config"}],source:"https://github.com/huggingface/transformers/blob/v4.27.1/src/transformers/models/distilbert/modeling_distilbert.py#L939"}}),Wi=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/v4.27.1/en/model_doc/auto#transformers.AutoTokenizer">AutoTokenizer</a>. See <a href="/docs/transformers/v4.27.1/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode">PreTrainedTokenizer.encode()</a> and
<a href="/docs/transformers/v4.27.1/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/v4.27.1/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/v4.27.1/src/transformers/models/distilbert/modeling_distilbert.py#L971",returnDescription:`
<p>A <a
  href="/docs/transformers/v4.27.1/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/v4.27.1/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/v4.27.1/en/main_classes/output#transformers.modeling_outputs.TokenClassifierOutput"
>transformers.modeling_outputs.TokenClassifierOutput</a> or <code>tuple(torch.FloatTensor)</code></p>
`}}),mn=new Ie({props:{$$slots:{default:[F3]},$$scope:{ctx:x}}}),gn=new qe({props:{anchor:"transformers.DistilBertForTokenClassification.forward.example",$$slots:{default:[D3]},$$scope:{ctx:x}}}),Ui=new Se({}),Qi=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/v4.27.1/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/v4.27.1/en/main_classes/model#transformers.PreTrainedModel.from_pretrained">from_pretrained()</a> method to load the model weights.`,name:"config"}],source:"https://github.com/huggingface/transformers/blob/v4.27.1/src/transformers/models/distilbert/modeling_distilbert.py#L821"}}),Ji=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/v4.27.1/en/model_doc/auto#transformers.AutoTokenizer">AutoTokenizer</a>. See <a href="/docs/transformers/v4.27.1/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode">PreTrainedTokenizer.encode()</a> and
<a href="/docs/transformers/v4.27.1/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/v4.27.1/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/v4.27.1/src/transformers/models/distilbert/modeling_distilbert.py#L855",returnDescription:`
<p>A <a
  href="/docs/transformers/v4.27.1/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/v4.27.1/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/v4.27.1/en/main_classes/output#transformers.modeling_outputs.QuestionAnsweringModelOutput"
>transformers.modeling_outputs.QuestionAnsweringModelOutput</a> or <code>tuple(torch.FloatTensor)</code></p>
`}}),bn=new Ie({props:{$$slots:{default:[E3]},$$scope:{ctx:x}}}),vn=new qe({props:{anchor:"transformers.DistilBertForQuestionAnswering.forward.example",$$slots:{default:[x3]},$$scope:{ctx:x}}}),Gi=new Se({}),Xi=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/v4.27.1/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/v4.27.1/en/main_classes/model#transformers.PreTrainedModel.from_pretrained">from_pretrained()</a> method to load the model weights.`,name:"config"}],source:"https://github.com/huggingface/transformers/blob/v4.27.1/src/transformers/models/distilbert/modeling_tf_distilbert.py#L536"}}),wn=new Ie({props:{$$slots:{default:[B3]},$$scope:{ctx:x}}}),tl=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/v4.27.1/en/model_doc/auto#transformers.AutoTokenizer">AutoTokenizer</a>. See <a href="/docs/transformers/v4.27.1/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__">PreTrainedTokenizer.<strong>call</strong>()</a> and
<a href="/docs/transformers/v4.27.1/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/v4.27.1/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/v4.27.1/src/transformers/models/distilbert/modeling_tf_distilbert.py#L541",returnDescription:`
<p>A <a
  href="/docs/transformers/v4.27.1/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/v4.27.1/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/v4.27.1/en/main_classes/output#transformers.modeling_tf_outputs.TFBaseModelOutput"
>transformers.modeling_tf_outputs.TFBaseModelOutput</a> or <code>tuple(tf.Tensor)</code></p>
`}}),Tn=new Ie({props:{$$slots:{default:[M3]},$$scope:{ctx:x}}}),yn=new qe({props:{anchor:"transformers.TFDistilBertModel.call.example",$$slots:{default:[z3]},$$scope:{ctx:x}}}),ol=new Se({}),sl=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/v4.27.1/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/v4.27.1/en/main_classes/model#transformers.PreTrainedModel.from_pretrained">from_pretrained()</a> method to load the model weights.`,name:"config"}],source:"https://github.com/huggingface/transformers/blob/v4.27.1/src/transformers/models/distilbert/modeling_tf_distilbert.py#L622"}}),Fn=new Ie({props:{$$slots:{default:[C3]},$$scope:{ctx:x}}}),ll=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/v4.27.1/en/model_doc/auto#transformers.AutoTokenizer">AutoTokenizer</a>. See <a href="/docs/transformers/v4.27.1/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__">PreTrainedTokenizer.<strong>call</strong>()</a> and
<a href="/docs/transformers/v4.27.1/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/v4.27.1/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/v4.27.1/src/transformers/models/distilbert/modeling_tf_distilbert.py#L642",returnDescription:`
<p>A <a
  href="/docs/transformers/v4.27.1/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/v4.27.1/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/v4.27.1/en/main_classes/output#transformers.modeling_tf_outputs.TFMaskedLMOutput"
>transformers.modeling_tf_outputs.TFMaskedLMOutput</a> or <code>tuple(tf.Tensor)</code></p>
`}}),Dn=new Ie({props:{$$slots:{default:[A3]},$$scope:{ctx:x}}}),En=new qe({props:{anchor:"transformers.TFDistilBertForMaskedLM.call.example",$$slots:{default:[j3]},$$scope:{ctx:x}}}),xn=new qe({props:{anchor:"transformers.TFDistilBertForMaskedLM.call.example-2",$$slots:{default:[q3]},$$scope:{ctx:x}}}),dl=new Se({}),cl=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/v4.27.1/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/v4.27.1/en/main_classes/model#transformers.PreTrainedModel.from_pretrained">from_pretrained()</a> method to load the model weights.`,name:"config"}],source:"https://github.com/huggingface/transformers/blob/v4.27.1/src/transformers/models/distilbert/modeling_tf_distilbert.py#L711"}}),Mn=new Ie({props:{$$slots:{default:[P3]},$$scope:{ctx:x}}}),fl=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/v4.27.1/en/model_doc/auto#transformers.AutoTokenizer">AutoTokenizer</a>. See <a href="/docs/transformers/v4.27.1/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__">PreTrainedTokenizer.<strong>call</strong>()</a> and
<a href="/docs/transformers/v4.27.1/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/v4.27.1/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/v4.27.1/src/transformers/models/distilbert/modeling_tf_distilbert.py#L728",returnDescription:`
<p>A <a
  href="/docs/transformers/v4.27.1/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/v4.27.1/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/v4.27.1/en/main_classes/output#transformers.modeling_tf_outputs.TFSequenceClassifierOutput"
>transformers.modeling_tf_outputs.TFSequenceClassifierOutput</a> or <code>tuple(tf.Tensor)</code></p>
`}}),zn=new Ie({props:{$$slots:{default:[L3]},$$scope:{ctx:x}}}),Cn=new qe({props:{anchor:"transformers.TFDistilBertForSequenceClassification.call.example",$$slots:{default:[O3]},$$scope:{ctx:x}}}),An=new qe({props:{anchor:"transformers.TFDistilBertForSequenceClassification.call.example-2",$$slots:{default:[I3]},$$scope:{ctx:x}}}),ml=new Se({}),gl=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/v4.27.1/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/v4.27.1/en/main_classes/model#transformers.PreTrainedModel.from_pretrained">from_pretrained()</a> method to load the model weights.`,name:"config"}],source:"https://github.com/huggingface/transformers/blob/v4.27.1/src/transformers/models/distilbert/modeling_tf_distilbert.py#L872"}}),qn=new Ie({props:{$$slots:{default:[S3]},$$scope:{ctx:x}}}),kl=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/v4.27.1/en/model_doc/auto#transformers.AutoTokenizer">AutoTokenizer</a>. See <a href="/docs/transformers/v4.27.1/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__">PreTrainedTokenizer.<strong>call</strong>()</a> and
<a href="/docs/transformers/v4.27.1/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/v4.27.1/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/v4.27.1/src/transformers/models/distilbert/modeling_tf_distilbert.py#L898",returnDescription:`
<p>A <a
  href="/docs/transformers/v4.27.1/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/v4.27.1/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/v4.27.1/en/main_classes/output#transformers.modeling_tf_outputs.TFMultipleChoiceModelOutput"
>transformers.modeling_tf_outputs.TFMultipleChoiceModelOutput</a> or <code>tuple(tf.Tensor)</code></p>
`}}),Pn=new Ie({props:{$$slots:{default:[N3]},$$scope:{ctx:x}}}),Ln=new qe({props:{anchor:"transformers.TFDistilBertForMultipleChoice.call.example",$$slots:{default:[R3]},$$scope:{ctx:x}}}),wl=new Se({}),Tl=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/v4.27.1/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/v4.27.1/en/main_classes/model#transformers.PreTrainedModel.from_pretrained">from_pretrained()</a> method to load the model weights.`,name:"config"}],source:"https://github.com/huggingface/transformers/blob/v4.27.1/src/transformers/models/distilbert/modeling_tf_distilbert.py#L797"}}),In=new Ie({props:{$$slots:{default:[W3]},$$scope:{ctx:x}}}),Dl=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/v4.27.1/en/model_doc/auto#transformers.AutoTokenizer">AutoTokenizer</a>. See <a href="/docs/transformers/v4.27.1/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__">PreTrainedTokenizer.<strong>call</strong>()</a> and
<a href="/docs/transformers/v4.27.1/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/v4.27.1/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/v4.27.1/src/transformers/models/distilbert/modeling_tf_distilbert.py#L808",returnDescription:`
<p>A <a
  href="/docs/transformers/v4.27.1/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/v4.27.1/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/v4.27.1/en/main_classes/output#transformers.modeling_tf_outputs.TFTokenClassifierOutput"
>transformers.modeling_tf_outputs.TFTokenClassifierOutput</a> or <code>tuple(tf.Tensor)</code></p>
`}}),Sn=new Ie({props:{$$slots:{default:[U3]},$$scope:{ctx:x}}}),Nn=new qe({props:{anchor:"transformers.TFDistilBertForTokenClassification.call.example",$$slots:{default:[Q3]},$$scope:{ctx:x}}}),Rn=new qe({props:{anchor:"transformers.TFDistilBertForTokenClassification.call.example-2",$$slots:{default:[H3]},$$scope:{ctx:x}}}),El=new Se({}),xl=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/v4.27.1/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/v4.27.1/en/main_classes/model#transformers.PreTrainedModel.from_pretrained">from_pretrained()</a> method to load the model weights.`,name:"config"}],source:"https://github.com/huggingface/transformers/blob/v4.27.1/src/transformers/models/distilbert/modeling_tf_distilbert.py#L996"}}),Un=new Ie({props:{$$slots:{default:[K3]},$$scope:{ctx:x}}}),Cl=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/v4.27.1/en/model_doc/auto#transformers.AutoTokenizer">AutoTokenizer</a>. See <a href="/docs/transformers/v4.27.1/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__">PreTrainedTokenizer.<strong>call</strong>()</a> and
<a href="/docs/transformers/v4.27.1/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/v4.27.1/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/v4.27.1/src/transformers/models/distilbert/modeling_tf_distilbert.py#L1007",returnDescription:`
<p>A <a
  href="/docs/transformers/v4.27.1/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/v4.27.1/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/v4.27.1/en/main_classes/output#transformers.modeling_tf_outputs.TFQuestionAnsweringModelOutput"
>transformers.modeling_tf_outputs.TFQuestionAnsweringModelOutput</a> or <code>tuple(tf.Tensor)</code></p>
`}}),Qn=new Ie({props:{$$slots:{default:[V3]},$$scope:{ctx:x}}}),Hn=new qe({props:{anchor:"transformers.TFDistilBertForQuestionAnswering.call.example",$$slots:{default:[J3]},$$scope:{ctx:x}}}),Kn=new qe({props:{anchor:"transformers.TFDistilBertForQuestionAnswering.call.example-2",$$slots:{default:[G3]},$$scope:{ctx:x}}}),Al=new Se({}),jl=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/v4.27.1/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/v4.27.1/en/main_classes/model#transformers.PreTrainedModel.from_pretrained">from_pretrained()</a> method to load the model weights.`,name:"config"}],source:"https://github.com/huggingface/transformers/blob/v4.27.1/src/transformers/models/distilbert/modeling_flax_distilbert.py#L532"}}),Rl=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/v4.27.1/en/model_doc/auto#transformers.AutoTokenizer">AutoTokenizer</a>. See <a href="/docs/transformers/v4.27.1/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode">PreTrainedTokenizer.encode()</a> and
<a href="/docs/transformers/v4.27.1/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/v4.27.1/en/main_classes/output#transformers.utils.ModelOutput">ModelOutput</a> instead of a plain tuple.`,name:"return_dict"}],source:"https://github.com/huggingface/transformers/blob/v4.27.1/src/transformers/models/distilbert/modeling_flax_distilbert.py#L455"}}),Jn=new Ie({props:{$$slots:{default:[X3]},$$scope:{ctx:x}}}),Gn=new qe({props:{anchor:"transformers.FlaxDistilBertModel.__call__.example",$$slots:{default:[Y3]},$$scope:{ctx:x}}}),Wl=new Se({}),Ul=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/v4.27.1/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/v4.27.1/en/main_classes/model#transformers.PreTrainedModel.from_pretrained">from_pretrained()</a> method to load the model weights.`,name:"config"}],source:"https://github.com/huggingface/transformers/blob/v4.27.1/src/transformers/models/distilbert/modeling_flax_distilbert.py#L605"}}),Zl=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/v4.27.1/en/model_doc/auto#transformers.AutoTokenizer">AutoTokenizer</a>. See <a href="/docs/transformers/v4.27.1/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode">PreTrainedTokenizer.encode()</a> and
<a href="/docs/transformers/v4.27.1/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/v4.27.1/en/main_classes/output#transformers.utils.ModelOutput">ModelOutput</a> instead of a plain tuple.`,name:"return_dict"}],source:"https://github.com/huggingface/transformers/blob/v4.27.1/src/transformers/models/distilbert/modeling_flax_distilbert.py#L455",returnDescription:`
<p>A <a
  href="/docs/transformers/v4.27.1/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/v4.27.1/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/v4.27.1/en/main_classes/output#transformers.modeling_flax_outputs.FlaxMaskedLMOutput"
>transformers.modeling_flax_outputs.FlaxMaskedLMOutput</a> or <code>tuple(torch.FloatTensor)</code></p>
`}}),Yn=new Ie({props:{$$slots:{default:[Z3]},$$scope:{ctx:x}}}),Zn=new qe({props:{anchor:"transformers.FlaxDistilBertForMaskedLM.__call__.example",$$slots:{default:[eC]},$$scope:{ctx:x}}}),ed=new Se({}),td=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/v4.27.1/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/v4.27.1/en/main_classes/model#transformers.PreTrainedModel.from_pretrained">from_pretrained()</a> method to load the model weights.`,name:"config"}],source:"https://github.com/huggingface/transformers/blob/v4.27.1/src/transformers/models/distilbert/modeling_flax_distilbert.py#L672"}}),dd=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/v4.27.1/en/model_doc/auto#transformers.AutoTokenizer">AutoTokenizer</a>. See <a href="/docs/transformers/v4.27.1/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode">PreTrainedTokenizer.encode()</a> and
<a href="/docs/transformers/v4.27.1/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/v4.27.1/en/main_classes/output#transformers.utils.ModelOutput">ModelOutput</a> instead of a plain tuple.`,name:"return_dict"}],source:"https://github.com/huggingface/transformers/blob/v4.27.1/src/transformers/models/distilbert/modeling_flax_distilbert.py#L455",returnDescription:`
<p>A <a
  href="/docs/transformers/v4.27.1/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/v4.27.1/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/v4.27.1/en/main_classes/output#transformers.modeling_flax_outputs.FlaxSequenceClassifierOutput"
>transformers.modeling_flax_outputs.FlaxSequenceClassifierOutput</a> or <code>tuple(torch.FloatTensor)</code></p>
`}}),tr=new Ie({props:{$$slots:{default:[tC]},$$scope:{ctx:x}}}),or=new qe({props:{anchor:"transformers.FlaxDistilBertForSequenceClassification.__call__.example",$$slots:{default:[oC]},$$scope:{ctx:x}}}),cd=new Se({}),pd=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/v4.27.1/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/v4.27.1/en/main_classes/model#transformers.PreTrainedModel.from_pretrained">from_pretrained()</a> method to load the model weights.`,name:"config"}],source:"https://github.com/huggingface/transformers/blob/v4.27.1/src/transformers/models/distilbert/modeling_flax_distilbert.py#L751"}}),vd=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/v4.27.1/en/model_doc/auto#transformers.AutoTokenizer">AutoTokenizer</a>. See <a href="/docs/transformers/v4.27.1/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode">PreTrainedTokenizer.encode()</a> and
<a href="/docs/transformers/v4.27.1/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/v4.27.1/en/main_classes/output#transformers.utils.ModelOutput">ModelOutput</a> instead of a plain tuple.`,name:"return_dict"}],source:"https://github.com/huggingface/transformers/blob/v4.27.1/src/transformers/models/distilbert/modeling_flax_distilbert.py#L455",returnDescription:`
<p>A <a
  href="/docs/transformers/v4.27.1/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/v4.27.1/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/v4.27.1/en/main_classes/output#transformers.modeling_flax_outputs.FlaxMultipleChoiceModelOutput"
>transformers.modeling_flax_outputs.FlaxMultipleChoiceModelOutput</a> or <code>tuple(torch.FloatTensor)</code></p>
`}}),nr=new Ie({props:{$$slots:{default:[sC]},$$scope:{ctx:x}}}),rr=new qe({props:{anchor:"transformers.FlaxDistilBertForMultipleChoice.__call__.example",$$slots:{default:[nC]},$$scope:{ctx:x}}}),kd=new Se({}),wd=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/v4.27.1/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/v4.27.1/en/main_classes/model#transformers.PreTrainedModel.from_pretrained">from_pretrained()</a> method to load the model weights.`,name:"config"}],source:"https://github.com/huggingface/transformers/blob/v4.27.1/src/transformers/models/distilbert/modeling_flax_distilbert.py#L816"}}),Bd=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/v4.27.1/en/model_doc/auto#transformers.AutoTokenizer">AutoTokenizer</a>. See <a href="/docs/transformers/v4.27.1/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode">PreTrainedTokenizer.encode()</a> and
<a href="/docs/transformers/v4.27.1/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/v4.27.1/en/main_classes/output#transformers.utils.ModelOutput">ModelOutput</a> instead of a plain tuple.`,name:"return_dict"}],source:"https://github.com/huggingface/transformers/blob/v4.27.1/src/transformers/models/distilbert/modeling_flax_distilbert.py#L455",returnDescription:`
<p>A <a
  href="/docs/transformers/v4.27.1/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/v4.27.1/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/v4.27.1/en/main_classes/output#transformers.modeling_flax_outputs.FlaxTokenClassifierOutput"
>transformers.modeling_flax_outputs.FlaxTokenClassifierOutput</a> or <code>tuple(torch.FloatTensor)</code></p>
`}}),ir=new Ie({props:{$$slots:{default:[rC]},$$scope:{ctx:x}}}),lr=new qe({props:{anchor:"transformers.FlaxDistilBertForTokenClassification.__call__.example",$$slots:{default:[aC]},$$scope:{ctx:x}}}),Md=new Se({}),zd=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/v4.27.1/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/v4.27.1/en/main_classes/model#transformers.PreTrainedModel.from_pretrained">from_pretrained()</a> method to load the model weights.`,name:"config"}],source:"https://github.com/huggingface/transformers/blob/v4.27.1/src/transformers/models/distilbert/modeling_flax_distilbert.py#L885"}}),Id=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/v4.27.1/en/model_doc/auto#transformers.AutoTokenizer">AutoTokenizer</a>. See <a href="/docs/transformers/v4.27.1/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode">PreTrainedTokenizer.encode()</a> and
<a href="/docs/transformers/v4.27.1/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/v4.27.1/en/main_classes/output#transformers.utils.ModelOutput">ModelOutput</a> instead of a plain tuple.`,name:"return_dict"}],source:"https://github.com/huggingface/transformers/blob/v4.27.1/src/transformers/models/distilbert/modeling_flax_distilbert.py#L455",returnDescription:`
<p>A <a
  href="/docs/transformers/v4.27.1/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/v4.27.1/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/v4.27.1/en/main_classes/output#transformers.modeling_flax_outputs.FlaxQuestionAnsweringModelOutput"
>transformers.modeling_flax_outputs.FlaxQuestionAnsweringModelOutput</a> or <code>tuple(torch.FloatTensor)</code></p>
`}}),cr=new Ie({props:{$$slots:{default:[iC]},$$scope:{ctx:x}}}),pr=new qe({props:{anchor:"transformers.FlaxDistilBertForQuestionAnswering.__call__.example",$$slots:{default:[lC]},$$scope:{ctx:x}}}),{c(){d=n("meta"),v=p(),f=n("h1"),m=n("a"),b=n("span"),w(l.$$.fragment),u=p(),B=n("span"),we=o("DistilBERT"),_e=p(),S=n("div"),ce=n("a"),Z=n("img"),Te=p(),W=n("a"),pe=n("img"),J=p(),oe=n("h2"),ie=n("a"),Q=n("span"),w(le.$$.fragment),ye=p(),H=n("span"),$e=o("Overview"),be=p(),O=n("p"),Fe=o("The DistilBERT model was proposed in the blog post "),de=n("a"),se=o(`Smaller, faster, cheaper, lighter: Introducing DistilBERT, a
distilled version of BERT`),C=o(", and the paper "),A=n("a"),De=o(`DistilBERT, a
distilled version of BERT: smaller, faster, cheaper and lighter`),X=o(`. DistilBERT is a
small, fast, cheap and light Transformer model trained by distilling BERT base. It has 40% less parameters than
`),fe=n("em"),Ee=o("bert-base-uncased"),Y=o(`, runs 60% faster while preserving over 95% of BERT\u2019s performances as measured on the GLUE language
understanding benchmark.`),ve=p(),he=n("p"),q=o("The abstract from the paper is the following:"),ke=p(),U=n("p"),me=n("em"),xe=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.`),G=p(),ue=n("p"),Be=o("Tips:"),I=p(),te=n("ul"),K=n("li"),ee=n("p"),ne=o("DistilBERT doesn\u2019t have "),j=n("code"),Me=o("token_type_ids"),P=o(`, you don\u2019t need to indicate which token belongs to which segment. Just
separate your segments with the separation token `),ge=n("code"),ze=o("tokenizer.sep_token"),k=o(" (or "),M=n("code"),Qe=o("[SEP]"),re=o(")."),He=p(),Ne=n("li"),z=n("p"),Ke=o("DistilBERT doesn\u2019t have options to select the input positions ("),Re=n("code"),Ve=o("position_ids"),Je=o(` input). This could be added if
necessary though, just let us know if you need this option.`),Ge=p(),L=n("li"),V=n("p"),Xe=o("Same as BERT but smaller. Trained by distillation of the pretrained BERT model, meaning it\u2019s been trained to predict the same probabilities as the larger model. The actual objective is a combination of:"),Ye=p(),N=n("ul"),We=n("li"),Ze=o("finding the same probabilities as the teacher model"),Ce=p(),Ue=n("li"),ae=o("predicting the masked tokens correctly (but no next-sentence objective)"),et=p(),Jp=n("li"),J_=o("a cosine similarity between the hidden states of the student and the teacher model"),um=p(),Lt=n("p"),G_=o("This model was contributed by "),qr=n("a"),X_=o("victorsanh"),Y_=o(`. This model jax version was
contributed by `),Pr=n("a"),Z_=o("kamalkraj"),eb=o(". The original code can be found "),Lr=n("a"),tb=o("here"),ob=o("."),fm=p(),Vo=n("h2"),Rs=n("a"),Gp=n("span"),w(Or.$$.fragment),sb=p(),Xp=n("span"),nb=o("Resources"),mm=p(),ic=n("p"),rb=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."),gm=p(),w(Ir.$$.fragment),_m=p(),je=n("ul"),Sr=n("li"),ab=o("A blog post on "),Nr=n("a"),ib=o("Getting Started with Sentiment Analysis using Python"),lb=o(" with DistilBERT."),db=p(),Rr=n("li"),cb=o("A blog post on how to "),Wr=n("a"),pb=o("train DistilBERT with Blurr for sequence classification"),hb=o("."),ub=p(),Ur=n("li"),fb=o("A blog post on how to use "),Qr=n("a"),mb=o("Ray to tune DistilBERT hyperparameters"),gb=o("."),_b=p(),Hr=n("li"),bb=o("A blog post on how to "),Kr=n("a"),vb=o("train DistilBERT with Hugging Face and Amazon SageMaker"),kb=o("."),wb=p(),Vr=n("li"),Tb=o("A notebook on how to "),Jr=n("a"),yb=o("finetune DistilBERT for multi-label classification"),$b=o(". \u{1F30E}"),Fb=p(),Gr=n("li"),Db=o("A notebook on how to "),Xr=n("a"),Eb=o("finetune DistilBERT for multiclass classification with PyTorch"),xb=o(". \u{1F30E}"),Bb=p(),Yr=n("li"),Mb=o("A notebook on how to "),Zr=n("a"),zb=o("finetune DistilBERT for text classification in TensorFlow"),Cb=o(". \u{1F30E}"),Ab=p(),go=n("li"),lc=n("a"),jb=o("DistilBertForSequenceClassification"),qb=o(" is supported by this "),ea=n("a"),Pb=o("example script"),Lb=o(" and "),ta=n("a"),Ob=o("notebook"),Ib=o("."),Sb=p(),_o=n("li"),dc=n("a"),Nb=o("TFDistilBertForSequenceClassification"),Rb=o(" is supported by this "),oa=n("a"),Wb=o("example script"),Ub=o(" and "),sa=n("a"),Qb=o("notebook"),Hb=o("."),Kb=p(),bo=n("li"),cc=n("a"),Vb=o("FlaxDistilBertForSequenceClassification"),Jb=o(" is supported by this "),na=n("a"),Gb=o("example script"),Xb=o(" and "),ra=n("a"),Yb=o("notebook"),Zb=o("."),ev=p(),Yp=n("li"),pc=n("a"),tv=o("Text classification task guide"),bm=p(),w(aa.$$.fragment),vm=p(),wt=n("ul"),vo=n("li"),hc=n("a"),ov=o("DistilBertForTokenClassification"),sv=o(" is supported by this "),ia=n("a"),nv=o("example script"),rv=o(" and "),la=n("a"),av=o("notebook"),iv=o("."),lv=p(),ko=n("li"),uc=n("a"),dv=o("TFDistilBertForTokenClassification"),cv=o(" is supported by this "),da=n("a"),pv=o("example script"),hv=o(" and "),ca=n("a"),uv=o("notebook"),fv=o("."),mv=p(),Ws=n("li"),fc=n("a"),gv=o("FlaxDistilBertForTokenClassification"),_v=o(" is supported by this "),pa=n("a"),bv=o("example script"),vv=o("."),kv=p(),mc=n("li"),ha=n("a"),wv=o("Token classification"),Tv=o(" chapter of the \u{1F917} Hugging Face Course."),yv=p(),Zp=n("li"),gc=n("a"),$v=o("Token classification task guide"),km=p(),w(ua.$$.fragment),wm=p(),Tt=n("ul"),wo=n("li"),_c=n("a"),Fv=o("DistilBertForMaskedLM"),Dv=o(" is supported by this "),fa=n("a"),Ev=o("example script"),xv=o(" and "),ma=n("a"),Bv=o("notebook"),Mv=o("."),zv=p(),To=n("li"),bc=n("a"),Cv=o("TFDistilBertForMaskedLM"),Av=o(" is supported by this "),ga=n("a"),jv=o("example script"),qv=o(" and "),_a=n("a"),Pv=o("notebook"),Lv=o("."),Ov=p(),yo=n("li"),vc=n("a"),Iv=o("FlaxDistilBertForMaskedLM"),Sv=o(" is supported by this "),ba=n("a"),Nv=o("example script"),Rv=o(" and "),va=n("a"),Wv=o("notebook"),Uv=o("."),Qv=p(),kc=n("li"),ka=n("a"),Hv=o("Masked language modeling"),Kv=o(" chapter of the \u{1F917} Hugging Face Course."),Vv=p(),eh=n("li"),wc=n("a"),Jv=o("Masked language modeling task guide"),Tm=p(),w(wa.$$.fragment),ym=p(),yt=n("ul"),$o=n("li"),Tc=n("a"),Gv=o("DistilBertForQuestionAnswering"),Xv=o(" is supported by this "),Ta=n("a"),Yv=o("example script"),Zv=o(" and "),ya=n("a"),ek=o("notebook"),tk=o("."),ok=p(),Fo=n("li"),yc=n("a"),sk=o("TFDistilBertForQuestionAnswering"),nk=o(" is supported by this "),$a=n("a"),rk=o("example script"),ak=o(" and "),Fa=n("a"),ik=o("notebook"),lk=o("."),dk=p(),Us=n("li"),$c=n("a"),ck=o("FlaxDistilBertForQuestionAnswering"),pk=o(" is supported by this "),Da=n("a"),hk=o("example script"),uk=o("."),fk=p(),Fc=n("li"),Ea=n("a"),mk=o("Question answering"),gk=o(" chapter of the \u{1F917} Hugging Face Course."),_k=p(),th=n("li"),Dc=n("a"),bk=o("Question answering task guide"),$m=p(),Ec=n("p"),oh=n("strong"),vk=o("Multiple choice"),Fm=p(),Do=n("ul"),Eo=n("li"),xc=n("a"),kk=o("DistilBertForMultipleChoice"),wk=o(" is supported by this "),xa=n("a"),Tk=o("example script"),yk=o(" and "),Ba=n("a"),$k=o("notebook"),Fk=o("."),Dk=p(),xo=n("li"),Bc=n("a"),Ek=o("TFDistilBertForMultipleChoice"),xk=o(" is supported by this "),Ma=n("a"),Bk=o("example script"),Mk=o(" and "),za=n("a"),zk=o("notebook"),Ck=o("."),Ak=p(),sh=n("li"),Mc=n("a"),jk=o("Multiple choice task guide"),Dm=p(),zc=n("p"),qk=o("\u2697\uFE0F Optimization"),Em=p(),Bo=n("ul"),Ca=n("li"),Pk=o("A blog post on how to "),Aa=n("a"),Lk=o("quantize DistilBERT with \u{1F917} Optimum and Intel"),Ok=o("."),Ik=p(),ja=n("li"),Sk=o("A blog post on how "),qa=n("a"),Nk=o("Optimizing Transformers for GPUs with \u{1F917} Optimum"),Rk=o("."),Wk=p(),Pa=n("li"),Uk=o("A blog post on "),La=n("a"),Qk=o("Optimizing Transformers with Hugging Face Optimum"),Hk=o("."),xm=p(),Cc=n("p"),Kk=o("\u26A1\uFE0F Inference"),Bm=p(),Qs=n("ul"),Oa=n("li"),Vk=o("A blog post on how to "),Ia=n("a"),Jk=o("Accelerate BERT inference with Hugging Face Transformers and AWS Inferentia"),Gk=o(" with DistilBERT."),Xk=p(),Sa=n("li"),Yk=o("A blog post on "),Na=n("a"),Zk=o("Serverless Inference with Hugging Face\u2019s Transformers, DistilBERT and Amazon SageMaker"),ew=o("."),Mm=p(),Ac=n("p"),tw=o("\u{1F680} Deploy"),zm=p(),Mo=n("ul"),Ra=n("li"),ow=o("A blog post on how to "),Wa=n("a"),sw=o("deploy DistilBERT on Google Cloud"),nw=o("."),rw=p(),Ua=n("li"),aw=o("A blog post on how to "),Qa=n("a"),iw=o("deploy DistilBERT with Amazon SageMaker"),lw=o("."),dw=p(),Ha=n("li"),cw=o("A blog post on how to "),Ka=n("a"),pw=o("Deploy BERT with Hugging Face Transformers, Amazon SageMaker and Terraform module"),hw=o("."),Cm=p(),Jo=n("h2"),Hs=n("a"),nh=n("span"),w(Va.$$.fragment),uw=p(),rh=n("span"),fw=o("DistilBertConfig"),Am=p(),Pt=n("div"),w(Ja.$$.fragment),mw=p(),ro=n("p"),gw=o("This is the configuration class to store the configuration of a "),jc=n("a"),_w=o("DistilBertModel"),bw=o(" or a "),qc=n("a"),vw=o("TFDistilBertModel"),kw=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
`),Ga=n("a"),ww=o("distilbert-base-uncased"),Tw=o(" architecture."),yw=p(),Go=n("p"),$w=o("Configuration objects inherit from "),Pc=n("a"),Fw=o("PretrainedConfig"),Dw=o(` and can be used to control the model outputs. Read the
documentation from `),Lc=n("a"),Ew=o("PretrainedConfig"),xw=o(" for more information."),Bw=p(),w(Ks.$$.fragment),jm=p(),Xo=n("h2"),Vs=n("a"),ah=n("span"),w(Xa.$$.fragment),Mw=p(),ih=n("span"),zw=o("DistilBertTokenizer"),qm=p(),tt=n("div"),w(Ya.$$.fragment),Cw=p(),lh=n("p"),Aw=o("Construct a DistilBERT tokenizer. Based on WordPiece."),jw=p(),Za=n("p"),qw=o("This tokenizer inherits from "),Oc=n("a"),Pw=o("PreTrainedTokenizer"),Lw=o(` which contains most of the main methods. Users should refer to
this superclass for more information regarding those methods.`),Ow=p(),zo=n("div"),w(ei.$$.fragment),Iw=p(),dh=n("p"),Sw=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:`),Nw=p(),ti=n("ul"),Ic=n("li"),Rw=o("single sequence: "),ch=n("code"),Ww=o("[CLS] X [SEP]"),Uw=p(),Sc=n("li"),Qw=o("pair of sequences: "),ph=n("code"),Hw=o("[CLS] A [SEP] B [SEP]"),Kw=p(),Js=n("div"),w(oi.$$.fragment),Vw=p(),hh=n("p"),Jw=o("Converts a sequence of tokens (string) in a single string."),Gw=p(),Ot=n("div"),w(si.$$.fragment),Xw=p(),uh=n("p"),Yw=o("Create a mask from the two sequences passed to be used in a sequence-pair classification task. A BERT sequence"),Zw=p(),w(Gs.$$.fragment),e1=p(),Yo=n("p"),t1=o("If "),fh=n("code"),o1=o("token_ids_1"),s1=o(" is "),mh=n("code"),n1=o("None"),r1=o(", this method only returns the first portion of the mask (0s)."),a1=p(),Xs=n("div"),w(ni.$$.fragment),i1=p(),ri=n("p"),l1=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 `),gh=n("code"),d1=o("prepare_for_model"),c1=o(" method."),Pm=p(),Zo=n("h2"),Ys=n("a"),_h=n("span"),w(ai.$$.fragment),p1=p(),bh=n("span"),h1=o("DistilBertTokenizerFast"),Lm=p(),ft=n("div"),w(ii.$$.fragment),u1=p(),li=n("p"),f1=o("Construct a \u201Cfast\u201D DistilBERT tokenizer (backed by HuggingFace\u2019s "),vh=n("em"),m1=o("tokenizers"),g1=o(" library). Based on WordPiece."),_1=p(),di=n("p"),b1=o("This tokenizer inherits from "),Nc=n("a"),v1=o("PreTrainedTokenizerFast"),k1=o(` which contains most of the main methods. Users should
refer to this superclass for more information regarding those methods.`),w1=p(),Co=n("div"),w(ci.$$.fragment),T1=p(),kh=n("p"),y1=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:`),$1=p(),pi=n("ul"),Rc=n("li"),F1=o("single sequence: "),wh=n("code"),D1=o("[CLS] X [SEP]"),E1=p(),Wc=n("li"),x1=o("pair of sequences: "),Th=n("code"),B1=o("[CLS] A [SEP] B [SEP]"),M1=p(),It=n("div"),w(hi.$$.fragment),z1=p(),yh=n("p"),C1=o("Create a mask from the two sequences passed to be used in a sequence-pair classification task. A BERT sequence"),A1=p(),w(Zs.$$.fragment),j1=p(),es=n("p"),q1=o("If "),$h=n("code"),P1=o("token_ids_1"),L1=o(" is "),Fh=n("code"),O1=o("None"),I1=o(", this method only returns the first portion of the mask (0s)."),Om=p(),ts=n("h2"),en=n("a"),Dh=n("span"),w(ui.$$.fragment),S1=p(),Eh=n("span"),N1=o("DistilBertModel"),Im=p(),mt=n("div"),w(fi.$$.fragment),R1=p(),xh=n("p"),W1=o("The bare DistilBERT encoder/transformer outputting raw hidden-states without any specific head on top."),U1=p(),mi=n("p"),Q1=o("This model inherits from "),Uc=n("a"),H1=o("PreTrainedModel"),K1=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.)`),V1=p(),gi=n("p"),J1=o("This model is also a PyTorch "),_i=n("a"),G1=o("torch.nn.Module"),X1=o(` subclass.
Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
and behavior.`),Y1=p(),St=n("div"),w(bi.$$.fragment),Z1=p(),os=n("p"),eT=o("The "),Qc=n("a"),tT=o("DistilBertModel"),oT=o(" forward method, overrides the "),Bh=n("code"),sT=o("__call__"),nT=o(" special method."),rT=p(),w(tn.$$.fragment),aT=p(),w(on.$$.fragment),Sm=p(),ss=n("h2"),sn=n("a"),Mh=n("span"),w(vi.$$.fragment),iT=p(),zh=n("span"),lT=o("DistilBertForMaskedLM"),Nm=p(),gt=n("div"),w(ki.$$.fragment),dT=p(),wi=n("p"),cT=o("DistilBert Model with a "),Ch=n("code"),pT=o("masked language modeling"),hT=o(" head on top."),uT=p(),Ti=n("p"),fT=o("This model inherits from "),Hc=n("a"),mT=o("PreTrainedModel"),gT=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.)`),_T=p(),yi=n("p"),bT=o("This model is also a PyTorch "),$i=n("a"),vT=o("torch.nn.Module"),kT=o(` subclass.
Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
and behavior.`),wT=p(),Nt=n("div"),w(Fi.$$.fragment),TT=p(),ns=n("p"),yT=o("The "),Kc=n("a"),$T=o("DistilBertForMaskedLM"),FT=o(" forward method, overrides the "),Ah=n("code"),DT=o("__call__"),ET=o(" special method."),xT=p(),w(nn.$$.fragment),BT=p(),w(rn.$$.fragment),Rm=p(),rs=n("h2"),an=n("a"),jh=n("span"),w(Di.$$.fragment),MT=p(),qh=n("span"),zT=o("DistilBertForSequenceClassification"),Wm=p(),_t=n("div"),w(Ei.$$.fragment),CT=p(),Ph=n("p"),AT=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.`),jT=p(),xi=n("p"),qT=o("This model inherits from "),Vc=n("a"),PT=o("PreTrainedModel"),LT=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.)`),OT=p(),Bi=n("p"),IT=o("This model is also a PyTorch "),Mi=n("a"),ST=o("torch.nn.Module"),NT=o(` subclass.
Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
and behavior.`),RT=p(),$t=n("div"),w(zi.$$.fragment),WT=p(),as=n("p"),UT=o("The "),Jc=n("a"),QT=o("DistilBertForSequenceClassification"),HT=o(" forward method, overrides the "),Lh=n("code"),KT=o("__call__"),VT=o(" special method."),JT=p(),w(ln.$$.fragment),GT=p(),w(dn.$$.fragment),XT=p(),w(cn.$$.fragment),Um=p(),is=n("h2"),pn=n("a"),Oh=n("span"),w(Ci.$$.fragment),YT=p(),Ih=n("span"),ZT=o("DistilBertForMultipleChoice"),Qm=p(),bt=n("div"),w(Ai.$$.fragment),ey=p(),Sh=n("p"),ty=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.`),oy=p(),ji=n("p"),sy=o("This model inherits from "),Gc=n("a"),ny=o("PreTrainedModel"),ry=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.)`),ay=p(),qi=n("p"),iy=o("This model is also a PyTorch "),Pi=n("a"),ly=o("torch.nn.Module"),dy=o(` subclass.
Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
and behavior.`),cy=p(),Rt=n("div"),w(Li.$$.fragment),py=p(),ls=n("p"),hy=o("The "),Xc=n("a"),uy=o("DistilBertForMultipleChoice"),fy=o(" forward method, overrides the "),Nh=n("code"),my=o("__call__"),gy=o(" special method."),_y=p(),w(hn.$$.fragment),by=p(),w(un.$$.fragment),Hm=p(),ds=n("h2"),fn=n("a"),Rh=n("span"),w(Oi.$$.fragment),vy=p(),Wh=n("span"),ky=o("DistilBertForTokenClassification"),Km=p(),vt=n("div"),w(Ii.$$.fragment),wy=p(),Uh=n("p"),Ty=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.`),yy=p(),Si=n("p"),$y=o("This model inherits from "),Yc=n("a"),Fy=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.)`),Ey=p(),Ni=n("p"),xy=o("This model is also a PyTorch "),Ri=n("a"),By=o("torch.nn.Module"),My=o(` subclass.
Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
and behavior.`),zy=p(),Wt=n("div"),w(Wi.$$.fragment),Cy=p(),cs=n("p"),Ay=o("The "),Zc=n("a"),jy=o("DistilBertForTokenClassification"),qy=o(" forward method, overrides the "),Qh=n("code"),Py=o("__call__"),Ly=o(" special method."),Oy=p(),w(mn.$$.fragment),Iy=p(),w(gn.$$.fragment),Vm=p(),ps=n("h2"),_n=n("a"),Hh=n("span"),w(Ui.$$.fragment),Sy=p(),Kh=n("span"),Ny=o("DistilBertForQuestionAnswering"),Jm=p(),kt=n("div"),w(Qi.$$.fragment),Ry=p(),hs=n("p"),Wy=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 `),Vh=n("code"),Uy=o("span start logits"),Qy=o(" and "),Jh=n("code"),Hy=o("span end logits"),Ky=o(")."),Vy=p(),Hi=n("p"),Jy=o("This model inherits from "),ep=n("a"),Gy=o("PreTrainedModel"),Xy=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.)`),Yy=p(),Ki=n("p"),Zy=o("This model is also a PyTorch "),Vi=n("a"),e$=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.`),o$=p(),Ut=n("div"),w(Ji.$$.fragment),s$=p(),us=n("p"),n$=o("The "),tp=n("a"),r$=o("DistilBertForQuestionAnswering"),a$=o(" forward method, overrides the "),Gh=n("code"),i$=o("__call__"),l$=o(" special method."),d$=p(),w(bn.$$.fragment),c$=p(),w(vn.$$.fragment),Gm=p(),fs=n("h2"),kn=n("a"),Xh=n("span"),w(Gi.$$.fragment),p$=p(),Yh=n("span"),h$=o("TFDistilBertModel"),Xm=p(),lt=n("div"),w(Xi.$$.fragment),u$=p(),Zh=n("p"),f$=o("The bare DistilBERT encoder/transformer outputting raw hidden-states without any specific head on top."),m$=p(),Yi=n("p"),g$=o("This model inherits from "),op=n("a"),_$=o("TFPreTrainedModel"),b$=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.)`),v$=p(),Zi=n("p"),k$=o("This model is also a "),el=n("a"),w$=o("tf.keras.Model"),T$=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.`),y$=p(),w(wn.$$.fragment),$$=p(),Qt=n("div"),w(tl.$$.fragment),F$=p(),ms=n("p"),D$=o("The "),sp=n("a"),E$=o("TFDistilBertModel"),x$=o(" forward method, overrides the "),eu=n("code"),B$=o("__call__"),M$=o(" special method."),z$=p(),w(Tn.$$.fragment),C$=p(),w(yn.$$.fragment),Ym=p(),gs=n("h2"),$n=n("a"),tu=n("span"),w(ol.$$.fragment),A$=p(),ou=n("span"),j$=o("TFDistilBertForMaskedLM"),Zm=p(),dt=n("div"),w(sl.$$.fragment),q$=p(),nl=n("p"),P$=o("DistilBert Model with a "),su=n("code"),L$=o("masked language modeling"),O$=o(" head on top."),I$=p(),rl=n("p"),S$=o("This model inherits from "),np=n("a"),N$=o("TFPreTrainedModel"),R$=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.)`),W$=p(),al=n("p"),U$=o("This model is also a "),il=n("a"),Q$=o("tf.keras.Model"),H$=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.`),K$=p(),w(Fn.$$.fragment),V$=p(),Ft=n("div"),w(ll.$$.fragment),J$=p(),_s=n("p"),G$=o("The "),rp=n("a"),X$=o("TFDistilBertForMaskedLM"),Y$=o(" forward method, overrides the "),nu=n("code"),Z$=o("__call__"),e2=o(" special method."),t2=p(),w(Dn.$$.fragment),o2=p(),w(En.$$.fragment),s2=p(),w(xn.$$.fragment),eg=p(),bs=n("h2"),Bn=n("a"),ru=n("span"),w(dl.$$.fragment),n2=p(),au=n("span"),r2=o("TFDistilBertForSequenceClassification"),tg=p(),ct=n("div"),w(cl.$$.fragment),a2=p(),iu=n("p"),i2=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.`),l2=p(),pl=n("p"),d2=o("This model inherits from "),ap=n("a"),c2=o("TFPreTrainedModel"),p2=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.)`),h2=p(),hl=n("p"),u2=o("This model is also a "),ul=n("a"),f2=o("tf.keras.Model"),m2=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.`),g2=p(),w(Mn.$$.fragment),_2=p(),Dt=n("div"),w(fl.$$.fragment),b2=p(),vs=n("p"),v2=o("The "),ip=n("a"),k2=o("TFDistilBertForSequenceClassification"),w2=o(" forward method, overrides the "),lu=n("code"),T2=o("__call__"),y2=o(" special method."),$2=p(),w(zn.$$.fragment),F2=p(),w(Cn.$$.fragment),D2=p(),w(An.$$.fragment),og=p(),ks=n("h2"),jn=n("a"),du=n("span"),w(ml.$$.fragment),E2=p(),cu=n("span"),x2=o("TFDistilBertForMultipleChoice"),sg=p(),pt=n("div"),w(gl.$$.fragment),B2=p(),pu=n("p"),M2=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.`),z2=p(),_l=n("p"),C2=o("This model inherits from "),lp=n("a"),A2=o("TFPreTrainedModel"),j2=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.)`),q2=p(),bl=n("p"),P2=o("This model is also a "),vl=n("a"),L2=o("tf.keras.Model"),O2=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.`),I2=p(),w(qn.$$.fragment),S2=p(),Ht=n("div"),w(kl.$$.fragment),N2=p(),ws=n("p"),R2=o("The "),dp=n("a"),W2=o("TFDistilBertForMultipleChoice"),U2=o(" forward method, overrides the "),hu=n("code"),Q2=o("__call__"),H2=o(" special method."),K2=p(),w(Pn.$$.fragment),V2=p(),w(Ln.$$.fragment),ng=p(),Ts=n("h2"),On=n("a"),uu=n("span"),w(wl.$$.fragment),J2=p(),fu=n("span"),G2=o("TFDistilBertForTokenClassification"),rg=p(),ht=n("div"),w(Tl.$$.fragment),X2=p(),mu=n("p"),Y2=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.`),Z2=p(),yl=n("p"),eF=o("This model inherits from "),cp=n("a"),tF=o("TFPreTrainedModel"),oF=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.)`),sF=p(),$l=n("p"),nF=o("This model is also a "),Fl=n("a"),rF=o("tf.keras.Model"),aF=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.`),iF=p(),w(In.$$.fragment),lF=p(),Et=n("div"),w(Dl.$$.fragment),dF=p(),ys=n("p"),cF=o("The "),pp=n("a"),pF=o("TFDistilBertForTokenClassification"),hF=o(" forward method, overrides the "),gu=n("code"),uF=o("__call__"),fF=o(" special method."),mF=p(),w(Sn.$$.fragment),gF=p(),w(Nn.$$.fragment),_F=p(),w(Rn.$$.fragment),ag=p(),$s=n("h2"),Wn=n("a"),_u=n("span"),w(El.$$.fragment),bF=p(),bu=n("span"),vF=o("TFDistilBertForQuestionAnswering"),ig=p(),ut=n("div"),w(xl.$$.fragment),kF=p(),Fs=n("p"),wF=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 `),vu=n("code"),TF=o("span start logits"),yF=o(" and "),ku=n("code"),$F=o("span end logits"),FF=o(")."),DF=p(),Bl=n("p"),EF=o("This model inherits from "),hp=n("a"),xF=o("TFPreTrainedModel"),BF=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.)`),MF=p(),Ml=n("p"),zF=o("This model is also a "),zl=n("a"),CF=o("tf.keras.Model"),AF=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.`),jF=p(),w(Un.$$.fragment),qF=p(),xt=n("div"),w(Cl.$$.fragment),PF=p(),Ds=n("p"),LF=o("The "),up=n("a"),OF=o("TFDistilBertForQuestionAnswering"),IF=o(" forward method, overrides the "),wu=n("code"),SF=o("__call__"),NF=o(" special method."),RF=p(),w(Qn.$$.fragment),WF=p(),w(Hn.$$.fragment),UF=p(),w(Kn.$$.fragment),lg=p(),Es=n("h2"),Vn=n("a"),Tu=n("span"),w(Al.$$.fragment),QF=p(),yu=n("span"),HF=o("FlaxDistilBertModel"),dg=p(),ot=n("div"),w(jl.$$.fragment),KF=p(),$u=n("p"),VF=o("The bare DistilBert Model transformer outputting raw hidden-states without any specific head on top."),JF=p(),ql=n("p"),GF=o("This model inherits from "),fp=n("a"),XF=o("FlaxPreTrainedModel"),YF=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)`),ZF=p(),Pl=n("p"),e0=o("This model is also a Flax Linen "),Ll=n("a"),t0=o("flax.linen.Module"),o0=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.`),s0=p(),Fu=n("p"),n0=o("Finally, this model supports inherent JAX features such as:"),r0=p(),ao=n("ul"),Du=n("li"),Ol=n("a"),a0=o("Just-In-Time (JIT) compilation"),i0=p(),Eu=n("li"),Il=n("a"),l0=o("Automatic Differentiation"),d0=p(),xu=n("li"),Sl=n("a"),c0=o("Vectorization"),p0=p(),Bu=n("li"),Nl=n("a"),h0=o("Parallelization"),u0=p(),Kt=n("div"),w(Rl.$$.fragment),f0=p(),xs=n("p"),m0=o("The "),Mu=n("code"),g0=o("FlaxDistilBertPreTrainedModel"),_0=o(" forward method, overrides the "),zu=n("code"),b0=o("__call__"),v0=o(" special method."),k0=p(),w(Jn.$$.fragment),w0=p(),w(Gn.$$.fragment),cg=p(),Bs=n("h2"),Xn=n("a"),Cu=n("span"),w(Wl.$$.fragment),T0=p(),Au=n("span"),y0=o("FlaxDistilBertForMaskedLM"),pg=p(),st=n("div"),w(Ul.$$.fragment),$0=p(),Ql=n("p"),F0=o("DistilBert Model with a "),ju=n("code"),D0=o("language modeling"),E0=o(" head on top."),x0=p(),Hl=n("p"),B0=o("This model inherits from "),mp=n("a"),M0=o("FlaxPreTrainedModel"),z0=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)`),C0=p(),Kl=n("p"),A0=o("This model is also a Flax Linen "),Vl=n("a"),j0=o("flax.linen.Module"),q0=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.`),P0=p(),qu=n("p"),L0=o("Finally, this model supports inherent JAX features such as:"),O0=p(),io=n("ul"),Pu=n("li"),Jl=n("a"),I0=o("Just-In-Time (JIT) compilation"),S0=p(),Lu=n("li"),Gl=n("a"),N0=o("Automatic Differentiation"),R0=p(),Ou=n("li"),Xl=n("a"),W0=o("Vectorization"),U0=p(),Iu=n("li"),Yl=n("a"),Q0=o("Parallelization"),H0=p(),Vt=n("div"),w(Zl.$$.fragment),K0=p(),Ms=n("p"),V0=o("The "),Su=n("code"),J0=o("FlaxDistilBertPreTrainedModel"),G0=o(" forward method, overrides the "),Nu=n("code"),X0=o("__call__"),Y0=o(" special method."),Z0=p(),w(Yn.$$.fragment),eD=p(),w(Zn.$$.fragment),hg=p(),zs=n("h2"),er=n("a"),Ru=n("span"),w(ed.$$.fragment),tD=p(),Wu=n("span"),oD=o("FlaxDistilBertForSequenceClassification"),ug=p(),nt=n("div"),w(td.$$.fragment),sD=p(),Uu=n("p"),nD=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.`),rD=p(),od=n("p"),aD=o("This model inherits from "),gp=n("a"),iD=o("FlaxPreTrainedModel"),lD=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)`),dD=p(),sd=n("p"),cD=o("This model is also a Flax Linen "),nd=n("a"),pD=o("flax.linen.Module"),hD=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.`),uD=p(),Qu=n("p"),fD=o("Finally, this model supports inherent JAX features such as:"),mD=p(),lo=n("ul"),Hu=n("li"),rd=n("a"),gD=o("Just-In-Time (JIT) compilation"),_D=p(),Ku=n("li"),ad=n("a"),bD=o("Automatic Differentiation"),vD=p(),Vu=n("li"),id=n("a"),kD=o("Vectorization"),wD=p(),Ju=n("li"),ld=n("a"),TD=o("Parallelization"),yD=p(),Jt=n("div"),w(dd.$$.fragment),$D=p(),Cs=n("p"),FD=o("The "),Gu=n("code"),DD=o("FlaxDistilBertPreTrainedModel"),ED=o(" forward method, overrides the "),Xu=n("code"),xD=o("__call__"),BD=o(" special method."),MD=p(),w(tr.$$.fragment),zD=p(),w(or.$$.fragment),fg=p(),As=n("h2"),sr=n("a"),Yu=n("span"),w(cd.$$.fragment),CD=p(),Zu=n("span"),AD=o("FlaxDistilBertForMultipleChoice"),mg=p(),rt=n("div"),w(pd.$$.fragment),jD=p(),ef=n("p"),qD=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.`),PD=p(),hd=n("p"),LD=o("This model inherits from "),_p=n("a"),OD=o("FlaxPreTrainedModel"),ID=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)`),SD=p(),ud=n("p"),ND=o("This model is also a Flax Linen "),fd=n("a"),RD=o("flax.linen.Module"),WD=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.`),UD=p(),tf=n("p"),QD=o("Finally, this model supports inherent JAX features such as:"),HD=p(),co=n("ul"),of=n("li"),md=n("a"),KD=o("Just-In-Time (JIT) compilation"),VD=p(),sf=n("li"),gd=n("a"),JD=o("Automatic Differentiation"),GD=p(),nf=n("li"),_d=n("a"),XD=o("Vectorization"),YD=p(),rf=n("li"),bd=n("a"),ZD=o("Parallelization"),e4=p(),Gt=n("div"),w(vd.$$.fragment),t4=p(),js=n("p"),o4=o("The "),af=n("code"),s4=o("FlaxDistilBertPreTrainedModel"),n4=o(" forward method, overrides the "),lf=n("code"),r4=o("__call__"),a4=o(" special method."),i4=p(),w(nr.$$.fragment),l4=p(),w(rr.$$.fragment),gg=p(),qs=n("h2"),ar=n("a"),df=n("span"),w(kd.$$.fragment),d4=p(),cf=n("span"),c4=o("FlaxDistilBertForTokenClassification"),_g=p(),at=n("div"),w(wd.$$.fragment),p4=p(),pf=n("p"),h4=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.`),u4=p(),Td=n("p"),f4=o("This model inherits from "),bp=n("a"),m4=o("FlaxPreTrainedModel"),g4=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)`),_4=p(),yd=n("p"),b4=o("This model is also a Flax Linen "),$d=n("a"),v4=o("flax.linen.Module"),k4=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.`),w4=p(),hf=n("p"),T4=o("Finally, this model supports inherent JAX features such as:"),y4=p(),po=n("ul"),uf=n("li"),Fd=n("a"),$4=o("Just-In-Time (JIT) compilation"),F4=p(),ff=n("li"),Dd=n("a"),D4=o("Automatic Differentiation"),E4=p(),mf=n("li"),Ed=n("a"),x4=o("Vectorization"),B4=p(),gf=n("li"),xd=n("a"),M4=o("Parallelization"),z4=p(),Xt=n("div"),w(Bd.$$.fragment),C4=p(),Ps=n("p"),A4=o("The "),_f=n("code"),j4=o("FlaxDistilBertPreTrainedModel"),q4=o(" forward method, overrides the "),bf=n("code"),P4=o("__call__"),L4=o(" special method."),O4=p(),w(ir.$$.fragment),I4=p(),w(lr.$$.fragment),bg=p(),Ls=n("h2"),dr=n("a"),vf=n("span"),w(Md.$$.fragment),S4=p(),kf=n("span"),N4=o("FlaxDistilBertForQuestionAnswering"),vg=p(),it=n("div"),w(zd.$$.fragment),R4=p(),Os=n("p"),W4=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 `),wf=n("code"),U4=o("span start logits"),Q4=o(" and "),Tf=n("code"),H4=o("span end logits"),K4=o(")."),V4=p(),Cd=n("p"),J4=o("This model inherits from "),vp=n("a"),G4=o("FlaxPreTrainedModel"),X4=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)`),Y4=p(),Ad=n("p"),Z4=o("This model is also a Flax Linen "),jd=n("a"),eE=o("flax.linen.Module"),tE=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.`),oE=p(),yf=n("p"),sE=o("Finally, this model supports inherent JAX features such as:"),nE=p(),ho=n("ul"),$f=n("li"),qd=n("a"),rE=o("Just-In-Time (JIT) compilation"),aE=p(),Ff=n("li"),Pd=n("a"),iE=o("Automatic Differentiation"),lE=p(),Df=n("li"),Ld=n("a"),dE=o("Vectorization"),cE=p(),Ef=n("li"),Od=n("a"),pE=o("Parallelization"),hE=p(),Yt=n("div"),w(Id.$$.fragment),uE=p(),Is=n("p"),fE=o("The "),xf=n("code"),mE=o("FlaxDistilBertPreTrainedModel"),gE=o(" forward method, overrides the "),Bf=n("code"),_E=o("__call__"),bE=o(" special method."),vE=p(),w(cr.$$.fragment),kE=p(),w(pr.$$.fragment),this.h()},l(i){const _=p3('[data-svelte="svelte-1phssyn"]',document.head);d=r(_,"META",{name:!0,content:!0}),_.forEach(t),v=h(i),f=r(i,"H1",{class:!0});var Sd=a(f);m=r(Sd,"A",{id:!0,class:!0,href:!0});var Mf=a(m);b=r(Mf,"SPAN",{});var zf=a(b);T(l.$$.fragment,zf),zf.forEach(t),Mf.forEach(t),u=h(Sd),B=r(Sd,"SPAN",{});var Cf=a(B);we=s(Cf,"DistilBERT"),Cf.forEach(t),Sd.forEach(t),_e=h(i),S=r(i,"DIV",{class:!0});var Nd=a(S);ce=r(Nd,"A",{href:!0});var Af=a(ce);Z=r(Af,"IMG",{alt:!0,src:!0}),Af.forEach(t),Te=h(Nd),W=r(Nd,"A",{href:!0});var jf=a(W);pe=r(jf,"IMG",{alt:!0,src:!0}),jf.forEach(t),Nd.forEach(t),J=h(i),oe=r(i,"H2",{class:!0});var Rd=a(oe);ie=r(Rd,"A",{id:!0,class:!0,href:!0});var qf=a(ie);Q=r(qf,"SPAN",{});var Pf=a(Q);T(le.$$.fragment,Pf),Pf.forEach(t),qf.forEach(t),ye=h(Rd),H=r(Rd,"SPAN",{});var Lf=a(H);$e=s(Lf,"Overview"),Lf.forEach(t),Rd.forEach(t),be=h(i),O=r(i,"P",{});var uo=a(O);Fe=s(uo,"The DistilBERT model was proposed in the blog post "),de=r(uo,"A",{href:!0,rel:!0});var Of=a(de);se=s(Of,`Smaller, faster, cheaper, lighter: Introducing DistilBERT, a
distilled version of BERT`),Of.forEach(t),C=s(uo,", and the paper "),A=r(uo,"A",{href:!0,rel:!0});var If=a(A);De=s(If,`DistilBERT, a
distilled version of BERT: smaller, faster, cheaper and lighter`),If.forEach(t),X=s(uo,`. DistilBERT is a
small, fast, cheap and light Transformer model trained by distilling BERT base. It has 40% less parameters than
`),fe=r(uo,"EM",{});var Sf=a(fe);Ee=s(Sf,"bert-base-uncased"),Sf.forEach(t),Y=s(uo,`, runs 60% faster while preserving over 95% of BERT\u2019s performances as measured on the GLUE language
understanding benchmark.`),uo.forEach(t),ve=h(i),he=r(i,"P",{});var Nf=a(he);q=s(Nf,"The abstract from the paper is the following:"),Nf.forEach(t),ke=h(i),U=r(i,"P",{});var Rf=a(U);me=r(Rf,"EM",{});var Wf=a(me);xe=s(Wf,`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.`),Wf.forEach(t),Rf.forEach(t),G=h(i),ue=r(i,"P",{});var Uf=a(ue);Be=s(Uf,"Tips:"),Uf.forEach(t),I=h(i),te=r(i,"UL",{});var Ss=a(te);K=r(Ss,"LI",{});var Qf=a(K);ee=r(Qf,"P",{});var fo=a(ee);ne=s(fo,"DistilBERT doesn\u2019t have "),j=r(fo,"CODE",{});var Hf=a(j);Me=s(Hf,"token_type_ids"),Hf.forEach(t),P=s(fo,`, you don\u2019t need to indicate which token belongs to which segment. Just
separate your segments with the separation token `),ge=r(fo,"CODE",{});var Kf=a(ge);ze=s(Kf,"tokenizer.sep_token"),Kf.forEach(t),k=s(fo," (or "),M=r(fo,"CODE",{});var Vf=a(M);Qe=s(Vf,"[SEP]"),Vf.forEach(t),re=s(fo,")."),fo.forEach(t),Qf.forEach(t),He=h(Ss),Ne=r(Ss,"LI",{});var Jf=a(Ne);z=r(Jf,"P",{});var Wd=a(z);Ke=s(Wd,"DistilBERT doesn\u2019t have options to select the input positions ("),Re=r(Wd,"CODE",{});var Gf=a(Re);Ve=s(Gf,"position_ids"),Gf.forEach(t),Je=s(Wd,` input). This could be added if
necessary though, just let us know if you need this option.`),Wd.forEach(t),Jf.forEach(t),Ge=h(Ss),L=r(Ss,"LI",{});var Ud=a(L);V=r(Ud,"P",{});var Xf=a(V);Xe=s(Xf,"Same as BERT but smaller. Trained by distillation of the pretrained BERT model, meaning it\u2019s been trained to predict the same probabilities as the larger model. The actual objective is a combination of:"),Xf.forEach(t),Ye=h(Ud),N=r(Ud,"UL",{});var Ns=a(N);We=r(Ns,"LI",{});var Yf=a(We);Ze=s(Yf,"finding the same probabilities as the teacher model"),Yf.forEach(t),Ce=h(Ns),Ue=r(Ns,"LI",{});var Zf=a(Ue);ae=s(Zf,"predicting the masked tokens correctly (but no next-sentence objective)"),Zf.forEach(t),et=h(Ns),Jp=r(Ns,"LI",{});var em=a(Jp);J_=s(em,"a cosine similarity between the hidden states of the student and the teacher model"),em.forEach(t),Ns.forEach(t),Ud.forEach(t),Ss.forEach(t),um=h(i),Lt=r(i,"P",{});var mo=a(Lt);G_=s(mo,"This model was contributed by "),qr=r(mo,"A",{href:!0,rel:!0});var tm=a(qr);X_=s(tm,"victorsanh"),tm.forEach(t),Y_=s(mo,`. This model jax version was
contributed by `),Pr=r(mo,"A",{href:!0,rel:!0});var om=a(Pr);Z_=s(om,"kamalkraj"),om.forEach(t),eb=s(mo,". The original code can be found "),Lr=r(mo,"A",{href:!0,rel:!0});var sm=a(Lr);tb=s(sm,"here"),sm.forEach(t),ob=s(mo,"."),mo.forEach(t),fm=h(i),Vo=r(i,"H2",{class:!0});var Qd=a(Vo);Rs=r(Qd,"A",{id:!0,class:!0,href:!0});var nm=a(Rs);Gp=r(nm,"SPAN",{});var rm=a(Gp);T(Or.$$.fragment,rm),rm.forEach(t),nm.forEach(t),sb=h(Qd),Xp=r(Qd,"SPAN",{});var am=a(Xp);nb=s(am,"Resources"),am.forEach(t),Qd.forEach(t),mm=h(i),ic=r(i,"P",{});var im=a(ic);rb=s(im,"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."),im.forEach(t),gm=h(i),T(Ir.$$.fragment,i),_m=h(i),je=r(i,"UL",{});var Oe=a(je);Sr=r(Oe,"LI",{});var Hd=a(Sr);ab=s(Hd,"A blog post on "),Nr=r(Hd,"A",{href:!0,rel:!0});var lm=a(Nr);ib=s(lm,"Getting Started with Sentiment Analysis using Python"),lm.forEach(t),lb=s(Hd," with DistilBERT."),Hd.forEach(t),db=h(Oe),Rr=r(Oe,"LI",{});var Kd=a(Rr);cb=s(Kd,"A blog post on how to "),Wr=r(Kd,"A",{href:!0,rel:!0});var dm=a(Wr);pb=s(dm,"train DistilBERT with Blurr for sequence classification"),dm.forEach(t),hb=s(Kd,"."),Kd.forEach(t),ub=h(Oe),Ur=r(Oe,"LI",{});var Vd=a(Ur);fb=s(Vd,"A blog post on how to use "),Qr=r(Vd,"A",{href:!0,rel:!0});var cm=a(Qr);mb=s(cm,"Ray to tune DistilBERT hyperparameters"),cm.forEach(t),gb=s(Vd,"."),Vd.forEach(t),_b=h(Oe),Hr=r(Oe,"LI",{});var wg=a(Hr);bb=s(wg,"A blog post on how to "),Kr=r(wg,"A",{href:!0,rel:!0});var xE=a(Kr);vb=s(xE,"train DistilBERT with Hugging Face and Amazon SageMaker"),xE.forEach(t),kb=s(wg,"."),wg.forEach(t),wb=h(Oe),Vr=r(Oe,"LI",{});var Tg=a(Vr);Tb=s(Tg,"A notebook on how to "),Jr=r(Tg,"A",{href:!0,rel:!0});var BE=a(Jr);yb=s(BE,"finetune DistilBERT for multi-label classification"),BE.forEach(t),$b=s(Tg,". \u{1F30E}"),Tg.forEach(t),Fb=h(Oe),Gr=r(Oe,"LI",{});var yg=a(Gr);Db=s(yg,"A notebook on how to "),Xr=r(yg,"A",{href:!0,rel:!0});var ME=a(Xr);Eb=s(ME,"finetune DistilBERT for multiclass classification with PyTorch"),ME.forEach(t),xb=s(yg,". \u{1F30E}"),yg.forEach(t),Bb=h(Oe),Yr=r(Oe,"LI",{});var $g=a(Yr);Mb=s($g,"A notebook on how to "),Zr=r($g,"A",{href:!0,rel:!0});var zE=a(Zr);zb=s(zE,"finetune DistilBERT for text classification in TensorFlow"),zE.forEach(t),Cb=s($g,". \u{1F30E}"),$g.forEach(t),Ab=h(Oe),go=r(Oe,"LI",{});var Jd=a(go);lc=r(Jd,"A",{href:!0});var CE=a(lc);jb=s(CE,"DistilBertForSequenceClassification"),CE.forEach(t),qb=s(Jd," is supported by this "),ea=r(Jd,"A",{href:!0,rel:!0});var AE=a(ea);Pb=s(AE,"example script"),AE.forEach(t),Lb=s(Jd," and "),ta=r(Jd,"A",{href:!0,rel:!0});var jE=a(ta);Ob=s(jE,"notebook"),jE.forEach(t),Ib=s(Jd,"."),Jd.forEach(t),Sb=h(Oe),_o=r(Oe,"LI",{});var Gd=a(_o);dc=r(Gd,"A",{href:!0});var qE=a(dc);Nb=s(qE,"TFDistilBertForSequenceClassification"),qE.forEach(t),Rb=s(Gd," is supported by this "),oa=r(Gd,"A",{href:!0,rel:!0});var PE=a(oa);Wb=s(PE,"example script"),PE.forEach(t),Ub=s(Gd," and "),sa=r(Gd,"A",{href:!0,rel:!0});var LE=a(sa);Qb=s(LE,"notebook"),LE.forEach(t),Hb=s(Gd,"."),Gd.forEach(t),Kb=h(Oe),bo=r(Oe,"LI",{});var Xd=a(bo);cc=r(Xd,"A",{href:!0});var OE=a(cc);Vb=s(OE,"FlaxDistilBertForSequenceClassification"),OE.forEach(t),Jb=s(Xd," is supported by this "),na=r(Xd,"A",{href:!0,rel:!0});var IE=a(na);Gb=s(IE,"example script"),IE.forEach(t),Xb=s(Xd," and "),ra=r(Xd,"A",{href:!0,rel:!0});var SE=a(ra);Yb=s(SE,"notebook"),SE.forEach(t),Zb=s(Xd,"."),Xd.forEach(t),ev=h(Oe),Yp=r(Oe,"LI",{});var NE=a(Yp);pc=r(NE,"A",{href:!0});var RE=a(pc);tv=s(RE,"Text classification task guide"),RE.forEach(t),NE.forEach(t),Oe.forEach(t),bm=h(i),T(aa.$$.fragment,i),vm=h(i),wt=r(i,"UL",{});var Ao=a(wt);vo=r(Ao,"LI",{});var Yd=a(vo);hc=r(Yd,"A",{href:!0});var WE=a(hc);ov=s(WE,"DistilBertForTokenClassification"),WE.forEach(t),sv=s(Yd," is supported by this "),ia=r(Yd,"A",{href:!0,rel:!0});var UE=a(ia);nv=s(UE,"example script"),UE.forEach(t),rv=s(Yd," and "),la=r(Yd,"A",{href:!0,rel:!0});var QE=a(la);av=s(QE,"notebook"),QE.forEach(t),iv=s(Yd,"."),Yd.forEach(t),lv=h(Ao),ko=r(Ao,"LI",{});var Zd=a(ko);uc=r(Zd,"A",{href:!0});var HE=a(uc);dv=s(HE,"TFDistilBertForTokenClassification"),HE.forEach(t),cv=s(Zd," is supported by this "),da=r(Zd,"A",{href:!0,rel:!0});var KE=a(da);pv=s(KE,"example script"),KE.forEach(t),hv=s(Zd," and "),ca=r(Zd,"A",{href:!0,rel:!0});var VE=a(ca);uv=s(VE,"notebook"),VE.forEach(t),fv=s(Zd,"."),Zd.forEach(t),mv=h(Ao),Ws=r(Ao,"LI",{});var pm=a(Ws);fc=r(pm,"A",{href:!0});var JE=a(fc);gv=s(JE,"FlaxDistilBertForTokenClassification"),JE.forEach(t),_v=s(pm," is supported by this "),pa=r(pm,"A",{href:!0,rel:!0});var GE=a(pa);bv=s(GE,"example script"),GE.forEach(t),vv=s(pm,"."),pm.forEach(t),kv=h(Ao),mc=r(Ao,"LI",{});var wE=a(mc);ha=r(wE,"A",{href:!0,rel:!0});var XE=a(ha);wv=s(XE,"Token classification"),XE.forEach(t),Tv=s(wE," chapter of the \u{1F917} Hugging Face Course."),wE.forEach(t),yv=h(Ao),Zp=r(Ao,"LI",{});var YE=a(Zp);gc=r(YE,"A",{href:!0});var ZE=a(gc);$v=s(ZE,"Token classification task guide"),ZE.forEach(t),YE.forEach(t),Ao.forEach(t),km=h(i),T(ua.$$.fragment,i),wm=h(i),Tt=r(i,"UL",{});var jo=a(Tt);wo=r(jo,"LI",{});var ec=a(wo);_c=r(ec,"A",{href:!0});var ex=a(_c);Fv=s(ex,"DistilBertForMaskedLM"),ex.forEach(t),Dv=s(ec," is supported by this "),fa=r(ec,"A",{href:!0,rel:!0});var tx=a(fa);Ev=s(tx,"example script"),tx.forEach(t),xv=s(ec," and "),ma=r(ec,"A",{href:!0,rel:!0});var ox=a(ma);Bv=s(ox,"notebook"),ox.forEach(t),Mv=s(ec,"."),ec.forEach(t),zv=h(jo),To=r(jo,"LI",{});var tc=a(To);bc=r(tc,"A",{href:!0});var sx=a(bc);Cv=s(sx,"TFDistilBertForMaskedLM"),sx.forEach(t),Av=s(tc," is supported by this "),ga=r(tc,"A",{href:!0,rel:!0});var nx=a(ga);jv=s(nx,"example script"),nx.forEach(t),qv=s(tc," and "),_a=r(tc,"A",{href:!0,rel:!0});var rx=a(_a);Pv=s(rx,"notebook"),rx.forEach(t),Lv=s(tc,"."),tc.forEach(t),Ov=h(jo),yo=r(jo,"LI",{});var oc=a(yo);vc=r(oc,"A",{href:!0});var ax=a(vc);Iv=s(ax,"FlaxDistilBertForMaskedLM"),ax.forEach(t),Sv=s(oc," is supported by this "),ba=r(oc,"A",{href:!0,rel:!0});var ix=a(ba);Nv=s(ix,"example script"),ix.forEach(t),Rv=s(oc," and "),va=r(oc,"A",{href:!0,rel:!0});var lx=a(va);Wv=s(lx,"notebook"),lx.forEach(t),Uv=s(oc,"."),oc.forEach(t),Qv=h(jo),kc=r(jo,"LI",{});var TE=a(kc);ka=r(TE,"A",{href:!0,rel:!0});var dx=a(ka);Hv=s(dx,"Masked language modeling"),dx.forEach(t),Kv=s(TE," chapter of the \u{1F917} Hugging Face Course."),TE.forEach(t),Vv=h(jo),eh=r(jo,"LI",{});var cx=a(eh);wc=r(cx,"A",{href:!0});var px=a(wc);Jv=s(px,"Masked language modeling task guide"),px.forEach(t),cx.forEach(t),jo.forEach(t),Tm=h(i),T(wa.$$.fragment,i),ym=h(i),yt=r(i,"UL",{});var qo=a(yt);$o=r(qo,"LI",{});var sc=a($o);Tc=r(sc,"A",{href:!0});var hx=a(Tc);Gv=s(hx,"DistilBertForQuestionAnswering"),hx.forEach(t),Xv=s(sc," is supported by this "),Ta=r(sc,"A",{href:!0,rel:!0});var ux=a(Ta);Yv=s(ux,"example script"),ux.forEach(t),Zv=s(sc," and "),ya=r(sc,"A",{href:!0,rel:!0});var fx=a(ya);ek=s(fx,"notebook"),fx.forEach(t),tk=s(sc,"."),sc.forEach(t),ok=h(qo),Fo=r(qo,"LI",{});var nc=a(Fo);yc=r(nc,"A",{href:!0});var mx=a(yc);sk=s(mx,"TFDistilBertForQuestionAnswering"),mx.forEach(t),nk=s(nc," is supported by this "),$a=r(nc,"A",{href:!0,rel:!0});var gx=a($a);rk=s(gx,"example script"),gx.forEach(t),ak=s(nc," and "),Fa=r(nc,"A",{href:!0,rel:!0});var _x=a(Fa);ik=s(_x,"notebook"),_x.forEach(t),lk=s(nc,"."),nc.forEach(t),dk=h(qo),Us=r(qo,"LI",{});var hm=a(Us);$c=r(hm,"A",{href:!0});var bx=a($c);ck=s(bx,"FlaxDistilBertForQuestionAnswering"),bx.forEach(t),pk=s(hm," is supported by this "),Da=r(hm,"A",{href:!0,rel:!0});var vx=a(Da);hk=s(vx,"example script"),vx.forEach(t),uk=s(hm,"."),hm.forEach(t),fk=h(qo),Fc=r(qo,"LI",{});var yE=a(Fc);Ea=r(yE,"A",{href:!0,rel:!0});var kx=a(Ea);mk=s(kx,"Question answering"),kx.forEach(t),gk=s(yE," chapter of the \u{1F917} Hugging Face Course."),yE.forEach(t),_k=h(qo),th=r(qo,"LI",{});var wx=a(th);Dc=r(wx,"A",{href:!0});var Tx=a(Dc);bk=s(Tx,"Question answering task guide"),Tx.forEach(t),wx.forEach(t),qo.forEach(t),$m=h(i),Ec=r(i,"P",{});var yx=a(Ec);oh=r(yx,"STRONG",{});var $x=a(oh);vk=s($x,"Multiple choice"),$x.forEach(t),yx.forEach(t),Fm=h(i),Do=r(i,"UL",{});var kp=a(Do);Eo=r(kp,"LI",{});var rc=a(Eo);xc=r(rc,"A",{href:!0});var Fx=a(xc);kk=s(Fx,"DistilBertForMultipleChoice"),Fx.forEach(t),wk=s(rc," is supported by this "),xa=r(rc,"A",{href:!0,rel:!0});var Dx=a(xa);Tk=s(Dx,"example script"),Dx.forEach(t),yk=s(rc," and "),Ba=r(rc,"A",{href:!0,rel:!0});var Ex=a(Ba);$k=s(Ex,"notebook"),Ex.forEach(t),Fk=s(rc,"."),rc.forEach(t),Dk=h(kp),xo=r(kp,"LI",{});var ac=a(xo);Bc=r(ac,"A",{href:!0});var xx=a(Bc);Ek=s(xx,"TFDistilBertForMultipleChoice"),xx.forEach(t),xk=s(ac," is supported by this "),Ma=r(ac,"A",{href:!0,rel:!0});var Bx=a(Ma);Bk=s(Bx,"example script"),Bx.forEach(t),Mk=s(ac," and "),za=r(ac,"A",{href:!0,rel:!0});var Mx=a(za);zk=s(Mx,"notebook"),Mx.forEach(t),Ck=s(ac,"."),ac.forEach(t),Ak=h(kp),sh=r(kp,"LI",{});var zx=a(sh);Mc=r(zx,"A",{href:!0});var Cx=a(Mc);jk=s(Cx,"Multiple choice task guide"),Cx.forEach(t),zx.forEach(t),kp.forEach(t),Dm=h(i),zc=r(i,"P",{});var Ax=a(zc);qk=s(Ax,"\u2697\uFE0F Optimization"),Ax.forEach(t),Em=h(i),Bo=r(i,"UL",{});var wp=a(Bo);Ca=r(wp,"LI",{});var Fg=a(Ca);Pk=s(Fg,"A blog post on how to "),Aa=r(Fg,"A",{href:!0,rel:!0});var jx=a(Aa);Lk=s(jx,"quantize DistilBERT with \u{1F917} Optimum and Intel"),jx.forEach(t),Ok=s(Fg,"."),Fg.forEach(t),Ik=h(wp),ja=r(wp,"LI",{});var Dg=a(ja);Sk=s(Dg,"A blog post on how "),qa=r(Dg,"A",{href:!0,rel:!0});var qx=a(qa);Nk=s(qx,"Optimizing Transformers for GPUs with \u{1F917} Optimum"),qx.forEach(t),Rk=s(Dg,"."),Dg.forEach(t),Wk=h(wp),Pa=r(wp,"LI",{});var Eg=a(Pa);Uk=s(Eg,"A blog post on "),La=r(Eg,"A",{href:!0,rel:!0});var Px=a(La);Qk=s(Px,"Optimizing Transformers with Hugging Face Optimum"),Px.forEach(t),Hk=s(Eg,"."),Eg.forEach(t),wp.forEach(t),xm=h(i),Cc=r(i,"P",{});var Lx=a(Cc);Kk=s(Lx,"\u26A1\uFE0F Inference"),Lx.forEach(t),Bm=h(i),Qs=r(i,"UL",{});var xg=a(Qs);Oa=r(xg,"LI",{});var Bg=a(Oa);Vk=s(Bg,"A blog post on how to "),Ia=r(Bg,"A",{href:!0,rel:!0});var Ox=a(Ia);Jk=s(Ox,"Accelerate BERT inference with Hugging Face Transformers and AWS Inferentia"),Ox.forEach(t),Gk=s(Bg," with DistilBERT."),Bg.forEach(t),Xk=h(xg),Sa=r(xg,"LI",{});var Mg=a(Sa);Yk=s(Mg,"A blog post on "),Na=r(Mg,"A",{href:!0,rel:!0});var Ix=a(Na);Zk=s(Ix,"Serverless Inference with Hugging Face\u2019s Transformers, DistilBERT and Amazon SageMaker"),Ix.forEach(t),ew=s(Mg,"."),Mg.forEach(t),xg.forEach(t),Mm=h(i),Ac=r(i,"P",{});var Sx=a(Ac);tw=s(Sx,"\u{1F680} Deploy"),Sx.forEach(t),zm=h(i),Mo=r(i,"UL",{});var Tp=a(Mo);Ra=r(Tp,"LI",{});var zg=a(Ra);ow=s(zg,"A blog post on how to "),Wa=r(zg,"A",{href:!0,rel:!0});var Nx=a(Wa);sw=s(Nx,"deploy DistilBERT on Google Cloud"),Nx.forEach(t),nw=s(zg,"."),zg.forEach(t),rw=h(Tp),Ua=r(Tp,"LI",{});var Cg=a(Ua);aw=s(Cg,"A blog post on how to "),Qa=r(Cg,"A",{href:!0,rel:!0});var Rx=a(Qa);iw=s(Rx,"deploy DistilBERT with Amazon SageMaker"),Rx.forEach(t),lw=s(Cg,"."),Cg.forEach(t),dw=h(Tp),Ha=r(Tp,"LI",{});var Ag=a(Ha);cw=s(Ag,"A blog post on how to "),Ka=r(Ag,"A",{href:!0,rel:!0});var Wx=a(Ka);pw=s(Wx,"Deploy BERT with Hugging Face Transformers, Amazon SageMaker and Terraform module"),Wx.forEach(t),hw=s(Ag,"."),Ag.forEach(t),Tp.forEach(t),Cm=h(i),Jo=r(i,"H2",{class:!0});var jg=a(Jo);Hs=r(jg,"A",{id:!0,class:!0,href:!0});var Ux=a(Hs);nh=r(Ux,"SPAN",{});var Qx=a(nh);T(Va.$$.fragment,Qx),Qx.forEach(t),Ux.forEach(t),uw=h(jg),rh=r(jg,"SPAN",{});var Hx=a(rh);fw=s(Hx,"DistilBertConfig"),Hx.forEach(t),jg.forEach(t),Am=h(i),Pt=r(i,"DIV",{class:!0});var hr=a(Pt);T(Ja.$$.fragment,hr),mw=h(hr),ro=r(hr,"P",{});var ur=a(ro);gw=s(ur,"This is the configuration class to store the configuration of a "),jc=r(ur,"A",{href:!0});var Kx=a(jc);_w=s(Kx,"DistilBertModel"),Kx.forEach(t),bw=s(ur," or a "),qc=r(ur,"A",{href:!0});var Vx=a(qc);vw=s(Vx,"TFDistilBertModel"),Vx.forEach(t),kw=s(ur,`. 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
`),Ga=r(ur,"A",{href:!0,rel:!0});var Jx=a(Ga);ww=s(Jx,"distilbert-base-uncased"),Jx.forEach(t),Tw=s(ur," architecture."),ur.forEach(t),yw=h(hr),Go=r(hr,"P",{});var yp=a(Go);$w=s(yp,"Configuration objects inherit from "),Pc=r(yp,"A",{href:!0});var Gx=a(Pc);Fw=s(Gx,"PretrainedConfig"),Gx.forEach(t),Dw=s(yp,` and can be used to control the model outputs. Read the
documentation from `),Lc=r(yp,"A",{href:!0});var Xx=a(Lc);Ew=s(Xx,"PretrainedConfig"),Xx.forEach(t),xw=s(yp," for more information."),yp.forEach(t),Bw=h(hr),T(Ks.$$.fragment,hr),hr.forEach(t),jm=h(i),Xo=r(i,"H2",{class:!0});var qg=a(Xo);Vs=r(qg,"A",{id:!0,class:!0,href:!0});var Yx=a(Vs);ah=r(Yx,"SPAN",{});var Zx=a(ah);T(Xa.$$.fragment,Zx),Zx.forEach(t),Yx.forEach(t),Mw=h(qg),ih=r(qg,"SPAN",{});var eB=a(ih);zw=s(eB,"DistilBertTokenizer"),eB.forEach(t),qg.forEach(t),qm=h(i),tt=r(i,"DIV",{class:!0});var Bt=a(tt);T(Ya.$$.fragment,Bt),Cw=h(Bt),lh=r(Bt,"P",{});var tB=a(lh);Aw=s(tB,"Construct a DistilBERT tokenizer. Based on WordPiece."),tB.forEach(t),jw=h(Bt),Za=r(Bt,"P",{});var Pg=a(Za);qw=s(Pg,"This tokenizer inherits from "),Oc=r(Pg,"A",{href:!0});var oB=a(Oc);Pw=s(oB,"PreTrainedTokenizer"),oB.forEach(t),Lw=s(Pg,` which contains most of the main methods. Users should refer to
this superclass for more information regarding those methods.`),Pg.forEach(t),Ow=h(Bt),zo=r(Bt,"DIV",{class:!0});var $p=a(zo);T(ei.$$.fragment,$p),Iw=h($p),dh=r($p,"P",{});var sB=a(dh);Sw=s(sB,`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:`),sB.forEach(t),Nw=h($p),ti=r($p,"UL",{});var Lg=a(ti);Ic=r(Lg,"LI",{});var $E=a(Ic);Rw=s($E,"single sequence: "),ch=r($E,"CODE",{});var nB=a(ch);Ww=s(nB,"[CLS] X [SEP]"),nB.forEach(t),$E.forEach(t),Uw=h(Lg),Sc=r(Lg,"LI",{});var FE=a(Sc);Qw=s(FE,"pair of sequences: "),ph=r(FE,"CODE",{});var rB=a(ph);Hw=s(rB,"[CLS] A [SEP] B [SEP]"),rB.forEach(t),FE.forEach(t),Lg.forEach(t),$p.forEach(t),Kw=h(Bt),Js=r(Bt,"DIV",{class:!0});var Og=a(Js);T(oi.$$.fragment,Og),Vw=h(Og),hh=r(Og,"P",{});var aB=a(hh);Jw=s(aB,"Converts a sequence of tokens (string) in a single string."),aB.forEach(t),Og.forEach(t),Gw=h(Bt),Ot=r(Bt,"DIV",{class:!0});var fr=a(Ot);T(si.$$.fragment,fr),Xw=h(fr),uh=r(fr,"P",{});var iB=a(uh);Yw=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),Zw=h(fr),T(Gs.$$.fragment,fr),e1=h(fr),Yo=r(fr,"P",{});var Fp=a(Yo);t1=s(Fp,"If "),fh=r(Fp,"CODE",{});var lB=a(fh);o1=s(lB,"token_ids_1"),lB.forEach(t),s1=s(Fp," is "),mh=r(Fp,"CODE",{});var dB=a(mh);n1=s(dB,"None"),dB.forEach(t),r1=s(Fp,", this method only returns the first portion of the mask (0s)."),Fp.forEach(t),fr.forEach(t),a1=h(Bt),Xs=r(Bt,"DIV",{class:!0});var Ig=a(Xs);T(ni.$$.fragment,Ig),i1=h(Ig),ri=r(Ig,"P",{});var Sg=a(ri);l1=s(Sg,`Retrieve sequence ids from a token list that has no special tokens added. This method is called when adding
special tokens using the tokenizer `),gh=r(Sg,"CODE",{});var cB=a(gh);d1=s(cB,"prepare_for_model"),cB.forEach(t),c1=s(Sg," method."),Sg.forEach(t),Ig.forEach(t),Bt.forEach(t),Pm=h(i),Zo=r(i,"H2",{class:!0});var Ng=a(Zo);Ys=r(Ng,"A",{id:!0,class:!0,href:!0});var pB=a(Ys);_h=r(pB,"SPAN",{});var hB=a(_h);T(ai.$$.fragment,hB),hB.forEach(t),pB.forEach(t),p1=h(Ng),bh=r(Ng,"SPAN",{});var uB=a(bh);h1=s(uB,"DistilBertTokenizerFast"),uB.forEach(t),Ng.forEach(t),Lm=h(i),ft=r(i,"DIV",{class:!0});var Po=a(ft);T(ii.$$.fragment,Po),u1=h(Po),li=r(Po,"P",{});var Rg=a(li);f1=s(Rg,"Construct a \u201Cfast\u201D DistilBERT tokenizer (backed by HuggingFace\u2019s "),vh=r(Rg,"EM",{});var fB=a(vh);m1=s(fB,"tokenizers"),fB.forEach(t),g1=s(Rg," library). Based on WordPiece."),Rg.forEach(t),_1=h(Po),di=r(Po,"P",{});var Wg=a(di);b1=s(Wg,"This tokenizer inherits from "),Nc=r(Wg,"A",{href:!0});var mB=a(Nc);v1=s(mB,"PreTrainedTokenizerFast"),mB.forEach(t),k1=s(Wg,` which contains most of the main methods. Users should
refer to this superclass for more information regarding those methods.`),Wg.forEach(t),w1=h(Po),Co=r(Po,"DIV",{class:!0});var Dp=a(Co);T(ci.$$.fragment,Dp),T1=h(Dp),kh=r(Dp,"P",{});var gB=a(kh);y1=s(gB,`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:`),gB.forEach(t),$1=h(Dp),pi=r(Dp,"UL",{});var Ug=a(pi);Rc=r(Ug,"LI",{});var DE=a(Rc);F1=s(DE,"single sequence: "),wh=r(DE,"CODE",{});var _B=a(wh);D1=s(_B,"[CLS] X [SEP]"),_B.forEach(t),DE.forEach(t),E1=h(Ug),Wc=r(Ug,"LI",{});var EE=a(Wc);x1=s(EE,"pair of sequences: "),Th=r(EE,"CODE",{});var bB=a(Th);B1=s(bB,"[CLS] A [SEP] B [SEP]"),bB.forEach(t),EE.forEach(t),Ug.forEach(t),Dp.forEach(t),M1=h(Po),It=r(Po,"DIV",{class:!0});var mr=a(It);T(hi.$$.fragment,mr),z1=h(mr),yh=r(mr,"P",{});var vB=a(yh);C1=s(vB,"Create a mask from the two sequences passed to be used in a sequence-pair classification task. A BERT sequence"),vB.forEach(t),A1=h(mr),T(Zs.$$.fragment,mr),j1=h(mr),es=r(mr,"P",{});var Ep=a(es);q1=s(Ep,"If "),$h=r(Ep,"CODE",{});var kB=a($h);P1=s(kB,"token_ids_1"),kB.forEach(t),L1=s(Ep," is "),Fh=r(Ep,"CODE",{});var wB=a(Fh);O1=s(wB,"None"),wB.forEach(t),I1=s(Ep,", this method only returns the first portion of the mask (0s)."),Ep.forEach(t),mr.forEach(t),Po.forEach(t),Om=h(i),ts=r(i,"H2",{class:!0});var Qg=a(ts);en=r(Qg,"A",{id:!0,class:!0,href:!0});var TB=a(en);Dh=r(TB,"SPAN",{});var yB=a(Dh);T(ui.$$.fragment,yB),yB.forEach(t),TB.forEach(t),S1=h(Qg),Eh=r(Qg,"SPAN",{});var $B=a(Eh);N1=s($B,"DistilBertModel"),$B.forEach(t),Qg.forEach(t),Im=h(i),mt=r(i,"DIV",{class:!0});var Lo=a(mt);T(fi.$$.fragment,Lo),R1=h(Lo),xh=r(Lo,"P",{});var FB=a(xh);W1=s(FB,"The bare DistilBERT encoder/transformer outputting raw hidden-states without any specific head on top."),FB.forEach(t),U1=h(Lo),mi=r(Lo,"P",{});var Hg=a(mi);Q1=s(Hg,"This model inherits from "),Uc=r(Hg,"A",{href:!0});var DB=a(Uc);H1=s(DB,"PreTrainedModel"),DB.forEach(t),K1=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),V1=h(Lo),gi=r(Lo,"P",{});var Kg=a(gi);J1=s(Kg,"This model is also a PyTorch "),_i=r(Kg,"A",{href:!0,rel:!0});var EB=a(_i);G1=s(EB,"torch.nn.Module"),EB.forEach(t),X1=s(Kg,` subclass.
Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
and behavior.`),Kg.forEach(t),Y1=h(Lo),St=r(Lo,"DIV",{class:!0});var gr=a(St);T(bi.$$.fragment,gr),Z1=h(gr),os=r(gr,"P",{});var xp=a(os);eT=s(xp,"The "),Qc=r(xp,"A",{href:!0});var xB=a(Qc);tT=s(xB,"DistilBertModel"),xB.forEach(t),oT=s(xp," forward method, overrides the "),Bh=r(xp,"CODE",{});var BB=a(Bh);sT=s(BB,"__call__"),BB.forEach(t),nT=s(xp," special method."),xp.forEach(t),rT=h(gr),T(tn.$$.fragment,gr),aT=h(gr),T(on.$$.fragment,gr),gr.forEach(t),Lo.forEach(t),Sm=h(i),ss=r(i,"H2",{class:!0});var Vg=a(ss);sn=r(Vg,"A",{id:!0,class:!0,href:!0});var MB=a(sn);Mh=r(MB,"SPAN",{});var zB=a(Mh);T(vi.$$.fragment,zB),zB.forEach(t),MB.forEach(t),iT=h(Vg),zh=r(Vg,"SPAN",{});var CB=a(zh);lT=s(CB,"DistilBertForMaskedLM"),CB.forEach(t),Vg.forEach(t),Nm=h(i),gt=r(i,"DIV",{class:!0});var Oo=a(gt);T(ki.$$.fragment,Oo),dT=h(Oo),wi=r(Oo,"P",{});var Jg=a(wi);cT=s(Jg,"DistilBert Model with a "),Ch=r(Jg,"CODE",{});var AB=a(Ch);pT=s(AB,"masked language modeling"),AB.forEach(t),hT=s(Jg," head on top."),Jg.forEach(t),uT=h(Oo),Ti=r(Oo,"P",{});var Gg=a(Ti);fT=s(Gg,"This model inherits from "),Hc=r(Gg,"A",{href:!0});var jB=a(Hc);mT=s(jB,"PreTrainedModel"),jB.forEach(t),gT=s(Gg,`. 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.)`),Gg.forEach(t),_T=h(Oo),yi=r(Oo,"P",{});var Xg=a(yi);bT=s(Xg,"This model is also a PyTorch "),$i=r(Xg,"A",{href:!0,rel:!0});var qB=a($i);vT=s(qB,"torch.nn.Module"),qB.forEach(t),kT=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),wT=h(Oo),Nt=r(Oo,"DIV",{class:!0});var _r=a(Nt);T(Fi.$$.fragment,_r),TT=h(_r),ns=r(_r,"P",{});var Bp=a(ns);yT=s(Bp,"The "),Kc=r(Bp,"A",{href:!0});var PB=a(Kc);$T=s(PB,"DistilBertForMaskedLM"),PB.forEach(t),FT=s(Bp," forward method, overrides the "),Ah=r(Bp,"CODE",{});var LB=a(Ah);DT=s(LB,"__call__"),LB.forEach(t),ET=s(Bp," special method."),Bp.forEach(t),xT=h(_r),T(nn.$$.fragment,_r),BT=h(_r),T(rn.$$.fragment,_r),_r.forEach(t),Oo.forEach(t),Rm=h(i),rs=r(i,"H2",{class:!0});var Yg=a(rs);an=r(Yg,"A",{id:!0,class:!0,href:!0});var OB=a(an);jh=r(OB,"SPAN",{});var IB=a(jh);T(Di.$$.fragment,IB),IB.forEach(t),OB.forEach(t),MT=h(Yg),qh=r(Yg,"SPAN",{});var SB=a(qh);zT=s(SB,"DistilBertForSequenceClassification"),SB.forEach(t),Yg.forEach(t),Wm=h(i),_t=r(i,"DIV",{class:!0});var Io=a(_t);T(Ei.$$.fragment,Io),CT=h(Io),Ph=r(Io,"P",{});var NB=a(Ph);AT=s(NB,`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.`),NB.forEach(t),jT=h(Io),xi=r(Io,"P",{});var Zg=a(xi);qT=s(Zg,"This model inherits from "),Vc=r(Zg,"A",{href:!0});var RB=a(Vc);PT=s(RB,"PreTrainedModel"),RB.forEach(t),LT=s(Zg,`. Check the superclass documentation for the generic methods the
library implements for all its model (such as downloading or saving, resizing the input embeddings, pruning heads
etc.)`),Zg.forEach(t),OT=h(Io),Bi=r(Io,"P",{});var e_=a(Bi);IT=s(e_,"This model is also a PyTorch "),Mi=r(e_,"A",{href:!0,rel:!0});var WB=a(Mi);ST=s(WB,"torch.nn.Module"),WB.forEach(t),NT=s(e_,` subclass.
Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
and behavior.`),e_.forEach(t),RT=h(Io),$t=r(Io,"DIV",{class:!0});var So=a($t);T(zi.$$.fragment,So),WT=h(So),as=r(So,"P",{});var Mp=a(as);UT=s(Mp,"The "),Jc=r(Mp,"A",{href:!0});var UB=a(Jc);QT=s(UB,"DistilBertForSequenceClassification"),UB.forEach(t),HT=s(Mp," forward method, overrides the "),Lh=r(Mp,"CODE",{});var QB=a(Lh);KT=s(QB,"__call__"),QB.forEach(t),VT=s(Mp," special method."),Mp.forEach(t),JT=h(So),T(ln.$$.fragment,So),GT=h(So),T(dn.$$.fragment,So),XT=h(So),T(cn.$$.fragment,So),So.forEach(t),Io.forEach(t),Um=h(i),is=r(i,"H2",{class:!0});var t_=a(is);pn=r(t_,"A",{id:!0,class:!0,href:!0});var HB=a(pn);Oh=r(HB,"SPAN",{});var KB=a(Oh);T(Ci.$$.fragment,KB),KB.forEach(t),HB.forEach(t),YT=h(t_),Ih=r(t_,"SPAN",{});var VB=a(Ih);ZT=s(VB,"DistilBertForMultipleChoice"),VB.forEach(t),t_.forEach(t),Qm=h(i),bt=r(i,"DIV",{class:!0});var No=a(bt);T(Ai.$$.fragment,No),ey=h(No),Sh=r(No,"P",{});var JB=a(Sh);ty=s(JB,`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.`),JB.forEach(t),oy=h(No),ji=r(No,"P",{});var o_=a(ji);sy=s(o_,"This model inherits from "),Gc=r(o_,"A",{href:!0});var GB=a(Gc);ny=s(GB,"PreTrainedModel"),GB.forEach(t),ry=s(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_.forEach(t),ay=h(No),qi=r(No,"P",{});var s_=a(qi);iy=s(s_,"This model is also a PyTorch "),Pi=r(s_,"A",{href:!0,rel:!0});var XB=a(Pi);ly=s(XB,"torch.nn.Module"),XB.forEach(t),dy=s(s_,` subclass.
Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
and behavior.`),s_.forEach(t),cy=h(No),Rt=r(No,"DIV",{class:!0});var br=a(Rt);T(Li.$$.fragment,br),py=h(br),ls=r(br,"P",{});var zp=a(ls);hy=s(zp,"The "),Xc=r(zp,"A",{href:!0});var YB=a(Xc);uy=s(YB,"DistilBertForMultipleChoice"),YB.forEach(t),fy=s(zp," forward method, overrides the "),Nh=r(zp,"CODE",{});var ZB=a(Nh);my=s(ZB,"__call__"),ZB.forEach(t),gy=s(zp," special method."),zp.forEach(t),_y=h(br),T(hn.$$.fragment,br),by=h(br),T(un.$$.fragment,br),br.forEach(t),No.forEach(t),Hm=h(i),ds=r(i,"H2",{class:!0});var n_=a(ds);fn=r(n_,"A",{id:!0,class:!0,href:!0});var eM=a(fn);Rh=r(eM,"SPAN",{});var tM=a(Rh);T(Oi.$$.fragment,tM),tM.forEach(t),eM.forEach(t),vy=h(n_),Wh=r(n_,"SPAN",{});var oM=a(Wh);ky=s(oM,"DistilBertForTokenClassification"),oM.forEach(t),n_.forEach(t),Km=h(i),vt=r(i,"DIV",{class:!0});var Ro=a(vt);T(Ii.$$.fragment,Ro),wy=h(Ro),Uh=r(Ro,"P",{});var sM=a(Uh);Ty=s(sM,`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.`),sM.forEach(t),yy=h(Ro),Si=r(Ro,"P",{});var r_=a(Si);$y=s(r_,"This model inherits from "),Yc=r(r_,"A",{href:!0});var nM=a(Yc);Fy=s(nM,"PreTrainedModel"),nM.forEach(t),Dy=s(r_,`. 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.)`),r_.forEach(t),Ey=h(Ro),Ni=r(Ro,"P",{});var a_=a(Ni);xy=s(a_,"This model is also a PyTorch "),Ri=r(a_,"A",{href:!0,rel:!0});var rM=a(Ri);By=s(rM,"torch.nn.Module"),rM.forEach(t),My=s(a_,` subclass.
Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
and behavior.`),a_.forEach(t),zy=h(Ro),Wt=r(Ro,"DIV",{class:!0});var vr=a(Wt);T(Wi.$$.fragment,vr),Cy=h(vr),cs=r(vr,"P",{});var Cp=a(cs);Ay=s(Cp,"The "),Zc=r(Cp,"A",{href:!0});var aM=a(Zc);jy=s(aM,"DistilBertForTokenClassification"),aM.forEach(t),qy=s(Cp," forward method, overrides the "),Qh=r(Cp,"CODE",{});var iM=a(Qh);Py=s(iM,"__call__"),iM.forEach(t),Ly=s(Cp," special method."),Cp.forEach(t),Oy=h(vr),T(mn.$$.fragment,vr),Iy=h(vr),T(gn.$$.fragment,vr),vr.forEach(t),Ro.forEach(t),Vm=h(i),ps=r(i,"H2",{class:!0});var i_=a(ps);_n=r(i_,"A",{id:!0,class:!0,href:!0});var lM=a(_n);Hh=r(lM,"SPAN",{});var dM=a(Hh);T(Ui.$$.fragment,dM),dM.forEach(t),lM.forEach(t),Sy=h(i_),Kh=r(i_,"SPAN",{});var cM=a(Kh);Ny=s(cM,"DistilBertForQuestionAnswering"),cM.forEach(t),i_.forEach(t),Jm=h(i),kt=r(i,"DIV",{class:!0});var Wo=a(kt);T(Qi.$$.fragment,Wo),Ry=h(Wo),hs=r(Wo,"P",{});var Ap=a(hs);Wy=s(Ap,`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 `),Vh=r(Ap,"CODE",{});var pM=a(Vh);Uy=s(pM,"span start logits"),pM.forEach(t),Qy=s(Ap," and "),Jh=r(Ap,"CODE",{});var hM=a(Jh);Hy=s(hM,"span end logits"),hM.forEach(t),Ky=s(Ap,")."),Ap.forEach(t),Vy=h(Wo),Hi=r(Wo,"P",{});var l_=a(Hi);Jy=s(l_,"This model inherits from "),ep=r(l_,"A",{href:!0});var uM=a(ep);Gy=s(uM,"PreTrainedModel"),uM.forEach(t),Xy=s(l_,`. 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.)`),l_.forEach(t),Yy=h(Wo),Ki=r(Wo,"P",{});var d_=a(Ki);Zy=s(d_,"This model is also a PyTorch "),Vi=r(d_,"A",{href:!0,rel:!0});var fM=a(Vi);e$=s(fM,"torch.nn.Module"),fM.forEach(t),t$=s(d_,` subclass.
Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
and behavior.`),d_.forEach(t),o$=h(Wo),Ut=r(Wo,"DIV",{class:!0});var kr=a(Ut);T(Ji.$$.fragment,kr),s$=h(kr),us=r(kr,"P",{});var jp=a(us);n$=s(jp,"The "),tp=r(jp,"A",{href:!0});var mM=a(tp);r$=s(mM,"DistilBertForQuestionAnswering"),mM.forEach(t),a$=s(jp," forward method, overrides the "),Gh=r(jp,"CODE",{});var gM=a(Gh);i$=s(gM,"__call__"),gM.forEach(t),l$=s(jp," special method."),jp.forEach(t),d$=h(kr),T(bn.$$.fragment,kr),c$=h(kr),T(vn.$$.fragment,kr),kr.forEach(t),Wo.forEach(t),Gm=h(i),fs=r(i,"H2",{class:!0});var c_=a(fs);kn=r(c_,"A",{id:!0,class:!0,href:!0});var _M=a(kn);Xh=r(_M,"SPAN",{});var bM=a(Xh);T(Gi.$$.fragment,bM),bM.forEach(t),_M.forEach(t),p$=h(c_),Yh=r(c_,"SPAN",{});var vM=a(Yh);h$=s(vM,"TFDistilBertModel"),vM.forEach(t),c_.forEach(t),Xm=h(i),lt=r(i,"DIV",{class:!0});var Zt=a(lt);T(Xi.$$.fragment,Zt),u$=h(Zt),Zh=r(Zt,"P",{});var kM=a(Zh);f$=s(kM,"The bare DistilBERT encoder/transformer outputting raw hidden-states without any specific head on top."),kM.forEach(t),m$=h(Zt),Yi=r(Zt,"P",{});var p_=a(Yi);g$=s(p_,"This model inherits from "),op=r(p_,"A",{href:!0});var wM=a(op);_$=s(wM,"TFPreTrainedModel"),wM.forEach(t),b$=s(p_,`. 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.)`),p_.forEach(t),v$=h(Zt),Zi=r(Zt,"P",{});var h_=a(Zi);k$=s(h_,"This model is also a "),el=r(h_,"A",{href:!0,rel:!0});var TM=a(el);w$=s(TM,"tf.keras.Model"),TM.forEach(t),T$=s(h_,` 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.`),h_.forEach(t),y$=h(Zt),T(wn.$$.fragment,Zt),$$=h(Zt),Qt=r(Zt,"DIV",{class:!0});var wr=a(Qt);T(tl.$$.fragment,wr),F$=h(wr),ms=r(wr,"P",{});var qp=a(ms);D$=s(qp,"The "),sp=r(qp,"A",{href:!0});var yM=a(sp);E$=s(yM,"TFDistilBertModel"),yM.forEach(t),x$=s(qp," forward method, overrides the "),eu=r(qp,"CODE",{});var $M=a(eu);B$=s($M,"__call__"),$M.forEach(t),M$=s(qp," special method."),qp.forEach(t),z$=h(wr),T(Tn.$$.fragment,wr),C$=h(wr),T(yn.$$.fragment,wr),wr.forEach(t),Zt.forEach(t),Ym=h(i),gs=r(i,"H2",{class:!0});var u_=a(gs);$n=r(u_,"A",{id:!0,class:!0,href:!0});var FM=a($n);tu=r(FM,"SPAN",{});var DM=a(tu);T(ol.$$.fragment,DM),DM.forEach(t),FM.forEach(t),A$=h(u_),ou=r(u_,"SPAN",{});var EM=a(ou);j$=s(EM,"TFDistilBertForMaskedLM"),EM.forEach(t),u_.forEach(t),Zm=h(i),dt=r(i,"DIV",{class:!0});var eo=a(dt);T(sl.$$.fragment,eo),q$=h(eo),nl=r(eo,"P",{});var f_=a(nl);P$=s(f_,"DistilBert Model with a "),su=r(f_,"CODE",{});var xM=a(su);L$=s(xM,"masked language modeling"),xM.forEach(t),O$=s(f_," head on top."),f_.forEach(t),I$=h(eo),rl=r(eo,"P",{});var m_=a(rl);S$=s(m_,"This model inherits from "),np=r(m_,"A",{href:!0});var BM=a(np);N$=s(BM,"TFPreTrainedModel"),BM.forEach(t),R$=s(m_,`. 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.)`),m_.forEach(t),W$=h(eo),al=r(eo,"P",{});var g_=a(al);U$=s(g_,"This model is also a "),il=r(g_,"A",{href:!0,rel:!0});var MM=a(il);Q$=s(MM,"tf.keras.Model"),MM.forEach(t),H$=s(g_,` 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.`),g_.forEach(t),K$=h(eo),T(Fn.$$.fragment,eo),V$=h(eo),Ft=r(eo,"DIV",{class:!0});var Uo=a(Ft);T(ll.$$.fragment,Uo),J$=h(Uo),_s=r(Uo,"P",{});var Pp=a(_s);G$=s(Pp,"The "),rp=r(Pp,"A",{href:!0});var zM=a(rp);X$=s(zM,"TFDistilBertForMaskedLM"),zM.forEach(t),Y$=s(Pp," forward method, overrides the "),nu=r(Pp,"CODE",{});var CM=a(nu);Z$=s(CM,"__call__"),CM.forEach(t),e2=s(Pp," special method."),Pp.forEach(t),t2=h(Uo),T(Dn.$$.fragment,Uo),o2=h(Uo),T(En.$$.fragment,Uo),s2=h(Uo),T(xn.$$.fragment,Uo),Uo.forEach(t),eo.forEach(t),eg=h(i),bs=r(i,"H2",{class:!0});var __=a(bs);Bn=r(__,"A",{id:!0,class:!0,href:!0});var AM=a(Bn);ru=r(AM,"SPAN",{});var jM=a(ru);T(dl.$$.fragment,jM),jM.forEach(t),AM.forEach(t),n2=h(__),au=r(__,"SPAN",{});var qM=a(au);r2=s(qM,"TFDistilBertForSequenceClassification"),qM.forEach(t),__.forEach(t),tg=h(i),ct=r(i,"DIV",{class:!0});var to=a(ct);T(cl.$$.fragment,to),a2=h(to),iu=r(to,"P",{});var PM=a(iu);i2=s(PM,`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.`),PM.forEach(t),l2=h(to),pl=r(to,"P",{});var b_=a(pl);d2=s(b_,"This model inherits from "),ap=r(b_,"A",{href:!0});var LM=a(ap);c2=s(LM,"TFPreTrainedModel"),LM.forEach(t),p2=s(b_,`. 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.)`),b_.forEach(t),h2=h(to),hl=r(to,"P",{});var v_=a(hl);u2=s(v_,"This model is also a "),ul=r(v_,"A",{href:!0,rel:!0});var OM=a(ul);f2=s(OM,"tf.keras.Model"),OM.forEach(t),m2=s(v_,` 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.`),v_.forEach(t),g2=h(to),T(Mn.$$.fragment,to),_2=h(to),Dt=r(to,"DIV",{class:!0});var Qo=a(Dt);T(fl.$$.fragment,Qo),b2=h(Qo),vs=r(Qo,"P",{});var Lp=a(vs);v2=s(Lp,"The "),ip=r(Lp,"A",{href:!0});var IM=a(ip);k2=s(IM,"TFDistilBertForSequenceClassification"),IM.forEach(t),w2=s(Lp," forward method, overrides the "),lu=r(Lp,"CODE",{});var SM=a(lu);T2=s(SM,"__call__"),SM.forEach(t),y2=s(Lp," special method."),Lp.forEach(t),$2=h(Qo),T(zn.$$.fragment,Qo),F2=h(Qo),T(Cn.$$.fragment,Qo),D2=h(Qo),T(An.$$.fragment,Qo),Qo.forEach(t),to.forEach(t),og=h(i),ks=r(i,"H2",{class:!0});var k_=a(ks);jn=r(k_,"A",{id:!0,class:!0,href:!0});var NM=a(jn);du=r(NM,"SPAN",{});var RM=a(du);T(ml.$$.fragment,RM),RM.forEach(t),NM.forEach(t),E2=h(k_),cu=r(k_,"SPAN",{});var WM=a(cu);x2=s(WM,"TFDistilBertForMultipleChoice"),WM.forEach(t),k_.forEach(t),sg=h(i),pt=r(i,"DIV",{class:!0});var oo=a(pt);T(gl.$$.fragment,oo),B2=h(oo),pu=r(oo,"P",{});var UM=a(pu);M2=s(UM,`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.`),UM.forEach(t),z2=h(oo),_l=r(oo,"P",{});var w_=a(_l);C2=s(w_,"This model inherits from "),lp=r(w_,"A",{href:!0});var QM=a(lp);A2=s(QM,"TFPreTrainedModel"),QM.forEach(t),j2=s(w_,`. Check the superclass documentation for the generic methods the
library implements for all its model (such as downloading or saving, resizing the input embeddings, pruning heads
etc.)`),w_.forEach(t),q2=h(oo),bl=r(oo,"P",{});var T_=a(bl);P2=s(T_,"This model is also a "),vl=r(T_,"A",{href:!0,rel:!0});var HM=a(vl);L2=s(HM,"tf.keras.Model"),HM.forEach(t),O2=s(T_,` subclass. Use it
as a regular TF 2.0 Keras Model and refer to the TF 2.0 documentation for all matter related to general usage and
behavior.`),T_.forEach(t),I2=h(oo),T(qn.$$.fragment,oo),S2=h(oo),Ht=r(oo,"DIV",{class:!0});var Tr=a(Ht);T(kl.$$.fragment,Tr),N2=h(Tr),ws=r(Tr,"P",{});var Op=a(ws);R2=s(Op,"The "),dp=r(Op,"A",{href:!0});var KM=a(dp);W2=s(KM,"TFDistilBertForMultipleChoice"),KM.forEach(t),U2=s(Op," forward method, overrides the "),hu=r(Op,"CODE",{});var VM=a(hu);Q2=s(VM,"__call__"),VM.forEach(t),H2=s(Op," special method."),Op.forEach(t),K2=h(Tr),T(Pn.$$.fragment,Tr),V2=h(Tr),T(Ln.$$.fragment,Tr),Tr.forEach(t),oo.forEach(t),ng=h(i),Ts=r(i,"H2",{class:!0});var y_=a(Ts);On=r(y_,"A",{id:!0,class:!0,href:!0});var JM=a(On);uu=r(JM,"SPAN",{});var GM=a(uu);T(wl.$$.fragment,GM),GM.forEach(t),JM.forEach(t),J2=h(y_),fu=r(y_,"SPAN",{});var XM=a(fu);G2=s(XM,"TFDistilBertForTokenClassification"),XM.forEach(t),y_.forEach(t),rg=h(i),ht=r(i,"DIV",{class:!0});var so=a(ht);T(Tl.$$.fragment,so),X2=h(so),mu=r(so,"P",{});var YM=a(mu);Y2=s(YM,`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.`),YM.forEach(t),Z2=h(so),yl=r(so,"P",{});var $_=a(yl);eF=s($_,"This model inherits from "),cp=r($_,"A",{href:!0});var ZM=a(cp);tF=s(ZM,"TFPreTrainedModel"),ZM.forEach(t),oF=s($_,`. 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.)`),$_.forEach(t),sF=h(so),$l=r(so,"P",{});var F_=a($l);nF=s(F_,"This model is also a "),Fl=r(F_,"A",{href:!0,rel:!0});var e7=a(Fl);rF=s(e7,"tf.keras.Model"),e7.forEach(t),aF=s(F_,` 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.`),F_.forEach(t),iF=h(so),T(In.$$.fragment,so),lF=h(so),Et=r(so,"DIV",{class:!0});var Ho=a(Et);T(Dl.$$.fragment,Ho),dF=h(Ho),ys=r(Ho,"P",{});var Ip=a(ys);cF=s(Ip,"The "),pp=r(Ip,"A",{href:!0});var t7=a(pp);pF=s(t7,"TFDistilBertForTokenClassification"),t7.forEach(t),hF=s(Ip," forward method, overrides the "),gu=r(Ip,"CODE",{});var o7=a(gu);uF=s(o7,"__call__"),o7.forEach(t),fF=s(Ip," special method."),Ip.forEach(t),mF=h(Ho),T(Sn.$$.fragment,Ho),gF=h(Ho),T(Nn.$$.fragment,Ho),_F=h(Ho),T(Rn.$$.fragment,Ho),Ho.forEach(t),so.forEach(t),ag=h(i),$s=r(i,"H2",{class:!0});var D_=a($s);Wn=r(D_,"A",{id:!0,class:!0,href:!0});var s7=a(Wn);_u=r(s7,"SPAN",{});var n7=a(_u);T(El.$$.fragment,n7),n7.forEach(t),s7.forEach(t),bF=h(D_),bu=r(D_,"SPAN",{});var r7=a(bu);vF=s(r7,"TFDistilBertForQuestionAnswering"),r7.forEach(t),D_.forEach(t),ig=h(i),ut=r(i,"DIV",{class:!0});var no=a(ut);T(xl.$$.fragment,no),kF=h(no),Fs=r(no,"P",{});var Sp=a(Fs);wF=s(Sp,`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 `),vu=r(Sp,"CODE",{});var a7=a(vu);TF=s(a7,"span start logits"),a7.forEach(t),yF=s(Sp," and "),ku=r(Sp,"CODE",{});var i7=a(ku);$F=s(i7,"span end logits"),i7.forEach(t),FF=s(Sp,")."),Sp.forEach(t),DF=h(no),Bl=r(no,"P",{});var E_=a(Bl);EF=s(E_,"This model inherits from "),hp=r(E_,"A",{href:!0});var l7=a(hp);xF=s(l7,"TFPreTrainedModel"),l7.forEach(t),BF=s(E_,`. 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.)`),E_.forEach(t),MF=h(no),Ml=r(no,"P",{});var x_=a(Ml);zF=s(x_,"This model is also a "),zl=r(x_,"A",{href:!0,rel:!0});var d7=a(zl);CF=s(d7,"tf.keras.Model"),d7.forEach(t),AF=s(x_,` 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_.forEach(t),jF=h(no),T(Un.$$.fragment,no),qF=h(no),xt=r(no,"DIV",{class:!0});var Ko=a(xt);T(Cl.$$.fragment,Ko),PF=h(Ko),Ds=r(Ko,"P",{});var Np=a(Ds);LF=s(Np,"The "),up=r(Np,"A",{href:!0});var c7=a(up);OF=s(c7,"TFDistilBertForQuestionAnswering"),c7.forEach(t),IF=s(Np," forward method, overrides the "),wu=r(Np,"CODE",{});var p7=a(wu);SF=s(p7,"__call__"),p7.forEach(t),NF=s(Np," special method."),Np.forEach(t),RF=h(Ko),T(Qn.$$.fragment,Ko),WF=h(Ko),T(Hn.$$.fragment,Ko),UF=h(Ko),T(Kn.$$.fragment,Ko),Ko.forEach(t),no.forEach(t),lg=h(i),Es=r(i,"H2",{class:!0});var B_=a(Es);Vn=r(B_,"A",{id:!0,class:!0,href:!0});var h7=a(Vn);Tu=r(h7,"SPAN",{});var u7=a(Tu);T(Al.$$.fragment,u7),u7.forEach(t),h7.forEach(t),QF=h(B_),yu=r(B_,"SPAN",{});var f7=a(yu);HF=s(f7,"FlaxDistilBertModel"),f7.forEach(t),B_.forEach(t),dg=h(i),ot=r(i,"DIV",{class:!0});var Mt=a(ot);T(jl.$$.fragment,Mt),KF=h(Mt),$u=r(Mt,"P",{});var m7=a($u);VF=s(m7,"The bare DistilBert Model transformer outputting raw hidden-states without any specific head on top."),m7.forEach(t),JF=h(Mt),ql=r(Mt,"P",{});var M_=a(ql);GF=s(M_,"This model inherits from "),fp=r(M_,"A",{href:!0});var g7=a(fp);XF=s(g7,"FlaxPreTrainedModel"),g7.forEach(t),YF=s(M_,`. 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)`),M_.forEach(t),ZF=h(Mt),Pl=r(Mt,"P",{});var z_=a(Pl);e0=s(z_,"This model is also a Flax Linen "),Ll=r(z_,"A",{href:!0,rel:!0});var _7=a(Ll);t0=s(_7,"flax.linen.Module"),_7.forEach(t),o0=s(z_,`
subclass. Use it as a regular Flax linen Module and refer to the Flax documentation for all matter related to
general usage and behavior.`),z_.forEach(t),s0=h(Mt),Fu=r(Mt,"P",{});var b7=a(Fu);n0=s(b7,"Finally, this model supports inherent JAX features such as:"),b7.forEach(t),r0=h(Mt),ao=r(Mt,"UL",{});var yr=a(ao);Du=r(yr,"LI",{});var v7=a(Du);Ol=r(v7,"A",{href:!0,rel:!0});var k7=a(Ol);a0=s(k7,"Just-In-Time (JIT) compilation"),k7.forEach(t),v7.forEach(t),i0=h(yr),Eu=r(yr,"LI",{});var w7=a(Eu);Il=r(w7,"A",{href:!0,rel:!0});var T7=a(Il);l0=s(T7,"Automatic Differentiation"),T7.forEach(t),w7.forEach(t),d0=h(yr),xu=r(yr,"LI",{});var y7=a(xu);Sl=r(y7,"A",{href:!0,rel:!0});var $7=a(Sl);c0=s($7,"Vectorization"),$7.forEach(t),y7.forEach(t),p0=h(yr),Bu=r(yr,"LI",{});var F7=a(Bu);Nl=r(F7,"A",{href:!0,rel:!0});var D7=a(Nl);h0=s(D7,"Parallelization"),D7.forEach(t),F7.forEach(t),yr.forEach(t),u0=h(Mt),Kt=r(Mt,"DIV",{class:!0});var $r=a(Kt);T(Rl.$$.fragment,$r),f0=h($r),xs=r($r,"P",{});var Rp=a(xs);m0=s(Rp,"The "),Mu=r(Rp,"CODE",{});var E7=a(Mu);g0=s(E7,"FlaxDistilBertPreTrainedModel"),E7.forEach(t),_0=s(Rp," forward method, overrides the "),zu=r(Rp,"CODE",{});var x7=a(zu);b0=s(x7,"__call__"),x7.forEach(t),v0=s(Rp," special method."),Rp.forEach(t),k0=h($r),T(Jn.$$.fragment,$r),w0=h($r),T(Gn.$$.fragment,$r),$r.forEach(t),Mt.forEach(t),cg=h(i),Bs=r(i,"H2",{class:!0});var C_=a(Bs);Xn=r(C_,"A",{id:!0,class:!0,href:!0});var B7=a(Xn);Cu=r(B7,"SPAN",{});var M7=a(Cu);T(Wl.$$.fragment,M7),M7.forEach(t),B7.forEach(t),T0=h(C_),Au=r(C_,"SPAN",{});var z7=a(Au);y0=s(z7,"FlaxDistilBertForMaskedLM"),z7.forEach(t),C_.forEach(t),pg=h(i),st=r(i,"DIV",{class:!0});var zt=a(st);T(Ul.$$.fragment,zt),$0=h(zt),Ql=r(zt,"P",{});var A_=a(Ql);F0=s(A_,"DistilBert Model with a "),ju=r(A_,"CODE",{});var C7=a(ju);D0=s(C7,"language modeling"),C7.forEach(t),E0=s(A_," head on top."),A_.forEach(t),x0=h(zt),Hl=r(zt,"P",{});var j_=a(Hl);B0=s(j_,"This model inherits from "),mp=r(j_,"A",{href:!0});var A7=a(mp);M0=s(A7,"FlaxPreTrainedModel"),A7.forEach(t),z0=s(j_,`. 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)`),j_.forEach(t),C0=h(zt),Kl=r(zt,"P",{});var q_=a(Kl);A0=s(q_,"This model is also a Flax Linen "),Vl=r(q_,"A",{href:!0,rel:!0});var j7=a(Vl);j0=s(j7,"flax.linen.Module"),j7.forEach(t),q0=s(q_,`
subclass. Use it as a regular Flax linen Module and refer to the Flax documentation for all matter related to
general usage and behavior.`),q_.forEach(t),P0=h(zt),qu=r(zt,"P",{});var q7=a(qu);L0=s(q7,"Finally, this model supports inherent JAX features such as:"),q7.forEach(t),O0=h(zt),io=r(zt,"UL",{});var Fr=a(io);Pu=r(Fr,"LI",{});var P7=a(Pu);Jl=r(P7,"A",{href:!0,rel:!0});var L7=a(Jl);I0=s(L7,"Just-In-Time (JIT) compilation"),L7.forEach(t),P7.forEach(t),S0=h(Fr),Lu=r(Fr,"LI",{});var O7=a(Lu);Gl=r(O7,"A",{href:!0,rel:!0});var I7=a(Gl);N0=s(I7,"Automatic Differentiation"),I7.forEach(t),O7.forEach(t),R0=h(Fr),Ou=r(Fr,"LI",{});var S7=a(Ou);Xl=r(S7,"A",{href:!0,rel:!0});var N7=a(Xl);W0=s(N7,"Vectorization"),N7.forEach(t),S7.forEach(t),U0=h(Fr),Iu=r(Fr,"LI",{});var R7=a(Iu);Yl=r(R7,"A",{href:!0,rel:!0});var W7=a(Yl);Q0=s(W7,"Parallelization"),W7.forEach(t),R7.forEach(t),Fr.forEach(t),H0=h(zt),Vt=r(zt,"DIV",{class:!0});var Dr=a(Vt);T(Zl.$$.fragment,Dr),K0=h(Dr),Ms=r(Dr,"P",{});var Wp=a(Ms);V0=s(Wp,"The "),Su=r(Wp,"CODE",{});var U7=a(Su);J0=s(U7,"FlaxDistilBertPreTrainedModel"),U7.forEach(t),G0=s(Wp," forward method, overrides the "),Nu=r(Wp,"CODE",{});var Q7=a(Nu);X0=s(Q7,"__call__"),Q7.forEach(t),Y0=s(Wp," special method."),Wp.forEach(t),Z0=h(Dr),T(Yn.$$.fragment,Dr),eD=h(Dr),T(Zn.$$.fragment,Dr),Dr.forEach(t),zt.forEach(t),hg=h(i),zs=r(i,"H2",{class:!0});var P_=a(zs);er=r(P_,"A",{id:!0,class:!0,href:!0});var H7=a(er);Ru=r(H7,"SPAN",{});var K7=a(Ru);T(ed.$$.fragment,K7),K7.forEach(t),H7.forEach(t),tD=h(P_),Wu=r(P_,"SPAN",{});var V7=a(Wu);oD=s(V7,"FlaxDistilBertForSequenceClassification"),V7.forEach(t),P_.forEach(t),ug=h(i),nt=r(i,"DIV",{class:!0});var Ct=a(nt);T(td.$$.fragment,Ct),sD=h(Ct),Uu=r(Ct,"P",{});var J7=a(Uu);nD=s(J7,`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.`),J7.forEach(t),rD=h(Ct),od=r(Ct,"P",{});var L_=a(od);aD=s(L_,"This model inherits from "),gp=r(L_,"A",{href:!0});var G7=a(gp);iD=s(G7,"FlaxPreTrainedModel"),G7.forEach(t),lD=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),dD=h(Ct),sd=r(Ct,"P",{});var O_=a(sd);cD=s(O_,"This model is also a Flax Linen "),nd=r(O_,"A",{href:!0,rel:!0});var X7=a(nd);pD=s(X7,"flax.linen.Module"),X7.forEach(t),hD=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),uD=h(Ct),Qu=r(Ct,"P",{});var Y7=a(Qu);fD=s(Y7,"Finally, this model supports inherent JAX features such as:"),Y7.forEach(t),mD=h(Ct),lo=r(Ct,"UL",{});var Er=a(lo);Hu=r(Er,"LI",{});var Z7=a(Hu);rd=r(Z7,"A",{href:!0,rel:!0});var ez=a(rd);gD=s(ez,"Just-In-Time (JIT) compilation"),ez.forEach(t),Z7.forEach(t),_D=h(Er),Ku=r(Er,"LI",{});var tz=a(Ku);ad=r(tz,"A",{href:!0,rel:!0});var oz=a(ad);bD=s(oz,"Automatic Differentiation"),oz.forEach(t),tz.forEach(t),vD=h(Er),Vu=r(Er,"LI",{});var sz=a(Vu);id=r(sz,"A",{href:!0,rel:!0});var nz=a(id);kD=s(nz,"Vectorization"),nz.forEach(t),sz.forEach(t),wD=h(Er),Ju=r(Er,"LI",{});var rz=a(Ju);ld=r(rz,"A",{href:!0,rel:!0});var az=a(ld);TD=s(az,"Parallelization"),az.forEach(t),rz.forEach(t),Er.forEach(t),yD=h(Ct),Jt=r(Ct,"DIV",{class:!0});var xr=a(Jt);T(dd.$$.fragment,xr),$D=h(xr),Cs=r(xr,"P",{});var Up=a(Cs);FD=s(Up,"The "),Gu=r(Up,"CODE",{});var iz=a(Gu);DD=s(iz,"FlaxDistilBertPreTrainedModel"),iz.forEach(t),ED=s(Up," forward method, overrides the "),Xu=r(Up,"CODE",{});var lz=a(Xu);xD=s(lz,"__call__"),lz.forEach(t),BD=s(Up," special method."),Up.forEach(t),MD=h(xr),T(tr.$$.fragment,xr),zD=h(xr),T(or.$$.fragment,xr),xr.forEach(t),Ct.forEach(t),fg=h(i),As=r(i,"H2",{class:!0});var I_=a(As);sr=r(I_,"A",{id:!0,class:!0,href:!0});var dz=a(sr);Yu=r(dz,"SPAN",{});var cz=a(Yu);T(cd.$$.fragment,cz),cz.forEach(t),dz.forEach(t),CD=h(I_),Zu=r(I_,"SPAN",{});var pz=a(Zu);AD=s(pz,"FlaxDistilBertForMultipleChoice"),pz.forEach(t),I_.forEach(t),mg=h(i),rt=r(i,"DIV",{class:!0});var At=a(rt);T(pd.$$.fragment,At),jD=h(At),ef=r(At,"P",{});var hz=a(ef);qD=s(hz,`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.`),hz.forEach(t),PD=h(At),hd=r(At,"P",{});var S_=a(hd);LD=s(S_,"This model inherits from "),_p=r(S_,"A",{href:!0});var uz=a(_p);OD=s(uz,"FlaxPreTrainedModel"),uz.forEach(t),ID=s(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)`),S_.forEach(t),SD=h(At),ud=r(At,"P",{});var N_=a(ud);ND=s(N_,"This model is also a Flax Linen "),fd=r(N_,"A",{href:!0,rel:!0});var fz=a(fd);RD=s(fz,"flax.linen.Module"),fz.forEach(t),WD=s(N_,`
subclass. Use it as a regular Flax linen Module and refer to the Flax documentation for all matter related to
general usage and behavior.`),N_.forEach(t),UD=h(At),tf=r(At,"P",{});var mz=a(tf);QD=s(mz,"Finally, this model supports inherent JAX features such as:"),mz.forEach(t),HD=h(At),co=r(At,"UL",{});var Br=a(co);of=r(Br,"LI",{});var gz=a(of);md=r(gz,"A",{href:!0,rel:!0});var _z=a(md);KD=s(_z,"Just-In-Time (JIT) compilation"),_z.forEach(t),gz.forEach(t),VD=h(Br),sf=r(Br,"LI",{});var bz=a(sf);gd=r(bz,"A",{href:!0,rel:!0});var vz=a(gd);JD=s(vz,"Automatic Differentiation"),vz.forEach(t),bz.forEach(t),GD=h(Br),nf=r(Br,"LI",{});var kz=a(nf);_d=r(kz,"A",{href:!0,rel:!0});var wz=a(_d);XD=s(wz,"Vectorization"),wz.forEach(t),kz.forEach(t),YD=h(Br),rf=r(Br,"LI",{});var Tz=a(rf);bd=r(Tz,"A",{href:!0,rel:!0});var yz=a(bd);ZD=s(yz,"Parallelization"),yz.forEach(t),Tz.forEach(t),Br.forEach(t),e4=h(At),Gt=r(At,"DIV",{class:!0});var Mr=a(Gt);T(vd.$$.fragment,Mr),t4=h(Mr),js=r(Mr,"P",{});var Qp=a(js);o4=s(Qp,"The "),af=r(Qp,"CODE",{});var $z=a(af);s4=s($z,"FlaxDistilBertPreTrainedModel"),$z.forEach(t),n4=s(Qp," forward method, overrides the "),lf=r(Qp,"CODE",{});var Fz=a(lf);r4=s(Fz,"__call__"),Fz.forEach(t),a4=s(Qp," special method."),Qp.forEach(t),i4=h(Mr),T(nr.$$.fragment,Mr),l4=h(Mr),T(rr.$$.fragment,Mr),Mr.forEach(t),At.forEach(t),gg=h(i),qs=r(i,"H2",{class:!0});var R_=a(qs);ar=r(R_,"A",{id:!0,class:!0,href:!0});var Dz=a(ar);df=r(Dz,"SPAN",{});var Ez=a(df);T(kd.$$.fragment,Ez),Ez.forEach(t),Dz.forEach(t),d4=h(R_),cf=r(R_,"SPAN",{});var xz=a(cf);c4=s(xz,"FlaxDistilBertForTokenClassification"),xz.forEach(t),R_.forEach(t),_g=h(i),at=r(i,"DIV",{class:!0});var jt=a(at);T(wd.$$.fragment,jt),p4=h(jt),pf=r(jt,"P",{});var Bz=a(pf);h4=s(Bz,`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.`),Bz.forEach(t),u4=h(jt),Td=r(jt,"P",{});var W_=a(Td);f4=s(W_,"This model inherits from "),bp=r(W_,"A",{href:!0});var Mz=a(bp);m4=s(Mz,"FlaxPreTrainedModel"),Mz.forEach(t),g4=s(W_,`. 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)`),W_.forEach(t),_4=h(jt),yd=r(jt,"P",{});var U_=a(yd);b4=s(U_,"This model is also a Flax Linen "),$d=r(U_,"A",{href:!0,rel:!0});var zz=a($d);v4=s(zz,"flax.linen.Module"),zz.forEach(t),k4=s(U_,`
subclass. Use it as a regular Flax linen Module and refer to the Flax documentation for all matter related to
general usage and behavior.`),U_.forEach(t),w4=h(jt),hf=r(jt,"P",{});var Cz=a(hf);T4=s(Cz,"Finally, this model supports inherent JAX features such as:"),Cz.forEach(t),y4=h(jt),po=r(jt,"UL",{});var zr=a(po);uf=r(zr,"LI",{});var Az=a(uf);Fd=r(Az,"A",{href:!0,rel:!0});var jz=a(Fd);$4=s(jz,"Just-In-Time (JIT) compilation"),jz.forEach(t),Az.forEach(t),F4=h(zr),ff=r(zr,"LI",{});var qz=a(ff);Dd=r(qz,"A",{href:!0,rel:!0});var Pz=a(Dd);D4=s(Pz,"Automatic Differentiation"),Pz.forEach(t),qz.forEach(t),E4=h(zr),mf=r(zr,"LI",{});var Lz=a(mf);Ed=r(Lz,"A",{href:!0,rel:!0});var Oz=a(Ed);x4=s(Oz,"Vectorization"),Oz.forEach(t),Lz.forEach(t),B4=h(zr),gf=r(zr,"LI",{});var Iz=a(gf);xd=r(Iz,"A",{href:!0,rel:!0});var Sz=a(xd);M4=s(Sz,"Parallelization"),Sz.forEach(t),Iz.forEach(t),zr.forEach(t),z4=h(jt),Xt=r(jt,"DIV",{class:!0});var Cr=a(Xt);T(Bd.$$.fragment,Cr),C4=h(Cr),Ps=r(Cr,"P",{});var Hp=a(Ps);A4=s(Hp,"The "),_f=r(Hp,"CODE",{});var Nz=a(_f);j4=s(Nz,"FlaxDistilBertPreTrainedModel"),Nz.forEach(t),q4=s(Hp," forward method, overrides the "),bf=r(Hp,"CODE",{});var Rz=a(bf);P4=s(Rz,"__call__"),Rz.forEach(t),L4=s(Hp," special method."),Hp.forEach(t),O4=h(Cr),T(ir.$$.fragment,Cr),I4=h(Cr),T(lr.$$.fragment,Cr),Cr.forEach(t),jt.forEach(t),bg=h(i),Ls=r(i,"H2",{class:!0});var Q_=a(Ls);dr=r(Q_,"A",{id:!0,class:!0,href:!0});var Wz=a(dr);vf=r(Wz,"SPAN",{});var Uz=a(vf);T(Md.$$.fragment,Uz),Uz.forEach(t),Wz.forEach(t),S4=h(Q_),kf=r(Q_,"SPAN",{});var Qz=a(kf);N4=s(Qz,"FlaxDistilBertForQuestionAnswering"),Qz.forEach(t),Q_.forEach(t),vg=h(i),it=r(i,"DIV",{class:!0});var qt=a(it);T(zd.$$.fragment,qt),R4=h(qt),Os=r(qt,"P",{});var Kp=a(Os);W4=s(Kp,`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 `),wf=r(Kp,"CODE",{});var Hz=a(wf);U4=s(Hz,"span start logits"),Hz.forEach(t),Q4=s(Kp," and "),Tf=r(Kp,"CODE",{});var Kz=a(Tf);H4=s(Kz,"span end logits"),Kz.forEach(t),K4=s(Kp,")."),Kp.forEach(t),V4=h(qt),Cd=r(qt,"P",{});var H_=a(Cd);J4=s(H_,"This model inherits from "),vp=r(H_,"A",{href:!0});var Vz=a(vp);G4=s(Vz,"FlaxPreTrainedModel"),Vz.forEach(t),X4=s(H_,`. 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)`),H_.forEach(t),Y4=h(qt),Ad=r(qt,"P",{});var K_=a(Ad);Z4=s(K_,"This model is also a Flax Linen "),jd=r(K_,"A",{href:!0,rel:!0});var Jz=a(jd);eE=s(Jz,"flax.linen.Module"),Jz.forEach(t),tE=s(K_,`
subclass. Use it as a regular Flax linen Module and refer to the Flax documentation for all matter related to
general usage and behavior.`),K_.forEach(t),oE=h(qt),yf=r(qt,"P",{});var Gz=a(yf);sE=s(Gz,"Finally, this model supports inherent JAX features such as:"),Gz.forEach(t),nE=h(qt),ho=r(qt,"UL",{});var Ar=a(ho);$f=r(Ar,"LI",{});var Xz=a($f);qd=r(Xz,"A",{href:!0,rel:!0});var Yz=a(qd);rE=s(Yz,"Just-In-Time (JIT) compilation"),Yz.forEach(t),Xz.forEach(t),aE=h(Ar),Ff=r(Ar,"LI",{});var Zz=a(Ff);Pd=r(Zz,"A",{href:!0,rel:!0});var e3=a(Pd);iE=s(e3,"Automatic Differentiation"),e3.forEach(t),Zz.forEach(t),lE=h(Ar),Df=r(Ar,"LI",{});var t3=a(Df);Ld=r(t3,"A",{href:!0,rel:!0});var o3=a(Ld);dE=s(o3,"Vectorization"),o3.forEach(t),t3.forEach(t),cE=h(Ar),Ef=r(Ar,"LI",{});var s3=a(Ef);Od=r(s3,"A",{href:!0,rel:!0});var n3=a(Od);pE=s(n3,"Parallelization"),n3.forEach(t),s3.forEach(t),Ar.forEach(t),hE=h(qt),Yt=r(qt,"DIV",{class:!0});var jr=a(Yt);T(Id.$$.fragment,jr),uE=h(jr),Is=r(jr,"P",{});var Vp=a(Is);fE=s(Vp,"The "),xf=r(Vp,"CODE",{});var r3=a(xf);mE=s(r3,"FlaxDistilBertPreTrainedModel"),r3.forEach(t),gE=s(Vp," forward method, overrides the "),Bf=r(Vp,"CODE",{});var a3=a(Bf);_E=s(a3,"__call__"),a3.forEach(t),bE=s(Vp," special method."),Vp.forEach(t),vE=h(jr),T(cr.$$.fragment,jr),kE=h(jr),T(pr.$$.fragment,jr),jr.forEach(t),qt.forEach(t),this.h()},h(){c(d,"name","hf:doc:metadata"),c(d,"content",JSON.stringify(cC)),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(Z,"alt","Models"),i3(Z.src,E="https://img.shields.io/badge/All_model_pages-distilbert-blueviolet")||c(Z,"src",E),c(ce,"href","https://huggingface.co/models?filter=distilbert"),c(pe,"alt","Spaces"),i3(pe.src,Ae="https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Spaces-blue")||c(pe,"src",Ae),c(W,"href","https://huggingface.co/spaces/docs-demos/distilbert-base-uncased"),c(S,"class","flex flex-wrap space-x-1"),c(ie,"id","overview"),c(ie,"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(ie,"href","#overview"),c(oe,"class","relative group"),c(de,"href","https://medium.com/huggingface/distilbert-8cf3380435b5"),c(de,"rel","nofollow"),c(A,"href","https://arxiv.org/abs/1910.01108"),c(A,"rel","nofollow"),c(qr,"href","https://huggingface.co/victorsanh"),c(qr,"rel","nofollow"),c(Pr,"href","https://huggingface.co/kamalkraj"),c(Pr,"rel","nofollow"),c(Lr,"href","https://github.com/huggingface/transformers/tree/main/examples/research_projects/distillation"),c(Lr,"rel","nofollow"),c(Rs,"id","resources"),c(Rs,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),c(Rs,"href","#resources"),c(Vo,"class","relative group"),c(Nr,"href","https://huggingface.co/blog/sentiment-analysis-python"),c(Nr,"rel","nofollow"),c(Wr,"href","https://huggingface.co/blog/fastai"),c(Wr,"rel","nofollow"),c(Qr,"href","https://huggingface.co/blog/ray-tune"),c(Qr,"rel","nofollow"),c(Kr,"href","https://huggingface.co/blog/the-partnership-amazon-sagemaker-and-hugging-face"),c(Kr,"rel","nofollow"),c(Jr,"href","https://colab.research.google.com/github/DhavalTaunk08/Transformers_scripts/blob/master/Transformers_multilabel_distilbert.ipynb"),c(Jr,"rel","nofollow"),c(Xr,"href","https://colab.research.google.com/github/abhimishra91/transformers-tutorials/blob/master/transformers_multiclass_classification.ipynb"),c(Xr,"rel","nofollow"),c(Zr,"href","https://colab.research.google.com/github/peterbayerle/huggingface_notebook/blob/main/distilbert_tf.ipynb"),c(Zr,"rel","nofollow"),c(lc,"href","/docs/transformers/v4.27.1/en/model_doc/distilbert#transformers.DistilBertForSequenceClassification"),c(ea,"href","https://github.com/huggingface/transformers/tree/main/examples/pytorch/text-classification"),c(ea,"rel","nofollow"),c(ta,"href","https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/text_classification.ipynb"),c(ta,"rel","nofollow"),c(dc,"href","/docs/transformers/v4.27.1/en/model_doc/distilbert#transformers.TFDistilBertForSequenceClassification"),c(oa,"href","https://github.com/huggingface/transformers/tree/main/examples/tensorflow/text-classification"),c(oa,"rel","nofollow"),c(sa,"href","https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/text_classification-tf.ipynb"),c(sa,"rel","nofollow"),c(cc,"href","/docs/transformers/v4.27.1/en/model_doc/distilbert#transformers.FlaxDistilBertForSequenceClassification"),c(na,"href","https://github.com/huggingface/transformers/tree/main/examples/flax/text-classification"),c(na,"rel","nofollow"),c(ra,"href","https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/text_classification_flax.ipynb"),c(ra,"rel","nofollow"),c(pc,"href","./tasks/sequence_classification"),c(hc,"href","/docs/transformers/v4.27.1/en/model_doc/distilbert#transformers.DistilBertForTokenClassification"),c(ia,"href","https://github.com/huggingface/transformers/tree/main/examples/pytorch/token-classification"),c(ia,"rel","nofollow"),c(la,"href","https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/token_classification.ipynb"),c(la,"rel","nofollow"),c(uc,"href","/docs/transformers/v4.27.1/en/model_doc/distilbert#transformers.TFDistilBertForTokenClassification"),c(da,"href","https://github.com/huggingface/transformers/tree/main/examples/tensorflow/token-classification"),c(da,"rel","nofollow"),c(ca,"href","https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/token_classification-tf.ipynb"),c(ca,"rel","nofollow"),c(fc,"href","/docs/transformers/v4.27.1/en/model_doc/distilbert#transformers.FlaxDistilBertForTokenClassification"),c(pa,"href","https://github.com/huggingface/transformers/tree/main/examples/flax/token-classification"),c(pa,"rel","nofollow"),c(ha,"href","https://huggingface.co/course/chapter7/2?fw=pt"),c(ha,"rel","nofollow"),c(gc,"href","./tasks/token_classification"),c(_c,"href","/docs/transformers/v4.27.1/en/model_doc/distilbert#transformers.DistilBertForMaskedLM"),c(fa,"href","https://github.com/huggingface/transformers/tree/main/examples/pytorch/language-modeling#robertabertdistilbert-and-masked-language-modeling"),c(fa,"rel","nofollow"),c(ma,"href","https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/language_modeling.ipynb"),c(ma,"rel","nofollow"),c(bc,"href","/docs/transformers/v4.27.1/en/model_doc/distilbert#transformers.TFDistilBertForMaskedLM"),c(ga,"href","https://github.com/huggingface/transformers/tree/main/examples/tensorflow/language-modeling#run_mlmpy"),c(ga,"rel","nofollow"),c(_a,"href","https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/language_modeling-tf.ipynb"),c(_a,"rel","nofollow"),c(vc,"href","/docs/transformers/v4.27.1/en/model_doc/distilbert#transformers.FlaxDistilBertForMaskedLM"),c(ba,"href","https://github.com/huggingface/transformers/tree/main/examples/flax/language-modeling#masked-language-modeling"),c(ba,"rel","nofollow"),c(va,"href","https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/masked_language_modeling_flax.ipynb"),c(va,"rel","nofollow"),c(ka,"href","https://huggingface.co/course/chapter7/3?fw=pt"),c(ka,"rel","nofollow"),c(wc,"href","./tasks/masked_language_modeling"),c(Tc,"href","/docs/transformers/v4.27.1/en/model_doc/distilbert#transformers.DistilBertForQuestionAnswering"),c(Ta,"href","https://github.com/huggingface/transformers/tree/main/examples/pytorch/question-answering"),c(Ta,"rel","nofollow"),c(ya,"href","https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/question_answering.ipynb"),c(ya,"rel","nofollow"),c(yc,"href","/docs/transformers/v4.27.1/en/model_doc/distilbert#transformers.TFDistilBertForQuestionAnswering"),c($a,"href","https://github.com/huggingface/transformers/tree/main/examples/tensorflow/question-answering"),c($a,"rel","nofollow"),c(Fa,"href","https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/question_answering-tf.ipynb"),c(Fa,"rel","nofollow"),c($c,"href","/docs/transformers/v4.27.1/en/model_doc/distilbert#transformers.FlaxDistilBertForQuestionAnswering"),c(Da,"href","https://github.com/huggingface/transformers/tree/main/examples/flax/question-answering"),c(Da,"rel","nofollow"),c(Ea,"href","https://huggingface.co/course/chapter7/7?fw=pt"),c(Ea,"rel","nofollow"),c(Dc,"href","./tasks/question_answering"),c(xc,"href","/docs/transformers/v4.27.1/en/model_doc/distilbert#transformers.DistilBertForMultipleChoice"),c(xa,"href","https://github.com/huggingface/transformers/tree/main/examples/pytorch/multiple-choice"),c(xa,"rel","nofollow"),c(Ba,"href","https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/multiple_choice.ipynb"),c(Ba,"rel","nofollow"),c(Bc,"href","/docs/transformers/v4.27.1/en/model_doc/distilbert#transformers.TFDistilBertForMultipleChoice"),c(Ma,"href","https://github.com/huggingface/transformers/tree/main/examples/tensorflow/multiple-choice"),c(Ma,"rel","nofollow"),c(za,"href","https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/multiple_choice-tf.ipynb"),c(za,"rel","nofollow"),c(Mc,"href","./tasks/multiple_choice"),c(Aa,"href","https://huggingface.co/blog/intel"),c(Aa,"rel","nofollow"),c(qa,"href","https://www.philschmid.de/optimizing-transformers-with-optimum-gpu"),c(qa,"rel","nofollow"),c(La,"href","https://www.philschmid.de/optimizing-transformers-with-optimum"),c(La,"rel","nofollow"),c(Ia,"href","https://huggingface.co/blog/bert-inferentia-sagemaker"),c(Ia,"rel","nofollow"),c(Na,"href","https://www.philschmid.de/sagemaker-serverless-huggingface-distilbert"),c(Na,"rel","nofollow"),c(Wa,"href","https://huggingface.co/blog/how-to-deploy-a-pipeline-to-google-clouds"),c(Wa,"rel","nofollow"),c(Qa,"href","https://huggingface.co/blog/deploy-hugging-face-models-easily-with-amazon-sagemaker"),c(Qa,"rel","nofollow"),c(Ka,"href","https://www.philschmid.de/terraform-huggingface-amazon-sagemaker"),c(Ka,"rel","nofollow"),c(Hs,"id","transformers.DistilBertConfig"),c(Hs,"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(Hs,"href","#transformers.DistilBertConfig"),c(Jo,"class","relative group"),c(jc,"href","/docs/transformers/v4.27.1/en/model_doc/distilbert#transformers.DistilBertModel"),c(qc,"href","/docs/transformers/v4.27.1/en/model_doc/distilbert#transformers.TFDistilBertModel"),c(Ga,"href","https://huggingface.co/distilbert-base-uncased"),c(Ga,"rel","nofollow"),c(Pc,"href","/docs/transformers/v4.27.1/en/main_classes/configuration#transformers.PretrainedConfig"),c(Lc,"href","/docs/transformers/v4.27.1/en/main_classes/configuration#transformers.PretrainedConfig"),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(Vs,"id","transformers.DistilBertTokenizer"),c(Vs,"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(Vs,"href","#transformers.DistilBertTokenizer"),c(Xo,"class","relative group"),c(Oc,"href","/docs/transformers/v4.27.1/en/main_classes/tokenizer#transformers.PreTrainedTokenizer"),c(zo,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),c(Js,"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(Xs,"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(Ys,"id","transformers.DistilBertTokenizerFast"),c(Ys,"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(Ys,"href","#transformers.DistilBertTokenizerFast"),c(Zo,"class","relative group"),c(Nc,"href","/docs/transformers/v4.27.1/en/main_classes/tokenizer#transformers.PreTrainedTokenizerFast"),c(Co,"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"),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(en,"id","transformers.DistilBertModel"),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.DistilBertModel"),c(ts,"class","relative group"),c(Uc,"href","/docs/transformers/v4.27.1/en/main_classes/model#transformers.PreTrainedModel"),c(_i,"href","https://pytorch.org/docs/stable/nn.html#torch.nn.Module"),c(_i,"rel","nofollow"),c(Qc,"href","/docs/transformers/v4.27.1/en/model_doc/distilbert#transformers.DistilBertModel"),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(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(sn,"id","transformers.DistilBertForMaskedLM"),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.DistilBertForMaskedLM"),c(ss,"class","relative group"),c(Hc,"href","/docs/transformers/v4.27.1/en/main_classes/model#transformers.PreTrainedModel"),c($i,"href","https://pytorch.org/docs/stable/nn.html#torch.nn.Module"),c($i,"rel","nofollow"),c(Kc,"href","/docs/transformers/v4.27.1/en/model_doc/distilbert#transformers.DistilBertForMaskedLM"),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(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(an,"id","transformers.DistilBertForSequenceClassification"),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.DistilBertForSequenceClassification"),c(rs,"class","relative group"),c(Vc,"href","/docs/transformers/v4.27.1/en/main_classes/model#transformers.PreTrainedModel"),c(Mi,"href","https://pytorch.org/docs/stable/nn.html#torch.nn.Module"),c(Mi,"rel","nofollow"),c(Jc,"href","/docs/transformers/v4.27.1/en/model_doc/distilbert#transformers.DistilBertForSequenceClassification"),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(_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(pn,"id","transformers.DistilBertForMultipleChoice"),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.DistilBertForMultipleChoice"),c(is,"class","relative group"),c(Gc,"href","/docs/transformers/v4.27.1/en/main_classes/model#transformers.PreTrainedModel"),c(Pi,"href","https://pytorch.org/docs/stable/nn.html#torch.nn.Module"),c(Pi,"rel","nofollow"),c(Xc,"href","/docs/transformers/v4.27.1/en/model_doc/distilbert#transformers.DistilBertForMultipleChoice"),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(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(fn,"id","transformers.DistilBertForTokenClassification"),c(fn,"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(fn,"href","#transformers.DistilBertForTokenClassification"),c(ds,"class","relative group"),c(Yc,"href","/docs/transformers/v4.27.1/en/main_classes/model#transformers.PreTrainedModel"),c(Ri,"href","https://pytorch.org/docs/stable/nn.html#torch.nn.Module"),c(Ri,"rel","nofollow"),c(Zc,"href","/docs/transformers/v4.27.1/en/model_doc/distilbert#transformers.DistilBertForTokenClassification"),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(_n,"id","transformers.DistilBertForQuestionAnswering"),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.DistilBertForQuestionAnswering"),c(ps,"class","relative group"),c(ep,"href","/docs/transformers/v4.27.1/en/main_classes/model#transformers.PreTrainedModel"),c(Vi,"href","https://pytorch.org/docs/stable/nn.html#torch.nn.Module"),c(Vi,"rel","nofollow"),c(tp,"href","/docs/transformers/v4.27.1/en/model_doc/distilbert#transformers.DistilBertForQuestionAnswering"),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(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(kn,"id","transformers.TFDistilBertModel"),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.TFDistilBertModel"),c(fs,"class","relative group"),c(op,"href","/docs/transformers/v4.27.1/en/main_classes/model#transformers.TFPreTrainedModel"),c(el,"href","https://www.tensorflow.org/api_docs/python/tf/keras/Model"),c(el,"rel","nofollow"),c(sp,"href","/docs/transformers/v4.27.1/en/model_doc/distilbert#transformers.TFDistilBertModel"),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(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(gs,"class","relative group"),c(np,"href","/docs/transformers/v4.27.1/en/main_classes/model#transformers.TFPreTrainedModel"),c(il,"href","https://www.tensorflow.org/api_docs/python/tf/keras/Model"),c(il,"rel","nofollow"),c(rp,"href","/docs/transformers/v4.27.1/en/model_doc/distilbert#transformers.TFDistilBertForMaskedLM"),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(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(Bn,"id","transformers.TFDistilBertForSequenceClassification"),c(Bn,"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(Bn,"href","#transformers.TFDistilBertForSequenceClassification"),c(bs,"class","relative group"),c(ap,"href","/docs/transformers/v4.27.1/en/main_classes/model#transformers.TFPreTrainedModel"),c(ul,"href","https://www.tensorflow.org/api_docs/python/tf/keras/Model"),c(ul,"rel","nofollow"),c(ip,"href","/docs/transformers/v4.27.1/en/model_doc/distilbert#transformers.TFDistilBertForSequenceClassification"),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(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(jn,"id","transformers.TFDistilBertForMultipleChoice"),c(jn,"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(jn,"href","#transformers.TFDistilBertForMultipleChoice"),c(ks,"class","relative group"),c(lp,"href","/docs/transformers/v4.27.1/en/main_classes/model#transformers.TFPreTrainedModel"),c(vl,"href","https://www.tensorflow.org/api_docs/python/tf/keras/Model"),c(vl,"rel","nofollow"),c(dp,"href","/docs/transformers/v4.27.1/en/model_doc/distilbert#transformers.TFDistilBertForMultipleChoice"),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(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(On,"id","transformers.TFDistilBertForTokenClassification"),c(On,"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(On,"href","#transformers.TFDistilBertForTokenClassification"),c(Ts,"class","relative group"),c(cp,"href","/docs/transformers/v4.27.1/en/main_classes/model#transformers.TFPreTrainedModel"),c(Fl,"href","https://www.tensorflow.org/api_docs/python/tf/keras/Model"),c(Fl,"rel","nofollow"),c(pp,"href","/docs/transformers/v4.27.1/en/model_doc/distilbert#transformers.TFDistilBertForTokenClassification"),c(Et,"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(Wn,"id","transformers.TFDistilBertForQuestionAnswering"),c(Wn,"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(Wn,"href","#transformers.TFDistilBertForQuestionAnswering"),c($s,"class","relative group"),c(hp,"href","/docs/transformers/v4.27.1/en/main_classes/model#transformers.TFPreTrainedModel"),c(zl,"href","https://www.tensorflow.org/api_docs/python/tf/keras/Model"),c(zl,"rel","nofollow"),c(up,"href","/docs/transformers/v4.27.1/en/model_doc/distilbert#transformers.TFDistilBertForQuestionAnswering"),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(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(Vn,"id","transformers.FlaxDistilBertModel"),c(Vn,"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(Vn,"href","#transformers.FlaxDistilBertModel"),c(Es,"class","relative group"),c(fp,"href","/docs/transformers/v4.27.1/en/main_classes/model#transformers.FlaxPreTrainedModel"),c(Ll,"href","https://flax.readthedocs.io/en/latest/flax.linen.html#module"),c(Ll,"rel","nofollow"),c(Ol,"href","https://jax.readthedocs.io/en/latest/jax.html#just-in-time-compilation-jit"),c(Ol,"rel","nofollow"),c(Il,"href","https://jax.readthedocs.io/en/latest/jax.html#automatic-differentiation"),c(Il,"rel","nofollow"),c(Sl,"href","https://jax.readthedocs.io/en/latest/jax.html#vectorization-vmap"),c(Sl,"rel","nofollow"),c(Nl,"href","https://jax.readthedocs.io/en/latest/jax.html#parallelization-pmap"),c(Nl,"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(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(Xn,"id","transformers.FlaxDistilBertForMaskedLM"),c(Xn,"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(Xn,"href","#transformers.FlaxDistilBertForMaskedLM"),c(Bs,"class","relative group"),c(mp,"href","/docs/transformers/v4.27.1/en/main_classes/model#transformers.FlaxPreTrainedModel"),c(Vl,"href","https://flax.readthedocs.io/en/latest/flax.linen.html#module"),c(Vl,"rel","nofollow"),c(Jl,"href","https://jax.readthedocs.io/en/latest/jax.html#just-in-time-compilation-jit"),c(Jl,"rel","nofollow"),c(Gl,"href","https://jax.readthedocs.io/en/latest/jax.html#automatic-differentiation"),c(Gl,"rel","nofollow"),c(Xl,"href","https://jax.readthedocs.io/en/latest/jax.html#vectorization-vmap"),c(Xl,"rel","nofollow"),c(Yl,"href","https://jax.readthedocs.io/en/latest/jax.html#parallelization-pmap"),c(Yl,"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(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(er,"id","transformers.FlaxDistilBertForSequenceClassification"),c(er,"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(er,"href","#transformers.FlaxDistilBertForSequenceClassification"),c(zs,"class","relative group"),c(gp,"href","/docs/transformers/v4.27.1/en/main_classes/model#transformers.FlaxPreTrainedModel"),c(nd,"href","https://flax.readthedocs.io/en/latest/flax.linen.html#module"),c(nd,"rel","nofollow"),c(rd,"href","https://jax.readthedocs.io/en/latest/jax.html#just-in-time-compilation-jit"),c(rd,"rel","nofollow"),c(ad,"href","https://jax.readthedocs.io/en/latest/jax.html#automatic-differentiation"),c(ad,"rel","nofollow"),c(id,"href","https://jax.readthedocs.io/en/latest/jax.html#vectorization-vmap"),c(id,"rel","nofollow"),c(ld,"href","https://jax.readthedocs.io/en/latest/jax.html#parallelization-pmap"),c(ld,"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(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(sr,"id","transformers.FlaxDistilBertForMultipleChoice"),c(sr,"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(sr,"href","#transformers.FlaxDistilBertForMultipleChoice"),c(As,"class","relative group"),c(_p,"href","/docs/transformers/v4.27.1/en/main_classes/model#transformers.FlaxPreTrainedModel"),c(fd,"href","https://flax.readthedocs.io/en/latest/flax.linen.html#module"),c(fd,"rel","nofollow"),c(md,"href","https://jax.readthedocs.io/en/latest/jax.html#just-in-time-compilation-jit"),c(md,"rel","nofollow"),c(gd,"href","https://jax.readthedocs.io/en/latest/jax.html#automatic-differentiation"),c(gd,"rel","nofollow"),c(_d,"href","https://jax.readthedocs.io/en/latest/jax.html#vectorization-vmap"),c(_d,"rel","nofollow"),c(bd,"href","https://jax.readthedocs.io/en/latest/jax.html#parallelization-pmap"),c(bd,"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(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(ar,"id","transformers.FlaxDistilBertForTokenClassification"),c(ar,"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(ar,"href","#transformers.FlaxDistilBertForTokenClassification"),c(qs,"class","relative group"),c(bp,"href","/docs/transformers/v4.27.1/en/main_classes/model#transformers.FlaxPreTrainedModel"),c($d,"href","https://flax.readthedocs.io/en/latest/flax.linen.html#module"),c($d,"rel","nofollow"),c(Fd,"href","https://jax.readthedocs.io/en/latest/jax.html#just-in-time-compilation-jit"),c(Fd,"rel","nofollow"),c(Dd,"href","https://jax.readthedocs.io/en/latest/jax.html#automatic-differentiation"),c(Dd,"rel","nofollow"),c(Ed,"href","https://jax.readthedocs.io/en/latest/jax.html#vectorization-vmap"),c(Ed,"rel","nofollow"),c(xd,"href","https://jax.readthedocs.io/en/latest/jax.html#parallelization-pmap"),c(xd,"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(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(dr,"id","transformers.FlaxDistilBertForQuestionAnswering"),c(dr,"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(dr,"href","#transformers.FlaxDistilBertForQuestionAnswering"),c(Ls,"class","relative group"),c(vp,"href","/docs/transformers/v4.27.1/en/main_classes/model#transformers.FlaxPreTrainedModel"),c(jd,"href","https://flax.readthedocs.io/en/latest/flax.linen.html#module"),c(jd,"rel","nofollow"),c(qd,"href","https://jax.readthedocs.io/en/latest/jax.html#just-in-time-compilation-jit"),c(qd,"rel","nofollow"),c(Pd,"href","https://jax.readthedocs.io/en/latest/jax.html#automatic-differentiation"),c(Pd,"rel","nofollow"),c(Ld,"href","https://jax.readthedocs.io/en/latest/jax.html#vectorization-vmap"),c(Ld,"rel","nofollow"),c(Od,"href","https://jax.readthedocs.io/en/latest/jax.html#parallelization-pmap"),c(Od,"rel","nofollow"),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(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(i,_){e(document.head,d),g(i,v,_),g(i,f,_),e(f,m),e(m,b),y(l,b,null),e(f,u),e(f,B),e(B,we),g(i,_e,_),g(i,S,_),e(S,ce),e(ce,Z),e(S,Te),e(S,W),e(W,pe),g(i,J,_),g(i,oe,_),e(oe,ie),e(ie,Q),y(le,Q,null),e(oe,ye),e(oe,H),e(H,$e),g(i,be,_),g(i,O,_),e(O,Fe),e(O,de),e(de,se),e(O,C),e(O,A),e(A,De),e(O,X),e(O,fe),e(fe,Ee),e(O,Y),g(i,ve,_),g(i,he,_),e(he,q),g(i,ke,_),g(i,U,_),e(U,me),e(me,xe),g(i,G,_),g(i,ue,_),e(ue,Be),g(i,I,_),g(i,te,_),e(te,K),e(K,ee),e(ee,ne),e(ee,j),e(j,Me),e(ee,P),e(ee,ge),e(ge,ze),e(ee,k),e(ee,M),e(M,Qe),e(ee,re),e(te,He),e(te,Ne),e(Ne,z),e(z,Ke),e(z,Re),e(Re,Ve),e(z,Je),e(te,Ge),e(te,L),e(L,V),e(V,Xe),e(L,Ye),e(L,N),e(N,We),e(We,Ze),e(N,Ce),e(N,Ue),e(Ue,ae),e(N,et),e(N,Jp),e(Jp,J_),g(i,um,_),g(i,Lt,_),e(Lt,G_),e(Lt,qr),e(qr,X_),e(Lt,Y_),e(Lt,Pr),e(Pr,Z_),e(Lt,eb),e(Lt,Lr),e(Lr,tb),e(Lt,ob),g(i,fm,_),g(i,Vo,_),e(Vo,Rs),e(Rs,Gp),y(Or,Gp,null),e(Vo,sb),e(Vo,Xp),e(Xp,nb),g(i,mm,_),g(i,ic,_),e(ic,rb),g(i,gm,_),y(Ir,i,_),g(i,_m,_),g(i,je,_),e(je,Sr),e(Sr,ab),e(Sr,Nr),e(Nr,ib),e(Sr,lb),e(je,db),e(je,Rr),e(Rr,cb),e(Rr,Wr),e(Wr,pb),e(Rr,hb),e(je,ub),e(je,Ur),e(Ur,fb),e(Ur,Qr),e(Qr,mb),e(Ur,gb),e(je,_b),e(je,Hr),e(Hr,bb),e(Hr,Kr),e(Kr,vb),e(Hr,kb),e(je,wb),e(je,Vr),e(Vr,Tb),e(Vr,Jr),e(Jr,yb),e(Vr,$b),e(je,Fb),e(je,Gr),e(Gr,Db),e(Gr,Xr),e(Xr,Eb),e(Gr,xb),e(je,Bb),e(je,Yr),e(Yr,Mb),e(Yr,Zr),e(Zr,zb),e(Yr,Cb),e(je,Ab),e(je,go),e(go,lc),e(lc,jb),e(go,qb),e(go,ea),e(ea,Pb),e(go,Lb),e(go,ta),e(ta,Ob),e(go,Ib),e(je,Sb),e(je,_o),e(_o,dc),e(dc,Nb),e(_o,Rb),e(_o,oa),e(oa,Wb),e(_o,Ub),e(_o,sa),e(sa,Qb),e(_o,Hb),e(je,Kb),e(je,bo),e(bo,cc),e(cc,Vb),e(bo,Jb),e(bo,na),e(na,Gb),e(bo,Xb),e(bo,ra),e(ra,Yb),e(bo,Zb),e(je,ev),e(je,Yp),e(Yp,pc),e(pc,tv),g(i,bm,_),y(aa,i,_),g(i,vm,_),g(i,wt,_),e(wt,vo),e(vo,hc),e(hc,ov),e(vo,sv),e(vo,ia),e(ia,nv),e(vo,rv),e(vo,la),e(la,av),e(vo,iv),e(wt,lv),e(wt,ko),e(ko,uc),e(uc,dv),e(ko,cv),e(ko,da),e(da,pv),e(ko,hv),e(ko,ca),e(ca,uv),e(ko,fv),e(wt,mv),e(wt,Ws),e(Ws,fc),e(fc,gv),e(Ws,_v),e(Ws,pa),e(pa,bv),e(Ws,vv),e(wt,kv),e(wt,mc),e(mc,ha),e(ha,wv),e(mc,Tv),e(wt,yv),e(wt,Zp),e(Zp,gc),e(gc,$v),g(i,km,_),y(ua,i,_),g(i,wm,_),g(i,Tt,_),e(Tt,wo),e(wo,_c),e(_c,Fv),e(wo,Dv),e(wo,fa),e(fa,Ev),e(wo,xv),e(wo,ma),e(ma,Bv),e(wo,Mv),e(Tt,zv),e(Tt,To),e(To,bc),e(bc,Cv),e(To,Av),e(To,ga),e(ga,jv),e(To,qv),e(To,_a),e(_a,Pv),e(To,Lv),e(Tt,Ov),e(Tt,yo),e(yo,vc),e(vc,Iv),e(yo,Sv),e(yo,ba),e(ba,Nv),e(yo,Rv),e(yo,va),e(va,Wv),e(yo,Uv),e(Tt,Qv),e(Tt,kc),e(kc,ka),e(ka,Hv),e(kc,Kv),e(Tt,Vv),e(Tt,eh),e(eh,wc),e(wc,Jv),g(i,Tm,_),y(wa,i,_),g(i,ym,_),g(i,yt,_),e(yt,$o),e($o,Tc),e(Tc,Gv),e($o,Xv),e($o,Ta),e(Ta,Yv),e($o,Zv),e($o,ya),e(ya,ek),e($o,tk),e(yt,ok),e(yt,Fo),e(Fo,yc),e(yc,sk),e(Fo,nk),e(Fo,$a),e($a,rk),e(Fo,ak),e(Fo,Fa),e(Fa,ik),e(Fo,lk),e(yt,dk),e(yt,Us),e(Us,$c),e($c,ck),e(Us,pk),e(Us,Da),e(Da,hk),e(Us,uk),e(yt,fk),e(yt,Fc),e(Fc,Ea),e(Ea,mk),e(Fc,gk),e(yt,_k),e(yt,th),e(th,Dc),e(Dc,bk),g(i,$m,_),g(i,Ec,_),e(Ec,oh),e(oh,vk),g(i,Fm,_),g(i,Do,_),e(Do,Eo),e(Eo,xc),e(xc,kk),e(Eo,wk),e(Eo,xa),e(xa,Tk),e(Eo,yk),e(Eo,Ba),e(Ba,$k),e(Eo,Fk),e(Do,Dk),e(Do,xo),e(xo,Bc),e(Bc,Ek),e(xo,xk),e(xo,Ma),e(Ma,Bk),e(xo,Mk),e(xo,za),e(za,zk),e(xo,Ck),e(Do,Ak),e(Do,sh),e(sh,Mc),e(Mc,jk),g(i,Dm,_),g(i,zc,_),e(zc,qk),g(i,Em,_),g(i,Bo,_),e(Bo,Ca),e(Ca,Pk),e(Ca,Aa),e(Aa,Lk),e(Ca,Ok),e(Bo,Ik),e(Bo,ja),e(ja,Sk),e(ja,qa),e(qa,Nk),e(ja,Rk),e(Bo,Wk),e(Bo,Pa),e(Pa,Uk),e(Pa,La),e(La,Qk),e(Pa,Hk),g(i,xm,_),g(i,Cc,_),e(Cc,Kk),g(i,Bm,_),g(i,Qs,_),e(Qs,Oa),e(Oa,Vk),e(Oa,Ia),e(Ia,Jk),e(Oa,Gk),e(Qs,Xk),e(Qs,Sa),e(Sa,Yk),e(Sa,Na),e(Na,Zk),e(Sa,ew),g(i,Mm,_),g(i,Ac,_),e(Ac,tw),g(i,zm,_),g(i,Mo,_),e(Mo,Ra),e(Ra,ow),e(Ra,Wa),e(Wa,sw),e(Ra,nw),e(Mo,rw),e(Mo,Ua),e(Ua,aw),e(Ua,Qa),e(Qa,iw),e(Ua,lw),e(Mo,dw),e(Mo,Ha),e(Ha,cw),e(Ha,Ka),e(Ka,pw),e(Ha,hw),g(i,Cm,_),g(i,Jo,_),e(Jo,Hs),e(Hs,nh),y(Va,nh,null),e(Jo,uw),e(Jo,rh),e(rh,fw),g(i,Am,_),g(i,Pt,_),y(Ja,Pt,null),e(Pt,mw),e(Pt,ro),e(ro,gw),e(ro,jc),e(jc,_w),e(ro,bw),e(ro,qc),e(qc,vw),e(ro,kw),e(ro,Ga),e(Ga,ww),e(ro,Tw),e(Pt,yw),e(Pt,Go),e(Go,$w),e(Go,Pc),e(Pc,Fw),e(Go,Dw),e(Go,Lc),e(Lc,Ew),e(Go,xw),e(Pt,Bw),y(Ks,Pt,null),g(i,jm,_),g(i,Xo,_),e(Xo,Vs),e(Vs,ah),y(Xa,ah,null),e(Xo,Mw),e(Xo,ih),e(ih,zw),g(i,qm,_),g(i,tt,_),y(Ya,tt,null),e(tt,Cw),e(tt,lh),e(lh,Aw),e(tt,jw),e(tt,Za),e(Za,qw),e(Za,Oc),e(Oc,Pw),e(Za,Lw),e(tt,Ow),e(tt,zo),y(ei,zo,null),e(zo,Iw),e(zo,dh),e(dh,Sw),e(zo,Nw),e(zo,ti),e(ti,Ic),e(Ic,Rw),e(Ic,ch),e(ch,Ww),e(ti,Uw),e(ti,Sc),e(Sc,Qw),e(Sc,ph),e(ph,Hw),e(tt,Kw),e(tt,Js),y(oi,Js,null),e(Js,Vw),e(Js,hh),e(hh,Jw),e(tt,Gw),e(tt,Ot),y(si,Ot,null),e(Ot,Xw),e(Ot,uh),e(uh,Yw),e(Ot,Zw),y(Gs,Ot,null),e(Ot,e1),e(Ot,Yo),e(Yo,t1),e(Yo,fh),e(fh,o1),e(Yo,s1),e(Yo,mh),e(mh,n1),e(Yo,r1),e(tt,a1),e(tt,Xs),y(ni,Xs,null),e(Xs,i1),e(Xs,ri),e(ri,l1),e(ri,gh),e(gh,d1),e(ri,c1),g(i,Pm,_),g(i,Zo,_),e(Zo,Ys),e(Ys,_h),y(ai,_h,null),e(Zo,p1),e(Zo,bh),e(bh,h1),g(i,Lm,_),g(i,ft,_),y(ii,ft,null),e(ft,u1),e(ft,li),e(li,f1),e(li,vh),e(vh,m1),e(li,g1),e(ft,_1),e(ft,di),e(di,b1),e(di,Nc),e(Nc,v1),e(di,k1),e(ft,w1),e(ft,Co),y(ci,Co,null),e(Co,T1),e(Co,kh),e(kh,y1),e(Co,$1),e(Co,pi),e(pi,Rc),e(Rc,F1),e(Rc,wh),e(wh,D1),e(pi,E1),e(pi,Wc),e(Wc,x1),e(Wc,Th),e(Th,B1),e(ft,M1),e(ft,It),y(hi,It,null),e(It,z1),e(It,yh),e(yh,C1),e(It,A1),y(Zs,It,null),e(It,j1),e(It,es),e(es,q1),e(es,$h),e($h,P1),e(es,L1),e(es,Fh),e(Fh,O1),e(es,I1),g(i,Om,_),g(i,ts,_),e(ts,en),e(en,Dh),y(ui,Dh,null),e(ts,S1),e(ts,Eh),e(Eh,N1),g(i,Im,_),g(i,mt,_),y(fi,mt,null),e(mt,R1),e(mt,xh),e(xh,W1),e(mt,U1),e(mt,mi),e(mi,Q1),e(mi,Uc),e(Uc,H1),e(mi,K1),e(mt,V1),e(mt,gi),e(gi,J1),e(gi,_i),e(_i,G1),e(gi,X1),e(mt,Y1),e(mt,St),y(bi,St,null),e(St,Z1),e(St,os),e(os,eT),e(os,Qc),e(Qc,tT),e(os,oT),e(os,Bh),e(Bh,sT),e(os,nT),e(St,rT),y(tn,St,null),e(St,aT),y(on,St,null),g(i,Sm,_),g(i,ss,_),e(ss,sn),e(sn,Mh),y(vi,Mh,null),e(ss,iT),e(ss,zh),e(zh,lT),g(i,Nm,_),g(i,gt,_),y(ki,gt,null),e(gt,dT),e(gt,wi),e(wi,cT),e(wi,Ch),e(Ch,pT),e(wi,hT),e(gt,uT),e(gt,Ti),e(Ti,fT),e(Ti,Hc),e(Hc,mT),e(Ti,gT),e(gt,_T),e(gt,yi),e(yi,bT),e(yi,$i),e($i,vT),e(yi,kT),e(gt,wT),e(gt,Nt),y(Fi,Nt,null),e(Nt,TT),e(Nt,ns),e(ns,yT),e(ns,Kc),e(Kc,$T),e(ns,FT),e(ns,Ah),e(Ah,DT),e(ns,ET),e(Nt,xT),y(nn,Nt,null),e(Nt,BT),y(rn,Nt,null),g(i,Rm,_),g(i,rs,_),e(rs,an),e(an,jh),y(Di,jh,null),e(rs,MT),e(rs,qh),e(qh,zT),g(i,Wm,_),g(i,_t,_),y(Ei,_t,null),e(_t,CT),e(_t,Ph),e(Ph,AT),e(_t,jT),e(_t,xi),e(xi,qT),e(xi,Vc),e(Vc,PT),e(xi,LT),e(_t,OT),e(_t,Bi),e(Bi,IT),e(Bi,Mi),e(Mi,ST),e(Bi,NT),e(_t,RT),e(_t,$t),y(zi,$t,null),e($t,WT),e($t,as),e(as,UT),e(as,Jc),e(Jc,QT),e(as,HT),e(as,Lh),e(Lh,KT),e(as,VT),e($t,JT),y(ln,$t,null),e($t,GT),y(dn,$t,null),e($t,XT),y(cn,$t,null),g(i,Um,_),g(i,is,_),e(is,pn),e(pn,Oh),y(Ci,Oh,null),e(is,YT),e(is,Ih),e(Ih,ZT),g(i,Qm,_),g(i,bt,_),y(Ai,bt,null),e(bt,ey),e(bt,Sh),e(Sh,ty),e(bt,oy),e(bt,ji),e(ji,sy),e(ji,Gc),e(Gc,ny),e(ji,ry),e(bt,ay),e(bt,qi),e(qi,iy),e(qi,Pi),e(Pi,ly),e(qi,dy),e(bt,cy),e(bt,Rt),y(Li,Rt,null),e(Rt,py),e(Rt,ls),e(ls,hy),e(ls,Xc),e(Xc,uy),e(ls,fy),e(ls,Nh),e(Nh,my),e(ls,gy),e(Rt,_y),y(hn,Rt,null),e(Rt,by),y(un,Rt,null),g(i,Hm,_),g(i,ds,_),e(ds,fn),e(fn,Rh),y(Oi,Rh,null),e(ds,vy),e(ds,Wh),e(Wh,ky),g(i,Km,_),g(i,vt,_),y(Ii,vt,null),e(vt,wy),e(vt,Uh),e(Uh,Ty),e(vt,yy),e(vt,Si),e(Si,$y),e(Si,Yc),e(Yc,Fy),e(Si,Dy),e(vt,Ey),e(vt,Ni),e(Ni,xy),e(Ni,Ri),e(Ri,By),e(Ni,My),e(vt,zy),e(vt,Wt),y(Wi,Wt,null),e(Wt,Cy),e(Wt,cs),e(cs,Ay),e(cs,Zc),e(Zc,jy),e(cs,qy),e(cs,Qh),e(Qh,Py),e(cs,Ly),e(Wt,Oy),y(mn,Wt,null),e(Wt,Iy),y(gn,Wt,null),g(i,Vm,_),g(i,ps,_),e(ps,_n),e(_n,Hh),y(Ui,Hh,null),e(ps,Sy),e(ps,Kh),e(Kh,Ny),g(i,Jm,_),g(i,kt,_),y(Qi,kt,null),e(kt,Ry),e(kt,hs),e(hs,Wy),e(hs,Vh),e(Vh,Uy),e(hs,Qy),e(hs,Jh),e(Jh,Hy),e(hs,Ky),e(kt,Vy),e(kt,Hi),e(Hi,Jy),e(Hi,ep),e(ep,Gy),e(Hi,Xy),e(kt,Yy),e(kt,Ki),e(Ki,Zy),e(Ki,Vi),e(Vi,e$),e(Ki,t$),e(kt,o$),e(kt,Ut),y(Ji,Ut,null),e(Ut,s$),e(Ut,us),e(us,n$),e(us,tp),e(tp,r$),e(us,a$),e(us,Gh),e(Gh,i$),e(us,l$),e(Ut,d$),y(bn,Ut,null),e(Ut,c$),y(vn,Ut,null),g(i,Gm,_),g(i,fs,_),e(fs,kn),e(kn,Xh),y(Gi,Xh,null),e(fs,p$),e(fs,Yh),e(Yh,h$),g(i,Xm,_),g(i,lt,_),y(Xi,lt,null),e(lt,u$),e(lt,Zh),e(Zh,f$),e(lt,m$),e(lt,Yi),e(Yi,g$),e(Yi,op),e(op,_$),e(Yi,b$),e(lt,v$),e(lt,Zi),e(Zi,k$),e(Zi,el),e(el,w$),e(Zi,T$),e(lt,y$),y(wn,lt,null),e(lt,$$),e(lt,Qt),y(tl,Qt,null),e(Qt,F$),e(Qt,ms),e(ms,D$),e(ms,sp),e(sp,E$),e(ms,x$),e(ms,eu),e(eu,B$),e(ms,M$),e(Qt,z$),y(Tn,Qt,null),e(Qt,C$),y(yn,Qt,null),g(i,Ym,_),g(i,gs,_),e(gs,$n),e($n,tu),y(ol,tu,null),e(gs,A$),e(gs,ou),e(ou,j$),g(i,Zm,_),g(i,dt,_),y(sl,dt,null),e(dt,q$),e(dt,nl),e(nl,P$),e(nl,su),e(su,L$),e(nl,O$),e(dt,I$),e(dt,rl),e(rl,S$),e(rl,np),e(np,N$),e(rl,R$),e(dt,W$),e(dt,al),e(al,U$),e(al,il),e(il,Q$),e(al,H$),e(dt,K$),y(Fn,dt,null),e(dt,V$),e(dt,Ft),y(ll,Ft,null),e(Ft,J$),e(Ft,_s),e(_s,G$),e(_s,rp),e(rp,X$),e(_s,Y$),e(_s,nu),e(nu,Z$),e(_s,e2),e(Ft,t2),y(Dn,Ft,null),e(Ft,o2),y(En,Ft,null),e(Ft,s2),y(xn,Ft,null),g(i,eg,_),g(i,bs,_),e(bs,Bn),e(Bn,ru),y(dl,ru,null),e(bs,n2),e(bs,au),e(au,r2),g(i,tg,_),g(i,ct,_),y(cl,ct,null),e(ct,a2),e(ct,iu),e(iu,i2),e(ct,l2),e(ct,pl),e(pl,d2),e(pl,ap),e(ap,c2),e(pl,p2),e(ct,h2),e(ct,hl),e(hl,u2),e(hl,ul),e(ul,f2),e(hl,m2),e(ct,g2),y(Mn,ct,null),e(ct,_2),e(ct,Dt),y(fl,Dt,null),e(Dt,b2),e(Dt,vs),e(vs,v2),e(vs,ip),e(ip,k2),e(vs,w2),e(vs,lu),e(lu,T2),e(vs,y2),e(Dt,$2),y(zn,Dt,null),e(Dt,F2),y(Cn,Dt,null),e(Dt,D2),y(An,Dt,null),g(i,og,_),g(i,ks,_),e(ks,jn),e(jn,du),y(ml,du,null),e(ks,E2),e(ks,cu),e(cu,x2),g(i,sg,_),g(i,pt,_),y(gl,pt,null),e(pt,B2),e(pt,pu),e(pu,M2),e(pt,z2),e(pt,_l),e(_l,C2),e(_l,lp),e(lp,A2),e(_l,j2),e(pt,q2),e(pt,bl),e(bl,P2),e(bl,vl),e(vl,L2),e(bl,O2),e(pt,I2),y(qn,pt,null),e(pt,S2),e(pt,Ht),y(kl,Ht,null),e(Ht,N2),e(Ht,ws),e(ws,R2),e(ws,dp),e(dp,W2),e(ws,U2),e(ws,hu),e(hu,Q2),e(ws,H2),e(Ht,K2),y(Pn,Ht,null),e(Ht,V2),y(Ln,Ht,null),g(i,ng,_),g(i,Ts,_),e(Ts,On),e(On,uu),y(wl,uu,null),e(Ts,J2),e(Ts,fu),e(fu,G2),g(i,rg,_),g(i,ht,_),y(Tl,ht,null),e(ht,X2),e(ht,mu),e(mu,Y2),e(ht,Z2),e(ht,yl),e(yl,eF),e(yl,cp),e(cp,tF),e(yl,oF),e(ht,sF),e(ht,$l),e($l,nF),e($l,Fl),e(Fl,rF),e($l,aF),e(ht,iF),y(In,ht,null),e(ht,lF),e(ht,Et),y(Dl,Et,null),e(Et,dF),e(Et,ys),e(ys,cF),e(ys,pp),e(pp,pF),e(ys,hF),e(ys,gu),e(gu,uF),e(ys,fF),e(Et,mF),y(Sn,Et,null),e(Et,gF),y(Nn,Et,null),e(Et,_F),y(Rn,Et,null),g(i,ag,_),g(i,$s,_),e($s,Wn),e(Wn,_u),y(El,_u,null),e($s,bF),e($s,bu),e(bu,vF),g(i,ig,_),g(i,ut,_),y(xl,ut,null),e(ut,kF),e(ut,Fs),e(Fs,wF),e(Fs,vu),e(vu,TF),e(Fs,yF),e(Fs,ku),e(ku,$F),e(Fs,FF),e(ut,DF),e(ut,Bl),e(Bl,EF),e(Bl,hp),e(hp,xF),e(Bl,BF),e(ut,MF),e(ut,Ml),e(Ml,zF),e(Ml,zl),e(zl,CF),e(Ml,AF),e(ut,jF),y(Un,ut,null),e(ut,qF),e(ut,xt),y(Cl,xt,null),e(xt,PF),e(xt,Ds),e(Ds,LF),e(Ds,up),e(up,OF),e(Ds,IF),e(Ds,wu),e(wu,SF),e(Ds,NF),e(xt,RF),y(Qn,xt,null),e(xt,WF),y(Hn,xt,null),e(xt,UF),y(Kn,xt,null),g(i,lg,_),g(i,Es,_),e(Es,Vn),e(Vn,Tu),y(Al,Tu,null),e(Es,QF),e(Es,yu),e(yu,HF),g(i,dg,_),g(i,ot,_),y(jl,ot,null),e(ot,KF),e(ot,$u),e($u,VF),e(ot,JF),e(ot,ql),e(ql,GF),e(ql,fp),e(fp,XF),e(ql,YF),e(ot,ZF),e(ot,Pl),e(Pl,e0),e(Pl,Ll),e(Ll,t0),e(Pl,o0),e(ot,s0),e(ot,Fu),e(Fu,n0),e(ot,r0),e(ot,ao),e(ao,Du),e(Du,Ol),e(Ol,a0),e(ao,i0),e(ao,Eu),e(Eu,Il),e(Il,l0),e(ao,d0),e(ao,xu),e(xu,Sl),e(Sl,c0),e(ao,p0),e(ao,Bu),e(Bu,Nl),e(Nl,h0),e(ot,u0),e(ot,Kt),y(Rl,Kt,null),e(Kt,f0),e(Kt,xs),e(xs,m0),e(xs,Mu),e(Mu,g0),e(xs,_0),e(xs,zu),e(zu,b0),e(xs,v0),e(Kt,k0),y(Jn,Kt,null),e(Kt,w0),y(Gn,Kt,null),g(i,cg,_),g(i,Bs,_),e(Bs,Xn),e(Xn,Cu),y(Wl,Cu,null),e(Bs,T0),e(Bs,Au),e(Au,y0),g(i,pg,_),g(i,st,_),y(Ul,st,null),e(st,$0),e(st,Ql),e(Ql,F0),e(Ql,ju),e(ju,D0),e(Ql,E0),e(st,x0),e(st,Hl),e(Hl,B0),e(Hl,mp),e(mp,M0),e(Hl,z0),e(st,C0),e(st,Kl),e(Kl,A0),e(Kl,Vl),e(Vl,j0),e(Kl,q0),e(st,P0),e(st,qu),e(qu,L0),e(st,O0),e(st,io),e(io,Pu),e(Pu,Jl),e(Jl,I0),e(io,S0),e(io,Lu),e(Lu,Gl),e(Gl,N0),e(io,R0),e(io,Ou),e(Ou,Xl),e(Xl,W0),e(io,U0),e(io,Iu),e(Iu,Yl),e(Yl,Q0),e(st,H0),e(st,Vt),y(Zl,Vt,null),e(Vt,K0),e(Vt,Ms),e(Ms,V0),e(Ms,Su),e(Su,J0),e(Ms,G0),e(Ms,Nu),e(Nu,X0),e(Ms,Y0),e(Vt,Z0),y(Yn,Vt,null),e(Vt,eD),y(Zn,Vt,null),g(i,hg,_),g(i,zs,_),e(zs,er),e(er,Ru),y(ed,Ru,null),e(zs,tD),e(zs,Wu),e(Wu,oD),g(i,ug,_),g(i,nt,_),y(td,nt,null),e(nt,sD),e(nt,Uu),e(Uu,nD),e(nt,rD),e(nt,od),e(od,aD),e(od,gp),e(gp,iD),e(od,lD),e(nt,dD),e(nt,sd),e(sd,cD),e(sd,nd),e(nd,pD),e(sd,hD),e(nt,uD),e(nt,Qu),e(Qu,fD),e(nt,mD),e(nt,lo),e(lo,Hu),e(Hu,rd),e(rd,gD),e(lo,_D),e(lo,Ku),e(Ku,ad),e(ad,bD),e(lo,vD),e(lo,Vu),e(Vu,id),e(id,kD),e(lo,wD),e(lo,Ju),e(Ju,ld),e(ld,TD),e(nt,yD),e(nt,Jt),y(dd,Jt,null),e(Jt,$D),e(Jt,Cs),e(Cs,FD),e(Cs,Gu),e(Gu,DD),e(Cs,ED),e(Cs,Xu),e(Xu,xD),e(Cs,BD),e(Jt,MD),y(tr,Jt,null),e(Jt,zD),y(or,Jt,null),g(i,fg,_),g(i,As,_),e(As,sr),e(sr,Yu),y(cd,Yu,null),e(As,CD),e(As,Zu),e(Zu,AD),g(i,mg,_),g(i,rt,_),y(pd,rt,null),e(rt,jD),e(rt,ef),e(ef,qD),e(rt,PD),e(rt,hd),e(hd,LD),e(hd,_p),e(_p,OD),e(hd,ID),e(rt,SD),e(rt,ud),e(ud,ND),e(ud,fd),e(fd,RD),e(ud,WD),e(rt,UD),e(rt,tf),e(tf,QD),e(rt,HD),e(rt,co),e(co,of),e(of,md),e(md,KD),e(co,VD),e(co,sf),e(sf,gd),e(gd,JD),e(co,GD),e(co,nf),e(nf,_d),e(_d,XD),e(co,YD),e(co,rf),e(rf,bd),e(bd,ZD),e(rt,e4),e(rt,Gt),y(vd,Gt,null),e(Gt,t4),e(Gt,js),e(js,o4),e(js,af),e(af,s4),e(js,n4),e(js,lf),e(lf,r4),e(js,a4),e(Gt,i4),y(nr,Gt,null),e(Gt,l4),y(rr,Gt,null),g(i,gg,_),g(i,qs,_),e(qs,ar),e(ar,df),y(kd,df,null),e(qs,d4),e(qs,cf),e(cf,c4),g(i,_g,_),g(i,at,_),y(wd,at,null),e(at,p4),e(at,pf),e(pf,h4),e(at,u4),e(at,Td),e(Td,f4),e(Td,bp),e(bp,m4),e(Td,g4),e(at,_4),e(at,yd),e(yd,b4),e(yd,$d),e($d,v4),e(yd,k4),e(at,w4),e(at,hf),e(hf,T4),e(at,y4),e(at,po),e(po,uf),e(uf,Fd),e(Fd,$4),e(po,F4),e(po,ff),e(ff,Dd),e(Dd,D4),e(po,E4),e(po,mf),e(mf,Ed),e(Ed,x4),e(po,B4),e(po,gf),e(gf,xd),e(xd,M4),e(at,z4),e(at,Xt),y(Bd,Xt,null),e(Xt,C4),e(Xt,Ps),e(Ps,A4),e(Ps,_f),e(_f,j4),e(Ps,q4),e(Ps,bf),e(bf,P4),e(Ps,L4),e(Xt,O4),y(ir,Xt,null),e(Xt,I4),y(lr,Xt,null),g(i,bg,_),g(i,Ls,_),e(Ls,dr),e(dr,vf),y(Md,vf,null),e(Ls,S4),e(Ls,kf),e(kf,N4),g(i,vg,_),g(i,it,_),y(zd,it,null),e(it,R4),e(it,Os),e(Os,W4),e(Os,wf),e(wf,U4),e(Os,Q4),e(Os,Tf),e(Tf,H4),e(Os,K4),e(it,V4),e(it,Cd),e(Cd,J4),e(Cd,vp),e(vp,G4),e(Cd,X4),e(it,Y4),e(it,Ad),e(Ad,Z4),e(Ad,jd),e(jd,eE),e(Ad,tE),e(it,oE),e(it,yf),e(yf,sE),e(it,nE),e(it,ho),e(ho,$f),e($f,qd),e(qd,rE),e(ho,aE),e(ho,Ff),e(Ff,Pd),e(Pd,iE),e(ho,lE),e(ho,Df),e(Df,Ld),e(Ld,dE),e(ho,cE),e(ho,Ef),e(Ef,Od),e(Od,pE),e(it,hE),e(it,Yt),y(Id,Yt,null),e(Yt,uE),e(Yt,Is),e(Is,fE),e(Is,xf),e(xf,mE),e(Is,gE),e(Is,Bf),e(Bf,_E),e(Is,bE),e(Yt,vE),y(cr,Yt,null),e(Yt,kE),y(pr,Yt,null),kg=!0},p(i,[_]){const Sd={};_&2&&(Sd.$$scope={dirty:_,ctx:i}),Ks.$set(Sd);const Mf={};_&2&&(Mf.$$scope={dirty:_,ctx:i}),Gs.$set(Mf);const zf={};_&2&&(zf.$$scope={dirty:_,ctx:i}),Zs.$set(zf);const Cf={};_&2&&(Cf.$$scope={dirty:_,ctx:i}),tn.$set(Cf);const Nd={};_&2&&(Nd.$$scope={dirty:_,ctx:i}),on.$set(Nd);const Af={};_&2&&(Af.$$scope={dirty:_,ctx:i}),nn.$set(Af);const jf={};_&2&&(jf.$$scope={dirty:_,ctx:i}),rn.$set(jf);const Rd={};_&2&&(Rd.$$scope={dirty:_,ctx:i}),ln.$set(Rd);const qf={};_&2&&(qf.$$scope={dirty:_,ctx:i}),dn.$set(qf);const Pf={};_&2&&(Pf.$$scope={dirty:_,ctx:i}),cn.$set(Pf);const Lf={};_&2&&(Lf.$$scope={dirty:_,ctx:i}),hn.$set(Lf);const uo={};_&2&&(uo.$$scope={dirty:_,ctx:i}),un.$set(uo);const Of={};_&2&&(Of.$$scope={dirty:_,ctx:i}),mn.$set(Of);const If={};_&2&&(If.$$scope={dirty:_,ctx:i}),gn.$set(If);const Sf={};_&2&&(Sf.$$scope={dirty:_,ctx:i}),bn.$set(Sf);const Nf={};_&2&&(Nf.$$scope={dirty:_,ctx:i}),vn.$set(Nf);const Rf={};_&2&&(Rf.$$scope={dirty:_,ctx:i}),wn.$set(Rf);const Wf={};_&2&&(Wf.$$scope={dirty:_,ctx:i}),Tn.$set(Wf);const Uf={};_&2&&(Uf.$$scope={dirty:_,ctx:i}),yn.$set(Uf);const Ss={};_&2&&(Ss.$$scope={dirty:_,ctx:i}),Fn.$set(Ss);const Qf={};_&2&&(Qf.$$scope={dirty:_,ctx:i}),Dn.$set(Qf);const fo={};_&2&&(fo.$$scope={dirty:_,ctx:i}),En.$set(fo);const Hf={};_&2&&(Hf.$$scope={dirty:_,ctx:i}),xn.$set(Hf);const Kf={};_&2&&(Kf.$$scope={dirty:_,ctx:i}),Mn.$set(Kf);const Vf={};_&2&&(Vf.$$scope={dirty:_,ctx:i}),zn.$set(Vf);const Jf={};_&2&&(Jf.$$scope={dirty:_,ctx:i}),Cn.$set(Jf);const Wd={};_&2&&(Wd.$$scope={dirty:_,ctx:i}),An.$set(Wd);const Gf={};_&2&&(Gf.$$scope={dirty:_,ctx:i}),qn.$set(Gf);const Ud={};_&2&&(Ud.$$scope={dirty:_,ctx:i}),Pn.$set(Ud);const Xf={};_&2&&(Xf.$$scope={dirty:_,ctx:i}),Ln.$set(Xf);const Ns={};_&2&&(Ns.$$scope={dirty:_,ctx:i}),In.$set(Ns);const Yf={};_&2&&(Yf.$$scope={dirty:_,ctx:i}),Sn.$set(Yf);const Zf={};_&2&&(Zf.$$scope={dirty:_,ctx:i}),Nn.$set(Zf);const em={};_&2&&(em.$$scope={dirty:_,ctx:i}),Rn.$set(em);const mo={};_&2&&(mo.$$scope={dirty:_,ctx:i}),Un.$set(mo);const tm={};_&2&&(tm.$$scope={dirty:_,ctx:i}),Qn.$set(tm);const om={};_&2&&(om.$$scope={dirty:_,ctx:i}),Hn.$set(om);const sm={};_&2&&(sm.$$scope={dirty:_,ctx:i}),Kn.$set(sm);const Qd={};_&2&&(Qd.$$scope={dirty:_,ctx:i}),Jn.$set(Qd);const nm={};_&2&&(nm.$$scope={dirty:_,ctx:i}),Gn.$set(nm);const rm={};_&2&&(rm.$$scope={dirty:_,ctx:i}),Yn.$set(rm);const am={};_&2&&(am.$$scope={dirty:_,ctx:i}),Zn.$set(am);const im={};_&2&&(im.$$scope={dirty:_,ctx:i}),tr.$set(im);const Oe={};_&2&&(Oe.$$scope={dirty:_,ctx:i}),or.$set(Oe);const Hd={};_&2&&(Hd.$$scope={dirty:_,ctx:i}),nr.$set(Hd);const lm={};_&2&&(lm.$$scope={dirty:_,ctx:i}),rr.$set(lm);const Kd={};_&2&&(Kd.$$scope={dirty:_,ctx:i}),ir.$set(Kd);const dm={};_&2&&(dm.$$scope={dirty:_,ctx:i}),lr.$set(dm);const Vd={};_&2&&(Vd.$$scope={dirty:_,ctx:i}),cr.$set(Vd);const cm={};_&2&&(cm.$$scope={dirty:_,ctx:i}),pr.$set(cm)},i(i){kg||($(l.$$.fragment,i),$(le.$$.fragment,i),$(Or.$$.fragment,i),$(Ir.$$.fragment,i),$(aa.$$.fragment,i),$(ua.$$.fragment,i),$(wa.$$.fragment,i),$(Va.$$.fragment,i),$(Ja.$$.fragment,i),$(Ks.$$.fragment,i),$(Xa.$$.fragment,i),$(Ya.$$.fragment,i),$(ei.$$.fragment,i),$(oi.$$.fragment,i),$(si.$$.fragment,i),$(Gs.$$.fragment,i),$(ni.$$.fragment,i),$(ai.$$.fragment,i),$(ii.$$.fragment,i),$(ci.$$.fragment,i),$(hi.$$.fragment,i),$(Zs.$$.fragment,i),$(ui.$$.fragment,i),$(fi.$$.fragment,i),$(bi.$$.fragment,i),$(tn.$$.fragment,i),$(on.$$.fragment,i),$(vi.$$.fragment,i),$(ki.$$.fragment,i),$(Fi.$$.fragment,i),$(nn.$$.fragment,i),$(rn.$$.fragment,i),$(Di.$$.fragment,i),$(Ei.$$.fragment,i),$(zi.$$.fragment,i),$(ln.$$.fragment,i),$(dn.$$.fragment,i),$(cn.$$.fragment,i),$(Ci.$$.fragment,i),$(Ai.$$.fragment,i),$(Li.$$.fragment,i),$(hn.$$.fragment,i),$(un.$$.fragment,i),$(Oi.$$.fragment,i),$(Ii.$$.fragment,i),$(Wi.$$.fragment,i),$(mn.$$.fragment,i),$(gn.$$.fragment,i),$(Ui.$$.fragment,i),$(Qi.$$.fragment,i),$(Ji.$$.fragment,i),$(bn.$$.fragment,i),$(vn.$$.fragment,i),$(Gi.$$.fragment,i),$(Xi.$$.fragment,i),$(wn.$$.fragment,i),$(tl.$$.fragment,i),$(Tn.$$.fragment,i),$(yn.$$.fragment,i),$(ol.$$.fragment,i),$(sl.$$.fragment,i),$(Fn.$$.fragment,i),$(ll.$$.fragment,i),$(Dn.$$.fragment,i),$(En.$$.fragment,i),$(xn.$$.fragment,i),$(dl.$$.fragment,i),$(cl.$$.fragment,i),$(Mn.$$.fragment,i),$(fl.$$.fragment,i),$(zn.$$.fragment,i),$(Cn.$$.fragment,i),$(An.$$.fragment,i),$(ml.$$.fragment,i),$(gl.$$.fragment,i),$(qn.$$.fragment,i),$(kl.$$.fragment,i),$(Pn.$$.fragment,i),$(Ln.$$.fragment,i),$(wl.$$.fragment,i),$(Tl.$$.fragment,i),$(In.$$.fragment,i),$(Dl.$$.fragment,i),$(Sn.$$.fragment,i),$(Nn.$$.fragment,i),$(Rn.$$.fragment,i),$(El.$$.fragment,i),$(xl.$$.fragment,i),$(Un.$$.fragment,i),$(Cl.$$.fragment,i),$(Qn.$$.fragment,i),$(Hn.$$.fragment,i),$(Kn.$$.fragment,i),$(Al.$$.fragment,i),$(jl.$$.fragment,i),$(Rl.$$.fragment,i),$(Jn.$$.fragment,i),$(Gn.$$.fragment,i),$(Wl.$$.fragment,i),$(Ul.$$.fragment,i),$(Zl.$$.fragment,i),$(Yn.$$.fragment,i),$(Zn.$$.fragment,i),$(ed.$$.fragment,i),$(td.$$.fragment,i),$(dd.$$.fragment,i),$(tr.$$.fragment,i),$(or.$$.fragment,i),$(cd.$$.fragment,i),$(pd.$$.fragment,i),$(vd.$$.fragment,i),$(nr.$$.fragment,i),$(rr.$$.fragment,i),$(kd.$$.fragment,i),$(wd.$$.fragment,i),$(Bd.$$.fragment,i),$(ir.$$.fragment,i),$(lr.$$.fragment,i),$(Md.$$.fragment,i),$(zd.$$.fragment,i),$(Id.$$.fragment,i),$(cr.$$.fragment,i),$(pr.$$.fragment,i),kg=!0)},o(i){F(l.$$.fragment,i),F(le.$$.fragment,i),F(Or.$$.fragment,i),F(Ir.$$.fragment,i),F(aa.$$.fragment,i),F(ua.$$.fragment,i),F(wa.$$.fragment,i),F(Va.$$.fragment,i),F(Ja.$$.fragment,i),F(Ks.$$.fragment,i),F(Xa.$$.fragment,i),F(Ya.$$.fragment,i),F(ei.$$.fragment,i),F(oi.$$.fragment,i),F(si.$$.fragment,i),F(Gs.$$.fragment,i),F(ni.$$.fragment,i),F(ai.$$.fragment,i),F(ii.$$.fragment,i),F(ci.$$.fragment,i),F(hi.$$.fragment,i),F(Zs.$$.fragment,i),F(ui.$$.fragment,i),F(fi.$$.fragment,i),F(bi.$$.fragment,i),F(tn.$$.fragment,i),F(on.$$.fragment,i),F(vi.$$.fragment,i),F(ki.$$.fragment,i),F(Fi.$$.fragment,i),F(nn.$$.fragment,i),F(rn.$$.fragment,i),F(Di.$$.fragment,i),F(Ei.$$.fragment,i),F(zi.$$.fragment,i),F(ln.$$.fragment,i),F(dn.$$.fragment,i),F(cn.$$.fragment,i),F(Ci.$$.fragment,i),F(Ai.$$.fragment,i),F(Li.$$.fragment,i),F(hn.$$.fragment,i),F(un.$$.fragment,i),F(Oi.$$.fragment,i),F(Ii.$$.fragment,i),F(Wi.$$.fragment,i),F(mn.$$.fragment,i),F(gn.$$.fragment,i),F(Ui.$$.fragment,i),F(Qi.$$.fragment,i),F(Ji.$$.fragment,i),F(bn.$$.fragment,i),F(vn.$$.fragment,i),F(Gi.$$.fragment,i),F(Xi.$$.fragment,i),F(wn.$$.fragment,i),F(tl.$$.fragment,i),F(Tn.$$.fragment,i),F(yn.$$.fragment,i),F(ol.$$.fragment,i),F(sl.$$.fragment,i),F(Fn.$$.fragment,i),F(ll.$$.fragment,i),F(Dn.$$.fragment,i),F(En.$$.fragment,i),F(xn.$$.fragment,i),F(dl.$$.fragment,i),F(cl.$$.fragment,i),F(Mn.$$.fragment,i),F(fl.$$.fragment,i),F(zn.$$.fragment,i),F(Cn.$$.fragment,i),F(An.$$.fragment,i),F(ml.$$.fragment,i),F(gl.$$.fragment,i),F(qn.$$.fragment,i),F(kl.$$.fragment,i),F(Pn.$$.fragment,i),F(Ln.$$.fragment,i),F(wl.$$.fragment,i),F(Tl.$$.fragment,i),F(In.$$.fragment,i),F(Dl.$$.fragment,i),F(Sn.$$.fragment,i),F(Nn.$$.fragment,i),F(Rn.$$.fragment,i),F(El.$$.fragment,i),F(xl.$$.fragment,i),F(Un.$$.fragment,i),F(Cl.$$.fragment,i),F(Qn.$$.fragment,i),F(Hn.$$.fragment,i),F(Kn.$$.fragment,i),F(Al.$$.fragment,i),F(jl.$$.fragment,i),F(Rl.$$.fragment,i),F(Jn.$$.fragment,i),F(Gn.$$.fragment,i),F(Wl.$$.fragment,i),F(Ul.$$.fragment,i),F(Zl.$$.fragment,i),F(Yn.$$.fragment,i),F(Zn.$$.fragment,i),F(ed.$$.fragment,i),F(td.$$.fragment,i),F(dd.$$.fragment,i),F(tr.$$.fragment,i),F(or.$$.fragment,i),F(cd.$$.fragment,i),F(pd.$$.fragment,i),F(vd.$$.fragment,i),F(nr.$$.fragment,i),F(rr.$$.fragment,i),F(kd.$$.fragment,i),F(wd.$$.fragment,i),F(Bd.$$.fragment,i),F(ir.$$.fragment,i),F(lr.$$.fragment,i),F(Md.$$.fragment,i),F(zd.$$.fragment,i),F(Id.$$.fragment,i),F(cr.$$.fragment,i),F(pr.$$.fragment,i),kg=!1},d(i){t(d),i&&t(v),i&&t(f),D(l),i&&t(_e),i&&t(S),i&&t(J),i&&t(oe),D(le),i&&t(be),i&&t(O),i&&t(ve),i&&t(he),i&&t(ke),i&&t(U),i&&t(G),i&&t(ue),i&&t(I),i&&t(te),i&&t(um),i&&t(Lt),i&&t(fm),i&&t(Vo),D(Or),i&&t(mm),i&&t(ic),i&&t(gm),D(Ir,i),i&&t(_m),i&&t(je),i&&t(bm),D(aa,i),i&&t(vm),i&&t(wt),i&&t(km),D(ua,i),i&&t(wm),i&&t(Tt),i&&t(Tm),D(wa,i),i&&t(ym),i&&t(yt),i&&t($m),i&&t(Ec),i&&t(Fm),i&&t(Do),i&&t(Dm),i&&t(zc),i&&t(Em),i&&t(Bo),i&&t(xm),i&&t(Cc),i&&t(Bm),i&&t(Qs),i&&t(Mm),i&&t(Ac),i&&t(zm),i&&t(Mo),i&&t(Cm),i&&t(Jo),D(Va),i&&t(Am),i&&t(Pt),D(Ja),D(Ks),i&&t(jm),i&&t(Xo),D(Xa),i&&t(qm),i&&t(tt),D(Ya),D(ei),D(oi),D(si),D(Gs),D(ni),i&&t(Pm),i&&t(Zo),D(ai),i&&t(Lm),i&&t(ft),D(ii),D(ci),D(hi),D(Zs),i&&t(Om),i&&t(ts),D(ui),i&&t(Im),i&&t(mt),D(fi),D(bi),D(tn),D(on),i&&t(Sm),i&&t(ss),D(vi),i&&t(Nm),i&&t(gt),D(ki),D(Fi),D(nn),D(rn),i&&t(Rm),i&&t(rs),D(Di),i&&t(Wm),i&&t(_t),D(Ei),D(zi),D(ln),D(dn),D(cn),i&&t(Um),i&&t(is),D(Ci),i&&t(Qm),i&&t(bt),D(Ai),D(Li),D(hn),D(un),i&&t(Hm),i&&t(ds),D(Oi),i&&t(Km),i&&t(vt),D(Ii),D(Wi),D(mn),D(gn),i&&t(Vm),i&&t(ps),D(Ui),i&&t(Jm),i&&t(kt),D(Qi),D(Ji),D(bn),D(vn),i&&t(Gm),i&&t(fs),D(Gi),i&&t(Xm),i&&t(lt),D(Xi),D(wn),D(tl),D(Tn),D(yn),i&&t(Ym),i&&t(gs),D(ol),i&&t(Zm),i&&t(dt),D(sl),D(Fn),D(ll),D(Dn),D(En),D(xn),i&&t(eg),i&&t(bs),D(dl),i&&t(tg),i&&t(ct),D(cl),D(Mn),D(fl),D(zn),D(Cn),D(An),i&&t(og),i&&t(ks),D(ml),i&&t(sg),i&&t(pt),D(gl),D(qn),D(kl),D(Pn),D(Ln),i&&t(ng),i&&t(Ts),D(wl),i&&t(rg),i&&t(ht),D(Tl),D(In),D(Dl),D(Sn),D(Nn),D(Rn),i&&t(ag),i&&t($s),D(El),i&&t(ig),i&&t(ut),D(xl),D(Un),D(Cl),D(Qn),D(Hn),D(Kn),i&&t(lg),i&&t(Es),D(Al),i&&t(dg),i&&t(ot),D(jl),D(Rl),D(Jn),D(Gn),i&&t(cg),i&&t(Bs),D(Wl),i&&t(pg),i&&t(st),D(Ul),D(Zl),D(Yn),D(Zn),i&&t(hg),i&&t(zs),D(ed),i&&t(ug),i&&t(nt),D(td),D(dd),D(tr),D(or),i&&t(fg),i&&t(As),D(cd),i&&t(mg),i&&t(rt),D(pd),D(vd),D(nr),D(rr),i&&t(gg),i&&t(qs),D(kd),i&&t(_g),i&&t(at),D(wd),D(Bd),D(ir),D(lr),i&&t(bg),i&&t(Ls),D(Md),i&&t(vg),i&&t(it),D(zd),D(Id),D(cr),D(pr)}}}const cC={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 pC(x){return h3(()=>{new URLSearchParams(window.location.search).get("fw")}),[]}class vC extends l3{constructor(d){super();d3(this,d,pC,dC,c3,{})}}export{vC as default,cC as metadata};
