Hugging Face's logo

Buckets:
hf-doc-build
/
doc-dev

Files
xet
hf-doc-build/doc-dev / kernels /pr_892 /en /_app /immutable /nodes /3.CRwehl-R.js
HuggingFaceDocBuilder's picture
HuggingFaceDocBuilder
download
raw
65.7 kB
import"../chunks/DsnmJJEf.js";import{i as Fe,h as ze,C as Le,H as a,D as r,E as d,a as Ye,s as De,b as y}from"../chunks/Boe5hxto.js";import{p as He,o as qe,s as e,f as p,a as c,b as Pe,c as o,d as R,r as t,n as M}from"../chunks/CMKpKl_X.js";const Ke='{"title":"Layers API Reference","local":"layers-api-reference","sections":[{"title":"Making layers kernel-aware","local":"making-layers-kernel-aware","sections":[{"title":"use_kernel_forward_from_hub","local":"kernels.use_kernel_forward_from_hub","sections":[],"depth":3},{"title":"use_kernel_func_from_hub","local":"kernels.use_kernel_func_from_hub","sections":[],"depth":3},{"title":"use_kernelized_func","local":"kernels.use_kernelized_func","sections":[],"depth":3},{"title":"replace_kernel_forward_from_hub","local":"kernels.replace_kernel_forward_from_hub","sections":[],"depth":3}],"depth":2},{"title":"Registering kernel mappings","local":"registering-kernel-mappings","sections":[{"title":"use_kernel_mapping","local":"kernels.use_kernel_mapping","sections":[],"depth":3},{"title":"register_kernel_mapping","local":"kernels.register_kernel_mapping","sections":[],"depth":3}],"depth":2},{"title":"Kernelizing a model","local":"kernelizing-a-model","sections":[{"title":"kernelize","local":"kernels.kernelize","sections":[],"depth":3}],"depth":2},{"title":"Classes","local":"classes","sections":[{"title":"Device","local":"kernels.Device","sections":[],"depth":3},{"title":"CUDAProperties","local":"kernels.CUDAProperties","sections":[],"depth":3},{"title":"ROCMProperties","local":"kernels.ROCMProperties","sections":[],"depth":3},{"title":"Mode","local":"kernels.Mode","sections":[],"depth":3},{"title":"FuncRepository","local":"kernels.FuncRepository","sections":[],"depth":3},{"title":"LayerRepository","local":"kernels.LayerRepository","sections":[],"depth":3},{"title":"LocalFuncRepository","local":"kernels.LocalFuncRepository","sections":[],"depth":3},{"title":"LocalLayerRepository","local":"kernels.LocalLayerRepository","sections":[],"depth":3},{"title":"LockedFuncRepository","local":"kernels.LockedFuncRepository","sections":[],"depth":3},{"title":"LockedLayerRepository","local":"kernels.LockedLayerRepository","sections":[],"depth":3}],"depth":2}],"depth":1}';var $e=R('<meta name="hf:doc:metadata"/>'),m=R("<p>Example:</p> <!>",1),Oe=R(`<p></p> <!> <!> <!> <!> <div class="docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"><!> <p>Decorator factory that makes a layer extensible using the specified layer name.</p> <p>This decorator which prepares a layer class to use kernel layers from the Hugging
Face Hub.</p> <p>When applied to a function, the function is converted into a layer (<code>nn.Module</code>),
made extensible using the given layer name, and then the class is instantiated.
Since <code>nn.Module</code> also implements the <code>__call__</code> method, the module can still be
used as if it was a function. Note that a decorated function is only visible to <a href="/docs/kernels/pr_892/en/api/layers#kernels.kernelize">kernelize()</a> if it is attached to a module using <a href="/docs/kernels/pr_892/en/api/layers#kernels.use_kernelized_func">use_kernelized_func()</a>.</p> <!></div> <!> <div class="docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"><!> <p>Decorator that makes a function extensible using the specified function name.</p> <p>This is a decorator factory that returns a decorator which prepares a function to use kernels from the
Hugging Face Hub.</p> <p>The function will be exposed as an instance of <code>torch.nn.Module</code> in which
the function is called in <code>forward</code>. For the function to be properly
kernelized, it <strong>must</strong> be a member of another <code>torch.nn.Module</code> that is
part of the model (see the example).</p> <blockquote class="warning"><p><code>use_kernel_func_from_hub</code> is deprecated and will be removed in kernels 0.17.
Use <a href="/docs/kernels/pr_892/en/api/layers#kernels.use_kernel_forward_from_hub">use_kernel_forward_from_hub()</a> instead.</p></blockquote> <!></div> <!> <div class="docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"><!> <p>This decorator attaches the target function within the module as a plain
attribute (not as a submodule). This makes the function visible to <a href="/docs/kernels/pr_892/en/api/layers#kernels.kernelize">kernelize()</a>.</p> <!></div> <!> <div class="docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"><!> <p>Function that prepares a layer class to use kernels from the Hugging Face Hub.</p> <p>It is recommended to use <a href="/docs/kernels/pr_892/en/api/layers#kernels.use_kernel_forward_from_hub">use_kernel_forward_from_hub()</a> decorator instead.
This function should only be used as a last resort to extend third-party layers,
it is inherently fragile since the member variables and <code>forward</code> signature
of such a layer can change.</p> <!></div> <!> <!> <div class="docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"><!> <p>Context manager that sets a kernel mapping for the duration of the context.</p> <p>This function allows temporary kernel mappings to be applied within a specific context, enabling different
kernel configurations for different parts of your code.</p> <!></div> <!> <div class="docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"><!> <p>Register a global mapping between layer names and their corresponding kernel implementations.</p> <p>This function allows you to register a mapping between a layer name and the corresponding kernel(s) to use,
depending on the device and mode. This should be used in conjunction with <a href="/docs/kernels/pr_892/en/api/layers#kernels.kernelize">kernelize()</a>.</p> <!></div> <!> <!> <div class="docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"><!> <p>Replace layer forward methods with optimized kernel implementations.</p> <p>This function iterates over all modules in the model and replaces the <code>forward</code> method of extensible layers
for which kernels are registered using <a href="/docs/kernels/pr_892/en/api/layers#kernels.register_kernel_mapping">register_kernel_mapping()</a> or <a href="/docs/kernels/pr_892/en/api/layers#kernels.use_kernel_mapping">use_kernel_mapping()</a>.</p> <!></div> <!> <!> <div class="docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"><!> <p>Represents a compute device with optional properties.</p> <p>This class encapsulates device information including device type and optional device-specific properties
like CUDA capabilities.</p> <!> <div class="docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"><!> <p>Run class validators on the instance.</p></div></div> <!> <div class="docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"><!> <p>CUDA-specific device properties for capability-based kernel selection.</p> <p>This class defines CUDA compute capability constraints for kernel selection, allowing kernels to specify
minimum and maximum CUDA compute capabilities they support.</p> <!> <p>Note:
CUDA compute capabilities are represented as integers where the major and minor versions are concatenated.
For example, compute capability 7.5 is represented as 75, and 8.6 is represented as 86.</p> <div class="docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"><!> <p>Run class validators on the instance.</p></div></div> <!> <div class="docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"><!> <p>ROCM-specific device properties for capability-based kernel selection.</p> <p>This class defines ROCM compute capability constraints for kernel selection, allowing kernels to specify
minimum and maximum ROCM compute capabilities they support.</p> <!> <p>Note:
ROCM compute capabilities are represented as integers where the major and minor versions are concatenated.
For example, compute capability 7.5 is represented as 75, and 8.6 is represented as 86.</p> <div class="docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"><!> <p>Run class validators on the instance.</p></div></div> <!> <div class="docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"><!> <p>Kernelize mode</p> <p>The <code>Mode</code> flag is used by <a href="/docs/kernels/pr_892/en/api/layers#kernels.kernelize">kernelize()</a> to select kernels for the given mode. Mappings can be registered for
specific modes.</p> <p>Note:
Different modes can be combined. For instance, <code>INFERENCE | TORCH_COMPILE</code> should be used for layers that
are used for inference <em>with</em> <code>torch.compile</code>.</p></div> <!> <div class="docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"><!> <p>Repository and name of a function for kernel mapping.</p> <blockquote class="warning"><p><code>FuncRepository</code> is deprecated and will be removed in kernels 0.17.
Use <a href="/docs/kernels/pr_892/en/api/layers#kernels.LayerRepository">LayerRepository</a> instead.</p></blockquote> <!></div> <!> <div class="docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"><!> <p>Repository and name of a layer for kernel mapping.</p> <!></div> <!> <div class="docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"><!> <p>Repository and function name from a local directory for kernel mapping.</p> <blockquote class="warning"><p><code>LocalFuncRepository</code> is deprecated and will be removed in kernels 0.17.
Use <a href="/docs/kernels/pr_892/en/api/layers#kernels.LocalLayerRepository">LocalLayerRepository</a> instead.</p></blockquote> <!></div> <!> <div class="docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"><!> <p>Repository from a local directory for kernel mapping.</p> <!></div> <!> <div class="docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"><!> <p>Repository and name of a function.</p> <p>In contrast to <code>FuncRepository</code>, this class uses repositories that
are locked inside a project.</p> <blockquote class="warning"><p><code>LockedFuncRepository</code> is deprecated and will be removed in kernels 0.17.
Use <a href="/docs/kernels/pr_892/en/api/layers#kernels.LockedLayerRepository">LockedLayerRepository</a> instead.</p></blockquote></div> <!> <div class="docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"><!> <p>Repository and name of a layer.</p> <p>In contrast to <code>LayerRepository</code>, this class uses repositories that
are locked inside a project.</p></div> <!> <p></p>`,1);function ns(je,ge){He(ge,!1),qe(()=>{new URLSearchParams(window.location.search).get("fw")}),Fe();var G=Oe();ze("6lk7xg",l=>{var i=$e();De(i,"content",Ke),c(l,i)});var W=e(p(G),2);Le(W,{containerStyle:"float: right; margin-left: 10px; display: inline-flex; position: relative; z-index: 10;"});var S=e(W,2);a(S,{title:"Layers API Reference",local:"layers-api-reference",headingTag:"h1"});var x=e(S,2);a(x,{title:"Making layers kernel-aware",local:"making-layers-kernel-aware",headingTag:"h2"});var V=e(x,2);a(V,{title:"use_kernel_forward_from_hub",local:"kernels.use_kernel_forward_from_hub",headingTag:"h3"});var h=e(V,2),N=o(h);r(N,{name:"kernels.use_kernel_forward_from_hub",anchor:"kernels.use_kernel_forward_from_hub",source:"https://github.com/huggingface/kernels/blob/vr_892/kernels/src/kernels/layer/layer.py#L344",parameters:[{name:"layer_name",val:": str"},{name:"condition",val:": Callable[['nn.Module'], bool] | None = None"}],parametersDescription:[{anchor:"kernels.use_kernel_forward_from_hub.layer_name",description:`<strong>layer_name</strong> (<code>str</code>) &#x2014;
The name of the layer to use for kernel lookup in registered mappings.`,name:"layer_name"},{anchor:"kernels.use_kernel_forward_from_hub.condition",description:`<strong>condition</strong> (<code>Callable[[&quot;nn.Module&quot;], bool]</code>, <em>optional</em>) &#x2014;
Additional condition that is checked during kernelization. The callable
is passed the module instance and is evaluated for every instance of
the layer when <a href="/docs/kernels/pr_892/en/api/layers#kernels.kernelize">kernelize()</a> is called. If it returns <code>False</code>,
kernelization is skipped for that instance.`,name:"condition"}],returnDescription:`<script context="module">export const metadata = 'undefined';<\/script>
<p>A decorator function that can be applied to layer classes.</p>
`,returnType:`<script context="module">export const metadata = 'undefined';<\/script>
<p><code>Callable</code></p>
`});var _e=e(N,8);d(_e,{anchor:"kernels.use_kernel_forward_from_hub.example",children:(l,i)=>{var s=m(),n=e(p(s),2);y(n,{code:"aW1wb3J0JTIwdG9yY2glMEFpbXBvcnQlMjB0b3JjaC5ubiUyMGFzJTIwbm4lMEElMEFmcm9tJTIwa2VybmVscyUyMGltcG9ydCUyMHVzZV9rZXJuZWxfZm9yd2FyZF9mcm9tX2h1YiUwQWZyb20lMjBrZXJuZWxzJTIwaW1wb3J0JTIwdXNlX2tlcm5lbGl6ZWRfZnVuYyUwQWZyb20lMjBrZXJuZWxzJTIwaW1wb3J0JTIwTW9kZSUyQyUyMGtlcm5lbGl6ZSUwQSUwQSU0MHVzZV9rZXJuZWxfZm9yd2FyZF9mcm9tX2h1YiglMjJNeUN1c3RvbUxheWVyJTIyKSUwQWNsYXNzJTIwTXlDdXN0b21MYXllcihubi5Nb2R1bGUpJTNBJTBBJTIwJTIwJTIwJTIwZGVmJTIwX19pbml0X18oc2VsZiUyQyUyMGhpZGRlbl9zaXplKSUzQSUwQSUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMHN1cGVyKCkuX19pbml0X18oKSUwQSUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMHNlbGYuaGlkZGVuX3NpemUlMjAlM0QlMjBoaWRkZW5fc2l6ZSUwQSUwQSUyMCUyMCUyMCUyMGRlZiUyMGZvcndhcmQoc2VsZiUyQyUyMHglM0ElMjB0b3JjaC5UZW5zb3IpJTNBJTBBJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIzJTIwb3JpZ2luYWwlMjBpbXBsZW1lbnRhdGlvbiUwQSUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMHJldHVybiUyMHglMEElMEFtb2RlbCUyMCUzRCUyME15Q3VzdG9tTGF5ZXIoNzY4KSUwQSUwQSUyMyUyMFRoZSUyMGxheWVyJTIwY2FuJTIwbm93JTIwYmUlMjBrZXJuZWxpemVkJTNBJTBBJTIzJTIwbW9kZWwlMjAlM0QlMjBrZXJuZWxpemUobW9kZWwlMkMlMjBtb2RlJTNETW9kZS5UUkFJTklORyUyMCU3QyUyME1vZGUuVE9SQ0hfQ09NUElMRSUyQyUyMGRldmljZSUzRCUyMmN1ZGElMjIpJTBBJTBBJTIzJTIwVXNlJTIwb24lMjBhJTIwZnVuY3Rpb24lMjAoY29udmVydHMlMjB0aGUlMjBmdW5jdGlvbiUyMHRvJTIwJTYwbm4uTW9kdWxlJTYwKS4lMjBUaGUlMjBmdW5jdGlvbiUwQSUyMyUyMGNhbiUyMHRoZW4lMjBiZSUyMHJlcGxhY2VkJTIwd2l0aCUyMGElMjBsYXllciUyMG1hcHBpbmclMjBmb3IlMjAlNjBNeUN1c3RvbUxheWVyJTYwLiUwQSU0MHVzZV9rZXJuZWxfZm9yd2FyZF9mcm9tX2h1YiglMjJNeUN1c3RvbUxheWVyJTIyKSUwQWRlZiUyMGlkZW50aXR5KHglM0ElMjB0b3JjaC5UZW5zb3IpJTIwLSUzRSUyMHRvcmNoLlRlbnNvciUzQSUwQSUyMCUyMCUyMCUyMHJldHVybiUyMHglMEElMEElNDB1c2Vfa2VybmVsaXplZF9mdW5jKGlkZW50aXR5KSUwQWNsYXNzJTIwTGF5ZXJVc2luZ0lkZW50aXR5KG5uLk1vZHVsZSklM0ElMEElMjAlMjAlMjAlMjBkZWYlMjBmb3J3YXJkKHNlbGYlMkMlMjB4JTNBJTIwdG9yY2guVGVuc29yKSUyMC0lM0UlMjB0b3JjaC5UZW5zb3IlM0ElMEElMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjByZXR1cm4lMjBpZGVudGl0eSh4KSUwQQ==",highlighted:`<span class="hljs-keyword">import</span> torch
<span class="hljs-keyword">import</span> torch.nn <span class="hljs-keyword">as</span> nn
<span class="hljs-keyword">from</span> kernels <span class="hljs-keyword">import</span> use_kernel_forward_from_hub
<span class="hljs-keyword">from</span> kernels <span class="hljs-keyword">import</span> use_kernelized_func
<span class="hljs-keyword">from</span> kernels <span class="hljs-keyword">import</span> Mode, kernelize
<span class="hljs-meta">@use_kernel_forward_from_hub(<span class="hljs-params"><span class="hljs-string">&quot;MyCustomLayer&quot;</span></span>)</span>
<span class="hljs-keyword">class</span> <span class="hljs-title class_">MyCustomLayer</span>(nn.Module):
<span class="hljs-keyword">def</span> <span class="hljs-title function_">__init__</span>(<span class="hljs-params">self, hidden_size</span>):
<span class="hljs-built_in">super</span>().__init__()
<span class="hljs-variable language_">self</span>.hidden_size = hidden_size
<span class="hljs-keyword">def</span> <span class="hljs-title function_">forward</span>(<span class="hljs-params">self, x: torch.Tensor</span>):
<span class="hljs-comment"># original implementation</span>
<span class="hljs-keyword">return</span> x
model = MyCustomLayer(<span class="hljs-number">768</span>)
<span class="hljs-comment"># The layer can now be kernelized:</span>
<span class="hljs-comment"># model = kernelize(model, mode=Mode.TRAINING | Mode.TORCH_COMPILE, device=&quot;cuda&quot;)</span>
<span class="hljs-comment"># Use on a function (converts the function to \`nn.Module\`). The function</span>
<span class="hljs-comment"># can then be replaced with a layer mapping for \`MyCustomLayer\`.</span>
<span class="hljs-meta">@use_kernel_forward_from_hub(<span class="hljs-params"><span class="hljs-string">&quot;MyCustomLayer&quot;</span></span>)</span>
<span class="hljs-keyword">def</span> <span class="hljs-title function_">identity</span>(<span class="hljs-params">x: torch.Tensor</span>) -&gt; torch.Tensor:
<span class="hljs-keyword">return</span> x
<span class="hljs-meta">@use_kernelized_func(<span class="hljs-params">identity</span>)</span>
<span class="hljs-keyword">class</span> <span class="hljs-title class_">LayerUsingIdentity</span>(nn.Module):
<span class="hljs-keyword">def</span> <span class="hljs-title function_">forward</span>(<span class="hljs-params">self, x: torch.Tensor</span>) -&gt; torch.Tensor:
<span class="hljs-keyword">return</span> identity(x)
`,lang:"python",wrap:!1}),c(l,s)},$$slots:{default:!0}}),t(h);var X=e(h,2);a(X,{title:"use_kernel_func_from_hub",local:"kernels.use_kernel_func_from_hub",headingTag:"h3"});var u=e(X,2),A=o(u);r(A,{name:"kernels.use_kernel_func_from_hub",anchor:"kernels.use_kernel_func_from_hub",source:"https://github.com/huggingface/kernels/blob/vr_892/kernels/src/kernels/layer/func.py#L204",parameters:[{name:"func_name",val:": str"}],parametersDescription:[{anchor:"kernels.use_kernel_func_from_hub.func_name",description:`<strong>func_name</strong> (<code>str</code>) &#x2014;
The name of the function name to use for kernel lookup in registered mappings.`,name:"func_name"}],returnDescription:`<script context="module">export const metadata = 'undefined';<\/script>
<p>A decorator function that can be applied to layer classes.</p>
`,returnType:`<script context="module">export const metadata = 'undefined';<\/script>
<p><code>Callable</code></p>
`});var fe=e(A,10);d(fe,{anchor:"kernels.use_kernel_func_from_hub.example",children:(l,i)=>{var s=m(),n=e(p(s),2);y(n,{code:"aW1wb3J0JTIwdG9yY2glMEFpbXBvcnQlMjB0b3JjaC5ubiUyMGFzJTIwbm4lMEElMEFmcm9tJTIwa2VybmVscyUyMGltcG9ydCUyMHVzZV9rZXJuZWxfZnVuY19mcm9tX2h1YiUwQWZyb20lMjBrZXJuZWxzJTIwaW1wb3J0JTIwTW9kZSUyQyUyMGtlcm5lbGl6ZSUwQSUwQSU0MHVzZV9rZXJuZWxfZnVuY19mcm9tX2h1YiglMjJteV9jdXN0b21fZnVuYyUyMiklMEFkZWYlMjBteV9jdXN0b21fZnVuYyh4JTNBJTIwdG9yY2guVGVuc29yKSUzQSUwQSUyMCUyMCUyMCUyMCUyMyUyME9yaWdpbmFsJTIwaW1wbGVtZW50YXRpb24lMEElMjAlMjAlMjAlMjByZXR1cm4lMjB4JTBBJTBBY2xhc3MlMjBNeU1vZGVsKHRvcmNoLm5uLk1vZHVsZSklM0ElMEElMjAlMjAlMjAlMjBkZWYlMjBfX2luaXRfXyhzZWxmKSUzQSUwQSUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMHN1cGVyKCkuX19pbml0X18oKSUwQSUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMHNlbGYuZm4lMjAlM0QlMjBteV9jdXN0b21fZnVuYyUwQSUwQSUyMCUyMCUyMCUyMGRlZiUyMGZvcndhcmQoc2VsZiUyQyUyMHgpJTNBJTBBJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwcmV0dXJuJTIwc2VsZi5mbih4KSUwQSUwQW1vZGVsJTIwJTNEJTIwTXlNb2RlbCgpJTBBJTBBJTIzJTIwVGhlJTIwbGF5ZXIlMjBjYW4lMjBub3clMjBiZSUyMGtlcm5lbGl6ZWQlM0ElMEElMjMlMjBtb2RlbCUyMCUzRCUyMGtlcm5lbGl6ZShtb2RlbCUyQyUyMG1vZGUlM0RNb2RlLlRSQUlOSU5HJTIwJTdDJTIwTW9kZS5UT1JDSF9DT01QSUxFJTJDJTIwZGV2aWNlJTNEJTIyY3VkYSUyMik=",highlighted:`<span class="hljs-keyword">import</span> torch
<span class="hljs-keyword">import</span> torch.nn <span class="hljs-keyword">as</span> nn
<span class="hljs-keyword">from</span> kernels <span class="hljs-keyword">import</span> use_kernel_func_from_hub
<span class="hljs-keyword">from</span> kernels <span class="hljs-keyword">import</span> Mode, kernelize
<span class="hljs-meta">@use_kernel_func_from_hub(<span class="hljs-params"><span class="hljs-string">&quot;my_custom_func&quot;</span></span>)</span>
<span class="hljs-keyword">def</span> <span class="hljs-title function_">my_custom_func</span>(<span class="hljs-params">x: torch.Tensor</span>):
<span class="hljs-comment"># Original implementation</span>
<span class="hljs-keyword">return</span> x
<span class="hljs-keyword">class</span> <span class="hljs-title class_">MyModel</span>(torch.nn.Module):
<span class="hljs-keyword">def</span> <span class="hljs-title function_">__init__</span>(<span class="hljs-params">self</span>):
<span class="hljs-built_in">super</span>().__init__()
<span class="hljs-variable language_">self</span>.fn = my_custom_func
<span class="hljs-keyword">def</span> <span class="hljs-title function_">forward</span>(<span class="hljs-params">self, x</span>):
<span class="hljs-keyword">return</span> <span class="hljs-variable language_">self</span>.fn(x)
model = MyModel()
<span class="hljs-comment"># The layer can now be kernelized:</span>
<span class="hljs-comment"># model = kernelize(model, mode=Mode.TRAINING | Mode.TORCH_COMPILE, device=&quot;cuda&quot;)</span>`,lang:"python",wrap:!1}),c(l,s)},$$slots:{default:!0}}),t(u);var E=e(u,2);a(E,{title:"use_kernelized_func",local:"kernels.use_kernelized_func",headingTag:"h3"});var w=e(E,2),Q=o(w);r(Q,{name:"kernels.use_kernelized_func",anchor:"kernels.use_kernelized_func",source:"https://github.com/huggingface/kernels/blob/vr_892/kernels/src/kernels/layer/layer.py#L462",parameters:[{name:"*args",val:": Callable"}],parametersDescription:[{anchor:"kernels.use_kernelized_func.*args",description:`<strong>*args</strong> (<code>Callable</code>) &#x2014;
Kernel functions to attach to the module.`,name:"*args"}],returnDescription:`<script context="module">export const metadata = 'undefined';<\/script>
<p>A decorator function that can be applied to modules.</p>
`,returnType:`<script context="module">export const metadata = 'undefined';<\/script>
<p><code>Callable</code></p>
`});var Ie=e(Q,4);d(Ie,{anchor:"kernels.use_kernelized_func.example",children:(l,i)=>{var s=m(),n=e(p(s),2);y(n,{code:"aW1wb3J0JTIwdG9yY2glMEFpbXBvcnQlMjB0b3JjaC5ubiUyMGFzJTIwbm4lMEElMEFmcm9tJTIwa2VybmVscyUyMGltcG9ydCUyMHVzZV9rZXJuZWxfZm9yd2FyZF9mcm9tX2h1YiUwQWZyb20lMjBrZXJuZWxzJTIwaW1wb3J0JTIwdXNlX2tlcm5lbGl6ZWRfZnVuYyUwQWZyb20lMjBrZXJuZWxzJTIwaW1wb3J0JTIwTW9kZSUyQyUyMGtlcm5lbGl6ZSUwQSUwQSUyMyUyMFVzZSUyMG9uJTIwYSUyMGZ1bmN0aW9uJTIwKGNvbnZlcnRzJTIwdGhlJTIwZnVuY3Rpb24lMjB0byUyMCU2MG5uLk1vZHVsZSU2MCkuJTIwVGhlJTIwZnVuY3Rpb24lMEElMjMlMjBjYW4lMjB0aGVuJTIwYmUlMjByZXBsYWNlZCUyMHdpdGglMjBhJTIwbGF5ZXIlMjBtYXBwaW5nJTIwZm9yJTIwJTYwTXlDdXN0b21MYXllciU2MC4lMEElNDB1c2Vfa2VybmVsX2ZvcndhcmRfZnJvbV9odWIoJTIyTXlDdXN0b21MYXllciUyMiklMEFkZWYlMjBpZGVudGl0eSh4JTNBJTIwdG9yY2guVGVuc29yKSUyMC0lM0UlMjB0b3JjaC5UZW5zb3IlM0ElMEElMjAlMjAlMjAlMjByZXR1cm4lMjB4JTBBJTBBJTQwdXNlX2tlcm5lbGl6ZWRfZnVuYyhpZGVudGl0eSklMEFjbGFzcyUyMExheWVyVXNpbmdJZGVudGl0eShubi5Nb2R1bGUpJTNBJTBBJTIwJTIwJTIwJTIwZGVmJTIwZm9yd2FyZChzZWxmJTJDJTIweCUzQSUyMHRvcmNoLlRlbnNvciklMjAtJTNFJTIwdG9yY2guVGVuc29yJTNBJTBBJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwcmV0dXJuJTIwaWRlbnRpdHkoeCklMEElMEFtb2RlbCUyMCUzRCUyMExheWVyVXNpbmdJZGVudGl0eSgpJTBBJTBBJTIzJTIwVGhlJTIwbGF5ZXIlMjBjYW4lMjBub3clMjBiZSUyMGtlcm5lbGl6ZWQlM0ElMEElMjMlMjBtb2RlbCUyMCUzRCUyMGtlcm5lbGl6ZShtb2RlbCUyQyUyMG1vZGUlM0RNb2RlLlRSQUlOSU5HJTIwJTdDJTIwTW9kZS5UT1JDSF9DT01QSUxFJTJDJTIwZGV2aWNlJTNEJTIyY3VkYSUyMik=",highlighted:`<span class="hljs-keyword">import</span> torch
<span class="hljs-keyword">import</span> torch.nn <span class="hljs-keyword">as</span> nn
<span class="hljs-keyword">from</span> kernels <span class="hljs-keyword">import</span> use_kernel_forward_from_hub
<span class="hljs-keyword">from</span> kernels <span class="hljs-keyword">import</span> use_kernelized_func
<span class="hljs-keyword">from</span> kernels <span class="hljs-keyword">import</span> Mode, kernelize
<span class="hljs-comment"># Use on a function (converts the function to \`nn.Module\`). The function</span>
<span class="hljs-comment"># can then be replaced with a layer mapping for \`MyCustomLayer\`.</span>
<span class="hljs-meta">@use_kernel_forward_from_hub(<span class="hljs-params"><span class="hljs-string">&quot;MyCustomLayer&quot;</span></span>)</span>
<span class="hljs-keyword">def</span> <span class="hljs-title function_">identity</span>(<span class="hljs-params">x: torch.Tensor</span>) -&gt; torch.Tensor:
<span class="hljs-keyword">return</span> x
<span class="hljs-meta">@use_kernelized_func(<span class="hljs-params">identity</span>)</span>
<span class="hljs-keyword">class</span> <span class="hljs-title class_">LayerUsingIdentity</span>(nn.Module):
<span class="hljs-keyword">def</span> <span class="hljs-title function_">forward</span>(<span class="hljs-params">self, x: torch.Tensor</span>) -&gt; torch.Tensor:
<span class="hljs-keyword">return</span> identity(x)
model = LayerUsingIdentity()
<span class="hljs-comment"># The layer can now be kernelized:</span>
<span class="hljs-comment"># model = kernelize(model, mode=Mode.TRAINING | Mode.TORCH_COMPILE, device=&quot;cuda&quot;)</span>`,lang:"python",wrap:!1}),c(l,s)},$$slots:{default:!0}}),t(w);var F=e(w,2);a(F,{title:"replace_kernel_forward_from_hub",local:"kernels.replace_kernel_forward_from_hub",headingTag:"h3"});var U=e(F,2),z=o(U);r(z,{name:"kernels.replace_kernel_forward_from_hub",anchor:"kernels.replace_kernel_forward_from_hub",source:"https://github.com/huggingface/kernels/blob/vr_892/kernels/src/kernels/layer/layer.py#L312",parameters:[{name:"layer_name",val:": str"},{name:"condition",val:": Callable[['nn.Module'], bool] | None = None"}],parametersDescription:[{anchor:"kernels.replace_kernel_forward_from_hub.layer_name",description:`<strong>layer_name</strong> (<code>str</code>) &#x2014;
The name of the layer to use for kernel lookup in registered mappings.`,name:"layer_name"},{anchor:"kernels.replace_kernel_forward_from_hub.condition",description:`<strong>condition</strong> (<code>Callable[[&quot;nn.Module&quot;], bool]</code>, <em>optional</em>) &#x2014;
Additional condition that is checked during kernelization. The callable
is passed the module instance and is evaluated for every instance of
the layer when <a href="/docs/kernels/pr_892/en/api/layers#kernels.kernelize">kernelize()</a> is called. If it returns <code>False</code>,
kernelization is skipped for that instance.`,name:"condition"}]});var ve=e(z,6);d(ve,{anchor:"kernels.replace_kernel_forward_from_hub.example",children:(l,i)=>{var s=m(),n=e(p(s),2);y(n,{code:"ZnJvbSUyMGtlcm5lbHMlMjBpbXBvcnQlMjByZXBsYWNlX2tlcm5lbF9mb3J3YXJkX2Zyb21faHViJTBBaW1wb3J0JTIwdG9yY2gubm4lMjBhcyUyMG5uJTBBJTBBcmVwbGFjZV9rZXJuZWxfZm9yd2FyZF9mcm9tX2h1Yihubi5MYXllck5vcm0lMkMlMjAlMjJMYXllck5vcm0lMjIp",highlighted:`<span class="hljs-keyword">from</span> kernels <span class="hljs-keyword">import</span> replace_kernel_forward_from_hub
<span class="hljs-keyword">import</span> torch.nn <span class="hljs-keyword">as</span> nn
replace_kernel_forward_from_hub(nn.LayerNorm, <span class="hljs-string">&quot;LayerNorm&quot;</span>)`,lang:"python",wrap:!1}),c(l,s)},$$slots:{default:!0}}),t(U);var L=e(U,2);a(L,{title:"Registering kernel mappings",local:"registering-kernel-mappings",headingTag:"h2"});var Y=e(L,2);a(Y,{title:"use_kernel_mapping",local:"kernels.use_kernel_mapping",headingTag:"h3"});var J=e(Y,2),D=o(J);r(D,{name:"kernels.use_kernel_mapping",anchor:"kernels.use_kernel_mapping",source:"https://github.com/huggingface/kernels/blob/vr_892/kernels/src/kernels/layer/kernelize.py#L20",parameters:[{name:"mapping",val:": dict[str, dict[Device | str, RepositoryProtocol | dict[Mode, RepositoryProtocol]]]"},{name:"inherit_mapping",val:": bool = True"}],parametersDescription:[{anchor:"kernels.use_kernel_mapping.mapping",description:`<strong>mapping</strong> (<code>dict[str, dict[Union[Device, str], Union[LayerRepositoryProtocol, dict[Mode, LayerRepositoryProtocol]]]]</code>) &#x2014;
The kernel mapping to apply. Maps layer names to device-specific kernel configurations.`,name:"mapping"},{anchor:"kernels.use_kernel_mapping.inherit_mapping",description:`<strong>inherit_mapping</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>True</code>) &#x2014;
When <code>True</code>, the current mapping will be extended by <code>mapping</code> inside the context. When <code>False</code>,
only <code>mapping</code> is used inside the context.`,name:"inherit_mapping"}],returnDescription:`<script context="module">export const metadata = 'undefined';<\/script>
<p>Context manager that handles the temporary kernel mapping.</p>
`});var Ce=e(D,6);d(Ce,{anchor:"kernels.use_kernel_mapping.example",children:(l,i)=>{var s=m(),n=e(p(s),2);y(n,{code:"aW1wb3J0JTIwdG9yY2glMEFpbXBvcnQlMjB0b3JjaC5ubiUyMGFzJTIwbm4lMEFmcm9tJTIwdG9yY2gubm4lMjBpbXBvcnQlMjBmdW5jdGlvbmFsJTIwYXMlMjBGJTBBJTBBZnJvbSUyMGtlcm5lbHMlMjBpbXBvcnQlMjB1c2Vfa2VybmVsX2ZvcndhcmRfZnJvbV9odWIlMEFmcm9tJTIwa2VybmVscyUyMGltcG9ydCUyMHVzZV9rZXJuZWxfbWFwcGluZyUyQyUyMExheWVyUmVwb3NpdG9yeSUyQyUyMERldmljZSUwQWZyb20lMjBrZXJuZWxzJTIwaW1wb3J0JTIwTW9kZSUyQyUyMGtlcm5lbGl6ZSUwQSUwQSUyMyUyMERlZmluZSUyMGElMjBtYXBwaW5nJTBBbWFwcGluZyUyMCUzRCUyMCU3QiUwQSUyMCUyMCUyMCUyMCUyMlNpbHVBbmRNdWwlMjIlM0ElMjAlN0IlMEElMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjJjdWRhJTIyJTNBJTIwTGF5ZXJSZXBvc2l0b3J5KCUwQSUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMHJlcG9faWQlM0QlMjJrZXJuZWxzLWNvbW11bml0eSUyRmFjdGl2YXRpb24lMjIlMkMlMEElMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjBsYXllcl9uYW1lJTNEJTIyU2lsdUFuZE11bCUyMiUyQyUwQSUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMHZlcnNpb24lM0QxJTBBJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwKSUwQSUyMCUyMCUyMCUyMCU3RCUwQSU3RCUwQSUwQSU0MHVzZV9rZXJuZWxfZm9yd2FyZF9mcm9tX2h1YiglMjJTaWx1QW5kTXVsJTIyKSUwQWNsYXNzJTIwU2lsdUFuZE11bChubi5Nb2R1bGUpJTNBJTBBJTIwJTIwJTIwJTIwZGVmJTIwZm9yd2FyZChzZWxmJTJDJTIweCUzQSUyMHRvcmNoLlRlbnNvciklMjAtJTNFJTIwdG9yY2guVGVuc29yJTNBJTBBJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwZCUyMCUzRCUyMHguc2hhcGUlNUItMSU1RCUyMCUyRiUyRiUyMDIlMEElMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjByZXR1cm4lMjBGLnNpbHUoeCU1Qi4uLiUyQyUyMCUzQWQlNUQpJTIwKiUyMHglNUIuLi4lMkMlMjBkJTNBJTVEJTBBJTBBbW9kZWwlMjAlM0QlMjBTaWx1QW5kTXVsKCklMEElMEElMjMlMjBVc2UlMjB0aGUlMjBtYXBwaW5nJTIwZm9yJTIwdGhlJTIwZHVyYXRpb24lMjBvZiUyMHRoZSUyMGNvbnRleHQuJTBBd2l0aCUyMHVzZV9rZXJuZWxfbWFwcGluZyhtYXBwaW5nKSUzQSUwQSUyMCUyMCUyMCUyMCUyMyUyMGtlcm5lbGl6ZSUyMHVzZXMlMjB0aGUlMjB0ZW1wb3JhcnklMjBtYXBwaW5nJTBBJTIwJTIwJTIwJTIwbW9kZWwlMjAlM0QlMjBrZXJuZWxpemUobW9kZWwlMkMlMjBtb2RlJTNETW9kZS5UUkFJTklORyUyMCU3QyUyME1vZGUuVE9SQ0hfQ09NUElMRSUyQyUyMGRldmljZSUzRCUyMmN1ZGElMjIpJTBBJTBBJTIzJTIwT3V0c2lkZSUyMHRoZSUyMGNvbnRleHQlMkMlMjBvcmlnaW5hbCUyMG1hcHBpbmdzJTIwYXJlJTIwcmVzdG9yZWQ=",highlighted:`<span class="hljs-keyword">import</span> torch
<span class="hljs-keyword">import</span> torch.nn <span class="hljs-keyword">as</span> nn
<span class="hljs-keyword">from</span> torch.nn <span class="hljs-keyword">import</span> functional <span class="hljs-keyword">as</span> F
<span class="hljs-keyword">from</span> kernels <span class="hljs-keyword">import</span> use_kernel_forward_from_hub
<span class="hljs-keyword">from</span> kernels <span class="hljs-keyword">import</span> use_kernel_mapping, LayerRepository, Device
<span class="hljs-keyword">from</span> kernels <span class="hljs-keyword">import</span> Mode, kernelize
<span class="hljs-comment"># Define a mapping</span>
mapping = {
<span class="hljs-string">&quot;SiluAndMul&quot;</span>: {
<span class="hljs-string">&quot;cuda&quot;</span>: LayerRepository(
repo_id=<span class="hljs-string">&quot;kernels-community/activation&quot;</span>,
layer_name=<span class="hljs-string">&quot;SiluAndMul&quot;</span>,
version=<span class="hljs-number">1</span>
)
}
}
<span class="hljs-meta">@use_kernel_forward_from_hub(<span class="hljs-params"><span class="hljs-string">&quot;SiluAndMul&quot;</span></span>)</span>
<span class="hljs-keyword">class</span> <span class="hljs-title class_">SiluAndMul</span>(nn.Module):
<span class="hljs-keyword">def</span> <span class="hljs-title function_">forward</span>(<span class="hljs-params">self, x: torch.Tensor</span>) -&gt; torch.Tensor:
d = x.shape[-<span class="hljs-number">1</span>] // <span class="hljs-number">2</span>
<span class="hljs-keyword">return</span> F.silu(x[..., :d]) * x[..., d:]
model = SiluAndMul()
<span class="hljs-comment"># Use the mapping for the duration of the context.</span>
<span class="hljs-keyword">with</span> use_kernel_mapping(mapping):
<span class="hljs-comment"># kernelize uses the temporary mapping</span>
model = kernelize(model, mode=Mode.TRAINING | Mode.TORCH_COMPILE, device=<span class="hljs-string">&quot;cuda&quot;</span>)
<span class="hljs-comment"># Outside the context, original mappings are restored</span>`,lang:"python",wrap:!1}),c(l,s)},$$slots:{default:!0}}),t(J);var H=e(J,2);a(H,{title:"register_kernel_mapping",local:"kernels.register_kernel_mapping",headingTag:"h3"});var T=e(H,2),q=o(T);r(q,{name:"kernels.register_kernel_mapping",anchor:"kernels.register_kernel_mapping",source:"https://github.com/huggingface/kernels/blob/vr_892/kernels/src/kernels/layer/kernelize.py#L100",parameters:[{name:"mapping",val:": dict[str, dict[Device | str, RepositoryProtocol | dict[Mode, RepositoryProtocol]]]"},{name:"inherit_mapping",val:": bool = True"}],parametersDescription:[{anchor:"kernels.register_kernel_mapping.mapping",description:`<strong>mapping</strong> (<code>dict[str, dict[Union[Device, str], Union[RepositoryProtocol, dict[Mode, RepositoryProtocol]]]]</code>) &#x2014;
The kernel mapping to register globally. Maps layer names to device-specific kernels.
The mapping can specify different kernels for different modes (training, inference, etc.).`,name:"mapping"},{anchor:"kernels.register_kernel_mapping.inherit_mapping",description:`<strong>inherit_mapping</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>True</code>) &#x2014;
When <code>True</code>, the current mapping will be extended by <code>mapping</code>. When <code>False</code>, the existing mappings
are erased before adding <code>mapping</code>.`,name:"inherit_mapping"}]});var Be=e(q,6);d(Be,{anchor:"kernels.register_kernel_mapping.example",children:(l,i)=>{var s=m(),n=e(p(s),2);y(n,{code:"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",highlighted:`<span class="hljs-keyword">from</span> kernels <span class="hljs-keyword">import</span> LayerRepository, register_kernel_mapping, Mode
<span class="hljs-comment"># Simple mapping for a single kernel per device</span>
kernel_layer_mapping = {
<span class="hljs-string">&quot;LlamaRMSNorm&quot;</span>: {
<span class="hljs-string">&quot;cuda&quot;</span>: LayerRepository(
repo_id=<span class="hljs-string">&quot;kernels-community/layer_norm&quot;</span>,
layer_name=<span class="hljs-string">&quot;LlamaRMSNorm&quot;</span>,
version=<span class="hljs-number">1</span>,
),
},
}
register_kernel_mapping(kernel_layer_mapping)
<span class="hljs-comment"># Advanced mapping with mode-specific kernels</span>
advanced_mapping = {
<span class="hljs-string">&quot;MultiHeadAttention&quot;</span>: {
<span class="hljs-string">&quot;cuda&quot;</span>: {
Mode.TRAINING: LayerRepository(
repo_id=<span class="hljs-string">&quot;kernels-community/training-kernels&quot;</span>,
layer_name=<span class="hljs-string">&quot;TrainingAttention&quot;</span>,
version=<span class="hljs-number">1</span>,
),
Mode.INFERENCE: LayerRepository(
repo_id=<span class="hljs-string">&quot;kernels-community/inference-kernels&quot;</span>,
layer_name=<span class="hljs-string">&quot;FastAttention&quot;</span>,
version=<span class="hljs-number">1</span>,
),
}
}
}
register_kernel_mapping(advanced_mapping)`,lang:"python",wrap:!1}),c(l,s)},$$slots:{default:!0}}),t(T);var P=e(T,2);a(P,{title:"Kernelizing a model",local:"kernelizing-a-model",headingTag:"h2"});var K=e(P,2);a(K,{title:"kernelize",local:"kernels.kernelize",headingTag:"h3"});var k=e(K,2),$=o(k);r($,{name:"kernels.kernelize",anchor:"kernels.kernelize",source:"https://github.com/huggingface/kernels/blob/vr_892/kernels/src/kernels/layer/kernelize.py#L178",parameters:[{name:"model",val:": 'nn.Module'"},{name:"mode",val:": Mode"},{name:"device",val:": str | 'torch.device' | None = None"},{name:"use_fallback",val:": bool | KernelizeFallback = True"}],parametersDescription:[{anchor:"kernels.kernelize.model",description:`<strong>model</strong> (<code>nn.Module</code>) &#x2014;
The PyTorch model to kernelize.`,name:"model"},{anchor:"kernels.kernelize.mode",description:`<strong>mode</strong> (<a href="/docs/kernels/pr_892/en/api/layers#kernels.Mode">Mode</a>) &#x2014; The mode that the kernel is going to be used in. For example,
<code>Mode.TRAINING | Mode.TORCH_COMPILE</code> kernelizes the model for training with
<code>torch.compile</code>.`,name:"mode"},{anchor:"kernels.kernelize.device",description:`<strong>device</strong> (<code>Union[str, torch.device]</code>, <em>optional</em>) &#x2014;
The device type to load kernels for. Supported device types are: &#x201C;cuda&#x201D;, &#x201C;mps&#x201D;, &#x201C;npu&#x201D;, &#x201C;rocm&#x201D;, &#x201C;tpu&#x201D;, &#x201C;xpu&#x201D;.
The device type will be inferred from the model parameters when not provided.`,name:"device"},{anchor:"kernels.kernelize.use_fallback",description:`<strong>use_fallback</strong> (<code>bool | KernelizeFallback</code>, <em>optional</em>, defaults to <code>True</code>) &#x2014;
Cases in which to use the original forward method. <code>True</code> is equivalent to <code>KernelizeFallback.DEFAULT</code>: it allows
fallback when no compatible mapping or mode exists. <code>False</code> is equivalent to <code>KernelizeFallback.NONE</code> and raises
instead. <code>KernelizeFallback.ALL</code> also falls back when kernel loading fails.`,name:"use_fallback"}],returnDescription:`<script context="module">export const metadata = 'undefined';<\/script>
<p>The kernelized model with optimized kernel implementations.</p>
`,returnType:`<script context="module">export const metadata = 'undefined';<\/script>
<p><code>nn.Module</code></p>
`});var Ze=e($,6);d(Ze,{anchor:"kernels.kernelize.example",children:(l,i)=>{var s=m(),n=e(p(s),2);y(n,{code:"aW1wb3J0JTIwdG9yY2glMEFpbXBvcnQlMjB0b3JjaC5ubiUyMGFzJTIwbm4lMEElMEFmcm9tJTIwa2VybmVscyUyMGltcG9ydCUyMGtlcm5lbGl6ZSUyQyUyME1vZGUlMkMlMjB1c2Vfa2VybmVsX21hcHBpbmclMkMlMjBMYXllclJlcG9zaXRvcnklMEFmcm9tJTIwa2VybmVscyUyMGltcG9ydCUyMHVzZV9rZXJuZWxfZm9yd2FyZF9mcm9tX2h1YiUwQSUwQSU0MHVzZV9rZXJuZWxfZm9yd2FyZF9mcm9tX2h1YiglMjJTaWx1QW5kTXVsJTIyKSUwQWNsYXNzJTIwU2lsdUFuZE11bChubi5Nb2R1bGUpJTNBJTBBJTIwJTIwJTIwJTIwZGVmJTIwZm9yd2FyZChzZWxmJTJDJTIweCUzQSUyMHRvcmNoLlRlbnNvciklMjAtJTNFJTIwdG9yY2guVGVuc29yJTNBJTBBJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwZCUyMCUzRCUyMHguc2hhcGUlNUItMSU1RCUyMCUyRiUyRiUyMDIlMEElMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjByZXR1cm4lMjBGLnNpbHUoeCU1Qi4uLiUyQyUyMCUzQWQlNUQpJTIwKiUyMHglNUIuLi4lMkMlMjBkJTNBJTVEJTBBJTBBbWFwcGluZyUyMCUzRCUyMCU3QiUwQSUyMCUyMCUyMCUyMCUyMlNpbHVBbmRNdWwlMjIlM0ElMjAlN0IlMEElMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjJjdWRhJTIyJTNBJTIwTGF5ZXJSZXBvc2l0b3J5KCUwQSUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMHJlcG9faWQlM0QlMjJrZXJuZWxzLWNvbW11bml0eSUyRmFjdGl2YXRpb24lMjIlMkMlMEElMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjBsYXllcl9uYW1lJTNEJTIyU2lsdUFuZE11bCUyMiUyQyUwQSUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMHZlcnNpb24lM0QxJTJDJTBBJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwKSUwQSUyMCUyMCUyMCUyMCU3RCUwQSU3RCUwQSUwQSUyMyUyMENyZWF0ZSUyMGFuZCUyMGtlcm5lbGl6ZSUyMGElMjBtb2RlbCUwQW1vZGVsJTIwJTNEJTIwbm4uU2VxdWVudGlhbCglMEElMjAlMjAlMjAlMjBubi5MaW5lYXIoMTAyNCUyQyUyMDIwNDglMkMlMjBkZXZpY2UlM0QlMjJjdWRhJTIyKSUyQyUwQSUyMCUyMCUyMCUyMFNpbHVBbmRNdWwoKSUyQyUwQSklMEElMEElMjMlMjBLZXJuZWxpemUlMjBmb3IlMjBpbmZlcmVuY2UlMEF3aXRoJTIwdXNlX2tlcm5lbF9tYXBwaW5nKG1hcHBpbmcpJTNBJTBBJTIwJTIwJTIwJTIwa2VybmVsaXplZF9tb2RlbCUyMCUzRCUyMGtlcm5lbGl6ZShtb2RlbCUyQyUyMG1vZGUlM0RNb2RlLlRSQUlOSU5HJTIwJTdDJTIwTW9kZS5UT1JDSF9DT01QSUxFKQ==",highlighted:`<span class="hljs-keyword">import</span> torch
<span class="hljs-keyword">import</span> torch.nn <span class="hljs-keyword">as</span> nn
<span class="hljs-keyword">from</span> kernels <span class="hljs-keyword">import</span> kernelize, Mode, use_kernel_mapping, LayerRepository
<span class="hljs-keyword">from</span> kernels <span class="hljs-keyword">import</span> use_kernel_forward_from_hub
<span class="hljs-meta">@use_kernel_forward_from_hub(<span class="hljs-params"><span class="hljs-string">&quot;SiluAndMul&quot;</span></span>)</span>
<span class="hljs-keyword">class</span> <span class="hljs-title class_">SiluAndMul</span>(nn.Module):
<span class="hljs-keyword">def</span> <span class="hljs-title function_">forward</span>(<span class="hljs-params">self, x: torch.Tensor</span>) -&gt; torch.Tensor:
d = x.shape[-<span class="hljs-number">1</span>] // <span class="hljs-number">2</span>
<span class="hljs-keyword">return</span> F.silu(x[..., :d]) * x[..., d:]
mapping = {
<span class="hljs-string">&quot;SiluAndMul&quot;</span>: {
<span class="hljs-string">&quot;cuda&quot;</span>: LayerRepository(
repo_id=<span class="hljs-string">&quot;kernels-community/activation&quot;</span>,
layer_name=<span class="hljs-string">&quot;SiluAndMul&quot;</span>,
version=<span class="hljs-number">1</span>,
)
}
}
<span class="hljs-comment"># Create and kernelize a model</span>
model = nn.Sequential(
nn.Linear(<span class="hljs-number">1024</span>, <span class="hljs-number">2048</span>, device=<span class="hljs-string">&quot;cuda&quot;</span>),
SiluAndMul(),
)
<span class="hljs-comment"># Kernelize for inference</span>
<span class="hljs-keyword">with</span> use_kernel_mapping(mapping):
kernelized_model = kernelize(model, mode=Mode.TRAINING | Mode.TORCH_COMPILE)`,lang:"python",wrap:!1}),c(l,s)},$$slots:{default:!0}}),t(k);var O=e(k,2);a(O,{title:"Classes",local:"classes",headingTag:"h2"});var ee=e(O,2);a(ee,{title:"Device",local:"kernels.Device",headingTag:"h3"});var b=e(ee,2),se=o(b);r(se,{name:"class kernels.Device",anchor:"kernels.Device",source:"https://github.com/huggingface/kernels/blob/vr_892/kernels/src/kernels/layer/device.py#L106",parameters:[{name:"type",val:": str"},{name:"properties",val:": kernels.layer.device.CUDAProperties | kernels.layer.device.ROCMProperties | None = None"}],parametersDescription:[{anchor:"kernels.Device.type",description:`<strong>type</strong> (<code>str</code>) &#x2014;
The device type (e.g., &#x201C;cuda&#x201D;, &#x201C;mps&#x201D;, &#x201C;npu&#x201D;, &#x201C;rocm&#x201D;, &#x201C;xpu&#x201D;).`,name:"type"},{anchor:"kernels.Device.properties",description:`<strong>properties</strong> (<a href="/docs/kernels/pr_892/en/api/layers#kernels.CUDAProperties">CUDAProperties</a>, <em>optional</em>) &#x2014;
Device-specific properties. Currently only <a href="/docs/kernels/pr_892/en/api/layers#kernels.CUDAProperties">CUDAProperties</a> is supported for CUDA devices.`,name:"properties"}]});var le=e(se,6);d(le,{anchor:"kernels.Device.example",children:(l,i)=>{var s=m(),n=e(p(s),2);y(n,{code:"ZnJvbSUyMGtlcm5lbHMlMjBpbXBvcnQlMjBEZXZpY2UlMkMlMjBDVURBUHJvcGVydGllcyUwQSUwQSUyMyUyMEJhc2ljJTIwQ1VEQSUyMGRldmljZSUwQWN1ZGFfZGV2aWNlJTIwJTNEJTIwRGV2aWNlKHR5cGUlM0QlMjJjdWRhJTIyKSUwQSUwQSUyMyUyMENVREElMjBkZXZpY2UlMjB3aXRoJTIwc3BlY2lmaWMlMjBjYXBhYmlsaXR5JTIwcmVxdWlyZW1lbnRzJTBBY3VkYV9kZXZpY2Vfd2l0aF9wcm9wcyUyMCUzRCUyMERldmljZSglMEElMjAlMjAlMjAlMjB0eXBlJTNEJTIyY3VkYSUyMiUyQyUwQSUyMCUyMCUyMCUyMHByb3BlcnRpZXMlM0RDVURBUHJvcGVydGllcyhtaW5fY2FwYWJpbGl0eSUzRDc1JTJDJTIwbWF4X2NhcGFiaWxpdHklM0Q5MCklMEEpJTBBJTBBJTIzJTIwTVBTJTIwZGV2aWNlJTIwZm9yJTIwQXBwbGUlMjBTaWxpY29uJTBBbXBzX2RldmljZSUyMCUzRCUyMERldmljZSh0eXBlJTNEJTIybXBzJTIyKSUwQSUwQSUyMyUyMFhQVSUyMGRldmljZSUyMChlLmcuJTJDJTIwSW50ZWwoUiklMjBEYXRhJTIwQ2VudGVyJTIwR1BVJTIwTWF4JTIwMTU1MCklMEF4cHVfZGV2aWNlJTIwJTNEJTIwRGV2aWNlKHR5cGUlM0QlMjJ4cHUlMjIpJTBBJTBBJTIzJTIwTlBVJTIwZGV2aWNlJTIwKEh1YXdlaSUyMEFzY2VuZCklMEFucHVfZGV2aWNlJTIwJTNEJTIwRGV2aWNlKHR5cGUlM0QlMjJucHUlMjIp",highlighted:`<span class="hljs-keyword">from</span> kernels <span class="hljs-keyword">import</span> Device, CUDAProperties
<span class="hljs-comment"># Basic CUDA device</span>
cuda_device = Device(<span class="hljs-built_in">type</span>=<span class="hljs-string">&quot;cuda&quot;</span>)
<span class="hljs-comment"># CUDA device with specific capability requirements</span>
cuda_device_with_props = Device(
<span class="hljs-built_in">type</span>=<span class="hljs-string">&quot;cuda&quot;</span>,
properties=CUDAProperties(min_capability=<span class="hljs-number">75</span>, max_capability=<span class="hljs-number">90</span>)
)
<span class="hljs-comment"># MPS device for Apple Silicon</span>
mps_device = Device(<span class="hljs-built_in">type</span>=<span class="hljs-string">&quot;mps&quot;</span>)
<span class="hljs-comment"># XPU device (e.g., Intel(R) Data Center GPU Max 1550)</span>
xpu_device = Device(<span class="hljs-built_in">type</span>=<span class="hljs-string">&quot;xpu&quot;</span>)
<span class="hljs-comment"># NPU device (Huawei Ascend)</span>
npu_device = Device(<span class="hljs-built_in">type</span>=<span class="hljs-string">&quot;npu&quot;</span>)`,lang:"python",wrap:!1}),c(l,s)},$$slots:{default:!0}});var ne=e(le,2),Re=o(ne);r(Re,{name:"validate",anchor:"kernels.Device.validate",source:"https://github.com/huggingface/kernels/blob/vr_892/kernels/src/huggingface_hub/dataclasses.py#L247",parameters:[]}),M(2),t(ne),t(b);var ae=e(b,2);a(ae,{title:"CUDAProperties",local:"kernels.CUDAProperties",headingTag:"h3"});var j=e(ae,2),re=o(j);r(re,{name:"class kernels.CUDAProperties",anchor:"kernels.CUDAProperties",source:"https://github.com/huggingface/kernels/blob/vr_892/kernels/src/kernels/layer/device.py#L8",parameters:[{name:"min_capability",val:": int"},{name:"max_capability",val:": int"}],parametersDescription:[{anchor:"kernels.CUDAProperties.min_capability",description:`<strong>min_capability</strong> (<code>int</code>) &#x2014;
Minimum CUDA compute capability required (e.g., 75 for compute capability 7.5).`,name:"min_capability"},{anchor:"kernels.CUDAProperties.max_capability",description:`<strong>max_capability</strong> (<code>int</code>) &#x2014;
Maximum CUDA compute capability supported (e.g., 90 for compute capability 9.0).`,name:"max_capability"}]});var oe=e(re,6);d(oe,{anchor:"kernels.CUDAProperties.example",children:(l,i)=>{var s=m(),n=e(p(s),2);y(n,{code:"ZnJvbSUyMGtlcm5lbHMlMjBpbXBvcnQlMjBDVURBUHJvcGVydGllcyUyQyUyMERldmljZSUwQSUwQSUyMyUyMERlZmluZSUyMENVREElMjBwcm9wZXJ0aWVzJTIwZm9yJTIwbW9kZXJuJTIwR1BVcyUyMChjb21wdXRlJTIwY2FwYWJpbGl0eSUyMDcuNSUyMHRvJTIwOS4wKSUwQWN1ZGFfcHJvcHMlMjAlM0QlMjBDVURBUHJvcGVydGllcyhtaW5fY2FwYWJpbGl0eSUzRDc1JTJDJTIwbWF4X2NhcGFiaWxpdHklM0Q5MCklMEElMEElMjMlMjBDcmVhdGUlMjBhJTIwZGV2aWNlJTIwd2l0aCUyMHRoZXNlJTIwcHJvcGVydGllcyUwQWRldmljZSUyMCUzRCUyMERldmljZSh0eXBlJTNEJTIyY3VkYSUyMiUyQyUyMHByb3BlcnRpZXMlM0RjdWRhX3Byb3BzKQ==",highlighted:`<span class="hljs-keyword">from</span> kernels <span class="hljs-keyword">import</span> CUDAProperties, Device
<span class="hljs-comment"># Define CUDA properties for modern GPUs (compute capability 7.5 to 9.0)</span>
cuda_props = CUDAProperties(min_capability=<span class="hljs-number">75</span>, max_capability=<span class="hljs-number">90</span>)
<span class="hljs-comment"># Create a device with these properties</span>
device = Device(<span class="hljs-built_in">type</span>=<span class="hljs-string">&quot;cuda&quot;</span>, properties=cuda_props)`,lang:"python",wrap:!1}),c(l,s)},$$slots:{default:!0}});var te=e(oe,4),Ge=o(te);r(Ge,{name:"validate",anchor:"kernels.CUDAProperties.validate",source:"https://github.com/huggingface/kernels/blob/vr_892/kernels/src/huggingface_hub/dataclasses.py#L247",parameters:[]}),M(2),t(te),t(j);var ie=e(j,2);a(ie,{title:"ROCMProperties",local:"kernels.ROCMProperties",headingTag:"h3"});var g=e(ie,2),ce=o(g);r(ce,{name:"class kernels.ROCMProperties",anchor:"kernels.ROCMProperties",source:"https://github.com/huggingface/kernels/blob/vr_892/kernels/src/kernels/layer/device.py#L57",parameters:[{name:"min_capability",val:": int"},{name:"max_capability",val:": int"}],parametersDescription:[{anchor:"kernels.ROCMProperties.min_capability",description:`<strong>min_capability</strong> (<code>int</code>) &#x2014;
Minimum ROCM compute capability required (e.g., 75 for compute capability 7.5).`,name:"min_capability"},{anchor:"kernels.ROCMProperties.max_capability",description:`<strong>max_capability</strong> (<code>int</code>) &#x2014;
Maximum ROCM compute capability supported (e.g., 90 for compute capability 9.0).`,name:"max_capability"}]});var pe=e(ce,6);d(pe,{anchor:"kernels.ROCMProperties.example",children:(l,i)=>{var s=m(),n=e(p(s),2);y(n,{code:"ZnJvbSUyMGtlcm5lbHMlMjBpbXBvcnQlMjBST0NNUHJvcGVydGllcyUyQyUyMERldmljZSUwQSUwQSUyMyUyMERlZmluZSUyMFJPQ00lMjBwcm9wZXJ0aWVzJTIwZm9yJTIwbW9kZXJuJTIwR1BVcyUyMChjb21wdXRlJTIwY2FwYWJpbGl0eSUyMDcuNSUyMHRvJTIwOS4wKSUwQXJvY21fcHJvcHMlMjAlM0QlMjBST0NNUHJvcGVydGllcyhtaW5fY2FwYWJpbGl0eSUzRDc1JTJDJTIwbWF4X2NhcGFiaWxpdHklM0Q5MCklMEElMEElMjMlMjBDcmVhdGUlMjBhJTIwZGV2aWNlJTIwd2l0aCUyMHRoZXNlJTIwcHJvcGVydGllcyUwQWRldmljZSUyMCUzRCUyMERldmljZSh0eXBlJTNEJTIycm9jbSUyMiUyQyUyMHByb3BlcnRpZXMlM0Ryb2NtX3Byb3BzKQ==",highlighted:`<span class="hljs-keyword">from</span> kernels <span class="hljs-keyword">import</span> ROCMProperties, Device
<span class="hljs-comment"># Define ROCM properties for modern GPUs (compute capability 7.5 to 9.0)</span>
rocm_props = ROCMProperties(min_capability=<span class="hljs-number">75</span>, max_capability=<span class="hljs-number">90</span>)
<span class="hljs-comment"># Create a device with these properties</span>
device = Device(<span class="hljs-built_in">type</span>=<span class="hljs-string">&quot;rocm&quot;</span>, properties=rocm_props)`,lang:"python",wrap:!1}),c(l,s)},$$slots:{default:!0}});var de=e(pe,4),We=o(de);r(We,{name:"validate",anchor:"kernels.ROCMProperties.validate",source:"https://github.com/huggingface/kernels/blob/vr_892/kernels/src/huggingface_hub/dataclasses.py#L247",parameters:[]}),M(2),t(de),t(g);var ye=e(g,2);a(ye,{title:"Mode",local:"kernels.Mode",headingTag:"h3"});var _=e(ye,2),Se=o(_);r(Se,{name:"class kernels.Mode",anchor:"kernels.Mode",source:"https://github.com/huggingface/kernels/blob/vr_892/kernels/src/kernels/layer/mode.py#L4",parameters:[{name:"value",val:""},{name:"names",val:" = None"},{name:"module",val:" = None"},{name:"qualname",val:" = None"},{name:"type",val:" = None"},{name:"start",val:" = 1"}],parametersDescription:[{anchor:"kernels.Mode.INFERENCE",description:"<strong>INFERENCE</strong> &#x2014; The kernel is used for inference.",name:"INFERENCE"},{anchor:"kernels.Mode.TRAINING",description:"<strong>TRAINING</strong> &#x2014; The kernel is used for training.",name:"TRAINING"},{anchor:"kernels.Mode.TORCH_COMPILE",description:"<strong>TORCH_COMPILE</strong> &#x2014; The kernel is used with <code>torch.compile</code>.",name:"TORCH_COMPILE"},{anchor:"kernels.Mode.FALLBACK",description:"<strong>FALLBACK</strong> &#x2014; In a kernel mapping, this kernel is used when no other mode matches.",name:"FALLBACK"}]}),M(6),t(_);var me=e(_,2);a(me,{title:"FuncRepository",local:"kernels.FuncRepository",headingTag:"h3"});var f=e(me,2),Me=o(f);r(Me,{name:"class kernels.FuncRepository",anchor:"kernels.FuncRepository",source:"https://github.com/huggingface/kernels/blob/vr_892/kernels/src/kernels/layer/func.py#L36",parameters:[{name:"repo_id",val:": str"},{name:"func_name",val:": str"},{name:"revision",val:": str | None = None"},{name:"version",val:": int | None = None"},{name:"trust_remote_code",val:": bool | list[str] = False"}],parametersDescription:[{anchor:"kernels.FuncRepository.repo_id",description:`<strong>repo_id</strong> (<code>str</code>) &#x2014;
The Hub repository containing the layer.`,name:"repo_id"},{anchor:"kernels.FuncRepository.func_name",description:`<strong>func_name</strong> (<code>str</code>) &#x2014;
The name of the function within the kernel repository.`,name:"func_name"},{anchor:"kernels.FuncRepository.revision",description:`<strong>revision</strong> (<code>str</code>, <em>optional</em>) &#x2014;
The specific revision (branch, tag, or commit) to download. Cannot be used together with <code>version</code>.`,name:"revision"},{anchor:"kernels.FuncRepository.version",description:`<strong>version</strong> (<code>int</code>, <em>optional</em>) &#x2014;
The kernel version to download. Cannot be used together with <code>revision</code>.
Either <code>version</code> or <code>revision</code> must be specified.`,name:"version"}]});var xe=e(Me,6);d(xe,{anchor:"kernels.FuncRepository.example",children:(l,i)=>{var s=m(),n=e(p(s),2);y(n,{code:"ZnJvbSUyMGtlcm5lbHMlMjBpbXBvcnQlMjBGdW5jUmVwb3NpdG9yeSUwQSUwQSUyMyUyMFJlZmVyZW5jZSUyMGElMjBzcGVjaWZpYyUyMGxheWVyJTIwYnklMjByZXZpc2lvbiUwQWxheWVyX3JlcG8lMjAlM0QlMjBGdW5jUmVwb3NpdG9yeSglMEElMjAlMjAlMjAlMjByZXBvX2lkJTNEJTIya2VybmVscy1jb21tdW5pdHklMkZhY3RpdmF0aW9uJTIyJTJDJTBBJTIwJTIwJTIwJTIwZnVuY19uYW1lJTNEJTIyc2lsdV9hbmRfbXVsJTIyJTJDJTBBJTIwJTIwJTIwJTIwcmV2aXNpb24lM0QlMjJtYWluJTIyJTJDJTBBKSUwQSUwQSUyMyUyMFJlZmVyZW5jZSUyMGElMjBsYXllciUyMGJ5JTIwdmVyc2lvbiUwQWxheWVyX3JlcG9fdmVyc2lvbmVkJTIwJTNEJTIwRnVuY1JlcG9zaXRvcnkoJTBBJTIwJTIwJTIwJTIwcmVwb19pZCUzRCUyMmtlcm5lbHMtY29tbXVuaXR5JTJGcmVsdSUyMiUyQyUwQSUyMCUyMCUyMCUyMGZ1bmNfbmFtZSUzRCUyMnJlbHUlMjIlMkMlMEElMjAlMjAlMjAlMjB2ZXJzaW9uJTNEMSUwQSk=",highlighted:`<span class="hljs-keyword">from</span> kernels <span class="hljs-keyword">import</span> FuncRepository
<span class="hljs-comment"># Reference a specific layer by revision</span>
layer_repo = FuncRepository(
repo_id=<span class="hljs-string">&quot;kernels-community/activation&quot;</span>,
func_name=<span class="hljs-string">&quot;silu_and_mul&quot;</span>,
revision=<span class="hljs-string">&quot;main&quot;</span>,
)
<span class="hljs-comment"># Reference a layer by version</span>
layer_repo_versioned = FuncRepository(
repo_id=<span class="hljs-string">&quot;kernels-community/relu&quot;</span>,
func_name=<span class="hljs-string">&quot;relu&quot;</span>,
version=<span class="hljs-number">1</span>
)`,lang:"python",wrap:!1}),c(l,s)},$$slots:{default:!0}}),t(f);var he=e(f,2);a(he,{title:"LayerRepository",local:"kernels.LayerRepository",headingTag:"h3"});var I=e(he,2),ue=o(I);r(ue,{name:"class kernels.LayerRepository",anchor:"kernels.LayerRepository",source:"https://github.com/huggingface/kernels/blob/vr_892/kernels/src/kernels/layer/layer.py#L71",parameters:[{name:"repo_id",val:": str"},{name:"layer_name",val:": str"},{name:"revision",val:": str | None = None"},{name:"version",val:": int | None = None"},{name:"trust_remote_code",val:": bool | list[str] = False"},{name:"user_agent",val:": str | dict | None = None"}],parametersDescription:[{anchor:"kernels.LayerRepository.repo_id",description:`<strong>repo_id</strong> (<code>str</code>) &#x2014;
The Hub repository containing the layer.`,name:"repo_id"},{anchor:"kernels.LayerRepository.layer_name",description:`<strong>layer_name</strong> (<code>str</code>) &#x2014;
The name of the layer within the kernel repository.`,name:"layer_name"},{anchor:"kernels.LayerRepository.revision",description:`<strong>revision</strong> (<code>str</code>, <em>optional</em>) &#x2014;
The specific revision (branch, tag, or commit) to download. Cannot be used together with <code>version</code>.`,name:"revision"},{anchor:"kernels.LayerRepository.version",description:`<strong>version</strong> (<code>int</code>, <em>optional</em>) &#x2014;
The kernel version to download. Cannot be used together with <code>revision</code>.
Either <code>version</code> or <code>revision</code> must be specified.`,name:"version"},{anchor:"kernels.LayerRepository.trust_remote_code",description:`<strong>trust_remote_code</strong> (<code>bool | list[str]</code>, <em>optional</em>, defaults to <code>False</code>) &#x2014;
Whether to allow loading kernels from untrusted organisations. When <code>False</code>,
only kernels from trusted organisations are allowed. When <code>True</code>, all
repositories are allowed. A list of repository IDs allows only those
repositories in addition to repositories from trusted organisations.`,name:"trust_remote_code"},{anchor:"kernels.LayerRepository.user_agent",description:`<strong>user_agent</strong> (<code>Union[str, dict]</code>, <em>optional</em>) &#x2014;
Optional application metadata to include in the user-agent for Hub requests.`,name:"user_agent"}]});var Ve=e(ue,4);d(Ve,{anchor:"kernels.LayerRepository.example",children:(l,i)=>{var s=m(),n=e(p(s),2);y(n,{code:"ZnJvbSUyMGtlcm5lbHMlMjBpbXBvcnQlMjBMYXllclJlcG9zaXRvcnklMEElMEElMjMlMjBSZWZlcmVuY2UlMjBhJTIwc3BlY2lmaWMlMjBsYXllciUyMGJ5JTIwdmVyc2lvbiUwQWxheWVyX3JlcG8lMjAlM0QlMjBMYXllclJlcG9zaXRvcnkoJTBBJTIwJTIwJTIwJTIwcmVwb19pZCUzRCUyMmtlcm5lbHMtY29tbXVuaXR5JTJGYWN0aXZhdGlvbiUyMiUyQyUwQSUyMCUyMCUyMCUyMGxheWVyX25hbWUlM0QlMjJTaWx1QW5kTXVsJTIyJTJDJTBBJTIwJTIwJTIwJTIwdmVyc2lvbiUzRDElMkMlMEEp",highlighted:`<span class="hljs-keyword">from</span> kernels <span class="hljs-keyword">import</span> LayerRepository
<span class="hljs-comment"># Reference a specific layer by version</span>
layer_repo = LayerRepository(
repo_id=<span class="hljs-string">&quot;kernels-community/activation&quot;</span>,
layer_name=<span class="hljs-string">&quot;SiluAndMul&quot;</span>,
version=<span class="hljs-number">1</span>,
)`,lang:"python",wrap:!1}),c(l,s)},$$slots:{default:!0}}),t(I);var we=e(I,2);a(we,{title:"LocalFuncRepository",local:"kernels.LocalFuncRepository",headingTag:"h3"});var v=e(we,2),Ue=o(v);r(Ue,{name:"class kernels.LocalFuncRepository",anchor:"kernels.LocalFuncRepository",source:"https://github.com/huggingface/kernels/blob/vr_892/kernels/src/kernels/layer/func.py#L144",parameters:[{name:"repo_path",val:": Path"},{name:"func_name",val:": str"}],parametersDescription:[{anchor:"kernels.LocalFuncRepository.repo_path",description:`<strong>repo_path</strong> (<code>Path</code>) &#x2014;
The local repository containing the layer.`,name:"repo_path"},{anchor:"kernels.LocalFuncRepository.func_name",description:`<strong>func_name</strong> (<code>str</code>) &#x2014;
The name of the function within the kernel repository.`,name:"func_name"}]});var Ne=e(Ue,6);d(Ne,{anchor:"kernels.LocalFuncRepository.example",children:(l,i)=>{var s=m(),n=e(p(s),2);y(n,{code:"ZnJvbSUyMHBhdGhsaWIlMjBpbXBvcnQlMjBQYXRoJTBBJTBBZnJvbSUyMGtlcm5lbHMlMjBpbXBvcnQlMjBMb2NhbEZ1bmNSZXBvc2l0b3J5JTBBJTBBJTIzJTIwUmVmZXJlbmNlJTIwYSUyMHNwZWNpZmljJTIwbGF5ZXIlMjBieSUyMHJldmlzaW9uJTBBbGF5ZXJfcmVwbyUyMCUzRCUyMExvY2FsRnVuY1JlcG9zaXRvcnkoJTBBJTIwJTIwJTIwJTIwcmVwb19wYXRoJTNEUGF0aCglMjIlMkZob21lJTJGZGFuaWVsJTJGa2VybmVscyUyRmFjdGl2YXRpb24lMjIpJTJDJTBBJTIwJTIwJTIwJTIwZnVuY19uYW1lJTNEJTIyc2lsdV9hbmRfbXVsJTIyJTJDJTBBKQ==",highlighted:`<span class="hljs-keyword">from</span> pathlib <span class="hljs-keyword">import</span> Path
<span class="hljs-keyword">from</span> kernels <span class="hljs-keyword">import</span> LocalFuncRepository
<span class="hljs-comment"># Reference a specific layer by revision</span>
layer_repo = LocalFuncRepository(
repo_path=Path(<span class="hljs-string">&quot;/home/daniel/kernels/activation&quot;</span>),
func_name=<span class="hljs-string">&quot;silu_and_mul&quot;</span>,
)`,lang:"python",wrap:!1}),c(l,s)},$$slots:{default:!0}}),t(v);var Je=e(v,2);a(Je,{title:"LocalLayerRepository",local:"kernels.LocalLayerRepository",headingTag:"h3"});var C=e(Je,2),Te=o(C);r(Te,{name:"class kernels.LocalLayerRepository",anchor:"kernels.LocalLayerRepository",source:"https://github.com/huggingface/kernels/blob/vr_892/kernels/src/kernels/layer/layer.py#L173",parameters:[{name:"repo_path",val:": Path"},{name:"layer_name",val:": str"}],parametersDescription:[{anchor:"kernels.LocalLayerRepository.repo_path",description:`<strong>repo_path</strong> (<code>Path</code>) &#x2014;
The local repository containing the layer.`,name:"repo_path"},{anchor:"kernels.LocalLayerRepository.layer_name",description:`<strong>layer_name</strong> (<code>str</code>) &#x2014;
The name of the layer within the kernel repository.`,name:"layer_name"}]});var Xe=e(Te,4);d(Xe,{anchor:"kernels.LocalLayerRepository.example",children:(l,i)=>{var s=m(),n=e(p(s),2);y(n,{code:"ZnJvbSUyMHBhdGhsaWIlMjBpbXBvcnQlMjBQYXRoJTBBJTBBZnJvbSUyMGtlcm5lbHMlMjBpbXBvcnQlMjBMb2NhbExheWVyUmVwb3NpdG9yeSUwQSUwQSUyMyUyMFJlZmVyZW5jZSUyMGElMjBzcGVjaWZpYyUyMGxheWVyJTIwYnklMjByZXZpc2lvbiUwQWxheWVyX3JlcG8lMjAlM0QlMjBMb2NhbExheWVyUmVwb3NpdG9yeSglMEElMjAlMjAlMjAlMjByZXBvX3BhdGglM0RQYXRoKCUyMiUyRmhvbWUlMkZkYW5pZWwlMkZrZXJuZWxzJTJGYWN0aXZhdGlvbiUyMiklMkMlMEElMjAlMjAlMjAlMjBsYXllcl9uYW1lJTNEJTIyU2lsdUFuZE11bCUyMiUyQyUwQSk=",highlighted:`<span class="hljs-keyword">from</span> pathlib <span class="hljs-keyword">import</span> Path
<span class="hljs-keyword">from</span> kernels <span class="hljs-keyword">import</span> LocalLayerRepository
<span class="hljs-comment"># Reference a specific layer by revision</span>
layer_repo = LocalLayerRepository(
repo_path=Path(<span class="hljs-string">&quot;/home/daniel/kernels/activation&quot;</span>),
layer_name=<span class="hljs-string">&quot;SiluAndMul&quot;</span>,
)`,lang:"python",wrap:!1}),c(l,s)},$$slots:{default:!0}}),t(C);var ke=e(C,2);a(ke,{title:"LockedFuncRepository",local:"kernels.LockedFuncRepository",headingTag:"h3"});var B=e(ke,2),Ae=o(B);r(Ae,{name:"class kernels.LockedFuncRepository",anchor:"kernels.LockedFuncRepository",source:"https://github.com/huggingface/kernels/blob/vr_892/kernels/src/kernels/layer/func.py#L262",parameters:[{name:"repo_id",val:": str"},{name:"lockfile",val:": pathlib.Path | None = None"},{name:"func_name",val:": str"},{name:"trust_remote_code",val:": bool | list[str] = False"}],parametersDescription:[{anchor:"kernels.LockedFuncRepository.repo_id",description:"<strong>repo_id</strong> (<code>str</code>) &#x2014; The Hub repository containing the function.",name:"repo_id"},{anchor:"kernels.LockedFuncRepository.lockfile",description:`<strong>lockfile</strong> (<code>Path</code>, <em>optional</em>) &#x2014; Path to the lockfile. If not provided,
the lockfile will be inferred from the caller&#x2019;s context.`,name:"lockfile"},{anchor:"kernels.LockedFuncRepository.func_name",description:"<strong>func_name</strong> (<code>str</code>) &#x2014; The name of the function within the kernel repository.",name:"func_name"},{anchor:"kernels.LockedFuncRepository.trust_remote_code",description:`<strong>trust_remote_code</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>False</code>) &#x2014;
Whether to allow loading kernels from untrusted organisations.`,name:"trust_remote_code"}]}),M(6),t(B);var be=e(B,2);a(be,{title:"LockedLayerRepository",local:"kernels.LockedLayerRepository",headingTag:"h3"});var Z=e(be,2),Ee=o(Z);r(Ee,{name:"class kernels.LockedLayerRepository",anchor:"kernels.LockedLayerRepository",source:"https://github.com/huggingface/kernels/blob/vr_892/kernels/src/kernels/layer/layer.py#L224",parameters:[{name:"repo_id",val:": str"},{name:"lockfile",val:": Path | None = None"},{name:"layer_name",val:": str"},{name:"trust_remote_code",val:": bool | list[str] = False"}]}),M(4),t(Z);var Qe=e(Z,2);Ye(Qe,{source:"https://github.com/huggingface/kernels/blob/main/docs/source/api/layers.md"}),M(2),c(je,G),Pe()}export{ns as component};

Xet Storage Details

Size:
65.7 kB
·
Xet hash:
5a820a7a58537f80fce83b4658893b2f3a812c8bcdfc40ae8ec3ae6d2be040c4

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