Buckets:
| import{s as Xo,f as Ao,o as Qo,n as se}from"../chunks/scheduler.25b97de1.js";import{S as Yo,i as Do,g as c,s as a,r as y,A as Oo,h as p,f as o,c as r,j as W,u as v,x as f,k as R,y as d,a as l,v as b,d as T,t as M,w as L}from"../chunks/index.d9030fc9.js";import{T as ut}from"../chunks/Tip.baa67368.js";import{D as B}from"../chunks/Docstring.ffac8efa.js";import{C as Ct}from"../chunks/CodeBlock.e6cd0d95.js";import{F as Ko,M as Vo}from"../chunks/Markdown.7217f838.js";import{E as qt}from"../chunks/ExampleCodeBlock.22dfe688.js";import{P as Io}from"../chunks/PipelineTag.5f100392.js";import{H as Fe,E as en}from"../chunks/EditOnGithub.91d95064.js";function tn($){let t,g='LayoutLMv3 is nearly identical to LayoutLMv2, so we’ve also included LayoutLMv2 resources you can adapt for LayoutLMv3 tasks. For these notebooks, take care to use <a href="/docs/transformers/pr_34652/en/model_doc/layoutlmv2#transformers.LayoutLMv2Processor">LayoutLMv2Processor</a> instead when preparing data for the model!';return{c(){t=c("p"),t.innerHTML=g},l(n){t=p(n,"P",{"data-svelte-h":!0}),f(t)!=="svelte-16a64x3"&&(t.innerHTML=g)},m(n,i){l(n,t,i)},p:se,d(n){n&&o(t)}}}function on($){let t,g="Example:",n,i,w;return i=new Ct({props:{code:"ZnJvbSUyMHRyYW5zZm9ybWVycyUyMGltcG9ydCUyMExheW91dExNdjNDb25maWclMkMlMjBMYXlvdXRMTXYzTW9kZWwlMEElMEElMjMlMjBJbml0aWFsaXppbmclMjBhJTIwTGF5b3V0TE12MyUyMG1pY3Jvc29mdCUyRmxheW91dGxtdjMtYmFzZSUyMHN0eWxlJTIwY29uZmlndXJhdGlvbiUwQWNvbmZpZ3VyYXRpb24lMjAlM0QlMjBMYXlvdXRMTXYzQ29uZmlnKCklMEElMEElMjMlMjBJbml0aWFsaXppbmclMjBhJTIwbW9kZWwlMjAod2l0aCUyMHJhbmRvbSUyMHdlaWdodHMpJTIwZnJvbSUyMHRoZSUyMG1pY3Jvc29mdCUyRmxheW91dGxtdjMtYmFzZSUyMHN0eWxlJTIwY29uZmlndXJhdGlvbiUwQW1vZGVsJTIwJTNEJTIwTGF5b3V0TE12M01vZGVsKGNvbmZpZ3VyYXRpb24pJTBBJTBBJTIzJTIwQWNjZXNzaW5nJTIwdGhlJTIwbW9kZWwlMjBjb25maWd1cmF0aW9uJTBBY29uZmlndXJhdGlvbiUyMCUzRCUyMG1vZGVsLmNvbmZpZw==",highlighted:`<span class="hljs-meta">>>> </span><span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> LayoutLMv3Config, LayoutLMv3Model | |
| <span class="hljs-meta">>>> </span><span class="hljs-comment"># Initializing a LayoutLMv3 microsoft/layoutlmv3-base style configuration</span> | |
| <span class="hljs-meta">>>> </span>configuration = LayoutLMv3Config() | |
| <span class="hljs-meta">>>> </span><span class="hljs-comment"># Initializing a model (with random weights) from the microsoft/layoutlmv3-base style configuration</span> | |
| <span class="hljs-meta">>>> </span>model = LayoutLMv3Model(configuration) | |
| <span class="hljs-meta">>>> </span><span class="hljs-comment"># Accessing the model configuration</span> | |
| <span class="hljs-meta">>>> </span>configuration = model.config`,wrap:!1}}),{c(){t=c("p"),t.textContent=g,n=a(),y(i.$$.fragment)},l(s){t=p(s,"P",{"data-svelte-h":!0}),f(t)!=="svelte-11lpom8"&&(t.textContent=g),n=r(s),v(i.$$.fragment,s)},m(s,k){l(s,t,k),l(s,n,k),b(i,s,k),w=!0},p:se,i(s){w||(T(i.$$.fragment,s),w=!0)},o(s){M(i.$$.fragment,s),w=!1},d(s){s&&(o(t),o(n)),L(i,s)}}}function nn($){let t,g=`Although the recipe for forward pass needs to be defined within this function, one should call the <code>Module</code> | |
| instance afterwards instead of this since the former takes care of running the pre and post processing steps while | |
| the latter silently ignores them.`;return{c(){t=c("p"),t.innerHTML=g},l(n){t=p(n,"P",{"data-svelte-h":!0}),f(t)!=="svelte-fincs2"&&(t.innerHTML=g)},m(n,i){l(n,t,i)},p:se,d(n){n&&o(t)}}}function sn($){let t,g="Examples:",n,i,w;return i=new Ct({props:{code:"ZnJvbSUyMHRyYW5zZm9ybWVycyUyMGltcG9ydCUyMEF1dG9Qcm9jZXNzb3IlMkMlMjBBdXRvTW9kZWwlMEFmcm9tJTIwZGF0YXNldHMlMjBpbXBvcnQlMjBsb2FkX2RhdGFzZXQlMEElMEFwcm9jZXNzb3IlMjAlM0QlMjBBdXRvUHJvY2Vzc29yLmZyb21fcHJldHJhaW5lZCglMjJtaWNyb3NvZnQlMkZsYXlvdXRsbXYzLWJhc2UlMjIlMkMlMjBhcHBseV9vY3IlM0RGYWxzZSklMEFtb2RlbCUyMCUzRCUyMEF1dG9Nb2RlbC5mcm9tX3ByZXRyYWluZWQoJTIybWljcm9zb2Z0JTJGbGF5b3V0bG12My1iYXNlJTIyKSUwQSUwQWRhdGFzZXQlMjAlM0QlMjBsb2FkX2RhdGFzZXQoJTIybmllbHNyJTJGZnVuc2QtbGF5b3V0bG12MyUyMiUyQyUyMHNwbGl0JTNEJTIydHJhaW4lMjIlMkMlMjB0cnVzdF9yZW1vdGVfY29kZSUzRFRydWUpJTBBZXhhbXBsZSUyMCUzRCUyMGRhdGFzZXQlNUIwJTVEJTBBaW1hZ2UlMjAlM0QlMjBleGFtcGxlJTVCJTIyaW1hZ2UlMjIlNUQlMEF3b3JkcyUyMCUzRCUyMGV4YW1wbGUlNUIlMjJ0b2tlbnMlMjIlNUQlMEFib3hlcyUyMCUzRCUyMGV4YW1wbGUlNUIlMjJiYm94ZXMlMjIlNUQlMEElMEFlbmNvZGluZyUyMCUzRCUyMHByb2Nlc3NvcihpbWFnZSUyQyUyMHdvcmRzJTJDJTIwYm94ZXMlM0Rib3hlcyUyQyUyMHJldHVybl90ZW5zb3JzJTNEJTIycHQlMjIpJTBBJTBBb3V0cHV0cyUyMCUzRCUyMG1vZGVsKCoqZW5jb2RpbmcpJTBBbGFzdF9oaWRkZW5fc3RhdGVzJTIwJTNEJTIwb3V0cHV0cy5sYXN0X2hpZGRlbl9zdGF0ZQ==",highlighted:`<span class="hljs-meta">>>> </span><span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> AutoProcessor, AutoModel | |
| <span class="hljs-meta">>>> </span><span class="hljs-keyword">from</span> datasets <span class="hljs-keyword">import</span> load_dataset | |
| <span class="hljs-meta">>>> </span>processor = AutoProcessor.from_pretrained(<span class="hljs-string">"microsoft/layoutlmv3-base"</span>, apply_ocr=<span class="hljs-literal">False</span>) | |
| <span class="hljs-meta">>>> </span>model = AutoModel.from_pretrained(<span class="hljs-string">"microsoft/layoutlmv3-base"</span>) | |
| <span class="hljs-meta">>>> </span>dataset = load_dataset(<span class="hljs-string">"nielsr/funsd-layoutlmv3"</span>, split=<span class="hljs-string">"train"</span>, trust_remote_code=<span class="hljs-literal">True</span>) | |
| <span class="hljs-meta">>>> </span>example = dataset[<span class="hljs-number">0</span>] | |
| <span class="hljs-meta">>>> </span>image = example[<span class="hljs-string">"image"</span>] | |
| <span class="hljs-meta">>>> </span>words = example[<span class="hljs-string">"tokens"</span>] | |
| <span class="hljs-meta">>>> </span>boxes = example[<span class="hljs-string">"bboxes"</span>] | |
| <span class="hljs-meta">>>> </span>encoding = processor(image, words, boxes=boxes, return_tensors=<span class="hljs-string">"pt"</span>) | |
| <span class="hljs-meta">>>> </span>outputs = model(**encoding) | |
| <span class="hljs-meta">>>> </span>last_hidden_states = outputs.last_hidden_state`,wrap:!1}}),{c(){t=c("p"),t.textContent=g,n=a(),y(i.$$.fragment)},l(s){t=p(s,"P",{"data-svelte-h":!0}),f(t)!=="svelte-kvfsh7"&&(t.textContent=g),n=r(s),v(i.$$.fragment,s)},m(s,k){l(s,t,k),l(s,n,k),b(i,s,k),w=!0},p:se,i(s){w||(T(i.$$.fragment,s),w=!0)},o(s){M(i.$$.fragment,s),w=!1},d(s){s&&(o(t),o(n)),L(i,s)}}}function an($){let t,g=`Although the recipe for forward pass needs to be defined within this function, one should call the <code>Module</code> | |
| instance afterwards instead of this since the former takes care of running the pre and post processing steps while | |
| the latter silently ignores them.`;return{c(){t=c("p"),t.innerHTML=g},l(n){t=p(n,"P",{"data-svelte-h":!0}),f(t)!=="svelte-fincs2"&&(t.innerHTML=g)},m(n,i){l(n,t,i)},p:se,d(n){n&&o(t)}}}function rn($){let t,g="Examples:",n,i,w;return i=new Ct({props:{code:"ZnJvbSUyMHRyYW5zZm9ybWVycyUyMGltcG9ydCUyMEF1dG9Qcm9jZXNzb3IlMkMlMjBBdXRvTW9kZWxGb3JTZXF1ZW5jZUNsYXNzaWZpY2F0aW9uJTBBZnJvbSUyMGRhdGFzZXRzJTIwaW1wb3J0JTIwbG9hZF9kYXRhc2V0JTBBaW1wb3J0JTIwdG9yY2glMEElMEFwcm9jZXNzb3IlMjAlM0QlMjBBdXRvUHJvY2Vzc29yLmZyb21fcHJldHJhaW5lZCglMjJtaWNyb3NvZnQlMkZsYXlvdXRsbXYzLWJhc2UlMjIlMkMlMjBhcHBseV9vY3IlM0RGYWxzZSklMEFtb2RlbCUyMCUzRCUyMEF1dG9Nb2RlbEZvclNlcXVlbmNlQ2xhc3NpZmljYXRpb24uZnJvbV9wcmV0cmFpbmVkKCUyMm1pY3Jvc29mdCUyRmxheW91dGxtdjMtYmFzZSUyMiklMEElMEFkYXRhc2V0JTIwJTNEJTIwbG9hZF9kYXRhc2V0KCUyMm5pZWxzciUyRmZ1bnNkLWxheW91dGxtdjMlMjIlMkMlMjBzcGxpdCUzRCUyMnRyYWluJTIyJTJDJTIwdHJ1c3RfcmVtb3RlX2NvZGUlM0RUcnVlKSUwQWV4YW1wbGUlMjAlM0QlMjBkYXRhc2V0JTVCMCU1RCUwQWltYWdlJTIwJTNEJTIwZXhhbXBsZSU1QiUyMmltYWdlJTIyJTVEJTBBd29yZHMlMjAlM0QlMjBleGFtcGxlJTVCJTIydG9rZW5zJTIyJTVEJTBBYm94ZXMlMjAlM0QlMjBleGFtcGxlJTVCJTIyYmJveGVzJTIyJTVEJTBBJTBBZW5jb2RpbmclMjAlM0QlMjBwcm9jZXNzb3IoaW1hZ2UlMkMlMjB3b3JkcyUyQyUyMGJveGVzJTNEYm94ZXMlMkMlMjByZXR1cm5fdGVuc29ycyUzRCUyMnB0JTIyKSUwQXNlcXVlbmNlX2xhYmVsJTIwJTNEJTIwdG9yY2gudGVuc29yKCU1QjElNUQpJTBBJTBBb3V0cHV0cyUyMCUzRCUyMG1vZGVsKCoqZW5jb2RpbmclMkMlMjBsYWJlbHMlM0RzZXF1ZW5jZV9sYWJlbCklMEFsb3NzJTIwJTNEJTIwb3V0cHV0cy5sb3NzJTBBbG9naXRzJTIwJTNEJTIwb3V0cHV0cy5sb2dpdHM=",highlighted:`<span class="hljs-meta">>>> </span><span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> AutoProcessor, AutoModelForSequenceClassification | |
| <span class="hljs-meta">>>> </span><span class="hljs-keyword">from</span> datasets <span class="hljs-keyword">import</span> load_dataset | |
| <span class="hljs-meta">>>> </span><span class="hljs-keyword">import</span> torch | |
| <span class="hljs-meta">>>> </span>processor = AutoProcessor.from_pretrained(<span class="hljs-string">"microsoft/layoutlmv3-base"</span>, apply_ocr=<span class="hljs-literal">False</span>) | |
| <span class="hljs-meta">>>> </span>model = AutoModelForSequenceClassification.from_pretrained(<span class="hljs-string">"microsoft/layoutlmv3-base"</span>) | |
| <span class="hljs-meta">>>> </span>dataset = load_dataset(<span class="hljs-string">"nielsr/funsd-layoutlmv3"</span>, split=<span class="hljs-string">"train"</span>, trust_remote_code=<span class="hljs-literal">True</span>) | |
| <span class="hljs-meta">>>> </span>example = dataset[<span class="hljs-number">0</span>] | |
| <span class="hljs-meta">>>> </span>image = example[<span class="hljs-string">"image"</span>] | |
| <span class="hljs-meta">>>> </span>words = example[<span class="hljs-string">"tokens"</span>] | |
| <span class="hljs-meta">>>> </span>boxes = example[<span class="hljs-string">"bboxes"</span>] | |
| <span class="hljs-meta">>>> </span>encoding = processor(image, words, boxes=boxes, return_tensors=<span class="hljs-string">"pt"</span>) | |
| <span class="hljs-meta">>>> </span>sequence_label = torch.tensor([<span class="hljs-number">1</span>]) | |
| <span class="hljs-meta">>>> </span>outputs = model(**encoding, labels=sequence_label) | |
| <span class="hljs-meta">>>> </span>loss = outputs.loss | |
| <span class="hljs-meta">>>> </span>logits = outputs.logits`,wrap:!1}}),{c(){t=c("p"),t.textContent=g,n=a(),y(i.$$.fragment)},l(s){t=p(s,"P",{"data-svelte-h":!0}),f(t)!=="svelte-kvfsh7"&&(t.textContent=g),n=r(s),v(i.$$.fragment,s)},m(s,k){l(s,t,k),l(s,n,k),b(i,s,k),w=!0},p:se,i(s){w||(T(i.$$.fragment,s),w=!0)},o(s){M(i.$$.fragment,s),w=!1},d(s){s&&(o(t),o(n)),L(i,s)}}}function ln($){let t,g=`Although the recipe for forward pass needs to be defined within this function, one should call the <code>Module</code> | |
| instance afterwards instead of this since the former takes care of running the pre and post processing steps while | |
| the latter silently ignores them.`;return{c(){t=c("p"),t.innerHTML=g},l(n){t=p(n,"P",{"data-svelte-h":!0}),f(t)!=="svelte-fincs2"&&(t.innerHTML=g)},m(n,i){l(n,t,i)},p:se,d(n){n&&o(t)}}}function dn($){let t,g="Examples:",n,i,w;return i=new Ct({props:{code:"ZnJvbSUyMHRyYW5zZm9ybWVycyUyMGltcG9ydCUyMEF1dG9Qcm9jZXNzb3IlMkMlMjBBdXRvTW9kZWxGb3JUb2tlbkNsYXNzaWZpY2F0aW9uJTBBZnJvbSUyMGRhdGFzZXRzJTIwaW1wb3J0JTIwbG9hZF9kYXRhc2V0JTBBJTBBcHJvY2Vzc29yJTIwJTNEJTIwQXV0b1Byb2Nlc3Nvci5mcm9tX3ByZXRyYWluZWQoJTIybWljcm9zb2Z0JTJGbGF5b3V0bG12My1iYXNlJTIyJTJDJTIwYXBwbHlfb2NyJTNERmFsc2UpJTBBbW9kZWwlMjAlM0QlMjBBdXRvTW9kZWxGb3JUb2tlbkNsYXNzaWZpY2F0aW9uLmZyb21fcHJldHJhaW5lZCglMjJtaWNyb3NvZnQlMkZsYXlvdXRsbXYzLWJhc2UlMjIlMkMlMjBudW1fbGFiZWxzJTNENyklMEElMEFkYXRhc2V0JTIwJTNEJTIwbG9hZF9kYXRhc2V0KCUyMm5pZWxzciUyRmZ1bnNkLWxheW91dGxtdjMlMjIlMkMlMjBzcGxpdCUzRCUyMnRyYWluJTIyJTJDJTIwdHJ1c3RfcmVtb3RlX2NvZGUlM0RUcnVlKSUwQWV4YW1wbGUlMjAlM0QlMjBkYXRhc2V0JTVCMCU1RCUwQWltYWdlJTIwJTNEJTIwZXhhbXBsZSU1QiUyMmltYWdlJTIyJTVEJTBBd29yZHMlMjAlM0QlMjBleGFtcGxlJTVCJTIydG9rZW5zJTIyJTVEJTBBYm94ZXMlMjAlM0QlMjBleGFtcGxlJTVCJTIyYmJveGVzJTIyJTVEJTBBd29yZF9sYWJlbHMlMjAlM0QlMjBleGFtcGxlJTVCJTIybmVyX3RhZ3MlMjIlNUQlMEElMEFlbmNvZGluZyUyMCUzRCUyMHByb2Nlc3NvcihpbWFnZSUyQyUyMHdvcmRzJTJDJTIwYm94ZXMlM0Rib3hlcyUyQyUyMHdvcmRfbGFiZWxzJTNEd29yZF9sYWJlbHMlMkMlMjByZXR1cm5fdGVuc29ycyUzRCUyMnB0JTIyKSUwQSUwQW91dHB1dHMlMjAlM0QlMjBtb2RlbCgqKmVuY29kaW5nKSUwQWxvc3MlMjAlM0QlMjBvdXRwdXRzLmxvc3MlMEFsb2dpdHMlMjAlM0QlMjBvdXRwdXRzLmxvZ2l0cw==",highlighted:`<span class="hljs-meta">>>> </span><span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> AutoProcessor, AutoModelForTokenClassification | |
| <span class="hljs-meta">>>> </span><span class="hljs-keyword">from</span> datasets <span class="hljs-keyword">import</span> load_dataset | |
| <span class="hljs-meta">>>> </span>processor = AutoProcessor.from_pretrained(<span class="hljs-string">"microsoft/layoutlmv3-base"</span>, apply_ocr=<span class="hljs-literal">False</span>) | |
| <span class="hljs-meta">>>> </span>model = AutoModelForTokenClassification.from_pretrained(<span class="hljs-string">"microsoft/layoutlmv3-base"</span>, num_labels=<span class="hljs-number">7</span>) | |
| <span class="hljs-meta">>>> </span>dataset = load_dataset(<span class="hljs-string">"nielsr/funsd-layoutlmv3"</span>, split=<span class="hljs-string">"train"</span>, trust_remote_code=<span class="hljs-literal">True</span>) | |
| <span class="hljs-meta">>>> </span>example = dataset[<span class="hljs-number">0</span>] | |
| <span class="hljs-meta">>>> </span>image = example[<span class="hljs-string">"image"</span>] | |
| <span class="hljs-meta">>>> </span>words = example[<span class="hljs-string">"tokens"</span>] | |
| <span class="hljs-meta">>>> </span>boxes = example[<span class="hljs-string">"bboxes"</span>] | |
| <span class="hljs-meta">>>> </span>word_labels = example[<span class="hljs-string">"ner_tags"</span>] | |
| <span class="hljs-meta">>>> </span>encoding = processor(image, words, boxes=boxes, word_labels=word_labels, return_tensors=<span class="hljs-string">"pt"</span>) | |
| <span class="hljs-meta">>>> </span>outputs = model(**encoding) | |
| <span class="hljs-meta">>>> </span>loss = outputs.loss | |
| <span class="hljs-meta">>>> </span>logits = outputs.logits`,wrap:!1}}),{c(){t=c("p"),t.textContent=g,n=a(),y(i.$$.fragment)},l(s){t=p(s,"P",{"data-svelte-h":!0}),f(t)!=="svelte-kvfsh7"&&(t.textContent=g),n=r(s),v(i.$$.fragment,s)},m(s,k){l(s,t,k),l(s,n,k),b(i,s,k),w=!0},p:se,i(s){w||(T(i.$$.fragment,s),w=!0)},o(s){M(i.$$.fragment,s),w=!1},d(s){s&&(o(t),o(n)),L(i,s)}}}function cn($){let t,g=`Although the recipe for forward pass needs to be defined within this function, one should call the <code>Module</code> | |
| instance afterwards instead of this since the former takes care of running the pre and post processing steps while | |
| the latter silently ignores them.`;return{c(){t=c("p"),t.innerHTML=g},l(n){t=p(n,"P",{"data-svelte-h":!0}),f(t)!=="svelte-fincs2"&&(t.innerHTML=g)},m(n,i){l(n,t,i)},p:se,d(n){n&&o(t)}}}function pn($){let t,g="Examples:",n,i,w;return i=new Ct({props:{code:"ZnJvbSUyMHRyYW5zZm9ybWVycyUyMGltcG9ydCUyMEF1dG9Qcm9jZXNzb3IlMkMlMjBBdXRvTW9kZWxGb3JRdWVzdGlvbkFuc3dlcmluZyUwQWZyb20lMjBkYXRhc2V0cyUyMGltcG9ydCUyMGxvYWRfZGF0YXNldCUwQWltcG9ydCUyMHRvcmNoJTBBJTBBcHJvY2Vzc29yJTIwJTNEJTIwQXV0b1Byb2Nlc3Nvci5mcm9tX3ByZXRyYWluZWQoJTIybWljcm9zb2Z0JTJGbGF5b3V0bG12My1iYXNlJTIyJTJDJTIwYXBwbHlfb2NyJTNERmFsc2UpJTBBbW9kZWwlMjAlM0QlMjBBdXRvTW9kZWxGb3JRdWVzdGlvbkFuc3dlcmluZy5mcm9tX3ByZXRyYWluZWQoJTIybWljcm9zb2Z0JTJGbGF5b3V0bG12My1iYXNlJTIyKSUwQSUwQWRhdGFzZXQlMjAlM0QlMjBsb2FkX2RhdGFzZXQoJTIybmllbHNyJTJGZnVuc2QtbGF5b3V0bG12MyUyMiUyQyUyMHNwbGl0JTNEJTIydHJhaW4lMjIlMkMlMjB0cnVzdF9yZW1vdGVfY29kZSUzRFRydWUpJTBBZXhhbXBsZSUyMCUzRCUyMGRhdGFzZXQlNUIwJTVEJTBBaW1hZ2UlMjAlM0QlMjBleGFtcGxlJTVCJTIyaW1hZ2UlMjIlNUQlMEFxdWVzdGlvbiUyMCUzRCUyMCUyMndoYXQncyUyMGhpcyUyMG5hbWUlM0YlMjIlMEF3b3JkcyUyMCUzRCUyMGV4YW1wbGUlNUIlMjJ0b2tlbnMlMjIlNUQlMEFib3hlcyUyMCUzRCUyMGV4YW1wbGUlNUIlMjJiYm94ZXMlMjIlNUQlMEElMEFlbmNvZGluZyUyMCUzRCUyMHByb2Nlc3NvcihpbWFnZSUyQyUyMHF1ZXN0aW9uJTJDJTIwd29yZHMlMkMlMjBib3hlcyUzRGJveGVzJTJDJTIwcmV0dXJuX3RlbnNvcnMlM0QlMjJwdCUyMiklMEFzdGFydF9wb3NpdGlvbnMlMjAlM0QlMjB0b3JjaC50ZW5zb3IoJTVCMSU1RCklMEFlbmRfcG9zaXRpb25zJTIwJTNEJTIwdG9yY2gudGVuc29yKCU1QjMlNUQpJTBBJTBBb3V0cHV0cyUyMCUzRCUyMG1vZGVsKCoqZW5jb2RpbmclMkMlMjBzdGFydF9wb3NpdGlvbnMlM0RzdGFydF9wb3NpdGlvbnMlMkMlMjBlbmRfcG9zaXRpb25zJTNEZW5kX3Bvc2l0aW9ucyklMEFsb3NzJTIwJTNEJTIwb3V0cHV0cy5sb3NzJTBBc3RhcnRfc2NvcmVzJTIwJTNEJTIwb3V0cHV0cy5zdGFydF9sb2dpdHMlMEFlbmRfc2NvcmVzJTIwJTNEJTIwb3V0cHV0cy5lbmRfbG9naXRz",highlighted:`<span class="hljs-meta">>>> </span><span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> AutoProcessor, AutoModelForQuestionAnswering | |
| <span class="hljs-meta">>>> </span><span class="hljs-keyword">from</span> datasets <span class="hljs-keyword">import</span> load_dataset | |
| <span class="hljs-meta">>>> </span><span class="hljs-keyword">import</span> torch | |
| <span class="hljs-meta">>>> </span>processor = AutoProcessor.from_pretrained(<span class="hljs-string">"microsoft/layoutlmv3-base"</span>, apply_ocr=<span class="hljs-literal">False</span>) | |
| <span class="hljs-meta">>>> </span>model = AutoModelForQuestionAnswering.from_pretrained(<span class="hljs-string">"microsoft/layoutlmv3-base"</span>) | |
| <span class="hljs-meta">>>> </span>dataset = load_dataset(<span class="hljs-string">"nielsr/funsd-layoutlmv3"</span>, split=<span class="hljs-string">"train"</span>, trust_remote_code=<span class="hljs-literal">True</span>) | |
| <span class="hljs-meta">>>> </span>example = dataset[<span class="hljs-number">0</span>] | |
| <span class="hljs-meta">>>> </span>image = example[<span class="hljs-string">"image"</span>] | |
| <span class="hljs-meta">>>> </span>question = <span class="hljs-string">"what's his name?"</span> | |
| <span class="hljs-meta">>>> </span>words = example[<span class="hljs-string">"tokens"</span>] | |
| <span class="hljs-meta">>>> </span>boxes = example[<span class="hljs-string">"bboxes"</span>] | |
| <span class="hljs-meta">>>> </span>encoding = processor(image, question, words, boxes=boxes, return_tensors=<span class="hljs-string">"pt"</span>) | |
| <span class="hljs-meta">>>> </span>start_positions = torch.tensor([<span class="hljs-number">1</span>]) | |
| <span class="hljs-meta">>>> </span>end_positions = torch.tensor([<span class="hljs-number">3</span>]) | |
| <span class="hljs-meta">>>> </span>outputs = model(**encoding, start_positions=start_positions, end_positions=end_positions) | |
| <span class="hljs-meta">>>> </span>loss = outputs.loss | |
| <span class="hljs-meta">>>> </span>start_scores = outputs.start_logits | |
| <span class="hljs-meta">>>> </span>end_scores = outputs.end_logits`,wrap:!1}}),{c(){t=c("p"),t.textContent=g,n=a(),y(i.$$.fragment)},l(s){t=p(s,"P",{"data-svelte-h":!0}),f(t)!=="svelte-kvfsh7"&&(t.textContent=g),n=r(s),v(i.$$.fragment,s)},m(s,k){l(s,t,k),l(s,n,k),b(i,s,k),w=!0},p:se,i(s){w||(T(i.$$.fragment,s),w=!0)},o(s){M(i.$$.fragment,s),w=!1},d(s){s&&(o(t),o(n)),L(i,s)}}}function mn($){let t,g,n,i,w,s,k=`The bare LayoutLMv3 Model transformer outputting raw hidden-states without any specific head on top. | |
| This model is a PyTorch <a href="https://pytorch.org/docs/stable/nn.html#torch.nn.Module" rel="nofollow">torch.nn.Module</a> sub-class. Use | |
| it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage and | |
| behavior.`,Q,z,C,Y,j,N='The <a href="/docs/transformers/pr_34652/en/model_doc/layoutlmv3#transformers.LayoutLMv3Model">LayoutLMv3Model</a> forward method, overrides the <code>__call__</code> special method.',I,m,F,le,je,De,be,E,ue,rt,K,Mt=`LayoutLMv3 Model with a sequence classification head on top (a linear layer on top of the final hidden state of the | |
| [CLS] token) e.g. for document image classification tasks such as the | |
| <a href="https://www.cs.cmu.edu/~aharley/rvl-cdip/" rel="nofollow">RVL-CDIP</a> dataset.`,G,ee,yt=`This model is a PyTorch <a href="https://pytorch.org/docs/stable/nn.html#torch.nn.Module" rel="nofollow">torch.nn.Module</a> sub-class. Use | |
| it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage and | |
| behavior.`,Te,Me,Ne,Le,Oe,Ke='The <a href="/docs/transformers/pr_34652/en/model_doc/layoutlmv3#transformers.LayoutLMv3ForSequenceClassification">LayoutLMv3ForSequenceClassification</a> forward method, overrides the <code>__call__</code> special method.',it,Je,Ie,te,Ue,O,ze,V,he,et,lt,Re=`LayoutLMv3 Model with a token classification head on top (a linear layer on top of the final hidden states) e.g. | |
| for sequence labeling (information extraction) tasks such as <a href="https://guillaumejaume.github.io/FUNSD/" rel="nofollow">FUNSD</a>, | |
| <a href="https://rrc.cvc.uab.es/?ch=13" rel="nofollow">SROIE</a>, <a href="https://github.com/clovaai/cord" rel="nofollow">CORD</a> and | |
| <a href="https://github.com/applicaai/kleister-nda" rel="nofollow">Kleister-NDA</a>.`,He,de,Ee=`This model is a PyTorch <a href="https://pytorch.org/docs/stable/nn.html#torch.nn.Module" rel="nofollow">torch.nn.Module</a> sub-class. Use | |
| it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage and | |
| behavior.`,tt,oe,U,We,ke,ht='The <a href="/docs/transformers/pr_34652/en/model_doc/layoutlmv3#transformers.LayoutLMv3ForTokenClassification">LayoutLMv3ForTokenClassification</a> forward method, overrides the <code>__call__</code> special method.',vt,ce,dt,Ze,Be,qe,ft,X,ae,re,P,ot=`LayoutLMv3 Model with a span classification head on top for extractive question-answering tasks such as | |
| <a href="https://rrc.cvc.uab.es/?ch=17" rel="nofollow">DocVQA</a> (a linear layer on top of the text part of the hidden-states output to | |
| compute <code>span start logits</code> and <code>span end logits</code>).`,nt,Pe,Ft=`This model is a PyTorch <a href="https://pytorch.org/docs/stable/nn.html#torch.nn.Module" rel="nofollow">torch.nn.Module</a> sub-class. Use | |
| it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage and | |
| behavior.`,st,D,Ve,ie,Se,we='The <a href="/docs/transformers/pr_34652/en/model_doc/layoutlmv3#transformers.LayoutLMv3ForQuestionAnswering">LayoutLMv3ForQuestionAnswering</a> forward method, overrides the <code>__call__</code> special method.',ct,J,fe,Ge,pe;return t=new Fe({props:{title:"LayoutLMv3Model",local:"transformers.LayoutLMv3Model",headingTag:"h2"}}),i=new B({props:{name:"class transformers.LayoutLMv3Model",anchor:"transformers.LayoutLMv3Model",parameters:[{name:"config",val:""}],parametersDescription:[{anchor:"transformers.LayoutLMv3Model.config",description:`<strong>config</strong> (<a href="/docs/transformers/pr_34652/en/model_doc/layoutlmv3#transformers.LayoutLMv3Config">LayoutLMv3Config</a>) — 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/pr_34652/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/vr_34652/src/transformers/models/layoutlmv3/modeling_layoutlmv3.py#L745"}}),C=new B({props:{name:"forward",anchor:"transformers.LayoutLMv3Model.forward",parameters:[{name:"input_ids",val:": typing.Optional[torch.LongTensor] = None"},{name:"bbox",val:": typing.Optional[torch.LongTensor] = None"},{name:"attention_mask",val:": typing.Optional[torch.FloatTensor] = None"},{name:"token_type_ids",val:": typing.Optional[torch.LongTensor] = None"},{name:"position_ids",val:": typing.Optional[torch.LongTensor] = None"},{name:"head_mask",val:": typing.Optional[torch.FloatTensor] = None"},{name:"inputs_embeds",val:": typing.Optional[torch.FloatTensor] = None"},{name:"pixel_values",val:": typing.Optional[torch.FloatTensor] = 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.LayoutLMv3Model.forward.input_ids",description:`<strong>input_ids</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size, token_sequence_length)</code>) — | |
| Indices of input sequence tokens in the vocabulary.</p> | |
| <p>Note that <code>sequence_length = token_sequence_length + patch_sequence_length + 1</code> where <code>1</code> is for [CLS] | |
| token. See <code>pixel_values</code> for <code>patch_sequence_length</code>.</p> | |
| <p>Indices can be obtained using <a href="/docs/transformers/pr_34652/en/model_doc/auto#transformers.AutoTokenizer">AutoTokenizer</a>. See <a href="/docs/transformers/pr_34652/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode">PreTrainedTokenizer.encode()</a> and | |
| <a href="/docs/transformers/pr_34652/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.LayoutLMv3Model.forward.bbox",description:`<strong>bbox</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size, token_sequence_length, 4)</code>, <em>optional</em>) — | |
| Bounding boxes of each input sequence tokens. Selected in the range <code>[0, config.max_2d_position_embeddings-1]</code>. Each bounding box should be a normalized version in (x0, y0, x1, y1) | |
| format, where (x0, y0) corresponds to the position of the upper left corner in the bounding box, and (x1, | |
| y1) represents the position of the lower right corner.</p> | |
| <p>Note that <code>sequence_length = token_sequence_length + patch_sequence_length + 1</code> where <code>1</code> is for [CLS] | |
| token. See <code>pixel_values</code> for <code>patch_sequence_length</code>.`,name:"bbox"},{anchor:"transformers.LayoutLMv3Model.forward.pixel_values",description:`<strong>pixel_values</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, num_channels, height, width)</code>) — | |
| Batch of document images. Each image is divided into patches of shape <code>(num_channels, config.patch_size, config.patch_size)</code> and the total number of patches (=<code>patch_sequence_length</code>) equals to <code>((height / config.patch_size) * (width / config.patch_size))</code>.`,name:"pixel_values"},{anchor:"transformers.LayoutLMv3Model.forward.attention_mask",description:`<strong>attention_mask</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, token_sequence_length)</code>, <em>optional</em>) — | |
| 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>Note that <code>sequence_length = token_sequence_length + patch_sequence_length + 1</code> where <code>1</code> is for [CLS] | |
| token. See <code>pixel_values</code> for <code>patch_sequence_length</code>.</p> | |
| <p><a href="../glossary#attention-mask">What are attention masks?</a>`,name:"attention_mask"},{anchor:"transformers.LayoutLMv3Model.forward.token_type_ids",description:`<strong>token_type_ids</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size, token_sequence_length)</code>, <em>optional</em>) — | |
| Segment token indices to indicate first and second portions of the inputs. Indices are selected in <code>[0, 1]</code>:</p> | |
| <ul> | |
| <li>0 corresponds to a <em>sentence A</em> token,</li> | |
| <li>1 corresponds to a <em>sentence B</em> token.</li> | |
| </ul> | |
| <p>Note that <code>sequence_length = token_sequence_length + patch_sequence_length + 1</code> where <code>1</code> is for [CLS] | |
| token. See <code>pixel_values</code> for <code>patch_sequence_length</code>.</p> | |
| <p><a href="../glossary#token-type-ids">What are token type IDs?</a>`,name:"token_type_ids"},{anchor:"transformers.LayoutLMv3Model.forward.position_ids",description:`<strong>position_ids</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size, token_sequence_length)</code>, <em>optional</em>) — | |
| Indices of positions of each input sequence tokens in the position embeddings. Selected in the range <code>[0, config.max_position_embeddings - 1]</code>.</p> | |
| <p>Note that <code>sequence_length = token_sequence_length + patch_sequence_length + 1</code> where <code>1</code> is for [CLS] | |
| token. See <code>pixel_values</code> for <code>patch_sequence_length</code>.</p> | |
| <p><a href="../glossary#position-ids">What are position IDs?</a>`,name:"position_ids"},{anchor:"transformers.LayoutLMv3Model.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>) — | |
| 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.LayoutLMv3Model.forward.inputs_embeds",description:`<strong>inputs_embeds</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, token_sequence_length, hidden_size)</code>, <em>optional</em>) — | |
| 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 <em>input_ids</em> indices into associated vectors than the | |
| model’s internal embedding lookup matrix.`,name:"inputs_embeds"},{anchor:"transformers.LayoutLMv3Model.forward.output_attentions",description:`<strong>output_attentions</strong> (<code>bool</code>, <em>optional</em>) — | |
| 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.LayoutLMv3Model.forward.output_hidden_states",description:`<strong>output_hidden_states</strong> (<code>bool</code>, <em>optional</em>) — | |
| 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.LayoutLMv3Model.forward.return_dict",description:`<strong>return_dict</strong> (<code>bool</code>, <em>optional</em>) — | |
| Whether or not to return a <a href="/docs/transformers/pr_34652/en/main_classes/output#transformers.utils.ModelOutput">ModelOutput</a> instead of a plain tuple.`,name:"return_dict"}],source:"https://github.com/huggingface/transformers/blob/vr_34652/src/transformers/models/layoutlmv3/modeling_layoutlmv3.py#L838",returnDescription:`<script context="module">export const metadata = 'undefined';<\/script> | |
| <p>A <a | |
| href="/docs/transformers/pr_34652/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/pr_34652/en/model_doc/layoutlmv3#transformers.LayoutLMv3Config" | |
| >LayoutLMv3Config</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>) — 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>) — 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>) — 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:`<script context="module">export const metadata = 'undefined';<\/script> | |
| <p><a | |
| href="/docs/transformers/pr_34652/en/main_classes/output#transformers.modeling_outputs.BaseModelOutput" | |
| >transformers.modeling_outputs.BaseModelOutput</a> or <code>tuple(torch.FloatTensor)</code></p> | |
| `}}),m=new ut({props:{$$slots:{default:[nn]},$$scope:{ctx:$}}}),le=new qt({props:{anchor:"transformers.LayoutLMv3Model.forward.example",$$slots:{default:[sn]},$$scope:{ctx:$}}}),De=new Fe({props:{title:"LayoutLMv3ForSequenceClassification",local:"transformers.LayoutLMv3ForSequenceClassification",headingTag:"h2"}}),ue=new B({props:{name:"class transformers.LayoutLMv3ForSequenceClassification",anchor:"transformers.LayoutLMv3ForSequenceClassification",parameters:[{name:"config",val:""}],parametersDescription:[{anchor:"transformers.LayoutLMv3ForSequenceClassification.config",description:`<strong>config</strong> (<a href="/docs/transformers/pr_34652/en/model_doc/layoutlmv3#transformers.LayoutLMv3Config">LayoutLMv3Config</a>) — 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/pr_34652/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/vr_34652/src/transformers/models/layoutlmv3/modeling_layoutlmv3.py#L1270"}}),Ne=new B({props:{name:"forward",anchor:"transformers.LayoutLMv3ForSequenceClassification.forward",parameters:[{name:"input_ids",val:": typing.Optional[torch.LongTensor] = None"},{name:"attention_mask",val:": typing.Optional[torch.FloatTensor] = None"},{name:"token_type_ids",val:": typing.Optional[torch.LongTensor] = None"},{name:"position_ids",val:": typing.Optional[torch.LongTensor] = None"},{name:"head_mask",val:": typing.Optional[torch.FloatTensor] = None"},{name:"inputs_embeds",val:": typing.Optional[torch.FloatTensor] = 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"},{name:"bbox",val:": typing.Optional[torch.LongTensor] = None"},{name:"pixel_values",val:": typing.Optional[torch.LongTensor] = None"}],parametersDescription:[{anchor:"transformers.LayoutLMv3ForSequenceClassification.forward.input_ids",description:`<strong>input_ids</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size, sequence_length)</code>) — | |
| Indices of input sequence tokens in the vocabulary.</p> | |
| <p>Indices can be obtained using <a href="/docs/transformers/pr_34652/en/model_doc/auto#transformers.AutoTokenizer">AutoTokenizer</a>. See <a href="/docs/transformers/pr_34652/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode">PreTrainedTokenizer.encode()</a> and | |
| <a href="/docs/transformers/pr_34652/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.LayoutLMv3ForSequenceClassification.forward.bbox",description:`<strong>bbox</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size, sequence_length, 4)</code>, <em>optional</em>) — | |
| Bounding boxes of each input sequence tokens. Selected in the range <code>[0, config.max_2d_position_embeddings-1]</code>. Each bounding box should be a normalized version in (x0, y0, x1, y1) | |
| format, where (x0, y0) corresponds to the position of the upper left corner in the bounding box, and (x1, | |
| y1) represents the position of the lower right corner.`,name:"bbox"},{anchor:"transformers.LayoutLMv3ForSequenceClassification.forward.pixel_values",description:`<strong>pixel_values</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, num_channels, height, width)</code>) — | |
| Batch of document images. Each image is divided into patches of shape <code>(num_channels, config.patch_size, config.patch_size)</code> and the total number of patches (=<code>patch_sequence_length</code>) equals to <code>((height / config.patch_size) * (width / config.patch_size))</code>.`,name:"pixel_values"},{anchor:"transformers.LayoutLMv3ForSequenceClassification.forward.attention_mask",description:`<strong>attention_mask</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length)</code>, <em>optional</em>) — | |
| 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.LayoutLMv3ForSequenceClassification.forward.token_type_ids",description:`<strong>token_type_ids</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size, sequence_length)</code>, <em>optional</em>) — | |
| Segment token indices to indicate first and second portions of the inputs. Indices are selected in <code>[0, 1]</code>:</p> | |
| <ul> | |
| <li>0 corresponds to a <em>sentence A</em> token,</li> | |
| <li>1 corresponds to a <em>sentence B</em> token.</li> | |
| </ul> | |
| <p><a href="../glossary#token-type-ids">What are token type IDs?</a>`,name:"token_type_ids"},{anchor:"transformers.LayoutLMv3ForSequenceClassification.forward.position_ids",description:`<strong>position_ids</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size, sequence_length)</code>, <em>optional</em>) — | |
| Indices of positions of each input sequence tokens in the position embeddings. Selected in the range <code>[0, config.max_position_embeddings - 1]</code>.</p> | |
| <p><a href="../glossary#position-ids">What are position IDs?</a>`,name:"position_ids"},{anchor:"transformers.LayoutLMv3ForSequenceClassification.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>) — | |
| 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.LayoutLMv3ForSequenceClassification.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>) — | |
| 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 <em>input_ids</em> indices into associated vectors than the | |
| model’s internal embedding lookup matrix.`,name:"inputs_embeds"},{anchor:"transformers.LayoutLMv3ForSequenceClassification.forward.output_attentions",description:`<strong>output_attentions</strong> (<code>bool</code>, <em>optional</em>) — | |
| 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.LayoutLMv3ForSequenceClassification.forward.output_hidden_states",description:`<strong>output_hidden_states</strong> (<code>bool</code>, <em>optional</em>) — | |
| 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.LayoutLMv3ForSequenceClassification.forward.return_dict",description:`<strong>return_dict</strong> (<code>bool</code>, <em>optional</em>) — | |
| Whether or not to return a <a href="/docs/transformers/pr_34652/en/main_classes/output#transformers.utils.ModelOutput">ModelOutput</a> instead of a plain tuple.`,name:"return_dict"}],source:"https://github.com/huggingface/transformers/blob/vr_34652/src/transformers/models/layoutlmv3/modeling_layoutlmv3.py#L1288",returnDescription:`<script context="module">export const metadata = 'undefined';<\/script> | |
| <p>A <a | |
| href="/docs/transformers/pr_34652/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/pr_34652/en/model_doc/layoutlmv3#transformers.LayoutLMv3Config" | |
| >LayoutLMv3Config</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) — 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>) — 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>) — 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>) — 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:`<script context="module">export const metadata = 'undefined';<\/script> | |
| <p><a | |
| href="/docs/transformers/pr_34652/en/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput" | |
| >transformers.modeling_outputs.SequenceClassifierOutput</a> or <code>tuple(torch.FloatTensor)</code></p> | |
| `}}),Je=new ut({props:{$$slots:{default:[an]},$$scope:{ctx:$}}}),te=new qt({props:{anchor:"transformers.LayoutLMv3ForSequenceClassification.forward.example",$$slots:{default:[rn]},$$scope:{ctx:$}}}),O=new Fe({props:{title:"LayoutLMv3ForTokenClassification",local:"transformers.LayoutLMv3ForTokenClassification",headingTag:"h2"}}),he=new B({props:{name:"class transformers.LayoutLMv3ForTokenClassification",anchor:"transformers.LayoutLMv3ForTokenClassification",parameters:[{name:"config",val:""}],parametersDescription:[{anchor:"transformers.LayoutLMv3ForTokenClassification.config",description:`<strong>config</strong> (<a href="/docs/transformers/pr_34652/en/model_doc/layoutlmv3#transformers.LayoutLMv3Config">LayoutLMv3Config</a>) — 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/pr_34652/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/vr_34652/src/transformers/models/layoutlmv3/modeling_layoutlmv3.py#L1027"}}),U=new B({props:{name:"forward",anchor:"transformers.LayoutLMv3ForTokenClassification.forward",parameters:[{name:"input_ids",val:": typing.Optional[torch.LongTensor] = None"},{name:"bbox",val:": typing.Optional[torch.LongTensor] = None"},{name:"attention_mask",val:": typing.Optional[torch.FloatTensor] = None"},{name:"token_type_ids",val:": typing.Optional[torch.LongTensor] = None"},{name:"position_ids",val:": typing.Optional[torch.LongTensor] = None"},{name:"head_mask",val:": typing.Optional[torch.FloatTensor] = None"},{name:"inputs_embeds",val:": typing.Optional[torch.FloatTensor] = 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"},{name:"pixel_values",val:": typing.Optional[torch.LongTensor] = None"}],parametersDescription:[{anchor:"transformers.LayoutLMv3ForTokenClassification.forward.input_ids",description:`<strong>input_ids</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size, sequence_length)</code>) — | |
| Indices of input sequence tokens in the vocabulary.</p> | |
| <p>Indices can be obtained using <a href="/docs/transformers/pr_34652/en/model_doc/auto#transformers.AutoTokenizer">AutoTokenizer</a>. See <a href="/docs/transformers/pr_34652/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode">PreTrainedTokenizer.encode()</a> and | |
| <a href="/docs/transformers/pr_34652/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.LayoutLMv3ForTokenClassification.forward.bbox",description:`<strong>bbox</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size, sequence_length, 4)</code>, <em>optional</em>) — | |
| Bounding boxes of each input sequence tokens. Selected in the range <code>[0, config.max_2d_position_embeddings-1]</code>. Each bounding box should be a normalized version in (x0, y0, x1, y1) | |
| format, where (x0, y0) corresponds to the position of the upper left corner in the bounding box, and (x1, | |
| y1) represents the position of the lower right corner.`,name:"bbox"},{anchor:"transformers.LayoutLMv3ForTokenClassification.forward.pixel_values",description:`<strong>pixel_values</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, num_channels, height, width)</code>) — | |
| Batch of document images. Each image is divided into patches of shape <code>(num_channels, config.patch_size, config.patch_size)</code> and the total number of patches (=<code>patch_sequence_length</code>) equals to <code>((height / config.patch_size) * (width / config.patch_size))</code>.`,name:"pixel_values"},{anchor:"transformers.LayoutLMv3ForTokenClassification.forward.attention_mask",description:`<strong>attention_mask</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length)</code>, <em>optional</em>) — | |
| 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.LayoutLMv3ForTokenClassification.forward.token_type_ids",description:`<strong>token_type_ids</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size, sequence_length)</code>, <em>optional</em>) — | |
| Segment token indices to indicate first and second portions of the inputs. Indices are selected in <code>[0, 1]</code>:</p> | |
| <ul> | |
| <li>0 corresponds to a <em>sentence A</em> token,</li> | |
| <li>1 corresponds to a <em>sentence B</em> token.</li> | |
| </ul> | |
| <p><a href="../glossary#token-type-ids">What are token type IDs?</a>`,name:"token_type_ids"},{anchor:"transformers.LayoutLMv3ForTokenClassification.forward.position_ids",description:`<strong>position_ids</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size, sequence_length)</code>, <em>optional</em>) — | |
| Indices of positions of each input sequence tokens in the position embeddings. Selected in the range <code>[0, config.max_position_embeddings - 1]</code>.</p> | |
| <p><a href="../glossary#position-ids">What are position IDs?</a>`,name:"position_ids"},{anchor:"transformers.LayoutLMv3ForTokenClassification.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>) — | |
| 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.LayoutLMv3ForTokenClassification.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>) — | |
| 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 <em>input_ids</em> indices into associated vectors than the | |
| model’s internal embedding lookup matrix.`,name:"inputs_embeds"},{anchor:"transformers.LayoutLMv3ForTokenClassification.forward.output_attentions",description:`<strong>output_attentions</strong> (<code>bool</code>, <em>optional</em>) — | |
| 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.LayoutLMv3ForTokenClassification.forward.output_hidden_states",description:`<strong>output_hidden_states</strong> (<code>bool</code>, <em>optional</em>) — | |
| 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.LayoutLMv3ForTokenClassification.forward.return_dict",description:`<strong>return_dict</strong> (<code>bool</code>, <em>optional</em>) — | |
| Whether or not to return a <a href="/docs/transformers/pr_34652/en/main_classes/output#transformers.utils.ModelOutput">ModelOutput</a> instead of a plain tuple.`,name:"return_dict"},{anchor:"transformers.LayoutLMv3ForTokenClassification.forward.labels",description:`<strong>labels</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size, sequence_length)</code>, <em>optional</em>) — | |
| 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/vr_34652/src/transformers/models/layoutlmv3/modeling_layoutlmv3.py#L1050",returnDescription:`<script context="module">export const metadata = 'undefined';<\/script> | |
| <p>A <a | |
| href="/docs/transformers/pr_34652/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/pr_34652/en/model_doc/layoutlmv3#transformers.LayoutLMv3Config" | |
| >LayoutLMv3Config</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) — Classification loss.</p> | |
| </li> | |
| <li> | |
| <p><strong>logits</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, config.num_labels)</code>) — 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>) — 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>) — 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:`<script context="module">export const metadata = 'undefined';<\/script> | |
| <p><a | |
| href="/docs/transformers/pr_34652/en/main_classes/output#transformers.modeling_outputs.TokenClassifierOutput" | |
| >transformers.modeling_outputs.TokenClassifierOutput</a> or <code>tuple(torch.FloatTensor)</code></p> | |
| `}}),ce=new ut({props:{$$slots:{default:[ln]},$$scope:{ctx:$}}}),Ze=new qt({props:{anchor:"transformers.LayoutLMv3ForTokenClassification.forward.example",$$slots:{default:[dn]},$$scope:{ctx:$}}}),qe=new Fe({props:{title:"LayoutLMv3ForQuestionAnswering",local:"transformers.LayoutLMv3ForQuestionAnswering",headingTag:"h2"}}),ae=new B({props:{name:"class transformers.LayoutLMv3ForQuestionAnswering",anchor:"transformers.LayoutLMv3ForQuestionAnswering",parameters:[{name:"config",val:""}],parametersDescription:[{anchor:"transformers.LayoutLMv3ForQuestionAnswering.config",description:`<strong>config</strong> (<a href="/docs/transformers/pr_34652/en/model_doc/layoutlmv3#transformers.LayoutLMv3Config">LayoutLMv3Config</a>) — 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/pr_34652/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/vr_34652/src/transformers/models/layoutlmv3/modeling_layoutlmv3.py#L1140"}}),Ve=new B({props:{name:"forward",anchor:"transformers.LayoutLMv3ForQuestionAnswering.forward",parameters:[{name:"input_ids",val:": typing.Optional[torch.LongTensor] = None"},{name:"attention_mask",val:": typing.Optional[torch.FloatTensor] = None"},{name:"token_type_ids",val:": typing.Optional[torch.LongTensor] = None"},{name:"position_ids",val:": typing.Optional[torch.LongTensor] = None"},{name:"head_mask",val:": typing.Optional[torch.FloatTensor] = None"},{name:"inputs_embeds",val:": typing.Optional[torch.FloatTensor] = None"},{name:"start_positions",val:": typing.Optional[torch.LongTensor] = None"},{name:"end_positions",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"},{name:"bbox",val:": typing.Optional[torch.LongTensor] = None"},{name:"pixel_values",val:": typing.Optional[torch.LongTensor] = None"}],parametersDescription:[{anchor:"transformers.LayoutLMv3ForQuestionAnswering.forward.input_ids",description:`<strong>input_ids</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size, sequence_length)</code>) — | |
| Indices of input sequence tokens in the vocabulary.</p> | |
| <p>Indices can be obtained using <a href="/docs/transformers/pr_34652/en/model_doc/auto#transformers.AutoTokenizer">AutoTokenizer</a>. See <a href="/docs/transformers/pr_34652/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode">PreTrainedTokenizer.encode()</a> and | |
| <a href="/docs/transformers/pr_34652/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.LayoutLMv3ForQuestionAnswering.forward.bbox",description:`<strong>bbox</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size, sequence_length, 4)</code>, <em>optional</em>) — | |
| Bounding boxes of each input sequence tokens. Selected in the range <code>[0, config.max_2d_position_embeddings-1]</code>. Each bounding box should be a normalized version in (x0, y0, x1, y1) | |
| format, where (x0, y0) corresponds to the position of the upper left corner in the bounding box, and (x1, | |
| y1) represents the position of the lower right corner.`,name:"bbox"},{anchor:"transformers.LayoutLMv3ForQuestionAnswering.forward.pixel_values",description:`<strong>pixel_values</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, num_channels, height, width)</code>) — | |
| Batch of document images. Each image is divided into patches of shape <code>(num_channels, config.patch_size, config.patch_size)</code> and the total number of patches (=<code>patch_sequence_length</code>) equals to <code>((height / config.patch_size) * (width / config.patch_size))</code>.`,name:"pixel_values"},{anchor:"transformers.LayoutLMv3ForQuestionAnswering.forward.attention_mask",description:`<strong>attention_mask</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length)</code>, <em>optional</em>) — | |
| 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.LayoutLMv3ForQuestionAnswering.forward.token_type_ids",description:`<strong>token_type_ids</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size, sequence_length)</code>, <em>optional</em>) — | |
| Segment token indices to indicate first and second portions of the inputs. Indices are selected in <code>[0, 1]</code>:</p> | |
| <ul> | |
| <li>0 corresponds to a <em>sentence A</em> token,</li> | |
| <li>1 corresponds to a <em>sentence B</em> token.</li> | |
| </ul> | |
| <p><a href="../glossary#token-type-ids">What are token type IDs?</a>`,name:"token_type_ids"},{anchor:"transformers.LayoutLMv3ForQuestionAnswering.forward.position_ids",description:`<strong>position_ids</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size, sequence_length)</code>, <em>optional</em>) — | |
| Indices of positions of each input sequence tokens in the position embeddings. Selected in the range <code>[0, config.max_position_embeddings - 1]</code>.</p> | |
| <p><a href="../glossary#position-ids">What are position IDs?</a>`,name:"position_ids"},{anchor:"transformers.LayoutLMv3ForQuestionAnswering.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>) — | |
| 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.LayoutLMv3ForQuestionAnswering.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>) — | |
| 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 <em>input_ids</em> indices into associated vectors than the | |
| model’s internal embedding lookup matrix.`,name:"inputs_embeds"},{anchor:"transformers.LayoutLMv3ForQuestionAnswering.forward.output_attentions",description:`<strong>output_attentions</strong> (<code>bool</code>, <em>optional</em>) — | |
| 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.LayoutLMv3ForQuestionAnswering.forward.output_hidden_states",description:`<strong>output_hidden_states</strong> (<code>bool</code>, <em>optional</em>) — | |
| 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.LayoutLMv3ForQuestionAnswering.forward.return_dict",description:`<strong>return_dict</strong> (<code>bool</code>, <em>optional</em>) — | |
| Whether or not to return a <a href="/docs/transformers/pr_34652/en/main_classes/output#transformers.utils.ModelOutput">ModelOutput</a> instead of a plain tuple.`,name:"return_dict"},{anchor:"transformers.LayoutLMv3ForQuestionAnswering.forward.start_positions",description:`<strong>start_positions</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size,)</code>, <em>optional</em>) — | |
| 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.LayoutLMv3ForQuestionAnswering.forward.end_positions",description:`<strong>end_positions</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size,)</code>, <em>optional</em>) — | |
| 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/vr_34652/src/transformers/models/layoutlmv3/modeling_layoutlmv3.py#L1158",returnDescription:`<script context="module">export const metadata = 'undefined';<\/script> | |
| <p>A <a | |
| href="/docs/transformers/pr_34652/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/pr_34652/en/model_doc/layoutlmv3#transformers.LayoutLMv3Config" | |
| >LayoutLMv3Config</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) — 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>) — 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>) — 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>) — 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>) — 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:`<script context="module">export const metadata = 'undefined';<\/script> | |
| <p><a | |
| href="/docs/transformers/pr_34652/en/main_classes/output#transformers.modeling_outputs.QuestionAnsweringModelOutput" | |
| >transformers.modeling_outputs.QuestionAnsweringModelOutput</a> or <code>tuple(torch.FloatTensor)</code></p> | |
| `}}),J=new ut({props:{$$slots:{default:[cn]},$$scope:{ctx:$}}}),Ge=new qt({props:{anchor:"transformers.LayoutLMv3ForQuestionAnswering.forward.example",$$slots:{default:[pn]},$$scope:{ctx:$}}}),{c(){y(t.$$.fragment),g=a(),n=c("div"),y(i.$$.fragment),w=a(),s=c("p"),s.innerHTML=k,Q=a(),z=c("div"),y(C.$$.fragment),Y=a(),j=c("p"),j.innerHTML=N,I=a(),y(m.$$.fragment),F=a(),y(le.$$.fragment),je=a(),y(De.$$.fragment),be=a(),E=c("div"),y(ue.$$.fragment),rt=a(),K=c("p"),K.innerHTML=Mt,G=a(),ee=c("p"),ee.innerHTML=yt,Te=a(),Me=c("div"),y(Ne.$$.fragment),Le=a(),Oe=c("p"),Oe.innerHTML=Ke,it=a(),y(Je.$$.fragment),Ie=a(),y(te.$$.fragment),Ue=a(),y(O.$$.fragment),ze=a(),V=c("div"),y(he.$$.fragment),et=a(),lt=c("p"),lt.innerHTML=Re,He=a(),de=c("p"),de.innerHTML=Ee,tt=a(),oe=c("div"),y(U.$$.fragment),We=a(),ke=c("p"),ke.innerHTML=ht,vt=a(),y(ce.$$.fragment),dt=a(),y(Ze.$$.fragment),Be=a(),y(qe.$$.fragment),ft=a(),X=c("div"),y(ae.$$.fragment),re=a(),P=c("p"),P.innerHTML=ot,nt=a(),Pe=c("p"),Pe.innerHTML=Ft,st=a(),D=c("div"),y(Ve.$$.fragment),ie=a(),Se=c("p"),Se.innerHTML=we,ct=a(),y(J.$$.fragment),fe=a(),y(Ge.$$.fragment),this.h()},l(h){v(t.$$.fragment,h),g=r(h),n=p(h,"DIV",{class:!0});var q=W(n);v(i.$$.fragment,q),w=r(q),s=p(q,"P",{"data-svelte-h":!0}),f(s)!=="svelte-90gqri"&&(s.innerHTML=k),Q=r(q),z=p(q,"DIV",{class:!0});var A=W(z);v(C.$$.fragment,A),Y=r(A),j=p(A,"P",{"data-svelte-h":!0}),f(j)!=="svelte-tmnond"&&(j.innerHTML=N),I=r(A),v(m.$$.fragment,A),F=r(A),v(le.$$.fragment,A),A.forEach(o),q.forEach(o),je=r(h),v(De.$$.fragment,h),be=r(h),E=p(h,"DIV",{class:!0});var Ce=W(E);v(ue.$$.fragment,Ce),rt=r(Ce),K=p(Ce,"P",{"data-svelte-h":!0}),f(K)!=="svelte-oc0y77"&&(K.innerHTML=Mt),G=r(Ce),ee=p(Ce,"P",{"data-svelte-h":!0}),f(ee)!=="svelte-68lg8f"&&(ee.innerHTML=yt),Te=r(Ce),Me=p(Ce,"DIV",{class:!0});var me=W(Me);v(Ne.$$.fragment,me),Le=r(me),Oe=p(me,"P",{"data-svelte-h":!0}),f(Oe)!=="svelte-7mkbwd"&&(Oe.innerHTML=Ke),it=r(me),v(Je.$$.fragment,me),Ie=r(me),v(te.$$.fragment,me),me.forEach(o),Ce.forEach(o),Ue=r(h),v(O.$$.fragment,h),ze=r(h),V=p(h,"DIV",{class:!0});var H=W(V);v(he.$$.fragment,H),et=r(H),lt=p(H,"P",{"data-svelte-h":!0}),f(lt)!=="svelte-16ux587"&&(lt.innerHTML=Re),He=r(H),de=p(H,"P",{"data-svelte-h":!0}),f(de)!=="svelte-68lg8f"&&(de.innerHTML=Ee),tt=r(H),oe=p(H,"DIV",{class:!0});var ge=W(oe);v(U.$$.fragment,ge),We=r(ge),ke=p(ge,"P",{"data-svelte-h":!0}),f(ke)!=="svelte-1p8bs75"&&(ke.innerHTML=ht),vt=r(ge),v(ce.$$.fragment,ge),dt=r(ge),v(Ze.$$.fragment,ge),ge.forEach(o),H.forEach(o),Be=r(h),v(qe.$$.fragment,h),ft=r(h),X=p(h,"DIV",{class:!0});var S=W(X);v(ae.$$.fragment,S),re=r(S),P=p(S,"P",{"data-svelte-h":!0}),f(P)!=="svelte-1p4p08z"&&(P.innerHTML=ot),nt=r(S),Pe=p(S,"P",{"data-svelte-h":!0}),f(Pe)!=="svelte-68lg8f"&&(Pe.innerHTML=Ft),st=r(S),D=p(S,"DIV",{class:!0});var Z=W(D);v(Ve.$$.fragment,Z),ie=r(Z),Se=p(Z,"P",{"data-svelte-h":!0}),f(Se)!=="svelte-fs677z"&&(Se.innerHTML=we),ct=r(Z),v(J.$$.fragment,Z),fe=r(Z),v(Ge.$$.fragment,Z),Z.forEach(o),S.forEach(o),this.h()},h(){R(z,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),R(n,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),R(Me,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),R(E,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),R(oe,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),R(V,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),R(D,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),R(X,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8")},m(h,q){b(t,h,q),l(h,g,q),l(h,n,q),b(i,n,null),d(n,w),d(n,s),d(n,Q),d(n,z),b(C,z,null),d(z,Y),d(z,j),d(z,I),b(m,z,null),d(z,F),b(le,z,null),l(h,je,q),b(De,h,q),l(h,be,q),l(h,E,q),b(ue,E,null),d(E,rt),d(E,K),d(E,G),d(E,ee),d(E,Te),d(E,Me),b(Ne,Me,null),d(Me,Le),d(Me,Oe),d(Me,it),b(Je,Me,null),d(Me,Ie),b(te,Me,null),l(h,Ue,q),b(O,h,q),l(h,ze,q),l(h,V,q),b(he,V,null),d(V,et),d(V,lt),d(V,He),d(V,de),d(V,tt),d(V,oe),b(U,oe,null),d(oe,We),d(oe,ke),d(oe,vt),b(ce,oe,null),d(oe,dt),b(Ze,oe,null),l(h,Be,q),b(qe,h,q),l(h,ft,q),l(h,X,q),b(ae,X,null),d(X,re),d(X,P),d(X,nt),d(X,Pe),d(X,st),d(X,D),b(Ve,D,null),d(D,ie),d(D,Se),d(D,ct),b(J,D,null),d(D,fe),b(Ge,D,null),pe=!0},p(h,q){const A={};q&2&&(A.$$scope={dirty:q,ctx:h}),m.$set(A);const Ce={};q&2&&(Ce.$$scope={dirty:q,ctx:h}),le.$set(Ce);const me={};q&2&&(me.$$scope={dirty:q,ctx:h}),Je.$set(me);const H={};q&2&&(H.$$scope={dirty:q,ctx:h}),te.$set(H);const ge={};q&2&&(ge.$$scope={dirty:q,ctx:h}),ce.$set(ge);const S={};q&2&&(S.$$scope={dirty:q,ctx:h}),Ze.$set(S);const Z={};q&2&&(Z.$$scope={dirty:q,ctx:h}),J.$set(Z);const Lt={};q&2&&(Lt.$$scope={dirty:q,ctx:h}),Ge.$set(Lt)},i(h){pe||(T(t.$$.fragment,h),T(i.$$.fragment,h),T(C.$$.fragment,h),T(m.$$.fragment,h),T(le.$$.fragment,h),T(De.$$.fragment,h),T(ue.$$.fragment,h),T(Ne.$$.fragment,h),T(Je.$$.fragment,h),T(te.$$.fragment,h),T(O.$$.fragment,h),T(he.$$.fragment,h),T(U.$$.fragment,h),T(ce.$$.fragment,h),T(Ze.$$.fragment,h),T(qe.$$.fragment,h),T(ae.$$.fragment,h),T(Ve.$$.fragment,h),T(J.$$.fragment,h),T(Ge.$$.fragment,h),pe=!0)},o(h){M(t.$$.fragment,h),M(i.$$.fragment,h),M(C.$$.fragment,h),M(m.$$.fragment,h),M(le.$$.fragment,h),M(De.$$.fragment,h),M(ue.$$.fragment,h),M(Ne.$$.fragment,h),M(Je.$$.fragment,h),M(te.$$.fragment,h),M(O.$$.fragment,h),M(he.$$.fragment,h),M(U.$$.fragment,h),M(ce.$$.fragment,h),M(Ze.$$.fragment,h),M(qe.$$.fragment,h),M(ae.$$.fragment,h),M(Ve.$$.fragment,h),M(J.$$.fragment,h),M(Ge.$$.fragment,h),pe=!1},d(h){h&&(o(g),o(n),o(je),o(be),o(E),o(Ue),o(ze),o(V),o(Be),o(ft),o(X)),L(t,h),L(i),L(C),L(m),L(le),L(De,h),L(ue),L(Ne),L(Je),L(te),L(O,h),L(he),L(U),L(ce),L(Ze),L(qe,h),L(ae),L(Ve),L(J),L(Ge)}}}function un($){let t,g;return t=new Vo({props:{$$slots:{default:[mn]},$$scope:{ctx:$}}}),{c(){y(t.$$.fragment)},l(n){v(t.$$.fragment,n)},m(n,i){b(t,n,i),g=!0},p(n,i){const w={};i&2&&(w.$$scope={dirty:i,ctx:n}),t.$set(w)},i(n){g||(T(t.$$.fragment,n),g=!0)},o(n){M(t.$$.fragment,n),g=!1},d(n){L(t,n)}}}function hn($){let t,g="TensorFlow models and layers in <code>transformers</code> accept two formats as input:",n,i,w="<li>having all inputs as keyword arguments (like PyTorch models), or</li> <li>having all inputs as a list, tuple or dict in the first positional argument.</li>",s,k,Q=`The reason the second format is supported is that Keras methods prefer this format when passing inputs to models | |
| and layers. Because of this support, when using methods like <code>model.fit()</code> things should “just work” for you - just | |
| pass your inputs and labels in any format that <code>model.fit()</code> supports! If, however, you want to use the second | |
| format outside of Keras methods like <code>fit()</code> and <code>predict()</code>, such as when creating your own layers or models with | |
| the Keras <code>Functional</code> API, there are three possibilities you can use to gather all the input Tensors in the first | |
| positional argument:`,z,C,Y=`<li>a single Tensor with <code>input_ids</code> only and nothing else: <code>model(input_ids)</code></li> <li>a list of varying length with one or several input Tensors IN THE ORDER given in the docstring: | |
| <code>model([input_ids, attention_mask])</code> or <code>model([input_ids, attention_mask, token_type_ids])</code></li> <li>a dictionary with one or several input Tensors associated to the input names given in the docstring: | |
| <code>model({"input_ids": input_ids, "token_type_ids": token_type_ids})</code></li>`,j,N,I=`Note that when creating models and layers with | |
| <a href="https://keras.io/guides/making_new_layers_and_models_via_subclassing/" rel="nofollow">subclassing</a> then you don’t need to worry | |
| about any of this, as you can just pass inputs like you would to any other Python function!`;return{c(){t=c("p"),t.innerHTML=g,n=a(),i=c("ul"),i.innerHTML=w,s=a(),k=c("p"),k.innerHTML=Q,z=a(),C=c("ul"),C.innerHTML=Y,j=a(),N=c("p"),N.innerHTML=I},l(m){t=p(m,"P",{"data-svelte-h":!0}),f(t)!=="svelte-1ajbfxg"&&(t.innerHTML=g),n=r(m),i=p(m,"UL",{"data-svelte-h":!0}),f(i)!=="svelte-qm1t26"&&(i.innerHTML=w),s=r(m),k=p(m,"P",{"data-svelte-h":!0}),f(k)!=="svelte-1v9qsc5"&&(k.innerHTML=Q),z=r(m),C=p(m,"UL",{"data-svelte-h":!0}),f(C)!=="svelte-15scerc"&&(C.innerHTML=Y),j=r(m),N=p(m,"P",{"data-svelte-h":!0}),f(N)!=="svelte-1an3odd"&&(N.innerHTML=I)},m(m,F){l(m,t,F),l(m,n,F),l(m,i,F),l(m,s,F),l(m,k,F),l(m,z,F),l(m,C,F),l(m,j,F),l(m,N,F)},p:se,d(m){m&&(o(t),o(n),o(i),o(s),o(k),o(z),o(C),o(j),o(N))}}}function fn($){let t,g=`Although the recipe for forward pass needs to be defined within this function, one should call the <code>Module</code> | |
| instance afterwards instead of this since the former takes care of running the pre and post processing steps while | |
| the latter silently ignores them.`;return{c(){t=c("p"),t.innerHTML=g},l(n){t=p(n,"P",{"data-svelte-h":!0}),f(t)!=="svelte-fincs2"&&(t.innerHTML=g)},m(n,i){l(n,t,i)},p:se,d(n){n&&o(t)}}}function gn($){let t,g="Examples:",n,i,w;return i=new Ct({props:{code:"ZnJvbSUyMHRyYW5zZm9ybWVycyUyMGltcG9ydCUyMEF1dG9Qcm9jZXNzb3IlMkMlMjBURkF1dG9Nb2RlbCUwQWZyb20lMjBkYXRhc2V0cyUyMGltcG9ydCUyMGxvYWRfZGF0YXNldCUwQSUwQXByb2Nlc3NvciUyMCUzRCUyMEF1dG9Qcm9jZXNzb3IuZnJvbV9wcmV0cmFpbmVkKCUyMm1pY3Jvc29mdCUyRmxheW91dGxtdjMtYmFzZSUyMiUyQyUyMGFwcGx5X29jciUzREZhbHNlKSUwQW1vZGVsJTIwJTNEJTIwVEZBdXRvTW9kZWwuZnJvbV9wcmV0cmFpbmVkKCUyMm1pY3Jvc29mdCUyRmxheW91dGxtdjMtYmFzZSUyMiklMEElMEFkYXRhc2V0JTIwJTNEJTIwbG9hZF9kYXRhc2V0KCUyMm5pZWxzciUyRmZ1bnNkLWxheW91dGxtdjMlMjIlMkMlMjBzcGxpdCUzRCUyMnRyYWluJTIyJTJDJTIwdHJ1c3RfcmVtb3RlX2NvZGUlM0RUcnVlKSUwQWV4YW1wbGUlMjAlM0QlMjBkYXRhc2V0JTVCMCU1RCUwQWltYWdlJTIwJTNEJTIwZXhhbXBsZSU1QiUyMmltYWdlJTIyJTVEJTBBd29yZHMlMjAlM0QlMjBleGFtcGxlJTVCJTIydG9rZW5zJTIyJTVEJTBBYm94ZXMlMjAlM0QlMjBleGFtcGxlJTVCJTIyYmJveGVzJTIyJTVEJTBBJTBBZW5jb2RpbmclMjAlM0QlMjBwcm9jZXNzb3IoaW1hZ2UlMkMlMjB3b3JkcyUyQyUyMGJveGVzJTNEYm94ZXMlMkMlMjByZXR1cm5fdGVuc29ycyUzRCUyMnRmJTIyKSUwQSUwQW91dHB1dHMlMjAlM0QlMjBtb2RlbCgqKmVuY29kaW5nKSUwQWxhc3RfaGlkZGVuX3N0YXRlcyUyMCUzRCUyMG91dHB1dHMubGFzdF9oaWRkZW5fc3RhdGU=",highlighted:`<span class="hljs-meta">>>> </span><span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> AutoProcessor, TFAutoModel | |
| <span class="hljs-meta">>>> </span><span class="hljs-keyword">from</span> datasets <span class="hljs-keyword">import</span> load_dataset | |
| <span class="hljs-meta">>>> </span>processor = AutoProcessor.from_pretrained(<span class="hljs-string">"microsoft/layoutlmv3-base"</span>, apply_ocr=<span class="hljs-literal">False</span>) | |
| <span class="hljs-meta">>>> </span>model = TFAutoModel.from_pretrained(<span class="hljs-string">"microsoft/layoutlmv3-base"</span>) | |
| <span class="hljs-meta">>>> </span>dataset = load_dataset(<span class="hljs-string">"nielsr/funsd-layoutlmv3"</span>, split=<span class="hljs-string">"train"</span>, trust_remote_code=<span class="hljs-literal">True</span>) | |
| <span class="hljs-meta">>>> </span>example = dataset[<span class="hljs-number">0</span>] | |
| <span class="hljs-meta">>>> </span>image = example[<span class="hljs-string">"image"</span>] | |
| <span class="hljs-meta">>>> </span>words = example[<span class="hljs-string">"tokens"</span>] | |
| <span class="hljs-meta">>>> </span>boxes = example[<span class="hljs-string">"bboxes"</span>] | |
| <span class="hljs-meta">>>> </span>encoding = processor(image, words, boxes=boxes, return_tensors=<span class="hljs-string">"tf"</span>) | |
| <span class="hljs-meta">>>> </span>outputs = model(**encoding) | |
| <span class="hljs-meta">>>> </span>last_hidden_states = outputs.last_hidden_state`,wrap:!1}}),{c(){t=c("p"),t.textContent=g,n=a(),y(i.$$.fragment)},l(s){t=p(s,"P",{"data-svelte-h":!0}),f(t)!=="svelte-kvfsh7"&&(t.textContent=g),n=r(s),v(i.$$.fragment,s)},m(s,k){l(s,t,k),l(s,n,k),b(i,s,k),w=!0},p:se,i(s){w||(T(i.$$.fragment,s),w=!0)},o(s){M(i.$$.fragment,s),w=!1},d(s){s&&(o(t),o(n)),L(i,s)}}}function _n($){let t,g="TensorFlow models and layers in <code>transformers</code> accept two formats as input:",n,i,w="<li>having all inputs as keyword arguments (like PyTorch models), or</li> <li>having all inputs as a list, tuple or dict in the first positional argument.</li>",s,k,Q=`The reason the second format is supported is that Keras methods prefer this format when passing inputs to models | |
| and layers. Because of this support, when using methods like <code>model.fit()</code> things should “just work” for you - just | |
| pass your inputs and labels in any format that <code>model.fit()</code> supports! If, however, you want to use the second | |
| format outside of Keras methods like <code>fit()</code> and <code>predict()</code>, such as when creating your own layers or models with | |
| the Keras <code>Functional</code> API, there are three possibilities you can use to gather all the input Tensors in the first | |
| positional argument:`,z,C,Y=`<li>a single Tensor with <code>input_ids</code> only and nothing else: <code>model(input_ids)</code></li> <li>a list of varying length with one or several input Tensors IN THE ORDER given in the docstring: | |
| <code>model([input_ids, attention_mask])</code> or <code>model([input_ids, attention_mask, token_type_ids])</code></li> <li>a dictionary with one or several input Tensors associated to the input names given in the docstring: | |
| <code>model({"input_ids": input_ids, "token_type_ids": token_type_ids})</code></li>`,j,N,I=`Note that when creating models and layers with | |
| <a href="https://keras.io/guides/making_new_layers_and_models_via_subclassing/" rel="nofollow">subclassing</a> then you don’t need to worry | |
| about any of this, as you can just pass inputs like you would to any other Python function!`;return{c(){t=c("p"),t.innerHTML=g,n=a(),i=c("ul"),i.innerHTML=w,s=a(),k=c("p"),k.innerHTML=Q,z=a(),C=c("ul"),C.innerHTML=Y,j=a(),N=c("p"),N.innerHTML=I},l(m){t=p(m,"P",{"data-svelte-h":!0}),f(t)!=="svelte-1ajbfxg"&&(t.innerHTML=g),n=r(m),i=p(m,"UL",{"data-svelte-h":!0}),f(i)!=="svelte-qm1t26"&&(i.innerHTML=w),s=r(m),k=p(m,"P",{"data-svelte-h":!0}),f(k)!=="svelte-1v9qsc5"&&(k.innerHTML=Q),z=r(m),C=p(m,"UL",{"data-svelte-h":!0}),f(C)!=="svelte-15scerc"&&(C.innerHTML=Y),j=r(m),N=p(m,"P",{"data-svelte-h":!0}),f(N)!=="svelte-1an3odd"&&(N.innerHTML=I)},m(m,F){l(m,t,F),l(m,n,F),l(m,i,F),l(m,s,F),l(m,k,F),l(m,z,F),l(m,C,F),l(m,j,F),l(m,N,F)},p:se,d(m){m&&(o(t),o(n),o(i),o(s),o(k),o(z),o(C),o(j),o(N))}}}function yn($){let t,g=`Although the recipe for forward pass needs to be defined within this function, one should call the <code>Module</code> | |
| instance afterwards instead of this since the former takes care of running the pre and post processing steps while | |
| the latter silently ignores them.`;return{c(){t=c("p"),t.innerHTML=g},l(n){t=p(n,"P",{"data-svelte-h":!0}),f(t)!=="svelte-fincs2"&&(t.innerHTML=g)},m(n,i){l(n,t,i)},p:se,d(n){n&&o(t)}}}function vn($){let t,g="Examples:",n,i,w;return i=new Ct({props:{code:"ZnJvbSUyMHRyYW5zZm9ybWVycyUyMGltcG9ydCUyMEF1dG9Qcm9jZXNzb3IlMkMlMjBURkF1dG9Nb2RlbEZvclNlcXVlbmNlQ2xhc3NpZmljYXRpb24lMEFmcm9tJTIwZGF0YXNldHMlMjBpbXBvcnQlMjBsb2FkX2RhdGFzZXQlMEFpbXBvcnQlMjB0ZW5zb3JmbG93JTIwYXMlMjB0ZiUwQSUwQXByb2Nlc3NvciUyMCUzRCUyMEF1dG9Qcm9jZXNzb3IuZnJvbV9wcmV0cmFpbmVkKCUyMm1pY3Jvc29mdCUyRmxheW91dGxtdjMtYmFzZSUyMiUyQyUyMGFwcGx5X29jciUzREZhbHNlKSUwQW1vZGVsJTIwJTNEJTIwVEZBdXRvTW9kZWxGb3JTZXF1ZW5jZUNsYXNzaWZpY2F0aW9uLmZyb21fcHJldHJhaW5lZCglMjJtaWNyb3NvZnQlMkZsYXlvdXRsbXYzLWJhc2UlMjIpJTBBJTBBZGF0YXNldCUyMCUzRCUyMGxvYWRfZGF0YXNldCglMjJuaWVsc3IlMkZmdW5zZC1sYXlvdXRsbXYzJTIyJTJDJTIwc3BsaXQlM0QlMjJ0cmFpbiUyMiUyQyUyMHRydXN0X3JlbW90ZV9jb2RlJTNEVHJ1ZSklMEFleGFtcGxlJTIwJTNEJTIwZGF0YXNldCU1QjAlNUQlMEFpbWFnZSUyMCUzRCUyMGV4YW1wbGUlNUIlMjJpbWFnZSUyMiU1RCUwQXdvcmRzJTIwJTNEJTIwZXhhbXBsZSU1QiUyMnRva2VucyUyMiU1RCUwQWJveGVzJTIwJTNEJTIwZXhhbXBsZSU1QiUyMmJib3hlcyUyMiU1RCUwQSUwQWVuY29kaW5nJTIwJTNEJTIwcHJvY2Vzc29yKGltYWdlJTJDJTIwd29yZHMlMkMlMjBib3hlcyUzRGJveGVzJTJDJTIwcmV0dXJuX3RlbnNvcnMlM0QlMjJ0ZiUyMiklMEFzZXF1ZW5jZV9sYWJlbCUyMCUzRCUyMHRmLmNvbnZlcnRfdG9fdGVuc29yKCU1QjElNUQpJTBBJTBBb3V0cHV0cyUyMCUzRCUyMG1vZGVsKCoqZW5jb2RpbmclMkMlMjBsYWJlbHMlM0RzZXF1ZW5jZV9sYWJlbCklMEFsb3NzJTIwJTNEJTIwb3V0cHV0cy5sb3NzJTBBbG9naXRzJTIwJTNEJTIwb3V0cHV0cy5sb2dpdHM=",highlighted:`<span class="hljs-meta">>>> </span><span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> AutoProcessor, TFAutoModelForSequenceClassification | |
| <span class="hljs-meta">>>> </span><span class="hljs-keyword">from</span> datasets <span class="hljs-keyword">import</span> load_dataset | |
| <span class="hljs-meta">>>> </span><span class="hljs-keyword">import</span> tensorflow <span class="hljs-keyword">as</span> tf | |
| <span class="hljs-meta">>>> </span>processor = AutoProcessor.from_pretrained(<span class="hljs-string">"microsoft/layoutlmv3-base"</span>, apply_ocr=<span class="hljs-literal">False</span>) | |
| <span class="hljs-meta">>>> </span>model = TFAutoModelForSequenceClassification.from_pretrained(<span class="hljs-string">"microsoft/layoutlmv3-base"</span>) | |
| <span class="hljs-meta">>>> </span>dataset = load_dataset(<span class="hljs-string">"nielsr/funsd-layoutlmv3"</span>, split=<span class="hljs-string">"train"</span>, trust_remote_code=<span class="hljs-literal">True</span>) | |
| <span class="hljs-meta">>>> </span>example = dataset[<span class="hljs-number">0</span>] | |
| <span class="hljs-meta">>>> </span>image = example[<span class="hljs-string">"image"</span>] | |
| <span class="hljs-meta">>>> </span>words = example[<span class="hljs-string">"tokens"</span>] | |
| <span class="hljs-meta">>>> </span>boxes = example[<span class="hljs-string">"bboxes"</span>] | |
| <span class="hljs-meta">>>> </span>encoding = processor(image, words, boxes=boxes, return_tensors=<span class="hljs-string">"tf"</span>) | |
| <span class="hljs-meta">>>> </span>sequence_label = tf.convert_to_tensor([<span class="hljs-number">1</span>]) | |
| <span class="hljs-meta">>>> </span>outputs = model(**encoding, labels=sequence_label) | |
| <span class="hljs-meta">>>> </span>loss = outputs.loss | |
| <span class="hljs-meta">>>> </span>logits = outputs.logits`,wrap:!1}}),{c(){t=c("p"),t.textContent=g,n=a(),y(i.$$.fragment)},l(s){t=p(s,"P",{"data-svelte-h":!0}),f(t)!=="svelte-kvfsh7"&&(t.textContent=g),n=r(s),v(i.$$.fragment,s)},m(s,k){l(s,t,k),l(s,n,k),b(i,s,k),w=!0},p:se,i(s){w||(T(i.$$.fragment,s),w=!0)},o(s){M(i.$$.fragment,s),w=!1},d(s){s&&(o(t),o(n)),L(i,s)}}}function bn($){let t,g="TensorFlow models and layers in <code>transformers</code> accept two formats as input:",n,i,w="<li>having all inputs as keyword arguments (like PyTorch models), or</li> <li>having all inputs as a list, tuple or dict in the first positional argument.</li>",s,k,Q=`The reason the second format is supported is that Keras methods prefer this format when passing inputs to models | |
| and layers. Because of this support, when using methods like <code>model.fit()</code> things should “just work” for you - just | |
| pass your inputs and labels in any format that <code>model.fit()</code> supports! If, however, you want to use the second | |
| format outside of Keras methods like <code>fit()</code> and <code>predict()</code>, such as when creating your own layers or models with | |
| the Keras <code>Functional</code> API, there are three possibilities you can use to gather all the input Tensors in the first | |
| positional argument:`,z,C,Y=`<li>a single Tensor with <code>input_ids</code> only and nothing else: <code>model(input_ids)</code></li> <li>a list of varying length with one or several input Tensors IN THE ORDER given in the docstring: | |
| <code>model([input_ids, attention_mask])</code> or <code>model([input_ids, attention_mask, token_type_ids])</code></li> <li>a dictionary with one or several input Tensors associated to the input names given in the docstring: | |
| <code>model({"input_ids": input_ids, "token_type_ids": token_type_ids})</code></li>`,j,N,I=`Note that when creating models and layers with | |
| <a href="https://keras.io/guides/making_new_layers_and_models_via_subclassing/" rel="nofollow">subclassing</a> then you don’t need to worry | |
| about any of this, as you can just pass inputs like you would to any other Python function!`;return{c(){t=c("p"),t.innerHTML=g,n=a(),i=c("ul"),i.innerHTML=w,s=a(),k=c("p"),k.innerHTML=Q,z=a(),C=c("ul"),C.innerHTML=Y,j=a(),N=c("p"),N.innerHTML=I},l(m){t=p(m,"P",{"data-svelte-h":!0}),f(t)!=="svelte-1ajbfxg"&&(t.innerHTML=g),n=r(m),i=p(m,"UL",{"data-svelte-h":!0}),f(i)!=="svelte-qm1t26"&&(i.innerHTML=w),s=r(m),k=p(m,"P",{"data-svelte-h":!0}),f(k)!=="svelte-1v9qsc5"&&(k.innerHTML=Q),z=r(m),C=p(m,"UL",{"data-svelte-h":!0}),f(C)!=="svelte-15scerc"&&(C.innerHTML=Y),j=r(m),N=p(m,"P",{"data-svelte-h":!0}),f(N)!=="svelte-1an3odd"&&(N.innerHTML=I)},m(m,F){l(m,t,F),l(m,n,F),l(m,i,F),l(m,s,F),l(m,k,F),l(m,z,F),l(m,C,F),l(m,j,F),l(m,N,F)},p:se,d(m){m&&(o(t),o(n),o(i),o(s),o(k),o(z),o(C),o(j),o(N))}}}function Tn($){let t,g=`Although the recipe for forward pass needs to be defined within this function, one should call the <code>Module</code> | |
| instance afterwards instead of this since the former takes care of running the pre and post processing steps while | |
| the latter silently ignores them.`;return{c(){t=c("p"),t.innerHTML=g},l(n){t=p(n,"P",{"data-svelte-h":!0}),f(t)!=="svelte-fincs2"&&(t.innerHTML=g)},m(n,i){l(n,t,i)},p:se,d(n){n&&o(t)}}}function Mn($){let t,g="Examples:",n,i,w;return i=new Ct({props:{code:"ZnJvbSUyMHRyYW5zZm9ybWVycyUyMGltcG9ydCUyMEF1dG9Qcm9jZXNzb3IlMkMlMjBURkF1dG9Nb2RlbEZvclRva2VuQ2xhc3NpZmljYXRpb24lMEFmcm9tJTIwZGF0YXNldHMlMjBpbXBvcnQlMjBsb2FkX2RhdGFzZXQlMEElMEFwcm9jZXNzb3IlMjAlM0QlMjBBdXRvUHJvY2Vzc29yLmZyb21fcHJldHJhaW5lZCglMjJtaWNyb3NvZnQlMkZsYXlvdXRsbXYzLWJhc2UlMjIlMkMlMjBhcHBseV9vY3IlM0RGYWxzZSklMEFtb2RlbCUyMCUzRCUyMFRGQXV0b01vZGVsRm9yVG9rZW5DbGFzc2lmaWNhdGlvbi5mcm9tX3ByZXRyYWluZWQoJTIybWljcm9zb2Z0JTJGbGF5b3V0bG12My1iYXNlJTIyJTJDJTIwbnVtX2xhYmVscyUzRDcpJTBBJTBBZGF0YXNldCUyMCUzRCUyMGxvYWRfZGF0YXNldCglMjJuaWVsc3IlMkZmdW5zZC1sYXlvdXRsbXYzJTIyJTJDJTIwc3BsaXQlM0QlMjJ0cmFpbiUyMiUyQyUyMHRydXN0X3JlbW90ZV9jb2RlJTNEVHJ1ZSklMEFleGFtcGxlJTIwJTNEJTIwZGF0YXNldCU1QjAlNUQlMEFpbWFnZSUyMCUzRCUyMGV4YW1wbGUlNUIlMjJpbWFnZSUyMiU1RCUwQXdvcmRzJTIwJTNEJTIwZXhhbXBsZSU1QiUyMnRva2VucyUyMiU1RCUwQWJveGVzJTIwJTNEJTIwZXhhbXBsZSU1QiUyMmJib3hlcyUyMiU1RCUwQXdvcmRfbGFiZWxzJTIwJTNEJTIwZXhhbXBsZSU1QiUyMm5lcl90YWdzJTIyJTVEJTBBJTBBZW5jb2RpbmclMjAlM0QlMjBwcm9jZXNzb3IoaW1hZ2UlMkMlMjB3b3JkcyUyQyUyMGJveGVzJTNEYm94ZXMlMkMlMjB3b3JkX2xhYmVscyUzRHdvcmRfbGFiZWxzJTJDJTIwcmV0dXJuX3RlbnNvcnMlM0QlMjJ0ZiUyMiklMEElMEFvdXRwdXRzJTIwJTNEJTIwbW9kZWwoKiplbmNvZGluZyklMEFsb3NzJTIwJTNEJTIwb3V0cHV0cy5sb3NzJTBBbG9naXRzJTIwJTNEJTIwb3V0cHV0cy5sb2dpdHM=",highlighted:`<span class="hljs-meta">>>> </span><span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> AutoProcessor, TFAutoModelForTokenClassification | |
| <span class="hljs-meta">>>> </span><span class="hljs-keyword">from</span> datasets <span class="hljs-keyword">import</span> load_dataset | |
| <span class="hljs-meta">>>> </span>processor = AutoProcessor.from_pretrained(<span class="hljs-string">"microsoft/layoutlmv3-base"</span>, apply_ocr=<span class="hljs-literal">False</span>) | |
| <span class="hljs-meta">>>> </span>model = TFAutoModelForTokenClassification.from_pretrained(<span class="hljs-string">"microsoft/layoutlmv3-base"</span>, num_labels=<span class="hljs-number">7</span>) | |
| <span class="hljs-meta">>>> </span>dataset = load_dataset(<span class="hljs-string">"nielsr/funsd-layoutlmv3"</span>, split=<span class="hljs-string">"train"</span>, trust_remote_code=<span class="hljs-literal">True</span>) | |
| <span class="hljs-meta">>>> </span>example = dataset[<span class="hljs-number">0</span>] | |
| <span class="hljs-meta">>>> </span>image = example[<span class="hljs-string">"image"</span>] | |
| <span class="hljs-meta">>>> </span>words = example[<span class="hljs-string">"tokens"</span>] | |
| <span class="hljs-meta">>>> </span>boxes = example[<span class="hljs-string">"bboxes"</span>] | |
| <span class="hljs-meta">>>> </span>word_labels = example[<span class="hljs-string">"ner_tags"</span>] | |
| <span class="hljs-meta">>>> </span>encoding = processor(image, words, boxes=boxes, word_labels=word_labels, return_tensors=<span class="hljs-string">"tf"</span>) | |
| <span class="hljs-meta">>>> </span>outputs = model(**encoding) | |
| <span class="hljs-meta">>>> </span>loss = outputs.loss | |
| <span class="hljs-meta">>>> </span>logits = outputs.logits`,wrap:!1}}),{c(){t=c("p"),t.textContent=g,n=a(),y(i.$$.fragment)},l(s){t=p(s,"P",{"data-svelte-h":!0}),f(t)!=="svelte-kvfsh7"&&(t.textContent=g),n=r(s),v(i.$$.fragment,s)},m(s,k){l(s,t,k),l(s,n,k),b(i,s,k),w=!0},p:se,i(s){w||(T(i.$$.fragment,s),w=!0)},o(s){M(i.$$.fragment,s),w=!1},d(s){s&&(o(t),o(n)),L(i,s)}}}function Ln($){let t,g="TensorFlow models and layers in <code>transformers</code> accept two formats as input:",n,i,w="<li>having all inputs as keyword arguments (like PyTorch models), or</li> <li>having all inputs as a list, tuple or dict in the first positional argument.</li>",s,k,Q=`The reason the second format is supported is that Keras methods prefer this format when passing inputs to models | |
| and layers. Because of this support, when using methods like <code>model.fit()</code> things should “just work” for you - just | |
| pass your inputs and labels in any format that <code>model.fit()</code> supports! If, however, you want to use the second | |
| format outside of Keras methods like <code>fit()</code> and <code>predict()</code>, such as when creating your own layers or models with | |
| the Keras <code>Functional</code> API, there are three possibilities you can use to gather all the input Tensors in the first | |
| positional argument:`,z,C,Y=`<li>a single Tensor with <code>input_ids</code> only and nothing else: <code>model(input_ids)</code></li> <li>a list of varying length with one or several input Tensors IN THE ORDER given in the docstring: | |
| <code>model([input_ids, attention_mask])</code> or <code>model([input_ids, attention_mask, token_type_ids])</code></li> <li>a dictionary with one or several input Tensors associated to the input names given in the docstring: | |
| <code>model({"input_ids": input_ids, "token_type_ids": token_type_ids})</code></li>`,j,N,I=`Note that when creating models and layers with | |
| <a href="https://keras.io/guides/making_new_layers_and_models_via_subclassing/" rel="nofollow">subclassing</a> then you don’t need to worry | |
| about any of this, as you can just pass inputs like you would to any other Python function!`;return{c(){t=c("p"),t.innerHTML=g,n=a(),i=c("ul"),i.innerHTML=w,s=a(),k=c("p"),k.innerHTML=Q,z=a(),C=c("ul"),C.innerHTML=Y,j=a(),N=c("p"),N.innerHTML=I},l(m){t=p(m,"P",{"data-svelte-h":!0}),f(t)!=="svelte-1ajbfxg"&&(t.innerHTML=g),n=r(m),i=p(m,"UL",{"data-svelte-h":!0}),f(i)!=="svelte-qm1t26"&&(i.innerHTML=w),s=r(m),k=p(m,"P",{"data-svelte-h":!0}),f(k)!=="svelte-1v9qsc5"&&(k.innerHTML=Q),z=r(m),C=p(m,"UL",{"data-svelte-h":!0}),f(C)!=="svelte-15scerc"&&(C.innerHTML=Y),j=r(m),N=p(m,"P",{"data-svelte-h":!0}),f(N)!=="svelte-1an3odd"&&(N.innerHTML=I)},m(m,F){l(m,t,F),l(m,n,F),l(m,i,F),l(m,s,F),l(m,k,F),l(m,z,F),l(m,C,F),l(m,j,F),l(m,N,F)},p:se,d(m){m&&(o(t),o(n),o(i),o(s),o(k),o(z),o(C),o(j),o(N))}}}function kn($){let t,g=`Although the recipe for forward pass needs to be defined within this function, one should call the <code>Module</code> | |
| instance afterwards instead of this since the former takes care of running the pre and post processing steps while | |
| the latter silently ignores them.`;return{c(){t=c("p"),t.innerHTML=g},l(n){t=p(n,"P",{"data-svelte-h":!0}),f(t)!=="svelte-fincs2"&&(t.innerHTML=g)},m(n,i){l(n,t,i)},p:se,d(n){n&&o(t)}}}function wn($){let t,g="Examples:",n,i,w;return i=new Ct({props:{code:"ZnJvbSUyMHRyYW5zZm9ybWVycyUyMGltcG9ydCUyMEF1dG9Qcm9jZXNzb3IlMkMlMjBURkF1dG9Nb2RlbEZvclF1ZXN0aW9uQW5zd2VyaW5nJTBBZnJvbSUyMGRhdGFzZXRzJTIwaW1wb3J0JTIwbG9hZF9kYXRhc2V0JTBBaW1wb3J0JTIwdGVuc29yZmxvdyUyMGFzJTIwdGYlMEElMEFwcm9jZXNzb3IlMjAlM0QlMjBBdXRvUHJvY2Vzc29yLmZyb21fcHJldHJhaW5lZCglMjJtaWNyb3NvZnQlMkZsYXlvdXRsbXYzLWJhc2UlMjIlMkMlMjBhcHBseV9vY3IlM0RGYWxzZSklMEFtb2RlbCUyMCUzRCUyMFRGQXV0b01vZGVsRm9yUXVlc3Rpb25BbnN3ZXJpbmcuZnJvbV9wcmV0cmFpbmVkKCUyMm1pY3Jvc29mdCUyRmxheW91dGxtdjMtYmFzZSUyMiklMEElMEFkYXRhc2V0JTIwJTNEJTIwbG9hZF9kYXRhc2V0KCUyMm5pZWxzciUyRmZ1bnNkLWxheW91dGxtdjMlMjIlMkMlMjBzcGxpdCUzRCUyMnRyYWluJTIyJTJDJTIwdHJ1c3RfcmVtb3RlX2NvZGUlM0RUcnVlKSUwQWV4YW1wbGUlMjAlM0QlMjBkYXRhc2V0JTVCMCU1RCUwQWltYWdlJTIwJTNEJTIwZXhhbXBsZSU1QiUyMmltYWdlJTIyJTVEJTBBcXVlc3Rpb24lMjAlM0QlMjAlMjJ3aGF0J3MlMjBoaXMlMjBuYW1lJTNGJTIyJTBBd29yZHMlMjAlM0QlMjBleGFtcGxlJTVCJTIydG9rZW5zJTIyJTVEJTBBYm94ZXMlMjAlM0QlMjBleGFtcGxlJTVCJTIyYmJveGVzJTIyJTVEJTBBJTBBZW5jb2RpbmclMjAlM0QlMjBwcm9jZXNzb3IoaW1hZ2UlMkMlMjBxdWVzdGlvbiUyQyUyMHdvcmRzJTJDJTIwYm94ZXMlM0Rib3hlcyUyQyUyMHJldHVybl90ZW5zb3JzJTNEJTIydGYlMjIpJTBBc3RhcnRfcG9zaXRpb25zJTIwJTNEJTIwdGYuY29udmVydF90b190ZW5zb3IoJTVCMSU1RCklMEFlbmRfcG9zaXRpb25zJTIwJTNEJTIwdGYuY29udmVydF90b190ZW5zb3IoJTVCMyU1RCklMEElMEFvdXRwdXRzJTIwJTNEJTIwbW9kZWwoKiplbmNvZGluZyUyQyUyMHN0YXJ0X3Bvc2l0aW9ucyUzRHN0YXJ0X3Bvc2l0aW9ucyUyQyUyMGVuZF9wb3NpdGlvbnMlM0RlbmRfcG9zaXRpb25zKSUwQWxvc3MlMjAlM0QlMjBvdXRwdXRzLmxvc3MlMEFzdGFydF9zY29yZXMlMjAlM0QlMjBvdXRwdXRzLnN0YXJ0X2xvZ2l0cyUwQWVuZF9zY29yZXMlMjAlM0QlMjBvdXRwdXRzLmVuZF9sb2dpdHM=",highlighted:`<span class="hljs-meta">>>> </span><span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> AutoProcessor, TFAutoModelForQuestionAnswering | |
| <span class="hljs-meta">>>> </span><span class="hljs-keyword">from</span> datasets <span class="hljs-keyword">import</span> load_dataset | |
| <span class="hljs-meta">>>> </span><span class="hljs-keyword">import</span> tensorflow <span class="hljs-keyword">as</span> tf | |
| <span class="hljs-meta">>>> </span>processor = AutoProcessor.from_pretrained(<span class="hljs-string">"microsoft/layoutlmv3-base"</span>, apply_ocr=<span class="hljs-literal">False</span>) | |
| <span class="hljs-meta">>>> </span>model = TFAutoModelForQuestionAnswering.from_pretrained(<span class="hljs-string">"microsoft/layoutlmv3-base"</span>) | |
| <span class="hljs-meta">>>> </span>dataset = load_dataset(<span class="hljs-string">"nielsr/funsd-layoutlmv3"</span>, split=<span class="hljs-string">"train"</span>, trust_remote_code=<span class="hljs-literal">True</span>) | |
| <span class="hljs-meta">>>> </span>example = dataset[<span class="hljs-number">0</span>] | |
| <span class="hljs-meta">>>> </span>image = example[<span class="hljs-string">"image"</span>] | |
| <span class="hljs-meta">>>> </span>question = <span class="hljs-string">"what's his name?"</span> | |
| <span class="hljs-meta">>>> </span>words = example[<span class="hljs-string">"tokens"</span>] | |
| <span class="hljs-meta">>>> </span>boxes = example[<span class="hljs-string">"bboxes"</span>] | |
| <span class="hljs-meta">>>> </span>encoding = processor(image, question, words, boxes=boxes, return_tensors=<span class="hljs-string">"tf"</span>) | |
| <span class="hljs-meta">>>> </span>start_positions = tf.convert_to_tensor([<span class="hljs-number">1</span>]) | |
| <span class="hljs-meta">>>> </span>end_positions = tf.convert_to_tensor([<span class="hljs-number">3</span>]) | |
| <span class="hljs-meta">>>> </span>outputs = model(**encoding, start_positions=start_positions, end_positions=end_positions) | |
| <span class="hljs-meta">>>> </span>loss = outputs.loss | |
| <span class="hljs-meta">>>> </span>start_scores = outputs.start_logits | |
| <span class="hljs-meta">>>> </span>end_scores = outputs.end_logits`,wrap:!1}}),{c(){t=c("p"),t.textContent=g,n=a(),y(i.$$.fragment)},l(s){t=p(s,"P",{"data-svelte-h":!0}),f(t)!=="svelte-kvfsh7"&&(t.textContent=g),n=r(s),v(i.$$.fragment,s)},m(s,k){l(s,t,k),l(s,n,k),b(i,s,k),w=!0},p:se,i(s){w||(T(i.$$.fragment,s),w=!0)},o(s){M(i.$$.fragment,s),w=!1},d(s){s&&(o(t),o(n)),L(i,s)}}}function xn($){let t,g,n,i,w,s,k=`The bare LayoutLMv3 Model transformer outputting raw hidden-states without any specific head on top. | |
| This model inherits from <a href="/docs/transformers/pr_34652/en/main_classes/model#transformers.TFPreTrainedModel">TFPreTrainedModel</a>. Check the superclass documentation for the generic methods the | |
| library implements for all its model (such as downloading or saving, resizing the input embeddings, pruning heads | |
| etc.)`,Q,z,C=`This model is also a <a href="https://www.tensorflow.org/api_docs/python/tf/keras/Model" rel="nofollow">keras.Model</a> 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,j,N,I,m,F,le,je='The <a href="/docs/transformers/pr_34652/en/model_doc/layoutlmv3#transformers.TFLayoutLMv3Model">TFLayoutLMv3Model</a> forward method, overrides the <code>__call__</code> special method.',De,be,E,ue,rt,K,Mt,G,ee,yt,Te,Me=`LayoutLMv3 Model with a sequence classification head on top (a linear layer on top of the final hidden state of the | |
| [CLS] token) e.g. for document image classification tasks such as the | |
| <a href="https://www.cs.cmu.edu/~aharley/rvl-cdip/" rel="nofollow">RVL-CDIP</a> dataset.`,Ne,Le,Oe=`This model inherits from <a href="/docs/transformers/pr_34652/en/main_classes/model#transformers.TFPreTrainedModel">TFPreTrainedModel</a>. Check the superclass documentation for the generic methods the | |
| library implements for all its model (such as downloading or saving, resizing the input embeddings, pruning heads | |
| etc.)`,Ke,it,Je=`This model is also a <a href="https://www.tensorflow.org/api_docs/python/tf/keras/Model" rel="nofollow">keras.Model</a> 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.`,Ie,te,Ue,O,ze,V,he,et='The <a href="/docs/transformers/pr_34652/en/model_doc/layoutlmv3#transformers.TFLayoutLMv3ForSequenceClassification">TFLayoutLMv3ForSequenceClassification</a> forward method, overrides the <code>__call__</code> special method.',lt,Re,He,de,Ee,tt,oe,U,We,ke,ht,vt=`LayoutLMv3 Model with a token classification head on top (a linear layer on top of the final hidden states) e.g. | |
| for sequence labeling (information extraction) tasks such as <a href="https://guillaumejaume.github.io/FUNSD/" rel="nofollow">FUNSD</a>, | |
| <a href="https://rrc.cvc.uab.es/?ch=13" rel="nofollow">SROIE</a>, <a href="https://github.com/clovaai/cord" rel="nofollow">CORD</a> and | |
| <a href="https://github.com/applicaai/kleister-nda" rel="nofollow">Kleister-NDA</a>.`,ce,dt,Ze=`This model inherits from <a href="/docs/transformers/pr_34652/en/main_classes/model#transformers.TFPreTrainedModel">TFPreTrainedModel</a>. Check the superclass documentation for the generic methods the | |
| library implements for all its model (such as downloading or saving, resizing the input embeddings, pruning heads | |
| etc.)`,Be,qe,ft=`This model is also a <a href="https://www.tensorflow.org/api_docs/python/tf/keras/Model" rel="nofollow">keras.Model</a> 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,ae,re,P,ot,nt,Pe,Ft='The <a href="/docs/transformers/pr_34652/en/model_doc/layoutlmv3#transformers.TFLayoutLMv3ForTokenClassification">TFLayoutLMv3ForTokenClassification</a> forward method, overrides the <code>__call__</code> special method.',st,D,Ve,ie,Se,we,ct,J,fe,Ge,pe,h=`LayoutLMv3 Model with a span classification head on top for extractive question-answering tasks such as | |
| <a href="https://rrc.cvc.uab.es/?ch=17" rel="nofollow">DocVQA</a> (a linear layer on top of the text part of the hidden-states output to | |
| compute <code>span start logits</code> and <code>span end logits</code>).`,q,A,Ce=`This model inherits from <a href="/docs/transformers/pr_34652/en/main_classes/model#transformers.TFPreTrainedModel">TFPreTrainedModel</a>. Check the superclass documentation for the generic methods the | |
| library implements for all its model (such as downloading or saving, resizing the input embeddings, pruning heads | |
| etc.)`,me,H,ge=`This model is also a <a href="https://www.tensorflow.org/api_docs/python/tf/keras/Model" rel="nofollow">keras.Model</a> 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.`,S,Z,Lt,_e,kt,It,Xe,wt='The <a href="/docs/transformers/pr_34652/en/model_doc/layoutlmv3#transformers.TFLayoutLMv3ForQuestionAnswering">TFLayoutLMv3ForQuestionAnswering</a> forward method, overrides the <code>__call__</code> special method.',Ut,Ae,At,pt,gt;return t=new Fe({props:{title:"TFLayoutLMv3Model",local:"transformers.TFLayoutLMv3Model",headingTag:"h2"}}),i=new B({props:{name:"class transformers.TFLayoutLMv3Model",anchor:"transformers.TFLayoutLMv3Model",parameters:[{name:"config",val:""},{name:"*inputs",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"transformers.TFLayoutLMv3Model.config",description:`<strong>config</strong> (<a href="/docs/transformers/pr_34652/en/model_doc/layoutlmv3#transformers.LayoutLMv3Config">LayoutLMv3Config</a>) — 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/pr_34652/en/main_classes/model#transformers.TFPreTrainedModel.from_pretrained">from_pretrained()</a> method to load the model weights.`,name:"config"}],source:"https://github.com/huggingface/transformers/blob/vr_34652/src/transformers/models/layoutlmv3/modeling_tf_layoutlmv3.py#L1252"}}),j=new ut({props:{$$slots:{default:[hn]},$$scope:{ctx:$}}}),m=new B({props:{name:"call",anchor:"transformers.TFLayoutLMv3Model.call",parameters:[{name:"input_ids",val:": tf.Tensor | None = None"},{name:"bbox",val:": tf.Tensor | None = None"},{name:"attention_mask",val:": tf.Tensor | None = None"},{name:"token_type_ids",val:": tf.Tensor | None = None"},{name:"position_ids",val:": tf.Tensor | None = None"},{name:"head_mask",val:": tf.Tensor | None = None"},{name:"inputs_embeds",val:": tf.Tensor | None = None"},{name:"pixel_values",val:": tf.Tensor | None = None"},{name:"output_attentions",val:": Optional[bool] = None"},{name:"output_hidden_states",val:": Optional[bool] = None"},{name:"return_dict",val:": Optional[bool] = None"},{name:"training",val:": bool = False"}],parametersDescription:[{anchor:"transformers.TFLayoutLMv3Model.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>) — | |
| Indices of input sequence tokens in the vocabulary.</p> | |
| <p>Note that <code>sequence_length = token_sequence_length + patch_sequence_length + 1</code> where <code>1</code> is for [CLS] | |
| token. See <code>pixel_values</code> for <code>patch_sequence_length</code>.</p> | |
| <p>Indices can be obtained using <a href="/docs/transformers/pr_34652/en/model_doc/auto#transformers.AutoTokenizer">AutoTokenizer</a>. See <a href="/docs/transformers/pr_34652/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode">PreTrainedTokenizer.encode()</a> and | |
| <a href="/docs/transformers/pr_34652/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.TFLayoutLMv3Model.call.bbox",description:`<strong>bbox</strong> (<code>Numpy array</code> or <code>tf.Tensor</code> of shape <code>(batch_size, sequence_length, 4)</code>, <em>optional</em>) — | |
| Bounding boxes of each input sequence tokens. Selected in the range <code>[0, config.max_2d_position_embeddings-1]</code>. Each bounding box should be a normalized version in (x0, y0, x1, y1) | |
| format, where (x0, y0) corresponds to the position of the upper left corner in the bounding box, and (x1, | |
| y1) represents the position of the lower right corner.</p> | |
| <p>Note that <code>sequence_length = token_sequence_length + patch_sequence_length + 1</code> where <code>1</code> is for [CLS] | |
| token. See <code>pixel_values</code> for <code>patch_sequence_length</code>.`,name:"bbox"},{anchor:"transformers.TFLayoutLMv3Model.call.pixel_values",description:`<strong>pixel_values</strong> (<code>tf.Tensor</code> of shape <code>(batch_size, num_channels, height, width)</code>) — | |
| Batch of document images. Each image is divided into patches of shape <code>(num_channels, config.patch_size, config.patch_size)</code> and the total number of patches (=<code>patch_sequence_length</code>) equals to <code>((height / config.patch_size) * (width / config.patch_size))</code>.`,name:"pixel_values"},{anchor:"transformers.TFLayoutLMv3Model.call.attention_mask",description:`<strong>attention_mask</strong> (<code>tf.Tensor</code> of shape <code>(batch_size, sequence_length)</code>, <em>optional</em>) — | |
| 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>Note that <code>sequence_length = token_sequence_length + patch_sequence_length + 1</code> where <code>1</code> is for [CLS] | |
| token. See <code>pixel_values</code> for <code>patch_sequence_length</code>.</p> | |
| <p><a href="../glossary#attention-mask">What are attention masks?</a>`,name:"attention_mask"},{anchor:"transformers.TFLayoutLMv3Model.call.token_type_ids",description:`<strong>token_type_ids</strong> (<code>Numpy array</code> or <code>tf.Tensor</code> of shape <code>(batch_size, sequence_length)</code>, <em>optional</em>) — | |
| Segment token indices to indicate first and second portions of the inputs. Indices are selected in <code>[0, 1]</code>:</p> | |
| <ul> | |
| <li>0 corresponds to a <em>sentence A</em> token,</li> | |
| <li>1 corresponds to a <em>sentence B</em> token.</li> | |
| </ul> | |
| <p>Note that <code>sequence_length = token_sequence_length + patch_sequence_length + 1</code> where <code>1</code> is for [CLS] | |
| token. See <code>pixel_values</code> for <code>patch_sequence_length</code>.</p> | |
| <p><a href="../glossary#token-type-ids">What are token type IDs?</a>`,name:"token_type_ids"},{anchor:"transformers.TFLayoutLMv3Model.call.position_ids",description:`<strong>position_ids</strong> (<code>Numpy array</code> or <code>tf.Tensor</code> of shape <code>(batch_size, sequence_length)</code>, <em>optional</em>) — | |
| Indices of positions of each input sequence tokens in the position embeddings. Selected in the range <code>[0, config.max_position_embeddings - 1]</code>.</p> | |
| <p>Note that <code>sequence_length = token_sequence_length + patch_sequence_length + 1</code> where <code>1</code> is for [CLS] | |
| token. See <code>pixel_values</code> for <code>patch_sequence_length</code>.</p> | |
| <p><a href="../glossary#position-ids">What are position IDs?</a>`,name:"position_ids"},{anchor:"transformers.TFLayoutLMv3Model.call.head_mask",description:`<strong>head_mask</strong> (<code>tf.Tensor</code> of shape <code>(num_heads,)</code> or <code>(num_layers, num_heads)</code>, <em>optional</em>) — | |
| 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.TFLayoutLMv3Model.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>) — | |
| 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 <em>input_ids</em> indices into associated vectors than the | |
| model’s internal embedding lookup matrix.`,name:"inputs_embeds"},{anchor:"transformers.TFLayoutLMv3Model.call.output_attentions",description:`<strong>output_attentions</strong> (<code>bool</code>, <em>optional</em>) — | |
| 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.TFLayoutLMv3Model.call.output_hidden_states",description:`<strong>output_hidden_states</strong> (<code>bool</code>, <em>optional</em>) — | |
| 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.TFLayoutLMv3Model.call.return_dict",description:`<strong>return_dict</strong> (<code>bool</code>, <em>optional</em>) — | |
| Whether or not to return a <a href="/docs/transformers/pr_34652/en/main_classes/output#transformers.utils.ModelOutput">ModelOutput</a> instead of a plain tuple.`,name:"return_dict"}],source:"https://github.com/huggingface/transformers/blob/vr_34652/src/transformers/models/layoutlmv3/modeling_tf_layoutlmv3.py#L1264",returnDescription:`<script context="module">export const metadata = 'undefined';<\/script> | |
| <p>A <a | |
| href="/docs/transformers/pr_34652/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/pr_34652/en/model_doc/layoutlmv3#transformers.LayoutLMv3Config" | |
| >LayoutLMv3Config</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>) — 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>) — 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>) — 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:`<script context="module">export const metadata = 'undefined';<\/script> | |
| <p><a | |
| href="/docs/transformers/pr_34652/en/main_classes/output#transformers.modeling_tf_outputs.TFBaseModelOutput" | |
| >transformers.modeling_tf_outputs.TFBaseModelOutput</a> or <code>tuple(tf.Tensor)</code></p> | |
| `}}),be=new ut({props:{$$slots:{default:[fn]},$$scope:{ctx:$}}}),ue=new qt({props:{anchor:"transformers.TFLayoutLMv3Model.call.example",$$slots:{default:[gn]},$$scope:{ctx:$}}}),K=new Fe({props:{title:"TFLayoutLMv3ForSequenceClassification",local:"transformers.TFLayoutLMv3ForSequenceClassification",headingTag:"h2"}}),ee=new B({props:{name:"class transformers.TFLayoutLMv3ForSequenceClassification",anchor:"transformers.TFLayoutLMv3ForSequenceClassification",parameters:[{name:"config",val:": LayoutLMv3Config"},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"transformers.TFLayoutLMv3ForSequenceClassification.config",description:`<strong>config</strong> (<a href="/docs/transformers/pr_34652/en/model_doc/layoutlmv3#transformers.LayoutLMv3Config">LayoutLMv3Config</a>) — 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/pr_34652/en/main_classes/model#transformers.TFPreTrainedModel.from_pretrained">from_pretrained()</a> method to load the model weights.`,name:"config"}],source:"https://github.com/huggingface/transformers/blob/vr_34652/src/transformers/models/layoutlmv3/modeling_tf_layoutlmv3.py#L1386"}}),te=new ut({props:{$$slots:{default:[_n]},$$scope:{ctx:$}}}),ze=new B({props:{name:"call",anchor:"transformers.TFLayoutLMv3ForSequenceClassification.call",parameters:[{name:"input_ids",val:": tf.Tensor | None = None"},{name:"attention_mask",val:": tf.Tensor | None = None"},{name:"token_type_ids",val:": tf.Tensor | None = None"},{name:"position_ids",val:": tf.Tensor | None = None"},{name:"head_mask",val:": tf.Tensor | None = None"},{name:"inputs_embeds",val:": tf.Tensor | None = None"},{name:"labels",val:": tf.Tensor | None = None"},{name:"output_attentions",val:": Optional[bool] = None"},{name:"output_hidden_states",val:": Optional[bool] = None"},{name:"return_dict",val:": Optional[bool] = None"},{name:"bbox",val:": tf.Tensor | None = None"},{name:"pixel_values",val:": tf.Tensor | None = None"},{name:"training",val:": Optional[bool] = False"}],parametersDescription:[{anchor:"transformers.TFLayoutLMv3ForSequenceClassification.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>) — | |
| Indices of input sequence tokens in the vocabulary.</p> | |
| <p>Note that <code>sequence_length = token_sequence_length + patch_sequence_length + 1</code> where <code>1</code> is for [CLS] | |
| token. See <code>pixel_values</code> for <code>patch_sequence_length</code>.</p> | |
| <p>Indices can be obtained using <a href="/docs/transformers/pr_34652/en/model_doc/auto#transformers.AutoTokenizer">AutoTokenizer</a>. See <a href="/docs/transformers/pr_34652/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode">PreTrainedTokenizer.encode()</a> and | |
| <a href="/docs/transformers/pr_34652/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.TFLayoutLMv3ForSequenceClassification.call.bbox",description:`<strong>bbox</strong> (<code>Numpy array</code> or <code>tf.Tensor</code> of shape <code>(batch_size, sequence_length, 4)</code>, <em>optional</em>) — | |
| Bounding boxes of each input sequence tokens. Selected in the range <code>[0, config.max_2d_position_embeddings-1]</code>. Each bounding box should be a normalized version in (x0, y0, x1, y1) | |
| format, where (x0, y0) corresponds to the position of the upper left corner in the bounding box, and (x1, | |
| y1) represents the position of the lower right corner.</p> | |
| <p>Note that <code>sequence_length = token_sequence_length + patch_sequence_length + 1</code> where <code>1</code> is for [CLS] | |
| token. See <code>pixel_values</code> for <code>patch_sequence_length</code>.`,name:"bbox"},{anchor:"transformers.TFLayoutLMv3ForSequenceClassification.call.pixel_values",description:`<strong>pixel_values</strong> (<code>tf.Tensor</code> of shape <code>(batch_size, num_channels, height, width)</code>) — | |
| Batch of document images. Each image is divided into patches of shape <code>(num_channels, config.patch_size, config.patch_size)</code> and the total number of patches (=<code>patch_sequence_length</code>) equals to <code>((height / config.patch_size) * (width / config.patch_size))</code>.`,name:"pixel_values"},{anchor:"transformers.TFLayoutLMv3ForSequenceClassification.call.attention_mask",description:`<strong>attention_mask</strong> (<code>tf.Tensor</code> of shape <code>(batch_size, sequence_length)</code>, <em>optional</em>) — | |
| 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>Note that <code>sequence_length = token_sequence_length + patch_sequence_length + 1</code> where <code>1</code> is for [CLS] | |
| token. See <code>pixel_values</code> for <code>patch_sequence_length</code>.</p> | |
| <p><a href="../glossary#attention-mask">What are attention masks?</a>`,name:"attention_mask"},{anchor:"transformers.TFLayoutLMv3ForSequenceClassification.call.token_type_ids",description:`<strong>token_type_ids</strong> (<code>Numpy array</code> or <code>tf.Tensor</code> of shape <code>(batch_size, sequence_length)</code>, <em>optional</em>) — | |
| Segment token indices to indicate first and second portions of the inputs. Indices are selected in <code>[0, 1]</code>:</p> | |
| <ul> | |
| <li>0 corresponds to a <em>sentence A</em> token,</li> | |
| <li>1 corresponds to a <em>sentence B</em> token.</li> | |
| </ul> | |
| <p>Note that <code>sequence_length = token_sequence_length + patch_sequence_length + 1</code> where <code>1</code> is for [CLS] | |
| token. See <code>pixel_values</code> for <code>patch_sequence_length</code>.</p> | |
| <p><a href="../glossary#token-type-ids">What are token type IDs?</a>`,name:"token_type_ids"},{anchor:"transformers.TFLayoutLMv3ForSequenceClassification.call.position_ids",description:`<strong>position_ids</strong> (<code>Numpy array</code> or <code>tf.Tensor</code> of shape <code>(batch_size, sequence_length)</code>, <em>optional</em>) — | |
| Indices of positions of each input sequence tokens in the position embeddings. Selected in the range <code>[0, config.max_position_embeddings - 1]</code>.</p> | |
| <p>Note that <code>sequence_length = token_sequence_length + patch_sequence_length + 1</code> where <code>1</code> is for [CLS] | |
| token. See <code>pixel_values</code> for <code>patch_sequence_length</code>.</p> | |
| <p><a href="../glossary#position-ids">What are position IDs?</a>`,name:"position_ids"},{anchor:"transformers.TFLayoutLMv3ForSequenceClassification.call.head_mask",description:`<strong>head_mask</strong> (<code>tf.Tensor</code> of shape <code>(num_heads,)</code> or <code>(num_layers, num_heads)</code>, <em>optional</em>) — | |
| 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.TFLayoutLMv3ForSequenceClassification.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>) — | |
| 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 <em>input_ids</em> indices into associated vectors than the | |
| model’s internal embedding lookup matrix.`,name:"inputs_embeds"},{anchor:"transformers.TFLayoutLMv3ForSequenceClassification.call.output_attentions",description:`<strong>output_attentions</strong> (<code>bool</code>, <em>optional</em>) — | |
| 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.TFLayoutLMv3ForSequenceClassification.call.output_hidden_states",description:`<strong>output_hidden_states</strong> (<code>bool</code>, <em>optional</em>) — | |
| 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.TFLayoutLMv3ForSequenceClassification.call.return_dict",description:`<strong>return_dict</strong> (<code>bool</code>, <em>optional</em>) — | |
| Whether or not to return a <a href="/docs/transformers/pr_34652/en/main_classes/output#transformers.utils.ModelOutput">ModelOutput</a> instead of a plain tuple.`,name:"return_dict"}],source:"https://github.com/huggingface/transformers/blob/vr_34652/src/transformers/models/layoutlmv3/modeling_tf_layoutlmv3.py#L1404",returnDescription:`<script context="module">export const metadata = 'undefined';<\/script> | |
| <p>A <a | |
| href="/docs/transformers/pr_34652/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/pr_34652/en/model_doc/layoutlmv3#transformers.LayoutLMv3Config" | |
| >LayoutLMv3Config</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) — 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>) — 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>) — 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>) — 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:`<script context="module">export const metadata = 'undefined';<\/script> | |
| <p><a | |
| href="/docs/transformers/pr_34652/en/main_classes/output#transformers.modeling_tf_outputs.TFSequenceClassifierOutput" | |
| >transformers.modeling_tf_outputs.TFSequenceClassifierOutput</a> or <code>tuple(tf.Tensor)</code></p> | |
| `}}),Re=new ut({props:{$$slots:{default:[yn]},$$scope:{ctx:$}}}),de=new qt({props:{anchor:"transformers.TFLayoutLMv3ForSequenceClassification.call.example",$$slots:{default:[vn]},$$scope:{ctx:$}}}),tt=new Fe({props:{title:"TFLayoutLMv3ForTokenClassification",local:"transformers.TFLayoutLMv3ForTokenClassification",headingTag:"h2"}}),We=new B({props:{name:"class transformers.TFLayoutLMv3ForTokenClassification",anchor:"transformers.TFLayoutLMv3ForTokenClassification",parameters:[{name:"config",val:": LayoutLMv3Config"},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"transformers.TFLayoutLMv3ForTokenClassification.config",description:`<strong>config</strong> (<a href="/docs/transformers/pr_34652/en/model_doc/layoutlmv3#transformers.LayoutLMv3Config">LayoutLMv3Config</a>) — 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/pr_34652/en/main_classes/model#transformers.TFPreTrainedModel.from_pretrained">from_pretrained()</a> method to load the model weights.`,name:"config"}],source:"https://github.com/huggingface/transformers/blob/vr_34652/src/transformers/models/layoutlmv3/modeling_tf_layoutlmv3.py#L1500"}}),ae=new ut({props:{$$slots:{default:[bn]},$$scope:{ctx:$}}}),ot=new B({props:{name:"call",anchor:"transformers.TFLayoutLMv3ForTokenClassification.call",parameters:[{name:"input_ids",val:": tf.Tensor | None = None"},{name:"bbox",val:": tf.Tensor | None = None"},{name:"attention_mask",val:": tf.Tensor | None = None"},{name:"token_type_ids",val:": tf.Tensor | None = None"},{name:"position_ids",val:": tf.Tensor | None = None"},{name:"head_mask",val:": tf.Tensor | None = None"},{name:"inputs_embeds",val:": tf.Tensor | None = None"},{name:"labels",val:": tf.Tensor | None = None"},{name:"output_attentions",val:": Optional[bool] = None"},{name:"output_hidden_states",val:": Optional[bool] = None"},{name:"return_dict",val:": Optional[bool] = None"},{name:"pixel_values",val:": tf.Tensor | None = None"},{name:"training",val:": Optional[bool] = False"}],parametersDescription:[{anchor:"transformers.TFLayoutLMv3ForTokenClassification.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>) — | |
| Indices of input sequence tokens in the vocabulary.</p> | |
| <p>Note that <code>sequence_length = token_sequence_length + patch_sequence_length + 1</code> where <code>1</code> is for [CLS] | |
| token. See <code>pixel_values</code> for <code>patch_sequence_length</code>.</p> | |
| <p>Indices can be obtained using <a href="/docs/transformers/pr_34652/en/model_doc/auto#transformers.AutoTokenizer">AutoTokenizer</a>. See <a href="/docs/transformers/pr_34652/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode">PreTrainedTokenizer.encode()</a> and | |
| <a href="/docs/transformers/pr_34652/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.TFLayoutLMv3ForTokenClassification.call.bbox",description:`<strong>bbox</strong> (<code>Numpy array</code> or <code>tf.Tensor</code> of shape <code>(batch_size, sequence_length, 4)</code>, <em>optional</em>) — | |
| Bounding boxes of each input sequence tokens. Selected in the range <code>[0, config.max_2d_position_embeddings-1]</code>. Each bounding box should be a normalized version in (x0, y0, x1, y1) | |
| format, where (x0, y0) corresponds to the position of the upper left corner in the bounding box, and (x1, | |
| y1) represents the position of the lower right corner.</p> | |
| <p>Note that <code>sequence_length = token_sequence_length + patch_sequence_length + 1</code> where <code>1</code> is for [CLS] | |
| token. See <code>pixel_values</code> for <code>patch_sequence_length</code>.`,name:"bbox"},{anchor:"transformers.TFLayoutLMv3ForTokenClassification.call.pixel_values",description:`<strong>pixel_values</strong> (<code>tf.Tensor</code> of shape <code>(batch_size, num_channels, height, width)</code>) — | |
| Batch of document images. Each image is divided into patches of shape <code>(num_channels, config.patch_size, config.patch_size)</code> and the total number of patches (=<code>patch_sequence_length</code>) equals to <code>((height / config.patch_size) * (width / config.patch_size))</code>.`,name:"pixel_values"},{anchor:"transformers.TFLayoutLMv3ForTokenClassification.call.attention_mask",description:`<strong>attention_mask</strong> (<code>tf.Tensor</code> of shape <code>(batch_size, sequence_length)</code>, <em>optional</em>) — | |
| 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>Note that <code>sequence_length = token_sequence_length + patch_sequence_length + 1</code> where <code>1</code> is for [CLS] | |
| token. See <code>pixel_values</code> for <code>patch_sequence_length</code>.</p> | |
| <p><a href="../glossary#attention-mask">What are attention masks?</a>`,name:"attention_mask"},{anchor:"transformers.TFLayoutLMv3ForTokenClassification.call.token_type_ids",description:`<strong>token_type_ids</strong> (<code>Numpy array</code> or <code>tf.Tensor</code> of shape <code>(batch_size, sequence_length)</code>, <em>optional</em>) — | |
| Segment token indices to indicate first and second portions of the inputs. Indices are selected in <code>[0, 1]</code>:</p> | |
| <ul> | |
| <li>0 corresponds to a <em>sentence A</em> token,</li> | |
| <li>1 corresponds to a <em>sentence B</em> token.</li> | |
| </ul> | |
| <p>Note that <code>sequence_length = token_sequence_length + patch_sequence_length + 1</code> where <code>1</code> is for [CLS] | |
| token. See <code>pixel_values</code> for <code>patch_sequence_length</code>.</p> | |
| <p><a href="../glossary#token-type-ids">What are token type IDs?</a>`,name:"token_type_ids"},{anchor:"transformers.TFLayoutLMv3ForTokenClassification.call.position_ids",description:`<strong>position_ids</strong> (<code>Numpy array</code> or <code>tf.Tensor</code> of shape <code>(batch_size, sequence_length)</code>, <em>optional</em>) — | |
| Indices of positions of each input sequence tokens in the position embeddings. Selected in the range <code>[0, config.max_position_embeddings - 1]</code>.</p> | |
| <p>Note that <code>sequence_length = token_sequence_length + patch_sequence_length + 1</code> where <code>1</code> is for [CLS] | |
| token. See <code>pixel_values</code> for <code>patch_sequence_length</code>.</p> | |
| <p><a href="../glossary#position-ids">What are position IDs?</a>`,name:"position_ids"},{anchor:"transformers.TFLayoutLMv3ForTokenClassification.call.head_mask",description:`<strong>head_mask</strong> (<code>tf.Tensor</code> of shape <code>(num_heads,)</code> or <code>(num_layers, num_heads)</code>, <em>optional</em>) — | |
| 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.TFLayoutLMv3ForTokenClassification.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>) — | |
| 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 <em>input_ids</em> indices into associated vectors than the | |
| model’s internal embedding lookup matrix.`,name:"inputs_embeds"},{anchor:"transformers.TFLayoutLMv3ForTokenClassification.call.output_attentions",description:`<strong>output_attentions</strong> (<code>bool</code>, <em>optional</em>) — | |
| 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.TFLayoutLMv3ForTokenClassification.call.output_hidden_states",description:`<strong>output_hidden_states</strong> (<code>bool</code>, <em>optional</em>) — | |
| 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.TFLayoutLMv3ForTokenClassification.call.return_dict",description:`<strong>return_dict</strong> (<code>bool</code>, <em>optional</em>) — | |
| Whether or not to return a <a href="/docs/transformers/pr_34652/en/main_classes/output#transformers.utils.ModelOutput">ModelOutput</a> instead of a plain tuple.`,name:"return_dict"},{anchor:"transformers.TFLayoutLMv3ForTokenClassification.call.labels",description:`<strong>labels</strong> (<code>tf.Tensor</code> of shape <code>(batch_size, sequence_length)</code>, <em>optional</em>) — | |
| 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/vr_34652/src/transformers/models/layoutlmv3/modeling_tf_layoutlmv3.py#L1529",returnDescription:`<script context="module">export const metadata = 'undefined';<\/script> | |
| <p>A <a | |
| href="/docs/transformers/pr_34652/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/pr_34652/en/model_doc/layoutlmv3#transformers.LayoutLMv3Config" | |
| >LayoutLMv3Config</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) — Classification loss.</p> | |
| </li> | |
| <li> | |
| <p><strong>logits</strong> (<code>tf.Tensor</code> of shape <code>(batch_size, sequence_length, config.num_labels)</code>) — 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>) — 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>) — 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:`<script context="module">export const metadata = 'undefined';<\/script> | |
| <p><a | |
| href="/docs/transformers/pr_34652/en/main_classes/output#transformers.modeling_tf_outputs.TFTokenClassifierOutput" | |
| >transformers.modeling_tf_outputs.TFTokenClassifierOutput</a> or <code>tuple(tf.Tensor)</code></p> | |
| `}}),D=new ut({props:{$$slots:{default:[Tn]},$$scope:{ctx:$}}}),ie=new qt({props:{anchor:"transformers.TFLayoutLMv3ForTokenClassification.call.example",$$slots:{default:[Mn]},$$scope:{ctx:$}}}),we=new Fe({props:{title:"TFLayoutLMv3ForQuestionAnswering",local:"transformers.TFLayoutLMv3ForQuestionAnswering",headingTag:"h2"}}),fe=new B({props:{name:"class transformers.TFLayoutLMv3ForQuestionAnswering",anchor:"transformers.TFLayoutLMv3ForQuestionAnswering",parameters:[{name:"config",val:": LayoutLMv3Config"},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"transformers.TFLayoutLMv3ForQuestionAnswering.config",description:`<strong>config</strong> (<a href="/docs/transformers/pr_34652/en/model_doc/layoutlmv3#transformers.LayoutLMv3Config">LayoutLMv3Config</a>) — 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/pr_34652/en/main_classes/model#transformers.TFPreTrainedModel.from_pretrained">from_pretrained()</a> method to load the model weights.`,name:"config"}],source:"https://github.com/huggingface/transformers/blob/vr_34652/src/transformers/models/layoutlmv3/modeling_tf_layoutlmv3.py#L1638"}}),Z=new ut({props:{$$slots:{default:[Ln]},$$scope:{ctx:$}}}),kt=new B({props:{name:"call",anchor:"transformers.TFLayoutLMv3ForQuestionAnswering.call",parameters:[{name:"input_ids",val:": tf.Tensor | None = None"},{name:"attention_mask",val:": tf.Tensor | None = None"},{name:"token_type_ids",val:": tf.Tensor | None = None"},{name:"position_ids",val:": tf.Tensor | None = None"},{name:"head_mask",val:": tf.Tensor | None = None"},{name:"inputs_embeds",val:": tf.Tensor | None = None"},{name:"start_positions",val:": tf.Tensor | None = None"},{name:"end_positions",val:": tf.Tensor | None = None"},{name:"output_attentions",val:": Optional[bool] = None"},{name:"output_hidden_states",val:": Optional[bool] = None"},{name:"bbox",val:": tf.Tensor | None = None"},{name:"pixel_values",val:": tf.Tensor | None = None"},{name:"return_dict",val:": Optional[bool] = None"},{name:"training",val:": bool = False"}],parametersDescription:[{anchor:"transformers.TFLayoutLMv3ForQuestionAnswering.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>) — | |
| Indices of input sequence tokens in the vocabulary.</p> | |
| <p>Note that <code>sequence_length = token_sequence_length + patch_sequence_length + 1</code> where <code>1</code> is for [CLS] | |
| token. See <code>pixel_values</code> for <code>patch_sequence_length</code>.</p> | |
| <p>Indices can be obtained using <a href="/docs/transformers/pr_34652/en/model_doc/auto#transformers.AutoTokenizer">AutoTokenizer</a>. See <a href="/docs/transformers/pr_34652/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode">PreTrainedTokenizer.encode()</a> and | |
| <a href="/docs/transformers/pr_34652/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.TFLayoutLMv3ForQuestionAnswering.call.bbox",description:`<strong>bbox</strong> (<code>Numpy array</code> or <code>tf.Tensor</code> of shape <code>(batch_size, sequence_length, 4)</code>, <em>optional</em>) — | |
| Bounding boxes of each input sequence tokens. Selected in the range <code>[0, config.max_2d_position_embeddings-1]</code>. Each bounding box should be a normalized version in (x0, y0, x1, y1) | |
| format, where (x0, y0) corresponds to the position of the upper left corner in the bounding box, and (x1, | |
| y1) represents the position of the lower right corner.</p> | |
| <p>Note that <code>sequence_length = token_sequence_length + patch_sequence_length + 1</code> where <code>1</code> is for [CLS] | |
| token. See <code>pixel_values</code> for <code>patch_sequence_length</code>.`,name:"bbox"},{anchor:"transformers.TFLayoutLMv3ForQuestionAnswering.call.pixel_values",description:`<strong>pixel_values</strong> (<code>tf.Tensor</code> of shape <code>(batch_size, num_channels, height, width)</code>) — | |
| Batch of document images. Each image is divided into patches of shape <code>(num_channels, config.patch_size, config.patch_size)</code> and the total number of patches (=<code>patch_sequence_length</code>) equals to <code>((height / config.patch_size) * (width / config.patch_size))</code>.`,name:"pixel_values"},{anchor:"transformers.TFLayoutLMv3ForQuestionAnswering.call.attention_mask",description:`<strong>attention_mask</strong> (<code>tf.Tensor</code> of shape <code>(batch_size, sequence_length)</code>, <em>optional</em>) — | |
| 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>Note that <code>sequence_length = token_sequence_length + patch_sequence_length + 1</code> where <code>1</code> is for [CLS] | |
| token. See <code>pixel_values</code> for <code>patch_sequence_length</code>.</p> | |
| <p><a href="../glossary#attention-mask">What are attention masks?</a>`,name:"attention_mask"},{anchor:"transformers.TFLayoutLMv3ForQuestionAnswering.call.token_type_ids",description:`<strong>token_type_ids</strong> (<code>Numpy array</code> or <code>tf.Tensor</code> of shape <code>(batch_size, sequence_length)</code>, <em>optional</em>) — | |
| Segment token indices to indicate first and second portions of the inputs. Indices are selected in <code>[0, 1]</code>:</p> | |
| <ul> | |
| <li>0 corresponds to a <em>sentence A</em> token,</li> | |
| <li>1 corresponds to a <em>sentence B</em> token.</li> | |
| </ul> | |
| <p>Note that <code>sequence_length = token_sequence_length + patch_sequence_length + 1</code> where <code>1</code> is for [CLS] | |
| token. See <code>pixel_values</code> for <code>patch_sequence_length</code>.</p> | |
| <p><a href="../glossary#token-type-ids">What are token type IDs?</a>`,name:"token_type_ids"},{anchor:"transformers.TFLayoutLMv3ForQuestionAnswering.call.position_ids",description:`<strong>position_ids</strong> (<code>Numpy array</code> or <code>tf.Tensor</code> of shape <code>(batch_size, sequence_length)</code>, <em>optional</em>) — | |
| Indices of positions of each input sequence tokens in the position embeddings. Selected in the range <code>[0, config.max_position_embeddings - 1]</code>.</p> | |
| <p>Note that <code>sequence_length = token_sequence_length + patch_sequence_length + 1</code> where <code>1</code> is for [CLS] | |
| token. See <code>pixel_values</code> for <code>patch_sequence_length</code>.</p> | |
| <p><a href="../glossary#position-ids">What are position IDs?</a>`,name:"position_ids"},{anchor:"transformers.TFLayoutLMv3ForQuestionAnswering.call.head_mask",description:`<strong>head_mask</strong> (<code>tf.Tensor</code> of shape <code>(num_heads,)</code> or <code>(num_layers, num_heads)</code>, <em>optional</em>) — | |
| 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.TFLayoutLMv3ForQuestionAnswering.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>) — | |
| 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 <em>input_ids</em> indices into associated vectors than the | |
| model’s internal embedding lookup matrix.`,name:"inputs_embeds"},{anchor:"transformers.TFLayoutLMv3ForQuestionAnswering.call.output_attentions",description:`<strong>output_attentions</strong> (<code>bool</code>, <em>optional</em>) — | |
| 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.TFLayoutLMv3ForQuestionAnswering.call.output_hidden_states",description:`<strong>output_hidden_states</strong> (<code>bool</code>, <em>optional</em>) — | |
| 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.TFLayoutLMv3ForQuestionAnswering.call.return_dict",description:`<strong>return_dict</strong> (<code>bool</code>, <em>optional</em>) — | |
| Whether or not to return a <a href="/docs/transformers/pr_34652/en/main_classes/output#transformers.utils.ModelOutput">ModelOutput</a> instead of a plain tuple.`,name:"return_dict"},{anchor:"transformers.TFLayoutLMv3ForQuestionAnswering.call.start_positions",description:`<strong>start_positions</strong> (<code>tf.Tensor</code> of shape <code>(batch_size,)</code>, <em>optional</em>) — | |
| 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.TFLayoutLMv3ForQuestionAnswering.call.end_positions",description:`<strong>end_positions</strong> (<code>tf.Tensor</code> of shape <code>(batch_size,)</code>, <em>optional</em>) — | |
| 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/vr_34652/src/transformers/models/layoutlmv3/modeling_tf_layoutlmv3.py#L1658",returnDescription:`<script context="module">export const metadata = 'undefined';<\/script> | |
| <p>A <a | |
| href="/docs/transformers/pr_34652/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/pr_34652/en/model_doc/layoutlmv3#transformers.LayoutLMv3Config" | |
| >LayoutLMv3Config</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) — 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>) — 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>) — 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>) — 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>) — 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:`<script context="module">export const metadata = 'undefined';<\/script> | |
| <p><a | |
| href="/docs/transformers/pr_34652/en/main_classes/output#transformers.modeling_tf_outputs.TFQuestionAnsweringModelOutput" | |
| >transformers.modeling_tf_outputs.TFQuestionAnsweringModelOutput</a> or <code>tuple(tf.Tensor)</code></p> | |
| `}}),Ae=new ut({props:{$$slots:{default:[kn]},$$scope:{ctx:$}}}),pt=new qt({props:{anchor:"transformers.TFLayoutLMv3ForQuestionAnswering.call.example",$$slots:{default:[wn]},$$scope:{ctx:$}}}),{c(){y(t.$$.fragment),g=a(),n=c("div"),y(i.$$.fragment),w=a(),s=c("p"),s.innerHTML=k,Q=a(),z=c("p"),z.innerHTML=C,Y=a(),y(j.$$.fragment),N=a(),I=c("div"),y(m.$$.fragment),F=a(),le=c("p"),le.innerHTML=je,De=a(),y(be.$$.fragment),E=a(),y(ue.$$.fragment),rt=a(),y(K.$$.fragment),Mt=a(),G=c("div"),y(ee.$$.fragment),yt=a(),Te=c("p"),Te.innerHTML=Me,Ne=a(),Le=c("p"),Le.innerHTML=Oe,Ke=a(),it=c("p"),it.innerHTML=Je,Ie=a(),y(te.$$.fragment),Ue=a(),O=c("div"),y(ze.$$.fragment),V=a(),he=c("p"),he.innerHTML=et,lt=a(),y(Re.$$.fragment),He=a(),y(de.$$.fragment),Ee=a(),y(tt.$$.fragment),oe=a(),U=c("div"),y(We.$$.fragment),ke=a(),ht=c("p"),ht.innerHTML=vt,ce=a(),dt=c("p"),dt.innerHTML=Ze,Be=a(),qe=c("p"),qe.innerHTML=ft,X=a(),y(ae.$$.fragment),re=a(),P=c("div"),y(ot.$$.fragment),nt=a(),Pe=c("p"),Pe.innerHTML=Ft,st=a(),y(D.$$.fragment),Ve=a(),y(ie.$$.fragment),Se=a(),y(we.$$.fragment),ct=a(),J=c("div"),y(fe.$$.fragment),Ge=a(),pe=c("p"),pe.innerHTML=h,q=a(),A=c("p"),A.innerHTML=Ce,me=a(),H=c("p"),H.innerHTML=ge,S=a(),y(Z.$$.fragment),Lt=a(),_e=c("div"),y(kt.$$.fragment),It=a(),Xe=c("p"),Xe.innerHTML=wt,Ut=a(),y(Ae.$$.fragment),At=a(),y(pt.$$.fragment),this.h()},l(u){v(t.$$.fragment,u),g=r(u),n=p(u,"DIV",{class:!0});var x=W(n);v(i.$$.fragment,x),w=r(x),s=p(x,"P",{"data-svelte-h":!0}),f(s)!=="svelte-1elvy1b"&&(s.innerHTML=k),Q=r(x),z=p(x,"P",{"data-svelte-h":!0}),f(z)!=="svelte-1be7e3c"&&(z.innerHTML=C),Y=r(x),v(j.$$.fragment,x),N=r(x),I=p(x,"DIV",{class:!0});var ye=W(I);v(m.$$.fragment,ye),F=r(ye),le=p(ye,"P",{"data-svelte-h":!0}),f(le)!=="svelte-3a086l"&&(le.innerHTML=je),De=r(ye),v(be.$$.fragment,ye),E=r(ye),v(ue.$$.fragment,ye),ye.forEach(o),x.forEach(o),rt=r(u),v(K.$$.fragment,u),Mt=r(u),G=p(u,"DIV",{class:!0});var ve=W(G);v(ee.$$.fragment,ve),yt=r(ve),Te=p(ve,"P",{"data-svelte-h":!0}),f(Te)!=="svelte-oc0y77"&&(Te.innerHTML=Me),Ne=r(ve),Le=p(ve,"P",{"data-svelte-h":!0}),f(Le)!=="svelte-2bgrwg"&&(Le.innerHTML=Oe),Ke=r(ve),it=p(ve,"P",{"data-svelte-h":!0}),f(it)!=="svelte-1be7e3c"&&(it.innerHTML=Je),Ie=r(ve),v(te.$$.fragment,ve),Ue=r(ve),O=p(ve,"DIV",{class:!0});var xe=W(O);v(ze.$$.fragment,xe),V=r(xe),he=p(xe,"P",{"data-svelte-h":!0}),f(he)!=="svelte-1x6jt2l"&&(he.innerHTML=et),lt=r(xe),v(Re.$$.fragment,xe),He=r(xe),v(de.$$.fragment,xe),xe.forEach(o),ve.forEach(o),Ee=r(u),v(tt.$$.fragment,u),oe=r(u),U=p(u,"DIV",{class:!0});var $e=W(U);v(We.$$.fragment,$e),ke=r($e),ht=p($e,"P",{"data-svelte-h":!0}),f(ht)!=="svelte-16ux587"&&(ht.innerHTML=vt),ce=r($e),dt=p($e,"P",{"data-svelte-h":!0}),f(dt)!=="svelte-2bgrwg"&&(dt.innerHTML=Ze),Be=r($e),qe=p($e,"P",{"data-svelte-h":!0}),f(qe)!=="svelte-1be7e3c"&&(qe.innerHTML=ft),X=r($e),v(ae.$$.fragment,$e),re=r($e),P=p($e,"DIV",{class:!0});var Qe=W(P);v(ot.$$.fragment,Qe),nt=r(Qe),Pe=p(Qe,"P",{"data-svelte-h":!0}),f(Pe)!=="svelte-1evv3hx"&&(Pe.innerHTML=Ft),st=r(Qe),v(D.$$.fragment,Qe),Ve=r(Qe),v(ie.$$.fragment,Qe),Qe.forEach(o),$e.forEach(o),Se=r(u),v(we.$$.fragment,u),ct=r(u),J=p(u,"DIV",{class:!0});var ne=W(J);v(fe.$$.fragment,ne),Ge=r(ne),pe=p(ne,"P",{"data-svelte-h":!0}),f(pe)!=="svelte-1p4p08z"&&(pe.innerHTML=h),q=r(ne),A=p(ne,"P",{"data-svelte-h":!0}),f(A)!=="svelte-2bgrwg"&&(A.innerHTML=Ce),me=r(ne),H=p(ne,"P",{"data-svelte-h":!0}),f(H)!=="svelte-1be7e3c"&&(H.innerHTML=ge),S=r(ne),v(Z.$$.fragment,ne),Lt=r(ne),_e=p(ne,"DIV",{class:!0});var at=W(_e);v(kt.$$.fragment,at),It=r(at),Xe=p(at,"P",{"data-svelte-h":!0}),f(Xe)!=="svelte-11ej4ej"&&(Xe.innerHTML=wt),Ut=r(at),v(Ae.$$.fragment,at),At=r(at),v(pt.$$.fragment,at),at.forEach(o),ne.forEach(o),this.h()},h(){R(I,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),R(n,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),R(O,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),R(G,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),R(P,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),R(U,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),R(_e,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),R(J,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8")},m(u,x){b(t,u,x),l(u,g,x),l(u,n,x),b(i,n,null),d(n,w),d(n,s),d(n,Q),d(n,z),d(n,Y),b(j,n,null),d(n,N),d(n,I),b(m,I,null),d(I,F),d(I,le),d(I,De),b(be,I,null),d(I,E),b(ue,I,null),l(u,rt,x),b(K,u,x),l(u,Mt,x),l(u,G,x),b(ee,G,null),d(G,yt),d(G,Te),d(G,Ne),d(G,Le),d(G,Ke),d(G,it),d(G,Ie),b(te,G,null),d(G,Ue),d(G,O),b(ze,O,null),d(O,V),d(O,he),d(O,lt),b(Re,O,null),d(O,He),b(de,O,null),l(u,Ee,x),b(tt,u,x),l(u,oe,x),l(u,U,x),b(We,U,null),d(U,ke),d(U,ht),d(U,ce),d(U,dt),d(U,Be),d(U,qe),d(U,X),b(ae,U,null),d(U,re),d(U,P),b(ot,P,null),d(P,nt),d(P,Pe),d(P,st),b(D,P,null),d(P,Ve),b(ie,P,null),l(u,Se,x),b(we,u,x),l(u,ct,x),l(u,J,x),b(fe,J,null),d(J,Ge),d(J,pe),d(J,q),d(J,A),d(J,me),d(J,H),d(J,S),b(Z,J,null),d(J,Lt),d(J,_e),b(kt,_e,null),d(_e,It),d(_e,Xe),d(_e,Ut),b(Ae,_e,null),d(_e,At),b(pt,_e,null),gt=!0},p(u,x){const ye={};x&2&&(ye.$$scope={dirty:x,ctx:u}),j.$set(ye);const ve={};x&2&&(ve.$$scope={dirty:x,ctx:u}),be.$set(ve);const xe={};x&2&&(xe.$$scope={dirty:x,ctx:u}),ue.$set(xe);const $e={};x&2&&($e.$$scope={dirty:x,ctx:u}),te.$set($e);const Qe={};x&2&&(Qe.$$scope={dirty:x,ctx:u}),Re.$set(Qe);const ne={};x&2&&(ne.$$scope={dirty:x,ctx:u}),de.$set(ne);const at={};x&2&&(at.$$scope={dirty:x,ctx:u}),ae.$set(at);const Qt={};x&2&&(Qt.$$scope={dirty:x,ctx:u}),D.$set(Qt);const zt={};x&2&&(zt.$$scope={dirty:x,ctx:u}),ie.$set(zt);const co={};x&2&&(co.$$scope={dirty:x,ctx:u}),Z.$set(co);const Yt={};x&2&&(Yt.$$scope={dirty:x,ctx:u}),Ae.$set(Yt);const bt={};x&2&&(bt.$$scope={dirty:x,ctx:u}),pt.$set(bt)},i(u){gt||(T(t.$$.fragment,u),T(i.$$.fragment,u),T(j.$$.fragment,u),T(m.$$.fragment,u),T(be.$$.fragment,u),T(ue.$$.fragment,u),T(K.$$.fragment,u),T(ee.$$.fragment,u),T(te.$$.fragment,u),T(ze.$$.fragment,u),T(Re.$$.fragment,u),T(de.$$.fragment,u),T(tt.$$.fragment,u),T(We.$$.fragment,u),T(ae.$$.fragment,u),T(ot.$$.fragment,u),T(D.$$.fragment,u),T(ie.$$.fragment,u),T(we.$$.fragment,u),T(fe.$$.fragment,u),T(Z.$$.fragment,u),T(kt.$$.fragment,u),T(Ae.$$.fragment,u),T(pt.$$.fragment,u),gt=!0)},o(u){M(t.$$.fragment,u),M(i.$$.fragment,u),M(j.$$.fragment,u),M(m.$$.fragment,u),M(be.$$.fragment,u),M(ue.$$.fragment,u),M(K.$$.fragment,u),M(ee.$$.fragment,u),M(te.$$.fragment,u),M(ze.$$.fragment,u),M(Re.$$.fragment,u),M(de.$$.fragment,u),M(tt.$$.fragment,u),M(We.$$.fragment,u),M(ae.$$.fragment,u),M(ot.$$.fragment,u),M(D.$$.fragment,u),M(ie.$$.fragment,u),M(we.$$.fragment,u),M(fe.$$.fragment,u),M(Z.$$.fragment,u),M(kt.$$.fragment,u),M(Ae.$$.fragment,u),M(pt.$$.fragment,u),gt=!1},d(u){u&&(o(g),o(n),o(rt),o(Mt),o(G),o(Ee),o(oe),o(U),o(Se),o(ct),o(J)),L(t,u),L(i),L(j),L(m),L(be),L(ue),L(K,u),L(ee),L(te),L(ze),L(Re),L(de),L(tt,u),L(We),L(ae),L(ot),L(D),L(ie),L(we,u),L(fe),L(Z),L(kt),L(Ae),L(pt)}}}function $n($){let t,g;return t=new Vo({props:{$$slots:{default:[xn]},$$scope:{ctx:$}}}),{c(){y(t.$$.fragment)},l(n){v(t.$$.fragment,n)},m(n,i){b(t,n,i),g=!0},p(n,i){const w={};i&2&&(w.$$scope={dirty:i,ctx:n}),t.$set(w)},i(n){g||(T(t.$$.fragment,n),g=!0)},o(n){M(t.$$.fragment,n),g=!1},d(n){L(t,n)}}}function Fn($){let t,g,n,i,w,s,k,Q,z,C=`The LayoutLMv3 model was proposed in <a href="https://arxiv.org/abs/2204.08387" rel="nofollow">LayoutLMv3: Pre-training for Document AI with Unified Text and Image Masking</a> by Yupan Huang, Tengchao Lv, Lei Cui, Yutong Lu, Furu Wei. | |
| LayoutLMv3 simplifies <a href="layoutlmv2">LayoutLMv2</a> by using patch embeddings (as in <a href="vit">ViT</a>) instead of leveraging a CNN backbone, and pre-trains the model on 3 objectives: masked language modeling (MLM), masked image modeling (MIM) | |
| and word-patch alignment (WPA).`,Y,j,N="The abstract from the paper is the following:",I,m,F="<em>Self-supervised pre-training techniques have achieved remarkable progress in Document AI. Most multimodal pre-trained models use a masked language modeling objective to learn bidirectional representations on the text modality, but they differ in pre-training objectives for the image modality. This discrepancy adds difficulty to multimodal representation learning. In this paper, we propose LayoutLMv3 to pre-train multimodal Transformers for Document AI with unified text and image masking. Additionally, LayoutLMv3 is pre-trained with a word-patch alignment objective to learn cross-modal alignment by predicting whether the corresponding image patch of a text word is masked. The simple unified architecture and training objectives make LayoutLMv3 a general-purpose pre-trained model for both text-centric and image-centric Document AI tasks. Experimental results show that LayoutLMv3 achieves state-of-the-art performance not only in text-centric tasks, including form understanding, receipt understanding, and document visual question answering, but also in image-centric tasks such as document image classification and document layout analysis.</em>",le,je,De,be,E,ue='LayoutLMv3 architecture. Taken from the <a href="https://arxiv.org/abs/2204.08387">original paper</a>.',rt,K,Mt='This model was contributed by <a href="https://huggingface.co/nielsr" rel="nofollow">nielsr</a>. The TensorFlow version of this model was added by <a href="https://huggingface.co/chriskoo" rel="nofollow">chriskoo</a>, <a href="https://huggingface.co/tokec" rel="nofollow">tokec</a>, and <a href="https://huggingface.co/lre" rel="nofollow">lre</a>. The original code can be found <a href="https://github.com/microsoft/unilm/tree/master/layoutlmv3" rel="nofollow">here</a>.',G,ee,yt,Te,Me=`<li>In terms of data processing, LayoutLMv3 is identical to its predecessor <a href="layoutlmv2">LayoutLMv2</a>, except that:<ul><li>images need to be resized and normalized with channels in regular RGB format. LayoutLMv2 on the other hand normalizes the images internally and expects the channels in BGR format.</li> <li>text is tokenized using byte-pair encoding (BPE), as opposed to WordPiece. | |
| Due to these differences in data preprocessing, one can use <a href="/docs/transformers/pr_34652/en/model_doc/layoutlmv3#transformers.LayoutLMv3Processor">LayoutLMv3Processor</a> which internally combines a <a href="/docs/transformers/pr_34652/en/model_doc/layoutlmv3#transformers.LayoutLMv3ImageProcessor">LayoutLMv3ImageProcessor</a> (for the image modality) and a <a href="/docs/transformers/pr_34652/en/model_doc/layoutlmv3#transformers.LayoutLMv3Tokenizer">LayoutLMv3Tokenizer</a>/<a href="/docs/transformers/pr_34652/en/model_doc/layoutlmv3#transformers.LayoutLMv3TokenizerFast">LayoutLMv3TokenizerFast</a> (for the text modality) to prepare all data for the model.</li></ul></li> <li>Regarding usage of <a href="/docs/transformers/pr_34652/en/model_doc/layoutlmv3#transformers.LayoutLMv3Processor">LayoutLMv3Processor</a>, we refer to the <a href="layoutlmv2#usage-layoutlmv2processor">usage guide</a> of its predecessor.</li>`,Ne,Le,Oe,Ke,it="A list of official Hugging Face and community (indicated by 🌎) resources to help you get started with LayoutLMv3. If you’re interested in submitting a resource to be included here, please feel free to open a Pull Request and we’ll review it! The resource should ideally demonstrate something new instead of duplicating an existing resource.",Je,Ie,te,Ue,O='<li>Demo notebooks for LayoutLMv3 can be found <a href="https://github.com/NielsRogge/Transformers-Tutorials/tree/master/LayoutLMv3" rel="nofollow">here</a>.</li> <li>Demo scripts can be found <a href="https://github.com/huggingface/transformers/tree/main/examples/research_projects/layoutlmv3" rel="nofollow">here</a>.</li>',ze,V,he,et,lt='<li><a href="/docs/transformers/pr_34652/en/model_doc/layoutlmv2#transformers.LayoutLMv2ForSequenceClassification">LayoutLMv2ForSequenceClassification</a> is supported by this <a href="https://colab.research.google.com/github/NielsRogge/Transformers-Tutorials/blob/master/LayoutLMv2/RVL-CDIP/Fine_tuning_LayoutLMv2ForSequenceClassification_on_RVL_CDIP.ipynb" rel="nofollow">notebook</a>.</li> <li><a href="../tasks/sequence_classification">Text classification task guide</a></li>',Re,He,de,Ee,tt='<li><a href="/docs/transformers/pr_34652/en/model_doc/layoutlmv3#transformers.LayoutLMv3ForTokenClassification">LayoutLMv3ForTokenClassification</a> is supported by this <a href="https://github.com/huggingface/transformers/tree/main/examples/research_projects/layoutlmv3" rel="nofollow">example script</a> and <a href="https://colab.research.google.com/github/NielsRogge/Transformers-Tutorials/blob/master/LayoutLMv3/Fine_tune_LayoutLMv3_on_FUNSD_(HuggingFace_Trainer).ipynb" rel="nofollow">notebook</a>.</li> <li>A <a href="https://colab.research.google.com/github/NielsRogge/Transformers-Tutorials/blob/master/LayoutLMv2/FUNSD/Inference_with_LayoutLMv2ForTokenClassification.ipynb" rel="nofollow">notebook</a> for how to perform inference with <a href="/docs/transformers/pr_34652/en/model_doc/layoutlmv2#transformers.LayoutLMv2ForTokenClassification">LayoutLMv2ForTokenClassification</a> and a <a href="https://colab.research.google.com/github/NielsRogge/Transformers-Tutorials/blob/master/LayoutLMv2/FUNSD/True_inference_with_LayoutLMv2ForTokenClassification_%2B_Gradio_demo.ipynb" rel="nofollow">notebook</a> for how to perform inference when no labels are available with <a href="/docs/transformers/pr_34652/en/model_doc/layoutlmv2#transformers.LayoutLMv2ForTokenClassification">LayoutLMv2ForTokenClassification</a>.</li> <li>A <a href="https://colab.research.google.com/github/NielsRogge/Transformers-Tutorials/blob/master/LayoutLMv2/FUNSD/Fine_tuning_LayoutLMv2ForTokenClassification_on_FUNSD_using_HuggingFace_Trainer.ipynb" rel="nofollow">notebook</a> for how to finetune <a href="/docs/transformers/pr_34652/en/model_doc/layoutlmv2#transformers.LayoutLMv2ForTokenClassification">LayoutLMv2ForTokenClassification</a> with the 🤗 Trainer.</li> <li><a href="../tasks/token_classification">Token classification task guide</a></li>',oe,U,We,ke,ht='<li><a href="/docs/transformers/pr_34652/en/model_doc/layoutlmv2#transformers.LayoutLMv2ForQuestionAnswering">LayoutLMv2ForQuestionAnswering</a> is supported by this <a href="https://colab.research.google.com/github/NielsRogge/Transformers-Tutorials/blob/master/LayoutLMv2/DocVQA/Fine_tuning_LayoutLMv2ForQuestionAnswering_on_DocVQA.ipynb" rel="nofollow">notebook</a>.</li> <li><a href="../tasks/question_answering">Question answering task guide</a></li>',vt,ce,dt="<strong>Document question answering</strong>",Ze,Be,qe='<li><a href="../tasks/document_question_answering">Document question answering task guide</a></li>',ft,X,ae,re,P,ot,nt,Pe=`This is the configuration class to store the configuration of a <a href="/docs/transformers/pr_34652/en/model_doc/layoutlmv3#transformers.LayoutLMv3Model">LayoutLMv3Model</a>. It is used to instantiate an | |
| LayoutLMv3 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 LayoutLMv3 | |
| <a href="https://huggingface.co/microsoft/layoutlmv3-base" rel="nofollow">microsoft/layoutlmv3-base</a> architecture.`,Ft,st,D=`Configuration objects inherit from <a href="/docs/transformers/pr_34652/en/main_classes/configuration#transformers.PretrainedConfig">PretrainedConfig</a> and can be used to control the model outputs. Read the | |
| documentation from <a href="/docs/transformers/pr_34652/en/main_classes/configuration#transformers.PretrainedConfig">PretrainedConfig</a> for more information.`,Ve,ie,Se,we,ct,J,fe,Ge,pe,h,q,A,Ce="Preprocess an image or a batch of images.",me,H,ge,S,Z,Lt,_e,kt="Constructs a LayoutLMv3 image processor.",It,Xe,wt,Ut,Ae,At="Preprocess an image or batch of images.",pt,gt,u,x,ye,ve,xe,$e=`Construct a LayoutLMv3 tokenizer. Based on <code>RoBERTatokenizer</code> (Byte Pair Encoding or BPE). | |
| <a href="/docs/transformers/pr_34652/en/model_doc/layoutlmv3#transformers.LayoutLMv3Tokenizer">LayoutLMv3Tokenizer</a> can be used to turn words, word-level bounding boxes and optional word labels to | |
| token-level <code>input_ids</code>, <code>attention_mask</code>, <code>token_type_ids</code>, <code>bbox</code>, and optional <code>labels</code> (for token | |
| classification).`,Qe,ne,at=`This tokenizer inherits from <a href="/docs/transformers/pr_34652/en/main_classes/tokenizer#transformers.PreTrainedTokenizer">PreTrainedTokenizer</a> which contains most of the main methods. Users should refer to | |
| this superclass for more information regarding those methods.`,Qt,zt,co=`<a href="/docs/transformers/pr_34652/en/model_doc/layoutlmv3#transformers.LayoutLMv3Tokenizer">LayoutLMv3Tokenizer</a> runs end-to-end tokenization: punctuation splitting and wordpiece. It also turns the | |
| word-level bounding boxes into token-level bounding boxes.`,Yt,bt,Rt,Lo,Dt,Uo=`Main method to tokenize and prepare for the model one or several sequence(s) or one or several pair(s) of | |
| sequences with word-level normalized bounding boxes and optional labels.`,ko,Ot,Wt,mo,Zt,uo,mt,Bt,wo,Kt,Ro="Construct a “fast” LayoutLMv3 tokenizer (backed by HuggingFace’s <em>tokenizers</em> library). Based on BPE.",xo,eo,Wo=`This tokenizer inherits from <a href="/docs/transformers/pr_34652/en/main_classes/tokenizer#transformers.PreTrainedTokenizerFast">PreTrainedTokenizerFast</a> which contains most of the main methods. Users should | |
| refer to this superclass for more information regarding those methods.`,$o,jt,Pt,Fo,to,Zo=`Main method to tokenize and prepare for the model one or several sequence(s) or one or several pair(s) of | |
| sequences with word-level normalized bounding boxes and optional labels.`,ho,St,fo,Ye,Gt,zo,oo,Bo=`Constructs a LayoutLMv3 processor which combines a LayoutLMv3 image processor and a LayoutLMv3 tokenizer into a | |
| single processor.`,qo,no,Po='<a href="/docs/transformers/pr_34652/en/model_doc/layoutlmv3#transformers.LayoutLMv3Processor">LayoutLMv3Processor</a> offers all the functionalities you need to prepare data for the model.',Co,so,So=`It first uses <a href="/docs/transformers/pr_34652/en/model_doc/layoutlmv3#transformers.LayoutLMv3ImageProcessor">LayoutLMv3ImageProcessor</a> to resize and normalize document images, and optionally applies OCR to | |
| get words and normalized bounding boxes. These are then provided to <a href="/docs/transformers/pr_34652/en/model_doc/layoutlmv3#transformers.LayoutLMv3Tokenizer">LayoutLMv3Tokenizer</a> or | |
| <a href="/docs/transformers/pr_34652/en/model_doc/layoutlmv3#transformers.LayoutLMv3TokenizerFast">LayoutLMv3TokenizerFast</a>, which turns the words and bounding boxes into token-level <code>input_ids</code>, | |
| <code>attention_mask</code>, <code>token_type_ids</code>, <code>bbox</code>. Optionally, one can provide integer <code>word_labels</code>, which are turned | |
| into token-level <code>labels</code> for token classification tasks (such as FUNSD, CORD).`,jo,xt,Ht,No,ao,Go=`This method first forwards the <code>images</code> argument to <a href="/docs/transformers/pr_34652/en/model_doc/imagegpt#transformers.ImageGPTFeatureExtractor.__call__"><strong>call</strong>()</a>. In case | |
| <a href="/docs/transformers/pr_34652/en/model_doc/layoutlmv3#transformers.LayoutLMv3ImageProcessor">LayoutLMv3ImageProcessor</a> was initialized with <code>apply_ocr</code> set to <code>True</code>, it passes the obtained words and | |
| bounding boxes along with the additional arguments to <a href="/docs/transformers/pr_34652/en/model_doc/layoutlmv3#transformers.LayoutLMv3Tokenizer.__call__"><strong>call</strong>()</a> and returns the output, | |
| together with resized and normalized <code>pixel_values</code>. In case <a href="/docs/transformers/pr_34652/en/model_doc/layoutlmv3#transformers.LayoutLMv3ImageProcessor">LayoutLMv3ImageProcessor</a> was initialized with | |
| <code>apply_ocr</code> set to <code>False</code>, it passes the words (<code>text</code>/\`<code>text_pair</code>) and <code>boxes</code> specified by the user along | |
| with the additional arguments to <a href="/docs/transformers/pr_34652/en/model_doc/layoutlmv3#transformers.LayoutLMv3Tokenizer.__call__"><strong>call</strong>()</a> and returns the output, together with | |
| resized and normalized <code>pixel_values</code>.`,Jo,ro,Ho="Please refer to the docstring of the above two methods for more information.",go,Nt,_o,Et,yo,po,vo;return w=new Fe({props:{title:"LayoutLMv3",local:"layoutlmv3",headingTag:"h1"}}),k=new Fe({props:{title:"Overview",local:"overview",headingTag:"h2"}}),ee=new Fe({props:{title:"Usage tips",local:"usage-tips",headingTag:"h2"}}),Le=new Fe({props:{title:"Resources",local:"resources",headingTag:"h2"}}),Ie=new ut({props:{$$slots:{default:[tn]},$$scope:{ctx:$}}}),V=new Io({props:{pipeline:"text-classification"}}),He=new Io({props:{pipeline:"token-classification"}}),U=new Io({props:{pipeline:"question-answering"}}),X=new Fe({props:{title:"LayoutLMv3Config",local:"transformers.LayoutLMv3Config",headingTag:"h2"}}),P=new B({props:{name:"class transformers.LayoutLMv3Config",anchor:"transformers.LayoutLMv3Config",parameters:[{name:"vocab_size",val:" = 50265"},{name:"hidden_size",val:" = 768"},{name:"num_hidden_layers",val:" = 12"},{name:"num_attention_heads",val:" = 12"},{name:"intermediate_size",val:" = 3072"},{name:"hidden_act",val:" = 'gelu'"},{name:"hidden_dropout_prob",val:" = 0.1"},{name:"attention_probs_dropout_prob",val:" = 0.1"},{name:"max_position_embeddings",val:" = 512"},{name:"type_vocab_size",val:" = 2"},{name:"initializer_range",val:" = 0.02"},{name:"layer_norm_eps",val:" = 1e-05"},{name:"pad_token_id",val:" = 1"},{name:"bos_token_id",val:" = 0"},{name:"eos_token_id",val:" = 2"},{name:"max_2d_position_embeddings",val:" = 1024"},{name:"coordinate_size",val:" = 128"},{name:"shape_size",val:" = 128"},{name:"has_relative_attention_bias",val:" = True"},{name:"rel_pos_bins",val:" = 32"},{name:"max_rel_pos",val:" = 128"},{name:"rel_2d_pos_bins",val:" = 64"},{name:"max_rel_2d_pos",val:" = 256"},{name:"has_spatial_attention_bias",val:" = True"},{name:"text_embed",val:" = True"},{name:"visual_embed",val:" = True"},{name:"input_size",val:" = 224"},{name:"num_channels",val:" = 3"},{name:"patch_size",val:" = 16"},{name:"classifier_dropout",val:" = None"},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"transformers.LayoutLMv3Config.vocab_size",description:`<strong>vocab_size</strong> (<code>int</code>, <em>optional</em>, defaults to 50265) — | |
| Vocabulary size of the LayoutLMv3 model. Defines the number of different tokens that can be represented by | |
| the <code>inputs_ids</code> passed when calling <a href="/docs/transformers/pr_34652/en/model_doc/layoutlmv3#transformers.LayoutLMv3Model">LayoutLMv3Model</a>.`,name:"vocab_size"},{anchor:"transformers.LayoutLMv3Config.hidden_size",description:`<strong>hidden_size</strong> (<code>int</code>, <em>optional</em>, defaults to 768) — | |
| Dimension of the encoder layers and the pooler layer.`,name:"hidden_size"},{anchor:"transformers.LayoutLMv3Config.num_hidden_layers",description:`<strong>num_hidden_layers</strong> (<code>int</code>, <em>optional</em>, defaults to 12) — | |
| Number of hidden layers in the Transformer encoder.`,name:"num_hidden_layers"},{anchor:"transformers.LayoutLMv3Config.num_attention_heads",description:`<strong>num_attention_heads</strong> (<code>int</code>, <em>optional</em>, defaults to 12) — | |
| Number of attention heads for each attention layer in the Transformer encoder.`,name:"num_attention_heads"},{anchor:"transformers.LayoutLMv3Config.intermediate_size",description:`<strong>intermediate_size</strong> (<code>int</code>, <em>optional</em>, defaults to 3072) — | |
| Dimension of the “intermediate” (i.e., feed-forward) layer in the Transformer encoder.`,name:"intermediate_size"},{anchor:"transformers.LayoutLMv3Config.hidden_act",description:`<strong>hidden_act</strong> (<code>str</code> or <code>function</code>, <em>optional</em>, defaults to <code>"gelu"</code>) — | |
| The non-linear activation function (function or string) in the encoder and pooler. If string, <code>"gelu"</code>, | |
| <code>"relu"</code>, <code>"selu"</code> and <code>"gelu_new"</code> are supported.`,name:"hidden_act"},{anchor:"transformers.LayoutLMv3Config.hidden_dropout_prob",description:`<strong>hidden_dropout_prob</strong> (<code>float</code>, <em>optional</em>, defaults to 0.1) — | |
| The dropout probability for all fully connected layers in the embeddings, encoder, and pooler.`,name:"hidden_dropout_prob"},{anchor:"transformers.LayoutLMv3Config.attention_probs_dropout_prob",description:`<strong>attention_probs_dropout_prob</strong> (<code>float</code>, <em>optional</em>, defaults to 0.1) — | |
| The dropout ratio for the attention probabilities.`,name:"attention_probs_dropout_prob"},{anchor:"transformers.LayoutLMv3Config.max_position_embeddings",description:`<strong>max_position_embeddings</strong> (<code>int</code>, <em>optional</em>, defaults to 512) — | |
| 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.LayoutLMv3Config.type_vocab_size",description:`<strong>type_vocab_size</strong> (<code>int</code>, <em>optional</em>, defaults to 2) — | |
| The vocabulary size of the <code>token_type_ids</code> passed when calling <a href="/docs/transformers/pr_34652/en/model_doc/layoutlmv3#transformers.LayoutLMv3Model">LayoutLMv3Model</a>.`,name:"type_vocab_size"},{anchor:"transformers.LayoutLMv3Config.initializer_range",description:`<strong>initializer_range</strong> (<code>float</code>, <em>optional</em>, defaults to 0.02) — | |
| The standard deviation of the truncated_normal_initializer for initializing all weight matrices.`,name:"initializer_range"},{anchor:"transformers.LayoutLMv3Config.layer_norm_eps",description:`<strong>layer_norm_eps</strong> (<code>float</code>, <em>optional</em>, defaults to 1e-5) — | |
| The epsilon used by the layer normalization layers.`,name:"layer_norm_eps"},{anchor:"transformers.LayoutLMv3Config.max_2d_position_embeddings",description:`<strong>max_2d_position_embeddings</strong> (<code>int</code>, <em>optional</em>, defaults to 1024) — | |
| The maximum value that the 2D position embedding might ever be used with. Typically set this to something | |
| large just in case (e.g., 1024).`,name:"max_2d_position_embeddings"},{anchor:"transformers.LayoutLMv3Config.coordinate_size",description:`<strong>coordinate_size</strong> (<code>int</code>, <em>optional</em>, defaults to <code>128</code>) — | |
| Dimension of the coordinate embeddings.`,name:"coordinate_size"},{anchor:"transformers.LayoutLMv3Config.shape_size",description:`<strong>shape_size</strong> (<code>int</code>, <em>optional</em>, defaults to <code>128</code>) — | |
| Dimension of the width and height embeddings.`,name:"shape_size"},{anchor:"transformers.LayoutLMv3Config.has_relative_attention_bias",description:`<strong>has_relative_attention_bias</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>True</code>) — | |
| Whether or not to use a relative attention bias in the self-attention mechanism.`,name:"has_relative_attention_bias"},{anchor:"transformers.LayoutLMv3Config.rel_pos_bins",description:`<strong>rel_pos_bins</strong> (<code>int</code>, <em>optional</em>, defaults to 32) — | |
| The number of relative position bins to be used in the self-attention mechanism.`,name:"rel_pos_bins"},{anchor:"transformers.LayoutLMv3Config.max_rel_pos",description:`<strong>max_rel_pos</strong> (<code>int</code>, <em>optional</em>, defaults to 128) — | |
| The maximum number of relative positions to be used in the self-attention mechanism.`,name:"max_rel_pos"},{anchor:"transformers.LayoutLMv3Config.max_rel_2d_pos",description:`<strong>max_rel_2d_pos</strong> (<code>int</code>, <em>optional</em>, defaults to 256) — | |
| The maximum number of relative 2D positions in the self-attention mechanism.`,name:"max_rel_2d_pos"},{anchor:"transformers.LayoutLMv3Config.rel_2d_pos_bins",description:`<strong>rel_2d_pos_bins</strong> (<code>int</code>, <em>optional</em>, defaults to 64) — | |
| The number of 2D relative position bins in the self-attention mechanism.`,name:"rel_2d_pos_bins"},{anchor:"transformers.LayoutLMv3Config.has_spatial_attention_bias",description:`<strong>has_spatial_attention_bias</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>True</code>) — | |
| Whether or not to use a spatial attention bias in the self-attention mechanism.`,name:"has_spatial_attention_bias"},{anchor:"transformers.LayoutLMv3Config.visual_embed",description:`<strong>visual_embed</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>True</code>) — | |
| Whether or not to add patch embeddings.`,name:"visual_embed"},{anchor:"transformers.LayoutLMv3Config.input_size",description:`<strong>input_size</strong> (<code>int</code>, <em>optional</em>, defaults to <code>224</code>) — | |
| The size (resolution) of the images.`,name:"input_size"},{anchor:"transformers.LayoutLMv3Config.num_channels",description:`<strong>num_channels</strong> (<code>int</code>, <em>optional</em>, defaults to <code>3</code>) — | |
| The number of channels of the images.`,name:"num_channels"},{anchor:"transformers.LayoutLMv3Config.patch_size",description:`<strong>patch_size</strong> (<code>int</code>, <em>optional</em>, defaults to <code>16</code>) — | |
| The size (resolution) of the patches.`,name:"patch_size"},{anchor:"transformers.LayoutLMv3Config.classifier_dropout",description:`<strong>classifier_dropout</strong> (<code>float</code>, <em>optional</em>) — | |
| The dropout ratio for the classification head.`,name:"classifier_dropout"}],source:"https://github.com/huggingface/transformers/blob/vr_34652/src/transformers/models/layoutlmv3/configuration_layoutlmv3.py#L36"}}),ie=new qt({props:{anchor:"transformers.LayoutLMv3Config.example",$$slots:{default:[on]},$$scope:{ctx:$}}}),we=new Fe({props:{title:"LayoutLMv3FeatureExtractor",local:"transformers.LayoutLMv3FeatureExtractor",headingTag:"h2"}}),fe=new B({props:{name:"class transformers.LayoutLMv3FeatureExtractor",anchor:"transformers.LayoutLMv3FeatureExtractor",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],source:"https://github.com/huggingface/transformers/blob/vr_34652/src/transformers/models/layoutlmv3/feature_extraction_layoutlmv3.py#L28"}}),h=new B({props:{name:"__call__",anchor:"transformers.LayoutLMv3FeatureExtractor.__call__",parameters:[{name:"images",val:""},{name:"**kwargs",val:""}],source:"https://github.com/huggingface/transformers/blob/vr_34652/src/transformers/image_processing_utils.py#L39"}}),H=new Fe({props:{title:"LayoutLMv3ImageProcessor",local:"transformers.LayoutLMv3ImageProcessor",headingTag:"h2"}}),Z=new B({props:{name:"class transformers.LayoutLMv3ImageProcessor",anchor:"transformers.LayoutLMv3ImageProcessor",parameters:[{name:"do_resize",val:": bool = True"},{name:"size",val:": typing.Dict[str, int] = None"},{name:"resample",val:": Resampling = <Resampling.BILINEAR: 2>"},{name:"do_rescale",val:": bool = True"},{name:"rescale_value",val:": float = 0.00392156862745098"},{name:"do_normalize",val:": bool = True"},{name:"image_mean",val:": typing.Union[float, typing.Iterable[float]] = None"},{name:"image_std",val:": typing.Union[float, typing.Iterable[float]] = None"},{name:"apply_ocr",val:": bool = True"},{name:"ocr_lang",val:": typing.Optional[str] = None"},{name:"tesseract_config",val:": typing.Optional[str] = ''"},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"transformers.LayoutLMv3ImageProcessor.do_resize",description:`<strong>do_resize</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>True</code>) — | |
| Whether to resize the image’s (height, width) dimensions to <code>(size["height"], size["width"])</code>. Can be | |
| overridden by <code>do_resize</code> in <code>preprocess</code>.`,name:"do_resize"},{anchor:"transformers.LayoutLMv3ImageProcessor.size",description:`<strong>size</strong> (<code>Dict[str, int]</code> <em>optional</em>, defaults to <code>{"height" -- 224, "width": 224}</code>): | |
| Size of the image after resizing. Can be overridden by <code>size</code> in <code>preprocess</code>.`,name:"size"},{anchor:"transformers.LayoutLMv3ImageProcessor.resample",description:`<strong>resample</strong> (<code>PILImageResampling</code>, <em>optional</em>, defaults to <code>PILImageResampling.BILINEAR</code>) — | |
| Resampling filter to use if resizing the image. Can be overridden by <code>resample</code> in <code>preprocess</code>.`,name:"resample"},{anchor:"transformers.LayoutLMv3ImageProcessor.do_rescale",description:`<strong>do_rescale</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>True</code>) — | |
| Whether to rescale the image’s pixel values by the specified <code>rescale_value</code>. Can be overridden by | |
| <code>do_rescale</code> in <code>preprocess</code>.`,name:"do_rescale"},{anchor:"transformers.LayoutLMv3ImageProcessor.rescale_factor",description:`<strong>rescale_factor</strong> (<code>float</code>, <em>optional</em>, defaults to 1 / 255) — | |
| Value by which the image’s pixel values are rescaled. Can be overridden by <code>rescale_factor</code> in | |
| <code>preprocess</code>.`,name:"rescale_factor"},{anchor:"transformers.LayoutLMv3ImageProcessor.do_normalize",description:`<strong>do_normalize</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>True</code>) — | |
| Whether to normalize the image. Can be overridden by the <code>do_normalize</code> parameter in the <code>preprocess</code> | |
| method.`,name:"do_normalize"},{anchor:"transformers.LayoutLMv3ImageProcessor.image_mean",description:`<strong>image_mean</strong> (<code>Iterable[float]</code> or <code>float</code>, <em>optional</em>, defaults to <code>IMAGENET_STANDARD_MEAN</code>) — | |
| Mean to use if normalizing the image. This is a float or list of floats the length of the number of | |
| channels in the image. Can be overridden by the <code>image_mean</code> parameter in the <code>preprocess</code> method.`,name:"image_mean"},{anchor:"transformers.LayoutLMv3ImageProcessor.image_std",description:`<strong>image_std</strong> (<code>Iterable[float]</code> or <code>float</code>, <em>optional</em>, defaults to <code>IMAGENET_STANDARD_STD</code>) — | |
| Standard deviation to use if normalizing the image. This is a float or list of floats the length of the | |
| number of channels in the image. Can be overridden by the <code>image_std</code> parameter in the <code>preprocess</code> method.`,name:"image_std"},{anchor:"transformers.LayoutLMv3ImageProcessor.apply_ocr",description:`<strong>apply_ocr</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>True</code>) — | |
| Whether to apply the Tesseract OCR engine to get words + normalized bounding boxes. Can be overridden by | |
| the <code>apply_ocr</code> parameter in the <code>preprocess</code> method.`,name:"apply_ocr"},{anchor:"transformers.LayoutLMv3ImageProcessor.ocr_lang",description:`<strong>ocr_lang</strong> (<code>str</code>, <em>optional</em>) — | |
| The language, specified by its ISO code, to be used by the Tesseract OCR engine. By default, English is | |
| used. Can be overridden by the <code>ocr_lang</code> parameter in the <code>preprocess</code> method.`,name:"ocr_lang"},{anchor:"transformers.LayoutLMv3ImageProcessor.tesseract_config",description:`<strong>tesseract_config</strong> (<code>str</code>, <em>optional</em>) — | |
| Any additional custom configuration flags that are forwarded to the <code>config</code> parameter when calling | |
| Tesseract. For example: ‘—psm 6’. Can be overridden by the <code>tesseract_config</code> parameter in the | |
| <code>preprocess</code> method.`,name:"tesseract_config"}],source:"https://github.com/huggingface/transformers/blob/vr_34652/src/transformers/models/layoutlmv3/image_processing_layoutlmv3.py#L103"}}),wt=new B({props:{name:"preprocess",anchor:"transformers.LayoutLMv3ImageProcessor.preprocess",parameters:[{name:"images",val:": typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), typing.List[ForwardRef('PIL.Image.Image')], typing.List[numpy.ndarray], typing.List[ForwardRef('torch.Tensor')]]"},{name:"do_resize",val:": bool = None"},{name:"size",val:": typing.Dict[str, int] = None"},{name:"resample",val:" = None"},{name:"do_rescale",val:": bool = None"},{name:"rescale_factor",val:": float = None"},{name:"do_normalize",val:": bool = None"},{name:"image_mean",val:": typing.Union[float, typing.Iterable[float]] = None"},{name:"image_std",val:": typing.Union[float, typing.Iterable[float]] = None"},{name:"apply_ocr",val:": bool = None"},{name:"ocr_lang",val:": typing.Optional[str] = None"},{name:"tesseract_config",val:": typing.Optional[str] = None"},{name:"return_tensors",val:": typing.Union[str, transformers.utils.generic.TensorType, NoneType] = None"},{name:"data_format",val:": ChannelDimension = <ChannelDimension.FIRST: 'channels_first'>"},{name:"input_data_format",val:": typing.Union[str, transformers.image_utils.ChannelDimension, NoneType] = None"}],parametersDescription:[{anchor:"transformers.LayoutLMv3ImageProcessor.preprocess.images",description:`<strong>images</strong> (<code>ImageInput</code>) — | |
| Image to preprocess. Expects a single or batch of images with pixel values ranging from 0 to 255. If | |
| passing in images with pixel values between 0 and 1, set <code>do_rescale=False</code>.`,name:"images"},{anchor:"transformers.LayoutLMv3ImageProcessor.preprocess.do_resize",description:`<strong>do_resize</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>self.do_resize</code>) — | |
| Whether to resize the image.`,name:"do_resize"},{anchor:"transformers.LayoutLMv3ImageProcessor.preprocess.size",description:`<strong>size</strong> (<code>Dict[str, int]</code>, <em>optional</em>, defaults to <code>self.size</code>) — | |
| Desired size of the output image after applying <code>resize</code>.`,name:"size"},{anchor:"transformers.LayoutLMv3ImageProcessor.preprocess.resample",description:`<strong>resample</strong> (<code>int</code>, <em>optional</em>, defaults to <code>self.resample</code>) — | |
| Resampling filter to use if resizing the image. This can be one of the <code>PILImageResampling</code> filters. | |
| Only has an effect if <code>do_resize</code> is set to <code>True</code>.`,name:"resample"},{anchor:"transformers.LayoutLMv3ImageProcessor.preprocess.do_rescale",description:`<strong>do_rescale</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>self.do_rescale</code>) — | |
| Whether to rescale the image pixel values between [0, 1].`,name:"do_rescale"},{anchor:"transformers.LayoutLMv3ImageProcessor.preprocess.rescale_factor",description:`<strong>rescale_factor</strong> (<code>float</code>, <em>optional</em>, defaults to <code>self.rescale_factor</code>) — | |
| Rescale factor to apply to the image pixel values. Only has an effect if <code>do_rescale</code> is set to <code>True</code>.`,name:"rescale_factor"},{anchor:"transformers.LayoutLMv3ImageProcessor.preprocess.do_normalize",description:`<strong>do_normalize</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>self.do_normalize</code>) — | |
| Whether to normalize the image.`,name:"do_normalize"},{anchor:"transformers.LayoutLMv3ImageProcessor.preprocess.image_mean",description:`<strong>image_mean</strong> (<code>float</code> or <code>Iterable[float]</code>, <em>optional</em>, defaults to <code>self.image_mean</code>) — | |
| Mean values to be used for normalization. Only has an effect if <code>do_normalize</code> is set to <code>True</code>.`,name:"image_mean"},{anchor:"transformers.LayoutLMv3ImageProcessor.preprocess.image_std",description:`<strong>image_std</strong> (<code>float</code> or <code>Iterable[float]</code>, <em>optional</em>, defaults to <code>self.image_std</code>) — | |
| Standard deviation values to be used for normalization. Only has an effect if <code>do_normalize</code> is set to | |
| <code>True</code>.`,name:"image_std"},{anchor:"transformers.LayoutLMv3ImageProcessor.preprocess.apply_ocr",description:`<strong>apply_ocr</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>self.apply_ocr</code>) — | |
| Whether to apply the Tesseract OCR engine to get words + normalized bounding boxes.`,name:"apply_ocr"},{anchor:"transformers.LayoutLMv3ImageProcessor.preprocess.ocr_lang",description:`<strong>ocr_lang</strong> (<code>str</code>, <em>optional</em>, defaults to <code>self.ocr_lang</code>) — | |
| The language, specified by its ISO code, to be used by the Tesseract OCR engine. By default, English is | |
| used.`,name:"ocr_lang"},{anchor:"transformers.LayoutLMv3ImageProcessor.preprocess.tesseract_config",description:`<strong>tesseract_config</strong> (<code>str</code>, <em>optional</em>, defaults to <code>self.tesseract_config</code>) — | |
| Any additional custom configuration flags that are forwarded to the <code>config</code> parameter when calling | |
| Tesseract.`,name:"tesseract_config"},{anchor:"transformers.LayoutLMv3ImageProcessor.preprocess.return_tensors",description:`<strong>return_tensors</strong> (<code>str</code> or <code>TensorType</code>, <em>optional</em>) — | |
| The type of tensors to return. Can be one of:<ul> | |
| <li>Unset: Return a list of <code>np.ndarray</code>.</li> | |
| <li><code>TensorType.TENSORFLOW</code> or <code>'tf'</code>: Return a batch of type <code>tf.Tensor</code>.</li> | |
| <li><code>TensorType.PYTORCH</code> or <code>'pt'</code>: Return a batch of type <code>torch.Tensor</code>.</li> | |
| <li><code>TensorType.NUMPY</code> or <code>'np'</code>: Return a batch of type <code>np.ndarray</code>.</li> | |
| <li><code>TensorType.JAX</code> or <code>'jax'</code>: Return a batch of type <code>jax.numpy.ndarray</code>.</li> | |
| </ul>`,name:"return_tensors"},{anchor:"transformers.LayoutLMv3ImageProcessor.preprocess.data_format",description:`<strong>data_format</strong> (<code>ChannelDimension</code> or <code>str</code>, <em>optional</em>, defaults to <code>ChannelDimension.FIRST</code>) — | |
| The channel dimension format for the output image. Can be one of:<ul> | |
| <li><code>ChannelDimension.FIRST</code>: image in (num_channels, height, width) format.</li> | |
| <li><code>ChannelDimension.LAST</code>: image in (height, width, num_channels) format.</li> | |
| </ul>`,name:"data_format"},{anchor:"transformers.LayoutLMv3ImageProcessor.preprocess.input_data_format",description:`<strong>input_data_format</strong> (<code>ChannelDimension</code> or <code>str</code>, <em>optional</em>) — | |
| The channel dimension format for the input image. If unset, the channel dimension format is inferred | |
| from the input image. Can be one of:<ul> | |
| <li><code>"channels_first"</code> or <code>ChannelDimension.FIRST</code>: image in (num_channels, height, width) format.</li> | |
| <li><code>"channels_last"</code> or <code>ChannelDimension.LAST</code>: image in (height, width, num_channels) format.</li> | |
| <li><code>"none"</code> or <code>ChannelDimension.NONE</code>: image in (height, width) format.</li> | |
| </ul>`,name:"input_data_format"}],source:"https://github.com/huggingface/transformers/blob/vr_34652/src/transformers/models/layoutlmv3/image_processing_layoutlmv3.py#L224"}}),gt=new Fe({props:{title:"LayoutLMv3Tokenizer",local:"transformers.LayoutLMv3Tokenizer",headingTag:"h2"}}),ye=new B({props:{name:"class transformers.LayoutLMv3Tokenizer",anchor:"transformers.LayoutLMv3Tokenizer",parameters:[{name:"vocab_file",val:""},{name:"merges_file",val:""},{name:"errors",val:" = 'replace'"},{name:"bos_token",val:" = '<s>'"},{name:"eos_token",val:" = '</s>'"},{name:"sep_token",val:" = '</s>'"},{name:"cls_token",val:" = '<s>'"},{name:"unk_token",val:" = '<unk>'"},{name:"pad_token",val:" = '<pad>'"},{name:"mask_token",val:" = '<mask>'"},{name:"add_prefix_space",val:" = True"},{name:"cls_token_box",val:" = [0, 0, 0, 0]"},{name:"sep_token_box",val:" = [0, 0, 0, 0]"},{name:"pad_token_box",val:" = [0, 0, 0, 0]"},{name:"pad_token_label",val:" = -100"},{name:"only_label_first_subword",val:" = True"},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"transformers.LayoutLMv3Tokenizer.vocab_file",description:`<strong>vocab_file</strong> (<code>str</code>) — | |
| Path to the vocabulary file.`,name:"vocab_file"},{anchor:"transformers.LayoutLMv3Tokenizer.merges_file",description:`<strong>merges_file</strong> (<code>str</code>) — | |
| Path to the merges file.`,name:"merges_file"},{anchor:"transformers.LayoutLMv3Tokenizer.errors",description:`<strong>errors</strong> (<code>str</code>, <em>optional</em>, defaults to <code>"replace"</code>) — | |
| Paradigm to follow when decoding bytes to UTF-8. See | |
| <a href="https://docs.python.org/3/library/stdtypes.html#bytes.decode" rel="nofollow">bytes.decode</a> for more information.`,name:"errors"},{anchor:"transformers.LayoutLMv3Tokenizer.bos_token",description:`<strong>bos_token</strong> (<code>str</code>, <em>optional</em>, defaults to <code>"<s>"</code>) — | |
| The beginning of sequence token that was used during pretraining. Can be used a sequence classifier token.</p> | |
| <div class="course-tip bg-gradient-to-br dark:bg-gradient-to-r before:border-green-500 dark:before:border-green-800 from-green-50 dark:from-gray-900 to-white dark:to-gray-950 border border-green-50 text-green-700 dark:text-gray-400"> | |
| <p>When building a sequence using special tokens, this is not the token that is used for the beginning of | |
| sequence. The token used is the <code>cls_token</code>.</p> | |
| </div>`,name:"bos_token"},{anchor:"transformers.LayoutLMv3Tokenizer.eos_token",description:`<strong>eos_token</strong> (<code>str</code>, <em>optional</em>, defaults to <code>"</s>"</code>) — | |
| The end of sequence token.</p> | |
| <div class="course-tip bg-gradient-to-br dark:bg-gradient-to-r before:border-green-500 dark:before:border-green-800 from-green-50 dark:from-gray-900 to-white dark:to-gray-950 border border-green-50 text-green-700 dark:text-gray-400"> | |
| <p>When building a sequence using special tokens, this is not the token that is used for the end of sequence. | |
| The token used is the <code>sep_token</code>.</p> | |
| </div>`,name:"eos_token"},{anchor:"transformers.LayoutLMv3Tokenizer.sep_token",description:`<strong>sep_token</strong> (<code>str</code>, <em>optional</em>, defaults to <code>"</s>"</code>) — | |
| 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.LayoutLMv3Tokenizer.cls_token",description:`<strong>cls_token</strong> (<code>str</code>, <em>optional</em>, defaults to <code>"<s>"</code>) — | |
| 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.LayoutLMv3Tokenizer.unk_token",description:`<strong>unk_token</strong> (<code>str</code>, <em>optional</em>, defaults to <code>"<unk>"</code>) — | |
| 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.LayoutLMv3Tokenizer.pad_token",description:`<strong>pad_token</strong> (<code>str</code>, <em>optional</em>, defaults to <code>"<pad>"</code>) — | |
| The token used for padding, for example when batching sequences of different lengths.`,name:"pad_token"},{anchor:"transformers.LayoutLMv3Tokenizer.mask_token",description:`<strong>mask_token</strong> (<code>str</code>, <em>optional</em>, defaults to <code>"<mask>"</code>) — | |
| 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.LayoutLMv3Tokenizer.add_prefix_space",description:`<strong>add_prefix_space</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>True</code>) — | |
| Whether or not to add an initial space to the input. This allows to treat the leading word just as any | |
| other word. (RoBERTa tokenizer detect beginning of words by the preceding space).`,name:"add_prefix_space"},{anchor:"transformers.LayoutLMv3Tokenizer.cls_token_box",description:`<strong>cls_token_box</strong> (<code>List[int]</code>, <em>optional</em>, defaults to <code>[0, 0, 0, 0]</code>) — | |
| The bounding box to use for the special [CLS] token.`,name:"cls_token_box"},{anchor:"transformers.LayoutLMv3Tokenizer.sep_token_box",description:`<strong>sep_token_box</strong> (<code>List[int]</code>, <em>optional</em>, defaults to <code>[0, 0, 0, 0]</code>) — | |
| The bounding box to use for the special [SEP] token.`,name:"sep_token_box"},{anchor:"transformers.LayoutLMv3Tokenizer.pad_token_box",description:`<strong>pad_token_box</strong> (<code>List[int]</code>, <em>optional</em>, defaults to <code>[0, 0, 0, 0]</code>) — | |
| The bounding box to use for the special [PAD] token.`,name:"pad_token_box"},{anchor:"transformers.LayoutLMv3Tokenizer.pad_token_label",description:`<strong>pad_token_label</strong> (<code>int</code>, <em>optional</em>, defaults to -100) — | |
| The label to use for padding tokens. Defaults to -100, which is the <code>ignore_index</code> of PyTorch’s | |
| CrossEntropyLoss.`,name:"pad_token_label"},{anchor:"transformers.LayoutLMv3Tokenizer.only_label_first_subword",description:`<strong>only_label_first_subword</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>True</code>) — | |
| Whether or not to only label the first subword, in case word labels are provided.`,name:"only_label_first_subword"}],source:"https://github.com/huggingface/transformers/blob/vr_34652/src/transformers/models/layoutlmv3/tokenization_layoutlmv3.py#L184"}}),Rt=new B({props:{name:"__call__",anchor:"transformers.LayoutLMv3Tokenizer.__call__",parameters:[{name:"text",val:": typing.Union[str, typing.List[str], typing.List[typing.List[str]]]"},{name:"text_pair",val:": typing.Union[typing.List[str], typing.List[typing.List[str]], NoneType] = None"},{name:"boxes",val:": typing.Union[typing.List[typing.List[int]], typing.List[typing.List[typing.List[int]]]] = None"},{name:"word_labels",val:": typing.Union[typing.List[int], typing.List[typing.List[int]], NoneType] = None"},{name:"add_special_tokens",val:": bool = True"},{name:"padding",val:": typing.Union[bool, str, transformers.utils.generic.PaddingStrategy] = False"},{name:"truncation",val:": typing.Union[bool, str, transformers.tokenization_utils_base.TruncationStrategy] = None"},{name:"max_length",val:": typing.Optional[int] = None"},{name:"stride",val:": int = 0"},{name:"pad_to_multiple_of",val:": typing.Optional[int] = None"},{name:"padding_side",val:": typing.Optional[bool] = None"},{name:"return_tensors",val:": typing.Union[str, transformers.utils.generic.TensorType, NoneType] = None"},{name:"return_token_type_ids",val:": typing.Optional[bool] = None"},{name:"return_attention_mask",val:": typing.Optional[bool] = None"},{name:"return_overflowing_tokens",val:": bool = False"},{name:"return_special_tokens_mask",val:": bool = False"},{name:"return_offsets_mapping",val:": bool = False"},{name:"return_length",val:": bool = False"},{name:"verbose",val:": bool = True"},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"transformers.LayoutLMv3Tokenizer.__call__.text",description:`<strong>text</strong> (<code>str</code>, <code>List[str]</code>, <code>List[List[str]]</code>) — | |
| The sequence or batch of sequences to be encoded. Each sequence can be a string, a list of strings | |
| (words of a single example or questions of a batch of examples) or a list of list of strings (batch of | |
| words).`,name:"text"},{anchor:"transformers.LayoutLMv3Tokenizer.__call__.text_pair",description:`<strong>text_pair</strong> (<code>List[str]</code>, <code>List[List[str]]</code>) — | |
| The sequence or batch of sequences to be encoded. Each sequence should be a list of strings | |
| (pretokenized string).`,name:"text_pair"},{anchor:"transformers.LayoutLMv3Tokenizer.__call__.boxes",description:`<strong>boxes</strong> (<code>List[List[int]]</code>, <code>List[List[List[int]]]</code>) — | |
| Word-level bounding boxes. Each bounding box should be normalized to be on a 0-1000 scale.`,name:"boxes"},{anchor:"transformers.LayoutLMv3Tokenizer.__call__.word_labels",description:`<strong>word_labels</strong> (<code>List[int]</code>, <code>List[List[int]]</code>, <em>optional</em>) — | |
| Word-level integer labels (for token classification tasks such as FUNSD, CORD).`,name:"word_labels"},{anchor:"transformers.LayoutLMv3Tokenizer.__call__.add_special_tokens",description:`<strong>add_special_tokens</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>True</code>) — | |
| Whether or not to encode the sequences with the special tokens relative to their model.`,name:"add_special_tokens"},{anchor:"transformers.LayoutLMv3Tokenizer.__call__.padding",description:`<strong>padding</strong> (<code>bool</code>, <code>str</code> or <a href="/docs/transformers/pr_34652/en/internal/file_utils#transformers.utils.PaddingStrategy">PaddingStrategy</a>, <em>optional</em>, defaults to <code>False</code>) — | |
| Activates and controls padding. Accepts the following values:</p> | |
| <ul> | |
| <li><code>True</code> or <code>'longest'</code>: Pad to the longest sequence in the batch (or no padding if only a single | |
| sequence if provided).</li> | |
| <li><code>'max_length'</code>: Pad to a maximum length specified with the argument <code>max_length</code> or to the maximum | |
| acceptable input length for the model if that argument is not provided.</li> | |
| <li><code>False</code> or <code>'do_not_pad'</code> (default): No padding (i.e., can output a batch with sequences of different | |
| lengths).</li> | |
| </ul>`,name:"padding"},{anchor:"transformers.LayoutLMv3Tokenizer.__call__.truncation",description:`<strong>truncation</strong> (<code>bool</code>, <code>str</code> or <a href="/docs/transformers/pr_34652/en/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy">TruncationStrategy</a>, <em>optional</em>, defaults to <code>False</code>) — | |
| Activates and controls truncation. Accepts the following values:</p> | |
| <ul> | |
| <li><code>True</code> or <code>'longest_first'</code>: Truncate to a maximum length specified with the argument <code>max_length</code> or | |
| to the maximum acceptable input length for the model if that argument is not provided. This will | |
| truncate token by token, removing a token from the longest sequence in the pair if a pair of | |
| sequences (or a batch of pairs) is provided.</li> | |
| <li><code>'only_first'</code>: Truncate to a maximum length specified with the argument <code>max_length</code> or to the | |
| maximum acceptable input length for the model if that argument is not provided. This will only | |
| truncate the first sequence of a pair if a pair of sequences (or a batch of pairs) is provided.</li> | |
| <li><code>'only_second'</code>: Truncate to a maximum length specified with the argument <code>max_length</code> or to the | |
| maximum acceptable input length for the model if that argument is not provided. This will only | |
| truncate the second sequence of a pair if a pair of sequences (or a batch of pairs) is provided.</li> | |
| <li><code>False</code> or <code>'do_not_truncate'</code> (default): No truncation (i.e., can output batch with sequence lengths | |
| greater than the model maximum admissible input size).</li> | |
| </ul>`,name:"truncation"},{anchor:"transformers.LayoutLMv3Tokenizer.__call__.max_length",description:`<strong>max_length</strong> (<code>int</code>, <em>optional</em>) — | |
| Controls the maximum length to use by one of the truncation/padding parameters.</p> | |
| <p>If left unset or set to <code>None</code>, this will use the predefined model maximum length if a maximum length | |
| is required by one of the truncation/padding parameters. If the model has no specific maximum input | |
| length (like XLNet) truncation/padding to a maximum length will be deactivated.`,name:"max_length"},{anchor:"transformers.LayoutLMv3Tokenizer.__call__.stride",description:`<strong>stride</strong> (<code>int</code>, <em>optional</em>, defaults to 0) — | |
| If set to a number along with <code>max_length</code>, the overflowing tokens returned when | |
| <code>return_overflowing_tokens=True</code> will contain some tokens from the end of the truncated sequence | |
| returned to provide some overlap between truncated and overflowing sequences. The value of this | |
| argument defines the number of overlapping tokens.`,name:"stride"},{anchor:"transformers.LayoutLMv3Tokenizer.__call__.pad_to_multiple_of",description:`<strong>pad_to_multiple_of</strong> (<code>int</code>, <em>optional</em>) — | |
| If set will pad the sequence to a multiple of the provided value. This is especially useful to enable | |
| the use of Tensor Cores on NVIDIA hardware with compute capability <code>>= 7.5</code> (Volta).`,name:"pad_to_multiple_of"},{anchor:"transformers.LayoutLMv3Tokenizer.__call__.return_tensors",description:`<strong>return_tensors</strong> (<code>str</code> or <a href="/docs/transformers/pr_34652/en/internal/file_utils#transformers.TensorType">TensorType</a>, <em>optional</em>) — | |
| If set, will return tensors instead of list of python integers. Acceptable values are:</p> | |
| <ul> | |
| <li><code>'tf'</code>: Return TensorFlow <code>tf.constant</code> objects.</li> | |
| <li><code>'pt'</code>: Return PyTorch <code>torch.Tensor</code> objects.</li> | |
| <li><code>'np'</code>: Return Numpy <code>np.ndarray</code> objects.</li> | |
| </ul>`,name:"return_tensors"},{anchor:"transformers.LayoutLMv3Tokenizer.__call__.add_special_tokens",description:`<strong>add_special_tokens</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>True</code>) — | |
| Whether or not to encode the sequences with the special tokens relative to their model.`,name:"add_special_tokens"},{anchor:"transformers.LayoutLMv3Tokenizer.__call__.padding",description:`<strong>padding</strong> (<code>bool</code>, <code>str</code> or <a href="/docs/transformers/pr_34652/en/internal/file_utils#transformers.utils.PaddingStrategy">PaddingStrategy</a>, <em>optional</em>, defaults to <code>False</code>) — | |
| Activates and controls padding. Accepts the following values:</p> | |
| <ul> | |
| <li><code>True</code> or <code>'longest'</code>: Pad to the longest sequence in the batch (or no padding if only a single | |
| sequence if provided).</li> | |
| <li><code>'max_length'</code>: Pad to a maximum length specified with the argument <code>max_length</code> or to the maximum | |
| acceptable input length for the model if that argument is not provided.</li> | |
| <li><code>False</code> or <code>'do_not_pad'</code> (default): No padding (i.e., can output a batch with sequences of different | |
| lengths).</li> | |
| </ul>`,name:"padding"},{anchor:"transformers.LayoutLMv3Tokenizer.__call__.truncation",description:`<strong>truncation</strong> (<code>bool</code>, <code>str</code> or <a href="/docs/transformers/pr_34652/en/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy">TruncationStrategy</a>, <em>optional</em>, defaults to <code>False</code>) — | |
| Activates and controls truncation. Accepts the following values:</p> | |
| <ul> | |
| <li><code>True</code> or <code>'longest_first'</code>: Truncate to a maximum length specified with the argument <code>max_length</code> or | |
| to the maximum acceptable input length for the model if that argument is not provided. This will | |
| truncate token by token, removing a token from the longest sequence in the pair if a pair of | |
| sequences (or a batch of pairs) is provided.</li> | |
| <li><code>'only_first'</code>: Truncate to a maximum length specified with the argument <code>max_length</code> or to the | |
| maximum acceptable input length for the model if that argument is not provided. This will only | |
| truncate the first sequence of a pair if a pair of sequences (or a batch of pairs) is provided.</li> | |
| <li><code>'only_second'</code>: Truncate to a maximum length specified with the argument <code>max_length</code> or to the | |
| maximum acceptable input length for the model if that argument is not provided. This will only | |
| truncate the second sequence of a pair if a pair of sequences (or a batch of pairs) is provided.</li> | |
| <li><code>False</code> or <code>'do_not_truncate'</code> (default): No truncation (i.e., can output batch with sequence lengths | |
| greater than the model maximum admissible input size).</li> | |
| </ul>`,name:"truncation"},{anchor:"transformers.LayoutLMv3Tokenizer.__call__.max_length",description:`<strong>max_length</strong> (<code>int</code>, <em>optional</em>) — | |
| Controls the maximum length to use by one of the truncation/padding parameters. If left unset or set to | |
| <code>None</code>, this will use the predefined model maximum length if a maximum length is required by one of the | |
| truncation/padding parameters. If the model has no specific maximum input length (like XLNet) | |
| truncation/padding to a maximum length will be deactivated.`,name:"max_length"},{anchor:"transformers.LayoutLMv3Tokenizer.__call__.stride",description:`<strong>stride</strong> (<code>int</code>, <em>optional</em>, defaults to 0) — | |
| If set to a number along with <code>max_length</code>, the overflowing tokens returned when | |
| <code>return_overflowing_tokens=True</code> will contain some tokens from the end of the truncated sequence | |
| returned to provide some overlap between truncated and overflowing sequences. The value of this | |
| argument defines the number of overlapping tokens.`,name:"stride"},{anchor:"transformers.LayoutLMv3Tokenizer.__call__.pad_to_multiple_of",description:`<strong>pad_to_multiple_of</strong> (<code>int</code>, <em>optional</em>) — | |
| If set will pad the sequence to a multiple of the provided value. This is especially useful to enable | |
| the use of Tensor Cores on NVIDIA hardware with compute capability <code>>= 7.5</code> (Volta).`,name:"pad_to_multiple_of"},{anchor:"transformers.LayoutLMv3Tokenizer.__call__.return_tensors",description:`<strong>return_tensors</strong> (<code>str</code> or <a href="/docs/transformers/pr_34652/en/internal/file_utils#transformers.TensorType">TensorType</a>, <em>optional</em>) — | |
| If set, will return tensors instead of list of python integers. Acceptable values are:</p> | |
| <ul> | |
| <li><code>'tf'</code>: Return TensorFlow <code>tf.constant</code> objects.</li> | |
| <li><code>'pt'</code>: Return PyTorch <code>torch.Tensor</code> objects.</li> | |
| <li><code>'np'</code>: Return Numpy <code>np.ndarray</code> objects.</li> | |
| </ul>`,name:"return_tensors"}],source:"https://github.com/huggingface/transformers/blob/vr_34652/src/transformers/models/layoutlmv3/tokenization_layoutlmv3.py#L532"}}),Wt=new B({props:{name:"save_vocabulary",anchor:"transformers.LayoutLMv3Tokenizer.save_vocabulary",parameters:[{name:"save_directory",val:": str"},{name:"filename_prefix",val:": typing.Optional[str] = None"}],source:"https://github.com/huggingface/transformers/blob/vr_34652/src/transformers/models/layoutlmv3/tokenization_layoutlmv3.py#L413"}}),Zt=new Fe({props:{title:"LayoutLMv3TokenizerFast",local:"transformers.LayoutLMv3TokenizerFast",headingTag:"h2"}}),Bt=new B({props:{name:"class transformers.LayoutLMv3TokenizerFast",anchor:"transformers.LayoutLMv3TokenizerFast",parameters:[{name:"vocab_file",val:" = None"},{name:"merges_file",val:" = None"},{name:"tokenizer_file",val:" = None"},{name:"errors",val:" = 'replace'"},{name:"bos_token",val:" = '<s>'"},{name:"eos_token",val:" = '</s>'"},{name:"sep_token",val:" = '</s>'"},{name:"cls_token",val:" = '<s>'"},{name:"unk_token",val:" = '<unk>'"},{name:"pad_token",val:" = '<pad>'"},{name:"mask_token",val:" = '<mask>'"},{name:"add_prefix_space",val:" = True"},{name:"trim_offsets",val:" = True"},{name:"cls_token_box",val:" = [0, 0, 0, 0]"},{name:"sep_token_box",val:" = [0, 0, 0, 0]"},{name:"pad_token_box",val:" = [0, 0, 0, 0]"},{name:"pad_token_label",val:" = -100"},{name:"only_label_first_subword",val:" = True"},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"transformers.LayoutLMv3TokenizerFast.vocab_file",description:`<strong>vocab_file</strong> (<code>str</code>) — | |
| Path to the vocabulary file.`,name:"vocab_file"},{anchor:"transformers.LayoutLMv3TokenizerFast.merges_file",description:`<strong>merges_file</strong> (<code>str</code>) — | |
| Path to the merges file.`,name:"merges_file"},{anchor:"transformers.LayoutLMv3TokenizerFast.errors",description:`<strong>errors</strong> (<code>str</code>, <em>optional</em>, defaults to <code>"replace"</code>) — | |
| Paradigm to follow when decoding bytes to UTF-8. See | |
| <a href="https://docs.python.org/3/library/stdtypes.html#bytes.decode" rel="nofollow">bytes.decode</a> for more information.`,name:"errors"},{anchor:"transformers.LayoutLMv3TokenizerFast.bos_token",description:`<strong>bos_token</strong> (<code>str</code>, <em>optional</em>, defaults to <code>"<s>"</code>) — | |
| The beginning of sequence token that was used during pretraining. Can be used a sequence classifier token.</p> | |
| <div class="course-tip bg-gradient-to-br dark:bg-gradient-to-r before:border-green-500 dark:before:border-green-800 from-green-50 dark:from-gray-900 to-white dark:to-gray-950 border border-green-50 text-green-700 dark:text-gray-400"> | |
| <p>When building a sequence using special tokens, this is not the token that is used for the beginning of | |
| sequence. The token used is the <code>cls_token</code>.</p> | |
| </div>`,name:"bos_token"},{anchor:"transformers.LayoutLMv3TokenizerFast.eos_token",description:`<strong>eos_token</strong> (<code>str</code>, <em>optional</em>, defaults to <code>"</s>"</code>) — | |
| The end of sequence token.</p> | |
| <div class="course-tip bg-gradient-to-br dark:bg-gradient-to-r before:border-green-500 dark:before:border-green-800 from-green-50 dark:from-gray-900 to-white dark:to-gray-950 border border-green-50 text-green-700 dark:text-gray-400"> | |
| <p>When building a sequence using special tokens, this is not the token that is used for the end of sequence. | |
| The token used is the <code>sep_token</code>.</p> | |
| </div>`,name:"eos_token"},{anchor:"transformers.LayoutLMv3TokenizerFast.sep_token",description:`<strong>sep_token</strong> (<code>str</code>, <em>optional</em>, defaults to <code>"</s>"</code>) — | |
| 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.LayoutLMv3TokenizerFast.cls_token",description:`<strong>cls_token</strong> (<code>str</code>, <em>optional</em>, defaults to <code>"<s>"</code>) — | |
| 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.LayoutLMv3TokenizerFast.unk_token",description:`<strong>unk_token</strong> (<code>str</code>, <em>optional</em>, defaults to <code>"<unk>"</code>) — | |
| 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.LayoutLMv3TokenizerFast.pad_token",description:`<strong>pad_token</strong> (<code>str</code>, <em>optional</em>, defaults to <code>"<pad>"</code>) — | |
| The token used for padding, for example when batching sequences of different lengths.`,name:"pad_token"},{anchor:"transformers.LayoutLMv3TokenizerFast.mask_token",description:`<strong>mask_token</strong> (<code>str</code>, <em>optional</em>, defaults to <code>"<mask>"</code>) — | |
| 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.LayoutLMv3TokenizerFast.add_prefix_space",description:`<strong>add_prefix_space</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>False</code>) — | |
| Whether or not to add an initial space to the input. This allows to treat the leading word just as any | |
| other word. (RoBERTa tokenizer detect beginning of words by the preceding space).`,name:"add_prefix_space"},{anchor:"transformers.LayoutLMv3TokenizerFast.trim_offsets",description:`<strong>trim_offsets</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>True</code>) — | |
| Whether the post processing step should trim offsets to avoid including whitespaces.`,name:"trim_offsets"},{anchor:"transformers.LayoutLMv3TokenizerFast.cls_token_box",description:`<strong>cls_token_box</strong> (<code>List[int]</code>, <em>optional</em>, defaults to <code>[0, 0, 0, 0]</code>) — | |
| The bounding box to use for the special [CLS] token.`,name:"cls_token_box"},{anchor:"transformers.LayoutLMv3TokenizerFast.sep_token_box",description:`<strong>sep_token_box</strong> (<code>List[int]</code>, <em>optional</em>, defaults to <code>[0, 0, 0, 0]</code>) — | |
| The bounding box to use for the special [SEP] token.`,name:"sep_token_box"},{anchor:"transformers.LayoutLMv3TokenizerFast.pad_token_box",description:`<strong>pad_token_box</strong> (<code>List[int]</code>, <em>optional</em>, defaults to <code>[0, 0, 0, 0]</code>) — | |
| The bounding box to use for the special [PAD] token.`,name:"pad_token_box"},{anchor:"transformers.LayoutLMv3TokenizerFast.pad_token_label",description:`<strong>pad_token_label</strong> (<code>int</code>, <em>optional</em>, defaults to -100) — | |
| The label to use for padding tokens. Defaults to -100, which is the <code>ignore_index</code> of PyTorch’s | |
| CrossEntropyLoss.`,name:"pad_token_label"},{anchor:"transformers.LayoutLMv3TokenizerFast.only_label_first_subword",description:`<strong>only_label_first_subword</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>True</code>) — | |
| Whether or not to only label the first subword, in case word labels are provided.`,name:"only_label_first_subword"}],source:"https://github.com/huggingface/transformers/blob/vr_34652/src/transformers/models/layoutlmv3/tokenization_layoutlmv3_fast.py#L49"}}),Pt=new B({props:{name:"__call__",anchor:"transformers.LayoutLMv3TokenizerFast.__call__",parameters:[{name:"text",val:": typing.Union[str, typing.List[str], typing.List[typing.List[str]]]"},{name:"text_pair",val:": typing.Union[typing.List[str], typing.List[typing.List[str]], NoneType] = None"},{name:"boxes",val:": typing.Union[typing.List[typing.List[int]], typing.List[typing.List[typing.List[int]]]] = None"},{name:"word_labels",val:": typing.Union[typing.List[int], typing.List[typing.List[int]], NoneType] = None"},{name:"add_special_tokens",val:": bool = True"},{name:"padding",val:": typing.Union[bool, str, transformers.utils.generic.PaddingStrategy] = False"},{name:"truncation",val:": typing.Union[bool, str, transformers.tokenization_utils_base.TruncationStrategy] = None"},{name:"max_length",val:": typing.Optional[int] = None"},{name:"stride",val:": int = 0"},{name:"pad_to_multiple_of",val:": typing.Optional[int] = None"},{name:"padding_side",val:": typing.Optional[bool] = None"},{name:"return_tensors",val:": typing.Union[str, transformers.utils.generic.TensorType, NoneType] = None"},{name:"return_token_type_ids",val:": typing.Optional[bool] = None"},{name:"return_attention_mask",val:": typing.Optional[bool] = None"},{name:"return_overflowing_tokens",val:": bool = False"},{name:"return_special_tokens_mask",val:": bool = False"},{name:"return_offsets_mapping",val:": bool = False"},{name:"return_length",val:": bool = False"},{name:"verbose",val:": bool = True"},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"transformers.LayoutLMv3TokenizerFast.__call__.text",description:`<strong>text</strong> (<code>str</code>, <code>List[str]</code>, <code>List[List[str]]</code>) — | |
| The sequence or batch of sequences to be encoded. Each sequence can be a string, a list of strings | |
| (words of a single example or questions of a batch of examples) or a list of list of strings (batch of | |
| words).`,name:"text"},{anchor:"transformers.LayoutLMv3TokenizerFast.__call__.text_pair",description:`<strong>text_pair</strong> (<code>List[str]</code>, <code>List[List[str]]</code>) — | |
| The sequence or batch of sequences to be encoded. Each sequence should be a list of strings | |
| (pretokenized string).`,name:"text_pair"},{anchor:"transformers.LayoutLMv3TokenizerFast.__call__.boxes",description:`<strong>boxes</strong> (<code>List[List[int]]</code>, <code>List[List[List[int]]]</code>) — | |
| Word-level bounding boxes. Each bounding box should be normalized to be on a 0-1000 scale.`,name:"boxes"},{anchor:"transformers.LayoutLMv3TokenizerFast.__call__.word_labels",description:`<strong>word_labels</strong> (<code>List[int]</code>, <code>List[List[int]]</code>, <em>optional</em>) — | |
| Word-level integer labels (for token classification tasks such as FUNSD, CORD).`,name:"word_labels"},{anchor:"transformers.LayoutLMv3TokenizerFast.__call__.add_special_tokens",description:`<strong>add_special_tokens</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>True</code>) — | |
| Whether or not to encode the sequences with the special tokens relative to their model.`,name:"add_special_tokens"},{anchor:"transformers.LayoutLMv3TokenizerFast.__call__.padding",description:`<strong>padding</strong> (<code>bool</code>, <code>str</code> or <a href="/docs/transformers/pr_34652/en/internal/file_utils#transformers.utils.PaddingStrategy">PaddingStrategy</a>, <em>optional</em>, defaults to <code>False</code>) — | |
| Activates and controls padding. Accepts the following values:</p> | |
| <ul> | |
| <li><code>True</code> or <code>'longest'</code>: Pad to the longest sequence in the batch (or no padding if only a single | |
| sequence if provided).</li> | |
| <li><code>'max_length'</code>: Pad to a maximum length specified with the argument <code>max_length</code> or to the maximum | |
| acceptable input length for the model if that argument is not provided.</li> | |
| <li><code>False</code> or <code>'do_not_pad'</code> (default): No padding (i.e., can output a batch with sequences of different | |
| lengths).</li> | |
| </ul>`,name:"padding"},{anchor:"transformers.LayoutLMv3TokenizerFast.__call__.truncation",description:`<strong>truncation</strong> (<code>bool</code>, <code>str</code> or <a href="/docs/transformers/pr_34652/en/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy">TruncationStrategy</a>, <em>optional</em>, defaults to <code>False</code>) — | |
| Activates and controls truncation. Accepts the following values:</p> | |
| <ul> | |
| <li><code>True</code> or <code>'longest_first'</code>: Truncate to a maximum length specified with the argument <code>max_length</code> or | |
| to the maximum acceptable input length for the model if that argument is not provided. This will | |
| truncate token by token, removing a token from the longest sequence in the pair if a pair of | |
| sequences (or a batch of pairs) is provided.</li> | |
| <li><code>'only_first'</code>: Truncate to a maximum length specified with the argument <code>max_length</code> or to the | |
| maximum acceptable input length for the model if that argument is not provided. This will only | |
| truncate the first sequence of a pair if a pair of sequences (or a batch of pairs) is provided.</li> | |
| <li><code>'only_second'</code>: Truncate to a maximum length specified with the argument <code>max_length</code> or to the | |
| maximum acceptable input length for the model if that argument is not provided. This will only | |
| truncate the second sequence of a pair if a pair of sequences (or a batch of pairs) is provided.</li> | |
| <li><code>False</code> or <code>'do_not_truncate'</code> (default): No truncation (i.e., can output batch with sequence lengths | |
| greater than the model maximum admissible input size).</li> | |
| </ul>`,name:"truncation"},{anchor:"transformers.LayoutLMv3TokenizerFast.__call__.max_length",description:`<strong>max_length</strong> (<code>int</code>, <em>optional</em>) — | |
| Controls the maximum length to use by one of the truncation/padding parameters.</p> | |
| <p>If left unset or set to <code>None</code>, this will use the predefined model maximum length if a maximum length | |
| is required by one of the truncation/padding parameters. If the model has no specific maximum input | |
| length (like XLNet) truncation/padding to a maximum length will be deactivated.`,name:"max_length"},{anchor:"transformers.LayoutLMv3TokenizerFast.__call__.stride",description:`<strong>stride</strong> (<code>int</code>, <em>optional</em>, defaults to 0) — | |
| If set to a number along with <code>max_length</code>, the overflowing tokens returned when | |
| <code>return_overflowing_tokens=True</code> will contain some tokens from the end of the truncated sequence | |
| returned to provide some overlap between truncated and overflowing sequences. The value of this | |
| argument defines the number of overlapping tokens.`,name:"stride"},{anchor:"transformers.LayoutLMv3TokenizerFast.__call__.pad_to_multiple_of",description:`<strong>pad_to_multiple_of</strong> (<code>int</code>, <em>optional</em>) — | |
| If set will pad the sequence to a multiple of the provided value. This is especially useful to enable | |
| the use of Tensor Cores on NVIDIA hardware with compute capability <code>>= 7.5</code> (Volta).`,name:"pad_to_multiple_of"},{anchor:"transformers.LayoutLMv3TokenizerFast.__call__.return_tensors",description:`<strong>return_tensors</strong> (<code>str</code> or <a href="/docs/transformers/pr_34652/en/internal/file_utils#transformers.TensorType">TensorType</a>, <em>optional</em>) — | |
| If set, will return tensors instead of list of python integers. Acceptable values are:</p> | |
| <ul> | |
| <li><code>'tf'</code>: Return TensorFlow <code>tf.constant</code> objects.</li> | |
| <li><code>'pt'</code>: Return PyTorch <code>torch.Tensor</code> objects.</li> | |
| <li><code>'np'</code>: Return Numpy <code>np.ndarray</code> objects.</li> | |
| </ul>`,name:"return_tensors"},{anchor:"transformers.LayoutLMv3TokenizerFast.__call__.add_special_tokens",description:`<strong>add_special_tokens</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>True</code>) — | |
| Whether or not to encode the sequences with the special tokens relative to their model.`,name:"add_special_tokens"},{anchor:"transformers.LayoutLMv3TokenizerFast.__call__.padding",description:`<strong>padding</strong> (<code>bool</code>, <code>str</code> or <a href="/docs/transformers/pr_34652/en/internal/file_utils#transformers.utils.PaddingStrategy">PaddingStrategy</a>, <em>optional</em>, defaults to <code>False</code>) — | |
| Activates and controls padding. Accepts the following values:</p> | |
| <ul> | |
| <li><code>True</code> or <code>'longest'</code>: Pad to the longest sequence in the batch (or no padding if only a single | |
| sequence if provided).</li> | |
| <li><code>'max_length'</code>: Pad to a maximum length specified with the argument <code>max_length</code> or to the maximum | |
| acceptable input length for the model if that argument is not provided.</li> | |
| <li><code>False</code> or <code>'do_not_pad'</code> (default): No padding (i.e., can output a batch with sequences of different | |
| lengths).</li> | |
| </ul>`,name:"padding"},{anchor:"transformers.LayoutLMv3TokenizerFast.__call__.truncation",description:`<strong>truncation</strong> (<code>bool</code>, <code>str</code> or <a href="/docs/transformers/pr_34652/en/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy">TruncationStrategy</a>, <em>optional</em>, defaults to <code>False</code>) — | |
| Activates and controls truncation. Accepts the following values:</p> | |
| <ul> | |
| <li><code>True</code> or <code>'longest_first'</code>: Truncate to a maximum length specified with the argument <code>max_length</code> or | |
| to the maximum acceptable input length for the model if that argument is not provided. This will | |
| truncate token by token, removing a token from the longest sequence in the pair if a pair of | |
| sequences (or a batch of pairs) is provided.</li> | |
| <li><code>'only_first'</code>: Truncate to a maximum length specified with the argument <code>max_length</code> or to the | |
| maximum acceptable input length for the model if that argument is not provided. This will only | |
| truncate the first sequence of a pair if a pair of sequences (or a batch of pairs) is provided.</li> | |
| <li><code>'only_second'</code>: Truncate to a maximum length specified with the argument <code>max_length</code> or to the | |
| maximum acceptable input length for the model if that argument is not provided. This will only | |
| truncate the second sequence of a pair if a pair of sequences (or a batch of pairs) is provided.</li> | |
| <li><code>False</code> or <code>'do_not_truncate'</code> (default): No truncation (i.e., can output batch with sequence lengths | |
| greater than the model maximum admissible input size).</li> | |
| </ul>`,name:"truncation"},{anchor:"transformers.LayoutLMv3TokenizerFast.__call__.max_length",description:`<strong>max_length</strong> (<code>int</code>, <em>optional</em>) — | |
| Controls the maximum length to use by one of the truncation/padding parameters. If left unset or set to | |
| <code>None</code>, this will use the predefined model maximum length if a maximum length is required by one of the | |
| truncation/padding parameters. If the model has no specific maximum input length (like XLNet) | |
| truncation/padding to a maximum length will be deactivated.`,name:"max_length"},{anchor:"transformers.LayoutLMv3TokenizerFast.__call__.stride",description:`<strong>stride</strong> (<code>int</code>, <em>optional</em>, defaults to 0) — | |
| If set to a number along with <code>max_length</code>, the overflowing tokens returned when | |
| <code>return_overflowing_tokens=True</code> will contain some tokens from the end of the truncated sequence | |
| returned to provide some overlap between truncated and overflowing sequences. The value of this | |
| argument defines the number of overlapping tokens.`,name:"stride"},{anchor:"transformers.LayoutLMv3TokenizerFast.__call__.pad_to_multiple_of",description:`<strong>pad_to_multiple_of</strong> (<code>int</code>, <em>optional</em>) — | |
| If set will pad the sequence to a multiple of the provided value. This is especially useful to enable | |
| the use of Tensor Cores on NVIDIA hardware with compute capability <code>>= 7.5</code> (Volta).`,name:"pad_to_multiple_of"},{anchor:"transformers.LayoutLMv3TokenizerFast.__call__.return_tensors",description:`<strong>return_tensors</strong> (<code>str</code> or <a href="/docs/transformers/pr_34652/en/internal/file_utils#transformers.TensorType">TensorType</a>, <em>optional</em>) — | |
| If set, will return tensors instead of list of python integers. Acceptable values are:</p> | |
| <ul> | |
| <li><code>'tf'</code>: Return TensorFlow <code>tf.constant</code> objects.</li> | |
| <li><code>'pt'</code>: Return PyTorch <code>torch.Tensor</code> objects.</li> | |
| <li><code>'np'</code>: Return Numpy <code>np.ndarray</code> objects.</li> | |
| </ul>`,name:"return_tensors"}],source:"https://github.com/huggingface/transformers/blob/vr_34652/src/transformers/models/layoutlmv3/tokenization_layoutlmv3_fast.py#L206"}}),St=new Fe({props:{title:"LayoutLMv3Processor",local:"transformers.LayoutLMv3Processor",headingTag:"h2"}}),Gt=new B({props:{name:"class transformers.LayoutLMv3Processor",anchor:"transformers.LayoutLMv3Processor",parameters:[{name:"image_processor",val:" = None"},{name:"tokenizer",val:" = None"},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"transformers.LayoutLMv3Processor.image_processor",description:`<strong>image_processor</strong> (<code>LayoutLMv3ImageProcessor</code>, <em>optional</em>) — | |
| An instance of <a href="/docs/transformers/pr_34652/en/model_doc/layoutlmv3#transformers.LayoutLMv3ImageProcessor">LayoutLMv3ImageProcessor</a>. The image processor is a required input.`,name:"image_processor"},{anchor:"transformers.LayoutLMv3Processor.tokenizer",description:`<strong>tokenizer</strong> (<code>LayoutLMv3Tokenizer</code> or <code>LayoutLMv3TokenizerFast</code>, <em>optional</em>) — | |
| An instance of <a href="/docs/transformers/pr_34652/en/model_doc/layoutlmv3#transformers.LayoutLMv3Tokenizer">LayoutLMv3Tokenizer</a> or <a href="/docs/transformers/pr_34652/en/model_doc/layoutlmv3#transformers.LayoutLMv3TokenizerFast">LayoutLMv3TokenizerFast</a>. The tokenizer is a required input.`,name:"tokenizer"}],source:"https://github.com/huggingface/transformers/blob/vr_34652/src/transformers/models/layoutlmv3/processing_layoutlmv3.py#L27"}}),Ht=new B({props:{name:"__call__",anchor:"transformers.LayoutLMv3Processor.__call__",parameters:[{name:"images",val:""},{name:"text",val:": typing.Union[str, typing.List[str], typing.List[typing.List[str]]] = None"},{name:"text_pair",val:": typing.Union[typing.List[str], typing.List[typing.List[str]], NoneType] = None"},{name:"boxes",val:": typing.Union[typing.List[typing.List[int]], typing.List[typing.List[typing.List[int]]]] = None"},{name:"word_labels",val:": typing.Union[typing.List[int], typing.List[typing.List[int]], NoneType] = None"},{name:"add_special_tokens",val:": bool = True"},{name:"padding",val:": typing.Union[bool, str, transformers.utils.generic.PaddingStrategy] = False"},{name:"truncation",val:": typing.Union[bool, str, transformers.tokenization_utils_base.TruncationStrategy] = None"},{name:"max_length",val:": typing.Optional[int] = None"},{name:"stride",val:": int = 0"},{name:"pad_to_multiple_of",val:": typing.Optional[int] = None"},{name:"return_token_type_ids",val:": typing.Optional[bool] = None"},{name:"return_attention_mask",val:": typing.Optional[bool] = None"},{name:"return_overflowing_tokens",val:": bool = False"},{name:"return_special_tokens_mask",val:": bool = False"},{name:"return_offsets_mapping",val:": bool = False"},{name:"return_length",val:": bool = False"},{name:"verbose",val:": bool = True"},{name:"return_tensors",val:": typing.Union[str, transformers.utils.generic.TensorType, NoneType] = None"},{name:"**kwargs",val:""}],source:"https://github.com/huggingface/transformers/blob/vr_34652/src/transformers/models/layoutlmv3/processing_layoutlmv3.py#L69"}}),Nt=new Ko({props:{pytorch:!0,tensorflow:!0,jax:!1,$$slots:{tensorflow:[$n],pytorch:[un]},$$scope:{ctx:$}}}),Et=new en({props:{source:"https://github.com/huggingface/transformers/blob/main/docs/source/en/model_doc/layoutlmv3.md"}}),{c(){t=c("meta"),g=a(),n=c("p"),i=a(),y(w.$$.fragment),s=a(),y(k.$$.fragment),Q=a(),z=c("p"),z.innerHTML=C,Y=a(),j=c("p"),j.textContent=N,I=a(),m=c("p"),m.innerHTML=F,le=a(),je=c("img"),be=a(),E=c("small"),E.innerHTML=ue,rt=a(),K=c("p"),K.innerHTML=Mt,G=a(),y(ee.$$.fragment),yt=a(),Te=c("ul"),Te.innerHTML=Me,Ne=a(),y(Le.$$.fragment),Oe=a(),Ke=c("p"),Ke.textContent=it,Je=a(),y(Ie.$$.fragment),te=a(),Ue=c("ul"),Ue.innerHTML=O,ze=a(),y(V.$$.fragment),he=a(),et=c("ul"),et.innerHTML=lt,Re=a(),y(He.$$.fragment),de=a(),Ee=c("ul"),Ee.innerHTML=tt,oe=a(),y(U.$$.fragment),We=a(),ke=c("ul"),ke.innerHTML=ht,vt=a(),ce=c("p"),ce.innerHTML=dt,Ze=a(),Be=c("ul"),Be.innerHTML=qe,ft=a(),y(X.$$.fragment),ae=a(),re=c("div"),y(P.$$.fragment),ot=a(),nt=c("p"),nt.innerHTML=Pe,Ft=a(),st=c("p"),st.innerHTML=D,Ve=a(),y(ie.$$.fragment),Se=a(),y(we.$$.fragment),ct=a(),J=c("div"),y(fe.$$.fragment),Ge=a(),pe=c("div"),y(h.$$.fragment),q=a(),A=c("p"),A.textContent=Ce,me=a(),y(H.$$.fragment),ge=a(),S=c("div"),y(Z.$$.fragment),Lt=a(),_e=c("p"),_e.textContent=kt,It=a(),Xe=c("div"),y(wt.$$.fragment),Ut=a(),Ae=c("p"),Ae.textContent=At,pt=a(),y(gt.$$.fragment),u=a(),x=c("div"),y(ye.$$.fragment),ve=a(),xe=c("p"),xe.innerHTML=$e,Qe=a(),ne=c("p"),ne.innerHTML=at,Qt=a(),zt=c("p"),zt.innerHTML=co,Yt=a(),bt=c("div"),y(Rt.$$.fragment),Lo=a(),Dt=c("p"),Dt.textContent=Uo,ko=a(),Ot=c("div"),y(Wt.$$.fragment),mo=a(),y(Zt.$$.fragment),uo=a(),mt=c("div"),y(Bt.$$.fragment),wo=a(),Kt=c("p"),Kt.innerHTML=Ro,xo=a(),eo=c("p"),eo.innerHTML=Wo,$o=a(),jt=c("div"),y(Pt.$$.fragment),Fo=a(),to=c("p"),to.textContent=Zo,ho=a(),y(St.$$.fragment),fo=a(),Ye=c("div"),y(Gt.$$.fragment),zo=a(),oo=c("p"),oo.textContent=Bo,qo=a(),no=c("p"),no.innerHTML=Po,Co=a(),so=c("p"),so.innerHTML=So,jo=a(),xt=c("div"),y(Ht.$$.fragment),No=a(),ao=c("p"),ao.innerHTML=Go,Jo=a(),ro=c("p"),ro.textContent=Ho,go=a(),y(Nt.$$.fragment),_o=a(),y(Et.$$.fragment),yo=a(),po=c("p"),this.h()},l(e){const _=Oo("svelte-u9bgzb",document.head);t=p(_,"META",{name:!0,content:!0}),_.forEach(o),g=r(e),n=p(e,"P",{}),W(n).forEach(o),i=r(e),v(w.$$.fragment,e),s=r(e),v(k.$$.fragment,e),Q=r(e),z=p(e,"P",{"data-svelte-h":!0}),f(z)!=="svelte-1f4jc90"&&(z.innerHTML=C),Y=r(e),j=p(e,"P",{"data-svelte-h":!0}),f(j)!=="svelte-vfdo9a"&&(j.textContent=N),I=r(e),m=p(e,"P",{"data-svelte-h":!0}),f(m)!=="svelte-1ma3m55"&&(m.innerHTML=F),le=r(e),je=p(e,"IMG",{src:!0,alt:!0,width:!0}),be=r(e),E=p(e,"SMALL",{"data-svelte-h":!0}),f(E)!=="svelte-1s1kkx4"&&(E.innerHTML=ue),rt=r(e),K=p(e,"P",{"data-svelte-h":!0}),f(K)!=="svelte-orqv4r"&&(K.innerHTML=Mt),G=r(e),v(ee.$$.fragment,e),yt=r(e),Te=p(e,"UL",{"data-svelte-h":!0}),f(Te)!=="svelte-1r4j8er"&&(Te.innerHTML=Me),Ne=r(e),v(Le.$$.fragment,e),Oe=r(e),Ke=p(e,"P",{"data-svelte-h":!0}),f(Ke)!=="svelte-6d8ri7"&&(Ke.textContent=it),Je=r(e),v(Ie.$$.fragment,e),te=r(e),Ue=p(e,"UL",{"data-svelte-h":!0}),f(Ue)!=="svelte-14k3q4u"&&(Ue.innerHTML=O),ze=r(e),v(V.$$.fragment,e),he=r(e),et=p(e,"UL",{"data-svelte-h":!0}),f(et)!=="svelte-1j0z9ui"&&(et.innerHTML=lt),Re=r(e),v(He.$$.fragment,e),de=r(e),Ee=p(e,"UL",{"data-svelte-h":!0}),f(Ee)!=="svelte-18tk4fc"&&(Ee.innerHTML=tt),oe=r(e),v(U.$$.fragment,e),We=r(e),ke=p(e,"UL",{"data-svelte-h":!0}),f(ke)!=="svelte-ly19h7"&&(ke.innerHTML=ht),vt=r(e),ce=p(e,"P",{"data-svelte-h":!0}),f(ce)!=="svelte-7jde1k"&&(ce.innerHTML=dt),Ze=r(e),Be=p(e,"UL",{"data-svelte-h":!0}),f(Be)!=="svelte-116uoyl"&&(Be.innerHTML=qe),ft=r(e),v(X.$$.fragment,e),ae=r(e),re=p(e,"DIV",{class:!0});var Tt=W(re);v(P.$$.fragment,Tt),ot=r(Tt),nt=p(Tt,"P",{"data-svelte-h":!0}),f(nt)!=="svelte-12nmpz3"&&(nt.innerHTML=Pe),Ft=r(Tt),st=p(Tt,"P",{"data-svelte-h":!0}),f(st)!=="svelte-1mon8q7"&&(st.innerHTML=D),Ve=r(Tt),v(ie.$$.fragment,Tt),Tt.forEach(o),Se=r(e),v(we.$$.fragment,e),ct=r(e),J=p(e,"DIV",{class:!0});var Vt=W(J);v(fe.$$.fragment,Vt),Ge=r(Vt),pe=p(Vt,"DIV",{class:!0});var Xt=W(pe);v(h.$$.fragment,Xt),q=r(Xt),A=p(Xt,"P",{"data-svelte-h":!0}),f(A)!=="svelte-khengj"&&(A.textContent=Ce),Xt.forEach(o),Vt.forEach(o),me=r(e),v(H.$$.fragment,e),ge=r(e),S=p(e,"DIV",{class:!0});var io=W(S);v(Z.$$.fragment,io),Lt=r(io),_e=p(io,"P",{"data-svelte-h":!0}),f(_e)!=="svelte-1xoh9ve"&&(_e.textContent=kt),It=r(io),Xe=p(io,"DIV",{class:!0});var bo=W(Xe);v(wt.$$.fragment,bo),Ut=r(bo),Ae=p(bo,"P",{"data-svelte-h":!0}),f(Ae)!=="svelte-1x3yxsa"&&(Ae.textContent=At),bo.forEach(o),io.forEach(o),pt=r(e),v(gt.$$.fragment,e),u=r(e),x=p(e,"DIV",{class:!0});var _t=W(x);v(ye.$$.fragment,_t),ve=r(_t),xe=p(_t,"P",{"data-svelte-h":!0}),f(xe)!=="svelte-k5rhqp"&&(xe.innerHTML=$e),Qe=r(_t),ne=p(_t,"P",{"data-svelte-h":!0}),f(ne)!=="svelte-1tupggq"&&(ne.innerHTML=at),Qt=r(_t),zt=p(_t,"P",{"data-svelte-h":!0}),f(zt)!=="svelte-1atp9fi"&&(zt.innerHTML=co),Yt=r(_t),bt=p(_t,"DIV",{class:!0});var To=W(bt);v(Rt.$$.fragment,To),Lo=r(To),Dt=p(To,"P",{"data-svelte-h":!0}),f(Dt)!=="svelte-1w6bb17"&&(Dt.textContent=Uo),To.forEach(o),ko=r(_t),Ot=p(_t,"DIV",{class:!0});var Eo=W(Ot);v(Wt.$$.fragment,Eo),Eo.forEach(o),_t.forEach(o),mo=r(e),v(Zt.$$.fragment,e),uo=r(e),mt=p(e,"DIV",{class:!0});var Jt=W(mt);v(Bt.$$.fragment,Jt),wo=r(Jt),Kt=p(Jt,"P",{"data-svelte-h":!0}),f(Kt)!=="svelte-1f709bx"&&(Kt.innerHTML=Ro),xo=r(Jt),eo=p(Jt,"P",{"data-svelte-h":!0}),f(eo)!=="svelte-1e2pjbq"&&(eo.innerHTML=Wo),$o=r(Jt),jt=p(Jt,"DIV",{class:!0});var Mo=W(jt);v(Pt.$$.fragment,Mo),Fo=r(Mo),to=p(Mo,"P",{"data-svelte-h":!0}),f(to)!=="svelte-1w6bb17"&&(to.textContent=Zo),Mo.forEach(o),Jt.forEach(o),ho=r(e),v(St.$$.fragment,e),fo=r(e),Ye=p(e,"DIV",{class:!0});var $t=W(Ye);v(Gt.$$.fragment,$t),zo=r($t),oo=p($t,"P",{"data-svelte-h":!0}),f(oo)!=="svelte-13xsew6"&&(oo.textContent=Bo),qo=r($t),no=p($t,"P",{"data-svelte-h":!0}),f(no)!=="svelte-3eritd"&&(no.innerHTML=Po),Co=r($t),so=p($t,"P",{"data-svelte-h":!0}),f(so)!=="svelte-1sgfeyl"&&(so.innerHTML=So),jo=r($t),xt=p($t,"DIV",{class:!0});var lo=W(xt);v(Ht.$$.fragment,lo),No=r(lo),ao=p(lo,"P",{"data-svelte-h":!0}),f(ao)!=="svelte-tjhq98"&&(ao.innerHTML=Go),Jo=r(lo),ro=p(lo,"P",{"data-svelte-h":!0}),f(ro)!=="svelte-ws0hzs"&&(ro.textContent=Ho),lo.forEach(o),$t.forEach(o),go=r(e),v(Nt.$$.fragment,e),_o=r(e),v(Et.$$.fragment,e),yo=r(e),po=p(e,"P",{}),W(po).forEach(o),this.h()},h(){R(t,"name","hf:doc:metadata"),R(t,"content",zn),Ao(je.src,De="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/layoutlmv3_architecture.png")||R(je,"src",De),R(je,"alt","drawing"),R(je,"width","600"),R(re,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),R(pe,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),R(J,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),R(Xe,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),R(S,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),R(bt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),R(Ot,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),R(x,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),R(jt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),R(mt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),R(xt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),R(Ye,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8")},m(e,_){d(document.head,t),l(e,g,_),l(e,n,_),l(e,i,_),b(w,e,_),l(e,s,_),b(k,e,_),l(e,Q,_),l(e,z,_),l(e,Y,_),l(e,j,_),l(e,I,_),l(e,m,_),l(e,le,_),l(e,je,_),l(e,be,_),l(e,E,_),l(e,rt,_),l(e,K,_),l(e,G,_),b(ee,e,_),l(e,yt,_),l(e,Te,_),l(e,Ne,_),b(Le,e,_),l(e,Oe,_),l(e,Ke,_),l(e,Je,_),b(Ie,e,_),l(e,te,_),l(e,Ue,_),l(e,ze,_),b(V,e,_),l(e,he,_),l(e,et,_),l(e,Re,_),b(He,e,_),l(e,de,_),l(e,Ee,_),l(e,oe,_),b(U,e,_),l(e,We,_),l(e,ke,_),l(e,vt,_),l(e,ce,_),l(e,Ze,_),l(e,Be,_),l(e,ft,_),b(X,e,_),l(e,ae,_),l(e,re,_),b(P,re,null),d(re,ot),d(re,nt),d(re,Ft),d(re,st),d(re,Ve),b(ie,re,null),l(e,Se,_),b(we,e,_),l(e,ct,_),l(e,J,_),b(fe,J,null),d(J,Ge),d(J,pe),b(h,pe,null),d(pe,q),d(pe,A),l(e,me,_),b(H,e,_),l(e,ge,_),l(e,S,_),b(Z,S,null),d(S,Lt),d(S,_e),d(S,It),d(S,Xe),b(wt,Xe,null),d(Xe,Ut),d(Xe,Ae),l(e,pt,_),b(gt,e,_),l(e,u,_),l(e,x,_),b(ye,x,null),d(x,ve),d(x,xe),d(x,Qe),d(x,ne),d(x,Qt),d(x,zt),d(x,Yt),d(x,bt),b(Rt,bt,null),d(bt,Lo),d(bt,Dt),d(x,ko),d(x,Ot),b(Wt,Ot,null),l(e,mo,_),b(Zt,e,_),l(e,uo,_),l(e,mt,_),b(Bt,mt,null),d(mt,wo),d(mt,Kt),d(mt,xo),d(mt,eo),d(mt,$o),d(mt,jt),b(Pt,jt,null),d(jt,Fo),d(jt,to),l(e,ho,_),b(St,e,_),l(e,fo,_),l(e,Ye,_),b(Gt,Ye,null),d(Ye,zo),d(Ye,oo),d(Ye,qo),d(Ye,no),d(Ye,Co),d(Ye,so),d(Ye,jo),d(Ye,xt),b(Ht,xt,null),d(xt,No),d(xt,ao),d(xt,Jo),d(xt,ro),l(e,go,_),b(Nt,e,_),l(e,_o,_),b(Et,e,_),l(e,yo,_),l(e,po,_),vo=!0},p(e,[_]){const Tt={};_&2&&(Tt.$$scope={dirty:_,ctx:e}),Ie.$set(Tt);const Vt={};_&2&&(Vt.$$scope={dirty:_,ctx:e}),ie.$set(Vt);const Xt={};_&2&&(Xt.$$scope={dirty:_,ctx:e}),Nt.$set(Xt)},i(e){vo||(T(w.$$.fragment,e),T(k.$$.fragment,e),T(ee.$$.fragment,e),T(Le.$$.fragment,e),T(Ie.$$.fragment,e),T(V.$$.fragment,e),T(He.$$.fragment,e),T(U.$$.fragment,e),T(X.$$.fragment,e),T(P.$$.fragment,e),T(ie.$$.fragment,e),T(we.$$.fragment,e),T(fe.$$.fragment,e),T(h.$$.fragment,e),T(H.$$.fragment,e),T(Z.$$.fragment,e),T(wt.$$.fragment,e),T(gt.$$.fragment,e),T(ye.$$.fragment,e),T(Rt.$$.fragment,e),T(Wt.$$.fragment,e),T(Zt.$$.fragment,e),T(Bt.$$.fragment,e),T(Pt.$$.fragment,e),T(St.$$.fragment,e),T(Gt.$$.fragment,e),T(Ht.$$.fragment,e),T(Nt.$$.fragment,e),T(Et.$$.fragment,e),vo=!0)},o(e){M(w.$$.fragment,e),M(k.$$.fragment,e),M(ee.$$.fragment,e),M(Le.$$.fragment,e),M(Ie.$$.fragment,e),M(V.$$.fragment,e),M(He.$$.fragment,e),M(U.$$.fragment,e),M(X.$$.fragment,e),M(P.$$.fragment,e),M(ie.$$.fragment,e),M(we.$$.fragment,e),M(fe.$$.fragment,e),M(h.$$.fragment,e),M(H.$$.fragment,e),M(Z.$$.fragment,e),M(wt.$$.fragment,e),M(gt.$$.fragment,e),M(ye.$$.fragment,e),M(Rt.$$.fragment,e),M(Wt.$$.fragment,e),M(Zt.$$.fragment,e),M(Bt.$$.fragment,e),M(Pt.$$.fragment,e),M(St.$$.fragment,e),M(Gt.$$.fragment,e),M(Ht.$$.fragment,e),M(Nt.$$.fragment,e),M(Et.$$.fragment,e),vo=!1},d(e){e&&(o(g),o(n),o(i),o(s),o(Q),o(z),o(Y),o(j),o(I),o(m),o(le),o(je),o(be),o(E),o(rt),o(K),o(G),o(yt),o(Te),o(Ne),o(Oe),o(Ke),o(Je),o(te),o(Ue),o(ze),o(he),o(et),o(Re),o(de),o(Ee),o(oe),o(We),o(ke),o(vt),o(ce),o(Ze),o(Be),o(ft),o(ae),o(re),o(Se),o(ct),o(J),o(me),o(ge),o(S),o(pt),o(u),o(x),o(mo),o(uo),o(mt),o(ho),o(fo),o(Ye),o(go),o(_o),o(yo),o(po)),o(t),L(w,e),L(k,e),L(ee,e),L(Le,e),L(Ie,e),L(V,e),L(He,e),L(U,e),L(X,e),L(P),L(ie),L(we,e),L(fe),L(h),L(H,e),L(Z),L(wt),L(gt,e),L(ye),L(Rt),L(Wt),L(Zt,e),L(Bt),L(Pt),L(St,e),L(Gt),L(Ht),L(Nt,e),L(Et,e)}}}const zn='{"title":"LayoutLMv3","local":"layoutlmv3","sections":[{"title":"Overview","local":"overview","sections":[],"depth":2},{"title":"Usage tips","local":"usage-tips","sections":[],"depth":2},{"title":"Resources","local":"resources","sections":[],"depth":2},{"title":"LayoutLMv3Config","local":"transformers.LayoutLMv3Config","sections":[],"depth":2},{"title":"LayoutLMv3FeatureExtractor","local":"transformers.LayoutLMv3FeatureExtractor","sections":[],"depth":2},{"title":"LayoutLMv3ImageProcessor","local":"transformers.LayoutLMv3ImageProcessor","sections":[],"depth":2},{"title":"LayoutLMv3Tokenizer","local":"transformers.LayoutLMv3Tokenizer","sections":[],"depth":2},{"title":"LayoutLMv3TokenizerFast","local":"transformers.LayoutLMv3TokenizerFast","sections":[],"depth":2},{"title":"LayoutLMv3Processor","local":"transformers.LayoutLMv3Processor","sections":[],"depth":2},{"title":"LayoutLMv3Model","local":"transformers.LayoutLMv3Model","sections":[],"depth":2},{"title":"LayoutLMv3ForSequenceClassification","local":"transformers.LayoutLMv3ForSequenceClassification","sections":[],"depth":2},{"title":"LayoutLMv3ForTokenClassification","local":"transformers.LayoutLMv3ForTokenClassification","sections":[],"depth":2},{"title":"LayoutLMv3ForQuestionAnswering","local":"transformers.LayoutLMv3ForQuestionAnswering","sections":[],"depth":2},{"title":"TFLayoutLMv3Model","local":"transformers.TFLayoutLMv3Model","sections":[],"depth":2},{"title":"TFLayoutLMv3ForSequenceClassification","local":"transformers.TFLayoutLMv3ForSequenceClassification","sections":[],"depth":2},{"title":"TFLayoutLMv3ForTokenClassification","local":"transformers.TFLayoutLMv3ForTokenClassification","sections":[],"depth":2},{"title":"TFLayoutLMv3ForQuestionAnswering","local":"transformers.TFLayoutLMv3ForQuestionAnswering","sections":[],"depth":2}],"depth":1}';function qn($){return Qo(()=>{new URLSearchParams(window.location.search).get("fw")}),[]}class Bn extends Yo{constructor(t){super(),Do(this,t,qn,Fn,Xo,{})}}export{Bn as component}; | |
Xet Storage Details
- Size:
- 250 kB
- Xet hash:
- d1a164db73e0c4abce2eb26c2492b7e51210c98da738004368eb9e8952f0e1c8
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.