Buckets:

hf-doc-build
/

doc-dev

hf-doc-build/doc-dev / transformers /pr_43265 /en /_app /immutable /nodes /108.d00fcfdb.js

HuggingFaceDocBuilder's picture

HuggingFaceDocBuilder

about 2 months ago

111 kB

	import{s as vo,o as Jo,n as R}from"../chunks/scheduler.31fdf58d.js";import{S as Uo,i as jo,e as m,s as i,c as h,h as ko,a as g,d as a,b as l,f as j,j as T,g as u,k,w as $o,l as c,m as p,n as _,t as b,o as y,p as M}from"../chunks/index.2f76fdf0.js";import{T as Fn}from"../chunks/Tip.8d349121.js";import{C as xo}from"../chunks/CopyLLMTxtMenu.53b607bf.js";import{D as V}from"../chunks/Docstring.7acc6835.js";import{C as E}from"../chunks/CodeBlock.e52df5d6.js";import{E as he}from"../chunks/ExampleCodeBlock.f9704f52.js";import{H as K,E as Wo}from"../chunks/MermaidChart.svelte_svelte_type_style_lang.08750ec0.js";import{H as Zo,a as wo}from"../chunks/HfOption.fb051768.js";function Co(v){let n,f;return n=new E({props:{code:"ZnJvbSUyMHRyYW5zZm9ybWVycyUyMGltcG9ydCUyMHBpcGVsaW5lJTBBJTBBJTBBcGlwZWxpbmUlMjAlM0QlMjBwaXBlbGluZSglMEElMjAlMjAlMjAlMjB0YXNrJTNEJTIyemVyby1zaG90LWltYWdlLWNsYXNzaWZpY2F0aW9uJTIyJTJDJTBBJTIwJTIwJTIwJTIwbW9kZWwlM0QlMjJrYWthb2JyYWluJTJGYWxpZ24tYmFzZSUyMiUyQyUwQSUyMCUyMCUyMCUyMGRldmljZSUzRDAlMkMlMEEpJTBBJTBBY2FuZGlkYXRlX2xhYmVscyUyMCUzRCUyMCU1QiUwQSUyMCUyMCUyMCUyMCUyMmElMjBwaG90byUyMG9mJTIwYSUyMGRvZyUyMiUyQyUwQSUyMCUyMCUyMCUyMCUyMmElMjBwaG90byUyMG9mJTIwYSUyMGNhdCUyMiUyQyUwQSUyMCUyMCUyMCUyMCUyMmElMjBwaG90byUyMG9mJTIwYSUyMHBlcnNvbiUyMiUwQSU1RCUwQSUwQXBpcGVsaW5lKCUyMmh0dHBzJTNBJTJGJTJGaHVnZ2luZ2ZhY2UuY28lMkZkYXRhc2V0cyUyRmh1Z2dpbmdmYWNlJTJGZG9jdW1lbnRhdGlvbi1pbWFnZXMlMkZyZXNvbHZlJTJGbWFpbiUyRnBpcGVsaW5lLWNhdC1jaG9uay5qcGVnJTIyJTJDJTIwY2FuZGlkYXRlX2xhYmVscyUzRGNhbmRpZGF0ZV9sYWJlbHMp",highlighted:`<span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> pipeline


	pipeline = pipeline(
	task=<span class="hljs-string">"zero-shot-image-classification"</span>,
	model=<span class="hljs-string">"kakaobrain/align-base"</span>,
	device=<span class="hljs-number">0</span>,
	)

	candidate_labels = [
	<span class="hljs-string">"a photo of a dog"</span>,
	<span class="hljs-string">"a photo of a cat"</span>,
	<span class="hljs-string">"a photo of a person"</span>
	]

	pipeline(<span class="hljs-string">"https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"</span>, candidate_labels=candidate_labels)`,lang:"python",wrap:!1}}),{c(){h(n.$$.fragment)},l(o){u(n.$$.fragment,o)},m(o,r){_(n,o,r),f=!0},p:R,i(o){f\|\|(b(n.$$.fragment,o),f=!0)},o(o){y(n.$$.fragment,o),f=!1},d(o){M(n,o)}}}function Io(v){let n,f;return n=new E({props:{code:"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",highlighted:`<span class="hljs-keyword">import</span> requests
	<span class="hljs-keyword">import</span> torch
	<span class="hljs-keyword">from</span> PIL <span class="hljs-keyword">import</span> Image

	<span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> AutoModelForZeroShotImageClassification, AutoProcessor


	processor = AutoProcessor.from_pretrained(<span class="hljs-string">"kakaobrain/align-base"</span>)
	model = AutoModelForZeroShotImageClassification.from_pretrained(<span class="hljs-string">"kakaobrain/align-base"</span>, device_map=<span class="hljs-string">"auto"</span>)

	url = <span class="hljs-string">"https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"</span>
	image = requests.get(url, stream=<span class="hljs-literal">True</span>)
	inputs = Image.<span class="hljs-built_in">open</span>(image.raw).convert(<span class="hljs-string">"RGB"</span>)

	image_inputs = processor(images=inputs, return_tensors=<span class="hljs-string">"pt"</span>).to(model.device)
	<span class="hljs-keyword">with</span> torch.no_grad():
	image_embeds = model.get_image_features(**image_inputs)

	candidate_labels = [<span class="hljs-string">"a photo of a dog"</span>, <span class="hljs-string">"a photo of a cat"</span>, <span class="hljs-string">"a photo of a person"</span>]
	text_inputs = processor(text=candidate_labels, padding=<span class="hljs-literal">True</span>, return_tensors=<span class="hljs-string">"pt"</span>).to(model.device)
	<span class="hljs-keyword">with</span> torch.no_grad():
	text_embeds = model.get_text_features(**text_inputs)

	image_embeds = image_embeds / image_embeds.norm(p=<span class="hljs-number">2</span>, dim=-<span class="hljs-number">1</span>, keepdim=<span class="hljs-literal">True</span>)
	text_embeds = text_embeds / text_embeds.norm(p=<span class="hljs-number">2</span>, dim=-<span class="hljs-number">1</span>, keepdim=<span class="hljs-literal">True</span>)

	logits = (image_embeds @ text_embeds.T) * <span class="hljs-number">100.0</span>
	probs = logits.softmax(dim=-<span class="hljs-number">1</span>).cpu().squeeze()

	<span class="hljs-keyword">for</span> label, score <span class="hljs-keyword">in</span> <span class="hljs-built_in">zip</span>(candidate_labels, probs):
	<span class="hljs-built_in">print</span>(<span class="hljs-string">f"<span class="hljs-subst">{label:20s}</span> → <span class="hljs-subst">{score.item():<span class="hljs-number">.4</span>f}</span>"</span>)`,lang:"python",wrap:!1}}),{c(){h(n.$$.fragment)},l(o){u(n.$$.fragment,o)},m(o,r){_(n,o,r),f=!0},p:R,i(o){f\|\|(b(n.$$.fragment,o),f=!0)},o(o){y(n.$$.fragment,o),f=!1},d(o){M(n,o)}}}function Bo(v){let n,f,o,r;return n=new wo({props:{id:"usage",option:"Pipeline",$$slots:{default:[Co]},$$scope:{ctx:v}}}),o=new wo({props:{id:"usage",option:"AutoModel",$$slots:{default:[Io]},$$scope:{ctx:v}}}),{c(){h(n.$$.fragment),f=i(),h(o.$$.fragment)},l(d){u(n.$$.fragment,d),f=l(d),u(o.$$.fragment,d)},m(d,t){_(n,d,t),p(d,f,t),_(o,d,t),r=!0},p(d,t){const w={};t&2&&(w.$$scope={dirty:t,ctx:d}),n.$set(w);const Q={};t&2&&(Q.$$scope={dirty:t,ctx:d}),o.$set(Q)},i(d){r\|\|(b(n.$$.fragment,d),b(o.$$.fragment,d),r=!0)},o(d){y(n.$$.fragment,d),y(o.$$.fragment,d),r=!1},d(d){d&&a(f),M(n,d),M(o,d)}}}function zo(v){let n,f="Example:",o,r,d;return r=new E({props:{code:"ZnJvbSUyMHRyYW5zZm9ybWVycyUyMGltcG9ydCUyMEFsaWduQ29uZmlnJTJDJTIwQWxpZ25Nb2RlbCUwQSUwQSUyMyUyMEluaXRpYWxpemluZyUyMGElMjBBbGlnbkNvbmZpZyUyMHdpdGglMjBrYWthb2JyYWluJTJGYWxpZ24tYmFzZSUyMHN0eWxlJTIwY29uZmlndXJhdGlvbiUwQWNvbmZpZ3VyYXRpb24lMjAlM0QlMjBBbGlnbkNvbmZpZygpJTBBJTBBJTIzJTIwSW5pdGlhbGl6aW5nJTIwYSUyMEFsaWduTW9kZWwlMjAod2l0aCUyMHJhbmRvbSUyMHdlaWdodHMpJTIwZnJvbSUyMHRoZSUyMGtha2FvYnJhaW4lMkZhbGlnbi1iYXNlJTIwc3R5bGUlMjBjb25maWd1cmF0aW9uJTBBbW9kZWwlMjAlM0QlMjBBbGlnbk1vZGVsKGNvbmZpZ3VyYXRpb24pJTBBJTBBJTIzJTIwQWNjZXNzaW5nJTIwdGhlJTIwbW9kZWwlMjBjb25maWd1cmF0aW9uJTBBY29uZmlndXJhdGlvbiUyMCUzRCUyMG1vZGVsLmNvbmZpZyUwQSUwQSUyMyUyMFdlJTIwY2FuJTIwYWxzbyUyMGluaXRpYWxpemUlMjBhJTIwQWxpZ25Db25maWclMjBmcm9tJTIwYSUyMEFsaWduVGV4dENvbmZpZyUyMGFuZCUyMGElMjBBbGlnblZpc2lvbkNvbmZpZyUwQWZyb20lMjB0cmFuc2Zvcm1lcnMlMjBpbXBvcnQlMjBBbGlnblRleHRDb25maWclMkMlMjBBbGlnblZpc2lvbkNvbmZpZyUwQSUwQSUyMyUyMEluaXRpYWxpemluZyUyMEFMSUdOJTIwVGV4dCUyMGFuZCUyMFZpc2lvbiUyMGNvbmZpZ3VyYXRpb25zJTBBY29uZmlnX3RleHQlMjAlM0QlMjBBbGlnblRleHRDb25maWcoKSUwQWNvbmZpZ192aXNpb24lMjAlM0QlMjBBbGlnblZpc2lvbkNvbmZpZygpJTBBJTBBY29uZmlnJTIwJTNEJTIwQWxpZ25Db25maWcodGV4dF9jb25maWclM0Rjb25maWdfdGV4dCUyQyUyMHZpc2lvbl9jb25maWclM0Rjb25maWdfdmlzaW9uKQ==",highlighted:`<span class="hljs-meta">>>> </span><span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> AlignConfig, AlignModel

	<span class="hljs-meta">>>> </span><span class="hljs-comment"># Initializing a AlignConfig with kakaobrain/align-base style configuration</span>
	<span class="hljs-meta">>>> </span>configuration = AlignConfig()

	<span class="hljs-meta">>>> </span><span class="hljs-comment"># Initializing a AlignModel (with random weights) from the kakaobrain/align-base style configuration</span>
	<span class="hljs-meta">>>> </span>model = AlignModel(configuration)

	<span class="hljs-meta">>>> </span><span class="hljs-comment"># Accessing the model configuration</span>
	<span class="hljs-meta">>>> </span>configuration = model.config

	<span class="hljs-meta">>>> </span><span class="hljs-comment"># We can also initialize a AlignConfig from a AlignTextConfig and a AlignVisionConfig</span>
	<span class="hljs-meta">>>> </span><span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> AlignTextConfig, AlignVisionConfig

	<span class="hljs-meta">>>> </span><span class="hljs-comment"># Initializing ALIGN Text and Vision configurations</span>
	<span class="hljs-meta">>>> </span>config_text = AlignTextConfig()
	<span class="hljs-meta">>>> </span>config_vision = AlignVisionConfig()

	<span class="hljs-meta">>>> </span>config = AlignConfig(text_config=config_text, vision_config=config_vision)`,lang:"python",wrap:!1}}),{c(){n=m("p"),n.textContent=f,o=i(),h(r.$$.fragment)},l(t){n=g(t,"P",{"data-svelte-h":!0}),T(n)!=="svelte-11lpom8"&&(n.textContent=f),o=l(t),u(r.$$.fragment,t)},m(t,w){p(t,n,w),p(t,o,w),_(r,t,w),d=!0},p:R,i(t){d\|\|(b(r.$$.fragment,t),d=!0)},o(t){y(r.$$.fragment,t),d=!1},d(t){t&&(a(n),a(o)),M(r,t)}}}function Ao(v){let n,f="Example:",o,r,d;return r=new E({props:{code:"ZnJvbSUyMHRyYW5zZm9ybWVycyUyMGltcG9ydCUyMEFsaWduVGV4dENvbmZpZyUyQyUyMEFsaWduVGV4dE1vZGVsJTBBJTBBJTIzJTIwSW5pdGlhbGl6aW5nJTIwYSUyMEFsaWduVGV4dENvbmZpZyUyMHdpdGglMjBrYWthb2JyYWluJTJGYWxpZ24tYmFzZSUyMHN0eWxlJTIwY29uZmlndXJhdGlvbiUwQWNvbmZpZ3VyYXRpb24lMjAlM0QlMjBBbGlnblRleHRDb25maWcoKSUwQSUwQSUyMyUyMEluaXRpYWxpemluZyUyMGElMjBBbGlnblRleHRNb2RlbCUyMCh3aXRoJTIwcmFuZG9tJTIwd2VpZ2h0cyklMjBmcm9tJTIwdGhlJTIwa2FrYW9icmFpbiUyRmFsaWduLWJhc2UlMjBzdHlsZSUyMGNvbmZpZ3VyYXRpb24lMEFtb2RlbCUyMCUzRCUyMEFsaWduVGV4dE1vZGVsKGNvbmZpZ3VyYXRpb24pJTBBJTBBJTIzJTIwQWNjZXNzaW5nJTIwdGhlJTIwbW9kZWwlMjBjb25maWd1cmF0aW9uJTBBY29uZmlndXJhdGlvbiUyMCUzRCUyMG1vZGVsLmNvbmZpZw==",highlighted:`<span class="hljs-meta">>>> </span><span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> AlignTextConfig, AlignTextModel

	<span class="hljs-meta">>>> </span><span class="hljs-comment"># Initializing a AlignTextConfig with kakaobrain/align-base style configuration</span>
	<span class="hljs-meta">>>> </span>configuration = AlignTextConfig()

	<span class="hljs-meta">>>> </span><span class="hljs-comment"># Initializing a AlignTextModel (with random weights) from the kakaobrain/align-base style configuration</span>
	<span class="hljs-meta">>>> </span>model = AlignTextModel(configuration)

	<span class="hljs-meta">>>> </span><span class="hljs-comment"># Accessing the model configuration</span>
	<span class="hljs-meta">>>> </span>configuration = model.config`,lang:"python",wrap:!1}}),{c(){n=m("p"),n.textContent=f,o=i(),h(r.$$.fragment)},l(t){n=g(t,"P",{"data-svelte-h":!0}),T(n)!=="svelte-11lpom8"&&(n.textContent=f),o=l(t),u(r.$$.fragment,t)},m(t,w){p(t,n,w),p(t,o,w),_(r,t,w),d=!0},p:R,i(t){d\|\|(b(r.$$.fragment,t),d=!0)},o(t){y(r.$$.fragment,t),d=!1},d(t){t&&(a(n),a(o)),M(r,t)}}}function No(v){let n,f="Example:",o,r,d;return r=new E({props:{code:"ZnJvbSUyMHRyYW5zZm9ybWVycyUyMGltcG9ydCUyMEFsaWduVmlzaW9uQ29uZmlnJTJDJTIwQWxpZ25WaXNpb25Nb2RlbCUwQSUwQSUyMyUyMEluaXRpYWxpemluZyUyMGElMjBBbGlnblZpc2lvbkNvbmZpZyUyMHdpdGglMjBrYWthb2JyYWluJTJGYWxpZ24tYmFzZSUyMHN0eWxlJTIwY29uZmlndXJhdGlvbiUwQWNvbmZpZ3VyYXRpb24lMjAlM0QlMjBBbGlnblZpc2lvbkNvbmZpZygpJTBBJTBBJTIzJTIwSW5pdGlhbGl6aW5nJTIwYSUyMEFsaWduVmlzaW9uTW9kZWwlMjAod2l0aCUyMHJhbmRvbSUyMHdlaWdodHMpJTIwZnJvbSUyMHRoZSUyMGtha2FvYnJhaW4lMkZhbGlnbi1iYXNlJTIwc3R5bGUlMjBjb25maWd1cmF0aW9uJTBBbW9kZWwlMjAlM0QlMjBBbGlnblZpc2lvbk1vZGVsKGNvbmZpZ3VyYXRpb24pJTBBJTBBJTIzJTIwQWNjZXNzaW5nJTIwdGhlJTIwbW9kZWwlMjBjb25maWd1cmF0aW9uJTBBY29uZmlndXJhdGlvbiUyMCUzRCUyMG1vZGVsLmNvbmZpZw==",highlighted:`<span class="hljs-meta">>>> </span><span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> AlignVisionConfig, AlignVisionModel

	<span class="hljs-meta">>>> </span><span class="hljs-comment"># Initializing a AlignVisionConfig with kakaobrain/align-base style configuration</span>
	<span class="hljs-meta">>>> </span>configuration = AlignVisionConfig()

	<span class="hljs-meta">>>> </span><span class="hljs-comment"># Initializing a AlignVisionModel (with random weights) from the kakaobrain/align-base style configuration</span>
	<span class="hljs-meta">>>> </span>model = AlignVisionModel(configuration)

	<span class="hljs-meta">>>> </span><span class="hljs-comment"># Accessing the model configuration</span>
	<span class="hljs-meta">>>> </span>configuration = model.config`,lang:"python",wrap:!1}}),{c(){n=m("p"),n.textContent=f,o=i(),h(r.$$.fragment)},l(t){n=g(t,"P",{"data-svelte-h":!0}),T(n)!=="svelte-11lpom8"&&(n.textContent=f),o=l(t),u(r.$$.fragment,t)},m(t,w){p(t,n,w),p(t,o,w),_(r,t,w),d=!0},p:R,i(t){d\|\|(b(r.$$.fragment,t),d=!0)},o(t){y(r.$$.fragment,t),d=!1},d(t){t&&(a(n),a(o)),M(r,t)}}}function Go(v){let n,f=`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(){n=m("p"),n.innerHTML=f},l(o){n=g(o,"P",{"data-svelte-h":!0}),T(n)!=="svelte-fincs2"&&(n.innerHTML=f)},m(o,r){p(o,n,r)},p:R,d(o){o&&a(n)}}}function Vo(v){let n,f="Examples:",o,r,d;return r=new E({props:{code:"aW1wb3J0JTIwdG9yY2glMEFmcm9tJTIwdHJhbnNmb3JtZXJzJTIwaW1wb3J0JTIwQXV0b1Byb2Nlc3NvciUyQyUyMEFsaWduTW9kZWwlMEFmcm9tJTIwdHJhbnNmb3JtZXJzLmltYWdlX3V0aWxzJTIwaW1wb3J0JTIwbG9hZF9pbWFnZSUwQSUwQW1vZGVsJTIwJTNEJTIwQWxpZ25Nb2RlbC5mcm9tX3ByZXRyYWluZWQoJTIya2FrYW9icmFpbiUyRmFsaWduLWJhc2UlMjIpJTBBcHJvY2Vzc29yJTIwJTNEJTIwQXV0b1Byb2Nlc3Nvci5mcm9tX3ByZXRyYWluZWQoJTIya2FrYW9icmFpbiUyRmFsaWduLWJhc2UlMjIpJTBBJTBBdXJsJTIwJTNEJTIwJTIyaHR0cCUzQSUyRiUyRmltYWdlcy5jb2NvZGF0YXNldC5vcmclMkZ2YWwyMDE3JTJGMDAwMDAwMDM5NzY5LmpwZyUyMiUwQWltYWdlJTIwJTNEJTIwbG9hZF9pbWFnZSh1cmwpJTBBJTBBaW5wdXRzJTIwJTNEJTIwcHJvY2Vzc29yKCUwQSUyMCUyMCUyMCUyMGltYWdlcyUzRGltYWdlJTJDJTIwdGV4dCUzRCU1QiUyMmElMjBwaG90byUyMG9mJTIwYSUyMGNhdCUyMiUyQyUyMCUyMmElMjBwaG90byUyMG9mJTIwYSUyMGRvZyUyMiU1RCUyQyUyMHJldHVybl90ZW5zb3JzJTNEJTIycHQlMjIlMkMlMjBwYWRkaW5nJTNEVHJ1ZSUwQSklMEElMEF3aXRoJTIwdG9yY2guaW5mZXJlbmNlX21vZGUoKSUzQSUwQSUyMCUyMCUyMCUyMG91dHB1dHMlMjAlM0QlMjBtb2RlbCgqKmlucHV0cyklMEFsb2dpdHNfcGVyX2ltYWdlJTIwJTNEJTIwb3V0cHV0cy5sb2dpdHNfcGVyX2ltYWdlJTIwJTIwJTIzJTIwdGhpcyUyMGlzJTIwdGhlJTIwaW1hZ2UtdGV4dCUyMHNpbWlsYXJpdHklMjBzY29yZSUwQXByb2JzJTIwJTNEJTIwbG9naXRzX3Blcl9pbWFnZS5zb2Z0bWF4KGRpbSUzRDEpJTIwJTIwJTIzJTIwd2UlMjBjYW4lMjB0YWtlJTIwdGhlJTIwc29mdG1heCUyMHRvJTIwZ2V0JTIwdGhlJTIwbGFiZWwlMjBwcm9iYWJpbGl0aWVz",highlighted:`<span class="hljs-meta">>>> </span><span class="hljs-keyword">import</span> torch
	<span class="hljs-meta">>>> </span><span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> AutoProcessor, AlignModel
	<span class="hljs-meta">>>> </span><span class="hljs-keyword">from</span> transformers.image_utils <span class="hljs-keyword">import</span> load_image

	<span class="hljs-meta">>>> </span>model = AlignModel.from_pretrained(<span class="hljs-string">"kakaobrain/align-base"</span>)
	<span class="hljs-meta">>>> </span>processor = AutoProcessor.from_pretrained(<span class="hljs-string">"kakaobrain/align-base"</span>)

	<span class="hljs-meta">>>> </span>url = <span class="hljs-string">"http://images.cocodataset.org/val2017/000000039769.jpg"</span>
	<span class="hljs-meta">>>> </span>image = load_image(url)

	<span class="hljs-meta">>>> </span>inputs = processor(
	<span class="hljs-meta">... </span> images=image, text=[<span class="hljs-string">"a photo of a cat"</span>, <span class="hljs-string">"a photo of a dog"</span>], return_tensors=<span class="hljs-string">"pt"</span>, padding=<span class="hljs-literal">True</span>
	<span class="hljs-meta">... </span>)

	<span class="hljs-meta">>>> </span><span class="hljs-keyword">with</span> torch.inference_mode():
	<span class="hljs-meta">... </span> outputs = model(**inputs)
	<span class="hljs-meta">>>> </span>logits_per_image = outputs.logits_per_image <span class="hljs-comment"># this is the image-text similarity score</span>
	<span class="hljs-meta">>>> </span>probs = logits_per_image.softmax(dim=<span class="hljs-number">1</span>) <span class="hljs-comment"># we can take the softmax to get the label probabilities</span>`,lang:"python",wrap:!1}}),{c(){n=m("p"),n.textContent=f,o=i(),h(r.$$.fragment)},l(t){n=g(t,"P",{"data-svelte-h":!0}),T(n)!=="svelte-kvfsh7"&&(n.textContent=f),o=l(t),u(r.$$.fragment,t)},m(t,w){p(t,n,w),p(t,o,w),_(r,t,w),d=!0},p:R,i(t){d\|\|(b(r.$$.fragment,t),d=!0)},o(t){y(r.$$.fragment,t),d=!1},d(t){t&&(a(n),a(o)),M(r,t)}}}function Ro(v){let n,f="Examples:",o,r,d;return r=new E({props:{code:"aW1wb3J0JTIwdG9yY2glMEFmcm9tJTIwdHJhbnNmb3JtZXJzJTIwaW1wb3J0JTIwQXV0b1Rva2VuaXplciUyQyUyMEFsaWduTW9kZWwlMEElMEFtb2RlbCUyMCUzRCUyMEFsaWduTW9kZWwuZnJvbV9wcmV0cmFpbmVkKCUyMmtha2FvYnJhaW4lMkZhbGlnbi1iYXNlJTIyKSUwQXRva2VuaXplciUyMCUzRCUyMEF1dG9Ub2tlbml6ZXIuZnJvbV9wcmV0cmFpbmVkKCUyMmtha2FvYnJhaW4lMkZhbGlnbi1iYXNlJTIyKSUwQSUwQWlucHV0cyUyMCUzRCUyMHRva2VuaXplciglNUIlMjJhJTIwcGhvdG8lMjBvZiUyMGElMjBjYXQlMjIlMkMlMjAlMjJhJTIwcGhvdG8lMjBvZiUyMGElMjBkb2clMjIlNUQlMkMlMjBwYWRkaW5nJTNEVHJ1ZSUyQyUyMHJldHVybl90ZW5zb3JzJTNEJTIycHQlMjIpJTBBd2l0aCUyMHRvcmNoLmluZmVyZW5jZV9tb2RlKCklM0ElMEElMjAlMjAlMjAlMjB0ZXh0X2ZlYXR1cmVzJTIwJTNEJTIwbW9kZWwuZ2V0X3RleHRfZmVhdHVyZXMoKippbnB1dHMp",highlighted:`<span class="hljs-meta">>>> </span><span class="hljs-keyword">import</span> torch
	<span class="hljs-meta">>>> </span><span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> AutoTokenizer, AlignModel

	<span class="hljs-meta">>>> </span>model = AlignModel.from_pretrained(<span class="hljs-string">"kakaobrain/align-base"</span>)
	<span class="hljs-meta">>>> </span>tokenizer = AutoTokenizer.from_pretrained(<span class="hljs-string">"kakaobrain/align-base"</span>)

	<span class="hljs-meta">>>> </span>inputs = tokenizer([<span class="hljs-string">"a photo of a cat"</span>, <span class="hljs-string">"a photo of a dog"</span>], padding=<span class="hljs-literal">True</span>, return_tensors=<span class="hljs-string">"pt"</span>)
	<span class="hljs-meta">>>> </span><span class="hljs-keyword">with</span> torch.inference_mode():
	<span class="hljs-meta">... </span> text_features = model.get_text_features(**inputs)`,lang:"python",wrap:!1}}),{c(){n=m("p"),n.textContent=f,o=i(),h(r.$$.fragment)},l(t){n=g(t,"P",{"data-svelte-h":!0}),T(n)!=="svelte-kvfsh7"&&(n.textContent=f),o=l(t),u(r.$$.fragment,t)},m(t,w){p(t,n,w),p(t,o,w),_(r,t,w),d=!0},p:R,i(t){d\|\|(b(r.$$.fragment,t),d=!0)},o(t){y(r.$$.fragment,t),d=!1},d(t){t&&(a(n),a(o)),M(r,t)}}}function Ho(v){let n,f="Examples:",o,r,d;return r=new E({props:{code:"aW1wb3J0JTIwdG9yY2glMEFmcm9tJTIwdHJhbnNmb3JtZXJzJTIwaW1wb3J0JTIwQXV0b1Byb2Nlc3NvciUyQyUyMEFsaWduTW9kZWwlMEFmcm9tJTIwdHJhbnNmb3JtZXJzLmltYWdlX3V0aWxzJTIwaW1wb3J0JTIwbG9hZF9pbWFnZSUwQSUwQW1vZGVsJTIwJTNEJTIwQWxpZ25Nb2RlbC5mcm9tX3ByZXRyYWluZWQoJTIya2FrYW9icmFpbiUyRmFsaWduLWJhc2UlMjIpJTBBcHJvY2Vzc29yJTIwJTNEJTIwQXV0b1Byb2Nlc3Nvci5mcm9tX3ByZXRyYWluZWQoJTIya2FrYW9icmFpbiUyRmFsaWduLWJhc2UlMjIpJTBBJTBBdXJsJTIwJTNEJTIwJTIyaHR0cCUzQSUyRiUyRmltYWdlcy5jb2NvZGF0YXNldC5vcmclMkZ2YWwyMDE3JTJGMDAwMDAwMDM5NzY5LmpwZyUyMiUwQWltYWdlJTIwJTNEJTIwbG9hZF9pbWFnZSh1cmwpJTBBJTBBaW5wdXRzJTIwJTNEJTIwcHJvY2Vzc29yKGltYWdlcyUzRGltYWdlJTJDJTIwcmV0dXJuX3RlbnNvcnMlM0QlMjJwdCUyMiklMEF3aXRoJTIwdG9yY2guaW5mZXJlbmNlX21vZGUoKSUzQSUwQSUyMCUyMCUyMCUyMGltYWdlX2ZlYXR1cmVzJTIwJTNEJTIwbW9kZWwuZ2V0X2ltYWdlX2ZlYXR1cmVzKCoqaW5wdXRzKQ==",highlighted:`<span class="hljs-meta">>>> </span><span class="hljs-keyword">import</span> torch
	<span class="hljs-meta">>>> </span><span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> AutoProcessor, AlignModel
	<span class="hljs-meta">>>> </span><span class="hljs-keyword">from</span> transformers.image_utils <span class="hljs-keyword">import</span> load_image

	<span class="hljs-meta">>>> </span>model = AlignModel.from_pretrained(<span class="hljs-string">"kakaobrain/align-base"</span>)
	<span class="hljs-meta">>>> </span>processor = AutoProcessor.from_pretrained(<span class="hljs-string">"kakaobrain/align-base"</span>)

	<span class="hljs-meta">>>> </span>url = <span class="hljs-string">"http://images.cocodataset.org/val2017/000000039769.jpg"</span>
	<span class="hljs-meta">>>> </span>image = load_image(url)

	<span class="hljs-meta">>>> </span>inputs = processor(images=image, return_tensors=<span class="hljs-string">"pt"</span>)
	<span class="hljs-meta">>>> </span><span class="hljs-keyword">with</span> torch.inference_mode():
	<span class="hljs-meta">... </span> image_features = model.get_image_features(**inputs)`,lang:"python",wrap:!1}}),{c(){n=m("p"),n.textContent=f,o=i(),h(r.$$.fragment)},l(t){n=g(t,"P",{"data-svelte-h":!0}),T(n)!=="svelte-kvfsh7"&&(n.textContent=f),o=l(t),u(r.$$.fragment,t)},m(t,w){p(t,n,w),p(t,o,w),_(r,t,w),d=!0},p:R,i(t){d\|\|(b(r.$$.fragment,t),d=!0)},o(t){y(r.$$.fragment,t),d=!1},d(t){t&&(a(n),a(o)),M(r,t)}}}function Fo(v){let n,f=`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(){n=m("p"),n.innerHTML=f},l(o){n=g(o,"P",{"data-svelte-h":!0}),T(n)!=="svelte-fincs2"&&(n.innerHTML=f)},m(o,r){p(o,n,r)},p:R,d(o){o&&a(n)}}}function Xo(v){let n,f="Examples:",o,r,d;return r=new E({props:{code:"ZnJvbSUyMHRyYW5zZm9ybWVycyUyMGltcG9ydCUyMEF1dG9Ub2tlbml6ZXIlMkMlMjBBbGlnblRleHRNb2RlbCUwQSUwQW1vZGVsJTIwJTNEJTIwQWxpZ25UZXh0TW9kZWwuZnJvbV9wcmV0cmFpbmVkKCUyMmtha2FvYnJhaW4lMkZhbGlnbi1iYXNlJTIyKSUwQXRva2VuaXplciUyMCUzRCUyMEF1dG9Ub2tlbml6ZXIuZnJvbV9wcmV0cmFpbmVkKCUyMmtha2FvYnJhaW4lMkZhbGlnbi1iYXNlJTIyKSUwQSUwQWlucHV0cyUyMCUzRCUyMHRva2VuaXplciglNUIlMjJhJTIwcGhvdG8lMjBvZiUyMGElMjBjYXQlMjIlMkMlMjAlMjJhJTIwcGhvdG8lMjBvZiUyMGElMjBkb2clMjIlNUQlMkMlMjBwYWRkaW5nJTNEVHJ1ZSUyQyUyMHJldHVybl90ZW5zb3JzJTNEJTIycHQlMjIpJTBBJTBBb3V0cHV0cyUyMCUzRCUyMG1vZGVsKCoqaW5wdXRzKSUwQWxhc3RfaGlkZGVuX3N0YXRlJTIwJTNEJTIwb3V0cHV0cy5sYXN0X2hpZGRlbl9zdGF0ZSUwQXBvb2xlZF9vdXRwdXQlMjAlM0QlMjBvdXRwdXRzLnBvb2xlcl9vdXRwdXQlMjAlMjAlMjMlMjBwb29sZWQlMjAoRU9TJTIwdG9rZW4pJTIwc3RhdGVz",highlighted:`<span class="hljs-meta">>>> </span><span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> AutoTokenizer, AlignTextModel

	<span class="hljs-meta">>>> </span>model = AlignTextModel.from_pretrained(<span class="hljs-string">"kakaobrain/align-base"</span>)
	<span class="hljs-meta">>>> </span>tokenizer = AutoTokenizer.from_pretrained(<span class="hljs-string">"kakaobrain/align-base"</span>)

	<span class="hljs-meta">>>> </span>inputs = tokenizer([<span class="hljs-string">"a photo of a cat"</span>, <span class="hljs-string">"a photo of a dog"</span>], padding=<span class="hljs-literal">True</span>, return_tensors=<span class="hljs-string">"pt"</span>)

	<span class="hljs-meta">>>> </span>outputs = model(**inputs)
	<span class="hljs-meta">>>> </span>last_hidden_state = outputs.last_hidden_state
	<span class="hljs-meta">>>> </span>pooled_output = outputs.pooler_output <span class="hljs-comment"># pooled (EOS token) states</span>`,lang:"python",wrap:!1}}),{c(){n=m("p"),n.textContent=f,o=i(),h(r.$$.fragment)},l(t){n=g(t,"P",{"data-svelte-h":!0}),T(n)!=="svelte-kvfsh7"&&(n.textContent=f),o=l(t),u(r.$$.fragment,t)},m(t,w){p(t,n,w),p(t,o,w),_(r,t,w),d=!0},p:R,i(t){d\|\|(b(r.$$.fragment,t),d=!0)},o(t){y(r.$$.fragment,t),d=!1},d(t){t&&(a(n),a(o)),M(r,t)}}}function Yo(v){let n,f=`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(){n=m("p"),n.innerHTML=f},l(o){n=g(o,"P",{"data-svelte-h":!0}),T(n)!=="svelte-fincs2"&&(n.innerHTML=f)},m(o,r){p(o,n,r)},p:R,d(o){o&&a(n)}}}function Eo(v){let n,f="Examples:",o,r,d;return r=new E({props:{code:"ZnJvbSUyMFBJTCUyMGltcG9ydCUyMEltYWdlJTBBaW1wb3J0JTIwaHR0cHglMEFmcm9tJTIwaW8lMjBpbXBvcnQlMjBCeXRlc0lPJTBBZnJvbSUyMHRyYW5zZm9ybWVycyUyMGltcG9ydCUyMEF1dG9Qcm9jZXNzb3IlMkMlMjBBbGlnblZpc2lvbk1vZGVsJTBBJTBBbW9kZWwlMjAlM0QlMjBBbGlnblZpc2lvbk1vZGVsLmZyb21fcHJldHJhaW5lZCglMjJrYWthb2JyYWluJTJGYWxpZ24tYmFzZSUyMiklMEFwcm9jZXNzb3IlMjAlM0QlMjBBdXRvUHJvY2Vzc29yLmZyb21fcHJldHJhaW5lZCglMjJrYWthb2JyYWluJTJGYWxpZ24tYmFzZSUyMiklMEElMEF1cmwlMjAlM0QlMjAlMjJodHRwJTNBJTJGJTJGaW1hZ2VzLmNvY29kYXRhc2V0Lm9yZyUyRnZhbDIwMTclMkYwMDAwMDAwMzk3NjkuanBnJTIyJTBBd2l0aCUyMGh0dHB4LnN0cmVhbSglMjJHRVQlMjIlMkMlMjB1cmwpJTIwYXMlMjByZXNwb25zZSUzQSUwQSUyMCUyMCUyMCUyMGltYWdlJTIwJTNEJTIwSW1hZ2Uub3BlbihCeXRlc0lPKHJlc3BvbnNlLnJlYWQoKSkpJTBBJTBBaW5wdXRzJTIwJTNEJTIwcHJvY2Vzc29yKGltYWdlcyUzRGltYWdlJTJDJTIwcmV0dXJuX3RlbnNvcnMlM0QlMjJwdCUyMiklMEElMEFvdXRwdXRzJTIwJTNEJTIwbW9kZWwoKippbnB1dHMpJTBBbGFzdF9oaWRkZW5fc3RhdGUlMjAlM0QlMjBvdXRwdXRzLmxhc3RfaGlkZGVuX3N0YXRlJTBBcG9vbGVkX291dHB1dCUyMCUzRCUyMG91dHB1dHMucG9vbGVyX291dHB1dCUyMCUyMCUyMyUyMHBvb2xlZCUyMENMUyUyMHN0YXRlcw==",highlighted:`<span class="hljs-meta">>>> </span><span class="hljs-keyword">from</span> PIL <span class="hljs-keyword">import</span> Image
	<span class="hljs-meta">>>> </span><span class="hljs-keyword">import</span> httpx
	<span class="hljs-meta">>>> </span><span class="hljs-keyword">from</span> io <span class="hljs-keyword">import</span> BytesIO
	<span class="hljs-meta">>>> </span><span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> AutoProcessor, AlignVisionModel

	<span class="hljs-meta">>>> </span>model = AlignVisionModel.from_pretrained(<span class="hljs-string">"kakaobrain/align-base"</span>)
	<span class="hljs-meta">>>> </span>processor = AutoProcessor.from_pretrained(<span class="hljs-string">"kakaobrain/align-base"</span>)

	<span class="hljs-meta">>>> </span>url = <span class="hljs-string">"http://images.cocodataset.org/val2017/000000039769.jpg"</span>
	<span class="hljs-meta">>>> </span><span class="hljs-keyword">with</span> httpx.stream(<span class="hljs-string">"GET"</span>, url) <span class="hljs-keyword">as</span> response:
	<span class="hljs-meta">... </span> image = Image.<span class="hljs-built_in">open</span>(BytesIO(response.read()))

	<span class="hljs-meta">>>> </span>inputs = processor(images=image, return_tensors=<span class="hljs-string">"pt"</span>)

	<span class="hljs-meta">>>> </span>outputs = model(**inputs)
	<span class="hljs-meta">>>> </span>last_hidden_state = outputs.last_hidden_state
	<span class="hljs-meta">>>> </span>pooled_output = outputs.pooler_output <span class="hljs-comment"># pooled CLS states</span>`,lang:"python",wrap:!1}}),{c(){n=m("p"),n.textContent=f,o=i(),h(r.$$.fragment)},l(t){n=g(t,"P",{"data-svelte-h":!0}),T(n)!=="svelte-kvfsh7"&&(n.textContent=f),o=l(t),u(r.$$.fragment,t)},m(t,w){p(t,n,w),p(t,o,w),_(r,t,w),d=!0},p:R,i(t){d\|\|(b(r.$$.fragment,t),d=!0)},o(t){y(r.$$.fragment,t),d=!1},d(t){t&&(a(n),a(o)),M(r,t)}}}function Qo(v){let n,f,o,r,d,t="<em>This model was published in HF papers on 2021-02-11 and contributed to Hugging Face Transformers on 2023-03-01.</em>",w,Q,Jt,te,Xn='<div class="flex flex-wrap space-x-1"><img alt="Transformers" src="https://img.shields.io/badge/Transformers-6B5B95?style=flat&logo=transformers&logoColor=white"/></div>',Ut,ue,jt,_e,Yn='<a href="https://huggingface.co/papers/2102.05918" rel="nofollow">ALIGN</a> is pretrained on a noisy 1.8 billion alt‑text and image pair dataset to show that scale can make up for the noise. It uses a dual‑encoder architecture, <a href="./efficientnet">EfficientNet</a> for images and <a href="./bert">BERT</a> for text, and a contrastive loss to align similar image–text embeddings together while pushing different embeddings apart. Once trained, ALIGN can encode any image and candidate captions into a shared vector space for zero‑shot retrieval or classification without requiring extra labels. This scale‑first approach reduces dataset curation costs and powers state‑of‑the‑art image–text retrieval and zero‑shot ImageNet classification.',kt,be,En='You can find all the original ALIGN checkpoints under the <a href="https://huggingface.co/kakaobrain?search_models=align" rel="nofollow">Kakao Brain</a> organization.',$t,ne,Qn="<p>Click on the ALIGN models in the right sidebar for more examples of how to apply ALIGN to different vision and text related tasks.</p>",xt,ye,Pn='The example below demonstrates zero-shot image classification with <a href="/docs/transformers/pr_43265/en/main_classes/pipelines#transformers.Pipeline">Pipeline</a> or the <a href="/docs/transformers/pr_43265/en/model_doc/auto#transformers.AutoModel">AutoModel</a> class.',Wt,oe,Zt,Me,Ct,Pe,Te,qe,qn='ALIGN projects the text and visual features into latent space and the dot product between the projected image and text features is used as the similarity score. The example below demonstrates how to calculate the image-text similarity score with <a href="/docs/transformers/pr_43265/en/model_doc/align#transformers.AlignProcessor">AlignProcessor</a> and <a href="/docs/transformers/pr_43265/en/model_doc/align#transformers.AlignModel">AlignModel</a>.',Kt,we,It,ve,Bt,Je,Sn='<li>Refer to the <a href="https://huggingface.co/blog/vit-align" rel="nofollow">Kakao Brain’s Open Source ViT, ALIGN, and the New COYO Text-Image Dataset</a> blog post for more details.</li>',zt,Ue,At,I,je,Ot,Se,Ln=`This is the configuration class to store the configuration of a AlignModel. It is used to instantiate a Align
	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 <a href="https://huggingface.co/kakaobrain/align-base" rel="nofollow">kakaobrain/align-base</a>`,en,Le,Dn=`Configuration objects inherit from <a href="/docs/transformers/pr_43265/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_43265/en/main_classes/configuration#transformers.PreTrainedConfig">PreTrainedConfig</a> for more information.`,tn,se,Nt,ke,Gt,B,$e,nn,De,Kn=`This is the configuration class to store the configuration of a AlignModel. It is used to instantiate a Align
	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 <a href="https://huggingface.co/kakaobrain/align-base" rel="nofollow">kakaobrain/align-base</a>`,on,Ke,On=`Configuration objects inherit from <a href="/docs/transformers/pr_43265/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_43265/en/main_classes/configuration#transformers.PreTrainedConfig">PreTrainedConfig</a> for more information.`,sn,ae,Vt,xe,Rt,z,We,an,Oe,eo=`This is the configuration class to store the configuration of a AlignModel. It is used to instantiate a Align
	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 <a href="https://huggingface.co/kakaobrain/align-base" rel="nofollow">kakaobrain/align-base</a>`,rn,et,to=`Configuration objects inherit from <a href="/docs/transformers/pr_43265/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_43265/en/main_classes/configuration#transformers.PreTrainedConfig">PreTrainedConfig</a> for more information.`,ln,re,Ht,Ze,Ft,A,Ce,cn,tt,no="Constructs a AlignProcessor which wraps a image processor and a tokenizer into a single processor.",dn,nt,oo=`<a href="/docs/transformers/pr_43265/en/model_doc/align#transformers.AlignProcessor">AlignProcessor</a> offers all the functionalities of <a href="/docs/transformers/pr_43265/en/model_doc/efficientnet#transformers.EfficientNetImageProcessor">EfficientNetImageProcessor</a> and <a href="/docs/transformers/pr_43265/en/model_doc/lxmert#transformers.BertTokenizer">BertTokenizer</a>. See the
	<a href="/docs/transformers/pr_43265/en/model_doc/efficientnet#transformers.EfficientNetImageProcessor">~EfficientNetImageProcessor</a> and <a href="/docs/transformers/pr_43265/en/model_doc/lxmert#transformers.BertTokenizer">~BertTokenizer</a> for more information.`,pn,ot,Ie,Xt,Be,Yt,J,ze,mn,st,so="The bare Align Model outputting raw hidden-states without any specific head on top.",gn,at,ao=`This model inherits from <a href="/docs/transformers/pr_43265/en/main_classes/model#transformers.PreTrainedModel">PreTrainedModel</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.)`,fn,rt,ro=`This model is also a PyTorch <a href="https://pytorch.org/docs/stable/nn.html#torch.nn.Module" rel="nofollow">torch.nn.Module</a> subclass.
	Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
	and behavior.`,hn,W,Ae,un,it,io='The <a href="/docs/transformers/pr_43265/en/model_doc/align#transformers.AlignModel">AlignModel</a> forward method, overrides the <code>__call__</code> special method.',_n,ie,bn,lt,lo=`<li><strong>loss</strong> (<code>torch.FloatTensor</code> of shape <code>(1,)</code>, <em>optional</em>, returned when <code>return_loss</code> is <code>True</code>) — Contrastive loss for image-text similarity.</li> <li><strong>logits_per_image</strong> (<code>torch.FloatTensor</code> of shape <code>(image_batch_size, text_batch_size)</code>) — The scaled dot product scores between <code>image_embeds</code> and <code>text_embeds</code>. This represents the image-text
	similarity scores.</li> <li><strong>logits_per_text</strong> (<code>torch.FloatTensor</code> of shape <code>(text_batch_size, image_batch_size)</code>) — The scaled dot product scores between <code>text_embeds</code> and <code>image_embeds</code>. This represents the text-image
	similarity scores.</li> <li><strong>text_embeds</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, output_dim</code>) — The text embeddings obtained by applying the projection layer to the pooled output of <a href="/docs/transformers/pr_43265/en/model_doc/align#transformers.AlignTextModel">AlignTextModel</a>.</li> <li><strong>image_embeds</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, output_dim</code>) — The output of <a href="/docs/transformers/pr_43265/en/model_doc/align#transformers.AlignVisionModel">AlignVisionModel</a>.</li> <li><strong>text_model_output</strong> (<code>~modeling_outputs.BaseModelOutputWithPooling</code>, <em>optional</em>) — The output of the <a href="/docs/transformers/pr_43265/en/model_doc/align#transformers.AlignTextModel">AlignTextModel</a>.</li> <li><strong>vision_model_output</strong> (<code>~modeling_outputs.BaseModelOutputWithPoolingAndNoAttention</code>, <em>optional</em>) — The output of the <a href="/docs/transformers/pr_43265/en/model_doc/align#transformers.AlignVisionModel">AlignVisionModel</a>.</li>`,yn,le,Mn,P,Ne,Tn,ct,co=`<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>pooler_output</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, hidden_size)</code>) — Last layer hidden-state of the first token of the sequence (classification token) after further processing
	through the layers used for the auxiliary pretraining task. E.g. for BERT-family of models, this returns
	the classification token after processing through a linear layer and a tanh activation function. The linear
	layer weights are trained from the next sentence prediction (classification) objective during pretraining.</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>`,wn,ce,vn,q,Ge,Jn,dt,po=`<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>pooler_output</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, hidden_size)</code>) — Last layer hidden-state of the first token of the sequence (classification token) after further processing
	through the layers used for the auxiliary pretraining task. E.g. for BERT-family of models, this returns
	the classification token after processing through a linear layer and a tanh activation function. The linear
	layer weights are trained from the next sentence prediction (classification) objective during pretraining.</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>`,Un,de,Et,Ve,Qt,$,Re,jn,pt,mo="The text model from ALIGN without any head or projection on top.",kn,mt,go=`This model inherits from <a href="/docs/transformers/pr_43265/en/main_classes/model#transformers.PreTrainedModel">PreTrainedModel</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.)`,$n,gt,fo=`This model is also a PyTorch <a href="https://pytorch.org/docs/stable/nn.html#torch.nn.Module" rel="nofollow">torch.nn.Module</a> subclass.
	Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
	and behavior.`,xn,Z,He,Wn,ft,ho='The <a href="/docs/transformers/pr_43265/en/model_doc/align#transformers.AlignTextModel">AlignTextModel</a> forward method, overrides the <code>__call__</code> special method.',Zn,pe,Cn,ht,uo=`<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>pooler_output</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, hidden_size)</code>) — Last layer hidden-state of the first token of the sequence (classification token) after further processing
	through the layers used for the auxiliary pretraining task. E.g. for BERT-family of models, this returns
	the classification token after processing through a linear layer and a tanh activation function. The linear
	layer weights are trained from the next sentence prediction (classification) objective during pretraining.</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>`,In,me,Pt,Fe,qt,x,Xe,Bn,ut,_o="The vision model from ALIGN without any head or projection on top.",zn,_t,bo=`This model inherits from <a href="/docs/transformers/pr_43265/en/main_classes/model#transformers.PreTrainedModel">PreTrainedModel</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.)`,An,bt,yo=`This model is also a PyTorch <a href="https://pytorch.org/docs/stable/nn.html#torch.nn.Module" rel="nofollow">torch.nn.Module</a> subclass.
	Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
	and behavior.`,Nn,C,Ye,Gn,yt,Mo='The <a href="/docs/transformers/pr_43265/en/model_doc/align#transformers.AlignVisionModel">AlignVisionModel</a> forward method, overrides the <code>__call__</code> special method.',Vn,ge,Rn,Mt,To=`<li><p><strong>last_hidden_state</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, num_channels, height, width)</code>) — Sequence of hidden-states at the output of the last layer of the model.</p></li> <li><p><strong>pooler_output</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, hidden_size)</code>) — Last layer hidden-state after a pooling operation on the spatial dimensions.</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, num_channels, height, width)</code>.</p> <p>Hidden-states of the model at the output of each layer plus the optional initial embedding outputs.</p></li>`,Hn,fe,St,Ee,Lt,Tt,Dt;return Q=new xo({props:{containerStyle:"float: right; margin-left: 10px; display: inline-flex; position: relative; z-index: 10;"}}),ue=new K({props:{title:"ALIGN",local:"align",headingTag:"h1"}}),oe=new Zo({props:{id:"usage",options:["Pipeline","AutoModel"],$$slots:{default:[Bo]},$$scope:{ctx:v}}}),Me=new K({props:{title:"Notes",local:"notes",headingTag:"h2"}}),we=new E({props:{code:"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",highlighted:`<span class="hljs-comment"># Example of using ALIGN for image-text similarity</span>
	<span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> AlignProcessor, AlignModel
	<span class="hljs-keyword">import</span> torch
	<span class="hljs-keyword">from</span> PIL <span class="hljs-keyword">import</span> Image
	<span class="hljs-keyword">import</span> requests
	<span class="hljs-keyword">from</span> io <span class="hljs-keyword">import</span> BytesIO

	<span class="hljs-comment"># Load processor and model</span>
	processor = AlignProcessor.from_pretrained(<span class="hljs-string">"kakaobrain/align-base"</span>)
	model = AlignModel.from_pretrained(<span class="hljs-string">"kakaobrain/align-base"</span>, device_map=<span class="hljs-string">"auto"</span>)

	<span class="hljs-comment"># Download image from URL</span>
	url = <span class="hljs-string">"https://huggingface.co/roschmid/dog-races/resolve/main/images/Golden_Retriever.jpg"</span>
	response = requests.get(url)
	image = Image.<span class="hljs-built_in">open</span>(BytesIO(response.content)) <span class="hljs-comment"># Convert the downloaded bytes to a PIL Image</span>

	texts = [<span class="hljs-string">"a photo of a cat"</span>, <span class="hljs-string">"a photo of a dog"</span>]

	<span class="hljs-comment"># Process image and text inputs</span>
	inputs = processor(images=image, text=texts, return_tensors=<span class="hljs-string">"pt"</span>).to(model.device)

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

	image_embeds = outputs.image_embeds
	text_embeds = outputs.text_embeds

	<span class="hljs-comment"># Normalize embeddings for cosine similarity</span>
	image_embeds = image_embeds / image_embeds.norm(dim=<span class="hljs-number">1</span>, keepdim=<span class="hljs-literal">True</span>)
	text_embeds = text_embeds / text_embeds.norm(dim=<span class="hljs-number">1</span>, keepdim=<span class="hljs-literal">True</span>)

	<span class="hljs-comment"># Calculate similarity scores</span>
	similarity_scores = torch.matmul(text_embeds, image_embeds.T)

	<span class="hljs-comment"># Print raw scores</span>
	<span class="hljs-built_in">print</span>(<span class="hljs-string">"Similarity scores:"</span>, similarity_scores)

	<span class="hljs-comment"># Convert to probabilities</span>
	probs = torch.nn.functional.softmax(similarity_scores, dim=<span class="hljs-number">0</span>)
	<span class="hljs-built_in">print</span>(<span class="hljs-string">"Probabilities:"</span>, probs)

	<span class="hljs-comment"># Get the most similar text</span>
	most_similar_idx = similarity_scores.argmax().item()
	<span class="hljs-built_in">print</span>(<span class="hljs-string">f"Most similar text: '<span class="hljs-subst">{texts[most_similar_idx]}</span>'"</span>)`,lang:"py",wrap:!1}}),ve=new K({props:{title:"Resources",local:"resources",headingTag:"h2"}}),Ue=new K({props:{title:"AlignConfig",local:"transformers.AlignConfig",headingTag:"h2"}}),je=new V({props:{name:"class transformers.AlignConfig",anchor:"transformers.AlignConfig",parameters:[{name:"transformers_version",val:": str \| None = None"},{name:"architectures",val:": list[str] \| None = None"},{name:"output_hidden_states",val:": bool \| None = False"},{name:"return_dict",val:": bool \| None = True"},{name:"dtype",val:": typing.Union[str, ForwardRef('torch.dtype'), NoneType] = None"},{name:"chunk_size_feed_forward",val:": int = 0"},{name:"is_encoder_decoder",val:": bool = False"},{name:"id2label",val:": dict[int, str] \| dict[str, str] \| None = None"},{name:"label2id",val:": dict[str, int] \| dict[str, str] \| None = None"},{name:"problem_type",val:": typing.Optional[typing.Literal['regression', 'single_label_classification', 'multi_label_classification']] = None"},{name:"text_config",val:": dict \| transformers.configuration_utils.PreTrainedConfig \| None = None"},{name:"vision_config",val:": dict \| transformers.configuration_utils.PreTrainedConfig \| None = None"},{name:"projection_dim",val:": int = 640"},{name:"temperature_init_value",val:": float = 1.0"},{name:"initializer_range",val:": float = 0.02"}],parametersDescription:[{anchor:"transformers.AlignConfig.text_config",description:`<strong>text_config</strong> (<code>Union[dict, ~configuration_utils.PreTrainedConfig]</code>, <em>optional</em>) —
	The config object or dictionary of the text backbone.`,name:"text_config"},{anchor:"transformers.AlignConfig.vision_config",description:`<strong>vision_config</strong> (<code>Union[dict, ~configuration_utils.PreTrainedConfig]</code>, <em>optional</em>) —
	The config object or dictionary of the vision backbone.`,name:"vision_config"},{anchor:"transformers.AlignConfig.projection_dim",description:`<strong>projection_dim</strong> (<code>int</code>, <em>optional</em>, defaults to <code>640</code>) —
	Dimensionality of text and vision projection layers.`,name:"projection_dim"},{anchor:"transformers.AlignConfig.temperature_init_value",description:`<strong>temperature_init_value</strong> (<code>float</code>, <em>optional</em>, defaults to 1.0) —
	The initial value of the <em>temperature</em> parameter. Default is used as per the original ALIGN implementation.`,name:"temperature_init_value"},{anchor:"transformers.AlignConfig.initializer_range",description:`<strong>initializer_range</strong> (<code>float</code>, <em>optional</em>, defaults to <code>0.02</code>) —
	The standard deviation of the truncated_normal_initializer for initializing all weight matrices.`,name:"initializer_range"}],source:"https://github.com/huggingface/transformers/blob/vr_43265/src/transformers/models/align/configuration_align.py#L157"}}),se=new he({props:{anchor:"transformers.AlignConfig.example",$$slots:{default:[zo]},$$scope:{ctx:v}}}),ke=new K({props:{title:"AlignTextConfig",local:"transformers.AlignTextConfig",headingTag:"h2"}}),$e=new V({props:{name:"class transformers.AlignTextConfig",anchor:"transformers.AlignTextConfig",parameters:[{name:"transformers_version",val:": str \| None = None"},{name:"architectures",val:": list[str] \| None = None"},{name:"output_hidden_states",val:": bool \| None = False"},{name:"return_dict",val:": bool \| None = True"},{name:"dtype",val:": typing.Union[str, ForwardRef('torch.dtype'), NoneType] = None"},{name:"chunk_size_feed_forward",val:": int = 0"},{name:"is_encoder_decoder",val:": bool = False"},{name:"id2label",val:": dict[int, str] \| dict[str, str] \| None = None"},{name:"label2id",val:": dict[str, int] \| dict[str, str] \| None = None"},{name:"problem_type",val:": typing.Optional[typing.Literal['regression', 'single_label_classification', 'multi_label_classification']] = None"},{name:"vocab_size",val:": int = 30522"},{name:"hidden_size",val:": int = 768"},{name:"num_hidden_layers",val:": int = 12"},{name:"num_attention_heads",val:": int = 12"},{name:"intermediate_size",val:": int = 3072"},{name:"hidden_act",val:": str = 'gelu'"},{name:"hidden_dropout_prob",val:": float \| int = 0.1"},{name:"attention_probs_dropout_prob",val:": float \| int = 0.1"},{name:"max_position_embeddings",val:": int = 512"},{name:"type_vocab_size",val:": int = 2"},{name:"initializer_range",val:": float = 0.02"},{name:"layer_norm_eps",val:": float = 1e-12"},{name:"pad_token_id",val:": int \| None = 0"},{name:"bos_token_id",val:": int \| None = None"},{name:"eos_token_id",val:": int \| list[int] \| None = None"}],parametersDescription:[{anchor:"transformers.AlignTextConfig.vocab_size",description:`<strong>vocab_size</strong> (<code>int</code>, <em>optional</em>, defaults to <code>30522</code>) —
	Vocabulary size of the model. Defines the number of different tokens that can be represented by the <code>input_ids</code>.`,name:"vocab_size"},{anchor:"transformers.AlignTextConfig.hidden_size",description:`<strong>hidden_size</strong> (<code>int</code>, <em>optional</em>, defaults to <code>768</code>) —
	Dimension of the hidden representations.`,name:"hidden_size"},{anchor:"transformers.AlignTextConfig.num_hidden_layers",description:`<strong>num_hidden_layers</strong> (<code>int</code>, <em>optional</em>, defaults to <code>12</code>) —
	Number of hidden layers in the Transformer decoder.`,name:"num_hidden_layers"},{anchor:"transformers.AlignTextConfig.num_attention_heads",description:`<strong>num_attention_heads</strong> (<code>int</code>, <em>optional</em>, defaults to <code>12</code>) —
	Number of attention heads for each attention layer in the Transformer decoder.`,name:"num_attention_heads"},{anchor:"transformers.AlignTextConfig.intermediate_size",description:`<strong>intermediate_size</strong> (<code>int</code>, <em>optional</em>, defaults to <code>3072</code>) —
	Dimension of the MLP representations.`,name:"intermediate_size"},{anchor:"transformers.AlignTextConfig.hidden_act",description:`<strong>hidden_act</strong> (<code>str</code>, <em>optional</em>, defaults to <code>gelu</code>) —
	The non-linear activation function (function or string) in the decoder. For example, <code>"gelu"</code>,
	<code>"relu"</code>, <code>"silu"</code>, etc.`,name:"hidden_act"},{anchor:"transformers.AlignTextConfig.hidden_dropout_prob",description:`<strong>hidden_dropout_prob</strong> (<code>Union[float, int]</code>, <em>optional</em>, defaults to <code>0.1</code>) —
	The dropout probability for all fully connected layers in the embeddings, encoder, and pooler.`,name:"hidden_dropout_prob"},{anchor:"transformers.AlignTextConfig.attention_probs_dropout_prob",description:`<strong>attention_probs_dropout_prob</strong> (<code>Union[float, int]</code>, <em>optional</em>, defaults to <code>0.1</code>) —
	The dropout ratio for the attention probabilities.`,name:"attention_probs_dropout_prob"},{anchor:"transformers.AlignTextConfig.max_position_embeddings",description:`<strong>max_position_embeddings</strong> (<code>int</code>, <em>optional</em>, defaults to <code>512</code>) —
	The maximum sequence length that this model might ever be used with.`,name:"max_position_embeddings"},{anchor:"transformers.AlignTextConfig.type_vocab_size",description:`<strong>type_vocab_size</strong> (<code>int</code>, <em>optional</em>, defaults to <code>2</code>) —
	The vocabulary size of the <code>token_type_ids</code>.`,name:"type_vocab_size"},{anchor:"transformers.AlignTextConfig.initializer_range",description:`<strong>initializer_range</strong> (<code>float</code>, <em>optional</em>, defaults to <code>0.02</code>) —
	The standard deviation of the truncated_normal_initializer for initializing all weight matrices.`,name:"initializer_range"},{anchor:"transformers.AlignTextConfig.layer_norm_eps",description:`<strong>layer_norm_eps</strong> (<code>float</code>, <em>optional</em>, defaults to <code>1e-12</code>) —
	The epsilon used by the layer normalization layers.`,name:"layer_norm_eps"},{anchor:"transformers.AlignTextConfig.pad_token_id",description:`<strong>pad_token_id</strong> (<code>int</code>, <em>optional</em>, defaults to <code>0</code>) —
	Token id used for padding in the vocabulary.`,name:"pad_token_id"},{anchor:"transformers.AlignTextConfig.bos_token_id",description:`<strong>bos_token_id</strong> (<code>int</code>, <em>optional</em>) —
	Token id used for beginning-of-stream in the vocabulary.`,name:"bos_token_id"},{anchor:"transformers.AlignTextConfig.eos_token_id",description:`<strong>eos_token_id</strong> (<code>Union[int, list[int]]</code>, <em>optional</em>) —
	Token id used for end-of-stream in the vocabulary.`,name:"eos_token_id"}],source:"https://github.com/huggingface/transformers/blob/vr_43265/src/transformers/models/align/configuration_align.py#L27"}}),ae=new he({props:{anchor:"transformers.AlignTextConfig.example",$$slots:{default:[Ao]},$$scope:{ctx:v}}}),xe=new K({props:{title:"AlignVisionConfig",local:"transformers.AlignVisionConfig",headingTag:"h2"}}),We=new V({props:{name:"class transformers.AlignVisionConfig",anchor:"transformers.AlignVisionConfig",parameters:[{name:"transformers_version",val:": str \| None = None"},{name:"architectures",val:": list[str] \| None = None"},{name:"output_hidden_states",val:": bool \| None = False"},{name:"return_dict",val:": bool \| None = True"},{name:"dtype",val:": typing.Union[str, ForwardRef('torch.dtype'), NoneType] = None"},{name:"chunk_size_feed_forward",val:": int = 0"},{name:"is_encoder_decoder",val:": bool = False"},{name:"id2label",val:": dict[int, str] \| dict[str, str] \| None = None"},{name:"label2id",val:": dict[str, int] \| dict[str, str] \| None = None"},{name:"problem_type",val:": typing.Optional[typing.Literal['regression', 'single_label_classification', 'multi_label_classification']] = None"},{name:"num_channels",val:": int = 3"},{name:"image_size",val:": int \| list[int] \| tuple[int, int] = 600"},{name:"width_coefficient",val:": float = 2.0"},{name:"depth_coefficient",val:": float = 3.1"},{name:"depth_divisor",val:": int = 8"},{name:"kernel_sizes",val:": list[int] \| tuple[int, ...] = (3, 3, 5, 3, 5, 5, 3)"},{name:"in_channels",val:": list[int] \| tuple[int, ...] = (32, 16, 24, 40, 80, 112, 192)"},{name:"out_channels",val:": list[int] \| tuple[int, ...] = (16, 24, 40, 80, 112, 192, 320)"},{name:"depthwise_padding",val:": list \| tuple[int, ...] = ()"},{name:"strides",val:": list[int] \| tuple[int, ...] = (1, 2, 2, 2, 1, 2, 1)"},{name:"num_block_repeats",val:": list[int] \| tuple[int, ...] = (1, 2, 2, 3, 3, 4, 1)"},{name:"expand_ratios",val:": list[int] \| tuple[int, ...] = (1, 6, 6, 6, 6, 6, 6)"},{name:"squeeze_expansion_ratio",val:": float = 0.25"},{name:"hidden_act",val:": str = 'swish'"},{name:"hidden_dim",val:": int = 2560"},{name:"pooling_type",val:": str = 'mean'"},{name:"initializer_range",val:": float = 0.02"},{name:"batch_norm_eps",val:": float = 0.001"},{name:"batch_norm_momentum",val:": float = 0.99"},{name:"drop_connect_rate",val:": float \| int = 0.2"}],parametersDescription:[{anchor:"transformers.AlignVisionConfig.num_channels",description:`<strong>num_channels</strong> (<code>int</code>, <em>optional</em>, defaults to <code>3</code>) —
	The number of input channels.`,name:"num_channels"},{anchor:"transformers.AlignVisionConfig.image_size",description:`<strong>image_size</strong> (<code>Union[int, list[int], tuple[int, int]]</code>, <em>optional</em>, defaults to <code>600</code>) —
	The size (resolution) of each image.`,name:"image_size"},{anchor:"transformers.AlignVisionConfig.width_coefficient",description:`<strong>width_coefficient</strong> (<code>float</code>, <em>optional</em>, defaults to 2.0) —
	Scaling coefficient for network width at each stage.`,name:"width_coefficient"},{anchor:"transformers.AlignVisionConfig.depth_coefficient",description:`<strong>depth_coefficient</strong> (<code>float</code>, <em>optional</em>, defaults to 3.1) —
	Scaling coefficient for network depth at each stage.`,name:"depth_coefficient"},{anchor:"transformers.AlignVisionConfig.depth_divisor",description:`<strong>depth_divisor</strong> (<code>int</code>, <em>optional</em>, defaults to 8) —
	A unit of network width.`,name:"depth_divisor"},{anchor:"transformers.AlignVisionConfig.kernel_sizes",description:`<strong>kernel_sizes</strong> (<code>list[int]</code>, <em>optional</em>, defaults to <code>[3, 3, 5, 3, 5, 5, 3]</code>) —
	List of kernel sizes to be used in each block.`,name:"kernel_sizes"},{anchor:"transformers.AlignVisionConfig.in_channels",description:`<strong>in_channels</strong> (<code>list[int]</code>, <em>optional</em>, defaults to <code>[32, 16, 24, 40, 80, 112, 192]</code>) —
	List of input channel sizes to be used in each block for convolutional layers.`,name:"in_channels"},{anchor:"transformers.AlignVisionConfig.out_channels",description:`<strong>out_channels</strong> (<code>list[int]</code>, <em>optional</em>, defaults to <code>[16, 24, 40, 80, 112, 192, 320]</code>) —
	List of output channel sizes to be used in each block for convolutional layers.`,name:"out_channels"},{anchor:"transformers.AlignVisionConfig.depthwise_padding",description:`<strong>depthwise_padding</strong> (<code>list[int]</code>, <em>optional</em>, defaults to <code>[]</code>) —
	List of block indices with square padding.`,name:"depthwise_padding"},{anchor:"transformers.AlignVisionConfig.strides",description:`<strong>strides</strong> (<code>list[int]</code>, <em>optional</em>, defaults to <code>[1, 2, 2, 2, 1, 2, 1]</code>) —
	List of stride sizes to be used in each block for convolutional layers.`,name:"strides"},{anchor:"transformers.AlignVisionConfig.num_block_repeats",description:`<strong>num_block_repeats</strong> (<code>list[int]</code>, <em>optional</em>, defaults to <code>[1, 2, 2, 3, 3, 4, 1]</code>) —
	List of the number of times each block is to repeated.`,name:"num_block_repeats"},{anchor:"transformers.AlignVisionConfig.expand_ratios",description:`<strong>expand_ratios</strong> (<code>list[int]</code>, <em>optional</em>, defaults to <code>[1, 6, 6, 6, 6, 6, 6]</code>) —
	List of scaling coefficient of each block.`,name:"expand_ratios"},{anchor:"transformers.AlignVisionConfig.squeeze_expansion_ratio",description:`<strong>squeeze_expansion_ratio</strong> (<code>float</code>, <em>optional</em>, defaults to 0.25) —
	Squeeze expansion ratio.`,name:"squeeze_expansion_ratio"},{anchor:"transformers.AlignVisionConfig.hidden_act",description:`<strong>hidden_act</strong> (<code>str</code>, <em>optional</em>, defaults to <code>swish</code>) —
	The non-linear activation function (function or string) in the decoder. For example, <code>"gelu"</code>,
	<code>"relu"</code>, <code>"silu"</code>, etc.`,name:"hidden_act"},{anchor:"transformers.AlignVisionConfig.hidden_dim",description:`<strong>hidden_dim</strong> (<code>int</code>, <em>optional</em>, defaults to 1280) —
	The hidden dimension of the layer before the classification head.`,name:"hidden_dim"},{anchor:"transformers.AlignVisionConfig.pooling_type",description:`<strong>pooling_type</strong> (<code>str</code> or <code>function</code>, <em>optional</em>, defaults to <code>"mean"</code>) —
	Type of final pooling to be applied before the dense classification head. Available options are [<code>"mean"</code>,
	<code>"max"</code>]`,name:"pooling_type"},{anchor:"transformers.AlignVisionConfig.initializer_range",description:`<strong>initializer_range</strong> (<code>float</code>, <em>optional</em>, defaults to <code>0.02</code>) —
	The standard deviation of the truncated_normal_initializer for initializing all weight matrices.`,name:"initializer_range"},{anchor:"transformers.AlignVisionConfig.batch_norm_eps",description:`<strong>batch_norm_eps</strong> (<code>float</code>, <em>optional</em>, defaults to <code>0.001</code>) —
	The epsilon used by the batch normalization layers.`,name:"batch_norm_eps"},{anchor:"transformers.AlignVisionConfig.batch_norm_momentum",description:`<strong>batch_norm_momentum</strong> (<code>float</code>, <em>optional</em>, defaults to 0.99) —
	The momentum used by the batch normalization layers.`,name:"batch_norm_momentum"},{anchor:"transformers.AlignVisionConfig.drop_connect_rate",description:`<strong>drop_connect_rate</strong> (<code>float</code>, <em>optional</em>, defaults to 0.2) —
	The drop rate for skip connections.`,name:"drop_connect_rate"}],source:"https://github.com/huggingface/transformers/blob/vr_43265/src/transformers/models/align/configuration_align.py#L66"}}),re=new he({props:{anchor:"transformers.AlignVisionConfig.example",$$slots:{default:[No]},$$scope:{ctx:v}}}),Ze=new K({props:{title:"AlignProcessor",local:"transformers.AlignProcessor",headingTag:"h2"}}),Ce=new V({props:{name:"class transformers.AlignProcessor",anchor:"transformers.AlignProcessor",parameters:[{name:"image_processor",val:""},{name:"tokenizer",val:""}],parametersDescription:[{anchor:"transformers.AlignProcessor.image_processor",description:`<strong>image_processor</strong> (<code>EfficientNetImageProcessor</code>) —
	The image processor is a required input.`,name:"image_processor"},{anchor:"transformers.AlignProcessor.tokenizer",description:`<strong>tokenizer</strong> (<code>BertTokenizer</code>) —
	The tokenizer is a required input.`,name:"tokenizer"}],source:"https://github.com/huggingface/transformers/blob/vr_43265/src/transformers/models/align/processing_align.py#L33"}}),Ie=new V({props:{name:"__call__",anchor:"transformers.AlignProcessor.__call__",parameters:[{name:"images",val:": typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None"},{name:"text",val:": str \| list[str] \| list[list[str]] \| None = None"},{name:"videos",val:": typing.Union[list['PIL.Image.Image'], numpy.ndarray, ForwardRef('torch.Tensor'), list[numpy.ndarray], list['torch.Tensor'], list[list['PIL.Image.Image']], list[list[numpy.ndarray]], list[list['torch.Tensor']], transformers.video_utils.URL, list[transformers.video_utils.URL], list[list[transformers.video_utils.URL]], transformers.video_utils.Path, list[transformers.video_utils.Path], list[list[transformers.video_utils.Path]], NoneType] = None"},{name:"audio",val:": typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], NoneType] = None"},{name:"**kwargs",val:": typing_extensions.Unpack[transformers.processing_utils.ProcessingKwargs]"}],parametersDescription:[{anchor:"transformers.AlignProcessor.__call__.images",description:`<strong>images</strong> (<code>Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]</code>, <em>optional</em>) —
	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.AlignProcessor.__call__.text",description:`<strong>text</strong> (<code>Union[str, list[str], list[list[str]]]</code>, <em>optional</em>) —
	The sequence or batch of sequences to be encoded. Each sequence can be a string or a list of strings
	(pretokenized string). If you pass a pretokenized input, set <code>is_split_into_words=True</code> to avoid ambiguity with batched inputs.`,name:"text"},{anchor:"transformers.AlignProcessor.__call__.videos",description:`<strong>videos</strong> (<code>Union[list[PIL.Image.Image], numpy.ndarray, torch.Tensor, list[numpy.ndarray], list[torch.Tensor], list[list[PIL.Image.Image]], list[list[numpy.ndarray]], list[list[torch.Tensor]], ~video_utils.URL, list[~video_utils.URL], list[list[~video_utils.URL]], ~video_utils.Path, list[~video_utils.Path], list[list[~video_utils.Path]]]</code>, <em>optional</em>) —
	Video to preprocess. Expects a single or batch of videos with pixel values ranging from 0 to 255. If
	passing in videos with pixel values between 0 and 1, set <code>do_rescale=False</code>.`,name:"videos"},{anchor:"transformers.AlignProcessor.__call__.audio",description:`<strong>audio</strong> (<code>Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]]</code>, <em>optional</em>) —
	The audio or batch of audios to be prepared. Each audio can be a NumPy array or PyTorch tensor.
	In case of a NumPy array/PyTorch tensor, each audio should be of shape (C, T), where C is a number of channels,
	and T is the sample length of the audio.`,name:"audio"},{anchor:"transformers.AlignProcessor.__call__.return_tensors",description:`<strong>return_tensors</strong> (<code>str</code> or <a href="/docs/transformers/pr_43265/en/internal/file_utils#transformers.TensorType">TensorType</a>, <em>optional</em>) —
	If set, will return tensors of a particular framework. Acceptable values are:</p>
	<ul>
	<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.AlignProcessor.__call__.kwargs",description:`<strong>*kwargs</strong> (<a href="/docs/transformers/pr_43265/en/main_classes/processors#transformers.ProcessingKwargs">ProcessingKwargs</a>, <em>optional</em>) —
	Additional processing options for each modality (text, images, videos, audio). Model-specific parameters
	are listed above; see the TypedDict class for the complete list of supported arguments.`,name:"*kwargs"}],source:"https://github.com/huggingface/transformers/blob/vr_43265/src/transformers/processing_utils.py#L643"}}),Be=new K({props:{title:"AlignModel",local:"transformers.AlignModel",headingTag:"h2"}}),ze=new V({props:{name:"class transformers.AlignModel",anchor:"transformers.AlignModel",parameters:[{name:"config",val:": AlignConfig"}],parametersDescription:[{anchor:"transformers.AlignModel.config",description:`<strong>config</strong> (<a href="/docs/transformers/pr_43265/en/model_doc/align#transformers.AlignConfig">AlignConfig</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_43265/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_43265/src/transformers/models/align/modeling_align.py#L1008"}}),Ae=new V({props:{name:"forward",anchor:"transformers.AlignModel.forward",parameters:[{name:"input_ids",val:": torch.LongTensor \| None = None"},{name:"pixel_values",val:": torch.FloatTensor \| None = None"},{name:"attention_mask",val:": torch.Tensor \| None = None"},{name:"token_type_ids",val:": torch.Tensor \| None = None"},{name:"position_ids",val:": torch.Tensor \| None = None"},{name:"inputs_embeds",val:": torch.Tensor \| None = None"},{name:"return_loss",val:": bool \| None = None"},{name:"**kwargs",val:": typing_extensions.Unpack[transformers.utils.generic.TransformersKwargs]"}],parametersDescription:[{anchor:"transformers.AlignModel.forward.input_ids",description:`<strong>input_ids</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size, sequence_length)</code>, <em>optional</em>) —
	Indices of input sequence tokens in the vocabulary. Padding will be ignored by default.</p>
	<p>Indices can be obtained using <a href="/docs/transformers/pr_43265/en/model_doc/auto#transformers.AutoTokenizer">AutoTokenizer</a>. See <a href="/docs/transformers/pr_43265/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode">PreTrainedTokenizer.encode()</a> and
	<a href="/docs/transformers/pr_43265/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.AlignModel.forward.pixel_values",description:`<strong>pixel_values</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, num_channels, image_size, image_size)</code>, <em>optional</em>) —
	The tensors corresponding to the input images. Pixel values can be obtained using
	<a href="/docs/transformers/pr_43265/en/model_doc/efficientnet#transformers.EfficientNetImageProcessor">EfficientNetImageProcessor</a>. See <code>EfficientNetImageProcessor.__call__()</code> for details (<a href="/docs/transformers/pr_43265/en/model_doc/align#transformers.AlignProcessor">AlignProcessor</a> uses
	<a href="/docs/transformers/pr_43265/en/model_doc/efficientnet#transformers.EfficientNetImageProcessor">EfficientNetImageProcessor</a> for processing images).`,name:"pixel_values"},{anchor:"transformers.AlignModel.forward.attention_mask",description:`<strong>attention_mask</strong> (<code>torch.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><a href="../glossary#attention-mask">What are attention masks?</a>`,name:"attention_mask"},{anchor:"transformers.AlignModel.forward.token_type_ids",description:`<strong>token_type_ids</strong> (<code>torch.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><a href="../glossary#token-type-ids">What are token type IDs?</a>`,name:"token_type_ids"},{anchor:"transformers.AlignModel.forward.position_ids",description:`<strong>position_ids</strong> (<code>torch.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.n_positions - 1]</code>.</p>
	<p><a href="../glossary#position-ids">What are position IDs?</a>`,name:"position_ids"},{anchor:"transformers.AlignModel.forward.inputs_embeds",description:`<strong>inputs_embeds</strong> (<code>torch.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 <code>input_ids</code> indices into associated vectors than the
	model’s internal embedding lookup matrix.`,name:"inputs_embeds"},{anchor:"transformers.AlignModel.forward.return_loss",description:`<strong>return_loss</strong> (<code>bool</code>, <em>optional</em>) —
	Whether or not to return the contrastive loss.`,name:"return_loss"}],source:"https://github.com/huggingface/transformers/blob/vr_43265/src/transformers/models/align/modeling_align.py#L1104",returnDescription:`<script context="module">export const metadata = 'undefined';<\/script>


	<p>A <code>AlignOutput</code> or a tuple of
	<code>torch.FloatTensor</code> (if <code>return_dict=False</code> is passed or when <code>config.return_dict=False</code>) comprising various
	elements depending on the configuration (<a
	href="/docs/transformers/pr_43265/en/model_doc/align#transformers.AlignConfig"
	>AlignConfig</a>) and inputs.</p>
	`,returnType:`<script context="module">export const metadata = 'undefined';<\/script>


	<p><code>AlignOutput</code> or <code>tuple(torch.FloatTensor)</code></p>
	`}}),ie=new Fn({props:{$$slots:{default:[Go]},$$scope:{ctx:v}}}),le=new he({props:{anchor:"transformers.AlignModel.forward.example",$$slots:{default:[Vo]},$$scope:{ctx:v}}}),Ne=new V({props:{name:"get_text_features",anchor:"transformers.AlignModel.get_text_features",parameters:[{name:"input_ids",val:": torch.Tensor \| None = None"},{name:"attention_mask",val:": torch.Tensor \| None = None"},{name:"token_type_ids",val:": torch.Tensor \| None = None"},{name:"position_ids",val:": torch.Tensor \| None = None"},{name:"inputs_embeds",val:": torch.Tensor \| None = None"},{name:"**kwargs",val:": typing_extensions.Unpack[transformers.utils.generic.TransformersKwargs]"}],parametersDescription:[{anchor:"transformers.AlignModel.get_text_features.input_ids",description:`<strong>input_ids</strong> (<code>torch.Tensor</code> of shape <code>(batch_size, sequence_length)</code>, <em>optional</em>) —
	Indices of input sequence tokens in the vocabulary. Padding will be ignored by default.</p>
	<p>Indices can be obtained using <a href="/docs/transformers/pr_43265/en/model_doc/auto#transformers.AutoTokenizer">AutoTokenizer</a>. See <a href="/docs/transformers/pr_43265/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode">PreTrainedTokenizer.encode()</a> and
	<a href="/docs/transformers/pr_43265/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.AlignModel.get_text_features.attention_mask",description:`<strong>attention_mask</strong> (<code>torch.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><a href="../glossary#attention-mask">What are attention masks?</a>`,name:"attention_mask"},{anchor:"transformers.AlignModel.get_text_features.token_type_ids",description:`<strong>token_type_ids</strong> (<code>torch.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><a href="../glossary#token-type-ids">What are token type IDs?</a>`,name:"token_type_ids"},{anchor:"transformers.AlignModel.get_text_features.position_ids",description:`<strong>position_ids</strong> (<code>torch.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.n_positions - 1]</code>.</p>
	<p><a href="../glossary#position-ids">What are position IDs?</a>`,name:"position_ids"},{anchor:"transformers.AlignModel.get_text_features.inputs_embeds",description:`<strong>inputs_embeds</strong> (<code>torch.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 <code>input_ids</code> indices into associated vectors than the
	model’s internal embedding lookup matrix.`,name:"inputs_embeds"}],source:"https://github.com/huggingface/transformers/blob/vr_43265/src/transformers/models/align/modeling_align.py#L1041",returnDescription:`<script context="module">export const metadata = 'undefined';<\/script>


	<p>A <a
	href="/docs/transformers/pr_43265/en/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling"
	>BaseModelOutputWithPooling</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_43265/en/model_doc/align#transformers.AlignConfig"
	>AlignConfig</a>) and inputs.</p>
	`,returnType:`<script context="module">export const metadata = 'undefined';<\/script>


	<p><a
	href="/docs/transformers/pr_43265/en/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling"
	>BaseModelOutputWithPooling</a> or <code>tuple(torch.FloatTensor)</code></p>
	`}}),ce=new he({props:{anchor:"transformers.AlignModel.get_text_features.example",$$slots:{default:[Ro]},$$scope:{ctx:v}}}),Ge=new V({props:{name:"get_image_features",anchor:"transformers.AlignModel.get_image_features",parameters:[{name:"pixel_values",val:": FloatTensor"},{name:"**kwargs",val:": typing_extensions.Unpack[transformers.utils.generic.TransformersKwargs]"}],parametersDescription:[{anchor:"transformers.AlignModel.get_image_features.pixel_values",description:`<strong>pixel_values</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, num_channels, image_size, image_size)</code>) —
	The tensors corresponding to the input images. Pixel values can be obtained using
	<a href="/docs/transformers/pr_43265/en/model_doc/efficientnet#transformers.EfficientNetImageProcessor">EfficientNetImageProcessor</a>. See <code>EfficientNetImageProcessor.__call__()</code> for details (<a href="/docs/transformers/pr_43265/en/model_doc/align#transformers.AlignProcessor">AlignProcessor</a> uses
	<a href="/docs/transformers/pr_43265/en/model_doc/efficientnet#transformers.EfficientNetImageProcessor">EfficientNetImageProcessor</a> for processing images).`,name:"pixel_values"}],source:"https://github.com/huggingface/transformers/blob/vr_43265/src/transformers/models/align/modeling_align.py#L1079",returnDescription:`<script context="module">export const metadata = 'undefined';<\/script>


	<p>A <a
	href="/docs/transformers/pr_43265/en/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling"
	>BaseModelOutputWithPooling</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_43265/en/model_doc/align#transformers.AlignConfig"
	>AlignConfig</a>) and inputs.</p>
	`,returnType:`<script context="module">export const metadata = 'undefined';<\/script>


	<p><a
	href="/docs/transformers/pr_43265/en/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling"
	>BaseModelOutputWithPooling</a> or <code>tuple(torch.FloatTensor)</code></p>
	`}}),de=new he({props:{anchor:"transformers.AlignModel.get_image_features.example",$$slots:{default:[Ho]},$$scope:{ctx:v}}}),Ve=new K({props:{title:"AlignTextModel",local:"transformers.AlignTextModel",headingTag:"h2"}}),Re=new V({props:{name:"class transformers.AlignTextModel",anchor:"transformers.AlignTextModel",parameters:[{name:"config",val:": AlignTextConfig"},{name:"add_pooling_layer",val:": bool = True"}],parametersDescription:[{anchor:"transformers.AlignTextModel.config",description:`<strong>config</strong> (<a href="/docs/transformers/pr_43265/en/model_doc/align#transformers.AlignTextConfig">AlignTextConfig</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_43265/en/main_classes/model#transformers.PreTrainedModel.from_pretrained">from_pretrained()</a> method to load the model weights.`,name:"config"},{anchor:"transformers.AlignTextModel.add_pooling_layer",description:`<strong>add_pooling_layer</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>True</code>) —
	Whether to add a pooling layer`,name:"add_pooling_layer"}],source:"https://github.com/huggingface/transformers/blob/vr_43265/src/transformers/models/align/modeling_align.py#L825"}}),He=new V({props:{name:"forward",anchor:"transformers.AlignTextModel.forward",parameters:[{name:"input_ids",val:": torch.Tensor \| None = None"},{name:"attention_mask",val:": torch.Tensor \| None = None"},{name:"token_type_ids",val:": torch.Tensor \| None = None"},{name:"position_ids",val:": torch.Tensor \| None = None"},{name:"inputs_embeds",val:": torch.Tensor \| None = None"},{name:"**kwargs",val:": typing_extensions.Unpack[transformers.utils.generic.TransformersKwargs]"}],parametersDescription:[{anchor:"transformers.AlignTextModel.forward.input_ids",description:`<strong>input_ids</strong> (<code>torch.Tensor</code> of shape <code>(batch_size, sequence_length)</code>, <em>optional</em>) —
	Indices of input sequence tokens in the vocabulary. Padding will be ignored by default.</p>
	<p>Indices can be obtained using <a href="/docs/transformers/pr_43265/en/model_doc/auto#transformers.AutoTokenizer">AutoTokenizer</a>. See <a href="/docs/transformers/pr_43265/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode">PreTrainedTokenizer.encode()</a> and
	<a href="/docs/transformers/pr_43265/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.AlignTextModel.forward.attention_mask",description:`<strong>attention_mask</strong> (<code>torch.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><a href="../glossary#attention-mask">What are attention masks?</a>`,name:"attention_mask"},{anchor:"transformers.AlignTextModel.forward.token_type_ids",description:`<strong>token_type_ids</strong> (<code>torch.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><a href="../glossary#token-type-ids">What are token type IDs?</a>`,name:"token_type_ids"},{anchor:"transformers.AlignTextModel.forward.position_ids",description:`<strong>position_ids</strong> (<code>torch.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.n_positions - 1]</code>.</p>
	<p><a href="../glossary#position-ids">What are position IDs?</a>`,name:"position_ids"},{anchor:"transformers.AlignTextModel.forward.inputs_embeds",description:`<strong>inputs_embeds</strong> (<code>torch.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 <code>input_ids</code> indices into associated vectors than the
	model’s internal embedding lookup matrix.`,name:"inputs_embeds"}],source:"https://github.com/huggingface/transformers/blob/vr_43265/src/transformers/models/align/modeling_align.py#L856",returnDescription:`<script context="module">export const metadata = 'undefined';<\/script>


	<p>A <a
	href="/docs/transformers/pr_43265/en/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling"
	>BaseModelOutputWithPooling</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_43265/en/model_doc/align#transformers.AlignConfig"
	>AlignConfig</a>) and inputs.</p>
	`,returnType:`<script context="module">export const metadata = 'undefined';<\/script>


	<p><a
	href="/docs/transformers/pr_43265/en/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling"
	>BaseModelOutputWithPooling</a> or <code>tuple(torch.FloatTensor)</code></p>
	`}}),pe=new Fn({props:{$$slots:{default:[Fo]},$$scope:{ctx:v}}}),me=new he({props:{anchor:"transformers.AlignTextModel.forward.example",$$slots:{default:[Xo]},$$scope:{ctx:v}}}),Fe=new K({props:{title:"AlignVisionModel",local:"transformers.AlignVisionModel",headingTag:"h2"}}),Xe=new V({props:{name:"class transformers.AlignVisionModel",anchor:"transformers.AlignVisionModel",parameters:[{name:"config",val:": AlignVisionConfig"}],parametersDescription:[{anchor:"transformers.AlignVisionModel.config",description:`<strong>config</strong> (<a href="/docs/transformers/pr_43265/en/model_doc/align#transformers.AlignVisionConfig">AlignVisionConfig</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_43265/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_43265/src/transformers/models/align/modeling_align.py#L931"}}),Ye=new V({props:{name:"forward",anchor:"transformers.AlignVisionModel.forward",parameters:[{name:"pixel_values",val:": torch.FloatTensor \| None = None"},{name:"**kwargs",val:": typing_extensions.Unpack[transformers.utils.generic.TransformersKwargs]"}],parametersDescription:[{anchor:"transformers.AlignVisionModel.forward.pixel_values",description:`<strong>pixel_values</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, num_channels, image_size, image_size)</code>, <em>optional</em>) —
	The tensors corresponding to the input images. Pixel values can be obtained using
	<a href="/docs/transformers/pr_43265/en/model_doc/efficientnet#transformers.EfficientNetImageProcessor">EfficientNetImageProcessor</a>. See <code>EfficientNetImageProcessor.__call__()</code> for details (<a href="/docs/transformers/pr_43265/en/model_doc/align#transformers.AlignProcessor">AlignProcessor</a> uses
	<a href="/docs/transformers/pr_43265/en/model_doc/efficientnet#transformers.EfficientNetImageProcessor">EfficientNetImageProcessor</a> for processing images).`,name:"pixel_values"}],source:"https://github.com/huggingface/transformers/blob/vr_43265/src/transformers/models/align/modeling_align.py#L959",returnDescription:`<script context="module">export const metadata = 'undefined';<\/script>


	<p>A <code>BaseModelOutputWithPoolingAndNoAttention</code> or a tuple of
	<code>torch.FloatTensor</code> (if <code>return_dict=False</code> is passed or when <code>config.return_dict=False</code>) comprising various
	elements depending on the configuration (<a
	href="/docs/transformers/pr_43265/en/model_doc/align#transformers.AlignConfig"
	>AlignConfig</a>) and inputs.</p>
	`,returnType:`<script context="module">export const metadata = 'undefined';<\/script>


	<p><code>BaseModelOutputWithPoolingAndNoAttention</code> or <code>tuple(torch.FloatTensor)</code></p>
	`}}),ge=new Fn({props:{$$slots:{default:[Yo]},$$scope:{ctx:v}}}),fe=new he({props:{anchor:"transformers.AlignVisionModel.forward.example",$$slots:{default:[Eo]},$$scope:{ctx:v}}}),Ee=new Wo({props:{source:"https://github.com/huggingface/transformers/blob/main/docs/source/en/model_doc/align.md"}}),{c(){n=m("meta"),f=i(),o=m("p"),r=i(),d=m("p"),d.innerHTML=t,w=i(),h(Q.$$.fragment),Jt=i(),te=m("div"),te.innerHTML=Xn,Ut=i(),h(ue.$$.fragment),jt=i(),_e=m("p"),_e.innerHTML=Yn,kt=i(),be=m("p"),be.innerHTML=En,$t=i(),ne=m("blockquote"),ne.innerHTML=Qn,xt=i(),ye=m("p"),ye.innerHTML=Pn,Wt=i(),h(oe.$$.fragment),Zt=i(),h(Me.$$.fragment),Ct=i(),Pe=m("ul"),Te=m("li"),qe=m("p"),qe.innerHTML=qn,Kt=i(),h(we.$$.fragment),It=i(),h(ve.$$.fragment),Bt=i(),Je=m("ul"),Je.innerHTML=Sn,zt=i(),h(Ue.$$.fragment),At=i(),I=m("div"),h(je.$$.fragment),Ot=i(),Se=m("p"),Se.innerHTML=Ln,en=i(),Le=m("p"),Le.innerHTML=Dn,tn=i(),h(se.$$.fragment),Nt=i(),h(ke.$$.fragment),Gt=i(),B=m("div"),h($e.$$.fragment),nn=i(),De=m("p"),De.innerHTML=Kn,on=i(),Ke=m("p"),Ke.innerHTML=On,sn=i(),h(ae.$$.fragment),Vt=i(),h(xe.$$.fragment),Rt=i(),z=m("div"),h(We.$$.fragment),an=i(),Oe=m("p"),Oe.innerHTML=eo,rn=i(),et=m("p"),et.innerHTML=to,ln=i(),h(re.$$.fragment),Ht=i(),h(Ze.$$.fragment),Ft=i(),A=m("div"),h(Ce.$$.fragment),cn=i(),tt=m("p"),tt.textContent=no,dn=i(),nt=m("p"),nt.innerHTML=oo,pn=i(),ot=m("div"),h(Ie.$$.fragment),Xt=i(),h(Be.$$.fragment),Yt=i(),J=m("div"),h(ze.$$.fragment),mn=i(),st=m("p"),st.textContent=so,gn=i(),at=m("p"),at.innerHTML=ao,fn=i(),rt=m("p"),rt.innerHTML=ro,hn=i(),W=m("div"),h(Ae.$$.fragment),un=i(),it=m("p"),it.innerHTML=io,_n=i(),h(ie.$$.fragment),bn=i(),lt=m("ul"),lt.innerHTML=lo,yn=i(),h(le.$$.fragment),Mn=i(),P=m("div"),h(Ne.$$.fragment),Tn=i(),ct=m("ul"),ct.innerHTML=co,wn=i(),h(ce.$$.fragment),vn=i(),q=m("div"),h(Ge.$$.fragment),Jn=i(),dt=m("ul"),dt.innerHTML=po,Un=i(),h(de.$$.fragment),Et=i(),h(Ve.$$.fragment),Qt=i(),$=m("div"),h(Re.$$.fragment),jn=i(),pt=m("p"),pt.textContent=mo,kn=i(),mt=m("p"),mt.innerHTML=go,$n=i(),gt=m("p"),gt.innerHTML=fo,xn=i(),Z=m("div"),h(He.$$.fragment),Wn=i(),ft=m("p"),ft.innerHTML=ho,Zn=i(),h(pe.$$.fragment),Cn=i(),ht=m("ul"),ht.innerHTML=uo,In=i(),h(me.$$.fragment),Pt=i(),h(Fe.$$.fragment),qt=i(),x=m("div"),h(Xe.$$.fragment),Bn=i(),ut=m("p"),ut.textContent=_o,zn=i(),_t=m("p"),_t.innerHTML=bo,An=i(),bt=m("p"),bt.innerHTML=yo,Nn=i(),C=m("div"),h(Ye.$$.fragment),Gn=i(),yt=m("p"),yt.innerHTML=Mo,Vn=i(),h(ge.$$.fragment),Rn=i(),Mt=m("ul"),Mt.innerHTML=To,Hn=i(),h(fe.$$.fragment),St=i(),h(Ee.$$.fragment),Lt=i(),Tt=m("p"),this.h()},l(e){const s=ko("svelte-u9bgzb",document.head);n=g(s,"META",{name:!0,content:!0}),s.forEach(a),f=l(e),o=g(e,"P",{}),j(o).forEach(a),r=l(e),d=g(e,"P",{"data-svelte-h":!0}),T(d)!=="svelte-12hnueq"&&(d.innerHTML=t),w=l(e),u(Q.$$.fragment,e),Jt=l(e),te=g(e,"DIV",{style:!0,"data-svelte-h":!0}),T(te)!=="svelte-1x6r7jy"&&(te.innerHTML=Xn),Ut=l(e),u(ue.$$.fragment,e),jt=l(e),_e=g(e,"P",{"data-svelte-h":!0}),T(_e)!=="svelte-hilans"&&(_e.innerHTML=Yn),kt=l(e),be=g(e,"P",{"data-svelte-h":!0}),T(be)!=="svelte-2l2dta"&&(be.innerHTML=En),$t=l(e),ne=g(e,"BLOCKQUOTE",{class:!0,"data-svelte-h":!0}),T(ne)!=="svelte-1nh8xmt"&&(ne.innerHTML=Qn),xt=l(e),ye=g(e,"P",{"data-svelte-h":!0}),T(ye)!=="svelte-jtgtbd"&&(ye.innerHTML=Pn),Wt=l(e),u(oe.$$.fragment,e),Zt=l(e),u(Me.$$.fragment,e),Ct=l(e),Pe=g(e,"UL",{});var wt=j(Pe);Te=g(wt,"LI",{});var Qe=j(Te);qe=g(Qe,"P",{"data-svelte-h":!0}),T(qe)!=="svelte-y011l"&&(qe.innerHTML=qn),Kt=l(Qe),u(we.$$.fragment,Qe),Qe.forEach(a),wt.forEach(a),It=l(e),u(ve.$$.fragment,e),Bt=l(e),Je=g(e,"UL",{"data-svelte-h":!0}),T(Je)!=="svelte-1cz922d"&&(Je.innerHTML=Sn),zt=l(e),u(Ue.$$.fragment,e),At=l(e),I=g(e,"DIV",{class:!0});var H=j(I);u(je.$$.fragment,H),Ot=l(H),Se=g(H,"P",{"data-svelte-h":!0}),T(Se)!=="svelte-1rgvoza"&&(Se.innerHTML=Ln),en=l(H),Le=g(H,"P",{"data-svelte-h":!0}),T(Le)!=="svelte-1e8815j"&&(Le.innerHTML=Dn),tn=l(H),u(se.$$.fragment,H),H.forEach(a),Nt=l(e),u(ke.$$.fragment,e),Gt=l(e),B=g(e,"DIV",{class:!0});var F=j(B);u($e.$$.fragment,F),nn=l(F),De=g(F,"P",{"data-svelte-h":!0}),T(De)!=="svelte-1rgvoza"&&(De.innerHTML=Kn),on=l(F),Ke=g(F,"P",{"data-svelte-h":!0}),T(Ke)!=="svelte-1e8815j"&&(Ke.innerHTML=On),sn=l(F),u(ae.$$.fragment,F),F.forEach(a),Vt=l(e),u(xe.$$.fragment,e),Rt=l(e),z=g(e,"DIV",{class:!0});var X=j(z);u(We.$$.fragment,X),an=l(X),Oe=g(X,"P",{"data-svelte-h":!0}),T(Oe)!=="svelte-1rgvoza"&&(Oe.innerHTML=eo),rn=l(X),et=g(X,"P",{"data-svelte-h":!0}),T(et)!=="svelte-1e8815j"&&(et.innerHTML=to),ln=l(X),u(re.$$.fragment,X),X.forEach(a),Ht=l(e),u(Ze.$$.fragment,e),Ft=l(e),A=g(e,"DIV",{class:!0});var Y=j(A);u(Ce.$$.fragment,Y),cn=l(Y),tt=g(Y,"P",{"data-svelte-h":!0}),T(tt)!=="svelte-1qg1pzo"&&(tt.textContent=no),dn=l(Y),nt=g(Y,"P",{"data-svelte-h":!0}),T(nt)!=="svelte-alsar1"&&(nt.innerHTML=oo),pn=l(Y),ot=g(Y,"DIV",{class:!0});var vt=j(ot);u(Ie.$$.fragment,vt),vt.forEach(a),Y.forEach(a),Xt=l(e),u(Be.$$.fragment,e),Yt=l(e),J=g(e,"DIV",{class:!0});var U=j(J);u(ze.$$.fragment,U),mn=l(U),st=g(U,"P",{"data-svelte-h":!0}),T(st)!=="svelte-1o4i2bl"&&(st.textContent=so),gn=l(U),at=g(U,"P",{"data-svelte-h":!0}),T(at)!=="svelte-1gb3c10"&&(at.innerHTML=ao),fn=l(U),rt=g(U,"P",{"data-svelte-h":!0}),T(rt)!=="svelte-hswkmf"&&(rt.innerHTML=ro),hn=l(U),W=g(U,"DIV",{class:!0});var N=j(W);u(Ae.$$.fragment,N),un=l(N),it=g(N,"P",{"data-svelte-h":!0}),T(it)!=="svelte-11tzztq"&&(it.innerHTML=io),_n=l(N),u(ie.$$.fragment,N),bn=l(N),lt=g(N,"UL",{"data-svelte-h":!0}),T(lt)!=="svelte-1aeelda"&&(lt.innerHTML=lo),yn=l(N),u(le.$$.fragment,N),N.forEach(a),Mn=l(U),P=g(U,"DIV",{class:!0});var O=j(P);u(Ne.$$.fragment,O),Tn=l(O),ct=g(O,"UL",{"data-svelte-h":!0}),T(ct)!=="svelte-1vt4ztn"&&(ct.innerHTML=co),wn=l(O),u(ce.$$.fragment,O),O.forEach(a),vn=l(U),q=g(U,"DIV",{class:!0});var ee=j(q);u(Ge.$$.fragment,ee),Jn=l(ee),dt=g(ee,"UL",{"data-svelte-h":!0}),T(dt)!=="svelte-1vt4ztn"&&(dt.innerHTML=po),Un=l(ee),u(de.$$.fragment,ee),ee.forEach(a),U.forEach(a),Et=l(e),u(Ve.$$.fragment,e),Qt=l(e),$=g(e,"DIV",{class:!0});var G=j($);u(Re.$$.fragment,G),jn=l(G),pt=g(G,"P",{"data-svelte-h":!0}),T(pt)!=="svelte-ufvayi"&&(pt.textContent=mo),kn=l(G),mt=g(G,"P",{"data-svelte-h":!0}),T(mt)!=="svelte-1gb3c10"&&(mt.innerHTML=go),$n=l(G),gt=g(G,"P",{"data-svelte-h":!0}),T(gt)!=="svelte-hswkmf"&&(gt.innerHTML=fo),xn=l(G),Z=g(G,"DIV",{class:!0});var S=j(Z);u(He.$$.fragment,S),Wn=l(S),ft=g(S,"P",{"data-svelte-h":!0}),T(ft)!=="svelte-7251ts"&&(ft.innerHTML=ho),Zn=l(S),u(pe.$$.fragment,S),Cn=l(S),ht=g(S,"UL",{"data-svelte-h":!0}),T(ht)!=="svelte-1vt4ztn"&&(ht.innerHTML=uo),In=l(S),u(me.$$.fragment,S),S.forEach(a),G.forEach(a),Pt=l(e),u(Fe.$$.fragment,e),qt=l(e),x=g(e,"DIV",{class:!0});var L=j(x);u(Xe.$$.fragment,L),Bn=l(L),ut=g(L,"P",{"data-svelte-h":!0}),T(ut)!=="svelte-4whvlf"&&(ut.textContent=_o),zn=l(L),_t=g(L,"P",{"data-svelte-h":!0}),T(_t)!=="svelte-1gb3c10"&&(_t.innerHTML=bo),An=l(L),bt=g(L,"P",{"data-svelte-h":!0}),T(bt)!=="svelte-hswkmf"&&(bt.innerHTML=yo),Nn=l(L),C=g(L,"DIV",{class:!0});var D=j(C);u(Ye.$$.fragment,D),Gn=l(D),yt=g(D,"P",{"data-svelte-h":!0}),T(yt)!=="svelte-1rdm3da"&&(yt.innerHTML=Mo),Vn=l(D),u(ge.$$.fragment,D),Rn=l(D),Mt=g(D,"UL",{"data-svelte-h":!0}),T(Mt)!=="svelte-eij2o0"&&(Mt.innerHTML=To),Hn=l(D),u(fe.$$.fragment,D),D.forEach(a),L.forEach(a),St=l(e),u(Ee.$$.fragment,e),Lt=l(e),Tt=g(e,"P",{}),j(Tt).forEach(a),this.h()},h(){k(n,"name","hf:doc:metadata"),k(n,"content",Po),$o(te,"float","right"),k(ne,"class","tip"),k(I,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),k(B,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),k(z,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),k(ot,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),k(A,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),k(W,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),k(P,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),k(q,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),k(J,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),k(Z,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),k($,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),k(C,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),k(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(e,s){c(document.head,n),p(e,f,s),p(e,o,s),p(e,r,s),p(e,d,s),p(e,w,s),_(Q,e,s),p(e,Jt,s),p(e,te,s),p(e,Ut,s),_(ue,e,s),p(e,jt,s),p(e,_e,s),p(e,kt,s),p(e,be,s),p(e,$t,s),p(e,ne,s),p(e,xt,s),p(e,ye,s),p(e,Wt,s),_(oe,e,s),p(e,Zt,s),_(Me,e,s),p(e,Ct,s),p(e,Pe,s),c(Pe,Te),c(Te,qe),c(Te,Kt),_(we,Te,null),p(e,It,s),_(ve,e,s),p(e,Bt,s),p(e,Je,s),p(e,zt,s),_(Ue,e,s),p(e,At,s),p(e,I,s),_(je,I,null),c(I,Ot),c(I,Se),c(I,en),c(I,Le),c(I,tn),_(se,I,null),p(e,Nt,s),_(ke,e,s),p(e,Gt,s),p(e,B,s),_($e,B,null),c(B,nn),c(B,De),c(B,on),c(B,Ke),c(B,sn),_(ae,B,null),p(e,Vt,s),_(xe,e,s),p(e,Rt,s),p(e,z,s),_(We,z,null),c(z,an),c(z,Oe),c(z,rn),c(z,et),c(z,ln),_(re,z,null),p(e,Ht,s),_(Ze,e,s),p(e,Ft,s),p(e,A,s),_(Ce,A,null),c(A,cn),c(A,tt),c(A,dn),c(A,nt),c(A,pn),c(A,ot),_(Ie,ot,null),p(e,Xt,s),_(Be,e,s),p(e,Yt,s),p(e,J,s),_(ze,J,null),c(J,mn),c(J,st),c(J,gn),c(J,at),c(J,fn),c(J,rt),c(J,hn),c(J,W),_(Ae,W,null),c(W,un),c(W,it),c(W,_n),_(ie,W,null),c(W,bn),c(W,lt),c(W,yn),_(le,W,null),c(J,Mn),c(J,P),_(Ne,P,null),c(P,Tn),c(P,ct),c(P,wn),_(ce,P,null),c(J,vn),c(J,q),_(Ge,q,null),c(q,Jn),c(q,dt),c(q,Un),_(de,q,null),p(e,Et,s),_(Ve,e,s),p(e,Qt,s),p(e,$,s),_(Re,$,null),c($,jn),c($,pt),c($,kn),c($,mt),c($,$n),c($,gt),c($,xn),c($,Z),_(He,Z,null),c(Z,Wn),c(Z,ft),c(Z,Zn),_(pe,Z,null),c(Z,Cn),c(Z,ht),c(Z,In),_(me,Z,null),p(e,Pt,s),_(Fe,e,s),p(e,qt,s),p(e,x,s),_(Xe,x,null),c(x,Bn),c(x,ut),c(x,zn),c(x,_t),c(x,An),c(x,bt),c(x,Nn),c(x,C),_(Ye,C,null),c(C,Gn),c(C,yt),c(C,Vn),_(ge,C,null),c(C,Rn),c(C,Mt),c(C,Hn),_(fe,C,null),p(e,St,s),_(Ee,e,s),p(e,Lt,s),p(e,Tt,s),Dt=!0},p(e,[s]){const wt={};s&2&&(wt.$$scope={dirty:s,ctx:e}),oe.$set(wt);const Qe={};s&2&&(Qe.$$scope={dirty:s,ctx:e}),se.$set(Qe);const H={};s&2&&(H.$$scope={dirty:s,ctx:e}),ae.$set(H);const F={};s&2&&(F.$$scope={dirty:s,ctx:e}),re.$set(F);const X={};s&2&&(X.$$scope={dirty:s,ctx:e}),ie.$set(X);const Y={};s&2&&(Y.$$scope={dirty:s,ctx:e}),le.$set(Y);const vt={};s&2&&(vt.$$scope={dirty:s,ctx:e}),ce.$set(vt);const U={};s&2&&(U.$$scope={dirty:s,ctx:e}),de.$set(U);const N={};s&2&&(N.$$scope={dirty:s,ctx:e}),pe.$set(N);const O={};s&2&&(O.$$scope={dirty:s,ctx:e}),me.$set(O);const ee={};s&2&&(ee.$$scope={dirty:s,ctx:e}),ge.$set(ee);const G={};s&2&&(G.$$scope={dirty:s,ctx:e}),fe.$set(G)},i(e){Dt\|\|(b(Q.$$.fragment,e),b(ue.$$.fragment,e),b(oe.$$.fragment,e),b(Me.$$.fragment,e),b(we.$$.fragment,e),b(ve.$$.fragment,e),b(Ue.$$.fragment,e),b(je.$$.fragment,e),b(se.$$.fragment,e),b(ke.$$.fragment,e),b($e.$$.fragment,e),b(ae.$$.fragment,e),b(xe.$$.fragment,e),b(We.$$.fragment,e),b(re.$$.fragment,e),b(Ze.$$.fragment,e),b(Ce.$$.fragment,e),b(Ie.$$.fragment,e),b(Be.$$.fragment,e),b(ze.$$.fragment,e),b(Ae.$$.fragment,e),b(ie.$$.fragment,e),b(le.$$.fragment,e),b(Ne.$$.fragment,e),b(ce.$$.fragment,e),b(Ge.$$.fragment,e),b(de.$$.fragment,e),b(Ve.$$.fragment,e),b(Re.$$.fragment,e),b(He.$$.fragment,e),b(pe.$$.fragment,e),b(me.$$.fragment,e),b(Fe.$$.fragment,e),b(Xe.$$.fragment,e),b(Ye.$$.fragment,e),b(ge.$$.fragment,e),b(fe.$$.fragment,e),b(Ee.$$.fragment,e),Dt=!0)},o(e){y(Q.$$.fragment,e),y(ue.$$.fragment,e),y(oe.$$.fragment,e),y(Me.$$.fragment,e),y(we.$$.fragment,e),y(ve.$$.fragment,e),y(Ue.$$.fragment,e),y(je.$$.fragment,e),y(se.$$.fragment,e),y(ke.$$.fragment,e),y($e.$$.fragment,e),y(ae.$$.fragment,e),y(xe.$$.fragment,e),y(We.$$.fragment,e),y(re.$$.fragment,e),y(Ze.$$.fragment,e),y(Ce.$$.fragment,e),y(Ie.$$.fragment,e),y(Be.$$.fragment,e),y(ze.$$.fragment,e),y(Ae.$$.fragment,e),y(ie.$$.fragment,e),y(le.$$.fragment,e),y(Ne.$$.fragment,e),y(ce.$$.fragment,e),y(Ge.$$.fragment,e),y(de.$$.fragment,e),y(Ve.$$.fragment,e),y(Re.$$.fragment,e),y(He.$$.fragment,e),y(pe.$$.fragment,e),y(me.$$.fragment,e),y(Fe.$$.fragment,e),y(Xe.$$.fragment,e),y(Ye.$$.fragment,e),y(ge.$$.fragment,e),y(fe.$$.fragment,e),y(Ee.$$.fragment,e),Dt=!1},d(e){e&&(a(f),a(o),a(r),a(d),a(w),a(Jt),a(te),a(Ut),a(jt),a(_e),a(kt),a(be),a($t),a(ne),a(xt),a(ye),a(Wt),a(Zt),a(Ct),a(Pe),a(It),a(Bt),a(Je),a(zt),a(At),a(I),a(Nt),a(Gt),a(B),a(Vt),a(Rt),a(z),a(Ht),a(Ft),a(A),a(Xt),a(Yt),a(J),a(Et),a(Qt),a($),a(Pt),a(qt),a(x),a(St),a(Lt),a(Tt)),a(n),M(Q,e),M(ue,e),M(oe,e),M(Me,e),M(we),M(ve,e),M(Ue,e),M(je),M(se),M(ke,e),M($e),M(ae),M(xe,e),M(We),M(re),M(Ze,e),M(Ce),M(Ie),M(Be,e),M(ze),M(Ae),M(ie),M(le),M(Ne),M(ce),M(Ge),M(de),M(Ve,e),M(Re),M(He),M(pe),M(me),M(Fe,e),M(Xe),M(Ye),M(ge),M(fe),M(Ee,e)}}}const Po='{"title":"ALIGN","local":"align","sections":[{"title":"Notes","local":"notes","sections":[],"depth":2},{"title":"Resources","local":"resources","sections":[],"depth":2},{"title":"AlignConfig","local":"transformers.AlignConfig","sections":[],"depth":2},{"title":"AlignTextConfig","local":"transformers.AlignTextConfig","sections":[],"depth":2},{"title":"AlignVisionConfig","local":"transformers.AlignVisionConfig","sections":[],"depth":2},{"title":"AlignProcessor","local":"transformers.AlignProcessor","sections":[],"depth":2},{"title":"AlignModel","local":"transformers.AlignModel","sections":[],"depth":2},{"title":"AlignTextModel","local":"transformers.AlignTextModel","sections":[],"depth":2},{"title":"AlignVisionModel","local":"transformers.AlignVisionModel","sections":[],"depth":2}],"depth":1}';function qo(v){return Jo(()=>{new URLSearchParams(window.location.search).get("fw")}),[]}class ss extends Uo{constructor(n){super(),jo(this,n,qo,Qo,vo,{})}}export{ss as component};

Xet Storage Details

Size:: 111 kB
Xet hash:: b34def9c223c022c41dc4b4ab18f31e45f7ec981a8dfc4da96977ba6e75271bf

Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.