diff --git a/README.md b/README.md index 73804b1..4d91afb 100644 --- a/README.md +++ b/README.md @@ -31,7 +31,8 @@ The problems cover what's actually inside Transformers, vLLM, TRL, diffusion mod ### Features -- **Browser editor** — Monaco with Python syntax highlighting, no IDE setup +- **Browser editor** — Monaco with Python syntax highlighting and autocomplete for + `torch`, `nn`, `F`, `np`, `math` and tensor methods, no IDE setup - **Instant feedback** — submit and see pass/fail per test case in seconds - **Reference solutions** — compare after your own attempt - **Progress tracking** — solved count and attempt history, persisted across sessions diff --git a/README_CN.md b/README_CN.md index a9ad71f..0eef626 100644 --- a/README_CN.md +++ b/README_CN.md @@ -29,7 +29,8 @@ ### 功能亮点 -- **浏览器直接写** — 内置 Monaco 编辑器，开箱即用，不用折腾本地 IDE +- **浏览器直接写** — 内置 Monaco 编辑器，支持 `torch`、`nn`、`F`、`np`、`math` + 以及张量方法的自动补全，开箱即用，不用折腾本地 IDE - **秒级反馈** — 提交即判，逐条显示测试结果 - **参考实现** — 先自己写，再看答案 - **进度记录** — 做了多少、试了几次，关掉浏览器也不丢 diff --git a/scripts/gen_completions.py b/scripts/gen_completions.py new file mode 100644 index 0000000..8971efd --- /dev/null +++ b/scripts/gen_completions.py @@ -0,0 +1,191 @@ +#!/usr/bin/env python3 +"""Generate Monaco completion data for the Python editor. + +Monaco ships a syntax highlighter for Python but no language service, so the +editor can only suggest words that already appear in the buffer -- typing +``np.`` or ``torch.`` offers nothing. This script introspects the exact modules +the grading sandbox injects into every submission's namespace +(see ``grading_service.main._execute_tests``) and writes them to a JSON file the +editor loads lazily. + +Run it after upgrading torch/numpy: + + python scripts/gen_completions.py +""" + +from __future__ import annotations + +import inspect +import json +import math +import re +import sys +from pathlib import Path +from typing import Any + +ROOT = Path(__file__).parent.parent +OUTPUT = ROOT / "web" / "src" / "lib" / "pythonCompletions.json" + +MAX_DOC = 160 + +# Mirrors the sandbox namespace in grading_service/main.py. Keep in sync. +import numpy # noqa: E402 +import torch # noqa: E402 + +NAMESPACES: dict[str, Any] = { + "torch": torch, + "nn": torch.nn, + "F": torch.nn.functional, + "np": numpy, + "math": math, + "Tensor": torch.Tensor, +} + +# Offered at the top level, plus after an unrecognised ``name.`` we fall back to +# Tensor members -- in these problems almost every local variable is a tensor. +KEYWORDS = [ + "and", "as", "assert", "break", "class", "continue", "def", "del", "elif", + "else", "except", "False", "finally", "for", "from", "global", "if", + "import", "in", "is", "lambda", "None", "nonlocal", "not", "or", "pass", + "raise", "return", "True", "try", "while", "with", "yield", +] +BUILTINS = [ + "abs", "all", "any", "bool", "dict", "enumerate", "filter", "float", + "format", "int", "isinstance", "len", "list", "map", "max", "min", + "print", "range", "repr", "reversed", "round", "set", "slice", "sorted", + "str", "sum", "tuple", "type", "zip", +] + +_SIG_LINE = re.compile(r"^\s*\w+\((.*?)\)(\s*->\s*[^\n]+)?\s*$") + + +def _skip_signature_block(lines: list[str], name: str) -> list[str]: + """Drop the leading ``name(...)`` signature, which torch and numpy docstrings + both carry and numpy wraps across several lines.""" + out = [ln for ln in lines if ln] + while out: + first = out[0] + if _SIG_LINE.match(first) and first.startswith(f"{name}("): + out = out[1:] + continue + if first.startswith(f"{name}("): + # a multi-line signature: consume until the parentheses balance + depth = 0 + for i, ln in enumerate(out): + depth += ln.count("(") - ln.count(")") + if depth <= 0: + out = out[i + 1:] + break + else: + return [] + continue + break + return out + + +def _signature(obj: Any, name: str) -> str: + """Best-effort signature. C extensions defeat inspect, so fall back to the + first docstring line, which torch and numpy both format as a signature.""" + try: + return str(inspect.signature(obj)) + except (TypeError, ValueError): + pass + doc = inspect.getdoc(obj) or "" + for line in doc.splitlines()[:3]: + line = line.strip() + if line.startswith(f"{name}(") and _SIG_LINE.match(line): + return line[len(name):] + return "(...)" + + +def _summary(obj: Any, name: str) -> str: + doc = inspect.getdoc(obj) or "" + lines = [ln.strip() for ln in doc.splitlines()] + body = _skip_signature_block(lines, name) + if not body: + return "" + text = body[0] + if len(text) > MAX_DOC: + text = text[: MAX_DOC - 1].rstrip() + "…" + return text + + +def _value(obj: Any) -> str: + """Short repr for a constant. Never call getdoc on one: inspect walks up to + the *type*, so math.pi would document itself as float.__doc__.""" + try: + text = repr(obj) + except Exception: + return "" + text = " ".join(text.split()) + if len(text) > 60: + return "" + return text + + +def _kind(obj: Any) -> str: + if inspect.ismodule(obj): + return "module" + if inspect.isclass(obj): + return "class" + if callable(obj): + return "function" + if inspect.isdatadescriptor(obj): + # Tensor.shape and friends: a descriptor, not a value. Its own __doc__ is + # meaningful, and repr() would print "". + return "property" + return "constant" + + +def collect(module: Any) -> list[dict[str, str]]: + out: list[dict[str, str]] = [] + for name in sorted(dir(module)): + if name.startswith("_"): + continue + try: + obj = getattr(module, name) + except Exception: + continue + kind = _kind(obj) + entry: dict[str, str] = {"l": name, "k": kind} + if kind in ("function", "class", "property"): + if kind != "property": + sig = _signature(obj, name) + if sig and sig != "(...)": + entry["d"] = sig + summary = _summary(obj, name) + if summary: + entry["s"] = summary + elif kind == "constant": + value = _value(obj) + if value: + entry["d"] = value + out.append(entry) + return out + + +def main() -> None: + data = { + "_comment": "Generated by scripts/gen_completions.py -- do not edit by hand.", + "versions": { + "torch": torch.__version__, + "numpy": numpy.__version__, + "python": f"{sys.version_info.major}.{sys.version_info.minor}", + }, + "keywords": KEYWORDS, + "builtins": BUILTINS, + "namespaces": {alias: collect(mod) for alias, mod in NAMESPACES.items()}, + } + OUTPUT.parent.mkdir(parents=True, exist_ok=True) + OUTPUT.write_text(json.dumps(data, ensure_ascii=False, separators=(",", ":")) + "\n", + encoding="utf-8") + total = sum(len(v) for v in data["namespaces"].values()) + size_kb = OUTPUT.stat().st_size / 1024 + print(f"Wrote {total} completions across {len(NAMESPACES)} namespaces " + f"to {OUTPUT.relative_to(ROOT)} ({size_kb:.0f} KB)") + for alias, entries in data["namespaces"].items(): + print(f" {alias:8s} {len(entries):5d}") + + +if __name__ == "__main__": + main() diff --git a/web/src/components/workspace/CodeEditor.tsx b/web/src/components/workspace/CodeEditor.tsx index 990d44c..1c4d89a 100644 --- a/web/src/components/workspace/CodeEditor.tsx +++ b/web/src/components/workspace/CodeEditor.tsx @@ -4,6 +4,7 @@ import { useRef, useEffect } from 'react'; import dynamic from 'next/dynamic'; import type { OnMount } from '@monaco-editor/react'; import { appleLight, appleDark } from '@/lib/monacoTheme'; +import { registerPythonCompletions } from '@/lib/pythonCompletions'; import { useTheme } from '@/context/ThemeContext'; const Editor = dynamic(() => import('@monaco-editor/react').then((m) => m.default), { @@ -47,6 +48,7 @@ export function CodeEditor({ monaco.editor.defineTheme('apple-light', appleLight); monaco.editor.defineTheme('apple-dark', appleDark); monaco.editor.setTheme(theme === 'dark' ? 'apple-dark' : 'apple-light'); + void registerPythonCompletions(monaco); editor.addCommand(monaco.KeyMod.CtrlCmd | monaco.KeyCode.Enter, () => runRef.current?.()); editor.addCommand(monaco.KeyMod.CtrlCmd | monaco.KeyMod.Shift | monaco.KeyCode.Enter, () => submitRef.current?.()); }; @@ -77,6 +79,10 @@ export function CodeEditor({ cursorBlinking: 'smooth', cursorSmoothCaretAnimation: 'on', bracketPairColorization: { enabled: true }, + quickSuggestions: { other: true, comments: false, strings: false }, + suggestOnTriggerCharacters: true, + wordBasedSuggestions: 'currentDocument', + suggest: { showWords: true, localityBonus: true }, overviewRulerBorder: false, hideCursorInOverviewRuler: true, scrollbar: { diff --git a/web/src/lib/pythonCompletions.json b/web/src/lib/pythonCompletions.json new file mode 100644 index 0000000..2980728 --- /dev/null +++ b/web/src/lib/pythonCompletions.json @@ -0,0 +1 @@ +{"_comment":"Generated by scripts/gen_completions.py -- do not edit by hand.","versions":{"torch":"2.13.0+cu130","numpy":"2.4.6","python":"3.11"},"keywords":["and","as","assert","break","class","continue","def","del","elif","else","except","False","finally","for","from","global","if","import","in","is","lambda","None","nonlocal","not","or","pass","raise","return","True","try","while","with","yield"],"builtins":["abs","all","any","bool","dict","enumerate","filter","float","format","int","isinstance","len","list","map","max","min","print","range","repr","reversed","round","set","slice","sorted","str","sum","tuple","type","zip"],"namespaces":{"torch":[{"l":"AVG","k":"constant","d":""},{"l":"AcceleratorError","k":"class","s":"Exception raised while executing on device"},{"l":"AggregationType","k":"class","s":"Members:"},{"l":"AliasDb","k":"class"},{"l":"AnyType","k":"class"},{"l":"Argument","k":"class"},{"l":"ArgumentSpec","k":"class"},{"l":"AwaitType","k":"class"},{"l":"BFloat16Storage","k":"class","d":"(*args, wrap_storage=None, dtype=None, device=None, _internal=False)"},{"l":"BFloat16Tensor","k":"class"},{"l":"BenchmarkConfig","k":"class"},{"l":"BenchmarkExecutionStats","k":"class"},{"l":"Block","k":"class"},{"l":"BoolStorage","k":"class","d":"(*args, wrap_storage=None, dtype=None, device=None, _internal=False)"},{"l":"BoolTensor","k":"class"},{"l":"BoolType","k":"class"},{"l":"BufferDict","k":"class"},{"l":"ByteStorage","k":"class","d":"(*args, wrap_storage=None, dtype=None, device=None, _internal=False)"},{"l":"ByteTensor","k":"class"},{"l":"CallStack","k":"class"},{"l":"Capsule","k":"class"},{"l":"CharStorage","k":"class","d":"(*args, wrap_storage=None, dtype=None, device=None, _internal=False)"},{"l":"CharTensor","k":"class"},{"l":"ClassType","k":"class"},{"l":"Code","k":"class"},{"l":"CompilationUnit","k":"class"},{"l":"CompleteArgumentSpec","k":"class"},{"l":"ComplexDoubleStorage","k":"class","d":"(*args, wrap_storage=None, dtype=None, device=None, _internal=False)"},{"l":"ComplexFloatStorage","k":"class","d":"(*args, wrap_storage=None, dtype=None, device=None, _internal=False)"},{"l":"ComplexType","k":"class"},{"l":"ConcreteModuleType","k":"class"},{"l":"ConcreteModuleTypeBuilder","k":"class"},{"l":"DeepCopyMemoTable","k":"class"},{"l":"DeserializationStorageContext","k":"class"},{"l":"DeviceObjType","k":"class"},{"l":"DictType","k":"class"},{"l":"DisableTorchFunction","k":"class"},{"l":"DisableTorchFunctionSubclass","k":"class"},{"l":"DispatchKey","k":"class","s":"Members:"},{"l":"DispatchKeySet","k":"class"},{"l":"DoubleStorage","k":"class","d":"(*args, wrap_storage=None, dtype=None, device=None, _internal=False)"},{"l":"DoubleTensor","k":"class"},{"l":"EnumType","k":"class"},{"l":"ErrorReport","k":"class"},{"l":"Event","k":"class","d":"(device=None, *, enable_timing=False, blocking=False, interprocess=False)","s":"Query and record Stream status to identify or control dependencies across Stream and measure timing."},{"l":"ExcludeDispatchKeyGuard","k":"class"},{"l":"ExecutionPlan","k":"class"},{"l":"FatalError","k":"class","s":"Common base class for all non-exit exceptions."},{"l":"FileCheck","k":"class"},{"l":"FloatStorage","k":"class","d":"(*args, wrap_storage=None, dtype=None, device=None, _internal=False)"},{"l":"FloatTensor","k":"class"},{"l":"FloatType","k":"class"},{"l":"FunctionSchema","k":"class"},{"l":"Future","k":"class"},{"l":"FutureType","k":"class"},{"l":"Generator","k":"class"},{"l":"GradScaler","k":"class","d":"(device: 'str' = 'cuda', init_scale: 'float' = 65536.0, growth_factor: 'float' = 2.0, backoff_factor: 'float' = 0.5, growth_interval: 'int' = 2000, enabled: 'bool' = True) -> 'None'","s":"An instance ``scaler`` of :class:`GradScaler`."},{"l":"Gradient","k":"class"},{"l":"Graph","k":"class"},{"l":"GraphExecutorState","k":"class"},{"l":"HalfStorage","k":"class","d":"(*args, wrap_storage=None, dtype=None, device=None, _internal=False)"},{"l":"HalfTensor","k":"class"},{"l":"IODescriptor","k":"class"},{"l":"InferredType","k":"class"},{"l":"IntStorage","k":"class","d":"(*args, wrap_storage=None, dtype=None, device=None, _internal=False)"},{"l":"IntTensor","k":"class"},{"l":"IntType","k":"class"},{"l":"InterfaceType","k":"class"},{"l":"JITException","k":"class","s":"Common base class for all non-exit exceptions."},{"l":"ListType","k":"class"},{"l":"LiteScriptModule","k":"class"},{"l":"LockingLogger","k":"class"},{"l":"LoggerBase","k":"class"},{"l":"LongStorage","k":"class","d":"(*args, wrap_storage=None, dtype=None, device=None, _internal=False)"},{"l":"LongTensor","k":"class"},{"l":"ModuleDict","k":"class"},{"l":"Node","k":"class"},{"l":"NoneType","k":"class"},{"l":"NoopLogger","k":"class"},{"l":"NumberType","k":"class"},{"l":"OperatorInfo","k":"class"},{"l":"OptionalType","k":"class"},{"l":"OutOfMemoryError","k":"class","s":"Exception raised when device is out of memory"},{"l":"PRIVATE_OPS","k":"constant","d":"('unique_dim',)"},{"l":"ParameterDict","k":"class"},{"l":"PyObjectType","k":"class"},{"l":"PyTorchFileReader","k":"class"},{"l":"PyTorchFileWriter","k":"class"},{"l":"QInt32Storage","k":"class","d":"(*args, wrap_storage=None, dtype=None, device=None, _internal=False)"},{"l":"QInt8Storage","k":"class","d":"(*args, wrap_storage=None, dtype=None, device=None, _internal=False)"},{"l":"QUInt2x4Storage","k":"class","d":"(*args, wrap_storage=None, dtype=None, device=None, _internal=False)"},{"l":"QUInt4x2Storage","k":"class","d":"(*args, wrap_storage=None, dtype=None, device=None, _internal=False)"},{"l":"QUInt8Storage","k":"class","d":"(*args, wrap_storage=None, dtype=None, device=None, _internal=False)"},{"l":"RRefType","k":"class"},{"l":"SUM","k":"constant","d":""},{"l":"ScriptClass","k":"class"},{"l":"ScriptClassFunction","k":"class"},{"l":"ScriptDict","k":"class"},{"l":"ScriptDictIterator","k":"class"},{"l":"ScriptDictKeyIterator","k":"class"},{"l":"ScriptFunction","k":"class","s":"Functionally equivalent to a :class:`ScriptModule`, but represents a single"},{"l":"ScriptList","k":"class"},{"l":"ScriptListIterator","k":"class"},{"l":"ScriptMethod","k":"class"},{"l":"ScriptModule","k":"class"},{"l":"ScriptModuleSerializer","k":"class"},{"l":"ScriptObject","k":"class"},{"l":"ScriptObjectProperty","k":"class"},{"l":"SerializationStorageContext","k":"class"},{"l":"ShortStorage","k":"class","d":"(*args, wrap_storage=None, dtype=None, device=None, _internal=False)"},{"l":"ShortTensor","k":"class"},{"l":"Size","k":"class","d":"(iterable=(), /)","s":"Built-in immutable sequence."},{"l":"StaticModule","k":"class"},{"l":"Storage","k":"class","d":"(*args, wrap_storage=None, dtype=None, device=None, _internal=False)"},{"l":"StorageBase","k":"class"},{"l":"Stream","k":"class","d":"(device, *, priority) -> Stream","s":"An in-order queue of executing the respective tasks asynchronously in first in first out (FIFO) order."},{"l":"StreamObjType","k":"class"},{"l":"StringType","k":"class"},{"l":"SymBool","k":"class","d":"(node)","s":"Like a bool (including magic methods), but redirects all operations on the"},{"l":"SymBoolType","k":"class"},{"l":"SymFloat","k":"class","d":"(node)","s":"Like a float (including magic methods), but redirects all operations on the"},{"l":"SymInt","k":"class","d":"(node)","s":"Like an int (including magic methods), but redirects all operations on the"},{"l":"SymIntType","k":"class"},{"l":"TYPE_CHECKING","k":"constant","d":"False"},{"l":"Tag","k":"class","s":"Members:"},{"l":"Tensor","k":"class"},{"l":"TensorType","k":"class"},{"l":"ThroughputBenchmark","k":"class"},{"l":"TracingState","k":"class"},{"l":"TupleType","k":"class"},{"l":"Type","k":"class"},{"l":"TypedStorage","k":"class","d":"(*args, wrap_storage=None, dtype=None, device=None, _internal=False)"},{"l":"USE_GLOBAL_DEPS","k":"constant","d":"True"},{"l":"USE_RTLD_GLOBAL_WITH_LIBTORCH","k":"constant","d":"False"},{"l":"UnionType","k":"class"},{"l":"UntypedStorage","k":"class","d":"(*args, **kwargs)"},{"l":"Use","k":"class"},{"l":"Value","k":"class"},{"l":"abs","k":"function","d":"(input: Tensor, *, out: Optional[Tensor]) -> Tensor","s":"Computes the absolute value of each element in :attr:`input`."},{"l":"abs_","k":"function"},{"l":"absolute","k":"function","d":"(input: Tensor, *, out: Optional[Tensor]) -> Tensor","s":"Alias for :func:`torch.abs`"},{"l":"accelerator","k":"module"},{"l":"acos","k":"function","d":"(input: Tensor, *, out: Optional[Tensor]) -> Tensor","s":"Returns a new tensor with the arccosine (in radians) of each element in :attr:`input`."},{"l":"acos_","k":"function"},{"l":"acosh","k":"function","d":"(input: Tensor, *, out: Optional[Tensor]) -> Tensor","s":"Returns a new tensor with the inverse hyperbolic cosine of the elements of :attr:`input`."},{"l":"acosh_","k":"function"},{"l":"adaptive_avg_pool1d","k":"function","d":"(input, output_size) -> Tensor","s":"Applies a 1D adaptive average pooling over an input signal composed of"},{"l":"adaptive_max_pool1d","k":"function"},{"l":"add","k":"function","d":"(input, other, *, alpha=1, out=None) -> Tensor","s":"Adds :attr:`other`, scaled by :attr:`alpha`, to :attr:`input`."},{"l":"addbmm","k":"function","d":"(input, batch1, batch2, *, beta=1, alpha=1, out=None) -> Tensor","s":"Performs a batch matrix-matrix product of matrices stored"},{"l":"addcdiv","k":"function","d":"(input, tensor1, tensor2, *, value=1, out=None) -> Tensor","s":"Performs the element-wise division of :attr:`tensor1` by :attr:`tensor2`,"},{"l":"addcmul","k":"function","d":"(input, tensor1, tensor2, *, value=1, out=None) -> Tensor","s":"Performs the element-wise multiplication of :attr:`tensor1`"},{"l":"addmm","k":"function","d":"(input, mat1, mat2, *, beta=1, alpha=1, out=None) -> Tensor","s":"Performs a matrix multiplication of the matrices :attr:`mat1` and :attr:`mat2`."},{"l":"addmv","k":"function","d":"(input, mat, vec, *, beta=1, alpha=1, out=None) -> Tensor","s":"Performs a matrix-vector product of the matrix :attr:`mat` and"},{"l":"addmv_","k":"function"},{"l":"addr","k":"function","d":"(input, vec1, vec2, *, beta=1, alpha=1, out=None) -> Tensor","s":"Performs the outer-product of vectors :attr:`vec1` and :attr:`vec2`"},{"l":"adjoint","k":"function","d":"(input: Tensor) -> Tensor","s":"Returns a view of the tensor conjugated and with the last two dimensions transposed."},{"l":"affine_grid_generator","k":"function"},{"l":"alias_copy","k":"function","s":"Performs the same operation as :func:`torch.alias`, but all output tensors"},{"l":"all","k":"function","d":"(input: Tensor, *, out=None) -> Tensor","s":"Tests if all elements in :attr:`input` evaluate to `True`."},{"l":"allclose","k":"function","d":"(input: Tensor, other: Tensor, rtol: float = 1e-05, atol: float = 1e-08, equal_nan: bool = False) -> bool","s":"This function checks if :attr:`input` and :attr:`other` satisfy the condition:"},{"l":"alpha_dropout","k":"function"},{"l":"alpha_dropout_","k":"function"},{"l":"amax","k":"function","d":"(input, dim=None, keepdim=False, *, out=None) -> Tensor","s":"Returns the maximum value of each slice of the :attr:`input` tensor in the given"},{"l":"amin","k":"function","d":"(input, dim=None, keepdim=False, *, out=None) -> Tensor","s":"Returns the minimum value of each slice of the :attr:`input` tensor in the given"},{"l":"aminmax","k":"function","d":"(input, *, dim=None, keepdim=False, out=None) -> (Tensor min, Tensor max)","s":"Computes the minimum and maximum values of the :attr:`input` tensor."},{"l":"amp","k":"module"},{"l":"angle","k":"function","d":"(input: Tensor, *, out: Optional[Tensor]) -> Tensor","s":"Computes the element-wise angle (in radians) of the given :attr:`input` tensor."},{"l":"any","k":"function","d":"(input: Tensor, *, out: Optional[Tensor]) -> Tensor","s":"Tests if any element in :attr:`input` evaluates to `True`."},{"l":"ao","k":"module"},{"l":"arange","k":"function","d":"(start=0, end, step=1, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor","s":"Returns a 1-D tensor of size :math:`\\left\\lceil \\frac{\\text{end} - \\text{start}}{\\text{step}} \\right\\rceil`"},{"l":"arccos","k":"function","d":"(input: Tensor, *, out: Optional[Tensor]) -> Tensor","s":"Alias for :func:`torch.acos`."},{"l":"arccos_","k":"function"},{"l":"arccosh","k":"function","d":"(input: Tensor, *, out: Optional[Tensor]) -> Tensor","s":"Alias for :func:`torch.acosh`."},{"l":"arccosh_","k":"function"},{"l":"arcsin","k":"function","d":"(input: Tensor, *, out: Optional[Tensor]) -> Tensor","s":"Alias for :func:`torch.asin`."},{"l":"arcsin_","k":"function"},{"l":"arcsinh","k":"function","d":"(input: Tensor, *, out: Optional[Tensor]) -> Tensor","s":"Alias for :func:`torch.asinh`."},{"l":"arcsinh_","k":"function"},{"l":"arctan","k":"function","d":"(input: Tensor, *, out: Optional[Tensor]) -> Tensor","s":"Alias for :func:`torch.atan`."},{"l":"arctan2","k":"function","d":"(input: Tensor, other: Tensor, *, out: Optional[Tensor]) -> Tensor","s":"Alias for :func:`torch.atan2`."},{"l":"arctan_","k":"function"},{"l":"arctanh","k":"function","d":"(input: Tensor, *, out: Optional[Tensor]) -> Tensor","s":"Alias for :func:`torch.atanh`."},{"l":"arctanh_","k":"function"},{"l":"are_deterministic_algorithms_enabled","k":"function","d":"() -> bool","s":"Returns True if the global deterministic flag is turned on. Refer to"},{"l":"argmax","k":"function","d":"(input) -> LongTensor","s":"Returns the indices of the maximum value of all elements in the :attr:`input` tensor."},{"l":"argmin","k":"function","d":"(input, dim=None, keepdim=False) -> LongTensor","s":"Returns the indices of the minimum value(s) of the flattened tensor or along a dimension"},{"l":"argsort","k":"function","d":"(input, dim=-1, descending=False, *, stable=False) -> Tensor","s":"Returns the indices that sort a tensor along a given dimension in ascending"},{"l":"argwhere","k":"function","d":"(input) -> Tensor","s":"Returns a tensor containing the indices of all non-zero elements of"},{"l":"as_strided","k":"function","d":"(input, size, stride, storage_offset=None) -> Tensor","s":"Create a view of an existing `torch.Tensor` :attr:`input` with specified"},{"l":"as_strided_","k":"function"},{"l":"as_strided_copy","k":"function","s":"Performs the same operation as :func:`torch.as_strided`, but all output tensors"},{"l":"as_strided_scatter","k":"function","d":"(input, src, size, stride, storage_offset=None) -> Tensor","s":"Embeds the values of the :attr:`src` tensor into :attr:`input` along"},{"l":"as_tensor","k":"function","d":"(data: Any, *, dtype: Optional[dtype] = None, device: Optional[DeviceLikeType]) -> Tensor","s":"Converts :attr:`data` into a tensor, sharing data and preserving autograd"},{"l":"asarray","k":"function","d":"(obj: Any, *, dtype: Optional[dtype], device: Optional[DeviceLikeType], copy: Optional[bool] = None, requires_grad: Optional[bool] = None) -> Tensor # noqa: B950","s":"Converts :attr:`obj` to a tensor."},{"l":"asin","k":"function","d":"(input: Tensor, *, out: Optional[Tensor]) -> Tensor","s":"Returns a new tensor with the arcsine of the elements (in radians) in the :attr:`input` tensor."},{"l":"asin_","k":"function"},{"l":"asinh","k":"function","d":"(input: Tensor, *, out: Optional[Tensor]) -> Tensor","s":"Returns a new tensor with the inverse hyperbolic sine of the elements of :attr:`input`."},{"l":"asinh_","k":"function"},{"l":"atan","k":"function","d":"(input: Tensor, *, out: Optional[Tensor]) -> Tensor","s":"Returns a new tensor with the arctangent of the elements (in radians) in the :attr:`input` tensor."},{"l":"atan2","k":"function","d":"(input: Tensor, other: Tensor, *, out: Optional[Tensor]) -> Tensor","s":"Element-wise arctangent of :math:`\\text{input}_{i} / \\text{other}_{i}`"},{"l":"atan_","k":"function"},{"l":"atanh","k":"function","d":"(input: Tensor, *, out: Optional[Tensor]) -> Tensor","s":"Returns a new tensor with the inverse hyperbolic tangent of the elements of :attr:`input`."},{"l":"atanh_","k":"function"},{"l":"atleast_1d","k":"function","d":"(*tensors)","s":"Returns a 1-dimensional view of each input tensor with zero dimensions."},{"l":"atleast_2d","k":"function","d":"(*tensors)","s":"Returns a 2-dimensional view of each input tensor with zero dimensions."},{"l":"atleast_3d","k":"function","d":"(*tensors)","s":"Returns a 3-dimensional view of each input tensor with zero dimensions."},{"l":"autocast","k":"class","d":"(device_type: str, dtype: torch.dtype | None = None, enabled: bool = True, cache_enabled: bool | None = None)","s":"Instances of :class:`autocast` serve as context managers or decorators that"},{"l":"autocast_decrement_nesting","k":"function"},{"l":"autocast_increment_nesting","k":"function"},{"l":"autograd","k":"module"},{"l":"avg_pool1d","k":"function","d":"(input, kernel_size, stride=None, padding=0, ceil_mode=False, count_include_pad=True) -> Tensor","s":"Applies a 1D average pooling over an input signal composed of several"},{"l":"backends","k":"module"},{"l":"baddbmm","k":"function","d":"(input, batch1, batch2, *, beta=1, alpha=1, out=None) -> Tensor","s":"Performs a batch matrix-matrix product of matrices in :attr:`batch1`"},{"l":"bartlett_window","k":"function","d":"(window_length, periodic=True, *, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor","s":"Bartlett window function."},{"l":"batch_norm","k":"function"},{"l":"batch_norm_backward_elemt","k":"function"},{"l":"batch_norm_backward_reduce","k":"function"},{"l":"batch_norm_elemt","k":"function"},{"l":"batch_norm_gather_stats","k":"function"},{"l":"batch_norm_gather_stats_with_counts","k":"function"},{"l":"batch_norm_stats","k":"function"},{"l":"batch_norm_update_stats","k":"function"},{"l":"bernoulli","k":"function","d":"(input: Tensor, *, generator: Optional[Generator], out: Optional[Tensor]) -> Tensor","s":"Draws binary random numbers (0 or 1) from a Bernoulli distribution."},{"l":"bfloat16","k":"constant","d":"torch.bfloat16"},{"l":"bilinear","k":"function","d":"(input1, input2, weight, bias=None) -> Tensor","s":"Applies a bilinear transformation to the incoming data:"},{"l":"binary_cross_entropy_with_logits","k":"function"},{"l":"bincount","k":"function","d":"(input, weights=None, minlength=0) -> Tensor","s":"Count the frequency of each value in an array of non-negative ints."},{"l":"binomial","k":"function"},{"l":"bit","k":"constant","d":"torch.uint1"},{"l":"bits16","k":"constant","d":"torch.bits16"},{"l":"bits1x8","k":"constant","d":"torch.bits1x8"},{"l":"bits2x4","k":"constant","d":"torch.bits2x4"},{"l":"bits4x2","k":"constant","d":"torch.bits4x2"},{"l":"bits8","k":"constant","d":"torch.bits8"},{"l":"bitwise_and","k":"function","d":"(input, other, *, out=None) -> Tensor","s":"Computes the bitwise AND of :attr:`input` and :attr:`other`. The input tensor must be of"},{"l":"bitwise_left_shift","k":"function","d":"(input, other, *, out=None) -> Tensor","s":"Computes the left arithmetic shift of :attr:`input` by :attr:`other` bits."},{"l":"bitwise_not","k":"function","d":"(input, *, out=None) -> Tensor","s":"Computes the bitwise NOT of the given input tensor. The input tensor must be of"},{"l":"bitwise_or","k":"function","d":"(input: Tensor, other: Tensor, *, out: Optional[Tensor]) -> Tensor","s":"Computes the bitwise OR of :attr:`input` and :attr:`other`. The input tensor must be of"},{"l":"bitwise_right_shift","k":"function","d":"(input, other, *, out=None) -> Tensor","s":"Computes the right arithmetic shift of :attr:`input` by :attr:`other` bits."},{"l":"bitwise_xor","k":"function","d":"(input, other, *, out=None) -> Tensor","s":"Computes the bitwise XOR of :attr:`input` and :attr:`other`. The input tensor must be of"},{"l":"blackman_window","k":"function","d":"(window_length, periodic=True, *, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor","s":"Blackman window function."},{"l":"block_diag","k":"function","d":"(*tensors)","s":"Create a block diagonal matrix from provided tensors."},{"l":"bmm","k":"function","d":"(input, mat2, *, out=None) -> Tensor","s":"Performs a batch matrix-matrix product of matrices stored in :attr:`input`"},{"l":"bool","k":"constant","d":"torch.bool"},{"l":"broadcast_shapes","k":"function","d":"(*shapes)","s":"Similar to :func:`broadcast_tensors` but for shapes."},{"l":"broadcast_tensors","k":"function","d":"(*tensors)","s":"Broadcasts the given tensors according to :ref:`broadcasting-semantics`."},{"l":"broadcast_to","k":"function","d":"(input, shape) -> Tensor","s":"Broadcasts :attr:`input` to the shape :attr:`\\shape`."},{"l":"bucketize","k":"function","d":"(input, boundaries, *, out_int32=False, right=False, out=None) -> Tensor","s":"Returns the indices of the buckets to which each value in the :attr:`input` belongs, where the"},{"l":"builtins","k":"module"},{"l":"can_cast","k":"function","d":"(from_, to) -> bool","s":"Determines if a type conversion is allowed under PyTorch casting rules"},{"l":"cartesian_prod","k":"function","d":"(*tensors: torch.Tensor) -> torch.Tensor","s":"Do cartesian product of the given sequence of tensors. The behavior is similar to"},{"l":"cat","k":"function","d":"(tensors, dim=0, *, out=None) -> Tensor","s":"Concatenates the given sequence of tensors in :attr:`tensors` in the given dimension."},{"l":"ccol_indices_copy","k":"function"},{"l":"cdist","k":"function","d":"(x1, x2, p=2.0, compute_mode='use_mm_for_euclid_dist_if_necessary')","s":"Computes batched the p-norm distance between each pair of the two collections of row vectors."},{"l":"cdouble","k":"constant","d":"torch.complex128"},{"l":"ceil","k":"function","d":"(input, *, out=None) -> Tensor","s":"Returns a new tensor with the ceil of the elements of :attr:`input`,"},{"l":"ceil_","k":"function"},{"l":"celu","k":"function"},{"l":"celu_","k":"function","d":"(input, alpha=1.) -> Tensor","s":"In-place version of :func:`~celu`."},{"l":"cfloat","k":"constant","d":"torch.complex64"},{"l":"chain_matmul","k":"function","d":"(*matrices, out=None)","s":"Returns the matrix product of the :math:`N` 2-D tensors. This product is efficiently computed"},{"l":"chalf","k":"constant","d":"torch.complex32"},{"l":"channel_shuffle","k":"function","d":"(input, groups) -> Tensor","s":"Divide the channels in a tensor of shape :math:`(*, C , H, W)`"},{"l":"channels_last","k":"constant","d":"torch.channels_last"},{"l":"channels_last_3d","k":"constant","d":"torch.channels_last_3d"},{"l":"cholesky","k":"function","d":"(input, upper=False, *, out=None) -> Tensor","s":"Computes the Cholesky decomposition of a symmetric positive-definite"},{"l":"cholesky_inverse","k":"function","d":"(L, upper=False, *, out=None) -> Tensor","s":"Computes the inverse of a complex Hermitian or real symmetric"},{"l":"cholesky_solve","k":"function","d":"(B, L, upper=False, *, out=None) -> Tensor","s":"Computes the solution of a system of linear equations with complex Hermitian"},{"l":"choose_qparams_optimized","k":"function"},{"l":"chunk","k":"function","d":"(input: Tensor, chunks: int, dim: int = 0) -> Tuple[Tensor, ...]","s":"Attempts to split a tensor into the specified number of chunks. Each chunk is a view of"},{"l":"clamp","k":"function","d":"(input, min=None, max=None, *, out=None) -> Tensor","s":"Clamps all elements in :attr:`input` into the range `[` :attr:`min`, :attr:`max` `]`."},{"l":"clamp_","k":"function"},{"l":"clamp_max","k":"function"},{"l":"clamp_max_","k":"function"},{"l":"clamp_min","k":"function"},{"l":"clamp_min_","k":"function"},{"l":"classes","k":"module"},{"l":"classproperty","k":"function","d":"(func)"},{"l":"clear_autocast_cache","k":"function"},{"l":"clip","k":"function","d":"(input, min=None, max=None, *, out=None) -> Tensor","s":"Alias for :func:`torch.clamp`."},{"l":"clip_","k":"function"},{"l":"clone","k":"function","d":"(input, *, memory_format=torch.preserve_format) -> Tensor","s":"Returns a copy of :attr:`input`."},{"l":"col_indices_copy","k":"function","s":"Performs the same operation as :func:`torch.col_indices`, but all output tensors"},{"l":"column_stack","k":"function","d":"(tensors, *, out=None) -> Tensor","s":"Creates a new tensor by horizontally stacking the tensors in :attr:`tensors`."},{"l":"combinations","k":"function","d":"(input: Tensor, r: int = 2, with_replacement: bool = False) -> seq","s":"Compute combinations of length :math:`r` of the given tensor. The behavior is similar to"},{"l":"compile","k":"function","d":"(model: collections.abc.Callable[~_InputT, ~_RetT] | None = None, *, fullgraph: bool = False, dynamic: bool | None = None, backend: str | collections.abc.Callable | None = None, mode: str | None = None, options: dict[str, str | int | bool | collections.abc.Callable] | None = None, name: str | None = None, disable: bool = False, recompile_limit: int | None = None, isolate_recompiles: bool = False, shapes_spec: Any = None) -> collections.abc.Callable[[collections.abc.Callable[~_InputT, ~_RetT]], collections.abc.Callable[~_InputT, ~_RetT]] | collections.abc.Callable[~_InputT, ~_RetT]","s":"Optimizes given model/function using TorchDynamo and specified backend."},{"l":"compiled_with_cxx11_abi","k":"function","d":"() -> bool","s":"Returns whether PyTorch was built with _GLIBCXX_USE_CXX11_ABI=1"},{"l":"compiler","k":"module"},{"l":"complex","k":"function","d":"(real, imag, *, out=None) -> Tensor","s":"Constructs a complex tensor with its real part equal to :attr:`real` and its"},{"l":"complex128","k":"constant","d":"torch.complex128"},{"l":"complex32","k":"constant","d":"torch.complex32"},{"l":"complex64","k":"constant","d":"torch.complex64"},{"l":"concat","k":"function","d":"(tensors, dim=0, *, out=None) -> Tensor","s":"Alias of :func:`torch.cat`."},{"l":"concatenate","k":"function","d":"(tensors, axis=0, out=None) -> Tensor","s":"Alias of :func:`torch.cat`."},{"l":"cond","k":"function","d":"(pred: bool | int | float | torch.Tensor, true_fn: collections.abc.Callable, false_fn: collections.abc.Callable, operands: tuple | list = ()) -> Any","s":"Conditionally applies `true_fn` or `false_fn`."},{"l":"conj","k":"function","d":"(input) -> Tensor","s":"Returns a view of :attr:`input` with a flipped conjugate bit. If :attr:`input` has a non-complex dtype,"},{"l":"conj_physical","k":"function","d":"(input, *, out=None) -> Tensor","s":"Computes the element-wise conjugate of the given :attr:`input` tensor."},{"l":"conj_physical_","k":"function"},{"l":"constant_pad_nd","k":"function"},{"l":"contiguous_format","k":"constant","d":"torch.contiguous_format"},{"l":"conv1d","k":"function","d":"(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1) -> Tensor","s":"Applies a 1D convolution over an input signal composed of several input"},{"l":"conv2d","k":"function","d":"(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1) -> Tensor","s":"Applies a 2D convolution over an input image composed of several input"},{"l":"conv3d","k":"function","d":"(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1) -> Tensor","s":"Applies a 3D convolution over an input image composed of several input"},{"l":"conv_tbc","k":"function","s":"Applies a 1-dimensional sequence convolution over an input sequence."},{"l":"conv_transpose1d","k":"function","d":"(input, weight, bias=None, stride=1, padding=0, output_padding=0, groups=1, dilation=1) -> Tensor","s":"Applies a 1D transposed convolution operator over an input signal"},{"l":"conv_transpose2d","k":"function","d":"(input, weight, bias=None, stride=1, padding=0, output_padding=0, groups=1, dilation=1) -> Tensor","s":"Applies a 2D transposed convolution operator over an input image"},{"l":"conv_transpose3d","k":"function","d":"(input, weight, bias=None, stride=1, padding=0, output_padding=0, groups=1, dilation=1) -> Tensor","s":"Applies a 3D transposed convolution operator over an input image"},{"l":"convolution","k":"function"},{"l":"copysign","k":"function","d":"(input, other, *, out=None) -> Tensor","s":"Create a new floating-point tensor with the magnitude of :attr:`input` and the sign of :attr:`other`, elementwise."},{"l":"corrcoef","k":"function","d":"(input) -> Tensor","s":"Estimates the Pearson product-moment correlation coefficient matrix of the variables given by the :attr:`input` matrix,"},{"l":"cos","k":"function","d":"(input, *, out=None) -> Tensor","s":"Returns a new tensor with the cosine of the elements of :attr:`input` given in radians."},{"l":"cos_","k":"function"},{"l":"cosh","k":"function","d":"(input, *, out=None) -> Tensor","s":"Returns a new tensor with the hyperbolic cosine of the elements of"},{"l":"cosh_","k":"function"},{"l":"cosine_embedding_loss","k":"function"},{"l":"cosine_similarity","k":"function","d":"(x1, x2, dim=1, eps=1e-8) -> Tensor","s":"Returns cosine similarity between ``x1`` and ``x2``, computed along dim. ``x1`` and ``x2`` must be broadcastable"},{"l":"count_nonzero","k":"function","d":"(input, dim=None) -> Tensor","s":"Counts the number of non-zero values in the tensor :attr:`input` along the given :attr:`dim`."},{"l":"cov","k":"function","d":"(input, *, correction=1, fweights=None, aweights=None) -> Tensor","s":"Estimates the covariance matrix of the variables given by the :attr:`input` matrix, where rows are"},{"l":"cpp","k":"module"},{"l":"cpu","k":"module"},{"l":"cross","k":"function","d":"(input, other, dim=None, *, out=None) -> Tensor","s":"Returns the cross product of vectors in dimension :attr:`dim` of :attr:`input`"},{"l":"crow_indices_copy","k":"function","s":"Performs the same operation as :func:`torch.crow_indices`, but all output tensors"},{"l":"ctc_loss","k":"function"},{"l":"ctypes","k":"module"},{"l":"cuda","k":"module"},{"l":"cudnn_affine_grid_generator","k":"function"},{"l":"cudnn_batch_norm","k":"function"},{"l":"cudnn_convolution","k":"function"},{"l":"cudnn_convolution_add_relu","k":"function"},{"l":"cudnn_convolution_relu","k":"function"},{"l":"cudnn_convolution_transpose","k":"function"},{"l":"cudnn_grid_sampler","k":"function"},{"l":"cudnn_is_acceptable","k":"function"},{"l":"cummax","k":"function","d":"(input, dim, *, out=None) -> (Tensor, LongTensor)","s":"Returns a namedtuple ``(values, indices)`` where ``values`` is the cumulative maximum of"},{"l":"cummin","k":"function","d":"(input, dim, *, out=None) -> (Tensor, LongTensor)","s":"Returns a namedtuple ``(values, indices)`` where ``values`` is the cumulative minimum of"},{"l":"cumprod","k":"function","d":"(input, dim, *, dtype=None, out=None) -> Tensor","s":"Returns the cumulative product of elements of :attr:`input` in the dimension"},{"l":"cumsum","k":"function","d":"(input, dim, *, dtype=None, out=None) -> Tensor","s":"Returns the cumulative sum of elements of :attr:`input` in the dimension"},{"l":"cumulative_trapezoid","k":"function","d":"(y, x=None, *, dx=None, dim=-1) -> Tensor","s":"Cumulatively computes the `trapezoidal rule `_"},{"l":"default_generator","k":"constant","d":""},{"l":"deg2rad","k":"function","d":"(input, *, out=None) -> Tensor","s":"Returns a new tensor with each of the elements of :attr:`input`"},{"l":"deg2rad_","k":"function"},{"l":"dequantize","k":"function","d":"(tensor) -> Tensor","s":"Returns an fp32 Tensor by dequantizing a quantized Tensor"},{"l":"det","k":"function","d":"(input) -> Tensor","s":"Alias for :func:`torch.linalg.det`"},{"l":"detach","k":"function"},{"l":"detach_","k":"function"},{"l":"detach_copy","k":"function","s":"Performs the same operation as :func:`torch.detach`, but all output tensors"},{"l":"device","k":"class"},{"l":"diag","k":"function","d":"(input, diagonal=0, *, out=None) -> Tensor","s":"- If :attr:`input` is a vector (1-D tensor), then returns a 2-D square tensor"},{"l":"diag_embed","k":"function","d":"(input, offset=0, dim1=-2, dim2=-1) -> Tensor","s":"Creates a tensor whose diagonals of certain 2D planes (specified by"},{"l":"diagflat","k":"function","d":"(input, offset=0) -> Tensor","s":"- If :attr:`input` is a vector (1-D tensor), then returns a 2-D square tensor"},{"l":"diagonal","k":"function","d":"(input, offset=0, dim1=0, dim2=1) -> Tensor","s":"Returns a partial view of :attr:`input` with the its diagonal elements"},{"l":"diagonal_copy","k":"function","s":"Performs the same operation as :func:`torch.diagonal`, but all output tensors"},{"l":"diagonal_scatter","k":"function","d":"(input, src, offset=0, dim1=0, dim2=1) -> Tensor","s":"Embeds the values of the :attr:`src` tensor into :attr:`input` along"},{"l":"diff","k":"function","d":"(input, n=1, dim=-1, prepend=None, append=None) -> Tensor","s":"Computes the n-th forward difference along the given dimension."},{"l":"digamma","k":"function","d":"(input, *, out=None) -> Tensor","s":"Alias for :func:`torch.special.digamma`."},{"l":"dist","k":"function","d":"(input, other, p=2) -> Tensor","s":"Returns the p-norm of (:attr:`input` - :attr:`other`)"},{"l":"distributed","k":"module"},{"l":"distributions","k":"module"},{"l":"div","k":"function","d":"(input, other, *, rounding_mode=None, out=None) -> Tensor","s":"Divides each element of the input ``input`` by the corresponding element of"},{"l":"divide","k":"function","d":"(input, other, *, rounding_mode=None, out=None) -> Tensor","s":"Alias for :func:`torch.div`."},{"l":"dot","k":"function","d":"(input, tensor, *, out=None) -> Tensor","s":"Computes the dot product of two 1D tensors."},{"l":"double","k":"constant","d":"torch.float64"},{"l":"dropout","k":"function"},{"l":"dropout_","k":"function"},{"l":"dsmm","k":"function"},{"l":"dsplit","k":"function","d":"(input, indices_or_sections) -> List of Tensors","s":"Splits :attr:`input`, a tensor with three or more dimensions, into multiple tensors"},{"l":"dstack","k":"function","d":"(tensors, *, out=None) -> Tensor","s":"Stack tensors in sequence depthwise (along third axis)."},{"l":"dtype","k":"class","d":"()"},{"l":"e","k":"constant","d":"2.718281828459045"},{"l":"eig","k":"function","d":"(self: torch.Tensor, eigenvectors: bool = False, *, e=None, v=None) -> tuple[torch.Tensor, torch.Tensor]"},{"l":"einsum","k":"function","d":"(*args: Any) -> torch.Tensor","s":"Sums the product of the elements of the input :attr:`operands` along dimensions specified using a notation"},{"l":"embedding","k":"function"},{"l":"embedding_bag","k":"function"},{"l":"embedding_renorm_","k":"function"},{"l":"empty","k":"function","d":"(*size, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False, pin_memory=False, memory_format=torch.contiguous_format) -> Tensor","s":"Returns a tensor filled with uninitialized data. The shape of the tensor is"},{"l":"empty_like","k":"function","d":"(input, *, dtype=None, layout=None, device=None, requires_grad=False, memory_format=torch.preserve_format) -> Tensor","s":"Returns an uninitialized tensor with the same size as :attr:`input`."},{"l":"empty_permuted","k":"function","d":"(size, physical_layout, *, dtype=None, layout=None, device=None, requires_grad=False, pin_memory=False) -> Tensor","s":"Creates an uninitialized, non-overlapping and dense tensor with the"},{"l":"empty_quantized","k":"function"},{"l":"empty_strided","k":"function","d":"(size, stride, *, dtype=None, layout=None, device=None, requires_grad=False, pin_memory=False) -> Tensor","s":"Creates a tensor with the specified :attr:`size` and :attr:`stride` and filled with undefined data."},{"l":"enable_grad","k":"class","d":"(orig_func: Optional[~F] = None) -> Union[Self, ~F]","s":"Context-manager that enables gradient calculation."},{"l":"eq","k":"function","d":"(input, other, *, out=None) -> Tensor","s":"Computes element-wise equality"},{"l":"equal","k":"function","d":"(input, other) -> bool","s":"``True`` if two tensors have the same size and elements, ``False`` otherwise."},{"l":"erf","k":"function","d":"(input, *, out=None) -> Tensor","s":"Alias for :func:`torch.special.erf`."},{"l":"erf_","k":"function"},{"l":"erfc","k":"function","d":"(input, *, out=None) -> Tensor","s":"Alias for :func:`torch.special.erfc`."},{"l":"erfc_","k":"function"},{"l":"erfinv","k":"function","d":"(input, *, out=None) -> Tensor","s":"Alias for :func:`torch.special.erfinv`."},{"l":"exp","k":"function","d":"(input, *, out=None) -> Tensor","s":"Returns a new tensor with the exponential of the elements"},{"l":"exp2","k":"function","d":"(input, *, out=None) -> Tensor","s":"Alias for :func:`torch.special.exp2`."},{"l":"exp2_","k":"function"},{"l":"exp_","k":"function"},{"l":"expand_copy","k":"function","s":"Performs the same operation as :func:`torch.Tensor.expand`, but all output tensors"},{"l":"expm1","k":"function","d":"(input, *, out=None) -> Tensor","s":"Alias for :func:`torch.special.expm1`."},{"l":"expm1_","k":"function"},{"l":"export","k":"module"},{"l":"eye","k":"function","d":"(n, m=None, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor","s":"Returns a 2-D tensor with ones on the diagonal and zeros elsewhere."},{"l":"fake_quantize_per_channel_affine","k":"function","d":"(input, scale, zero_point, axis, quant_min, quant_max) -> Tensor","s":"Returns a new tensor with the data in :attr:`input` fake quantized per channel using :attr:`scale`,"},{"l":"fake_quantize_per_tensor_affine","k":"function","d":"(input, scale, zero_point, quant_min, quant_max) -> Tensor","s":"Returns a new tensor with the data in :attr:`input` fake quantized using :attr:`scale`,"},{"l":"fbgemm_linear_fp16_weight","k":"function"},{"l":"fbgemm_linear_fp16_weight_fp32_activation","k":"function"},{"l":"fbgemm_linear_int8_weight","k":"function"},{"l":"fbgemm_linear_int8_weight_fp32_activation","k":"function"},{"l":"fbgemm_linear_quantize_weight","k":"function"},{"l":"fbgemm_pack_gemm_matrix_fp16","k":"function"},{"l":"fbgemm_pack_quantized_matrix","k":"function"},{"l":"feature_alpha_dropout","k":"function"},{"l":"feature_alpha_dropout_","k":"function"},{"l":"feature_dropout","k":"function"},{"l":"feature_dropout_","k":"function"},{"l":"fft","k":"module"},{"l":"fill","k":"function"},{"l":"fill_","k":"function"},{"l":"finfo","k":"class"},{"l":"fix","k":"function","d":"(input, *, out=None) -> Tensor","s":"Alias for :func:`torch.trunc`"},{"l":"fix_","k":"function"},{"l":"flatten","k":"function","d":"(input, start_dim=0, end_dim=-1) -> Tensor","s":"Flattens :attr:`input` by reshaping it into a one-dimensional tensor. If :attr:`start_dim` or :attr:`end_dim`"},{"l":"flip","k":"function","d":"(input, dims) -> Tensor","s":"Reverse the order of an n-D tensor along given axis in dims."},{"l":"fliplr","k":"function","d":"(input) -> Tensor","s":"Flip tensor in the left/right direction, returning a new tensor."},{"l":"flipud","k":"function","d":"(input) -> Tensor","s":"Flip tensor in the up/down direction, returning a new tensor."},{"l":"float","k":"constant","d":"torch.float32"},{"l":"float16","k":"constant","d":"torch.float16"},{"l":"float32","k":"constant","d":"torch.float32"},{"l":"float4_e2m1fn_x2","k":"constant","d":"torch.float4_e2m1fn_x2"},{"l":"float64","k":"constant","d":"torch.float64"},{"l":"float8_e4m3fn","k":"constant","d":"torch.float8_e4m3fn"},{"l":"float8_e4m3fnuz","k":"constant","d":"torch.float8_e4m3fnuz"},{"l":"float8_e5m2","k":"constant","d":"torch.float8_e5m2"},{"l":"float8_e5m2fnuz","k":"constant","d":"torch.float8_e5m2fnuz"},{"l":"float8_e8m0fnu","k":"constant","d":"torch.float8_e8m0fnu"},{"l":"float_power","k":"function","d":"(input, exponent, *, out=None) -> Tensor","s":"Raises :attr:`input` to the power of :attr:`exponent`, elementwise, in double precision."},{"l":"floor","k":"function","d":"(input, *, out=None) -> Tensor","s":"Returns a new tensor with the floor of the elements of :attr:`input`,"},{"l":"floor_","k":"function"},{"l":"floor_divide","k":"function","d":"(input, other, *, out=None) -> Tensor","s":".. note::"},{"l":"fmax","k":"function","d":"(input, other, *, out=None) -> Tensor","s":"Computes the element-wise maximum of :attr:`input` and :attr:`other`."},{"l":"fmin","k":"function","d":"(input, other, *, out=None) -> Tensor","s":"Computes the element-wise minimum of :attr:`input` and :attr:`other`."},{"l":"fmod","k":"function","d":"(input, other, *, out=None) -> Tensor","s":"Applies C++'s `std::fmod `_ entrywise."},{"l":"fork","k":"function","d":"(*args, **kwargs) -> torch._C.Future"},{"l":"frac","k":"function","d":"(input, *, out=None) -> Tensor","s":"Computes the fractional portion of each element in :attr:`input`."},{"l":"frac_","k":"function"},{"l":"frexp","k":"function","d":"(input, *, out=None) -> (Tensor mantissa, Tensor exponent)","s":"Decomposes :attr:`input` into mantissa and exponent tensors"},{"l":"frobenius_norm","k":"function"},{"l":"from_dlpack","k":"function","d":"(ext_tensor: Any, *, device: torch.device | str | int | None = None, copy: bool | None = None) -> 'torch.Tensor'","s":"Converts a tensor from an external library into a ``torch.Tensor``."},{"l":"from_file","k":"function","d":"(filename, shared=None, size=0, *, dtype=None, layout=None, device=None, pin_memory=False)","s":"Creates a CPU tensor with a storage backed by a memory-mapped file."},{"l":"from_numpy","k":"function","d":"(ndarray) -> Tensor","s":"Creates a :class:`Tensor` from a :class:`numpy.ndarray`."},{"l":"frombuffer","k":"function","d":"(buffer, *, dtype, count=-1, offset=0, requires_grad=False) -> Tensor","s":"Creates a 1-dimensional :class:`Tensor` from an object that implements"},{"l":"full","k":"function","d":"(size, fill_value, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor","s":"Creates a tensor of size :attr:`size` filled with :attr:`fill_value`. The"},{"l":"full_like","k":"function","d":"(input, fill_value, \\*, dtype=None, layout=torch.strided, device=None, requires_grad=False, memory_format=torch.preserve_format) -> Tensor","s":"Returns a tensor with the same size as :attr:`input` filled with :attr:`fill_value`."},{"l":"func","k":"module"},{"l":"functional","k":"module"},{"l":"functools","k":"module"},{"l":"fused_moving_avg_obs_fake_quant","k":"function"},{"l":"futures","k":"module"},{"l":"fx","k":"module"},{"l":"gather","k":"function","d":"(input, dim, index, *, sparse_grad=False, out=None) -> Tensor","s":"Gathers values along an axis specified by `dim`."},{"l":"gcd","k":"function","d":"(input, other, *, out=None) -> Tensor","s":"Computes the element-wise greatest common divisor (GCD) of :attr:`input` and :attr:`other`."},{"l":"gcd_","k":"function"},{"l":"ge","k":"function","d":"(input, other, *, out=None) -> Tensor","s":"Computes :math:`\\text{input} \\geq \\text{other}` element-wise."},{"l":"geqrf","k":"function","d":"(input, *, out=None) -> (Tensor, Tensor)","s":"This is a low-level function for calling LAPACK's geqrf directly. This function"},{"l":"ger","k":"function","d":"(input, vec2, *, out=None) -> Tensor","s":"Alias of :func:`torch.outer`."},{"l":"get_autocast_cpu_dtype","k":"function"},{"l":"get_autocast_dtype","k":"function"},{"l":"get_autocast_gpu_dtype","k":"function"},{"l":"get_autocast_ipu_dtype","k":"function"},{"l":"get_autocast_xla_dtype","k":"function"},{"l":"get_default_device","k":"function","d":"() -> 'torch.device'","s":"Gets the default ``torch.Tensor`` to be allocated on ``device``"},{"l":"get_default_dtype","k":"function","d":"() -> torch.dtype","s":"Get the current default floating point :class:`torch.dtype`."},{"l":"get_deterministic_debug_mode","k":"function","d":"() -> int","s":"Returns the current value of the debug mode for deterministic"},{"l":"get_device","k":"function"},{"l":"get_device_module","k":"function","d":"(device: torch.device | str | None = None)","s":"Returns the module associated with a given device(e.g., torch.device('cuda'), \"mtia:0\", \"xpu\", ...)."},{"l":"get_file_path","k":"function","d":"(*path_components: str) -> str"},{"l":"get_float32_matmul_precision","k":"function","d":"() -> str","s":"Returns the current value of float32 matrix multiplication precision. Refer to"},{"l":"get_num_interop_threads","k":"function","d":"() -> int","s":"Returns the number of threads used for inter-op parallelism on CPU"},{"l":"get_num_threads","k":"function","d":"() -> int","s":"Returns the number of threads used for parallelizing CPU operations"},{"l":"get_rng_state","k":"function","d":"() -> torch.Tensor","s":"Returns the random number generator state as a `torch.ByteTensor`."},{"l":"glob","k":"module"},{"l":"gradient","k":"function","d":"(input, *, spacing=1, dim=None, edge_order=1) -> List of Tensors","s":"Estimates the gradient of a function :math:`g : \\mathbb{R}^n \\rightarrow \\mathbb{R}` in"},{"l":"greater","k":"function","d":"(input, other, *, out=None) -> Tensor","s":"Alias for :func:`torch.gt`."},{"l":"greater_equal","k":"function","d":"(input, other, *, out=None) -> Tensor","s":"Alias for :func:`torch.ge`."},{"l":"grid_sampler","k":"function"},{"l":"grid_sampler_2d","k":"function"},{"l":"grid_sampler_3d","k":"function"},{"l":"group_norm","k":"function"},{"l":"gru","k":"function"},{"l":"gru_cell","k":"function"},{"l":"gt","k":"function","d":"(input, other, *, out=None) -> Tensor","s":"Computes :math:`\\text{input} > \\text{other}` element-wise."},{"l":"half","k":"constant","d":"torch.float16"},{"l":"hamming_window","k":"function","d":"(window_length, *, dtype=None, layout=None, device=None, pin_memory=False, requires_grad=False) -> Tensor","s":"Hamming window function."},{"l":"hann_window","k":"function","d":"(window_length, periodic=True, *, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor","s":"Hann window function."},{"l":"hardshrink","k":"function","d":"(input, lambd=0.5) -> Tensor","s":"Applies the hard shrinkage function element-wise"},{"l":"has_lapack","k":"constant","d":"True"},{"l":"has_mkl","k":"constant","d":"True"},{"l":"has_openmp","k":"constant","d":"True"},{"l":"has_spectral","k":"constant","d":"True"},{"l":"hash_tensor","k":"function","d":"(input, *, mode=0) -> Tensor","s":"Returns a hash of all elements in the :attr:`input` tensor."},{"l":"heaviside","k":"function","d":"(input, values, *, out=None) -> Tensor","s":"Computes the Heaviside step function for each element in :attr:`input`."},{"l":"hinge_embedding_loss","k":"function"},{"l":"histc","k":"function","d":"(input, bins=100, min=0, max=0, *, out=None) -> Tensor","s":"Computes the histogram of a tensor."},{"l":"histogram","k":"function","d":"(input, bins, *, range=None, weight=None, density=False, out=None) -> (Tensor, Tensor)","s":"Computes a histogram of the values in a tensor."},{"l":"histogramdd","k":"function","d":"(input, bins, *, range=None, weight=None, density=False, out=None) -> (Tensor, Tensor[])","s":"Computes a multi-dimensional histogram of the values in a tensor."},{"l":"hsmm","k":"function"},{"l":"hsplit","k":"function","d":"(input, indices_or_sections) -> List of Tensors","s":"Splits :attr:`input`, a tensor with one or more dimensions, into multiple tensors"},{"l":"hspmm","k":"function","d":"(mat1, mat2, *, out=None) -> Tensor","s":"Performs a matrix multiplication of a :ref:`sparse COO matrix"},{"l":"hstack","k":"function","d":"(tensors, *, out=None) -> Tensor","s":"Stack tensors in sequence horizontally (column wise)."},{"l":"hub","k":"module"},{"l":"hypot","k":"function","d":"(input, other, *, out=None) -> Tensor","s":"Given the legs of a right triangle, return its hypotenuse."},{"l":"i0","k":"function","d":"(input, *, out=None) -> Tensor","s":"Alias for :func:`torch.special.i0`."},{"l":"i0_","k":"function"},{"l":"igamma","k":"function","d":"(input, other, *, out=None) -> Tensor","s":"Alias for :func:`torch.special.gammainc`."},{"l":"igammac","k":"function","d":"(input, other, *, out=None) -> Tensor","s":"Alias for :func:`torch.special.gammaincc`."},{"l":"iinfo","k":"class"},{"l":"imag","k":"function","d":"(input) -> Tensor","s":"Returns a new tensor containing imaginary values of the :attr:`self` tensor."},{"l":"import_ir_module","k":"function","d":"(arg0: torch._C.CompilationUnit, arg1: str, arg2: object, arg3: dict, arg4: bool) -> torch._C.ScriptModule"},{"l":"import_ir_module_from_buffer","k":"function","d":"(arg0: torch._C.CompilationUnit, arg1: str, arg2: object, arg3: dict, arg4: bool) -> torch._C.ScriptModule"},{"l":"importlib","k":"module"},{"l":"index_add","k":"function","d":"(input: Tensor, dim: int, index: Tensor, source: Tensor, *, alpha: Union[Number, _complex] = 1, out: Optional[Tensor]) -> Tensor # noqa: B950","s":"See :meth:`~Tensor.index_add_` for function description."},{"l":"index_copy","k":"function","d":"(input: Tensor, dim: int, index: Tensor, source: Tensor, *, out: Optional[Tensor]) -> Tensor","s":"See :meth:`~Tensor.index_copy_` for function description."},{"l":"index_fill","k":"function"},{"l":"index_put","k":"function"},{"l":"index_put_","k":"function"},{"l":"index_reduce","k":"function","d":"(input: Tensor, dim: int, index: Tensor, source: Tensor, reduce: str, *, include_self: bool = True, out: Optional[Tensor]) -> Tensor # noqa: B950","s":"See :meth:`~Tensor.index_reduce_` for function description."},{"l":"index_select","k":"function","d":"(input, dim, index, *, out=None) -> Tensor","s":"Returns a new tensor which indexes the :attr:`input` tensor along dimension"},{"l":"indices_copy","k":"function","s":"Performs the same operation as :func:`torch.indices`, but all output tensors"},{"l":"inf","k":"constant","d":"inf"},{"l":"inference_mode","k":"class","d":"(mode=True)","s":"Context manager that enables or disables inference mode."},{"l":"init_num_threads","k":"function","d":"() -> None","s":"Initializes the number of parallel threads used on the current thread."},{"l":"initial_seed","k":"function","d":"() -> int","s":"Returns the initial seed for generating random numbers as a"},{"l":"inner","k":"function","d":"(input, other, *, out=None) -> Tensor","s":"Computes the dot product for 1D tensors. For higher dimensions, sums the product"},{"l":"inspect","k":"module"},{"l":"instance_norm","k":"function"},{"l":"int","k":"constant","d":"torch.int32"},{"l":"int1","k":"constant","d":"torch.int1"},{"l":"int16","k":"constant","d":"torch.int16"},{"l":"int2","k":"constant","d":"torch.int2"},{"l":"int3","k":"constant","d":"torch.int3"},{"l":"int32","k":"constant","d":"torch.int32"},{"l":"int4","k":"constant","d":"torch.int4"},{"l":"int5","k":"constant","d":"torch.int5"},{"l":"int6","k":"constant","d":"torch.int6"},{"l":"int64","k":"constant","d":"torch.int64"},{"l":"int7","k":"constant","d":"torch.int7"},{"l":"int8","k":"constant","d":"torch.int8"},{"l":"int_repr","k":"function"},{"l":"inverse","k":"function","d":"(input, *, out=None) -> Tensor","s":"Alias for :func:`torch.linalg.inv`"},{"l":"is_anomaly_check_nan_enabled","k":"function"},{"l":"is_anomaly_enabled","k":"function"},{"l":"is_autocast_cache_enabled","k":"function"},{"l":"is_autocast_cpu_enabled","k":"function"},{"l":"is_autocast_enabled","k":"function"},{"l":"is_autocast_ipu_enabled","k":"function"},{"l":"is_autocast_xla_enabled","k":"function"},{"l":"is_complex","k":"function","d":"(input: Tensor) -> bool","s":"Returns True if the data type of :attr:`input` is a complex data type i.e.,"},{"l":"is_conj","k":"function","d":"(input) -> (bool)","s":"Returns True if the :attr:`input` is a conjugated tensor, i.e. its conjugate bit is set to `True`."},{"l":"is_deterministic_algorithms_warn_only_enabled","k":"function","d":"() -> bool","s":"Returns True if the global deterministic flag is set to warn only."},{"l":"is_distributed","k":"function"},{"l":"is_floating_point","k":"function","d":"(input: Tensor) -> bool","s":"Returns True if the data type of :attr:`input` is a floating point data type i.e.,"},{"l":"is_grad_enabled","k":"function","d":"() -> (bool)","s":"Returns True if grad mode is currently enabled."},{"l":"is_inference","k":"function","d":"(input) -> (bool)","s":"Returns True if :attr:`input` is an inference tensor."},{"l":"is_inference_mode_enabled","k":"function","d":"() -> (bool)","s":"Returns True if inference mode is currently enabled."},{"l":"is_neg","k":"function"},{"l":"is_nonzero","k":"function","d":"(input) -> (bool)","s":"Returns True if the :attr:`input` is a single element tensor which is not equal to zero"},{"l":"is_same_size","k":"function"},{"l":"is_signed","k":"function"},{"l":"is_storage","k":"function","d":"(obj: Any, /) -> TypeGuard[ForwardRef('TypedStorage | UntypedStorage')]","s":"Returns True if `obj` is a PyTorch storage object."},{"l":"is_tensor","k":"function","d":"(obj: Any, /) -> typing_extensions.TypeIs[ForwardRef('torch.Tensor')]","s":"Returns True if `obj` is a PyTorch tensor."},{"l":"is_vulkan_available","k":"function"},{"l":"is_warn_always_enabled","k":"function","d":"() -> bool","s":"Returns True if the global warn_always flag is turned on. Refer to"},{"l":"isclose","k":"function","d":"(input, other, rtol=1e-05, atol=1e-08, equal_nan=False) -> Tensor","s":"Returns a new tensor with boolean elements representing if each element of"},{"l":"isfinite","k":"function","d":"(input) -> Tensor","s":"Returns a new tensor with boolean elements representing if each element is `finite` or not."},{"l":"isin","k":"function","d":"(elements, test_elements, *, assume_unique=False, invert=False) -> Tensor","s":"Tests if each element of :attr:`elements` is in :attr:`test_elements`. Returns"},{"l":"isinf","k":"function","d":"(input) -> Tensor","s":"Tests if each element of :attr:`input` is infinite"},{"l":"isnan","k":"function","d":"(input) -> Tensor","s":"Returns a new tensor with boolean elements representing if each element of :attr:`input`"},{"l":"isneginf","k":"function","d":"(input, *, out=None) -> Tensor","s":"Tests if each element of :attr:`input` is negative infinity or not."},{"l":"isposinf","k":"function","d":"(input, *, out=None) -> Tensor","s":"Tests if each element of :attr:`input` is positive infinity or not."},{"l":"isreal","k":"function","d":"(input) -> Tensor","s":"Returns a new tensor with boolean elements representing if each element of :attr:`input` is real-valued or not."},{"l":"istft","k":"function","d":"(input, n_fft, hop_length=None, win_length=None, window=None, center=True, normalized=False, onesided=None, length=None, return_complex=False) -> Tensor:","s":"Inverse short time Fourier Transform. This is expected to be the inverse of :func:`~torch.stft`."},{"l":"jagged","k":"constant","d":"torch.jagged"},{"l":"jit","k":"module"},{"l":"kaiser_window","k":"function","d":"(window_length, periodic=True, beta=12.0, *, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor","s":"Computes the Kaiser window with window length :attr:`window_length` and shape parameter :attr:`beta`."},{"l":"kl_div","k":"function"},{"l":"kron","k":"function","d":"(input, other, *, out=None) -> Tensor","s":"Computes the Kronecker product, denoted by :math:`\\otimes`, of :attr:`input` and :attr:`other`."},{"l":"kthvalue","k":"function","d":"(input, k, dim=None, keepdim=False, *, out=None) -> (Tensor, LongTensor)","s":"Returns a namedtuple ``(values, indices)`` where ``values`` is the :attr:`k` th"},{"l":"layer_norm","k":"function"},{"l":"layout","k":"class","d":"()"},{"l":"lcm","k":"function","d":"(input, other, *, out=None) -> Tensor","s":"Computes the element-wise least common multiple (LCM) of :attr:`input` and :attr:`other`."},{"l":"lcm_","k":"function"},{"l":"ldexp","k":"function","d":"(input, other, *, out=None) -> Tensor","s":"Multiplies :attr:`input` by 2 ** :attr:`other`."},{"l":"ldexp_","k":"function"},{"l":"le","k":"function","d":"(input, other, *, out=None) -> Tensor","s":"Computes :math:`\\text{input} \\leq \\text{other}` element-wise."},{"l":"legacy_contiguous_format","k":"constant","d":"torch.contiguous_format"},{"l":"lerp","k":"function","d":"(input, end, weight, *, out=None)","s":"Does a linear interpolation of two tensors :attr:`start` (given by :attr:`input`) and :attr:`end` based"},{"l":"less","k":"function","d":"(input, other, *, out=None) -> Tensor","s":"Alias for :func:`torch.lt`."},{"l":"less_equal","k":"function","d":"(input, other, *, out=None) -> Tensor","s":"Alias for :func:`torch.le`."},{"l":"lgamma","k":"function","d":"(input, *, out=None) -> Tensor","s":"Computes the natural logarithm of the absolute value of the gamma function on :attr:`input`."},{"l":"library","k":"module"},{"l":"linalg","k":"module"},{"l":"linspace","k":"function","d":"(start, end, steps, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor","s":"Creates a one-dimensional tensor of size :attr:`steps` whose values are evenly"},{"l":"load","k":"function","d":"(f: Union[str, os.PathLike[str], IO[bytes]], map_location: collections.abc.Callable[[torch.types.Storage, str], torch.types.Storage] | torch.device | str | dict[str, str] | None = None, pickle_module: Any = None, *, weights_only: bool | None = None, mmap: bool | None = None, **pickle_load_args: Any) -> Any","s":"Loads an object saved with :func:`torch.save` from a file."},{"l":"lobpcg","k":"function","d":"(A: torch.Tensor, k: int | None = None, B: torch.Tensor | None = None, X: torch.Tensor | None = None, n: int | None = None, iK: torch.Tensor | None = None, niter: int | None = None, tol: float | None = None, largest: bool | None = None, method: str | None = None, tracker: None = None, ortho_iparams: dict[str, int] | None = None, ortho_fparams: dict[str, float] | None = None, ortho_bparams: dict[str, bool] | None = None) -> tuple[torch.Tensor, torch.Tensor]","s":"Find the k largest (or smallest) eigenvalues and the corresponding"},{"l":"log","k":"function","d":"(input, *, out=None) -> Tensor","s":"Returns a new tensor with the natural logarithm of the elements"},{"l":"log10","k":"function","d":"(input: Tensor, *, out: Optional[Tensor]) -> Tensor","s":"Returns a new tensor with the logarithm to the base 10 of the elements"},{"l":"log10_","k":"function"},{"l":"log1p","k":"function","d":"(input, *, out=None) -> Tensor","s":"Returns a new tensor with the natural logarithm of (1 + :attr:`input`)."},{"l":"log1p_","k":"function"},{"l":"log2","k":"function","d":"(input: Tensor, *, out: Optional[Tensor]) -> Tensor","s":"Returns a new tensor with the logarithm to the base 2 of the elements"},{"l":"log2_","k":"function"},{"l":"log_","k":"function"},{"l":"log_softmax","k":"function"},{"l":"logaddexp","k":"function","d":"(input, other, *, out=None) -> Tensor","s":"Logarithm of the sum of exponentiations of the inputs."},{"l":"logaddexp2","k":"function","d":"(input, other, *, out=None) -> Tensor","s":"Logarithm of the sum of exponentiations of the inputs in base-2."},{"l":"logcumsumexp","k":"function","d":"(input, dim, *, out=None) -> Tensor","s":"Returns the logarithm of the cumulative summation of the exponentiation of"},{"l":"logdet","k":"function","d":"(input) -> Tensor","s":"Calculates log determinant of a square matrix or batches of square matrices."},{"l":"logical_and","k":"function","d":"(input, other, *, out=None) -> Tensor","s":"Computes the element-wise logical AND of the given input tensors. Zeros are treated as ``False`` and nonzeros are"},{"l":"logical_not","k":"function","d":"(input, *, out=None) -> Tensor","s":"Computes the element-wise logical NOT of the given input tensor. If not specified, the output tensor will have the bool"},{"l":"logical_or","k":"function","d":"(input, other, *, out=None) -> Tensor","s":"Computes the element-wise logical OR of the given input tensors. Zeros are treated as ``False`` and nonzeros are"},{"l":"logical_xor","k":"function","d":"(input: Tensor, other: Tensor, *, out: Optional[Tensor]) -> Tensor","s":"Computes the element-wise logical XOR of the given input tensors. Zeros are treated as ``False`` and nonzeros are"},{"l":"logit","k":"function","d":"(input, eps=None, *, out=None) -> Tensor","s":"Alias for :func:`torch.special.logit`."},{"l":"logit_","k":"function"},{"l":"logspace","k":"function","d":"(start, end, steps, base=10.0, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor","s":"Creates a one-dimensional tensor of size :attr:`steps` whose values are evenly"},{"l":"logsumexp","k":"function","d":"(input, dim, keepdim=False, *, out=None)","s":"Returns the log of summed exponentials of each row of the :attr:`input`"},{"l":"long","k":"constant","d":"torch.int64"},{"l":"lstm","k":"function"},{"l":"lstm_cell","k":"function"},{"l":"lstsq","k":"function","d":"(input: torch.Tensor, A: torch.Tensor, *, out=None) -> tuple[torch.Tensor, torch.Tensor]"},{"l":"lt","k":"function","d":"(input, other, *, out=None) -> Tensor","s":"Computes :math:`\\text{input} < \\text{other}` element-wise."},{"l":"lu","k":"function","d":"(*args, **kwargs)","s":"Computes the LU factorization of a matrix or batches of matrices"},{"l":"lu_solve","k":"function","d":"(b, LU_data, LU_pivots, *, out=None) -> Tensor","s":"Returns the LU solve of the linear system :math:`Ax = b` using the partially pivoted"},{"l":"lu_unpack","k":"function","d":"(LU_data, LU_pivots, unpack_data=True, unpack_pivots=True, *, out=None) -> (Tensor, Tensor, Tensor)","s":"Unpacks the LU decomposition returned by :func:`~linalg.lu_factor` into the `P, L, U` matrices."},{"l":"manual_seed","k":"function","d":"(seed) -> torch._C.Generator","s":"Sets the seed for generating random numbers on all devices. Returns a"},{"l":"margin_ranking_loss","k":"function"},{"l":"masked","k":"module"},{"l":"masked_fill","k":"function"},{"l":"masked_scatter","k":"function"},{"l":"masked_select","k":"function","d":"(input, mask, *, out=None) -> Tensor","s":"Returns a new 1-D tensor which indexes the :attr:`input` tensor according to"},{"l":"math","k":"module"},{"l":"matmul","k":"function","d":"(input, other, *, out=None) -> Tensor","s":"Matrix product of two tensors."},{"l":"matrix_exp","k":"function","d":"(A) -> Tensor","s":"Alias for :func:`torch.linalg.matrix_exp`."},{"l":"matrix_power","k":"function","d":"(input, n, *, out=None) -> Tensor","s":"Alias for :func:`torch.linalg.matrix_power`"},{"l":"matrix_rank","k":"function","d":"(input, tol=None, symmetric=False, *, out=None) -> torch.Tensor"},{"l":"max","k":"function","d":"(input, *, out=None) -> Tensor","s":"Returns the maximum value of all elements in the ``input`` tensor."},{"l":"max_pool1d","k":"function"},{"l":"max_pool1d_with_indices","k":"function"},{"l":"max_pool2d","k":"function"},{"l":"max_pool3d","k":"function"},{"l":"maximum","k":"function","d":"(input, other, *, out=None) -> Tensor","s":"Computes the element-wise maximum of :attr:`input` and :attr:`other`."},{"l":"mean","k":"function","d":"(input, *, dtype=None) -> Tensor","s":".. note::"},{"l":"median","k":"function","d":"(input) -> Tensor","s":"Returns the median of the values in :attr:`input`."},{"l":"memory_format","k":"class","d":"()"},{"l":"merge_type_from_type_comment","k":"function","d":"(arg0: torch._C._jit_tree_views.Decl, arg1: torch._C._jit_tree_views.Decl, arg2: bool) -> torch._C._jit_tree_views.Decl"},{"l":"meshgrid","k":"function","d":"(*tensors, indexing: str | None = None) -> tuple[torch.Tensor, ...]","s":"Creates grids of coordinates specified by the 1D inputs in `attr`:tensors."},{"l":"min","k":"function","d":"(input, *, out=None) -> Tensor","s":"Returns the minimum value of all elements in the :attr:`input` tensor."},{"l":"minimum","k":"function","d":"(input, other, *, out=None) -> Tensor","s":"Computes the element-wise minimum of :attr:`input` and :attr:`other`."},{"l":"miopen_batch_norm","k":"function"},{"l":"miopen_convolution","k":"function"},{"l":"miopen_convolution_add_relu","k":"function"},{"l":"miopen_convolution_relu","k":"function"},{"l":"miopen_convolution_transpose","k":"function"},{"l":"miopen_ctc_loss","k":"function"},{"l":"miopen_depthwise_convolution","k":"function"},{"l":"miopen_rnn","k":"function"},{"l":"mkldnn_adaptive_avg_pool2d","k":"function"},{"l":"mkldnn_convolution","k":"function"},{"l":"mkldnn_linear_backward_weights","k":"function"},{"l":"mkldnn_max_pool2d","k":"function"},{"l":"mkldnn_max_pool3d","k":"function"},{"l":"mkldnn_rnn_layer","k":"function"},{"l":"mm","k":"function","d":"(input, mat2, *, out=None) -> Tensor","s":"Performs a matrix multiplication of the matrices :attr:`input` and :attr:`mat2`."},{"l":"mode","k":"function","d":"(input, dim=-1, keepdim=False, *, out=None) -> (Tensor, LongTensor)","s":"Returns a namedtuple ``(values, indices)`` where ``values`` is the mode"},{"l":"monitor","k":"module"},{"l":"moveaxis","k":"function","d":"(input, source, destination) -> Tensor","s":"Alias for :func:`torch.movedim`."},{"l":"movedim","k":"function","d":"(input, source, destination) -> Tensor","s":"Moves the dimension(s) of :attr:`input` at the position(s) in :attr:`source`"},{"l":"mps","k":"module"},{"l":"msort","k":"function","d":"(input: Tensor, *, out: Optional[Tensor]) -> Tensor","s":"Sorts the elements of the :attr:`input` tensor along its first dimension"},{"l":"mtia","k":"module"},{"l":"mul","k":"function","d":"(input, other, *, out=None) -> Tensor","s":"Multiplies :attr:`input` by :attr:`other`."},{"l":"multinomial","k":"function","d":"(input, num_samples, replacement=False, *, generator=None, out=None) -> LongTensor","s":"Returns a tensor where each row contains :attr:`num_samples` indices sampled"},{"l":"multiply","k":"function","d":"(input, other, *, out=None)","s":"Alias for :func:`torch.mul`."},{"l":"multiprocessing","k":"module"},{"l":"mv","k":"function","d":"(input, vec, *, out=None) -> Tensor","s":"Performs a matrix-vector product of the matrix :attr:`input` and the vector"},{"l":"mvlgamma","k":"function","d":"(input, p, *, out=None) -> Tensor","s":"Alias for :func:`torch.special.multigammaln`."},{"l":"nan","k":"constant","d":"nan"},{"l":"nan_to_num","k":"function","d":"(input, nan=0.0, posinf=None, neginf=None, *, out=None) -> Tensor","s":"Replaces :literal:`NaN`, positive infinity, and negative infinity values in :attr:`input`"},{"l":"nan_to_num_","k":"function"},{"l":"nanmean","k":"function","d":"(input, dim=None, keepdim=False, *, dtype=None, out=None) -> Tensor","s":"Computes the mean of all `non-NaN` elements along the specified dimensions."},{"l":"nanmedian","k":"function","d":"(input) -> Tensor","s":"Returns the median of the values in :attr:`input`, ignoring ``NaN`` values."},{"l":"nanquantile","k":"function","d":"(input, q, dim=None, keepdim=False, *, interpolation='linear', out=None) -> Tensor","s":"This is a variant of :func:`torch.quantile` that \"ignores\" ``NaN`` values,"},{"l":"nansum","k":"function","d":"(input, *, dtype=None) -> Tensor","s":"Returns the sum of all elements, treating Not a Numbers (NaNs) as zero."},{"l":"narrow","k":"function","d":"(input, dim, start, length) -> Tensor","s":"Returns a new tensor that is a narrowed version of :attr:`input` tensor. The"},{"l":"narrow_copy","k":"function","d":"(input, dim, start, length, *, out=None) -> Tensor","s":"Same as :meth:`Tensor.narrow` except this returns a copy rather"},{"l":"native_batch_norm","k":"function"},{"l":"native_channel_shuffle","k":"function","d":"(input, groups) -> Tensor","s":"Native kernel level implementation of the `channel_shuffle`."},{"l":"native_dropout","k":"function"},{"l":"native_group_norm","k":"function"},{"l":"native_layer_norm","k":"function"},{"l":"native_norm","k":"function"},{"l":"ne","k":"function","d":"(input, other, *, out=None) -> Tensor","s":"Computes :math:`\\text{input} \\neq \\text{other}` element-wise."},{"l":"neg","k":"function","d":"(input, *, out=None) -> Tensor","s":"Returns a new tensor with the negative of the elements of :attr:`input`."},{"l":"neg_","k":"function"},{"l":"negative","k":"function","d":"(input, *, out=None) -> Tensor","s":"Alias for :func:`torch.neg`"},{"l":"negative_","k":"function"},{"l":"nested","k":"module"},{"l":"newaxis","k":"constant","d":"None"},{"l":"nextafter","k":"function","d":"(input, other, *, out=None) -> Tensor","s":"Return the next floating-point value after :attr:`input` towards :attr:`other`, elementwise."},{"l":"nn","k":"module"},{"l":"no_grad","k":"class","d":"() -> None","s":"Context-manager that disables gradient calculation."},{"l":"nonzero","k":"function","d":"(input, *, out=None, as_tuple=False) -> LongTensor or tuple of LongTensors","s":".. note::"},{"l":"nonzero_static","k":"function","d":"(input, *, size, fill_value=-1) -> Tensor","s":"Returns a 2-D tensor where each row is the index for a non-zero value."},{"l":"norm","k":"function","d":"(input, p: float | str | None = 'fro', dim=None, keepdim=False, out=None, dtype=None)","s":"Returns the matrix norm or vector norm of a given tensor."},{"l":"norm_except_dim","k":"function"},{"l":"normal","k":"function","d":"(mean, std, *, generator=None, out=None) -> Tensor","s":"Returns a tensor of random numbers drawn from separate normal distributions"},{"l":"not_equal","k":"function","d":"(input, other, *, out=None) -> Tensor","s":"Alias for :func:`torch.ne`."},{"l":"nuclear_norm","k":"function"},{"l":"numel","k":"function","d":"(input: Tensor) -> int","s":"Returns the total number of elements in the :attr:`input` tensor."},{"l":"ones","k":"function","d":"(*size, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor","s":"Returns a tensor filled with the scalar value `1`, with the shape defined"},{"l":"ones_like","k":"function","d":"(input, *, dtype=None, layout=None, device=None, requires_grad=False, memory_format=torch.preserve_format) -> Tensor","s":"Returns a tensor filled with the scalar value `1`, with the same size as"},{"l":"ops","k":"module"},{"l":"optim","k":"module"},{"l":"orgqr","k":"function","d":"(input, tau) -> Tensor","s":"Alias for :func:`torch.linalg.householder_product`."},{"l":"ormqr","k":"function","d":"(input, tau, other, left=True, transpose=False, *, out=None) -> Tensor","s":"Computes the matrix-matrix multiplication of a product of Householder matrices with a general matrix."},{"l":"os","k":"module"},{"l":"outer","k":"function","d":"(input, vec2, *, out=None) -> Tensor","s":"Outer product of :attr:`input` and :attr:`vec2`."},{"l":"overrides","k":"module"},{"l":"package","k":"module"},{"l":"pairwise_distance","k":"function","d":"(x1, x2, p=2.0, eps=1e-6, keepdim=False) -> Tensor","s":"See :class:`torch.nn.PairwiseDistance` for details"},{"l":"parse_ir","k":"function","d":"(input: str, parse_tensor_constants: bool = False) -> torch::jit::Graph"},{"l":"parse_schema","k":"function","d":"(schema: str, allow_typevars: bool = True) -> c10::FunctionSchema"},{"l":"parse_type_comment","k":"function","d":"(arg0: str) -> torch._C._jit_tree_views.Decl"},{"l":"pca_lowrank","k":"function","d":"(A: torch.Tensor, q: int | None = None, center: bool = True, niter: int = 2) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]","s":"Performs linear Principal Component Analysis (PCA) on a low-rank"},{"l":"pdist","k":"function","d":"(input, p=2) -> Tensor","s":"Computes the p-norm distance between every pair of row vectors in the input."},{"l":"per_channel_affine","k":"constant","d":"torch.per_channel_affine"},{"l":"per_channel_affine_float_qparams","k":"constant","d":"torch.per_channel_affine_float_qparams"},{"l":"per_channel_symmetric","k":"constant","d":"torch.per_channel_symmetric"},{"l":"per_tensor_affine","k":"constant","d":"torch.per_tensor_affine"},{"l":"per_tensor_symmetric","k":"constant","d":"torch.per_tensor_symmetric"},{"l":"permute","k":"function","d":"(input, dims) -> Tensor","s":"Returns a view of the original tensor :attr:`input` with its dimensions permuted."},{"l":"permute_copy","k":"function","s":"Performs the same operation as :func:`torch.permute`, but all output tensors"},{"l":"pi","k":"constant","d":"3.141592653589793"},{"l":"pinverse","k":"function","d":"(input, rcond=1e-15) -> Tensor","s":"Alias for :func:`torch.linalg.pinv`"},{"l":"pixel_shuffle","k":"function","d":"(input, upscale_factor) -> Tensor","s":"Rearranges elements in a tensor of shape :math:`(*, C \\times r^2, H, W)` to a"},{"l":"pixel_unshuffle","k":"function","d":"(input, downscale_factor) -> Tensor","s":"Reverses the :class:`~torch.nn.PixelShuffle` operation by rearranging elements in a"},{"l":"platform","k":"module"},{"l":"poisson","k":"function","d":"(input, generator=None) -> Tensor","s":"Returns a tensor of the same size as :attr:`input` with each element"},{"l":"poisson_nll_loss","k":"function"},{"l":"polar","k":"function","d":"(abs, angle, *, out=None) -> Tensor","s":"Constructs a complex tensor whose elements are Cartesian coordinates"},{"l":"polygamma","k":"function","d":"(n, input, *, out=None) -> Tensor","s":"Alias for :func:`torch.special.polygamma`."},{"l":"positive","k":"function","d":"(input) -> Tensor","s":"Returns :attr:`input`."},{"l":"pow","k":"function","d":"(input, exponent, *, out=None) -> Tensor","s":"Takes the power of each element in :attr:`input` with :attr:`exponent` and"},{"l":"prelu","k":"function","d":"(input, weight) -> Tensor","s":"Applies element-wise the function"},{"l":"prepare_multiprocessing_environment","k":"function","d":"(path: str) -> None"},{"l":"preserve_format","k":"constant","d":"torch.preserve_format"},{"l":"prod","k":"function","d":"(input: Tensor, *, dtype: Optional[_dtype]) -> Tensor","s":"Returns the product of all elements in the :attr:`input` tensor."},{"l":"profiler","k":"module"},{"l":"profiler_allow_cudagraph_cupti_lazy_reinit_cuda12","k":"function","d":"()"},{"l":"promote_types","k":"function","d":"(type1, type2) -> dtype","s":"Returns the :class:`torch.dtype` with the smallest size and scalar kind that is"},{"l":"put","k":"function"},{"l":"q_per_channel_axis","k":"function"},{"l":"q_per_channel_scales","k":"function"},{"l":"q_per_channel_zero_points","k":"function"},{"l":"q_scale","k":"function"},{"l":"q_zero_point","k":"function"},{"l":"qint32","k":"constant","d":"torch.qint32"},{"l":"qint8","k":"constant","d":"torch.qint8"},{"l":"qr","k":"function","d":"(input: Tensor, some: bool = True, *, out: Union[Tensor, Tuple[Tensor, ...], List[Tensor], None]) -> (Tensor, Tensor)","s":"Computes the QR decomposition of a matrix or a batch of matrices :attr:`input`,"},{"l":"qscheme","k":"class","d":"()"},{"l":"quantile","k":"function","d":"(input, q, dim=None, keepdim=False, *, interpolation='linear', out=None) -> Tensor","s":"Computes the q-th quantiles of each row of the :attr:`input` tensor along the dimension :attr:`dim`."},{"l":"quantization","k":"module"},{"l":"quantize_per_channel","k":"function","d":"(input, scales, zero_points, axis, dtype) -> Tensor","s":"Converts a float tensor to a per-channel quantized tensor with given scales and zero points."},{"l":"quantize_per_tensor","k":"function","d":"(input, scale, zero_point, dtype) -> Tensor","s":"Converts a float tensor to a quantized tensor with given scale and zero point."},{"l":"quantize_per_tensor_dynamic","k":"function","d":"(input, dtype, reduce_range) -> Tensor","s":"Converts a float tensor to a quantized tensor with scale and zero_point calculated"},{"l":"quantized_batch_norm","k":"function","d":"(input, weight=None, bias=None, mean, var, eps, output_scale, output_zero_point) -> Tensor","s":"Applies batch normalization on a 4D (NCHW) quantized tensor."},{"l":"quantized_gru","k":"function","d":"(*args: _P.args, **kwargs: _P.kwargs) -> ~_T"},{"l":"quantized_gru_cell","k":"function"},{"l":"quantized_lstm","k":"function","d":"(*args: _P.args, **kwargs: _P.kwargs) -> ~_T"},{"l":"quantized_lstm_cell","k":"function"},{"l":"quantized_max_pool1d","k":"function","d":"(input, kernel_size, stride=[], padding=0, dilation=1, ceil_mode=False) -> Tensor","s":"Applies a 1D max pooling over an input quantized tensor composed of several input planes."},{"l":"quantized_max_pool2d","k":"function","d":"(input, kernel_size, stride=[], padding=0, dilation=1, ceil_mode=False) -> Tensor","s":"Applies a 2D max pooling over an input quantized tensor composed of several input planes."},{"l":"quantized_max_pool3d","k":"function"},{"l":"quantized_rnn_relu_cell","k":"function"},{"l":"quantized_rnn_tanh_cell","k":"function"},{"l":"quasirandom","k":"module"},{"l":"quint2x4","k":"constant","d":"torch.quint2x4"},{"l":"quint4x2","k":"constant","d":"torch.quint4x2"},{"l":"quint8","k":"constant","d":"torch.quint8"},{"l":"rad2deg","k":"function","d":"(input: Tensor, *, out: Optional[Tensor]) -> Tensor","s":"Returns a new tensor with each of the elements of :attr:`input`"},{"l":"rad2deg_","k":"function"},{"l":"rand","k":"function","d":"(*size, *, generator=None, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False, pin_memory=False) -> Tensor","s":"Returns a tensor filled with random numbers from a uniform distribution"},{"l":"rand_like","k":"function","d":"(input, *, generator=None, dtype=None, layout=None, device=None, requires_grad=False, memory_format=torch.preserve_format) -> Tensor","s":"Returns a tensor with the same size as :attr:`input` that is filled with"},{"l":"randint","k":"function","d":"(low=0, high, size, \\*, generator=None, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor","s":"Returns a tensor filled with random integers generated uniformly"},{"l":"randint_like","k":"function","d":"(input, low=0, high, \\*, generator=None, dtype=None, layout=torch.strided, device=None, requires_grad=False, memory_format=torch.preserve_format) -> Tensor","s":"Returns a tensor with the same shape as Tensor :attr:`input` filled with"},{"l":"randn","k":"function","d":"(*size, *, generator=None, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False, pin_memory=False) -> Tensor","s":"Returns a tensor filled with random numbers from a normal distribution"},{"l":"randn_like","k":"function","d":"(input, *, generator=None, dtype=None, layout=None, device=None, requires_grad=False, memory_format=torch.preserve_format) -> Tensor","s":"Returns a tensor with the same size as :attr:`input` that is filled with"},{"l":"random","k":"module"},{"l":"randperm","k":"function","d":"(n, *, generator=None, out=None, dtype=torch.int64,layout=torch.strided, device=None, requires_grad=False, pin_memory=False) -> Tensor","s":"Returns a random permutation of integers from ``0`` to ``n - 1``."},{"l":"range","k":"function","d":"(start=0, end, step=1, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor","s":"Returns a 1-D tensor of size :math:`\\left\\lfloor \\frac{\\text{end} - \\text{start}}{\\text{step}} \\right\\rfloor + 1`"},{"l":"ravel","k":"function","d":"(input) -> Tensor","s":"Return a contiguous flattened tensor. A copy is made only if needed."},{"l":"real","k":"function","d":"(input) -> Tensor","s":"Returns a new tensor containing real values of the :attr:`self` tensor."},{"l":"reciprocal","k":"function","d":"(input, *, out=None) -> Tensor","s":"Returns a new tensor with the reciprocal of the elements of :attr:`input`"},{"l":"reciprocal_","k":"function"},{"l":"relu","k":"function"},{"l":"relu_","k":"function","d":"(input) -> Tensor","s":"In-place version of :func:`~relu`."},{"l":"remainder","k":"function","d":"(input, other, *, out=None) -> Tensor","s":"Computes"},{"l":"renorm","k":"function","d":"(input, p, dim, maxnorm, *, out=None) -> Tensor","s":"Returns a tensor where each sub-tensor of :attr:`input` along dimension"},{"l":"repeat_interleave","k":"function","d":"(input, repeats, dim=None, *, output_size=None) -> Tensor","s":"Repeat elements of a tensor."},{"l":"reshape","k":"function","d":"(input, shape) -> Tensor","s":"Returns a tensor with the same data and number of elements as :attr:`input`,"},{"l":"resize_as_","k":"function"},{"l":"resize_as_sparse_","k":"function"},{"l":"resolve_conj","k":"function","d":"(input) -> Tensor","s":"Returns a new tensor with materialized conjugation if :attr:`input`'s conjugate bit is set to `True`,"},{"l":"resolve_neg","k":"function","d":"(input) -> Tensor","s":"Returns a new tensor with materialized negation if :attr:`input`'s negative bit is set to `True`,"},{"l":"result_type","k":"function","d":"(tensor1, tensor2) -> dtype","s":"Returns the :class:`torch.dtype` that would result from performing an arithmetic"},{"l":"return_types","k":"module"},{"l":"rms_norm","k":"function"},{"l":"rnn_relu","k":"function"},{"l":"rnn_relu_cell","k":"function"},{"l":"rnn_tanh","k":"function"},{"l":"rnn_tanh_cell","k":"function"},{"l":"roll","k":"function","d":"(input, shifts, dims=None) -> Tensor","s":"Roll the tensor :attr:`input` along the given dimension(s). Elements that are"},{"l":"rot90","k":"function","d":"(input, k=1, dims=(0, 1)) -> Tensor","s":"Rotate an n-D tensor by 90 degrees in the plane specified by dims axis."},{"l":"round","k":"function","d":"(input, *, decimals=0, out=None) -> Tensor","s":"Rounds elements of :attr:`input` to the nearest integer."},{"l":"round_","k":"function"},{"l":"row_indices_copy","k":"function"},{"l":"row_stack","k":"function","d":"(tensors, *, out=None) -> Tensor","s":"Alias of :func:`torch.vstack`."},{"l":"rrelu","k":"function"},{"l":"rrelu_","k":"function","d":"(input, lower=1./8, upper=1./3, training=False) -> Tensor","s":"In-place version of :func:`~rrelu`."},{"l":"rsqrt","k":"function","d":"(input, *, out=None) -> Tensor","s":"Returns a new tensor with the reciprocal of the square-root of each of"},{"l":"rsqrt_","k":"function"},{"l":"rsub","k":"function"},{"l":"saddmm","k":"function"},{"l":"save","k":"function","d":"(obj: object, f: Union[str, os.PathLike[str], IO[bytes]], pickle_module: Any = , pickle_protocol: int = 2, _use_new_zipfile_serialization: bool = True, _disable_byteorder_record: bool = False) -> None","s":"Saves an object to a disk file."},{"l":"scalar_tensor","k":"function"},{"l":"scatter","k":"function","d":"(input, dim, index, src) -> Tensor","s":"Out-of-place version of :meth:`torch.Tensor.scatter_`"},{"l":"scatter_add","k":"function","d":"(input, dim, index, src) -> Tensor","s":"Out-of-place version of :meth:`torch.Tensor.scatter_add_`"},{"l":"scatter_reduce","k":"function","d":"(input, dim, index, src, reduce, *, include_self=True) -> Tensor","s":"Out-of-place version of :meth:`torch.Tensor.scatter_reduce_`"},{"l":"searchsorted","k":"function","d":"(sorted_sequence, values, *, out_int32=False, right=False, side=None, out=None, sorter=None) -> Tensor","s":"Find the indices from the *innermost* dimension of :attr:`sorted_sequence` such that, if the"},{"l":"seed","k":"function","d":"() -> int","s":"Sets the seed for generating random numbers to a non-deterministic"},{"l":"segment_reduce","k":"function","d":"(data: Tensor, reduce: str, *, lengths: Tensor | None = None, indices: Tensor | None = None, offsets: Tensor | None = None, axis: _int = 0, unsafe: _bool = False, initial: Number | _complex | None = None) -> Tensor # noqa: B950","s":"Perform a segment reduction operation on the input tensor along the specified axis."},{"l":"select","k":"function","d":"(input, dim, index) -> Tensor","s":"Slices the :attr:`input` tensor along the selected dimension at the given index."},{"l":"select_copy","k":"function","s":"Performs the same operation as :func:`torch.select`, but all output tensors"},{"l":"select_scatter","k":"function","d":"(input, src, dim, index) -> Tensor","s":"Embeds the values of the :attr:`src` tensor into :attr:`input` at the given index."},{"l":"selu","k":"function"},{"l":"selu_","k":"function","d":"(input) -> Tensor","s":"In-place version of :func:`~selu`."},{"l":"serialization","k":"module"},{"l":"set_anomaly_enabled","k":"function"},{"l":"set_autocast_cache_enabled","k":"function"},{"l":"set_autocast_cpu_dtype","k":"function"},{"l":"set_autocast_cpu_enabled","k":"function"},{"l":"set_autocast_dtype","k":"function"},{"l":"set_autocast_enabled","k":"function"},{"l":"set_autocast_gpu_dtype","k":"function"},{"l":"set_autocast_ipu_dtype","k":"function"},{"l":"set_autocast_ipu_enabled","k":"function"},{"l":"set_autocast_xla_dtype","k":"function"},{"l":"set_autocast_xla_enabled","k":"function"},{"l":"set_default_device","k":"function","d":"(device: 'Device') -> None","s":"Sets the default ``torch.Tensor`` to be allocated on ``device``. This"},{"l":"set_default_dtype","k":"function","d":"(d: 'torch.dtype', /) -> None","s":"Sets the default floating point dtype to :attr:`d`. Supports floating point dtype"},{"l":"set_default_tensor_type","k":"function","d":"(t: type['torch.Tensor'] | str, /) -> None","s":".. warning::"},{"l":"set_deterministic_debug_mode","k":"function","d":"(debug_mode: int | str) -> None","s":"Sets the debug mode for deterministic operations."},{"l":"set_float32_matmul_precision","k":"function","d":"(precision: str) -> None","s":"Sets the internal precision of float32 matrix multiplications."},{"l":"set_flush_denormal","k":"function","d":"(mode) -> bool","s":"Disables denormal floating numbers on CPU."},{"l":"set_grad_enabled","k":"class","d":"(mode: bool) -> None","s":"Context-manager that sets gradient calculation on or off."},{"l":"set_num_interop_threads","k":"function","d":"(int)","s":"Sets the number of threads used for interop parallelism"},{"l":"set_num_threads","k":"function","d":"(int)","s":"Sets the number of threads used for intraop parallelism on CPU."},{"l":"set_printoptions","k":"function","d":"(precision=None, threshold=None, edgeitems=None, linewidth=None, profile=None, sci_mode=None)","s":"Set options for printing. Items shamelessly taken from NumPy"},{"l":"set_rng_state","k":"function","d":"(new_state: torch.Tensor) -> None","s":"Sets the random number generator state."},{"l":"set_warn_always","k":"function","d":"(b: bool, /) -> None","s":"When this flag is False (default) then some PyTorch warnings may only"},{"l":"sgn","k":"function","d":"(input, *, out=None) -> Tensor","s":"This function is an extension of torch.sign() to complex tensors."},{"l":"short","k":"constant","d":"torch.int16"},{"l":"sigmoid","k":"function","d":"(input, *, out=None) -> Tensor","s":"Alias for :func:`torch.special.expit`."},{"l":"sigmoid_","k":"function"},{"l":"sign","k":"function","d":"(input, *, out=None) -> Tensor","s":"Returns a new tensor with the signs of the elements of :attr:`input`."},{"l":"signal","k":"module"},{"l":"signbit","k":"function","d":"(input, *, out=None) -> Tensor","s":"Tests if each element of :attr:`input` has its sign bit set or not."},{"l":"sin","k":"function","d":"(input, *, out=None) -> Tensor","s":"Returns a new tensor with the sine of the elements in the :attr:`input` tensor,"},{"l":"sin_","k":"function"},{"l":"sinc","k":"function","d":"(input, *, out=None) -> Tensor","s":"Alias for :func:`torch.special.sinc`."},{"l":"sinc_","k":"function"},{"l":"sinh","k":"function","d":"(input, *, out=None) -> Tensor","s":"Returns a new tensor with the hyperbolic sine of the elements of"},{"l":"sinh_","k":"function"},{"l":"slice_copy","k":"function","s":"Performs the same operation as :func:`torch.slice`, but all output tensors"},{"l":"slice_inverse","k":"function"},{"l":"slice_scatter","k":"function","d":"(input, src, dim=0, start=None, end=None, step=1) -> Tensor","s":"Embeds the values of the :attr:`src` tensor into :attr:`input` at the given"},{"l":"slogdet","k":"function","d":"(input) -> (Tensor, Tensor)","s":"Alias for :func:`torch.linalg.slogdet`"},{"l":"smm","k":"function","d":"(input, mat) -> Tensor","s":"Performs a matrix multiplication of the sparse matrix :attr:`input`"},{"l":"softmax","k":"function","d":"(input, dim, *, dtype=None) -> Tensor","s":"Alias for :func:`torch.nn.functional.softmax`."},{"l":"solve","k":"function","d":"(input: torch.Tensor, A: torch.Tensor, *, out=None) -> tuple[torch.Tensor, torch.Tensor]"},{"l":"sort","k":"function","d":"(input, dim=-1, descending=False, *, stable=False, out=None) -> (Tensor, LongTensor)","s":"Sorts the elements of the :attr:`input` tensor along a given dimension"},{"l":"sparse","k":"module"},{"l":"sparse_bsc","k":"constant","d":"torch.sparse_bsc"},{"l":"sparse_bsc_tensor","k":"function","d":"(ccol_indices, row_indices, values, size=None, *, dtype=None, device=None, pin_memory=False, requires_grad=False, check_invariants=None) -> Tensor","s":"Constructs a :ref:`sparse tensor in BSC (Block Compressed Sparse"},{"l":"sparse_bsr","k":"constant","d":"torch.sparse_bsr"},{"l":"sparse_bsr_tensor","k":"function","d":"(crow_indices, col_indices, values, size=None, *, dtype=None, device=None, pin_memory=False, requires_grad=False, check_invariants=None) -> Tensor","s":"Constructs a :ref:`sparse tensor in BSR (Block Compressed Sparse Row))"},{"l":"sparse_compressed_tensor","k":"function","d":"(compressed_indices, plain_indices, values, size=None, *, dtype=None, layout=None, device=None, pin_memory=False, requires_grad=False, check_invariants=None) -> Tensor","s":"Constructs a :ref:`sparse tensor in Compressed Sparse format - CSR,"},{"l":"sparse_coo","k":"constant","d":"torch.sparse_coo"},{"l":"sparse_coo_tensor","k":"function","d":"(indices, values, size=None, *, dtype=None, device=None, pin_memory=False, requires_grad=False, check_invariants=None, is_coalesced=None) -> Tensor","s":"Constructs a :ref:`sparse tensor in COO(rdinate) format"},{"l":"sparse_csc","k":"constant","d":"torch.sparse_csc"},{"l":"sparse_csc_tensor","k":"function","d":"(ccol_indices, row_indices, values, size=None, *, dtype=None, device=None, pin_memory=False, requires_grad=False, check_invariants=None) -> Tensor","s":"Constructs a :ref:`sparse tensor in CSC (Compressed Sparse Column)"},{"l":"sparse_csr","k":"constant","d":"torch.sparse_csr"},{"l":"sparse_csr_tensor","k":"function","d":"(crow_indices, col_indices, values, size=None, *, dtype=None, device=None, pin_memory=False, requires_grad=False, check_invariants=None) -> Tensor","s":"Constructs a :ref:`sparse tensor in CSR (Compressed Sparse Row) ` with specified"},{"l":"special","k":"module"},{"l":"split","k":"function","d":"(tensor: torch.Tensor, split_size_or_sections: int | list[int], dim: int = 0) -> tuple[torch.Tensor, ...]","s":"Splits the tensor into chunks. Each chunk is a view of the original tensor."},{"l":"split_copy","k":"function","s":"Performs the same operation as :func:`torch.split`, but all output tensors"},{"l":"split_with_sizes","k":"function"},{"l":"split_with_sizes_copy","k":"function","s":"Performs the same operation as :func:`torch.split_with_sizes`, but all output tensors"},{"l":"spmm","k":"function"},{"l":"sqrt","k":"function","d":"(input, *, out=None) -> Tensor","s":"Returns a new tensor with the square-root of the elements of :attr:`input`."},{"l":"sqrt_","k":"function"},{"l":"square","k":"function","d":"(input: Tensor, *, out: Optional[Tensor]) -> Tensor","s":"Returns a new tensor with the square of the elements of :attr:`input`."},{"l":"square_","k":"function"},{"l":"squeeze","k":"function","d":"(input: Tensor, dim: Optional[Union[int, List[int]]]) -> Tensor","s":"Returns a tensor with all specified dimensions of :attr:`input` of size `1` removed."},{"l":"squeeze_copy","k":"function","s":"Performs the same operation as :func:`torch.squeeze`, but all output tensors"},{"l":"sspaddmm","k":"function","d":"(input, mat1, mat2, *, beta=1, alpha=1, out=None) -> Tensor","s":"Matrix multiplies a sparse tensor :attr:`mat1` with a dense tensor"},{"l":"stack","k":"function","d":"(tensors, dim=0, *, out=None) -> Tensor","s":"Concatenates a sequence of tensors along a new dimension."},{"l":"std","k":"function","d":"(input, dim=None, *, correction=1, keepdim=False, out=None) -> Tensor","s":"Calculates the standard deviation over the dimensions specified by :attr:`dim`."},{"l":"std_mean","k":"function","d":"(input, dim=None, *, correction=1, keepdim=False, out=None) -> (Tensor, Tensor)","s":"Calculates the standard deviation and mean over the dimensions specified by"},{"l":"stft","k":"function","d":"(input: torch.Tensor, n_fft: int, hop_length: int | None = None, win_length: int | None = None, window: torch.Tensor | None = None, center: bool = True, pad_mode: str = 'reflect', normalized: bool = False, onesided: bool | None = None, return_complex: bool | None = None, align_to_window: bool | None = None) -> torch.Tensor","s":"Short-time Fourier transform (STFT)."},{"l":"storage","k":"module"},{"l":"strided","k":"constant","d":"torch.strided"},{"l":"sub","k":"function","d":"(input, other, *, alpha=1, out=None) -> Tensor","s":"Subtracts :attr:`other`, scaled by :attr:`alpha`, from :attr:`input`."},{"l":"subtract","k":"function","d":"(input, other, *, alpha=1, out=None) -> Tensor","s":"Alias for :func:`torch.sub`."},{"l":"sum","k":"function","d":"(input, *, dtype=None) -> Tensor","s":"Returns the sum of all elements in the :attr:`input` tensor."},{"l":"svd","k":"function","d":"(input, some=True, compute_uv=True, *, out=None) -> (Tensor, Tensor, Tensor)","s":"Computes the singular value decomposition of either a matrix or batch of"},{"l":"svd_lowrank","k":"function","d":"(A: torch.Tensor, q: int | None = 6, niter: int | None = 2, M: torch.Tensor | None = None) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]","s":"Return the singular value decomposition ``(U, S, V)`` of a matrix,"},{"l":"swapaxes","k":"function","d":"(input, axis0, axis1) -> Tensor","s":"Alias for :func:`torch.transpose`."},{"l":"swapdims","k":"function","d":"(input, dim0, dim1) -> Tensor","s":"Alias for :func:`torch.transpose`."},{"l":"sym_constrain_range","k":"function"},{"l":"sym_constrain_range_for_size","k":"function"},{"l":"sym_float","k":"function","d":"(a)","s":"SymInt-aware utility for float casting."},{"l":"sym_fresh_size","k":"function","d":"(expr)"},{"l":"sym_int","k":"function","d":"(a)","s":"SymInt-aware utility for int casting."},{"l":"sym_ite","k":"function","d":"(b, t, f)","s":"SymInt-aware utility for ternary operator (``t if b else f``.)"},{"l":"sym_max","k":"function","d":"(a, b)","s":"SymInt-aware utility for max which avoids branching on a < b."},{"l":"sym_min","k":"function","d":"(a, b)","s":"SymInt-aware utility for min()."},{"l":"sym_not","k":"function","d":"(a)","s":"SymInt-aware utility for logical negation."},{"l":"sym_sqrt","k":"function","d":"(a)"},{"l":"sym_sum","k":"function","d":"(*args)","s":"N-ary add which is faster to compute for long lists than iterated binary"},{"l":"symeig","k":"function","d":"(input, eigenvectors=False, upper=True, *, out=None) -> tuple[torch.Tensor, torch.Tensor]"},{"l":"sys","k":"module"},{"l":"t","k":"function","d":"(input) -> Tensor","s":"Expects :attr:`input` to be <= 2-D tensor and transposes dimensions 0"},{"l":"t_copy","k":"function","s":"Performs the same operation as :func:`torch.t`, but all output tensors"},{"l":"take","k":"function","d":"(input, index) -> Tensor","s":"Returns a new tensor with the elements of :attr:`input` at the given indices."},{"l":"take_along_dim","k":"function","d":"(input, indices, dim=None, *, out=None) -> Tensor","s":"Selects values from :attr:`input` at the 1-dimensional indices from :attr:`indices` along the given :attr:`dim`."},{"l":"tan","k":"function","d":"(input, *, out=None) -> Tensor","s":"Returns a new tensor with the tangent of the elements in the :attr:`input` tensor,"},{"l":"tan_","k":"function"},{"l":"tanh","k":"function","d":"(input, *, out=None) -> Tensor","s":"Returns a new tensor with the hyperbolic tangent of the elements"},{"l":"tanh_","k":"function"},{"l":"tensor","k":"function","d":"(data, *, dtype=None, device=None, requires_grad=False, pin_memory=False) -> Tensor","s":"Constructs a tensor with no autograd history (also known as a \"leaf tensor\", see :doc:`/notes/autograd`) by copying :attr:`data`."},{"l":"tensor_split","k":"function","d":"(input, indices_or_sections, dim=0) -> List of Tensors","s":"Splits a tensor into multiple sub-tensors, all of which are views of :attr:`input`,"},{"l":"tensordot","k":"function","d":"(a, b, dims=2, out: torch.Tensor | None = None)","s":"Returns a contraction of a and b over multiple dimensions."},{"l":"testing","k":"module"},{"l":"textwrap","k":"module"},{"l":"thread_safe_generator","k":"function","d":"() -> torch._C.Generator | None","s":"Returns a thread-safe random number generator for use in DataLoader workers."},{"l":"threading","k":"module"},{"l":"threshold","k":"function"},{"l":"threshold_","k":"function","d":"(input, threshold, value) -> Tensor","s":"In-place version of :func:`~threshold`."},{"l":"tile","k":"function","d":"(input, dims) -> Tensor","s":"Constructs a tensor by repeating the elements of :attr:`input`."},{"l":"to_dlpack","k":"function","d":"(tensor) -> PyCapsule","s":"Returns an opaque object (a \"DLPack capsule\") representing the tensor."},{"l":"topk","k":"function","d":"(input, k, dim=None, largest=True, sorted=True, *, out=None) -> (Tensor, LongTensor)","s":"Returns the :attr:`k` largest elements of the given :attr:`input` tensor along"},{"l":"torch","k":"module"},{"l":"torch_version","k":"module"},{"l":"trace","k":"function","d":"(input) -> Tensor","s":"Returns the sum of the elements of the diagonal of the input 2-D matrix."},{"l":"transpose","k":"function","d":"(input, dim0, dim1) -> Tensor","s":"Returns a tensor that is a transposed version of :attr:`input`."},{"l":"transpose_copy","k":"function","s":"Performs the same operation as :func:`torch.transpose`, but all output tensors"},{"l":"trapezoid","k":"function","d":"(y, x=None, *, dx=None, dim=-1) -> Tensor","s":"Computes the `trapezoidal rule `_ along"},{"l":"trapz","k":"function","d":"(y, x=None, *, dim=-1) -> Tensor","s":"Alias for :func:`torch.trapezoid`."},{"l":"triangular_solve","k":"function","d":"(b, A, upper=True, transpose=False, unitriangular=False, *, out=None) -> (Tensor, Tensor)","s":"Solves a system of equations with a square upper or lower triangular invertible matrix :math:`A`"},{"l":"tril","k":"function","d":"(input, diagonal=0, *, out=None) -> Tensor","s":"Returns the lower triangular part of the matrix (2-D tensor) or batch of matrices"},{"l":"tril_indices","k":"function","d":"(row, col, offset=0, *, dtype=torch.long, device='cpu', layout=torch.strided) -> Tensor","s":"Returns the indices of the lower triangular part of a :attr:`row`-by-"},{"l":"triplet_margin_loss","k":"function"},{"l":"triu","k":"function","d":"(input, diagonal=0, *, out=None) -> Tensor","s":"Returns the upper triangular part of a matrix (2-D tensor) or batch of matrices"},{"l":"triu_indices","k":"function","d":"(row, col, offset=0, *, dtype=torch.long, device='cpu', layout=torch.strided) -> Tensor","s":"Returns the indices of the upper triangular part of a :attr:`row` by"},{"l":"true_divide","k":"function","d":"(dividend, divisor, *, out) -> Tensor","s":"Alias for :func:`torch.div` with ``rounding_mode=None``."},{"l":"trunc","k":"function","d":"(input, *, out=None) -> Tensor","s":"Returns a new tensor with the truncated integer values of"},{"l":"trunc_","k":"function"},{"l":"typename","k":"function","d":"(obj: Any, /) -> str","s":"String representation of the type of an object."},{"l":"types","k":"module"},{"l":"uint1","k":"constant","d":"torch.uint1"},{"l":"uint16","k":"constant","d":"torch.uint16"},{"l":"uint2","k":"constant","d":"torch.uint2"},{"l":"uint3","k":"constant","d":"torch.uint3"},{"l":"uint32","k":"constant","d":"torch.uint32"},{"l":"uint4","k":"constant","d":"torch.uint4"},{"l":"uint5","k":"constant","d":"torch.uint5"},{"l":"uint6","k":"constant","d":"torch.uint6"},{"l":"uint64","k":"constant","d":"torch.uint64"},{"l":"uint7","k":"constant","d":"torch.uint7"},{"l":"uint8","k":"constant","d":"torch.uint8"},{"l":"unbind","k":"function","d":"(input, dim=0) -> seq","s":"Removes a tensor dimension."},{"l":"unbind_copy","k":"function","s":"Performs the same operation as :func:`torch.unbind`, but all output tensors"},{"l":"unflatten","k":"function","d":"(input, dim, sizes) -> Tensor","s":"Expands a dimension of the input tensor over multiple dimensions."},{"l":"unfold_copy","k":"function","s":"Performs the same operation as :func:`torch.unfold`, but all output tensors"},{"l":"unify_type_list","k":"function","d":"(arg0: collections.abc.Sequence[c10::Type]) -> c10::Type"},{"l":"unique","k":"function","d":"(*args, **kwargs)","s":"Returns the unique elements of the input tensor."},{"l":"unique_consecutive","k":"function","d":"(*args, **kwargs)","s":"Eliminates all but the first element from every consecutive group of equivalent elements."},{"l":"unravel_index","k":"function","d":"(indices: torch.Tensor, shape: int | collections.abc.Sequence[int] | torch.Size) -> tuple[torch.Tensor, ...]","s":"Converts a tensor of flat indices into a tuple of coordinate tensors that"},{"l":"unsafe_chunk","k":"function","d":"(input, chunks, dim=0) -> List of Tensors","s":"Works like :func:`torch.chunk` but without enforcing the autograd restrictions"},{"l":"unsafe_split","k":"function","d":"(tensor, split_size_or_sections, dim=0) -> List of Tensors","s":"Works like :func:`torch.split` but without enforcing the autograd restrictions"},{"l":"unsafe_split_with_sizes","k":"function"},{"l":"unsqueeze","k":"function","d":"(input, dim) -> Tensor","s":"Returns a new tensor with a dimension of size one inserted at the"},{"l":"unsqueeze_copy","k":"function","s":"Performs the same operation as :func:`torch.unsqueeze`, but all output tensors"},{"l":"use_deterministic_algorithms","k":"function","d":"(mode: bool, *, warn_only: bool = False) -> None","s":"Sets whether PyTorch operations must use \"deterministic\""},{"l":"utils","k":"module"},{"l":"values_copy","k":"function","s":"Performs the same operation as :func:`torch.values`, but all output tensors"},{"l":"vander","k":"function","d":"(x, N=None, increasing=False) -> Tensor","s":"Generates a Vandermonde matrix."},{"l":"var","k":"function","d":"(input, dim=None, *, correction=1, keepdim=False, out=None) -> Tensor","s":"Calculates the variance over the dimensions specified by :attr:`dim`. :attr:`dim`"},{"l":"var_mean","k":"function","d":"(input, dim=None, *, correction=1, keepdim=False, out=None) -> (Tensor, Tensor)","s":"Calculates the variance and mean over the dimensions specified by :attr:`dim`."},{"l":"vdot","k":"function","d":"(input, other, *, out=None) -> Tensor","s":"Computes the dot product of two 1D vectors along a dimension."},{"l":"version","k":"module"},{"l":"view_as_complex","k":"function","d":"(input) -> Tensor","s":"Returns a view of :attr:`input` as a complex tensor. For an input complex"},{"l":"view_as_complex_copy","k":"function","s":"Performs the same operation as :func:`torch.view_as_complex`, but all output tensors"},{"l":"view_as_real","k":"function","d":"(input) -> Tensor","s":"Returns a view of :attr:`input` as a real tensor. For an input complex tensor of"},{"l":"view_as_real_copy","k":"function","s":"Performs the same operation as :func:`torch.view_as_real`, but all output tensors"},{"l":"view_copy","k":"function","s":"Performs the same operation as :func:`torch.view`, but all output tensors"},{"l":"vmap","k":"function","d":"(func: 'Callable[_P, _R]', in_dims: 'in_dims_t' = 0, out_dims: 'out_dims_t' = 0, randomness: 'str' = 'error', *, chunk_size: 'int | None' = None) -> 'Callable[_P, _R]'","s":"vmap is the vectorizing map; ``vmap(func)`` returns a new function that"},{"l":"vsplit","k":"function","d":"(input, indices_or_sections) -> List of Tensors","s":"Splits :attr:`input`, a tensor with two or more dimensions, into multiple tensors"},{"l":"vstack","k":"function","d":"(tensors, *, out=None) -> Tensor","s":"Stack tensors in sequence vertically (row wise)."},{"l":"wait","k":"function","d":"(arg0: torch._C.Future) -> object"},{"l":"warnings","k":"module"},{"l":"where","k":"function","d":"(condition, input, other, *, out=None) -> Tensor","s":"Return a tensor of elements selected from either :attr:`input` or :attr:`other`, depending on :attr:`condition`."},{"l":"while_loop","k":"function","d":"(cond_fn, body_fn, carried_inputs)","s":"Run ``body_fn(*carried_inputs)`` while ``cond_fn(*carried_inputs)`` returns"},{"l":"windows","k":"module"},{"l":"xlogy","k":"function","d":"(input, other, *, out=None) -> Tensor","s":"Alias for :func:`torch.special.xlogy`."},{"l":"xlogy_","k":"function"},{"l":"xpu","k":"module"},{"l":"zero_","k":"function"},{"l":"zeros","k":"function","d":"(*size, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor","s":"Returns a tensor filled with the scalar value `0`, with the shape defined"},{"l":"zeros_like","k":"function","d":"(input, *, dtype=None, layout=None, device=None, requires_grad=False, memory_format=torch.preserve_format) -> Tensor","s":"Returns a tensor filled with the scalar value `0`, with the same size as"}],"nn":[{"l":"AdaptiveAvgPool1d","k":"class","d":"(output_size: Union[int, NoneType, tuple[int | None, ...]]) -> None","s":"Applies a 1D adaptive average pooling over an input signal composed of several input planes."},{"l":"AdaptiveAvgPool2d","k":"class","d":"(output_size: Union[int, NoneType, tuple[int | None, ...]]) -> None","s":"Applies a 2D adaptive average pooling over an input signal composed of several input planes."},{"l":"AdaptiveAvgPool3d","k":"class","d":"(output_size: Union[int, NoneType, tuple[int | None, ...]]) -> None","s":"Applies a 3D adaptive average pooling over an input signal composed of several input planes."},{"l":"AdaptiveLogSoftmaxWithLoss","k":"class","d":"(in_features: int, n_classes: int, cutoffs: collections.abc.Sequence[int], div_value: float = 4.0, head_bias: bool = False, device=None, dtype=None) -> None","s":"Efficient softmax approximation."},{"l":"AdaptiveMaxPool1d","k":"class","d":"(output_size: Union[int, NoneType, tuple[int | None, ...]], return_indices: bool = False) -> None","s":"Applies a 1D adaptive max pooling over an input signal composed of several input planes."},{"l":"AdaptiveMaxPool2d","k":"class","d":"(output_size: Union[int, NoneType, tuple[int | None, ...]], return_indices: bool = False) -> None","s":"Applies a 2D adaptive max pooling over an input signal composed of several input planes."},{"l":"AdaptiveMaxPool3d","k":"class","d":"(output_size: Union[int, NoneType, tuple[int | None, ...]], return_indices: bool = False) -> None","s":"Applies a 3D adaptive max pooling over an input signal composed of several input planes."},{"l":"AlphaDropout","k":"class","d":"(p: float = 0.5, inplace: bool = False) -> None","s":"Applies Alpha Dropout over the input."},{"l":"AvgPool1d","k":"class","d":"(kernel_size: Union[int, tuple[int]], stride: Union[int, tuple[int]] = None, padding: Union[int, tuple[int]] = 0, ceil_mode: bool = False, count_include_pad: bool = True) -> None","s":"Applies a 1D average pooling over an input signal composed of several input planes."},{"l":"AvgPool2d","k":"class","d":"(kernel_size: Union[int, tuple[int, int]], stride: Union[int, tuple[int, int], NoneType] = None, padding: Union[int, tuple[int, int]] = 0, ceil_mode: bool = False, count_include_pad: bool = True, divisor_override: int | None = None) -> None","s":"Applies a 2D average pooling over an input signal composed of several input planes."},{"l":"AvgPool3d","k":"class","d":"(kernel_size: Union[int, tuple[int, int, int]], stride: Union[int, tuple[int, int, int], NoneType] = None, padding: Union[int, tuple[int, int, int]] = 0, ceil_mode: bool = False, count_include_pad: bool = True, divisor_override: int | None = None) -> None","s":"Applies a 3D average pooling over an input signal composed of several input planes."},{"l":"BCELoss","k":"class","d":"(weight: torch.Tensor | None = None, size_average=None, reduce=None, reduction: str = 'mean') -> None","s":"Creates a criterion that measures the Binary Cross Entropy between the target and"},{"l":"BCEWithLogitsLoss","k":"class","d":"(weight: torch.Tensor | None = None, size_average=None, reduce=None, reduction: str = 'mean', pos_weight: torch.Tensor | None = None) -> None","s":"This loss combines a `Sigmoid` layer and the `BCELoss` in one single"},{"l":"BatchNorm1d","k":"class","d":"(num_features: int, eps: float = 1e-05, momentum: float | None = 0.1, affine: bool = True, track_running_stats: bool = True, device=None, dtype=None, *, bias: bool = True) -> None","s":"Applies Batch Normalization over a 2D or 3D input."},{"l":"BatchNorm2d","k":"class","d":"(num_features: int, eps: float = 1e-05, momentum: float | None = 0.1, affine: bool = True, track_running_stats: bool = True, device=None, dtype=None, *, bias: bool = True) -> None","s":"Applies Batch Normalization over a 4D input."},{"l":"BatchNorm3d","k":"class","d":"(num_features: int, eps: float = 1e-05, momentum: float | None = 0.1, affine: bool = True, track_running_stats: bool = True, device=None, dtype=None, *, bias: bool = True) -> None","s":"Applies Batch Normalization over a 5D input."},{"l":"Bilinear","k":"class","d":"(in1_features: int, in2_features: int, out_features: int, bias: bool = True, device=None, dtype=None) -> None","s":"Applies a bilinear transformation to the incoming data: :math:`y = x_1^T A x_2 + b`."},{"l":"Buffer","k":"class","d":"(data=None, *, persistent=True)","s":"A kind of Tensor that should not be considered a model"},{"l":"CELU","k":"class","d":"(alpha: float = 1.0, inplace: bool = False) -> None","s":"Applies the CELU function element-wise."},{"l":"CTCLoss","k":"class","d":"(blank: int = 0, reduction: str = 'mean', zero_infinity: bool = False) -> None","s":"The Connectionist Temporal Classification loss."},{"l":"ChannelShuffle","k":"class","d":"(groups: int) -> None","s":"Divides and rearranges the channels in a tensor."},{"l":"CircularPad1d","k":"class","d":"(padding: Union[int, tuple[int, int]]) -> None","s":"Pads the input tensor using circular padding of the input boundary."},{"l":"CircularPad2d","k":"class","d":"(padding: Union[int, tuple[int, int, int, int]]) -> None","s":"Pads the input tensor using circular padding of the input boundary."},{"l":"CircularPad3d","k":"class","d":"(padding: Union[int, tuple[int, int, int, int, int, int]]) -> None","s":"Pads the input tensor using circular padding of the input boundary."},{"l":"ConstantPad1d","k":"class","d":"(padding: Union[int, tuple[int, int]], value: float) -> None","s":"Pads the input tensor boundaries with a constant value."},{"l":"ConstantPad2d","k":"class","d":"(padding: Union[int, tuple[int, int, int, int]], value: float) -> None","s":"Pads the input tensor boundaries with a constant value."},{"l":"ConstantPad3d","k":"class","d":"(padding: Union[int, tuple[int, int, int, int, int, int]], value: float) -> None","s":"Pads the input tensor boundaries with a constant value."},{"l":"Container","k":"class","d":"(*args, **kwargs)","s":"Base class for all neural network modules."},{"l":"Conv1d","k":"class","d":"(in_channels: int, out_channels: int, kernel_size: Union[int, tuple[int]], stride: Union[int, tuple[int]] = 1, padding: Union[str, int, tuple[int]] = 0, dilation: Union[int, tuple[int]] = 1, groups: int = 1, bias: bool = True, padding_mode: Literal['zeros', 'reflect', 'replicate', 'circular'] = 'zeros', device=None, dtype=None) -> None","s":"Applies a 1D convolution over an input signal composed of several input"},{"l":"Conv2d","k":"class","d":"(in_channels: int, out_channels: int, kernel_size: Union[int, tuple[int, int]], stride: Union[int, tuple[int, int]] = 1, padding: Union[str, int, tuple[int, int]] = 0, dilation: Union[int, tuple[int, int]] = 1, groups: int = 1, bias: bool = True, padding_mode: Literal['zeros', 'reflect', 'replicate', 'circular'] = 'zeros', device=None, dtype=None) -> None","s":"Applies a 2D convolution over an input signal composed of several input"},{"l":"Conv3d","k":"class","d":"(in_channels: int, out_channels: int, kernel_size: Union[int, tuple[int, int, int]], stride: Union[int, tuple[int, int, int]] = 1, padding: Union[str, int, tuple[int, int, int]] = 0, dilation: Union[int, tuple[int, int, int]] = 1, groups: int = 1, bias: bool = True, padding_mode: Literal['zeros', 'reflect', 'replicate', 'circular'] = 'zeros', device=None, dtype=None) -> None","s":"Applies a 3D convolution over an input signal composed of several input"},{"l":"ConvTranspose1d","k":"class","d":"(in_channels: int, out_channels: int, kernel_size: Union[int, tuple[int]], stride: Union[int, tuple[int]] = 1, padding: Union[int, tuple[int]] = 0, output_padding: Union[int, tuple[int]] = 0, groups: int = 1, bias: bool = True, dilation: Union[int, tuple[int]] = 1, padding_mode: Literal['zeros', 'reflect', 'replicate', 'circular'] = 'zeros', device=None, dtype=None) -> None","s":"Applies a 1D transposed convolution operator over an input image"},{"l":"ConvTranspose2d","k":"class","d":"(in_channels: int, out_channels: int, kernel_size: Union[int, tuple[int, int]], stride: Union[int, tuple[int, int]] = 1, padding: Union[int, tuple[int, int]] = 0, output_padding: Union[int, tuple[int, int]] = 0, groups: int = 1, bias: bool = True, dilation: Union[int, tuple[int, int]] = 1, padding_mode: Literal['zeros', 'reflect', 'replicate', 'circular'] = 'zeros', device=None, dtype=None) -> None","s":"Applies a 2D transposed convolution operator over an input image"},{"l":"ConvTranspose3d","k":"class","d":"(in_channels: int, out_channels: int, kernel_size: Union[int, tuple[int, int, int]], stride: Union[int, tuple[int, int, int]] = 1, padding: Union[int, tuple[int, int, int]] = 0, output_padding: Union[int, tuple[int, int, int]] = 0, groups: int = 1, bias: bool = True, dilation: Union[int, tuple[int, int, int]] = 1, padding_mode: Literal['zeros', 'reflect', 'replicate', 'circular'] = 'zeros', device=None, dtype=None) -> None","s":"Applies a 3D transposed convolution operator over an input image composed of several input"},{"l":"CosineEmbeddingLoss","k":"class","d":"(margin: float = 0.0, size_average=None, reduce=None, reduction: str = 'mean') -> None","s":"Creates a criterion that measures the loss given input tensors"},{"l":"CosineSimilarity","k":"class","d":"(dim: int = 1, eps: float = 1e-08) -> None","s":"Returns cosine similarity between :math:`x_1` and :math:`x_2`, computed along `dim`."},{"l":"CrossEntropyLoss","k":"class","d":"(weight: torch.Tensor | None = None, size_average=None, ignore_index: int = -100, reduce=None, reduction: str = 'mean', label_smoothing: float = 0.0) -> None","s":"This criterion computes the cross entropy loss between input logits"},{"l":"CrossMapLRN2d","k":"class","d":"(size: int, alpha: float = 0.0001, beta: float = 0.75, k: float = 1) -> None","s":"Base class for all neural network modules."},{"l":"DataParallel","k":"class","d":"(module: ~T, device_ids: collections.abc.Sequence[int | torch.device] | None = None, output_device: int | torch.device | None = None, dim: int = 0) -> None","s":"Implements data parallelism at the module level."},{"l":"Dropout","k":"class","d":"(p: float = 0.5, inplace: bool = False) -> None","s":"During training, randomly zeroes some of the elements of the input tensor with probability :attr:`p`."},{"l":"Dropout1d","k":"class","d":"(p: float = 0.5, inplace: bool = False) -> None","s":"Randomly zero out entire channels."},{"l":"Dropout2d","k":"class","d":"(p: float = 0.5, inplace: bool = False) -> None","s":"Randomly zero out entire channels."},{"l":"Dropout3d","k":"class","d":"(p: float = 0.5, inplace: bool = False) -> None","s":"Randomly zero out entire channels."},{"l":"ELU","k":"class","d":"(alpha: float = 1.0, inplace: bool = False) -> None","s":"Applies the Exponential Linear Unit (ELU) function, element-wise."},{"l":"Embedding","k":"class","d":"(num_embeddings: int, embedding_dim: int, padding_idx: int | None = None, max_norm: float | None = None, norm_type: float = 2.0, scale_grad_by_freq: bool = False, sparse: bool = False, _weight: torch.Tensor | None = None, _freeze: bool = False, device=None, dtype=None) -> None","s":"A simple lookup table that stores embeddings of a fixed dictionary and size."},{"l":"EmbeddingBag","k":"class","d":"(num_embeddings: int, embedding_dim: int, max_norm: float | None = None, norm_type: float = 2.0, scale_grad_by_freq: bool = False, mode: str = 'mean', sparse: bool = False, _weight: torch.Tensor | None = None, include_last_offset: bool = False, padding_idx: int | None = None, device=None, dtype=None) -> None","s":"Compute sums or means of 'bags' of embeddings, without instantiating the intermediate embeddings."},{"l":"FeatureAlphaDropout","k":"class","d":"(p: float = 0.5, inplace: bool = False) -> None","s":"Randomly masks out entire channels."},{"l":"Flatten","k":"class","d":"(start_dim: int = 1, end_dim: int = -1) -> None","s":"Flattens a contiguous range of dims into a tensor."},{"l":"Fold","k":"class","d":"(output_size: Union[int, tuple[int, ...]], kernel_size: Union[int, tuple[int, ...]], dilation: Union[int, tuple[int, ...]] = 1, padding: Union[int, tuple[int, ...]] = 0, stride: Union[int, tuple[int, ...]] = 1) -> None","s":"Combines an array of sliding local blocks into a large containing tensor."},{"l":"FractionalMaxPool2d","k":"class","d":"(kernel_size: Union[int, tuple[int, int]], output_size: Union[int, tuple[int, int], NoneType] = None, output_ratio: Union[float, tuple[float, float], NoneType] = None, return_indices: bool = False, _random_samples=None) -> None","s":"Applies a 2D fractional max pooling over an input signal composed of several input planes."},{"l":"FractionalMaxPool3d","k":"class","d":"(kernel_size: Union[int, tuple[int, int, int]], output_size: Union[int, tuple[int, int, int], NoneType] = None, output_ratio: Union[float, tuple[float, float, float], NoneType] = None, return_indices: bool = False, _random_samples=None) -> None","s":"Applies a 3D fractional max pooling over an input signal composed of several input planes."},{"l":"GELU","k":"class","d":"(approximate: str = 'none') -> None","s":"Applies the Gaussian Error Linear Units function."},{"l":"GLU","k":"class","d":"(dim: int = -1) -> None","s":"Applies the gated linear unit function."},{"l":"GRU","k":"class","d":"(*args, **kwargs)","s":"__init__(input_size,hidden_size,num_layers=1,bias=True,batch_first=False,dropout=0.0,bidirectional=False,device=None,dtype=None)"},{"l":"GRUCell","k":"class","d":"(input_size: int, hidden_size: int, bias: bool = True, device=None, dtype=None) -> None","s":"A gated recurrent unit (GRU) cell."},{"l":"GaussianNLLLoss","k":"class","d":"(*, full: bool = False, eps: float = 1e-06, reduction: str = 'mean') -> None","s":"Gaussian negative log likelihood loss."},{"l":"GroupNorm","k":"class","d":"(num_groups: int, num_channels: int, eps: float = 1e-05, affine: bool = True, device=None, dtype=None, *, bias: bool = True) -> None","s":"Applies Group Normalization over a mini-batch of inputs."},{"l":"Hardshrink","k":"class","d":"(lambd: float = 0.5) -> None","s":"Applies the Hard Shrinkage (Hardshrink) function element-wise."},{"l":"Hardsigmoid","k":"class","d":"(inplace: bool = False) -> None","s":"Applies the Hardsigmoid function element-wise."},{"l":"Hardswish","k":"class","d":"(inplace: bool = False) -> None","s":"Applies the Hardswish function, element-wise."},{"l":"Hardtanh","k":"class","d":"(min_val: float = -1.0, max_val: float = 1.0, inplace: bool = False, min_value: float | None = None, max_value: float | None = None) -> None","s":"Applies the HardTanh function element-wise."},{"l":"HingeEmbeddingLoss","k":"class","d":"(margin: float = 1.0, size_average=None, reduce=None, reduction: str = 'mean') -> None","s":"Measures the loss given an input tensor :math:`x` and a labels tensor :math:`y`"},{"l":"HuberLoss","k":"class","d":"(reduction: str = 'mean', delta: float = 1.0) -> None","s":"Creates a criterion that uses a squared term if the absolute"},{"l":"Identity","k":"class","d":"(*args: Any, **kwargs: Any) -> None","s":"A placeholder identity operator that is argument-insensitive."},{"l":"InstanceNorm1d","k":"class","d":"(num_features: int, eps: float = 1e-05, momentum: float = 0.1, affine: bool = False, track_running_stats: bool = False, device=None, dtype=None, *, bias: bool = True) -> None","s":"Applies Instance Normalization."},{"l":"InstanceNorm2d","k":"class","d":"(num_features: int, eps: float = 1e-05, momentum: float = 0.1, affine: bool = False, track_running_stats: bool = False, device=None, dtype=None, *, bias: bool = True) -> None","s":"Applies Instance Normalization."},{"l":"InstanceNorm3d","k":"class","d":"(num_features: int, eps: float = 1e-05, momentum: float = 0.1, affine: bool = False, track_running_stats: bool = False, device=None, dtype=None, *, bias: bool = True) -> None","s":"Applies Instance Normalization."},{"l":"KLDivLoss","k":"class","d":"(size_average=None, reduce=None, reduction: str = 'mean', log_target: bool = False) -> None","s":"The Kullback-Leibler divergence loss."},{"l":"L1Loss","k":"class","d":"(size_average=None, reduce=None, reduction: str = 'mean') -> None","s":"Creates a criterion that measures the mean absolute error (MAE) between each element in"},{"l":"LPPool1d","k":"class","d":"(norm_type: float, kernel_size: Union[int, tuple[int, ...]], stride: Union[int, tuple[int, ...], NoneType] = None, ceil_mode: bool = False) -> None","s":"Applies a 1D power-average pooling over an input signal composed of several input planes."},{"l":"LPPool2d","k":"class","d":"(norm_type: float, kernel_size: Union[int, tuple[int, ...]], stride: Union[int, tuple[int, ...], NoneType] = None, ceil_mode: bool = False) -> None","s":"Applies a 2D power-average pooling over an input signal composed of several input planes."},{"l":"LPPool3d","k":"class","d":"(norm_type: float, kernel_size: Union[int, tuple[int, ...]], stride: Union[int, tuple[int, ...], NoneType] = None, ceil_mode: bool = False) -> None","s":"Applies a 3D power-average pooling over an input signal composed of several input planes."},{"l":"LSTM","k":"class","d":"(*args, **kwargs)","s":"__init__(input_size,hidden_size,num_layers=1,bias=True,batch_first=False,dropout=0.0,bidirectional=False,proj_size=0,device=None,dtype=None)"},{"l":"LSTMCell","k":"class","d":"(input_size: int, hidden_size: int, bias: bool = True, device=None, dtype=None) -> None","s":"A long short-term memory (LSTM) cell."},{"l":"LayerNorm","k":"class","d":"(normalized_shape: int | list[int] | torch.Size, eps: float = 1e-05, elementwise_affine: bool = True, bias: bool = True, device=None, dtype=None) -> None","s":"Applies Layer Normalization over a mini-batch of inputs."},{"l":"LazyBatchNorm1d","k":"class","d":"(eps=1e-05, momentum=0.1, affine=True, track_running_stats=True, device=None, dtype=None, *, bias=True) -> None","s":"A :class:`torch.nn.BatchNorm1d` module with lazy initialization."},{"l":"LazyBatchNorm2d","k":"class","d":"(eps=1e-05, momentum=0.1, affine=True, track_running_stats=True, device=None, dtype=None, *, bias=True) -> None","s":"A :class:`torch.nn.BatchNorm2d` module with lazy initialization."},{"l":"LazyBatchNorm3d","k":"class","d":"(eps=1e-05, momentum=0.1, affine=True, track_running_stats=True, device=None, dtype=None, *, bias=True) -> None","s":"A :class:`torch.nn.BatchNorm3d` module with lazy initialization."},{"l":"LazyConv1d","k":"class","d":"(out_channels: int, kernel_size: Union[int, tuple[int]], stride: Union[int, tuple[int]] = 1, padding: Union[int, tuple[int]] = 0, dilation: Union[int, tuple[int]] = 1, groups: int = 1, bias: bool = True, padding_mode: Literal['zeros', 'reflect', 'replicate', 'circular'] = 'zeros', device=None, dtype=None) -> None","s":"A :class:`torch.nn.Conv1d` module with lazy initialization of the ``in_channels`` argument."},{"l":"LazyConv2d","k":"class","d":"(out_channels: int, kernel_size: Union[int, tuple[int, int]], stride: Union[int, tuple[int, int]] = 1, padding: Union[int, tuple[int, int]] = 0, dilation: Union[int, tuple[int, int]] = 1, groups: int = 1, bias: bool = True, padding_mode: Literal['zeros', 'reflect', 'replicate', 'circular'] = 'zeros', device=None, dtype=None) -> None","s":"A :class:`torch.nn.Conv2d` module with lazy initialization of the ``in_channels`` argument."},{"l":"LazyConv3d","k":"class","d":"(out_channels: int, kernel_size: Union[int, tuple[int, int, int]], stride: Union[int, tuple[int, int, int]] = 1, padding: Union[int, tuple[int, int, int]] = 0, dilation: Union[int, tuple[int, int, int]] = 1, groups: int = 1, bias: bool = True, padding_mode: Literal['zeros', 'reflect', 'replicate', 'circular'] = 'zeros', device=None, dtype=None) -> None","s":"A :class:`torch.nn.Conv3d` module with lazy initialization of the ``in_channels`` argument."},{"l":"LazyConvTranspose1d","k":"class","d":"(out_channels: int, kernel_size: Union[int, tuple[int]], stride: Union[int, tuple[int]] = 1, padding: Union[int, tuple[int]] = 0, output_padding: Union[int, tuple[int]] = 0, groups: int = 1, bias: bool = True, dilation: Union[int, tuple[int]] = 1, padding_mode: Literal['zeros', 'reflect', 'replicate', 'circular'] = 'zeros', device=None, dtype=None) -> None","s":"A :class:`torch.nn.ConvTranspose1d` module with lazy initialization of the ``in_channels`` argument."},{"l":"LazyConvTranspose2d","k":"class","d":"(out_channels: int, kernel_size: Union[int, tuple[int, int]], stride: Union[int, tuple[int, int]] = 1, padding: Union[int, tuple[int, int]] = 0, output_padding: Union[int, tuple[int, int]] = 0, groups: int = 1, bias: bool = True, dilation: int = 1, padding_mode: Literal['zeros', 'reflect', 'replicate', 'circular'] = 'zeros', device=None, dtype=None) -> None","s":"A :class:`torch.nn.ConvTranspose2d` module with lazy initialization of the ``in_channels`` argument."},{"l":"LazyConvTranspose3d","k":"class","d":"(out_channels: int, kernel_size: Union[int, tuple[int, int, int]], stride: Union[int, tuple[int, int, int]] = 1, padding: Union[int, tuple[int, int, int]] = 0, output_padding: Union[int, tuple[int, int, int]] = 0, groups: int = 1, bias: bool = True, dilation: Union[int, tuple[int, int, int]] = 1, padding_mode: Literal['zeros', 'reflect', 'replicate', 'circular'] = 'zeros', device=None, dtype=None) -> None","s":"A :class:`torch.nn.ConvTranspose3d` module with lazy initialization of the ``in_channels`` argument."},{"l":"LazyInstanceNorm1d","k":"class","d":"(eps=1e-05, momentum=0.1, affine=True, track_running_stats=True, device=None, dtype=None, *, bias=True) -> None","s":"A :class:`torch.nn.InstanceNorm1d` module with lazy initialization of the ``num_features`` argument."},{"l":"LazyInstanceNorm2d","k":"class","d":"(eps=1e-05, momentum=0.1, affine=True, track_running_stats=True, device=None, dtype=None, *, bias=True) -> None","s":"A :class:`torch.nn.InstanceNorm2d` module with lazy initialization of the ``num_features`` argument."},{"l":"LazyInstanceNorm3d","k":"class","d":"(eps=1e-05, momentum=0.1, affine=True, track_running_stats=True, device=None, dtype=None, *, bias=True) -> None","s":"A :class:`torch.nn.InstanceNorm3d` module with lazy initialization of the ``num_features`` argument."},{"l":"LazyLinear","k":"class","d":"(out_features: int, bias: bool = True, device=None, dtype=None) -> None","s":"A :class:`torch.nn.Linear` module where `in_features` is inferred."},{"l":"LeakyReLU","k":"class","d":"(negative_slope: float = 0.01, inplace: bool = False) -> None","s":"Applies the LeakyReLU function element-wise."},{"l":"Linear","k":"class","d":"(in_features: int, out_features: int, bias: bool = True, device=None, dtype=None) -> None","s":"Applies an affine linear transformation to the incoming data: :math:`y = xA^T + b`."},{"l":"LinearCrossEntropyLoss","k":"class","d":"(in_features: int, num_classes: int, *, out_features: tuple[int, ...] = (), bias: bool = False, device=None, dtype=None, reduction: str = 'mean', weight: torch.Tensor | None = None, ignore_index: int | None = None, label_smoothing: float = 0.0, options: torch.nn.modules.linear_cross_entropy_options.LinearCrossEntropyOptions | None = None) -> None","s":"This criterion computes the cross entropy loss between input,"},{"l":"LinearCrossEntropyOptions","k":"class","d":"(allow_retain_graph: bool = False, batch_chunk_size: int | None = None, chunking_method: str | None = 'auto', acc_policy: Literal['accurate', 'balanced', 'compact', 'auto'] = 'auto', acc_dtype: torch.dtype | None = None) -> None","s":"Configuration for the chunked implementation of"},{"l":"LocalResponseNorm","k":"class","d":"(size: int, alpha: float = 0.0001, beta: float = 0.75, k: float = 1.0) -> None","s":"Applies local response normalization over an input signal."},{"l":"LogSigmoid","k":"class","d":"(*args: Any, **kwargs: Any) -> None","s":"Applies the Logsigmoid function element-wise."},{"l":"LogSoftmax","k":"class","d":"(dim: int | None = None) -> None","s":"Applies the :math:`\\log(\\text{Softmax}(x))` function to an n-dimensional input Tensor."},{"l":"MSELoss","k":"class","d":"(size_average=None, reduce=None, reduction: str = 'mean') -> None","s":"Creates a criterion that measures the mean squared error (squared L2 norm) between"},{"l":"MarginRankingLoss","k":"class","d":"(margin: float = 0.0, size_average=None, reduce=None, reduction: str = 'mean') -> None","s":"Creates a criterion that measures the loss given"},{"l":"MaxPool1d","k":"class","d":"(kernel_size: Union[int, tuple[int, ...]], stride: Union[int, tuple[int, ...], NoneType] = None, padding: Union[int, tuple[int, ...]] = 0, dilation: Union[int, tuple[int, ...]] = 1, return_indices: bool = False, ceil_mode: bool = False) -> None","s":"Applies a 1D max pooling over an input signal composed of several input planes."},{"l":"MaxPool2d","k":"class","d":"(kernel_size: Union[int, tuple[int, ...]], stride: Union[int, tuple[int, ...], NoneType] = None, padding: Union[int, tuple[int, ...]] = 0, dilation: Union[int, tuple[int, ...]] = 1, return_indices: bool = False, ceil_mode: bool = False) -> None","s":"Applies a 2D max pooling over an input signal composed of several input planes."},{"l":"MaxPool3d","k":"class","d":"(kernel_size: Union[int, tuple[int, ...]], stride: Union[int, tuple[int, ...], NoneType] = None, padding: Union[int, tuple[int, ...]] = 0, dilation: Union[int, tuple[int, ...]] = 1, return_indices: bool = False, ceil_mode: bool = False) -> None","s":"Applies a 3D max pooling over an input signal composed of several input planes."},{"l":"MaxUnpool1d","k":"class","d":"(kernel_size: Union[int, tuple[int]], stride: Union[int, tuple[int], NoneType] = None, padding: Union[int, tuple[int]] = 0) -> None","s":"Computes a partial inverse of :class:`MaxPool1d`."},{"l":"MaxUnpool2d","k":"class","d":"(kernel_size: Union[int, tuple[int, int]], stride: Union[int, tuple[int, int], NoneType] = None, padding: Union[int, tuple[int, int]] = 0) -> None","s":"Computes a partial inverse of :class:`MaxPool2d`."},{"l":"MaxUnpool3d","k":"class","d":"(kernel_size: Union[int, tuple[int, int, int]], stride: Union[int, tuple[int, int, int], NoneType] = None, padding: Union[int, tuple[int, int, int]] = 0) -> None","s":"Computes a partial inverse of :class:`MaxPool3d`."},{"l":"Mish","k":"class","d":"(inplace: bool = False) -> None","s":"Applies the Mish function, element-wise."},{"l":"Module","k":"class","d":"(*args: Any, **kwargs: Any) -> None","s":"Base class for all neural network modules."},{"l":"ModuleDict","k":"class","d":"(modules: 'Mapping[str, Module] | None' = None) -> 'None'","s":"Holds submodules in a dictionary."},{"l":"ModuleList","k":"class","d":"(modules: 'Iterable[Module] | None' = None) -> 'None'","s":"Holds submodules in a list."},{"l":"MultiLabelMarginLoss","k":"class","d":"(size_average=None, reduce=None, reduction: str = 'mean') -> None","s":"Creates a criterion that optimizes a multi-class multi-classification"},{"l":"MultiLabelSoftMarginLoss","k":"class","d":"(weight: torch.Tensor | None = None, size_average=None, reduce=None, reduction: str = 'mean') -> None","s":"Creates a criterion that optimizes a multi-label one-versus-all"},{"l":"MultiMarginLoss","k":"class","d":"(p: int = 1, margin: float = 1.0, weight: torch.Tensor | None = None, size_average=None, reduce=None, reduction: str = 'mean') -> None","s":"Creates a criterion that optimizes a multi-class classification hinge"},{"l":"MultiheadAttention","k":"class","d":"(embed_dim, num_heads, dropout=0.0, bias=True, add_bias_kv=False, add_zero_attn=False, kdim=None, vdim=None, batch_first=False, device=None, dtype=None) -> None","s":"Allows the model to jointly attend to information from different representation subspaces."},{"l":"NLLLoss","k":"class","d":"(weight: torch.Tensor | None = None, size_average=None, ignore_index: int = -100, reduce=None, reduction: str = 'mean') -> None","s":"The negative log likelihood loss. It is useful to train a classification"},{"l":"NLLLoss2d","k":"class","d":"(*args, **kwargs)","s":"The negative log likelihood loss. It is useful to train a classification"},{"l":"PReLU","k":"class","d":"(num_parameters: int = 1, init: float = 0.25, device=None, dtype=None) -> None","s":"Applies the element-wise PReLU function."},{"l":"PairwiseDistance","k":"class","d":"(p: float = 2.0, eps: float = 1e-06, keepdim: bool = False) -> None","s":"Computes the pairwise distance between input vectors, or between columns of input matrices."},{"l":"Parameter","k":"class","d":"(data=None, requires_grad=True)","s":"A kind of Tensor that is to be considered a module parameter."},{"l":"ParameterDict","k":"class","d":"(parameters: 'Any' = None) -> 'None'","s":"Holds parameters in a dictionary."},{"l":"ParameterList","k":"class","d":"(values: 'Iterable[Any] | None' = None) -> 'None'","s":"Holds parameters in a list."},{"l":"PixelShuffle","k":"class","d":"(upscale_factor: int) -> None","s":"Rearrange elements in a tensor according to an upscaling factor."},{"l":"PixelUnshuffle","k":"class","d":"(downscale_factor: int) -> None","s":"Reverse the PixelShuffle operation."},{"l":"PoissonNLLLoss","k":"class","d":"(log_input: bool = True, full: bool = False, size_average=None, eps: float = 1e-08, reduce=None, reduction: str = 'mean') -> None","s":"Negative log likelihood loss with Poisson distribution of target."},{"l":"RMSNorm","k":"class","d":"(normalized_shape: int | list[int] | torch.Size, eps: float | None = None, elementwise_affine: bool = True, device=None, dtype=None) -> None","s":"Applies Root Mean Square Layer Normalization over a mini-batch of inputs."},{"l":"RNN","k":"class","d":"(*args, **kwargs)","s":"__init__(input_size,hidden_size,num_layers=1,nonlinearity='tanh',bias=True,batch_first=False,dropout=0.0,bidirectional=False,device=None,dtype=None)"},{"l":"RNNBase","k":"class","d":"(mode: str, input_size: int, hidden_size: int, num_layers: int = 1, bias: bool = True, batch_first: bool = False, dropout: float = 0.0, bidirectional: bool = False, proj_size: int = 0, device=None, dtype=None) -> None","s":"Base class for RNN modules (RNN, LSTM, GRU)."},{"l":"RNNCell","k":"class","d":"(input_size: int, hidden_size: int, bias: bool = True, nonlinearity: str = 'tanh', device=None, dtype=None) -> None","s":"An Elman RNN cell with tanh or ReLU non-linearity."},{"l":"RNNCellBase","k":"class","d":"(input_size: int, hidden_size: int, bias: bool, num_chunks: int, device=None, dtype=None) -> None","s":"Base class for all neural network modules."},{"l":"RReLU","k":"class","d":"(lower: float = 0.125, upper: float = 0.3333333333333333, inplace: bool = False) -> None","s":"Applies the randomized leaky rectified linear unit function, element-wise."},{"l":"ReLU","k":"class","d":"(inplace: bool = False) -> None","s":"Applies the rectified linear unit function element-wise."},{"l":"ReLU6","k":"class","d":"(inplace: bool = False) -> None","s":"Applies the ReLU6 function element-wise."},{"l":"ReflectionPad1d","k":"class","d":"(padding: Union[int, tuple[int, int]]) -> None","s":"Pads the input tensor using the reflection of the input boundary."},{"l":"ReflectionPad2d","k":"class","d":"(padding: Union[int, tuple[int, int, int, int]]) -> None","s":"Pads the input tensor using the reflection of the input boundary."},{"l":"ReflectionPad3d","k":"class","d":"(padding: Union[int, tuple[int, int, int, int, int, int]]) -> None","s":"Pads the input tensor using the reflection of the input boundary."},{"l":"ReplicationPad1d","k":"class","d":"(padding: Union[int, tuple[int, int]]) -> None","s":"Pads the input tensor using replication of the input boundary."},{"l":"ReplicationPad2d","k":"class","d":"(padding: Union[int, tuple[int, int, int, int]]) -> None","s":"Pads the input tensor using replication of the input boundary."},{"l":"ReplicationPad3d","k":"class","d":"(padding: Union[int, tuple[int, int, int, int, int, int]]) -> None","s":"Pads the input tensor using replication of the input boundary."},{"l":"SELU","k":"class","d":"(inplace: bool = False) -> None","s":"Applies the SELU function element-wise."},{"l":"Sequential","k":"class","d":"(*args)","s":"A sequential container."},{"l":"SiLU","k":"class","d":"(inplace: bool = False) -> None","s":"Applies the Sigmoid Linear Unit (SiLU) function, element-wise."},{"l":"Sigmoid","k":"class","d":"(*args: Any, **kwargs: Any) -> None","s":"Applies the Sigmoid function element-wise."},{"l":"SmoothL1Loss","k":"class","d":"(size_average=None, reduce=None, reduction: str = 'mean', beta: float = 1.0) -> None","s":"Creates a criterion that uses a squared term if the absolute"},{"l":"SoftMarginLoss","k":"class","d":"(size_average=None, reduce=None, reduction: str = 'mean') -> None","s":"Creates a criterion that optimizes a two-class classification"},{"l":"Softmax","k":"class","d":"(dim: int | None = None) -> None","s":"Applies the Softmax function to an n-dimensional input Tensor."},{"l":"Softmax2d","k":"class","d":"(*args: Any, **kwargs: Any) -> None","s":"Applies SoftMax over features to each spatial location."},{"l":"Softmin","k":"class","d":"(dim: int | None = None) -> None","s":"Applies the Softmin function to an n-dimensional input Tensor."},{"l":"Softplus","k":"class","d":"(beta: float = 1.0, threshold: float = 20.0) -> None","s":"Applies the Softplus function element-wise."},{"l":"Softshrink","k":"class","d":"(lambd: float = 0.5) -> None","s":"Applies the soft shrinkage function element-wise."},{"l":"Softsign","k":"class","d":"(*args: Any, **kwargs: Any) -> None","s":"Applies the element-wise Softsign function."},{"l":"SyncBatchNorm","k":"class","d":"(num_features: int, eps: float = 1e-05, momentum: float | None = 0.1, affine: bool = True, track_running_stats: bool = True, process_group: typing.Any | None = None, device=None, dtype=None, *, bias: bool = True) -> None","s":"Applies Batch Normalization over a N-Dimensional input."},{"l":"Tanh","k":"class","d":"(*args: Any, **kwargs: Any) -> None","s":"Applies the Hyperbolic Tangent (Tanh) function element-wise."},{"l":"Tanhshrink","k":"class","d":"(*args: Any, **kwargs: Any) -> None","s":"Applies the element-wise Tanhshrink function."},{"l":"Threshold","k":"class","d":"(threshold: float, value: float, inplace: bool = False) -> None","s":"Thresholds each element of the input Tensor."},{"l":"Transformer","k":"class","d":"(d_model: int = 512, nhead: int = 8, num_encoder_layers: int = 6, num_decoder_layers: int = 6, dim_feedforward: int = 2048, dropout: float = 0.1, activation: str | collections.abc.Callable[[torch.Tensor], torch.Tensor] = , custom_encoder: typing.Any | None = None, custom_decoder: typing.Any | None = None, layer_norm_eps: float = 1e-05, batch_first: bool = False, norm_first: bool = False, bias: bool = True, device=None, dtype=None) -> None","s":"A basic transformer layer."},{"l":"TransformerDecoder","k":"class","d":"(decoder_layer: 'TransformerDecoderLayer', num_layers: int, norm: torch.nn.modules.module.Module | None = None) -> None","s":"TransformerDecoder is a stack of N decoder layers."},{"l":"TransformerDecoderLayer","k":"class","d":"(d_model: int, nhead: int, dim_feedforward: int = 2048, dropout: float = 0.1, activation: str | collections.abc.Callable[[torch.Tensor], torch.Tensor] = , layer_norm_eps: float = 1e-05, batch_first: bool = False, norm_first: bool = False, bias: bool = True, device=None, dtype=None) -> None","s":"TransformerDecoderLayer is made up of self-attn, multi-head-attn and feedforward network."},{"l":"TransformerEncoder","k":"class","d":"(encoder_layer: 'TransformerEncoderLayer', num_layers: int, norm: torch.nn.modules.module.Module | None = None, enable_nested_tensor: bool = True, mask_check: bool = True) -> None","s":"TransformerEncoder is a stack of N encoder layers."},{"l":"TransformerEncoderLayer","k":"class","d":"(d_model: int, nhead: int, dim_feedforward: int = 2048, dropout: float = 0.1, activation: str | collections.abc.Callable[[torch.Tensor], torch.Tensor] = , layer_norm_eps: float = 1e-05, batch_first: bool = False, norm_first: bool = False, bias: bool = True, device=None, dtype=None) -> None","s":"TransformerEncoderLayer is made up of self-attn and feedforward network."},{"l":"TripletMarginLoss","k":"class","d":"(margin: float = 1.0, p: float = 2.0, eps: float = 1e-06, swap: bool = False, size_average=None, reduce=None, reduction: str = 'mean') -> None","s":"Creates a criterion that measures the triplet loss given an input"},{"l":"TripletMarginWithDistanceLoss","k":"class","d":"(*, distance_function: collections.abc.Callable[[torch.Tensor, torch.Tensor], torch.Tensor] | None = None, margin: float = 1.0, swap: bool = False, reduction: str = 'mean') -> None","s":"Creates a criterion that measures the triplet loss given input"},{"l":"Unflatten","k":"class","d":"(dim: int, unflattened_size: torch.Size | list[int] | tuple[int, ...]) -> None","s":"Unflattens a tensor dim expanding it to a desired shape. For use with :class:`~nn.Sequential`."},{"l":"Unfold","k":"class","d":"(kernel_size: Union[int, tuple[int, ...]], dilation: Union[int, tuple[int, ...]] = 1, padding: Union[int, tuple[int, ...]] = 0, stride: Union[int, tuple[int, ...]] = 1) -> None","s":"Extracts sliding local blocks from a batched input tensor."},{"l":"UninitializedBuffer","k":"class","d":"(requires_grad=False, device=None, dtype=None, persistent=True) -> None","s":"A buffer that is not initialized."},{"l":"UninitializedParameter","k":"class","d":"(requires_grad=True, device=None, dtype=None) -> None","s":"A parameter that is not initialized."},{"l":"Upsample","k":"class","d":"(size: Union[int, tuple[int, ...], NoneType] = None, scale_factor: Union[float, tuple[float, ...], NoneType] = None, mode: str = 'nearest', align_corners: bool | None = None, recompute_scale_factor: bool | None = None) -> None","s":"Upsamples a given multi-channel 1D (temporal), 2D (spatial) or 3D (volumetric) data."},{"l":"UpsamplingBilinear2d","k":"class","d":"(size: Union[int, tuple[int, int], NoneType] = None, scale_factor: Union[float, tuple[float, float], NoneType] = None) -> None","s":"Applies a 2D bilinear upsampling to an input signal composed of several input channels."},{"l":"UpsamplingNearest2d","k":"class","d":"(size: Union[int, tuple[int, int], NoneType] = None, scale_factor: Union[float, tuple[float, float], NoneType] = None) -> None","s":"Applies a 2D nearest neighbor upsampling to an input signal composed of several input channels."},{"l":"ZeroPad1d","k":"class","d":"(padding: Union[int, tuple[int, int]]) -> None","s":"Pads the input tensor boundaries with zero."},{"l":"ZeroPad2d","k":"class","d":"(padding: Union[int, tuple[int, int, int, int]]) -> None","s":"Pads the input tensor boundaries with zero."},{"l":"ZeroPad3d","k":"class","d":"(padding: Union[int, tuple[int, int, int, int, int, int]]) -> None","s":"Pads the input tensor boundaries with zero."},{"l":"attention","k":"module"},{"l":"common_types","k":"module"},{"l":"factory_kwargs","k":"function","d":"(kwargs)","s":"Return a canonicalized dict of factory kwargs."},{"l":"functional","k":"module"},{"l":"grad","k":"module"},{"l":"init","k":"module"},{"l":"intrinsic","k":"module"},{"l":"modules","k":"module"},{"l":"parallel","k":"module"},{"l":"parameter","k":"module"},{"l":"qat","k":"module"},{"l":"quantizable","k":"module"},{"l":"quantized","k":"module"},{"l":"utils","k":"module"}],"F":[{"l":"BroadcastingList1","k":"constant"},{"l":"BroadcastingList2","k":"constant"},{"l":"BroadcastingList3","k":"constant"},{"l":"Callable","k":"class","d":"()"},{"l":"DType","k":"class","s":"int([x]) -> integer"},{"l":"GRID_SAMPLE_INTERPOLATION_MODES","k":"constant","d":"{'bilinear': 0, 'nearest': 1, 'bicubic': 2}"},{"l":"GRID_SAMPLE_PADDING_MODES","k":"constant","d":"{'zeros': 0, 'border': 1, 'reflection': 2}"},{"l":"Optional","k":"function","d":"(*args, **kwds)","s":"Optional[X] is equivalent to Union[X, None]."},{"l":"ScalingType","k":"class","s":"Supported Tensor scaling types"},{"l":"SwizzleType","k":"class","s":"Supported scale swizzle types"},{"l":"TYPE_CHECKING","k":"constant","d":"False"},{"l":"Tensor","k":"class"},{"l":"adaptive_avg_pool1d","k":"function","d":"(input, output_size) -> Tensor","s":"Applies a 1D adaptive average pooling over an input signal composed of"},{"l":"adaptive_avg_pool2d","k":"function","d":"(input: torch.Tensor, output_size: None) -> torch.Tensor","s":"Apply a 2D adaptive average pooling over an input signal composed of several input planes."},{"l":"adaptive_avg_pool3d","k":"function","d":"(input: torch.Tensor, output_size: None) -> torch.Tensor","s":"Apply a 3D adaptive average pooling over an input signal composed of several input planes."},{"l":"adaptive_max_pool1d","k":"function","d":"(*args, **kwargs)","s":"Applies a 1D adaptive max pooling over an input signal composed of"},{"l":"adaptive_max_pool1d_with_indices","k":"function","d":"(input: torch.Tensor, output_size: None, return_indices: bool = False) -> tuple[torch.Tensor, torch.Tensor]","s":"adaptive_max_pool1d(input, output_size, return_indices=False)"},{"l":"adaptive_max_pool2d","k":"function","d":"(*args, **kwargs)","s":"Applies a 2D adaptive max pooling over an input signal composed of"},{"l":"adaptive_max_pool2d_with_indices","k":"function","d":"(input: torch.Tensor, output_size: None, return_indices: bool = False) -> tuple[torch.Tensor, torch.Tensor]","s":"adaptive_max_pool2d(input, output_size, return_indices=False)"},{"l":"adaptive_max_pool3d","k":"function","d":"(*args, **kwargs)","s":"Applies a 3D adaptive max pooling over an input signal composed of"},{"l":"adaptive_max_pool3d_with_indices","k":"function","d":"(input: torch.Tensor, output_size: None, return_indices: bool = False) -> tuple[torch.Tensor, torch.Tensor]","s":"adaptive_max_pool3d(input, output_size, return_indices=False)"},{"l":"affine_grid","k":"function","d":"(theta: torch.Tensor, size: list[int], align_corners: bool | None = None) -> torch.Tensor","s":"Generate 2D or 3D flow field (sampling grid), given a batch of affine matrices :attr:`theta`."},{"l":"alpha_dropout","k":"function","d":"(input: torch.Tensor, p: float = 0.5, training: bool = False, inplace: bool = False) -> torch.Tensor","s":"Apply alpha dropout to the input."},{"l":"assert_int_or_pair","k":"function","d":"(arg: list[int], arg_name: str, message: str) -> None"},{"l":"avg_pool1d","k":"function","d":"(input, kernel_size, stride=None, padding=0, ceil_mode=False, count_include_pad=True) -> Tensor","s":"Applies a 1D average pooling over an input signal composed of several"},{"l":"avg_pool2d","k":"function","d":"(input, kernel_size, stride=None, padding=0, ceil_mode=False, count_include_pad=True, divisor_override=None) -> Tensor","s":"Applies 2D average-pooling operation in :math:`kH \\times kW` regions by step size"},{"l":"avg_pool3d","k":"function","d":"(input, kernel_size, stride=None, padding=0, ceil_mode=False, count_include_pad=True, divisor_override=None) -> Tensor","s":"Applies 3D average-pooling operation in :math:`kT \\times kH \\times kW` regions by step"},{"l":"batch_norm","k":"function","d":"(input: torch.Tensor, running_mean: torch.Tensor | None, running_var: torch.Tensor | None, weight: torch.Tensor | None = None, bias: torch.Tensor | None = None, training: bool = False, momentum: float = 0.1, eps: float = 1e-05) -> torch.Tensor","s":"Apply Batch Normalization for each channel across a batch of data."},{"l":"bilinear","k":"function","d":"(input1, input2, weight, bias=None) -> Tensor","s":"Applies a bilinear transformation to the incoming data:"},{"l":"binary_cross_entropy","k":"function","d":"(input: torch.Tensor, target: torch.Tensor, weight: torch.Tensor | None = None, size_average: bool | None = None, reduce: bool | None = None, reduction: str = 'mean') -> torch.Tensor","s":"Compute Binary Cross Entropy between the target and input probabilities."},{"l":"binary_cross_entropy_with_logits","k":"function","d":"(input: torch.Tensor, target: torch.Tensor, weight: torch.Tensor | None = None, size_average: bool | None = None, reduce: bool | None = None, reduction: str = 'mean', pos_weight: torch.Tensor | None = None) -> torch.Tensor","s":"Compute Binary Cross Entropy between target and input logits."},{"l":"boolean_dispatch","k":"function","d":"(arg_name, arg_index, default, if_true, if_false, module_name, func_name)","s":"Dispatches to either of 2 script functions based on a boolean argument."},{"l":"celu","k":"function","d":"(input: torch.Tensor, alpha: float = 1.0, inplace: bool = False) -> torch.Tensor","s":"Applies element-wise,"},{"l":"celu_","k":"function","d":"(input, alpha=1.) -> Tensor","s":"In-place version of :func:`~celu`."},{"l":"channel_shuffle","k":"function","d":"(input, groups) -> Tensor","s":"Divide the channels in a tensor of shape :math:`(*, C , H, W)`"},{"l":"conv1d","k":"function","d":"(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1) -> Tensor","s":"Applies a 1D convolution over an input signal composed of several input"},{"l":"conv2d","k":"function","d":"(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1) -> Tensor","s":"Applies a 2D convolution over an input image composed of several input"},{"l":"conv3d","k":"function","d":"(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1) -> Tensor","s":"Applies a 3D convolution over an input image composed of several input"},{"l":"conv_tbc","k":"function","s":"Applies a 1-dimensional sequence convolution over an input sequence."},{"l":"conv_transpose1d","k":"function","d":"(input, weight, bias=None, stride=1, padding=0, output_padding=0, groups=1, dilation=1) -> Tensor","s":"Applies a 1D transposed convolution operator over an input signal"},{"l":"conv_transpose2d","k":"function","d":"(input, weight, bias=None, stride=1, padding=0, output_padding=0, groups=1, dilation=1) -> Tensor","s":"Applies a 2D transposed convolution operator over an input image"},{"l":"conv_transpose3d","k":"function","d":"(input, weight, bias=None, stride=1, padding=0, output_padding=0, groups=1, dilation=1) -> Tensor","s":"Applies a 3D transposed convolution operator over an input image"},{"l":"cosine_embedding_loss","k":"function","d":"(input1: torch.Tensor, input2: torch.Tensor, target: torch.Tensor, margin: float = 0, size_average: bool | None = None, reduce: bool | None = None, reduction: str = 'mean') -> torch.Tensor","s":"Compute the cosine embedding loss."},{"l":"cosine_similarity","k":"function","d":"(x1, x2, dim=1, eps=1e-8) -> Tensor","s":"Returns cosine similarity between ``x1`` and ``x2``, computed along dim. ``x1`` and ``x2`` must be broadcastable"},{"l":"cross_entropy","k":"function","d":"(input: torch.Tensor, target: torch.Tensor, weight: torch.Tensor | None = None, size_average: bool | None = None, ignore_index: int = -100, reduce: bool | None = None, reduction: str = 'mean', label_smoothing: float = 0.0) -> torch.Tensor","s":"Compute the cross entropy loss between input logits and target."},{"l":"ctc_loss","k":"function","d":"(log_probs: torch.Tensor, targets: torch.Tensor, input_lengths: torch.Tensor, target_lengths: torch.Tensor, blank: int = 0, reduction: str = 'mean', zero_infinity: bool = False) -> torch.Tensor","s":"Compute the Connectionist Temporal Classification loss."},{"l":"dataclasses","k":"module"},{"l":"dropout","k":"function","d":"(input: torch.Tensor, p: float = 0.5, training: bool = True, inplace: bool = False) -> torch.Tensor","s":"During training, randomly zeroes some elements of the input tensor with probability :attr:`p`."},{"l":"dropout1d","k":"function","d":"(input: torch.Tensor, p: float = 0.5, training: bool = True, inplace: bool = False) -> torch.Tensor","s":"Randomly zero out entire channels (a channel is a 1D feature map)."},{"l":"dropout2d","k":"function","d":"(input: torch.Tensor, p: float = 0.5, training: bool = True, inplace: bool = False) -> torch.Tensor","s":"Randomly zero out entire channels (a channel is a 2D feature map)."},{"l":"dropout3d","k":"function","d":"(input: torch.Tensor, p: float = 0.5, training: bool = True, inplace: bool = False) -> torch.Tensor","s":"Randomly zero out entire channels (a channel is a 3D feature map)."},{"l":"elu","k":"function","d":"(input: torch.Tensor, alpha: float = 1.0, inplace: bool = False) -> torch.Tensor","s":"Apply the Exponential Linear Unit (ELU) function element-wise."},{"l":"elu_","k":"function","d":"(input, alpha=1.) -> Tensor","s":"In-place version of :func:`~elu`."},{"l":"embedding","k":"function","d":"(input: torch.Tensor, weight: torch.Tensor, padding_idx: int | None = None, max_norm: float | None = None, norm_type: float = 2.0, scale_grad_by_freq: bool = False, sparse: bool = False) -> torch.Tensor","s":"Generate a simple lookup table that looks up embeddings in a fixed dictionary and size."},{"l":"embedding_bag","k":"function","d":"(input: torch.Tensor, weight: torch.Tensor, offsets: torch.Tensor | None = None, max_norm: float | None = None, norm_type: float = 2, scale_grad_by_freq: bool = False, mode: str = 'mean', sparse: bool = False, per_sample_weights: torch.Tensor | None = None, include_last_offset: bool = False, padding_idx: int | None = None) -> torch.Tensor","s":"Compute sums, means or maxes of `bags` of embeddings."},{"l":"feature_alpha_dropout","k":"function","d":"(input: torch.Tensor, p: float = 0.5, training: bool = False, inplace: bool = False) -> torch.Tensor","s":"Randomly masks out entire channels (a channel is a feature map)."},{"l":"fold","k":"function","d":"(input: torch.Tensor, output_size: None, kernel_size: None, dilation: None = 1, padding: None = 0, stride: None = 1) -> torch.Tensor","s":"Combine an array of sliding local blocks into a large containing tensor."},{"l":"fractional_max_pool2d","k":"function","d":"(*args, **kwargs)","s":"Applies 2D fractional max pooling over an input signal composed of several input planes."},{"l":"fractional_max_pool2d_with_indices","k":"function","d":"(input: torch.Tensor, kernel_size: None, output_size: NoneType = None, output_ratio: NoneType = None, return_indices: bool = False, _random_samples: torch.Tensor | None = None) -> tuple[torch.Tensor, torch.Tensor]","s":"fractional_max_pool2d(input, kernel_size, output_size=None, output_ratio=None, return_indices=False, _random_samples=None)"},{"l":"fractional_max_pool3d","k":"function","d":"(*args, **kwargs)","s":"Applies 3D fractional max pooling over an input signal composed of several input planes."},{"l":"fractional_max_pool3d_with_indices","k":"function","d":"(input: torch.Tensor, kernel_size: None, output_size: NoneType = None, output_ratio: NoneType = None, return_indices: bool = False, _random_samples: torch.Tensor | None = None) -> tuple[torch.Tensor, torch.Tensor]","s":"fractional_max_pool3d(input, kernel_size, output_size=None, output_ratio=None, return_indices=False, _random_samples=None)"},{"l":"gaussian_nll_loss","k":"function","d":"(input: torch.Tensor, target: torch.Tensor, var: torch.Tensor | float, full: bool = False, eps: float = 1e-06, reduction: str = 'mean') -> torch.Tensor","s":"Compute the Gaussian negative log likelihood loss."},{"l":"gelu","k":"function","d":"(input, approximate = 'none') -> Tensor","s":"When the approximate argument is 'none', it applies element-wise the function"},{"l":"glu","k":"function","d":"(input: torch.Tensor, dim: int = -1) -> torch.Tensor","s":"The gated linear unit. Computes:"},{"l":"grad","k":"module"},{"l":"grid_sample","k":"function","d":"(input: torch.Tensor, grid: torch.Tensor, mode: str = 'bilinear', padding_mode: str = 'zeros', align_corners: bool | None = None) -> torch.Tensor","s":"Compute grid sample."},{"l":"group_norm","k":"function","d":"(input: torch.Tensor, num_groups: int, weight: torch.Tensor | None = None, bias: torch.Tensor | None = None, eps: float = 1e-05) -> torch.Tensor","s":"Apply Group Normalization for last certain number of dimensions."},{"l":"grouped_mm","k":"function","d":"(mat_a: torch.Tensor, mat_b: torch.Tensor, *, offs: torch.Tensor | None = None, bias: torch.Tensor | None = None, out_dtype: torch.dtype | None = None) -> torch.Tensor","s":"Computes a grouped matrix multiply that shares weight shapes across experts but"},{"l":"gumbel_softmax","k":"function","d":"(logits: torch.Tensor, tau: float = 1, hard: bool = False, eps: float = 1e-10, dim: int = -1) -> torch.Tensor","s":"Sample from the Gumbel-Softmax distribution (`Link 1`_ `Link 2`_) and optionally discretize."},{"l":"handle_torch_function","k":"function","d":"(public_api: collections.abc.Callable[~_P, ~_R], relevant_args: collections.abc.Iterable[typing.Any], *args: _P.args, **kwargs: _P.kwargs) -> ~_R","s":"Implement a function with checks for ``__torch_function__`` overrides."},{"l":"hardshrink","k":"function","d":"(input, lambd=0.5) -> Tensor","s":"Applies the hard shrinkage function element-wise"},{"l":"hardsigmoid","k":"function","d":"(input: torch.Tensor, inplace: bool = False) -> torch.Tensor","s":"Apply the Hardsigmoid function element-wise."},{"l":"hardswish","k":"function","d":"(input: torch.Tensor, inplace: bool = False) -> torch.Tensor","s":"Apply hardswish function, element-wise."},{"l":"hardtanh","k":"function","d":"(input: torch.Tensor, min_val: float = -1.0, max_val: float = 1.0, inplace: bool = False) -> torch.Tensor","s":"Applies the HardTanh function element-wise. See :class:`~torch.nn.Hardtanh` for more"},{"l":"hardtanh_","k":"function","d":"(input, min_val=-1., max_val=1.) -> Tensor","s":"In-place version of :func:`~hardtanh`."},{"l":"has_torch_function","k":"function","s":"Check for __torch_function__ implementations in the elements of an iterable"},{"l":"has_torch_function_unary","k":"function","s":"Special case of `has_torch_function` for single inputs."},{"l":"has_torch_function_variadic","k":"function","s":"Special case of `has_torch_function` that skips tuple creation."},{"l":"hinge_embedding_loss","k":"function","d":"(input: torch.Tensor, target: torch.Tensor, margin: float = 1.0, size_average: bool | None = None, reduce: bool | None = None, reduction: str = 'mean') -> torch.Tensor","s":"Compute the hinge embedding loss."},{"l":"huber_loss","k":"function","d":"(input: torch.Tensor, target: torch.Tensor, reduction: str = 'mean', delta: float = 1.0, weight: torch.Tensor | None = None) -> torch.Tensor","s":"Compute the Huber loss, with optional weighting."},{"l":"importlib","k":"module"},{"l":"instance_norm","k":"function","d":"(input: torch.Tensor, running_mean: torch.Tensor | None = None, running_var: torch.Tensor | None = None, weight: torch.Tensor | None = None, bias: torch.Tensor | None = None, use_input_stats: bool = True, momentum: float = 0.1, eps: float = 1e-05) -> torch.Tensor","s":"Apply Instance Normalization independently for each channel in every data sample within a batch."},{"l":"interpolate","k":"function","d":"(input: torch.Tensor, size: int | None = None, scale_factor: list[float] | None = None, mode: str = 'nearest', align_corners: bool | None = None, recompute_scale_factor: bool | None = None, antialias: bool = False) -> torch.Tensor","s":"Down/up samples the input."},{"l":"kl_div","k":"function","d":"(input: torch.Tensor, target: torch.Tensor, size_average: bool | None = None, reduce: bool | None = None, reduction: str = 'mean', log_target: bool = False) -> torch.Tensor","s":"Compute the KL Divergence loss."},{"l":"l1_loss","k":"function","d":"(input: torch.Tensor, target: torch.Tensor, size_average: bool | None = None, reduce: bool | None = None, reduction: str = 'mean', weight: torch.Tensor | None = None) -> torch.Tensor","s":"Compute the L1 loss, with optional weighting."},{"l":"layer_norm","k":"function","d":"(input: torch.Tensor, normalized_shape: list[int], weight: torch.Tensor | None = None, bias: torch.Tensor | None = None, eps: float = 1e-05) -> torch.Tensor","s":"Apply Layer Normalization for last certain number of dimensions."},{"l":"leaky_relu","k":"function","d":"(input: torch.Tensor, negative_slope: float = 0.01, inplace: bool = False) -> torch.Tensor","s":"Applies element-wise,"},{"l":"leaky_relu_","k":"function","d":"(input, negative_slope=0.01) -> Tensor","s":"In-place version of :func:`~leaky_relu`."},{"l":"linear","k":"function","d":"(input, weight, bias=None) -> Tensor","s":"Applies a linear transformation to the incoming data: :math:`y = xA^T + b`."},{"l":"linear_cross_entropy","k":"function","d":"(input: torch.Tensor, linear_weight: torch.Tensor, target: torch.Tensor, *, linear_bias: torch.Tensor | None = None, weight: torch.Tensor | None = None, reduction: str = 'mean', ignore_index: int | None = None, label_smoothing: float = 0.0, options: 'LinearCrossEntropyOptions | None' = None) -> torch.Tensor","s":"Compute the cross entropy loss between inputs, transformed linearly, and target."},{"l":"local_response_norm","k":"function","d":"(input: torch.Tensor, size: int, alpha: float = 0.0001, beta: float = 0.75, k: float = 1.0) -> torch.Tensor","s":"Apply local response normalization over an input signal."},{"l":"log_softmax","k":"function","d":"(input: torch.Tensor, dim: int | None = None, _stacklevel: int = 3, dtype: int | None = None) -> torch.Tensor","s":"Apply a softmax followed by a logarithm."},{"l":"logsigmoid","k":"function","d":"(input) -> Tensor","s":"Applies element-wise :math:`\\text{LogSigmoid}(x_i) = \\log \\left(\\frac{1}{1 + \\exp(-x_i)}\\right)`"},{"l":"lp_pool1d","k":"function","d":"(input: torch.Tensor, norm_type: int | float, kernel_size: int, stride: NoneType = None, ceil_mode: bool = False) -> torch.Tensor","s":"Apply a 1D power-average pooling over an input signal composed of several input planes."},{"l":"lp_pool2d","k":"function","d":"(input: torch.Tensor, norm_type: int | float, kernel_size: None, stride: NoneType = None, ceil_mode: bool = False) -> torch.Tensor","s":"Apply a 2D power-average pooling over an input signal composed of several input planes."},{"l":"lp_pool3d","k":"function","d":"(input: torch.Tensor, norm_type: int | float, kernel_size: None, stride: NoneType = None, ceil_mode: bool = False) -> torch.Tensor","s":"Apply a 3D power-average pooling over an input signal composed of several input planes."},{"l":"margin_ranking_loss","k":"function","d":"(input1: torch.Tensor, input2: torch.Tensor, target: torch.Tensor, margin: float = 0, size_average: bool | None = None, reduce: bool | None = None, reduction: str = 'mean') -> torch.Tensor","s":"Compute the margin ranking loss."},{"l":"math","k":"module"},{"l":"max_pool1d","k":"function","d":"(*args, **kwargs)","s":"Applies a 1D max pooling over an input signal composed of several input"},{"l":"max_pool1d_with_indices","k":"function","d":"(input: torch.Tensor, kernel_size: None, stride: NoneType = None, padding: None = 0, dilation: None = 1, ceil_mode: bool = False, return_indices: bool = False) -> tuple[torch.Tensor, torch.Tensor]","s":"max_pool1d(input, kernel_size, stride=None, padding=0, dilation=1, ceil_mode=False, return_indices=False)"},{"l":"max_pool2d","k":"function","d":"(*args, **kwargs)","s":"Applies a 2D max pooling over an input signal composed of several input"},{"l":"max_pool2d_with_indices","k":"function","d":"(input: torch.Tensor, kernel_size: None, stride: NoneType = None, padding: None = 0, dilation: None = 1, ceil_mode: bool = False, return_indices: bool = False) -> tuple[torch.Tensor, torch.Tensor]","s":"max_pool2d(input, kernel_size, stride=None, padding=0, dilation=1, ceil_mode=False, return_indices=False)"},{"l":"max_pool3d","k":"function","d":"(*args, **kwargs)","s":"Applies a 3D max pooling over an input signal composed of several input"},{"l":"max_pool3d_with_indices","k":"function","d":"(input: torch.Tensor, kernel_size: None, stride: NoneType = None, padding: None = 0, dilation: None = 1, ceil_mode: bool = False, return_indices: bool = False) -> tuple[torch.Tensor, torch.Tensor]","s":"max_pool3d(input, kernel_size, stride=None, padding=0, dilation=1, ceil_mode=False, return_indices=False)"},{"l":"max_unpool1d","k":"function","d":"(input: torch.Tensor, indices: torch.Tensor, kernel_size: None, stride: NoneType = None, padding: None = 0, output_size: NoneType = None) -> torch.Tensor","s":"Compute a partial inverse of :class:`MaxPool1d`."},{"l":"max_unpool2d","k":"function","d":"(input: torch.Tensor, indices: torch.Tensor, kernel_size: None, stride: NoneType = None, padding: None = 0, output_size: NoneType = None) -> torch.Tensor","s":"Compute a partial inverse of :class:`MaxPool2d`."},{"l":"max_unpool3d","k":"function","d":"(input: torch.Tensor, indices: torch.Tensor, kernel_size: None, stride: NoneType = None, padding: None = 0, output_size: NoneType = None) -> torch.Tensor","s":"Compute a partial inverse of :class:`MaxPool3d`."},{"l":"mish","k":"function","d":"(input: torch.Tensor, inplace: bool = False) -> torch.Tensor","s":"Apply the Mish function, element-wise."},{"l":"mse_loss","k":"function","d":"(input: torch.Tensor, target: torch.Tensor, size_average: bool | None = None, reduce: bool | None = None, reduction: str = 'mean', weight: torch.Tensor | None = None) -> torch.Tensor","s":"Compute the element-wise mean squared error, with optional weighting."},{"l":"multi_head_attention_forward","k":"function","d":"(query: torch.Tensor, key: torch.Tensor, value: torch.Tensor, embed_dim_to_check: int, num_heads: int, in_proj_weight: torch.Tensor | None, in_proj_bias: torch.Tensor | None, bias_k: torch.Tensor | None, bias_v: torch.Tensor | None, add_zero_attn: bool, dropout_p: float, out_proj_weight: torch.Tensor, out_proj_bias: torch.Tensor | None, training: bool = True, key_padding_mask: torch.Tensor | None = None, need_weights: bool = True, attn_mask: torch.Tensor | None = None, use_separate_proj_weight: bool = False, q_proj_weight: torch.Tensor | None = None, k_proj_weight: torch.Tensor | None = None, v_proj_weight: torch.Tensor | None = None, static_k: torch.Tensor | None = None, static_v: torch.Tensor | None = None, average_attn_weights: bool = True, is_causal: bool = False) -> tuple[torch.Tensor, torch.Tensor | None]","s":"Forward method for MultiHeadAttention."},{"l":"multi_margin_loss","k":"function","d":"(input: torch.Tensor, target: torch.Tensor, p: int = 1, margin: float = 1.0, weight: torch.Tensor | None = None, size_average: bool | None = None, reduce: bool | None = None, reduction: str = 'mean') -> torch.Tensor","s":"Compute the multi margin loss, with optional weighting."},{"l":"multilabel_margin_loss","k":"function","d":"(input: torch.Tensor, target: torch.Tensor, size_average: bool | None = None, reduce: bool | None = None, reduction: str = 'mean') -> torch.Tensor","s":"Compute the multilabel margin loss."},{"l":"multilabel_soft_margin_loss","k":"function","d":"(input: torch.Tensor, target: torch.Tensor, weight: torch.Tensor | None = None, size_average: bool | None = None, reduce: bool | None = None, reduction: str = 'mean') -> torch.Tensor","s":"Compute the multilabel soft margin loss."},{"l":"native_channel_shuffle","k":"function","d":"(input, groups) -> Tensor","s":"Native kernel level implementation of the `channel_shuffle`."},{"l":"nll_loss","k":"function","d":"(input: torch.Tensor, target: torch.Tensor, weight: torch.Tensor | None = None, size_average: bool | None = None, ignore_index: int = -100, reduce: bool | None = None, reduction: str = 'mean') -> torch.Tensor","s":"Compute the negative log likelihood loss."},{"l":"normalize","k":"function","d":"(input: torch.Tensor, p: float = 2.0, dim: int = 1, eps: float = 1e-12, out: torch.Tensor | None = None) -> torch.Tensor","s":"Perform :math:`L_p` normalization of inputs over specified dimension."},{"l":"np","k":"module"},{"l":"one_hot","k":"function","d":"(tensor, num_classes=-1) -> LongTensor","s":"Takes LongTensor with index values of shape ``(*)`` and returns a tensor"},{"l":"pad","k":"function","d":"(input: torch.Tensor, pad: list[int], mode: str = 'constant', value: float | None = None) -> torch.Tensor","s":"Pads tensor."},{"l":"pairwise_distance","k":"function","d":"(x1, x2, p=2.0, eps=1e-6, keepdim=False) -> Tensor","s":"See :class:`torch.nn.PairwiseDistance` for details"},{"l":"pdist","k":"function","d":"(input, p=2) -> Tensor","s":"Computes the p-norm distance between every pair of row vectors in the input."},{"l":"pixel_shuffle","k":"function","d":"(input, upscale_factor) -> Tensor","s":"Rearranges elements in a tensor of shape :math:`(*, C \\times r^2, H, W)` to a"},{"l":"pixel_unshuffle","k":"function","d":"(input, downscale_factor) -> Tensor","s":"Reverses the :class:`~torch.nn.PixelShuffle` operation by rearranging elements in a"},{"l":"poisson_nll_loss","k":"function","d":"(input: torch.Tensor, target: torch.Tensor, log_input: bool = True, full: bool = False, size_average: bool | None = None, eps: float = 1e-08, reduce: bool | None = None, reduction: str = 'mean') -> torch.Tensor","s":"Compute the Poisson negative log likelihood loss."},{"l":"prelu","k":"function","d":"(input, weight) -> Tensor","s":"Applies element-wise the function"},{"l":"relu","k":"function","d":"(input: torch.Tensor, inplace: bool = False) -> torch.Tensor","s":"Applies the rectified linear unit function element-wise. See"},{"l":"relu6","k":"function","d":"(input: torch.Tensor, inplace: bool = False) -> torch.Tensor","s":"Applies the element-wise function :math:`\\text{ReLU6}(x) = \\min(\\max(0,x), 6)`."},{"l":"relu_","k":"function","d":"(input) -> Tensor","s":"In-place version of :func:`~relu`."},{"l":"reproducibility_notes","k":"constant"},{"l":"rms_norm","k":"function","d":"(input: torch.Tensor, normalized_shape: list[int], weight: torch.Tensor | None = None, eps: float | None = None) -> torch.Tensor","s":"Apply Root Mean Square Layer Normalization."},{"l":"rrelu","k":"function","d":"(input: torch.Tensor, lower: float = 0.125, upper: float = 0.3333333333333333, training: bool = False, inplace: bool = False) -> torch.Tensor","s":"Randomized leaky ReLU."},{"l":"rrelu_","k":"function","d":"(input, lower=1./8, upper=1./3, training=False) -> Tensor","s":"In-place version of :func:`~rrelu`."},{"l":"scaled_dot_product_attention","k":"function","s":"Computes scaled dot product attention on query, key and value tensors, using an optional attention mask if passed,"},{"l":"scaled_grouped_mm","k":"function","d":"(mat_a: torch.Tensor, mat_b: torch.Tensor, scale_a: torch.Tensor | list[torch.Tensor], scale_recipe_a: torch.nn.functional._ScalingType | list[torch.nn.functional._ScalingType], scale_b: torch.Tensor | list[torch.Tensor], scale_recipe_b: torch.nn.functional._ScalingType | list[torch.nn.functional._ScalingType], swizzle_a: torch.nn.functional._SwizzleType | list[torch.nn.functional._SwizzleType] | None = None, swizzle_b: torch.nn.functional._SwizzleType | list[torch.nn.functional._SwizzleType] | None = None, bias: torch.Tensor | None = None, offs: torch.Tensor | None = None, output_dtype: torch.dtype | None = torch.bfloat16, contraction_dim: list[int] | tuple[int, ...] = (), use_fast_accum: bool = False) -> torch.Tensor","s":"Applies a grouped scaled matrix-multiply, grouped_mm(mat_a, mat_b) where the scaling of mat_a and mat_b are described by"},{"l":"scaled_mm","k":"function","d":"(mat_a: torch.Tensor, mat_b: torch.Tensor, scale_a: torch.Tensor | list[torch.Tensor], scale_recipe_a: torch.nn.functional._ScalingType | list[torch.nn.functional._ScalingType], scale_b: torch.Tensor | list[torch.Tensor], scale_recipe_b: torch.nn.functional._ScalingType | list[torch.nn.functional._ScalingType], swizzle_a: torch.nn.functional._SwizzleType | list[torch.nn.functional._SwizzleType] | None = None, swizzle_b: torch.nn.functional._SwizzleType | list[torch.nn.functional._SwizzleType] | None = None, bias: torch.Tensor | None = None, output_dtype: torch.dtype | None = torch.bfloat16, contraction_dim: list[int] | tuple[int, ...] = (), use_fast_accum: bool = False) -> torch.Tensor","s":"Applies a scaled matrix-multiply, mm(mat_a, mat_b) where the scaling of mat_a and mat_b are described by"},{"l":"selu","k":"function","d":"(input: torch.Tensor, inplace: bool = False) -> torch.Tensor","s":"Applies element-wise,"},{"l":"selu_","k":"function","d":"(input) -> Tensor","s":"In-place version of :func:`~selu`."},{"l":"sigmoid","k":"function","d":"(input)","s":"Applies the element-wise function :math:`\\text{Sigmoid}(x) = \\frac{1}{1 + \\exp(-x)}`"},{"l":"silu","k":"function","d":"(input: torch.Tensor, inplace: bool = False) -> torch.Tensor","s":"Apply the Sigmoid Linear Unit (SiLU) function, element-wise."},{"l":"smooth_l1_loss","k":"function","d":"(input: torch.Tensor, target: torch.Tensor, size_average: bool | None = None, reduce: bool | None = None, reduction: str = 'mean', beta: float = 1.0) -> torch.Tensor","s":"Compute the Smooth L1 loss."},{"l":"soft_margin_loss","k":"function","d":"(input: torch.Tensor, target: torch.Tensor, size_average: bool | None = None, reduce: bool | None = None, reduction: str = 'mean') -> torch.Tensor","s":"Compute the soft margin loss."},{"l":"softmax","k":"function","d":"(input: torch.Tensor, dim: int | None = None, _stacklevel: int = 3, dtype: int | None = None) -> torch.Tensor","s":"Apply a softmax function."},{"l":"softmin","k":"function","d":"(input: torch.Tensor, dim: int | None = None, _stacklevel: int = 3, dtype: int | None = None) -> torch.Tensor","s":"Apply a softmin function."},{"l":"softplus","k":"function","d":"(input, beta=1, threshold=20) -> Tensor","s":"Applies element-wise, the function :math:`\\text{Softplus}(x) = \\frac{1}{\\beta} * \\log(1 + \\exp(\\beta * x))`."},{"l":"softshrink","k":"function","d":"(input, lambd=0.5) -> Tensor","s":"Applies the soft shrinkage function elementwise"},{"l":"softsign","k":"function","d":"(input)","s":"Applies element-wise, the function :math:`\\text{SoftSign}(x) = \\frac{x}{1 + |x|}`"},{"l":"sparse_support_notes","k":"constant"},{"l":"tanh","k":"function","d":"(input)","s":"Applies element-wise,"},{"l":"tanhshrink","k":"function","d":"(input)","s":"Applies element-wise, :math:`\\text{Tanhshrink}(x) = x - \\text{Tanh}(x)`"},{"l":"tf32_notes","k":"constant"},{"l":"threshold","k":"function","d":"(input: torch.Tensor, threshold: float, value: float, inplace: bool = False) -> torch.Tensor","s":"Apply a threshold to each element of the input Tensor."},{"l":"threshold_","k":"function","d":"(input, threshold, value) -> Tensor","s":"In-place version of :func:`~threshold`."},{"l":"torch","k":"module"},{"l":"triplet_margin_loss","k":"function","d":"(anchor: torch.Tensor, positive: torch.Tensor, negative: torch.Tensor, margin: float = 1.0, p: float = 2, eps: float = 1e-06, swap: bool = False, size_average: bool | None = None, reduce: bool | None = None, reduction: str = 'mean') -> torch.Tensor","s":"Compute the triplet loss between given input tensors and a margin greater than 0."},{"l":"triplet_margin_with_distance_loss","k":"function","d":"(anchor: torch.Tensor, positive: torch.Tensor, negative: torch.Tensor, *, distance_function: collections.abc.Callable[[torch.Tensor, torch.Tensor], torch.Tensor] | None = None, margin: float = 1.0, swap: bool = False, reduction: str = 'mean') -> torch.Tensor","s":"Compute the triplet margin loss for input tensors using a custom distance function."},{"l":"unfold","k":"function","d":"(input: torch.Tensor, kernel_size: None, dilation: None = 1, padding: None = 0, stride: None = 1) -> torch.Tensor","s":"Extract sliding local blocks from a batched input tensor."},{"l":"upsample","k":"function","d":"(input, size=None, scale_factor=None, mode='nearest', align_corners=None)","s":"Upsample input."},{"l":"upsample_bilinear","k":"function","d":"(input, size=None, scale_factor=None)","s":"Upsamples the input, using bilinear upsampling."},{"l":"upsample_nearest","k":"function","d":"(input, size=None, scale_factor=None)","s":"Upsamples the input, using nearest neighbours' pixel values."},{"l":"warnings","k":"module"}],"np":[{"l":"False_","k":"constant","d":"np.False_"},{"l":"ScalarType","k":"constant"},{"l":"True_","k":"constant","d":"np.True_"},{"l":"abs","k":"function","d":"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"absolute(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])"},{"l":"absolute","k":"function","d":"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Calculate the absolute value element-wise."},{"l":"acos","k":"function","d":"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"arccos(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])"},{"l":"acosh","k":"function","d":"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"arccosh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])"},{"l":"add","k":"function","d":"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Add arguments element-wise."},{"l":"all","k":"function","d":"(a, axis=None, out=None, keepdims=, *, where=)","s":"Test whether all array elements along a given axis evaluate to True."},{"l":"allclose","k":"function","d":"(a, b, rtol=1e-05, atol=1e-08, equal_nan=False)","s":"Returns True if two arrays are element-wise equal within a tolerance."},{"l":"amax","k":"function","d":"(a, axis=None, out=None, keepdims=, initial=, where=)","s":"Return the maximum of an array or maximum along an axis."},{"l":"amin","k":"function","d":"(a, axis=None, out=None, keepdims=, initial=, where=)","s":"Return the minimum of an array or minimum along an axis."},{"l":"angle","k":"function","d":"(z, deg=False)","s":"Return the angle of the complex argument."},{"l":"any","k":"function","d":"(a, axis=None, out=None, keepdims=, *, where=)","s":"Test whether any array element along a given axis evaluates to True."},{"l":"append","k":"function","d":"(arr, values, axis=None)","s":"Append values to the end of an array."},{"l":"apply_along_axis","k":"function","d":"(func1d, axis, arr, *args, **kwargs)","s":"Apply a function to 1-D slices along the given axis."},{"l":"apply_over_axes","k":"function","d":"(func, a, axes)","s":"Apply a function repeatedly over multiple axes."},{"l":"arange","k":"function","d":"(start_or_stop, /, stop=None, step=1, *, dtype=None, device=None, like=None)","s":"Return evenly spaced values within a given interval."},{"l":"arccos","k":"function","d":"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Trigonometric inverse cosine, element-wise."},{"l":"arccosh","k":"function","d":"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Inverse hyperbolic cosine, element-wise."},{"l":"arcsin","k":"function","d":"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Inverse sine, element-wise."},{"l":"arcsinh","k":"function","d":"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Inverse hyperbolic sine element-wise."},{"l":"arctan","k":"function","d":"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Trigonometric inverse tangent, element-wise."},{"l":"arctan2","k":"function","d":"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Element-wise arc tangent of ``x1/x2`` choosing the quadrant correctly."},{"l":"arctanh","k":"function","d":"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Inverse hyperbolic tangent element-wise."},{"l":"argmax","k":"function","d":"(a, axis=None, out=None, *, keepdims=)","s":"Returns the indices of the maximum values along an axis."},{"l":"argmin","k":"function","d":"(a, axis=None, out=None, *, keepdims=)","s":"Returns the indices of the minimum values along an axis."},{"l":"argpartition","k":"function","d":"(a, kth, axis=-1, kind='introselect', order=None)","s":"Perform an indirect partition along the given axis using the"},{"l":"argsort","k":"function","d":"(a, axis=-1, kind=None, order=None, *, stable=None)","s":"Returns the indices that would sort an array."},{"l":"argwhere","k":"function","d":"(a)","s":"Find the indices of array elements that are non-zero, grouped by element."},{"l":"around","k":"function","d":"(a, decimals=0, out=None)","s":"Round an array to the given number of decimals."},{"l":"array","k":"function","d":"(object, dtype=None, *, copy=True, order='K', subok=False, ndmin=0, ndmax=0, like=None)","s":"Create an array."},{"l":"array2string","k":"function","d":"(a, max_line_width=None, precision=None, suppress_small=None, separator=' ', prefix='', *, formatter=None, threshold=None, edgeitems=None, sign=None, floatmode=None, suffix='', legacy=None)","s":"Return a string representation of an array."},{"l":"array_equal","k":"function","d":"(a1, a2, equal_nan=False)","s":"True if two arrays have the same shape and elements, False otherwise."},{"l":"array_equiv","k":"function","d":"(a1, a2)","s":"Returns True if input arrays are shape consistent and all elements equal."},{"l":"array_repr","k":"function","d":"(arr, max_line_width=None, precision=None, suppress_small=None)","s":"Return the string representation of an array."},{"l":"array_split","k":"function","d":"(ary, indices_or_sections, axis=0)","s":"Split an array into multiple sub-arrays."},{"l":"array_str","k":"function","d":"(a, max_line_width=None, precision=None, suppress_small=None)","s":"Return a string representation of the data in an array."},{"l":"asanyarray","k":"function","d":"(a, dtype=None, order=None, *, device=None, copy=None, like=None)","s":"Convert the input to an ndarray, but pass ndarray subclasses through."},{"l":"asarray","k":"function","d":"(a, dtype=None, order=None, *, device=None, copy=None, like=None)","s":"Convert the input to an array."},{"l":"asarray_chkfinite","k":"function","d":"(a, dtype=None, order=None)","s":"Convert the input to an array, checking for NaNs or Infs."},{"l":"ascontiguousarray","k":"function","d":"(a, dtype=None, *, like=None)","s":"Return a contiguous array (ndim >= 1) in memory (C order)."},{"l":"asfortranarray","k":"function","d":"(a, dtype=None, *, like=None)","s":"Return an array (ndim >= 1) laid out in Fortran order in memory."},{"l":"asin","k":"function","d":"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"arcsin(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])"},{"l":"asinh","k":"function","d":"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"arcsinh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])"},{"l":"asmatrix","k":"function","d":"(data, dtype=None)","s":"Interpret the input as a matrix."},{"l":"astype","k":"function","d":"(x, dtype, /, *, copy=True, device=None)","s":"Copies an array to a specified data type."},{"l":"atan","k":"function","d":"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"arctan(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])"},{"l":"atan2","k":"function","d":"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"arctan2(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])"},{"l":"atanh","k":"function","d":"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"arctanh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])"},{"l":"atleast_1d","k":"function","d":"(*arys)","s":"Convert inputs to arrays with at least one dimension."},{"l":"atleast_2d","k":"function","d":"(*arys)","s":"View inputs as arrays with at least two dimensions."},{"l":"atleast_3d","k":"function","d":"(*arys)","s":"View inputs as arrays with at least three dimensions."},{"l":"average","k":"function","d":"(a, axis=None, weights=None, returned=False, *, keepdims=)","s":"Compute the weighted average along the specified axis."},{"l":"bartlett","k":"function","d":"(M)","s":"Return the Bartlett window."},{"l":"base_repr","k":"function","d":"(number, base=2, padding=0)","s":"Return a string representation of a number in the given base system."},{"l":"binary_repr","k":"function","d":"(num, width=None)","s":"Return the binary representation of the input number as a string."},{"l":"bincount","k":"function","d":"(x, /, weights=None, minlength=0)","s":"Count number of occurrences of each value in array of non-negative ints."},{"l":"bitwise_and","k":"function","d":"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Compute the bit-wise AND of two arrays element-wise."},{"l":"bitwise_count","k":"function","d":"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Computes the number of 1-bits in the absolute value of ``x``."},{"l":"bitwise_invert","k":"function","d":"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"invert(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])"},{"l":"bitwise_left_shift","k":"function","d":"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"left_shift(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])"},{"l":"bitwise_not","k":"function","d":"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"invert(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])"},{"l":"bitwise_or","k":"function","d":"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Compute the bit-wise OR of two arrays element-wise."},{"l":"bitwise_right_shift","k":"function","d":"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"right_shift(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])"},{"l":"bitwise_xor","k":"function","d":"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Compute the bit-wise XOR of two arrays element-wise."},{"l":"blackman","k":"function","d":"(M)","s":"Return the Blackman window."},{"l":"block","k":"function","d":"(arrays)","s":"Assemble an nd-array from nested lists of blocks."},{"l":"bmat","k":"function","d":"(obj, ldict=None, gdict=None)","s":"Build a matrix object from a string, nested sequence, or array."},{"l":"bool","k":"class","d":"(value=False, /)","s":"Boolean type (True or False), stored as a byte."},{"l":"bool_","k":"class","d":"(value=False, /)","s":"Boolean type (True or False), stored as a byte."},{"l":"broadcast","k":"class","d":"(*arrays)","s":"Produce an object that mimics broadcasting."},{"l":"broadcast_arrays","k":"function","d":"(*args, subok=False)","s":"Broadcast any number of arrays against each other."},{"l":"broadcast_shapes","k":"function","d":"(*args)","s":"Broadcast the input shapes into a single shape."},{"l":"broadcast_to","k":"function","d":"(array, shape, subok=False)","s":"Broadcast an array to a new shape."},{"l":"busday_count","k":"function","d":"(begindates, enddates, weekmask='1111100', holidays=(), busdaycal=None, out=None)","s":"Counts the number of valid days between `begindates` and"},{"l":"busday_offset","k":"function","d":"(dates, offsets, roll='raise', weekmask='1111100', holidays=None, busdaycal=None, out=None)","s":"First adjusts the date to fall on a valid day according to"},{"l":"busdaycalendar","k":"class","d":"(weekmask='1111100', holidays=None)","s":"A business day calendar object that efficiently stores information"},{"l":"byte","k":"class","d":"(value=0, /)","s":"Signed integer type, compatible with C ``char``."},{"l":"bytes_","k":"class","d":"(value='', /, *args, **kwargs)","s":"A byte string."},{"l":"c_","k":"constant"},{"l":"can_cast","k":"function","d":"(from_, to, casting='safe')","s":"Returns True if cast between data types can occur according to the"},{"l":"cbrt","k":"function","d":"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Return the cube-root of an array, element-wise."},{"l":"cdouble","k":"class","d":"(real=0, imag=0, /)","s":"Complex number type composed of two double-precision floating-point numbers,"},{"l":"ceil","k":"function","d":"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Return the ceiling of the input, element-wise."},{"l":"char","k":"module"},{"l":"character","k":"class","d":"()","s":"Abstract base class of all character string scalar types."},{"l":"choose","k":"function","d":"(a, choices, out=None, mode='raise')","s":"Construct an array from an index array and a list of arrays to choose from."},{"l":"clip","k":"function","d":"(a, a_min=, a_max=, out=None, *, min=, max=, **kwargs)","s":"Clip (limit) the values in an array."},{"l":"clongdouble","k":"class","d":"(real=0, imag=0, /)","s":"Complex number type composed of two extended-precision floating-point numbers."},{"l":"column_stack","k":"function","d":"(tup)","s":"Stack 1-D arrays as columns into a 2-D array."},{"l":"common_type","k":"function","d":"(*arrays)","s":"Return a scalar type which is common to the input arrays."},{"l":"complex128","k":"class","d":"(real=0, imag=0, /)","s":"Complex number type composed of two double-precision floating-point numbers,"},{"l":"complex256","k":"class","d":"(real=0, imag=0, /)","s":"Complex number type composed of two extended-precision floating-point numbers."},{"l":"complex64","k":"class","d":"(real=0, imag=0, /)","s":"Complex number type composed of two single-precision floating-point numbers."},{"l":"complexfloating","k":"class","d":"()","s":"Abstract base class of all complex number scalar types that are made up of"},{"l":"compress","k":"function","d":"(condition, a, axis=None, out=None)","s":"Return selected slices of an array along given axis."},{"l":"concat","k":"function","d":"(arrays, /, axis=0, out=None, *, dtype=None, casting='same_kind')","s":"Join a sequence of arrays along an existing axis."},{"l":"concatenate","k":"function","d":"(arrays, /, axis=0, out=None, *, dtype=None, casting='same_kind')","s":"Join a sequence of arrays along an existing axis."},{"l":"conj","k":"function","d":"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"conjugate(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])"},{"l":"conjugate","k":"function","d":"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Return the complex conjugate, element-wise."},{"l":"convolve","k":"function","d":"(a, v, mode='full')","s":"Returns the discrete, linear convolution of two one-dimensional sequences."},{"l":"copy","k":"function","d":"(a, order='K', subok=False)","s":"Return an array copy of the given object."},{"l":"copysign","k":"function","d":"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Change the sign of x1 to that of x2, element-wise."},{"l":"copyto","k":"function","d":"(dst, src, casting='same_kind', where=True)","s":"Copies values from one array to another, broadcasting as necessary."},{"l":"core","k":"module"},{"l":"corrcoef","k":"function","d":"(x, y=None, rowvar=True, *, dtype=None)","s":"Return Pearson product-moment correlation coefficients."},{"l":"correlate","k":"function","d":"(a, v, mode='valid')","s":"Cross-correlation of two 1-dimensional sequences."},{"l":"cos","k":"function","d":"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Cosine element-wise."},{"l":"cosh","k":"function","d":"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Hyperbolic cosine, element-wise."},{"l":"count_nonzero","k":"function","d":"(a, axis=None, *, keepdims=False)","s":"Counts the number of non-zero values in the array ``a``."},{"l":"cov","k":"function","d":"(m, y=None, rowvar=True, bias=False, ddof=None, fweights=None, aweights=None, *, dtype=None)","s":"Estimate a covariance matrix, given data and weights."},{"l":"cross","k":"function","d":"(a, b, axisa=-1, axisb=-1, axisc=-1, axis=None)","s":"Return the cross product of two (arrays of) vectors."},{"l":"csingle","k":"class","d":"(real=0, imag=0, /)","s":"Complex number type composed of two single-precision floating-point numbers."},{"l":"ctypeslib","k":"module"},{"l":"cumprod","k":"function","d":"(a, axis=None, dtype=None, out=None)","s":"Return the cumulative product of elements along a given axis."},{"l":"cumsum","k":"function","d":"(a, axis=None, dtype=None, out=None)","s":"Return the cumulative sum of the elements along a given axis."},{"l":"cumulative_prod","k":"function","d":"(x, /, *, axis=None, dtype=None, out=None, include_initial=False)","s":"Return the cumulative product of elements along a given axis."},{"l":"cumulative_sum","k":"function","d":"(x, /, *, axis=None, dtype=None, out=None, include_initial=False)","s":"Return the cumulative sum of the elements along a given axis."},{"l":"datetime64","k":"class","d":"(value=None, /, *args)","s":"If created from a 64-bit integer, it represents an offset from ``1970-01-01T00:00:00``."},{"l":"datetime_as_string","k":"function","d":"(arr, unit=None, timezone='naive', casting='same_kind')","s":"Convert an array of datetimes into an array of strings."},{"l":"datetime_data","k":"function","d":"(dtype, /)","s":"Get information about the step size of a date or time type."},{"l":"deg2rad","k":"function","d":"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Convert angles from degrees to radians."},{"l":"degrees","k":"function","d":"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Convert angles from radians to degrees."},{"l":"delete","k":"function","d":"(arr, obj, axis=None)","s":"Return a new array with sub-arrays along an axis deleted. For a one"},{"l":"diag","k":"function","d":"(v, k=0)","s":"Extract a diagonal or construct a diagonal array."},{"l":"diag_indices","k":"function","d":"(n, ndim=2)","s":"Return the indices to access the main diagonal of an array."},{"l":"diag_indices_from","k":"function","d":"(arr)","s":"Return the indices to access the main diagonal of an n-dimensional array."},{"l":"diagflat","k":"function","d":"(v, k=0)","s":"Create a two-dimensional array with the flattened input as a diagonal."},{"l":"diagonal","k":"function","d":"(a, offset=0, axis1=0, axis2=1)","s":"Return specified diagonals."},{"l":"diff","k":"function","d":"(a, n=1, axis=-1, prepend=, append=)","s":"Calculate the n-th discrete difference along the given axis."},{"l":"digitize","k":"function","d":"(x, bins, right=False)","s":"Return the indices of the bins to which each value in input array belongs."},{"l":"divide","k":"function","d":"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Divide arguments element-wise."},{"l":"divmod","k":"function","d":"(x1, x2, /, out=(None, None), *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Return element-wise quotient and remainder simultaneously."},{"l":"dot","k":"function","d":"(a, b, out=None)","s":"Dot product of two arrays. Specifically,"},{"l":"double","k":"class","d":"(value=0, /)","s":"Double-precision floating-point number type, compatible with Python :class:`float` and C ``double``."},{"l":"dsplit","k":"function","d":"(ary, indices_or_sections)","s":"Split array into multiple sub-arrays along the 3rd axis (depth)."},{"l":"dstack","k":"function","d":"(tup)","s":"Stack arrays in sequence depth wise (along third axis)."},{"l":"dtype","k":"class","d":"(dtype, align=False, copy=False, **kwargs)","s":"--"},{"l":"dtypes","k":"module"},{"l":"e","k":"constant","d":"2.718281828459045"},{"l":"ediff1d","k":"function","d":"(ary, to_end=None, to_begin=None)","s":"The differences between consecutive elements of an array."},{"l":"einsum","k":"function","d":"(*operands, out=None, optimize=False, **kwargs)","s":"Evaluates the Einstein summation convention on the operands."},{"l":"einsum_path","k":"function","d":"(*operands, optimize='greedy', einsum_call=False)","s":"Evaluates the lowest cost contraction order for an einsum expression by"},{"l":"emath","k":"module"},{"l":"empty","k":"function","d":"(shape, dtype=None, order='C', *, device=None, like=None)","s":"Return a new array of given shape and type, without initializing entries."},{"l":"empty_like","k":"function","d":"(prototype, /, dtype=None, order='K', subok=True, shape=None, *, device=None)","s":"Return a new array with the same shape and type as a given array."},{"l":"equal","k":"function","d":"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Return (x1 == x2) element-wise."},{"l":"errstate","k":"class","d":"(*, call=, all=None, divide=None, over=None, under=None, invalid=None)","s":"Context manager for floating-point error handling."},{"l":"euler_gamma","k":"constant","d":"0.5772156649015329"},{"l":"exceptions","k":"module"},{"l":"exp","k":"function","d":"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Calculate the exponential of all elements in the input array."},{"l":"exp2","k":"function","d":"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Calculate `2**p` for all `p` in the input array."},{"l":"expand_dims","k":"function","d":"(a, axis)","s":"Expand the shape of an array."},{"l":"expm1","k":"function","d":"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Calculate ``exp(x) - 1`` for all elements in the array."},{"l":"extract","k":"function","d":"(condition, arr)","s":"Return the elements of an array that satisfy some condition."},{"l":"eye","k":"function","d":"(N, M=None, k=0, dtype=, order='C', *, device=None, like=None)","s":"Return a 2-D array with ones on the diagonal and zeros elsewhere."},{"l":"f2py","k":"module"},{"l":"fabs","k":"function","d":"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Compute the absolute values element-wise."},{"l":"fft","k":"module"},{"l":"fill_diagonal","k":"function","d":"(a, val, wrap=False)","s":"Fill the main diagonal of the given array of any dimensionality."},{"l":"finfo","k":"class","d":"(dtype)","s":"Machine limits for floating point types."},{"l":"fix","k":"function","d":"(x, out=None)","s":"Round to nearest integer towards zero."},{"l":"flatiter","k":"class","d":"()","s":"Flat iterator object to iterate over arrays."},{"l":"flatnonzero","k":"function","d":"(a)","s":"Return indices that are non-zero in the flattened version of a."},{"l":"flexible","k":"class","d":"()","s":"Abstract base class of all scalar types without predefined length."},{"l":"flip","k":"function","d":"(m, axis=None)","s":"Reverse the order of elements in an array along the given axis."},{"l":"fliplr","k":"function","d":"(m)","s":"Reverse the order of elements along axis 1 (left/right)."},{"l":"flipud","k":"function","d":"(m)","s":"Reverse the order of elements along axis 0 (up/down)."},{"l":"float128","k":"class","d":"(value=0, /)","s":"Extended-precision floating-point number type, compatible with C ``long double``"},{"l":"float16","k":"class","d":"(value=0, /)","s":"Half-precision floating-point number type."},{"l":"float32","k":"class","d":"(value=0, /)","s":"Single-precision floating-point number type, compatible with C ``float``."},{"l":"float64","k":"class","d":"(value=0, /)","s":"Double-precision floating-point number type, compatible with Python :class:`float` and C ``double``."},{"l":"float_power","k":"function","d":"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"First array elements raised to powers from second array, element-wise."},{"l":"floating","k":"class","d":"()","s":"Abstract base class of all floating-point scalar types."},{"l":"floor","k":"function","d":"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Return the floor of the input, element-wise."},{"l":"floor_divide","k":"function","d":"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Return the largest integer smaller or equal to the division of the inputs."},{"l":"fmax","k":"function","d":"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Element-wise maximum of array elements."},{"l":"fmin","k":"function","d":"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Element-wise minimum of array elements."},{"l":"fmod","k":"function","d":"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Returns the element-wise remainder of division."},{"l":"format_float_positional","k":"function","d":"(x, precision=None, unique=True, fractional=True, trim='k', sign=False, pad_left=None, pad_right=None, min_digits=None)","s":"Format a floating-point scalar as a decimal string in positional notation."},{"l":"format_float_scientific","k":"function","d":"(x, precision=None, unique=True, trim='k', sign=False, pad_left=None, exp_digits=None, min_digits=None)","s":"Format a floating-point scalar as a decimal string in scientific notation."},{"l":"frexp","k":"function","d":"(x, /, out=(None, None), *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Decompose the elements of x into mantissa and twos exponent."},{"l":"from_dlpack","k":"function","d":"(x, /, *, device=None, copy=None)","s":"Create a NumPy array from an object implementing the ``__dlpack__``"},{"l":"frombuffer","k":"function","d":"(buffer, dtype=None, count=-1, offset=0, *, like=None)","s":"Interpret a buffer as a 1-dimensional array."},{"l":"fromfile","k":"function","d":"(file, dtype=None, count=-1, sep='', offset=0, *, like=None)","s":"Construct an array from data in a text or binary file."},{"l":"fromfunction","k":"function","d":"(function, shape, *, dtype=, like=None, **kwargs)","s":"Construct an array by executing a function over each coordinate."},{"l":"fromiter","k":"function","d":"(iter, dtype, count=-1, *, like=None)","s":"Create a new 1-dimensional array from an iterable object."},{"l":"frompyfunc","k":"function","d":"(func, /, nin, nout, **kwargs)","s":"Takes an arbitrary Python function and returns a NumPy ufunc."},{"l":"fromregex","k":"function","d":"(file, regexp, dtype, encoding=None)","s":"Construct an array from a text file, using regular expression parsing."},{"l":"fromstring","k":"function","d":"(string, dtype=float, count=-1, *, sep, like=None)","s":"A new 1-D array initialized from text data in a string."},{"l":"full","k":"function","d":"(shape, fill_value, dtype=None, order='C', *, device=None, like=None)","s":"Return a new array of given shape and type, filled with `fill_value`."},{"l":"full_like","k":"function","d":"(a, fill_value, dtype=None, order='K', subok=True, shape=None, *, device=None)","s":"Return a full array with the same shape and type as a given array."},{"l":"gcd","k":"function","d":"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Returns the greatest common divisor of ``|x1|`` and ``|x2|``"},{"l":"generic","k":"class","d":"()","s":"Base class for numpy scalar types."},{"l":"genfromtxt","k":"function","d":"(fname, dtype=, comments='#', delimiter=None, skip_header=0, skip_footer=0, converters=None, missing_values=None, filling_values=None, usecols=None, names=None, excludelist=None, deletechars=\" !#$%&'()*+,-./:;<=>?@[\\\\]^{|}~\", replace_space='_', autostrip=False, case_sensitive=True, defaultfmt='f%i', unpack=None, usemask=False, loose=True, invalid_raise=True, max_rows=None, encoding=None, *, ndmin=0, like=None)","s":"Load data from a text file, with missing values handled as specified."},{"l":"geomspace","k":"function","d":"(start, stop, num=50, endpoint=True, dtype=None, axis=0)","s":"Return numbers spaced evenly on a log scale (a geometric progression)."},{"l":"get_include","k":"function","d":"()","s":"Return the directory that contains the NumPy \\*.h header files."},{"l":"get_printoptions","k":"function","d":"()","s":"Return the current print options."},{"l":"getbufsize","k":"function","d":"()","s":"Return the size of the buffer used in ufuncs."},{"l":"geterr","k":"function","d":"()","s":"Get the current way of handling floating-point errors."},{"l":"geterrcall","k":"function","d":"()","s":"Return the current callback function used on floating-point errors."},{"l":"gradient","k":"function","d":"(f, *varargs, axis=None, edge_order=1)","s":"Return the gradient of an N-dimensional array."},{"l":"greater","k":"function","d":"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Return the truth value of (x1 > x2) element-wise."},{"l":"greater_equal","k":"function","d":"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Return the truth value of (x1 >= x2) element-wise."},{"l":"half","k":"class","d":"(value=0, /)","s":"Half-precision floating-point number type."},{"l":"hamming","k":"function","d":"(M)","s":"Return the Hamming window."},{"l":"hanning","k":"function","d":"(M)","s":"Return the Hanning window."},{"l":"heaviside","k":"function","d":"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Compute the Heaviside step function."},{"l":"histogram","k":"function","d":"(a, bins=10, range=None, density=None, weights=None)","s":"Compute the histogram of a dataset."},{"l":"histogram2d","k":"function","d":"(x, y, bins=10, range=None, density=None, weights=None)","s":"Compute the bi-dimensional histogram of two data samples."},{"l":"histogram_bin_edges","k":"function","d":"(a, bins=10, range=None, weights=None)","s":"Function to calculate only the edges of the bins used by the `histogram`"},{"l":"histogramdd","k":"function","d":"(sample, bins=10, range=None, density=None, weights=None)","s":"Compute the multidimensional histogram of some data."},{"l":"hsplit","k":"function","d":"(ary, indices_or_sections)","s":"Split an array into multiple sub-arrays horizontally (column-wise)."},{"l":"hstack","k":"function","d":"(tup, *, dtype=None, casting='same_kind')","s":"Stack arrays in sequence horizontally (column wise)."},{"l":"hypot","k":"function","d":"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Given the \"legs\" of a right triangle, return its hypotenuse."},{"l":"i0","k":"function","d":"(x)","s":"Modified Bessel function of the first kind, order 0."},{"l":"identity","k":"function","d":"(n, dtype=None, *, like=None)","s":"Return the identity array."},{"l":"iinfo","k":"class","d":"(int_type)","s":"Machine limits for integer types."},{"l":"imag","k":"function","d":"(val)","s":"Return the imaginary part of the complex argument."},{"l":"index_exp","k":"constant"},{"l":"indices","k":"function","d":"(dimensions, dtype=, sparse=False)","s":"Return an array representing the indices of a grid."},{"l":"inexact","k":"class","d":"()","s":"Abstract base class of all numeric scalar types with a (potentially)"},{"l":"inf","k":"constant","d":"inf"},{"l":"info","k":"function","d":"(object=None, maxwidth=76, output=None, toplevel='numpy')","s":"Get help information for an array, function, class, or module."},{"l":"inner","k":"function","d":"(a, b, /)","s":"Inner product of two arrays."},{"l":"insert","k":"function","d":"(arr, obj, values, axis=None)","s":"Insert values along the given axis before the given indices."},{"l":"int16","k":"class","d":"(value=0, /)","s":"Signed integer type, compatible with C ``short``."},{"l":"int32","k":"class","d":"(value=0, /)","s":"Signed integer type, compatible with C ``int``."},{"l":"int64","k":"class","d":"(value=0, /)","s":"Signed integer type, compatible with C ``long``."},{"l":"int8","k":"class","d":"(value=0, /)","s":"Signed integer type, compatible with C ``char``."},{"l":"int_","k":"class","d":"(value=0, /)","s":"Signed integer type, compatible with C ``long``."},{"l":"intc","k":"class","d":"(value=0, /)","s":"Signed integer type, compatible with C ``int``."},{"l":"integer","k":"class","d":"()","s":"Abstract base class of all integer scalar types."},{"l":"interp","k":"function","d":"(x, xp, fp, left=None, right=None, period=None)","s":"One-dimensional linear interpolation for monotonically increasing sample points."},{"l":"intersect1d","k":"function","d":"(ar1, ar2, assume_unique=False, return_indices=False)","s":"Find the intersection of two arrays."},{"l":"intp","k":"class","d":"(value=0, /)","s":"Signed integer type, compatible with C ``long``."},{"l":"invert","k":"function","d":"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Compute bit-wise inversion, or bit-wise NOT, element-wise."},{"l":"is_busday","k":"function","d":"(dates, weekmask='1111100', holidays=None, busdaycal=None, out=None)","s":"Calculates which of the given dates are valid days, and which are not."},{"l":"isclose","k":"function","d":"(a, b, rtol=1e-05, atol=1e-08, equal_nan=False)","s":"Returns a boolean array where two arrays are element-wise equal within a"},{"l":"iscomplex","k":"function","d":"(x)","s":"Returns a bool array, where True if input element is complex."},{"l":"iscomplexobj","k":"function","d":"(x)","s":"Check for a complex type or an array of complex numbers."},{"l":"isdtype","k":"function","d":"(dtype, kind)","s":"Determine if a provided dtype is of a specified data type ``kind``."},{"l":"isfinite","k":"function","d":"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Test element-wise for finiteness (not infinity and not Not a Number)."},{"l":"isfortran","k":"function","d":"(a)","s":"Check if the array is Fortran contiguous but *not* C contiguous."},{"l":"isin","k":"function","d":"(element, test_elements, assume_unique=False, invert=False, *, kind=None)","s":"Calculates ``element in test_elements``, broadcasting over `element` only."},{"l":"isinf","k":"function","d":"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Test element-wise for positive or negative infinity."},{"l":"isnan","k":"function","d":"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Test element-wise for NaN and return result as a boolean array."},{"l":"isnat","k":"function","d":"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Test element-wise for NaT (not a time) and return result as a boolean array."},{"l":"isneginf","k":"function","d":"(x, out=None)","s":"Test element-wise for negative infinity, return result as bool array."},{"l":"isposinf","k":"function","d":"(x, out=None)","s":"Test element-wise for positive infinity, return result as bool array."},{"l":"isreal","k":"function","d":"(x)","s":"Returns a bool array, where True if input element is real."},{"l":"isrealobj","k":"function","d":"(x)","s":"Return True if x is a not complex type or an array of complex numbers."},{"l":"isscalar","k":"function","d":"(element)","s":"Returns True if the type of `element` is a scalar type."},{"l":"issubdtype","k":"function","d":"(arg1, arg2)","s":"Returns True if first argument is a typecode lower/equal in type hierarchy."},{"l":"iterable","k":"function","d":"(y)","s":"Check whether or not an object can be iterated over."},{"l":"ix_","k":"function","d":"(*args)","s":"Construct an open mesh from multiple sequences."},{"l":"kaiser","k":"function","d":"(M, beta)","s":"Return the Kaiser window."},{"l":"kron","k":"function","d":"(a, b)","s":"Kronecker product of two arrays."},{"l":"lcm","k":"function","d":"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Returns the lowest common multiple of ``|x1|`` and ``|x2|``"},{"l":"ldexp","k":"function","d":"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Returns x1 * 2**x2, element-wise."},{"l":"left_shift","k":"function","d":"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Shift the bits of an integer to the left."},{"l":"less","k":"function","d":"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Return the truth value of (x1 < x2) element-wise."},{"l":"less_equal","k":"function","d":"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Return the truth value of (x1 <= x2) element-wise."},{"l":"lexsort","k":"function","d":"(keys, axis=-1)","s":"Perform an indirect stable sort using a sequence of keys."},{"l":"lib","k":"module"},{"l":"linalg","k":"module"},{"l":"linspace","k":"function","d":"(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0, *, device=None)","s":"Return evenly spaced numbers over a specified interval."},{"l":"little_endian","k":"constant","d":"True"},{"l":"load","k":"function","d":"(file, mmap_mode=None, allow_pickle=False, fix_imports=True, encoding='ASCII', *, max_header_size=10000)","s":"Load arrays or pickled objects from ``.npy``, ``.npz`` or pickled files."},{"l":"loadtxt","k":"function","d":"(fname, dtype=, comments='#', delimiter=None, converters=None, skiprows=0, usecols=None, unpack=False, ndmin=0, encoding=None, max_rows=None, *, quotechar=None, like=None)","s":"Load data from a text file."},{"l":"log","k":"function","d":"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Natural logarithm, element-wise."},{"l":"log10","k":"function","d":"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Return the base 10 logarithm of the input array, element-wise."},{"l":"log1p","k":"function","d":"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Return the natural logarithm of one plus the input array, element-wise."},{"l":"log2","k":"function","d":"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Base-2 logarithm of `x`."},{"l":"logaddexp","k":"function","d":"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Logarithm of the sum of exponentiations of the inputs."},{"l":"logaddexp2","k":"function","d":"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Logarithm of the sum of exponentiations of the inputs in base-2."},{"l":"logical_and","k":"function","d":"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Compute the truth value of x1 AND x2 element-wise."},{"l":"logical_not","k":"function","d":"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Compute the truth value of NOT x element-wise."},{"l":"logical_or","k":"function","d":"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Compute the truth value of x1 OR x2 element-wise."},{"l":"logical_xor","k":"function","d":"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Compute the truth value of x1 XOR x2, element-wise."},{"l":"logspace","k":"function","d":"(start, stop, num=50, endpoint=True, base=10.0, dtype=None, axis=0)","s":"Return numbers spaced evenly on a log scale."},{"l":"long","k":"class","d":"(value=0, /)","s":"Signed integer type, compatible with C ``long``."},{"l":"longdouble","k":"class","d":"(value=0, /)","s":"Extended-precision floating-point number type, compatible with C ``long double``"},{"l":"longlong","k":"class","d":"(value=0, /)","s":"Signed integer type, compatible with C ``long long``."},{"l":"ma","k":"module"},{"l":"mask_indices","k":"function","d":"(n, mask_func, k=0)","s":"Return the indices to access (n, n) arrays, given a masking function."},{"l":"matmul","k":"function","d":"(x1, x2, /, out=None, *, axes=, axis=, keepdims=False, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Matrix product of two arrays."},{"l":"matrix","k":"class","d":"(data, dtype=None, copy=True)","s":"Returns a matrix from an array-like object, or from a string of data."},{"l":"matrix_transpose","k":"function","d":"(x, /)","s":"Transposes a matrix (or a stack of matrices) ``x``."},{"l":"matvec","k":"function","d":"(x1, x2, /, out=None, *, axes=, axis=, keepdims=False, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Matrix-vector dot product of two arrays."},{"l":"max","k":"function","d":"(a, axis=None, out=None, keepdims=, initial=, where=)","s":"Return the maximum of an array or maximum along an axis."},{"l":"maximum","k":"function","d":"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Element-wise maximum of array elements."},{"l":"may_share_memory","k":"function","d":"(a, b, /, max_work=0)","s":"Determine if two arrays might share memory"},{"l":"mean","k":"function","d":"(a, axis=None, dtype=None, out=None, keepdims=, *, where=)","s":"Compute the arithmetic mean along the specified axis."},{"l":"median","k":"function","d":"(a, axis=None, out=None, overwrite_input=False, keepdims=False)","s":"Compute the median along the specified axis."},{"l":"memmap","k":"class","d":"(filename, dtype=, mode='r+', offset=0, shape=None, order='C')","s":"Create a memory-map to an array stored in a *binary* file on disk."},{"l":"meshgrid","k":"function","d":"(*xi, copy=True, sparse=False, indexing='xy')","s":"Return a tuple of coordinate matrices from coordinate vectors."},{"l":"mgrid","k":"constant"},{"l":"min","k":"function","d":"(a, axis=None, out=None, keepdims=, initial=, where=)","s":"Return the minimum of an array or minimum along an axis."},{"l":"min_scalar_type","k":"function","d":"(a, /)","s":"For scalar ``a``, returns the data type with the smallest size"},{"l":"minimum","k":"function","d":"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Element-wise minimum of array elements."},{"l":"mintypecode","k":"function","d":"(typechars, typeset='GDFgdf', default='d')","s":"Return the character for the minimum-size type to which given types can"},{"l":"mod","k":"function","d":"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"remainder(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])"},{"l":"modf","k":"function","d":"(x, /, out=(None, None), *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Return the fractional and integral parts of an array, element-wise."},{"l":"moveaxis","k":"function","d":"(a, source, destination)","s":"Move axes of an array to new positions."},{"l":"multiply","k":"function","d":"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Multiply arguments element-wise."},{"l":"nan","k":"constant","d":"nan"},{"l":"nan_to_num","k":"function","d":"(x, copy=True, nan=0.0, posinf=None, neginf=None)","s":"Replace NaN with zero and infinity with large finite numbers (default"},{"l":"nanargmax","k":"function","d":"(a, axis=None, out=None, *, keepdims=)","s":"Return the indices of the maximum values in the specified axis ignoring"},{"l":"nanargmin","k":"function","d":"(a, axis=None, out=None, *, keepdims=)","s":"Return the indices of the minimum values in the specified axis ignoring"},{"l":"nancumprod","k":"function","d":"(a, axis=None, dtype=None, out=None)","s":"Return the cumulative product of array elements over a given axis treating Not a"},{"l":"nancumsum","k":"function","d":"(a, axis=None, dtype=None, out=None)","s":"Return the cumulative sum of array elements over a given axis treating Not a"},{"l":"nanmax","k":"function","d":"(a, axis=None, out=None, keepdims=, initial=, where=)","s":"Return the maximum of an array or maximum along an axis, ignoring any"},{"l":"nanmean","k":"function","d":"(a, axis=None, dtype=None, out=None, keepdims=, *, where=)","s":"Compute the arithmetic mean along the specified axis, ignoring NaNs."},{"l":"nanmedian","k":"function","d":"(a, axis=None, out=None, overwrite_input=False, keepdims=)","s":"Compute the median along the specified axis, while ignoring NaNs."},{"l":"nanmin","k":"function","d":"(a, axis=None, out=None, keepdims=, initial=, where=)","s":"Return minimum of an array or minimum along an axis, ignoring any NaNs."},{"l":"nanpercentile","k":"function","d":"(a, q, axis=None, out=None, overwrite_input=False, method='linear', keepdims=, *, weights=None)","s":"Compute the qth percentile of the data along the specified axis,"},{"l":"nanprod","k":"function","d":"(a, axis=None, dtype=None, out=None, keepdims=, initial=, where=)","s":"Return the product of array elements over a given axis treating Not a"},{"l":"nanquantile","k":"function","d":"(a, q, axis=None, out=None, overwrite_input=False, method='linear', keepdims=, *, weights=None)","s":"Compute the qth quantile of the data along the specified axis,"},{"l":"nanstd","k":"function","d":"(a, axis=None, dtype=None, out=None, ddof=0, keepdims=, *, where=, mean=, correction=)","s":"Compute the standard deviation along the specified axis, while"},{"l":"nansum","k":"function","d":"(a, axis=None, dtype=None, out=None, keepdims=, initial=, where=)","s":"Return the sum of array elements over a given axis treating Not a"},{"l":"nanvar","k":"function","d":"(a, axis=None, dtype=None, out=None, ddof=0, keepdims=, *, where=, mean=, correction=)","s":"Compute the variance along the specified axis, while ignoring NaNs."},{"l":"ndarray","k":"class","d":"(shape, dtype=None, buffer=None, offset=0, strides=None, order=None)","s":"An array object represents a multidimensional, homogeneous array"},{"l":"ndenumerate","k":"class","d":"(arr)","s":"Multidimensional index iterator."},{"l":"ndim","k":"function","d":"(a)","s":"Return the number of dimensions of an array."},{"l":"ndindex","k":"class","d":"(*shape)","s":"An N-dimensional iterator object to index arrays."},{"l":"nditer","k":"class","d":"(op, flags=None, op_flags=None, op_dtypes=None, order='K', casting='safe', op_axes=None, itershape=None, buffersize=0)","s":"Efficient multi-dimensional iterator object to iterate over arrays."},{"l":"negative","k":"function","d":"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Numerical negative, element-wise."},{"l":"nested_iters","k":"function","d":"(op, axes, flags=None, op_flags=None, op_dtypes=None, order='K', casting='safe', buffersize=0)","s":"Create nditers for use in nested loops"},{"l":"newaxis","k":"constant","d":"None"},{"l":"nextafter","k":"function","d":"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Return the next floating-point value after x1 towards x2, element-wise."},{"l":"nonzero","k":"function","d":"(a)","s":"Return the indices of the elements that are non-zero."},{"l":"not_equal","k":"function","d":"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Return (x1 != x2) element-wise."},{"l":"number","k":"class","d":"()","s":"Abstract base class of all numeric scalar types."},{"l":"object_","k":"class","d":"(value=None, /)","s":"Any Python object."},{"l":"ogrid","k":"constant"},{"l":"ones","k":"function","d":"(shape, dtype=None, order='C', *, device=None, like=None)","s":"Return a new array of given shape and type, filled with ones."},{"l":"ones_like","k":"function","d":"(a, dtype=None, order='K', subok=True, shape=None, *, device=None)","s":"Return an array of ones with the same shape and type as a given array."},{"l":"outer","k":"function","d":"(a, b, out=None)","s":"Compute the outer product of two vectors."},{"l":"packbits","k":"function","d":"(a, /, axis=None, bitorder='big')","s":"Packs the elements of a binary-valued array into bits in a uint8 array."},{"l":"pad","k":"function","d":"(array, pad_width, mode='constant', **kwargs)","s":"Pad an array."},{"l":"partition","k":"function","d":"(a, kth, axis=-1, kind='introselect', order=None)","s":"Return a partitioned copy of an array."},{"l":"percentile","k":"function","d":"(a, q, axis=None, out=None, overwrite_input=False, method='linear', keepdims=False, *, weights=None)","s":"Compute the q-th percentile of the data along the specified axis."},{"l":"permute_dims","k":"function","d":"(a, axes=None)","s":"Returns an array with axes transposed."},{"l":"pi","k":"constant","d":"3.141592653589793"},{"l":"piecewise","k":"function","d":"(x, condlist, funclist, *args, **kw)","s":"Evaluate a piecewise-defined function."},{"l":"place","k":"function","d":"(arr, mask, vals)","s":"Change elements of an array based on conditional and input values."},{"l":"poly","k":"function","d":"(seq_of_zeros)","s":"Find the coefficients of a polynomial with the given sequence of roots."},{"l":"poly1d","k":"class","d":"(c_or_r, r=False, variable=None)","s":"A one-dimensional polynomial class."},{"l":"polyadd","k":"function","d":"(a1, a2)","s":"Find the sum of two polynomials."},{"l":"polyder","k":"function","d":"(p, m=1)","s":"Return the derivative of the specified order of a polynomial."},{"l":"polydiv","k":"function","d":"(u, v)","s":"Returns the quotient and remainder of polynomial division."},{"l":"polyfit","k":"function","d":"(x, y, deg, rcond=None, full=False, w=None, cov=False)","s":"Least squares polynomial fit."},{"l":"polyint","k":"function","d":"(p, m=1, k=None)","s":"Return an antiderivative (indefinite integral) of a polynomial."},{"l":"polymul","k":"function","d":"(a1, a2)","s":"Find the product of two polynomials."},{"l":"polynomial","k":"module"},{"l":"polysub","k":"function","d":"(a1, a2)","s":"Difference (subtraction) of two polynomials."},{"l":"polyval","k":"function","d":"(p, x)","s":"Evaluate a polynomial at specific values."},{"l":"positive","k":"function","d":"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Numerical positive, element-wise."},{"l":"pow","k":"function","d":"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"power(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])"},{"l":"power","k":"function","d":"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"First array elements raised to powers from second array, element-wise."},{"l":"printoptions","k":"function","d":"(*args, **kwargs)","s":"Context manager for setting print options."},{"l":"prod","k":"function","d":"(a, axis=None, dtype=None, out=None, keepdims=, initial=, where=)","s":"Return the product of array elements over a given axis."},{"l":"promote_types","k":"function","d":"(type1, type2, /)","s":"Returns the data type with the smallest size and smallest scalar"},{"l":"ptp","k":"function","d":"(a, axis=None, out=None, keepdims=)","s":"Range of values (maximum - minimum) along an axis."},{"l":"put","k":"function","d":"(a, ind, v, mode='raise')","s":"Replaces specified elements of an array with given values."},{"l":"put_along_axis","k":"function","d":"(arr, indices, values, axis)","s":"Put values into the destination array by matching 1d index and data slices."},{"l":"putmask","k":"function","d":"(a, /, mask, values)","s":"Changes elements of an array based on conditional and input values."},{"l":"quantile","k":"function","d":"(a, q, axis=None, out=None, overwrite_input=False, method='linear', keepdims=False, *, weights=None)","s":"Compute the q-th quantile of the data along the specified axis."},{"l":"r_","k":"constant"},{"l":"rad2deg","k":"function","d":"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Convert angles from radians to degrees."},{"l":"radians","k":"function","d":"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Convert angles from degrees to radians."},{"l":"random","k":"module"},{"l":"ravel","k":"function","d":"(a, order='C')","s":"Return a contiguous flattened array."},{"l":"ravel_multi_index","k":"function","d":"(multi_index, dims, mode='raise', order='C')","s":"Converts a tuple of index arrays into an array of flat"},{"l":"real","k":"function","d":"(val)","s":"Return the real part of the complex argument."},{"l":"real_if_close","k":"function","d":"(a, tol=100)","s":"If input is complex with all imaginary parts close to zero, return"},{"l":"rec","k":"module"},{"l":"recarray","k":"class","d":"(shape, dtype=None, buf=None, offset=0, strides=None, formats=None, names=None, titles=None, byteorder=None, aligned=False, order='C')","s":"Construct an ndarray that allows field access using attributes."},{"l":"reciprocal","k":"function","d":"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Return the reciprocal of the argument, element-wise."},{"l":"record","k":"class","d":"(length_or_data, /, dtype=None)","s":"A data-type scalar that allows field access as attribute lookup."},{"l":"remainder","k":"function","d":"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Returns the element-wise remainder of division."},{"l":"repeat","k":"function","d":"(a, repeats, axis=None)","s":"Repeat each element of an array after themselves"},{"l":"require","k":"function","d":"(a, dtype=None, requirements=None, *, like=None)","s":"Return an ndarray of the provided type that satisfies requirements."},{"l":"reshape","k":"function","d":"(a, /, shape, order='C', *, copy=None)","s":"Gives a new shape to an array without changing its data."},{"l":"resize","k":"function","d":"(a, new_shape)","s":"Return a new array with the specified shape."},{"l":"result_type","k":"function","d":"(*arrays_and_dtypes)","s":"Returns the type that results from applying the NumPy"},{"l":"right_shift","k":"function","d":"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Shift the bits of an integer to the right."},{"l":"rint","k":"function","d":"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Round elements of the array to the nearest integer."},{"l":"roll","k":"function","d":"(a, shift, axis=None)","s":"Roll array elements along a given axis."},{"l":"rollaxis","k":"function","d":"(a, axis, start=0)","s":"Roll the specified axis backwards, until it lies in a given position."},{"l":"roots","k":"function","d":"(p)","s":"Return the roots of a polynomial with coefficients given in p."},{"l":"rot90","k":"function","d":"(m, k=1, axes=(0, 1))","s":"Rotate an array by 90 degrees in the plane specified by axes."},{"l":"round","k":"function","d":"(a, decimals=0, out=None)","s":"Evenly round to the given number of decimals."},{"l":"row_stack","k":"function","d":"(tup, *, dtype=None, casting='same_kind')","s":"Stack arrays in sequence vertically (row wise)."},{"l":"s_","k":"constant"},{"l":"save","k":"function","d":"(file, arr, allow_pickle=True)","s":"Save an array to a binary file in NumPy ``.npy`` format."},{"l":"savetxt","k":"function","d":"(fname, X, fmt='%.18e', delimiter=' ', newline='\\n', header='', footer='', comments='# ', encoding=None)","s":"Save an array to a text file."},{"l":"savez","k":"function","d":"(file, *args, allow_pickle=True, **kwds)","s":"Save several arrays into a single file in uncompressed ``.npz`` format."},{"l":"savez_compressed","k":"function","d":"(file, *args, allow_pickle=True, **kwds)","s":"Save several arrays into a single file in compressed ``.npz`` format."},{"l":"sctypeDict","k":"constant"},{"l":"searchsorted","k":"function","d":"(a, v, side='left', sorter=None)","s":"Find indices where elements should be inserted to maintain order."},{"l":"select","k":"function","d":"(condlist, choicelist, default=0)","s":"Return an array drawn from elements in choicelist, depending on conditions."},{"l":"set_printoptions","k":"function","d":"(precision=None, threshold=None, edgeitems=None, linewidth=None, suppress=None, nanstr=None, infstr=None, formatter=None, sign=None, floatmode=None, *, legacy=None, override_repr=None)","s":"Set printing options."},{"l":"setbufsize","k":"function","d":"(size)","s":"Set the size of the buffer used in ufuncs."},{"l":"setdiff1d","k":"function","d":"(ar1, ar2, assume_unique=False)","s":"Find the set difference of two arrays."},{"l":"seterr","k":"function","d":"(all=None, divide=None, over=None, under=None, invalid=None)","s":"Set how floating-point errors are handled."},{"l":"seterrcall","k":"function","d":"(func)","s":"Set the floating-point error callback function or log object."},{"l":"setxor1d","k":"function","d":"(ar1, ar2, assume_unique=False)","s":"Find the set exclusive-or of two arrays."},{"l":"shape","k":"function","d":"(a)","s":"Return the shape of an array."},{"l":"shares_memory","k":"function","d":"(a, b, /, max_work=-1)","s":"Determine if two arrays share memory."},{"l":"short","k":"class","d":"(value=0, /)","s":"Signed integer type, compatible with C ``short``."},{"l":"show_config","k":"function","d":"(mode='stdout')","s":"Show libraries and system information on which NumPy was built"},{"l":"show_runtime","k":"function","d":"()","s":"Print information about various resources in the system"},{"l":"sign","k":"function","d":"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Returns an element-wise indication of the sign of a number."},{"l":"signbit","k":"function","d":"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Returns element-wise True where signbit is set (less than zero)."},{"l":"signedinteger","k":"class","d":"()","s":"Abstract base class of all signed integer scalar types."},{"l":"sin","k":"function","d":"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Trigonometric sine, element-wise."},{"l":"sinc","k":"function","d":"(x)","s":"Return the normalized sinc function."},{"l":"single","k":"class","d":"(value=0, /)","s":"Single-precision floating-point number type, compatible with C ``float``."},{"l":"sinh","k":"function","d":"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Hyperbolic sine, element-wise."},{"l":"size","k":"function","d":"(a, axis=None)","s":"Return the number of elements along a given axis."},{"l":"sort","k":"function","d":"(a, axis=-1, kind=None, order=None, *, stable=None)","s":"Return a sorted copy of an array."},{"l":"sort_complex","k":"function","d":"(a)","s":"Sort a complex array using the real part first, then the imaginary part."},{"l":"spacing","k":"function","d":"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Return the distance between x and the nearest adjacent number."},{"l":"split","k":"function","d":"(ary, indices_or_sections, axis=0)","s":"Split an array into multiple sub-arrays as views into `ary`."},{"l":"sqrt","k":"function","d":"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Return the non-negative square-root of an array, element-wise."},{"l":"square","k":"function","d":"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Return the element-wise square of the input."},{"l":"squeeze","k":"function","d":"(a, axis=None)","s":"Remove axes of length one from `a`."},{"l":"stack","k":"function","d":"(arrays, axis=0, out=None, *, dtype=None, casting='same_kind')","s":"Join a sequence of arrays along a new axis."},{"l":"std","k":"function","d":"(a, axis=None, dtype=None, out=None, ddof=0, keepdims=, *, where=, mean=, correction=)","s":"Compute the standard deviation along the specified axis."},{"l":"str_","k":"class","d":"(value='', /, *args, **kwargs)","s":"A unicode string."},{"l":"strings","k":"module"},{"l":"subtract","k":"function","d":"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Subtract arguments, element-wise."},{"l":"sum","k":"function","d":"(a, axis=None, dtype=None, out=None, keepdims=, initial=, where=)","s":"Sum of array elements over a given axis."},{"l":"swapaxes","k":"function","d":"(a, axis1, axis2)","s":"Interchange two axes of an array."},{"l":"take","k":"function","d":"(a, indices, axis=None, out=None, mode='raise')","s":"Take elements from an array along an axis."},{"l":"take_along_axis","k":"function","d":"(arr, indices, axis=-1)","s":"Take values from the input array by matching 1d index and data slices."},{"l":"tan","k":"function","d":"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Compute tangent element-wise."},{"l":"tanh","k":"function","d":"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Compute hyperbolic tangent element-wise."},{"l":"tensordot","k":"function","d":"(a, b, axes=2)","s":"Compute tensor dot product along specified axes."},{"l":"test","k":"function","d":"(label='fast', verbose=1, extra_argv=None, doctests=False, coverage=False, durations=-1, tests=None)","s":"Pytest test runner."},{"l":"testing","k":"module"},{"l":"tile","k":"function","d":"(A, reps)","s":"Construct an array by repeating A the number of times given by reps."},{"l":"timedelta64","k":"class","d":"(value=0, /, *args)","s":"A timedelta stored as a 64-bit integer."},{"l":"trace","k":"function","d":"(a, offset=0, axis1=0, axis2=1, dtype=None, out=None)","s":"Return the sum along diagonals of the array."},{"l":"transpose","k":"function","d":"(a, axes=None)","s":"Returns an array with axes transposed."},{"l":"trapezoid","k":"function","d":"(y, x=None, dx=1.0, axis=-1)","s":"Integrate along the given axis using the composite trapezoidal rule."},{"l":"tri","k":"function","d":"(N, M=None, k=0, dtype=, *, like=None)","s":"An array with ones at and below the given diagonal and zeros elsewhere."},{"l":"tril","k":"function","d":"(m, k=0)","s":"Lower triangle of an array."},{"l":"tril_indices","k":"function","d":"(n, k=0, m=None)","s":"Return the indices for the lower-triangle of an (n, m) array."},{"l":"tril_indices_from","k":"function","d":"(arr, k=0)","s":"Return the indices for the lower-triangle of arr."},{"l":"trim_zeros","k":"function","d":"(filt, trim='fb', axis=None)","s":"Remove values along a dimension which are zero along all other."},{"l":"triu","k":"function","d":"(m, k=0)","s":"Upper triangle of an array."},{"l":"triu_indices","k":"function","d":"(n, k=0, m=None)","s":"Return the indices for the upper-triangle of an (n, m) array."},{"l":"triu_indices_from","k":"function","d":"(arr, k=0)","s":"Return the indices for the upper-triangle of arr."},{"l":"true_divide","k":"function","d":"(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"divide(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])"},{"l":"trunc","k":"function","d":"(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Return the truncated value of the input, element-wise."},{"l":"typecodes","k":"constant"},{"l":"typename","k":"function","d":"(char)","s":"Return a description for the given data type code."},{"l":"typing","k":"module"},{"l":"ubyte","k":"class","d":"(value=0, /)","s":"Unsigned integer type, compatible with C ``unsigned char``."},{"l":"ufunc","k":"class","d":"()","s":"Functions that operate element by element on whole arrays."},{"l":"uint","k":"class","d":"(value=0, /)","s":"Unsigned signed integer type, 64bit on 64bit systems and 32bit on 32bit systems."},{"l":"uint16","k":"class","d":"(value=0, /)","s":"Unsigned integer type, compatible with C ``unsigned short``."},{"l":"uint32","k":"class","d":"(value=0, /)","s":"Unsigned integer type, compatible with C ``unsigned int``."},{"l":"uint64","k":"class","d":"(value=0, /)","s":"Unsigned signed integer type, 64bit on 64bit systems and 32bit on 32bit systems."},{"l":"uint8","k":"class","d":"(value=0, /)","s":"Unsigned integer type, compatible with C ``unsigned char``."},{"l":"uintc","k":"class","d":"(value=0, /)","s":"Unsigned integer type, compatible with C ``unsigned int``."},{"l":"uintp","k":"class","d":"(value=0, /)","s":"Unsigned signed integer type, 64bit on 64bit systems and 32bit on 32bit systems."},{"l":"ulong","k":"class","d":"(value=0, /)","s":"Unsigned signed integer type, 64bit on 64bit systems and 32bit on 32bit systems."},{"l":"ulonglong","k":"class","d":"(value=0, /)","s":"Unsigned integer type, compatible with C ``unsigned long long``."},{"l":"union1d","k":"function","d":"(ar1, ar2)","s":"Find the union of two arrays."},{"l":"unique","k":"function","d":"(ar, return_index=False, return_inverse=False, return_counts=False, axis=None, *, equal_nan=True, sorted=True)","s":"Find the unique elements of an array."},{"l":"unique_all","k":"function","d":"(x)","s":"Find the unique elements of an array, and counts, inverse, and indices."},{"l":"unique_counts","k":"function","d":"(x)","s":"Find the unique elements and counts of an input array `x`."},{"l":"unique_inverse","k":"function","d":"(x)","s":"Find the unique elements of `x` and indices to reconstruct `x`."},{"l":"unique_values","k":"function","d":"(x)","s":"Returns the unique elements of an input array `x`."},{"l":"unpackbits","k":"function","d":"(a, /, axis=None, count=None, bitorder='big')","s":"Unpacks elements of a uint8 array into a binary-valued output array."},{"l":"unravel_index","k":"function","d":"(indices, shape, order='C')","s":"Converts a flat index or array of flat indices into a tuple"},{"l":"unsignedinteger","k":"class","d":"()","s":"Abstract base class of all unsigned integer scalar types."},{"l":"unstack","k":"function","d":"(x, /, *, axis=0)","s":"Split an array into a sequence of arrays along the given axis."},{"l":"unwrap","k":"function","d":"(p, discont=None, axis=-1, *, period=6.283185307179586)","s":"Unwrap by taking the complement of large deltas with respect to the period."},{"l":"ushort","k":"class","d":"(value=0, /)","s":"Unsigned integer type, compatible with C ``unsigned short``."},{"l":"vander","k":"function","d":"(x, N=None, increasing=False)","s":"Generate a Vandermonde matrix."},{"l":"var","k":"function","d":"(a, axis=None, dtype=None, out=None, ddof=0, keepdims=, *, where=, mean=, correction=)","s":"Compute the variance along the specified axis."},{"l":"vdot","k":"function","d":"(a, b, /)","s":"Return the dot product of two vectors."},{"l":"vecdot","k":"function","d":"(x1, x2, /, out=None, *, axes=, axis=, keepdims=False, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Vector dot product of two arrays."},{"l":"vecmat","k":"function","d":"(x1, x2, /, out=None, *, axes=, axis=, keepdims=False, casting='same_kind', order='K', dtype=None, subok=True, signature=None)","s":"Vector-matrix dot product of two arrays."},{"l":"vectorize","k":"class","d":"(pyfunc=, otypes=None, doc=None, excluded=None, cache=False, signature=None)","s":"Returns an object that acts like pyfunc, but takes arrays as input."},{"l":"void","k":"class","d":"(length_or_data, /, dtype=None)","s":"np.void(length_or_data, /, dtype=None)"},{"l":"vsplit","k":"function","d":"(ary, indices_or_sections)","s":"Split an array into multiple sub-arrays vertically (row-wise)."},{"l":"vstack","k":"function","d":"(tup, *, dtype=None, casting='same_kind')","s":"Stack arrays in sequence vertically (row wise)."},{"l":"where","k":"function","d":"(condition, x=None, y=None, /)","s":"Return elements chosen from `x` or `y` depending on `condition`."},{"l":"zeros","k":"function","d":"(shape, dtype=None, order='C', *, device=None, like=None)","s":"Return a new array of given shape and type, filled with zeros."},{"l":"zeros_like","k":"function","d":"(a, dtype=None, order='K', subok=True, shape=None, *, device=None)","s":"Return an array of zeros with the same shape and type as a given array."}],"math":[{"l":"acos","k":"function","d":"(x, /)","s":"Return the arc cosine (measured in radians) of x."},{"l":"acosh","k":"function","d":"(x, /)","s":"Return the inverse hyperbolic cosine of x."},{"l":"asin","k":"function","d":"(x, /)","s":"Return the arc sine (measured in radians) of x."},{"l":"asinh","k":"function","d":"(x, /)","s":"Return the inverse hyperbolic sine of x."},{"l":"atan","k":"function","d":"(x, /)","s":"Return the arc tangent (measured in radians) of x."},{"l":"atan2","k":"function","d":"(y, x, /)","s":"Return the arc tangent (measured in radians) of y/x."},{"l":"atanh","k":"function","d":"(x, /)","s":"Return the inverse hyperbolic tangent of x."},{"l":"cbrt","k":"function","d":"(x, /)","s":"Return the cube root of x."},{"l":"ceil","k":"function","d":"(x, /)","s":"Return the ceiling of x as an Integral."},{"l":"comb","k":"function","d":"(n, k, /)","s":"Number of ways to choose k items from n items without repetition and without order."},{"l":"copysign","k":"function","d":"(x, y, /)","s":"Return a float with the magnitude (absolute value) of x but the sign of y."},{"l":"cos","k":"function","d":"(x, /)","s":"Return the cosine of x (measured in radians)."},{"l":"cosh","k":"function","d":"(x, /)","s":"Return the hyperbolic cosine of x."},{"l":"degrees","k":"function","d":"(x, /)","s":"Convert angle x from radians to degrees."},{"l":"dist","k":"function","d":"(p, q, /)","s":"Return the Euclidean distance between two points p and q."},{"l":"e","k":"constant","d":"2.718281828459045"},{"l":"erf","k":"function","d":"(x, /)","s":"Error function at x."},{"l":"erfc","k":"function","d":"(x, /)","s":"Complementary error function at x."},{"l":"exp","k":"function","d":"(x, /)","s":"Return e raised to the power of x."},{"l":"exp2","k":"function","d":"(x, /)","s":"Return 2 raised to the power of x."},{"l":"expm1","k":"function","d":"(x, /)","s":"Return exp(x)-1."},{"l":"fabs","k":"function","d":"(x, /)","s":"Return the absolute value of the float x."},{"l":"factorial","k":"function","d":"(n, /)","s":"Find n!."},{"l":"floor","k":"function","d":"(x, /)","s":"Return the floor of x as an Integral."},{"l":"fmod","k":"function","d":"(x, y, /)","s":"Return fmod(x, y), according to platform C."},{"l":"frexp","k":"function","d":"(x, /)","s":"Return the mantissa and exponent of x, as pair (m, e)."},{"l":"fsum","k":"function","d":"(seq, /)","s":"Return an accurate floating point sum of values in the iterable seq."},{"l":"gamma","k":"function","d":"(x, /)","s":"Gamma function at x."},{"l":"gcd","k":"function","d":"(*integers)","s":"Greatest Common Divisor."},{"l":"hypot","k":"function","d":"(*coordinates) -> value","s":"Multidimensional Euclidean distance from the origin to a point."},{"l":"inf","k":"constant","d":"inf"},{"l":"isclose","k":"function","d":"(a, b, *, rel_tol=1e-09, abs_tol=0.0)","s":"Determine whether two floating point numbers are close in value."},{"l":"isfinite","k":"function","d":"(x, /)","s":"Return True if x is neither an infinity nor a NaN, and False otherwise."},{"l":"isinf","k":"function","d":"(x, /)","s":"Return True if x is a positive or negative infinity, and False otherwise."},{"l":"isnan","k":"function","d":"(x, /)","s":"Return True if x is a NaN (not a number), and False otherwise."},{"l":"isqrt","k":"function","d":"(n, /)","s":"Return the integer part of the square root of the input."},{"l":"lcm","k":"function","d":"(*integers)","s":"Least Common Multiple."},{"l":"ldexp","k":"function","d":"(x, i, /)","s":"Return x * (2**i)."},{"l":"lgamma","k":"function","d":"(x, /)","s":"Natural logarithm of absolute value of Gamma function at x."},{"l":"log","k":"function","d":"(x, [base=math.e])","s":"Return the logarithm of x to the given base."},{"l":"log10","k":"function","d":"(x, /)","s":"Return the base 10 logarithm of x."},{"l":"log1p","k":"function","d":"(x, /)","s":"Return the natural logarithm of 1+x (base e)."},{"l":"log2","k":"function","d":"(x, /)","s":"Return the base 2 logarithm of x."},{"l":"modf","k":"function","d":"(x, /)","s":"Return the fractional and integer parts of x."},{"l":"nan","k":"constant","d":"nan"},{"l":"nextafter","k":"function","d":"(x, y, /)","s":"Return the next floating-point value after x towards y."},{"l":"perm","k":"function","d":"(n, k=None, /)","s":"Number of ways to choose k items from n items without repetition and with order."},{"l":"pi","k":"constant","d":"3.141592653589793"},{"l":"pow","k":"function","d":"(x, y, /)","s":"Return x**y (x to the power of y)."},{"l":"prod","k":"function","d":"(iterable, /, *, start=1)","s":"Calculate the product of all the elements in the input iterable."},{"l":"radians","k":"function","d":"(x, /)","s":"Convert angle x from degrees to radians."},{"l":"remainder","k":"function","d":"(x, y, /)","s":"Difference between x and the closest integer multiple of y."},{"l":"sin","k":"function","d":"(x, /)","s":"Return the sine of x (measured in radians)."},{"l":"sinh","k":"function","d":"(x, /)","s":"Return the hyperbolic sine of x."},{"l":"sqrt","k":"function","d":"(x, /)","s":"Return the square root of x."},{"l":"tan","k":"function","d":"(x, /)","s":"Return the tangent of x (measured in radians)."},{"l":"tanh","k":"function","d":"(x, /)","s":"Return the hyperbolic tangent of x."},{"l":"tau","k":"constant","d":"6.283185307179586"},{"l":"trunc","k":"function","d":"(x, /)","s":"Truncates the Real x to the nearest Integral toward 0."},{"l":"ulp","k":"function","d":"(x, /)","s":"Return the value of the least significant bit of the float x."}],"Tensor":[{"l":"H","k":"property","s":"Returns a view of a matrix (2-D tensor) conjugated and transposed."},{"l":"T","k":"property","s":"Returns a view of this tensor with its dimensions reversed."},{"l":"abs","k":"function","d":"() -> Tensor","s":"See :func:`torch.abs`"},{"l":"abs_","k":"function","d":"() -> Tensor","s":"In-place version of :meth:`~Tensor.abs`"},{"l":"absolute","k":"function","d":"() -> Tensor","s":"Alias for :func:`abs`"},{"l":"absolute_","k":"function","d":"() -> Tensor","s":"In-place version of :meth:`~Tensor.absolute`"},{"l":"acos","k":"function","d":"() -> Tensor","s":"See :func:`torch.acos`"},{"l":"acos_","k":"function","d":"() -> Tensor","s":"In-place version of :meth:`~Tensor.acos`"},{"l":"acosh","k":"function","d":"() -> Tensor","s":"See :func:`torch.acosh`"},{"l":"acosh_","k":"function","d":"() -> Tensor","s":"In-place version of :meth:`~Tensor.acosh`"},{"l":"add","k":"function","d":"(other, *, alpha=1) -> Tensor","s":"Add a scalar or tensor to :attr:`self` tensor. If both :attr:`alpha`"},{"l":"add_","k":"function","d":"(other, *, alpha=1) -> Tensor","s":"In-place version of :meth:`~Tensor.add`"},{"l":"addbmm","k":"function","d":"(batch1, batch2, *, beta=1, alpha=1) -> Tensor","s":"See :func:`torch.addbmm`"},{"l":"addbmm_","k":"function","d":"(batch1, batch2, *, beta=1, alpha=1) -> Tensor","s":"In-place version of :meth:`~Tensor.addbmm`"},{"l":"addcdiv","k":"function","d":"(tensor1, tensor2, *, value=1) -> Tensor","s":"See :func:`torch.addcdiv`"},{"l":"addcdiv_","k":"function","d":"(tensor1, tensor2, *, value=1) -> Tensor","s":"In-place version of :meth:`~Tensor.addcdiv`"},{"l":"addcmul","k":"function","d":"(tensor1, tensor2, *, value=1) -> Tensor","s":"See :func:`torch.addcmul`"},{"l":"addcmul_","k":"function","d":"(tensor1, tensor2, *, value=1) -> Tensor","s":"In-place version of :meth:`~Tensor.addcmul`"},{"l":"addmm","k":"function","d":"(mat1, mat2, *, beta=1, alpha=1) -> Tensor","s":"See :func:`torch.addmm`"},{"l":"addmm_","k":"function","d":"(mat1, mat2, *, beta=1, alpha=1) -> Tensor","s":"In-place version of :meth:`~Tensor.addmm`"},{"l":"addmv","k":"function","d":"(mat, vec, *, beta=1, alpha=1) -> Tensor","s":"See :func:`torch.addmv`"},{"l":"addmv_","k":"function","d":"(mat, vec, *, beta=1, alpha=1) -> Tensor","s":"In-place version of :meth:`~Tensor.addmv`"},{"l":"addr","k":"function","d":"(vec1, vec2, *, beta=1, alpha=1) -> Tensor","s":"See :func:`torch.addr`"},{"l":"addr_","k":"function","d":"(vec1, vec2, *, beta=1, alpha=1) -> Tensor","s":"In-place version of :meth:`~Tensor.addr`"},{"l":"adjoint","k":"function","d":"() -> Tensor","s":"Alias for :func:`adjoint`"},{"l":"all","k":"function","d":"(dim=None, keepdim=False) -> Tensor","s":"See :func:`torch.all`"},{"l":"allclose","k":"function","d":"(other, rtol=1e-05, atol=1e-08, equal_nan=False) -> Tensor","s":"See :func:`torch.allclose`"},{"l":"amax","k":"function","d":"(dim=None, keepdim=False) -> Tensor","s":"See :func:`torch.amax`"},{"l":"amin","k":"function","d":"(dim=None, keepdim=False) -> Tensor","s":"See :func:`torch.amin`"},{"l":"aminmax","k":"function","d":"(*, dim=None, keepdim=False) -> (Tensor min, Tensor max)","s":"See :func:`torch.aminmax`"},{"l":"angle","k":"function","d":"() -> Tensor","s":"See :func:`torch.angle`"},{"l":"any","k":"function","d":"(dim=None, keepdim=False) -> Tensor","s":"See :func:`torch.any`"},{"l":"apply_","k":"function","d":"(callable) -> Tensor","s":"Applies the function :attr:`callable` to each element in the tensor, replacing"},{"l":"arccos","k":"function","d":"() -> Tensor","s":"See :func:`torch.arccos`"},{"l":"arccos_","k":"function","d":"() -> Tensor","s":"In-place version of :meth:`~Tensor.arccos`"},{"l":"arccosh","k":"function","s":"acosh() -> Tensor"},{"l":"arccosh_","k":"function","s":"acosh_() -> Tensor"},{"l":"arcsin","k":"function","d":"() -> Tensor","s":"See :func:`torch.arcsin`"},{"l":"arcsin_","k":"function","d":"() -> Tensor","s":"In-place version of :meth:`~Tensor.arcsin`"},{"l":"arcsinh","k":"function","d":"() -> Tensor","s":"See :func:`torch.arcsinh`"},{"l":"arcsinh_","k":"function","d":"() -> Tensor","s":"In-place version of :meth:`~Tensor.arcsinh`"},{"l":"arctan","k":"function","d":"() -> Tensor","s":"See :func:`torch.arctan`"},{"l":"arctan2","k":"function","d":"(other) -> Tensor","s":"See :func:`torch.arctan2`"},{"l":"arctan2_","k":"function","s":"atan2_(other) -> Tensor"},{"l":"arctan_","k":"function","d":"() -> Tensor","s":"In-place version of :meth:`~Tensor.arctan`"},{"l":"arctanh","k":"function","d":"() -> Tensor","s":"See :func:`torch.arctanh`"},{"l":"arctanh_","k":"function","d":"(other) -> Tensor","s":"In-place version of :meth:`~Tensor.arctanh`"},{"l":"argmax","k":"function","d":"(dim=None, keepdim=False) -> LongTensor","s":"See :func:`torch.argmax`"},{"l":"argmin","k":"function","d":"(dim=None, keepdim=False) -> LongTensor","s":"See :func:`torch.argmin`"},{"l":"argsort","k":"function","d":"(dim=-1, descending=False) -> LongTensor","s":"See :func:`torch.argsort`"},{"l":"argwhere","k":"function","d":"() -> Tensor","s":"See :func:`torch.argwhere`"},{"l":"as_strided","k":"function","d":"(size, stride, storage_offset=None) -> Tensor","s":"See :func:`torch.as_strided`"},{"l":"as_strided_","k":"function","d":"(size, stride, storage_offset=None) -> Tensor","s":"In-place version of :meth:`~Tensor.as_strided`"},{"l":"as_strided_scatter","k":"function","d":"(src, size, stride, storage_offset=None) -> Tensor","s":"See :func:`torch.as_strided_scatter`"},{"l":"as_subclass","k":"function","d":"(cls) -> Tensor","s":"Makes a ``cls`` instance with the same data pointer as ``self``. Changes"},{"l":"asin","k":"function","d":"() -> Tensor","s":"See :func:`torch.asin`"},{"l":"asin_","k":"function","d":"() -> Tensor","s":"In-place version of :meth:`~Tensor.asin`"},{"l":"asinh","k":"function","d":"() -> Tensor","s":"See :func:`torch.asinh`"},{"l":"asinh_","k":"function","d":"() -> Tensor","s":"In-place version of :meth:`~Tensor.asinh`"},{"l":"atan","k":"function","d":"() -> Tensor","s":"See :func:`torch.atan`"},{"l":"atan2","k":"function","d":"(other) -> Tensor","s":"See :func:`torch.atan2`"},{"l":"atan2_","k":"function","d":"(other) -> Tensor","s":"In-place version of :meth:`~Tensor.atan2`"},{"l":"atan_","k":"function","d":"() -> Tensor","s":"In-place version of :meth:`~Tensor.atan`"},{"l":"atanh","k":"function","d":"() -> Tensor","s":"See :func:`torch.atanh`"},{"l":"atanh_","k":"function","d":"(other) -> Tensor","s":"In-place version of :meth:`~Tensor.atanh`"},{"l":"backward","k":"function","d":"(self, gradient=None, retain_graph=None, create_graph=False, inputs=None)","s":"Computes the gradient of current tensor wrt graph leaves."},{"l":"baddbmm","k":"function","d":"(batch1, batch2, *, beta=1, alpha=1) -> Tensor","s":"See :func:`torch.baddbmm`"},{"l":"baddbmm_","k":"function","d":"(batch1, batch2, *, beta=1, alpha=1) -> Tensor","s":"In-place version of :meth:`~Tensor.baddbmm`"},{"l":"bernoulli","k":"function","d":"(*, generator=None) -> Tensor","s":"Returns a result tensor where each :math:`\\texttt{result[i]}` is independently"},{"l":"bernoulli_","k":"function","d":"(p=0.5, *, generator=None) -> Tensor","s":"Fills each location of :attr:`self` with an independent sample from"},{"l":"bfloat16","k":"function","d":"(memory_format=torch.preserve_format) -> Tensor","s":"``self.bfloat16()`` is equivalent to ``self.to(torch.bfloat16)``. See :func:`to`."},{"l":"bincount","k":"function","d":"(weights=None, minlength=0) -> Tensor","s":"See :func:`torch.bincount`"},{"l":"bitwise_and","k":"function","d":"() -> Tensor","s":"See :func:`torch.bitwise_and`"},{"l":"bitwise_and_","k":"function","d":"() -> Tensor","s":"In-place version of :meth:`~Tensor.bitwise_and`"},{"l":"bitwise_left_shift","k":"function","d":"(other) -> Tensor","s":"See :func:`torch.bitwise_left_shift`"},{"l":"bitwise_left_shift_","k":"function","d":"(other) -> Tensor","s":"In-place version of :meth:`~Tensor.bitwise_left_shift`"},{"l":"bitwise_not","k":"function","d":"() -> Tensor","s":"See :func:`torch.bitwise_not`"},{"l":"bitwise_not_","k":"function","d":"() -> Tensor","s":"In-place version of :meth:`~Tensor.bitwise_not`"},{"l":"bitwise_or","k":"function","d":"() -> Tensor","s":"See :func:`torch.bitwise_or`"},{"l":"bitwise_or_","k":"function","d":"() -> Tensor","s":"In-place version of :meth:`~Tensor.bitwise_or`"},{"l":"bitwise_right_shift","k":"function","d":"(other) -> Tensor","s":"See :func:`torch.bitwise_right_shift`"},{"l":"bitwise_right_shift_","k":"function","d":"(other) -> Tensor","s":"In-place version of :meth:`~Tensor.bitwise_right_shift`"},{"l":"bitwise_xor","k":"function","d":"() -> Tensor","s":"See :func:`torch.bitwise_xor`"},{"l":"bitwise_xor_","k":"function","d":"() -> Tensor","s":"In-place version of :meth:`~Tensor.bitwise_xor`"},{"l":"bmm","k":"function","d":"(batch2) -> Tensor","s":"See :func:`torch.bmm`"},{"l":"bool","k":"function","d":"(memory_format=torch.preserve_format) -> Tensor","s":"``self.bool()`` is equivalent to ``self.to(torch.bool)``. See :func:`to`."},{"l":"broadcast_to","k":"function","d":"(shape) -> Tensor","s":"See :func:`torch.broadcast_to`."},{"l":"byte","k":"function","d":"(memory_format=torch.preserve_format) -> Tensor","s":"``self.byte()`` is equivalent to ``self.to(torch.uint8)``. See :func:`to`."},{"l":"cauchy_","k":"function","d":"(median=0, sigma=1, *, generator=None) -> Tensor","s":"Fills the tensor with numbers drawn from the Cauchy distribution:"},{"l":"ccol_indices","k":"function"},{"l":"cdouble","k":"function","d":"(memory_format=torch.preserve_format) -> Tensor","s":"``self.cdouble()`` is equivalent to ``self.to(torch.complex128)``. See :func:`to`."},{"l":"ceil","k":"function","d":"() -> Tensor","s":"See :func:`torch.ceil`"},{"l":"ceil_","k":"function","d":"() -> Tensor","s":"In-place version of :meth:`~Tensor.ceil`"},{"l":"cfloat","k":"function","d":"(memory_format=torch.preserve_format) -> Tensor","s":"``self.cfloat()`` is equivalent to ``self.to(torch.complex64)``. See :func:`to`."},{"l":"chalf","k":"function","d":"(memory_format=torch.preserve_format) -> Tensor","s":"``self.chalf()`` is equivalent to ``self.to(torch.complex32)``. See :func:`to`."},{"l":"char","k":"function","d":"(memory_format=torch.preserve_format) -> Tensor","s":"``self.char()`` is equivalent to ``self.to(torch.int8)``. See :func:`to`."},{"l":"cholesky","k":"function","d":"(upper=False) -> Tensor","s":"See :func:`torch.cholesky`"},{"l":"cholesky_inverse","k":"function","d":"(upper=False) -> Tensor","s":"See :func:`torch.cholesky_inverse`"},{"l":"cholesky_solve","k":"function","d":"(input2, upper=False) -> Tensor","s":"See :func:`torch.cholesky_solve`"},{"l":"chunk","k":"function","d":"(chunks, dim=0) -> List of Tensors","s":"See :func:`torch.chunk`"},{"l":"clamp","k":"function","d":"(min=None, max=None) -> Tensor","s":"See :func:`torch.clamp`"},{"l":"clamp_","k":"function","d":"(min=None, max=None) -> Tensor","s":"In-place version of :meth:`~Tensor.clamp`"},{"l":"clamp_max","k":"function"},{"l":"clamp_max_","k":"function"},{"l":"clamp_min","k":"function"},{"l":"clamp_min_","k":"function"},{"l":"clip","k":"function","d":"(min=None, max=None) -> Tensor","s":"Alias for :meth:`~Tensor.clamp`."},{"l":"clip_","k":"function","d":"(min=None, max=None) -> Tensor","s":"Alias for :meth:`~Tensor.clamp_`."},{"l":"clone","k":"function","d":"(*, memory_format=torch.preserve_format) -> Tensor","s":"See :func:`torch.clone`"},{"l":"coalesce","k":"function","d":"() -> Tensor","s":"Returns a coalesced copy of :attr:`self` if :attr:`self` is an"},{"l":"col_indices","k":"function","d":"() -> IntTensor","s":"Returns the tensor containing the column indices of the :attr:`self`"},{"l":"conj","k":"function","d":"() -> Tensor","s":"See :func:`torch.conj`"},{"l":"conj_physical","k":"function","d":"() -> Tensor","s":"See :func:`torch.conj_physical`"},{"l":"conj_physical_","k":"function","d":"() -> Tensor","s":"In-place version of :meth:`~Tensor.conj_physical`"},{"l":"const_data_ptr","k":"function","d":"() -> int","s":"Returns the address of the first element of :attr:`self` tensor."},{"l":"contiguous","k":"function","d":"(memory_format=torch.contiguous_format) -> Tensor","s":"Returns a contiguous in memory tensor containing the same data as :attr:`self` tensor. If"},{"l":"copy_","k":"function","d":"(src, non_blocking=False) -> Tensor","s":"Copies the elements from :attr:`src` into :attr:`self` tensor and returns"},{"l":"copysign","k":"function","d":"(other) -> Tensor","s":"See :func:`torch.copysign`"},{"l":"copysign_","k":"function","d":"(other) -> Tensor","s":"In-place version of :meth:`~Tensor.copysign`"},{"l":"corrcoef","k":"function","d":"() -> Tensor","s":"See :func:`torch.corrcoef`"},{"l":"cos","k":"function","d":"() -> Tensor","s":"See :func:`torch.cos`"},{"l":"cos_","k":"function","d":"() -> Tensor","s":"In-place version of :meth:`~Tensor.cos`"},{"l":"cosh","k":"function","d":"() -> Tensor","s":"See :func:`torch.cosh`"},{"l":"cosh_","k":"function","d":"() -> Tensor","s":"In-place version of :meth:`~Tensor.cosh`"},{"l":"count_nonzero","k":"function","d":"(dim=None) -> Tensor","s":"See :func:`torch.count_nonzero`"},{"l":"cov","k":"function","d":"(*, correction=1, fweights=None, aweights=None) -> Tensor","s":"See :func:`torch.cov`"},{"l":"cpu","k":"function","d":"(memory_format=torch.preserve_format) -> Tensor","s":"Returns a copy of this object in CPU memory."},{"l":"cross","k":"function","d":"(other, dim=None) -> Tensor","s":"See :func:`torch.cross`"},{"l":"crow_indices","k":"function","d":"() -> IntTensor","s":"Returns the tensor containing the compressed row indices of the :attr:`self`"},{"l":"cuda","k":"function","d":"(device=None, non_blocking=False, memory_format=torch.preserve_format) -> Tensor","s":"Returns a copy of this object in CUDA memory."},{"l":"cummax","k":"function","d":"(dim) -> (Tensor, Tensor)","s":"See :func:`torch.cummax`"},{"l":"cummin","k":"function","d":"(dim) -> (Tensor, Tensor)","s":"See :func:`torch.cummin`"},{"l":"cumprod","k":"function","d":"(dim, dtype=None) -> Tensor","s":"See :func:`torch.cumprod`"},{"l":"cumprod_","k":"function","d":"(dim, dtype=None) -> Tensor","s":"In-place version of :meth:`~Tensor.cumprod`"},{"l":"cumsum","k":"function","d":"(dim, dtype=None) -> Tensor","s":"See :func:`torch.cumsum`"},{"l":"cumsum_","k":"function","d":"(dim, dtype=None) -> Tensor","s":"In-place version of :meth:`~Tensor.cumsum`"},{"l":"data","k":"property"},{"l":"data_ptr","k":"function","d":"() -> int","s":"Returns the address of the first element of :attr:`self` tensor."},{"l":"deg2rad","k":"function","d":"() -> Tensor","s":"See :func:`torch.deg2rad`"},{"l":"deg2rad_","k":"function","d":"() -> Tensor","s":"In-place version of :meth:`~Tensor.deg2rad`"},{"l":"dense_dim","k":"function","d":"() -> int","s":"Return the number of dense dimensions in a :ref:`sparse tensor ` :attr:`self`."},{"l":"dequantize","k":"function","d":"() -> Tensor","s":"Given a quantized Tensor, dequantize it and return the dequantized float Tensor."},{"l":"det","k":"function","d":"() -> Tensor","s":"See :func:`torch.det`"},{"l":"detach","k":"function","s":"Returns a new Tensor, detached from the current graph."},{"l":"detach_","k":"function","s":"Detaches the Tensor from the graph that created it, making it a leaf."},{"l":"device","k":"property","s":"Is the :class:`torch.device` where this Tensor is."},{"l":"diag","k":"function","d":"(diagonal=0) -> Tensor","s":"See :func:`torch.diag`"},{"l":"diag_embed","k":"function","d":"(offset=0, dim1=-2, dim2=-1) -> Tensor","s":"See :func:`torch.diag_embed`"},{"l":"diagflat","k":"function","d":"(offset=0) -> Tensor","s":"See :func:`torch.diagflat`"},{"l":"diagonal","k":"function","d":"(offset=0, dim1=0, dim2=1) -> Tensor","s":"See :func:`torch.diagonal`"},{"l":"diagonal_scatter","k":"function","d":"(src, offset=0, dim1=0, dim2=1) -> Tensor","s":"See :func:`torch.diagonal_scatter`"},{"l":"diff","k":"function","d":"(n=1, dim=-1, prepend=None, append=None) -> Tensor","s":"See :func:`torch.diff`"},{"l":"digamma","k":"function","d":"() -> Tensor","s":"See :func:`torch.digamma`"},{"l":"digamma_","k":"function","d":"() -> Tensor","s":"In-place version of :meth:`~Tensor.digamma`"},{"l":"dim","k":"function","d":"() -> int","s":"Returns the number of dimensions of :attr:`self` tensor."},{"l":"dim_order","k":"function","d":"(self, *, ambiguity_check: bool | list[torch.memory_format] = False)","s":"Returns the uniquely determined tuple of int describing the dim order or"},{"l":"dist","k":"function","d":"(other, p=2) -> Tensor","s":"See :func:`torch.dist`"},{"l":"div","k":"function","d":"(value, *, rounding_mode=None) -> Tensor","s":"See :func:`torch.div`"},{"l":"div_","k":"function","d":"(value, *, rounding_mode=None) -> Tensor","s":"In-place version of :meth:`~Tensor.div`"},{"l":"divide","k":"function","d":"(value, *, rounding_mode=None) -> Tensor","s":"See :func:`torch.divide`"},{"l":"divide_","k":"function","d":"(value, *, rounding_mode=None) -> Tensor","s":"In-place version of :meth:`~Tensor.divide`"},{"l":"dot","k":"function","d":"(other) -> Tensor","s":"See :func:`torch.dot`"},{"l":"double","k":"function","d":"(memory_format=torch.preserve_format) -> Tensor","s":"``self.double()`` is equivalent to ``self.to(torch.float64)``. See :func:`to`."},{"l":"dsplit","k":"function","d":"(split_size_or_sections) -> List of Tensors","s":"See :func:`torch.dsplit`"},{"l":"dtype","k":"property"},{"l":"eig","k":"function","d":"(self, eigenvectors=False)"},{"l":"element_size","k":"function","d":"() -> int","s":"Returns the size in bytes of an individual element."},{"l":"eq","k":"function","d":"(other) -> Tensor","s":"See :func:`torch.eq`"},{"l":"eq_","k":"function","d":"(other) -> Tensor","s":"In-place version of :meth:`~Tensor.eq`"},{"l":"equal","k":"function","d":"(other) -> bool","s":"See :func:`torch.equal`"},{"l":"erf","k":"function","d":"() -> Tensor","s":"See :func:`torch.erf`"},{"l":"erf_","k":"function","d":"() -> Tensor","s":"In-place version of :meth:`~Tensor.erf`"},{"l":"erfc","k":"function","d":"() -> Tensor","s":"See :func:`torch.erfc`"},{"l":"erfc_","k":"function","d":"() -> Tensor","s":"In-place version of :meth:`~Tensor.erfc`"},{"l":"erfinv","k":"function","d":"() -> Tensor","s":"See :func:`torch.erfinv`"},{"l":"erfinv_","k":"function","d":"() -> Tensor","s":"In-place version of :meth:`~Tensor.erfinv`"},{"l":"exp","k":"function","d":"() -> Tensor","s":"See :func:`torch.exp`"},{"l":"exp2","k":"function","d":"() -> Tensor","s":"See :func:`torch.exp2`"},{"l":"exp2_","k":"function","d":"() -> Tensor","s":"In-place version of :meth:`~Tensor.exp2`"},{"l":"exp_","k":"function","d":"() -> Tensor","s":"In-place version of :meth:`~Tensor.exp`"},{"l":"expand","k":"function","d":"(*size) -> Tensor","s":"Returns a new view of the :attr:`self` tensor with singleton dimensions expanded"},{"l":"expand_as","k":"function","d":"(other) -> Tensor","s":"Expand this tensor to the same size as :attr:`other`."},{"l":"expm1","k":"function","d":"() -> Tensor","s":"See :func:`torch.expm1`"},{"l":"expm1_","k":"function","d":"() -> Tensor","s":"In-place version of :meth:`~Tensor.expm1`"},{"l":"exponential_","k":"function","d":"(lambd=1, *, generator=None) -> Tensor","s":"Fills :attr:`self` tensor with elements drawn from the PDF (probability density function):"},{"l":"fill_","k":"function","d":"(value) -> Tensor","s":"Fills :attr:`self` tensor with the specified value."},{"l":"fill_diagonal_","k":"function","d":"(fill_value, wrap=False) -> Tensor","s":"Fill the main diagonal of a tensor that has at least 2-dimensions."},{"l":"fix","k":"function","d":"() -> Tensor","s":"See :func:`torch.fix`."},{"l":"fix_","k":"function","d":"() -> Tensor","s":"In-place version of :meth:`~Tensor.fix`"},{"l":"flatten","k":"function","d":"(start_dim=0, end_dim=-1) -> Tensor","s":"See :func:`torch.flatten`"},{"l":"flip","k":"function","d":"(dims) -> Tensor","s":"See :func:`torch.flip`"},{"l":"fliplr","k":"function","d":"() -> Tensor","s":"See :func:`torch.fliplr`"},{"l":"flipud","k":"function","d":"() -> Tensor","s":"See :func:`torch.flipud`"},{"l":"float","k":"function","d":"(memory_format=torch.preserve_format) -> Tensor","s":"``self.float()`` is equivalent to ``self.to(torch.float32)``. See :func:`to`."},{"l":"float_power","k":"function","d":"(exponent) -> Tensor","s":"See :func:`torch.float_power`"},{"l":"float_power_","k":"function","d":"(exponent) -> Tensor","s":"In-place version of :meth:`~Tensor.float_power`"},{"l":"floor","k":"function","d":"() -> Tensor","s":"See :func:`torch.floor`"},{"l":"floor_","k":"function","d":"() -> Tensor","s":"In-place version of :meth:`~Tensor.floor`"},{"l":"floor_divide","k":"function","d":"(value) -> Tensor","s":"See :func:`torch.floor_divide`"},{"l":"floor_divide_","k":"function","d":"(value) -> Tensor","s":"In-place version of :meth:`~Tensor.floor_divide`"},{"l":"fmax","k":"function","d":"(other) -> Tensor","s":"See :func:`torch.fmax`"},{"l":"fmin","k":"function","d":"(other) -> Tensor","s":"See :func:`torch.fmin`"},{"l":"fmod","k":"function","d":"(divisor) -> Tensor","s":"See :func:`torch.fmod`"},{"l":"fmod_","k":"function","d":"(divisor) -> Tensor","s":"In-place version of :meth:`~Tensor.fmod`"},{"l":"frac","k":"function","d":"() -> Tensor","s":"See :func:`torch.frac`"},{"l":"frac_","k":"function","d":"() -> Tensor","s":"In-place version of :meth:`~Tensor.frac`"},{"l":"frexp","k":"function","d":"(input) -> (Tensor mantissa, Tensor exponent)","s":"See :func:`torch.frexp`"},{"l":"gather","k":"function","d":"(dim, index) -> Tensor","s":"See :func:`torch.gather`"},{"l":"gcd","k":"function","d":"(other) -> Tensor","s":"See :func:`torch.gcd`"},{"l":"gcd_","k":"function","d":"(other) -> Tensor","s":"In-place version of :meth:`~Tensor.gcd`"},{"l":"ge","k":"function","d":"(other) -> Tensor","s":"See :func:`torch.ge`."},{"l":"ge_","k":"function","d":"(other) -> Tensor","s":"In-place version of :meth:`~Tensor.ge`."},{"l":"geometric_","k":"function","d":"(p, *, generator=None) -> Tensor","s":"Fills :attr:`self` tensor with elements drawn from the geometric distribution:"},{"l":"geqrf","k":"function","d":"() -> (Tensor, Tensor)","s":"See :func:`torch.geqrf`"},{"l":"ger","k":"function","d":"(vec2) -> Tensor","s":"See :func:`torch.ger`"},{"l":"get_device","k":"function","d":"() -> Device ordinal (Integer)","s":"For CUDA tensors, this function returns the device ordinal of the GPU on which the tensor resides."},{"l":"grad","k":"property","s":"This attribute is ``None`` by default and becomes a Tensor the first time a call to"},{"l":"grad_dtype","k":"property","s":"The allowed dtype of :attr:``grad`` for this tensor."},{"l":"grad_fn","k":"property"},{"l":"greater","k":"function","d":"(other) -> Tensor","s":"See :func:`torch.greater`."},{"l":"greater_","k":"function","d":"(other) -> Tensor","s":"In-place version of :meth:`~Tensor.greater`."},{"l":"greater_equal","k":"function","d":"(other) -> Tensor","s":"See :func:`torch.greater_equal`."},{"l":"greater_equal_","k":"function","d":"(other) -> Tensor","s":"In-place version of :meth:`~Tensor.greater_equal`."},{"l":"gt","k":"function","d":"(other) -> Tensor","s":"See :func:`torch.gt`."},{"l":"gt_","k":"function","d":"(other) -> Tensor","s":"In-place version of :meth:`~Tensor.gt`."},{"l":"half","k":"function","d":"(memory_format=torch.preserve_format) -> Tensor","s":"``self.half()`` is equivalent to ``self.to(torch.float16)``. See :func:`to`."},{"l":"hardshrink","k":"function","d":"(lambd=0.5) -> Tensor","s":"See :func:`torch.nn.functional.hardshrink`"},{"l":"hash_tensor","k":"function"},{"l":"heaviside","k":"function","d":"(values) -> Tensor","s":"See :func:`torch.heaviside`"},{"l":"heaviside_","k":"function","d":"(values) -> Tensor","s":"In-place version of :meth:`~Tensor.heaviside`"},{"l":"histc","k":"function","d":"(bins=100, min=0, max=0) -> Tensor","s":"See :func:`torch.histc`"},{"l":"histogram","k":"function","d":"(input, bins, *, range=None, weight=None, density=False) -> (Tensor, Tensor)","s":"See :func:`torch.histogram`"},{"l":"hsplit","k":"function","d":"(split_size_or_sections) -> List of Tensors","s":"See :func:`torch.hsplit`"},{"l":"hypot","k":"function","d":"(other) -> Tensor","s":"See :func:`torch.hypot`"},{"l":"hypot_","k":"function","d":"(other) -> Tensor","s":"In-place version of :meth:`~Tensor.hypot`"},{"l":"i0","k":"function","d":"() -> Tensor","s":"See :func:`torch.i0`"},{"l":"i0_","k":"function","d":"() -> Tensor","s":"In-place version of :meth:`~Tensor.i0`"},{"l":"igamma","k":"function","d":"(other) -> Tensor","s":"See :func:`torch.igamma`"},{"l":"igamma_","k":"function","d":"(other) -> Tensor","s":"In-place version of :meth:`~Tensor.igamma`"},{"l":"igammac","k":"function","d":"(other) -> Tensor","s":"See :func:`torch.igammac`"},{"l":"igammac_","k":"function","d":"(other) -> Tensor","s":"In-place version of :meth:`~Tensor.igammac`"},{"l":"imag","k":"property","s":"Returns a new tensor containing imaginary values of the :attr:`self` tensor."},{"l":"index","k":"function","d":"(self, positions, dims)","s":"Index a regular tensor by binding specified positions to dims."},{"l":"index_add","k":"function","d":"(dim, index, source, *, alpha=1) -> Tensor","s":"Out-of-place version of :meth:`torch.Tensor.index_add_`."},{"l":"index_add_","k":"function","d":"(dim, index, source, *, alpha=1) -> Tensor","s":"Accumulate the elements of :attr:`alpha` times ``source`` into the :attr:`self`"},{"l":"index_copy","k":"function","d":"(dim, index, tensor2) -> Tensor","s":"Out-of-place version of :meth:`torch.Tensor.index_copy_`."},{"l":"index_copy_","k":"function","d":"(dim, index, tensor) -> Tensor","s":"Copies the elements of :attr:`tensor` into the :attr:`self` tensor by selecting"},{"l":"index_fill","k":"function","d":"(dim, index, value) -> Tensor","s":"Out-of-place version of :meth:`torch.Tensor.index_fill_`."},{"l":"index_fill_","k":"function","d":"(dim, index, value) -> Tensor","s":"Fills the elements of the :attr:`self` tensor with value :attr:`value` by"},{"l":"index_put","k":"function","d":"(indices, values, accumulate=False) -> Tensor","s":"Out-place version of :meth:`~Tensor.index_put_`."},{"l":"index_put_","k":"function","d":"(indices, values, accumulate=False) -> Tensor","s":"Puts values from the tensor :attr:`values` into the tensor :attr:`self` using"},{"l":"index_reduce","k":"function"},{"l":"index_reduce_","k":"function","d":"(dim, index, source, reduce, *, include_self=True) -> Tensor","s":"Accumulate the elements of ``source`` into the :attr:`self`"},{"l":"index_select","k":"function","d":"(dim, index) -> Tensor","s":"See :func:`torch.index_select`"},{"l":"indices","k":"function","d":"() -> Tensor","s":"Return the indices tensor of a :ref:`sparse COO tensor `."},{"l":"inner","k":"function","d":"(other) -> Tensor","s":"See :func:`torch.inner`."},{"l":"int","k":"function","d":"(memory_format=torch.preserve_format) -> Tensor","s":"``self.int()`` is equivalent to ``self.to(torch.int32)``. See :func:`to`."},{"l":"int_repr","k":"function","d":"() -> Tensor","s":"Given a quantized Tensor,"},{"l":"inverse","k":"function","d":"() -> Tensor","s":"See :func:`torch.inverse`"},{"l":"ipu","k":"function","d":"(device=None, non_blocking=False, memory_format=torch.preserve_format) -> Tensor","s":"Returns a copy of this object in IPU memory."},{"l":"is_coalesced","k":"function","d":"() -> bool","s":"Returns ``True`` if :attr:`self` is a :ref:`sparse COO tensor"},{"l":"is_complex","k":"function","d":"() -> bool","s":"Returns True if the data type of :attr:`self` is a complex data type."},{"l":"is_conj","k":"function","d":"() -> bool","s":"Returns True if the conjugate bit of :attr:`self` is set to true."},{"l":"is_contiguous","k":"function","d":"(memory_format=torch.contiguous_format) -> bool","s":"Returns True if :attr:`self` tensor is contiguous in memory in the order specified"},{"l":"is_cpu","k":"property","s":"Is ``True`` if the Tensor is stored on the CPU, ``False`` otherwise."},{"l":"is_cuda","k":"property","s":"Is ``True`` if the Tensor is stored on the GPU, ``False`` otherwise."},{"l":"is_distributed","k":"function"},{"l":"is_floating_point","k":"function","d":"() -> bool","s":"Returns True if the data type of :attr:`self` is a floating point data type."},{"l":"is_inference","k":"function","d":"() -> bool","s":"See :func:`torch.is_inference`"},{"l":"is_ipu","k":"property","s":"Is ``True`` if the Tensor is stored on the IPU, ``False`` otherwise."},{"l":"is_leaf","k":"property","s":"All Tensors that have :attr:`requires_grad` which is ``False`` will be leaf Tensors by convention."},{"l":"is_maia","k":"property"},{"l":"is_meta","k":"property","s":"Is ``True`` if the Tensor is a meta tensor, ``False`` otherwise. Meta tensors"},{"l":"is_mkldnn","k":"property"},{"l":"is_mps","k":"property","s":"Is ``True`` if the Tensor is stored on the MPS device, ``False`` otherwise."},{"l":"is_mtia","k":"property"},{"l":"is_neg","k":"function","d":"() -> bool","s":"Returns True if the negative bit of :attr:`self` is set to true."},{"l":"is_nested","k":"property"},{"l":"is_nonzero","k":"function"},{"l":"is_pinned","k":"function","s":"Returns true if this tensor resides in pinned memory."},{"l":"is_quantized","k":"property","s":"Is ``True`` if the Tensor is quantized, ``False`` otherwise."},{"l":"is_same_size","k":"function"},{"l":"is_set_to","k":"function","d":"(tensor) -> bool","s":"Returns True if both tensors are pointing to the exact same memory (same"},{"l":"is_shared","k":"function","d":"(self)","s":"Checks if tensor is in shared memory."},{"l":"is_signed","k":"function","d":"() -> bool","s":"Returns True if the data type of :attr:`self` is a signed data type."},{"l":"is_sparse","k":"property","s":"Is ``True`` if the Tensor uses sparse COO storage layout, ``False`` otherwise."},{"l":"is_sparse_csr","k":"property","s":"Is ``True`` if the Tensor uses sparse CSR storage layout, ``False`` otherwise."},{"l":"is_vulkan","k":"property"},{"l":"is_xla","k":"property","s":"Is ``True`` if the Tensor is stored on an XLA device, ``False`` otherwise."},{"l":"is_xpu","k":"property","s":"Is ``True`` if the Tensor is stored on the XPU, ``False`` otherwise."},{"l":"isclose","k":"function","d":"(other, rtol=1e-05, atol=1e-08, equal_nan=False) -> Tensor","s":"See :func:`torch.isclose`"},{"l":"isfinite","k":"function","d":"() -> Tensor","s":"See :func:`torch.isfinite`"},{"l":"isinf","k":"function","d":"() -> Tensor","s":"See :func:`torch.isinf`"},{"l":"isnan","k":"function","d":"() -> Tensor","s":"See :func:`torch.isnan`"},{"l":"isneginf","k":"function","d":"() -> Tensor","s":"See :func:`torch.isneginf`"},{"l":"isposinf","k":"function","d":"() -> Tensor","s":"See :func:`torch.isposinf`"},{"l":"isreal","k":"function","d":"() -> Tensor","s":"See :func:`torch.isreal`"},{"l":"istft","k":"function","d":"(self, n_fft: int, hop_length: int | None = None, win_length: int | None = None, window: 'Tensor | None' = None, center: bool = True, normalized: bool = False, onesided: bool | None = None, length: int | None = None, return_complex: bool = False)","s":"See :func:`torch.istft`"},{"l":"item","k":"function","d":"() -> number","s":"Returns the value of this tensor as a standard Python number. This only works"},{"l":"itemsize","k":"property","s":"Alias for :meth:`~Tensor.element_size()`"},{"l":"kron","k":"function","d":"(other) -> Tensor","s":"See :func:`torch.kron`"},{"l":"kthvalue","k":"function","d":"(k, dim=None, keepdim=False) -> (Tensor, LongTensor)","s":"See :func:`torch.kthvalue`"},{"l":"layout","k":"property"},{"l":"lcm","k":"function","d":"(other) -> Tensor","s":"See :func:`torch.lcm`"},{"l":"lcm_","k":"function","d":"(other) -> Tensor","s":"In-place version of :meth:`~Tensor.lcm`"},{"l":"ldexp","k":"function","d":"(other) -> Tensor","s":"See :func:`torch.ldexp`"},{"l":"ldexp_","k":"function","d":"(other) -> Tensor","s":"In-place version of :meth:`~Tensor.ldexp`"},{"l":"le","k":"function","d":"(other) -> Tensor","s":"See :func:`torch.le`."},{"l":"le_","k":"function","d":"(other) -> Tensor","s":"In-place version of :meth:`~Tensor.le`."},{"l":"lerp","k":"function","d":"(end, weight) -> Tensor","s":"See :func:`torch.lerp`"},{"l":"lerp_","k":"function","d":"(end, weight) -> Tensor","s":"In-place version of :meth:`~Tensor.lerp`"},{"l":"less","k":"function","s":"lt(other) -> Tensor"},{"l":"less_","k":"function","d":"(other) -> Tensor","s":"In-place version of :meth:`~Tensor.less`."},{"l":"less_equal","k":"function","d":"(other) -> Tensor","s":"See :func:`torch.less_equal`."},{"l":"less_equal_","k":"function","d":"(other) -> Tensor","s":"In-place version of :meth:`~Tensor.less_equal`."},{"l":"lgamma","k":"function","d":"() -> Tensor","s":"See :func:`torch.lgamma`"},{"l":"lgamma_","k":"function","d":"() -> Tensor","s":"In-place version of :meth:`~Tensor.lgamma`"},{"l":"log","k":"function","d":"() -> Tensor","s":"See :func:`torch.log`"},{"l":"log10","k":"function","d":"() -> Tensor","s":"See :func:`torch.log10`"},{"l":"log10_","k":"function","d":"() -> Tensor","s":"In-place version of :meth:`~Tensor.log10`"},{"l":"log1p","k":"function","d":"() -> Tensor","s":"See :func:`torch.log1p`"},{"l":"log1p_","k":"function","d":"() -> Tensor","s":"In-place version of :meth:`~Tensor.log1p`"},{"l":"log2","k":"function","d":"() -> Tensor","s":"See :func:`torch.log2`"},{"l":"log2_","k":"function","d":"() -> Tensor","s":"In-place version of :meth:`~Tensor.log2`"},{"l":"log_","k":"function","d":"() -> Tensor","s":"In-place version of :meth:`~Tensor.log`"},{"l":"log_normal_","k":"function","d":"(mean=1, std=2, *, generator=None)","s":"Fills :attr:`self` tensor with numbers samples from the log-normal distribution"},{"l":"log_softmax","k":"function"},{"l":"logaddexp","k":"function","d":"(other) -> Tensor","s":"See :func:`torch.logaddexp`"},{"l":"logaddexp2","k":"function","d":"(other) -> Tensor","s":"See :func:`torch.logaddexp2`"},{"l":"logcumsumexp","k":"function","d":"(dim) -> Tensor","s":"See :func:`torch.logcumsumexp`"},{"l":"logdet","k":"function","d":"() -> Tensor","s":"See :func:`torch.logdet`"},{"l":"logical_and","k":"function","d":"() -> Tensor","s":"See :func:`torch.logical_and`"},{"l":"logical_and_","k":"function","d":"() -> Tensor","s":"In-place version of :meth:`~Tensor.logical_and`"},{"l":"logical_not","k":"function","d":"() -> Tensor","s":"See :func:`torch.logical_not`"},{"l":"logical_not_","k":"function","d":"() -> Tensor","s":"In-place version of :meth:`~Tensor.logical_not`"},{"l":"logical_or","k":"function","d":"() -> Tensor","s":"See :func:`torch.logical_or`"},{"l":"logical_or_","k":"function","d":"() -> Tensor","s":"In-place version of :meth:`~Tensor.logical_or`"},{"l":"logical_xor","k":"function","d":"() -> Tensor","s":"See :func:`torch.logical_xor`"},{"l":"logical_xor_","k":"function","d":"() -> Tensor","s":"In-place version of :meth:`~Tensor.logical_xor`"},{"l":"logit","k":"function","d":"() -> Tensor","s":"See :func:`torch.logit`"},{"l":"logit_","k":"function","d":"() -> Tensor","s":"In-place version of :meth:`~Tensor.logit`"},{"l":"logsumexp","k":"function","d":"(dim, keepdim=False) -> Tensor","s":"See :func:`torch.logsumexp`"},{"l":"long","k":"function","d":"(memory_format=torch.preserve_format) -> Tensor","s":"``self.long()`` is equivalent to ``self.to(torch.int64)``. See :func:`to`."},{"l":"lstsq","k":"function","d":"(self, other)"},{"l":"lt","k":"function","d":"(other) -> Tensor","s":"See :func:`torch.lt`."},{"l":"lt_","k":"function","d":"(other) -> Tensor","s":"In-place version of :meth:`~Tensor.lt`."},{"l":"lu","k":"function","d":"(self, pivot=True, get_infos=False)","s":"See :func:`torch.lu`"},{"l":"lu_solve","k":"function","d":"(LU_data, LU_pivots) -> Tensor","s":"See :func:`torch.lu_solve`"},{"l":"mH","k":"property","s":"Accessing this property is equivalent to calling :func:`adjoint`."},{"l":"mT","k":"property","s":"Returns a view of this tensor with the last two dimensions transposed."},{"l":"map2_","k":"function"},{"l":"map_","k":"function","d":"(tensor, callable)","s":"Applies :attr:`callable` for each element in :attr:`self` tensor and the given"},{"l":"masked_fill","k":"function","d":"(mask, value) -> Tensor","s":"Out-of-place version of :meth:`torch.Tensor.masked_fill_`"},{"l":"masked_fill_","k":"function","d":"(mask, value)","s":"Fills elements of :attr:`self` tensor with :attr:`value` where :attr:`mask` is"},{"l":"masked_scatter","k":"function","d":"(mask, tensor) -> Tensor","s":"Out-of-place version of :meth:`torch.Tensor.masked_scatter_`"},{"l":"masked_scatter_","k":"function","d":"(mask, source)","s":"Copies elements from :attr:`source` into :attr:`self` tensor at positions where"},{"l":"masked_select","k":"function","d":"(mask) -> Tensor","s":"See :func:`torch.masked_select`"},{"l":"matmul","k":"function","d":"(tensor2) -> Tensor","s":"See :func:`torch.matmul`"},{"l":"matrix_exp","k":"function","d":"() -> Tensor","s":"See :func:`torch.matrix_exp`"},{"l":"matrix_power","k":"function","d":"(n) -> Tensor","s":".. note:: :meth:`~Tensor.matrix_power` is deprecated, use :func:`torch.linalg.matrix_power` instead."},{"l":"max","k":"function","d":"(dim=None, keepdim=False) -> Tensor or (Tensor, Tensor)","s":"See :func:`torch.max`"},{"l":"maximum","k":"function","d":"(other) -> Tensor","s":"See :func:`torch.maximum`"},{"l":"mean","k":"function","d":"(dim=None, keepdim=False, *, dtype=None) -> Tensor","s":"See :func:`torch.mean`"},{"l":"median","k":"function","d":"(dim=None, keepdim=False) -> (Tensor, LongTensor)","s":"See :func:`torch.median`"},{"l":"min","k":"function","d":"(dim=None, keepdim=False) -> Tensor or (Tensor, Tensor)","s":"See :func:`torch.min`"},{"l":"minimum","k":"function","d":"(other) -> Tensor","s":"See :func:`torch.minimum`"},{"l":"mm","k":"function","d":"(mat2) -> Tensor","s":"See :func:`torch.mm`"},{"l":"mode","k":"function","d":"(dim=None, keepdim=False) -> (Tensor, LongTensor)","s":"See :func:`torch.mode`"},{"l":"module_load","k":"function","d":"(self, other, assign=False)","s":"Defines how to transform ``other`` when loading it into ``self`` in :meth:`~nn.Module.load_state_dict`."},{"l":"moveaxis","k":"function","d":"(source, destination) -> Tensor","s":"See :func:`torch.moveaxis`"},{"l":"movedim","k":"function","d":"(source, destination) -> Tensor","s":"See :func:`torch.movedim`"},{"l":"msort","k":"function","d":"() -> Tensor","s":"See :func:`torch.msort`"},{"l":"mtia","k":"function","d":"(device=None, non_blocking=False, memory_format=torch.preserve_format) -> Tensor","s":"Returns a copy of this object in MTIA memory."},{"l":"mul","k":"function","d":"(value) -> Tensor","s":"See :func:`torch.mul`."},{"l":"mul_","k":"function","d":"(value) -> Tensor","s":"In-place version of :meth:`~Tensor.mul`."},{"l":"multinomial","k":"function","d":"(num_samples, replacement=False, *, generator=None) -> Tensor","s":"See :func:`torch.multinomial`"},{"l":"multiply","k":"function","d":"(value) -> Tensor","s":"See :func:`torch.multiply`."},{"l":"multiply_","k":"function","d":"(value) -> Tensor","s":"In-place version of :meth:`~Tensor.multiply`."},{"l":"mv","k":"function","d":"(vec) -> Tensor","s":"See :func:`torch.mv`"},{"l":"mvlgamma","k":"function","d":"(p) -> Tensor","s":"See :func:`torch.mvlgamma`"},{"l":"mvlgamma_","k":"function","d":"(p) -> Tensor","s":"In-place version of :meth:`~Tensor.mvlgamma`"},{"l":"name","k":"property"},{"l":"nan_to_num","k":"function","d":"(nan=0.0, posinf=None, neginf=None) -> Tensor","s":"See :func:`torch.nan_to_num`."},{"l":"nan_to_num_","k":"function","d":"(nan=0.0, posinf=None, neginf=None) -> Tensor","s":"In-place version of :meth:`~Tensor.nan_to_num`."},{"l":"nanmean","k":"function","d":"(dim=None, keepdim=False, *, dtype=None) -> Tensor","s":"See :func:`torch.nanmean`"},{"l":"nanmedian","k":"function","d":"(dim=None, keepdim=False) -> (Tensor, LongTensor)","s":"See :func:`torch.nanmedian`"},{"l":"nanquantile","k":"function","d":"(q, dim=None, keepdim=False, *, interpolation='linear') -> Tensor","s":"See :func:`torch.nanquantile`"},{"l":"nansum","k":"function","d":"(dim=None, keepdim=False, dtype=None) -> Tensor","s":"See :func:`torch.nansum`"},{"l":"narrow","k":"function","d":"(dimension, start, length) -> Tensor","s":"See :func:`torch.narrow`."},{"l":"narrow_copy","k":"function","d":"(dimension, start, length) -> Tensor","s":"See :func:`torch.narrow_copy`."},{"l":"nbytes","k":"property","s":"Returns the number of bytes consumed by the \"view\" of elements of the Tensor"},{"l":"ndim","k":"property","s":"Alias for :meth:`~Tensor.dim()`"},{"l":"ndimension","k":"function","d":"() -> int","s":"Alias for :meth:`~Tensor.dim()`"},{"l":"ne","k":"function","d":"(other) -> Tensor","s":"See :func:`torch.ne`."},{"l":"ne_","k":"function","d":"(other) -> Tensor","s":"In-place version of :meth:`~Tensor.ne`."},{"l":"neg","k":"function","d":"() -> Tensor","s":"See :func:`torch.neg`"},{"l":"neg_","k":"function","d":"() -> Tensor","s":"In-place version of :meth:`~Tensor.neg`"},{"l":"negative","k":"function","d":"() -> Tensor","s":"See :func:`torch.negative`"},{"l":"negative_","k":"function","d":"() -> Tensor","s":"In-place version of :meth:`~Tensor.negative`"},{"l":"nelement","k":"function","d":"() -> int","s":"Alias for :meth:`~Tensor.numel`"},{"l":"new","k":"function"},{"l":"new_empty","k":"function","d":"(size, *, dtype=None, device=None, requires_grad=False, layout=torch.strided, pin_memory=False) -> Tensor","s":"Returns a Tensor of size :attr:`size` filled with uninitialized data."},{"l":"new_empty_strided","k":"function","d":"(size, stride, dtype=None, device=None, requires_grad=False, layout=torch.strided, pin_memory=False) -> Tensor","s":"Returns a Tensor of size :attr:`size` and strides :attr:`stride` filled with"},{"l":"new_full","k":"function","d":"(size, fill_value, *, dtype=None, device=None, requires_grad=False, layout=torch.strided, pin_memory=False) -> Tensor","s":"Returns a Tensor of size :attr:`size` filled with :attr:`fill_value`."},{"l":"new_ones","k":"function","d":"(size, *, dtype=None, device=None, requires_grad=False, layout=torch.strided, pin_memory=False) -> Tensor","s":"Returns a Tensor of size :attr:`size` filled with ``1``."},{"l":"new_tensor","k":"function","d":"(data, *, dtype=None, device=None, requires_grad=False, layout=torch.strided, pin_memory=False) -> Tensor","s":"Returns a new Tensor with :attr:`data` as the tensor data."},{"l":"new_zeros","k":"function","d":"(size, *, dtype=None, device=None, requires_grad=False, layout=torch.strided, pin_memory=False) -> Tensor","s":"Returns a Tensor of size :attr:`size` filled with ``0``."},{"l":"nextafter","k":"function","d":"(other) -> Tensor","s":"See :func:`torch.nextafter`"},{"l":"nextafter_","k":"function","d":"(other) -> Tensor","s":"In-place version of :meth:`~Tensor.nextafter`"},{"l":"nonzero","k":"function","d":"() -> LongTensor","s":"See :func:`torch.nonzero`"},{"l":"nonzero_static","k":"function","d":"(*, size, fill_value=-1) -> LongTensor","s":"See :func:`torch.nonzero_static`"},{"l":"norm","k":"function","d":"(self, p: float | str | None = 'fro', dim=None, keepdim=False, dtype=None)","s":"See :func:`torch.linalg.norm`"},{"l":"normal_","k":"function","d":"(mean=0, std=1, *, generator=None) -> Tensor","s":"Fills :attr:`self` tensor with elements samples from the normal distribution"},{"l":"not_equal","k":"function","d":"(other) -> Tensor","s":"See :func:`torch.not_equal`."},{"l":"not_equal_","k":"function","d":"(other) -> Tensor","s":"In-place version of :meth:`~Tensor.not_equal`."},{"l":"numel","k":"function","d":"() -> int","s":"See :func:`torch.numel`"},{"l":"numpy","k":"function","d":"(*, force=False) -> numpy.ndarray","s":"Returns the tensor as a NumPy :class:`ndarray`."},{"l":"orgqr","k":"function","d":"(input2) -> Tensor","s":"See :func:`torch.orgqr`"},{"l":"ormqr","k":"function","d":"(input2, input3, left=True, transpose=False) -> Tensor","s":"See :func:`torch.ormqr`"},{"l":"outer","k":"function","d":"(vec2) -> Tensor","s":"See :func:`torch.outer`."},{"l":"output_nr","k":"property"},{"l":"permute","k":"function","d":"(*dims) -> Tensor","s":"Returns a view of the tensor with its dimensions permuted."},{"l":"pin_memory","k":"function","d":"() -> Tensor","s":"Copies the tensor to pinned memory, if it's not already pinned."},{"l":"pinverse","k":"function","d":"() -> Tensor","s":"See :func:`torch.pinverse`"},{"l":"polygamma","k":"function","d":"(n) -> Tensor","s":"See :func:`torch.polygamma`"},{"l":"polygamma_","k":"function","d":"(n) -> Tensor","s":"In-place version of :meth:`~Tensor.polygamma`"},{"l":"positive","k":"function","d":"() -> Tensor","s":"See :func:`torch.positive`"},{"l":"pow","k":"function","d":"(exponent) -> Tensor","s":"See :func:`torch.pow`"},{"l":"pow_","k":"function","d":"(exponent) -> Tensor","s":"In-place version of :meth:`~Tensor.pow`"},{"l":"prelu","k":"function"},{"l":"prod","k":"function","d":"(dim=None, keepdim=False, dtype=None) -> Tensor","s":"See :func:`torch.prod`"},{"l":"put","k":"function","d":"(input, index, source, accumulate=False) -> Tensor","s":"Out-of-place version of :meth:`torch.Tensor.put_`."},{"l":"put_","k":"function","d":"(index, source, accumulate=False) -> Tensor","s":"Copies the elements from :attr:`source` into the positions specified by"},{"l":"q_per_channel_axis","k":"function","d":"() -> int","s":"Given a Tensor quantized by linear (affine) per-channel quantization,"},{"l":"q_per_channel_scales","k":"function","d":"() -> Tensor","s":"Given a Tensor quantized by linear (affine) per-channel quantization,"},{"l":"q_per_channel_zero_points","k":"function","d":"() -> Tensor","s":"Given a Tensor quantized by linear (affine) per-channel quantization,"},{"l":"q_scale","k":"function","d":"() -> float","s":"Given a Tensor quantized by linear(affine) quantization,"},{"l":"q_zero_point","k":"function","d":"() -> int","s":"Given a Tensor quantized by linear(affine) quantization,"},{"l":"qr","k":"function","d":"(some=True) -> (Tensor, Tensor)","s":"See :func:`torch.qr`"},{"l":"qscheme","k":"function","d":"() -> torch.qscheme","s":"Returns the quantization scheme of a given QTensor."},{"l":"quantile","k":"function","d":"(q, dim=None, keepdim=False, *, interpolation='linear') -> Tensor","s":"See :func:`torch.quantile`"},{"l":"rad2deg","k":"function","d":"() -> Tensor","s":"See :func:`torch.rad2deg`"},{"l":"rad2deg_","k":"function","d":"() -> Tensor","s":"In-place version of :meth:`~Tensor.rad2deg`"},{"l":"random_","k":"function","d":"(from=0, to=None, *, generator=None) -> Tensor","s":"Fills :attr:`self` tensor with numbers sampled from the discrete uniform"},{"l":"ravel","k":"function","d":"() -> Tensor","s":"see :func:`torch.ravel`"},{"l":"real","k":"property","s":"Returns a new tensor containing real values of the :attr:`self` tensor for a complex-valued input tensor."},{"l":"reciprocal","k":"function","d":"() -> Tensor","s":"See :func:`torch.reciprocal`"},{"l":"reciprocal_","k":"function","d":"() -> Tensor","s":"In-place version of :meth:`~Tensor.reciprocal`"},{"l":"record_stream","k":"function","d":"(stream)","s":"Marks the tensor as having been used by this stream. When the tensor"},{"l":"register_hook","k":"function","d":"(self, hook)","s":"Registers a backward hook."},{"l":"register_post_accumulate_grad_hook","k":"function","d":"(self, hook)","s":"Registers a backward hook that runs after grad accumulation."},{"l":"reinforce","k":"function","d":"(self, reward)"},{"l":"relu","k":"function"},{"l":"relu_","k":"function"},{"l":"remainder","k":"function","d":"(divisor) -> Tensor","s":"See :func:`torch.remainder`"},{"l":"remainder_","k":"function","d":"(divisor) -> Tensor","s":"In-place version of :meth:`~Tensor.remainder`"},{"l":"renorm","k":"function","d":"(p, dim, maxnorm) -> Tensor","s":"See :func:`torch.renorm`"},{"l":"renorm_","k":"function","d":"(p, dim, maxnorm) -> Tensor","s":"In-place version of :meth:`~Tensor.renorm`"},{"l":"repeat","k":"function","d":"(*repeats) -> Tensor","s":"Repeats this tensor along the specified dimensions."},{"l":"repeat_interleave","k":"function","d":"(repeats, dim=None, *, output_size=None) -> Tensor","s":"See :func:`torch.repeat_interleave`."},{"l":"requires_grad","k":"property","s":"Is ``True`` if gradients need to be computed for this Tensor, ``False`` otherwise."},{"l":"requires_grad_","k":"function","d":"(requires_grad=True) -> Tensor","s":"Change if autograd should record operations on this tensor: sets this tensor's"},{"l":"reshape","k":"function","d":"(*shape) -> Tensor","s":"Returns a tensor with the same data and number of elements as :attr:`self`"},{"l":"reshape_as","k":"function","d":"(other) -> Tensor","s":"Returns this tensor as the same shape as :attr:`other`."},{"l":"resize","k":"function","d":"(self, *sizes)"},{"l":"resize_","k":"function","d":"(*sizes, memory_format=torch.contiguous_format) -> Tensor","s":"Resizes :attr:`self` tensor to the specified size. If the number of elements is"},{"l":"resize_as","k":"function","d":"(self, tensor)"},{"l":"resize_as_","k":"function","d":"(tensor, memory_format=torch.contiguous_format) -> Tensor","s":"Resizes the :attr:`self` tensor to be the same size as the specified"},{"l":"resize_as_sparse_","k":"function"},{"l":"resolve_conj","k":"function","d":"() -> Tensor","s":"See :func:`torch.resolve_conj`"},{"l":"resolve_neg","k":"function","d":"() -> Tensor","s":"See :func:`torch.resolve_neg`"},{"l":"retain_grad","k":"function","d":"() -> None","s":"Enables this Tensor to have their :attr:`grad` populated during"},{"l":"retains_grad","k":"property","s":"Is ``True`` if this Tensor is non-leaf and its :attr:`grad` is enabled to be"},{"l":"roll","k":"function","d":"(shifts, dims) -> Tensor","s":"See :func:`torch.roll`"},{"l":"rot90","k":"function","d":"(k, dims) -> Tensor","s":"See :func:`torch.rot90`"},{"l":"round","k":"function","d":"(decimals=0) -> Tensor","s":"See :func:`torch.round`"},{"l":"round_","k":"function","d":"(decimals=0) -> Tensor","s":"In-place version of :meth:`~Tensor.round`"},{"l":"row_indices","k":"function"},{"l":"rsqrt","k":"function","d":"() -> Tensor","s":"See :func:`torch.rsqrt`"},{"l":"rsqrt_","k":"function","d":"() -> Tensor","s":"In-place version of :meth:`~Tensor.rsqrt`"},{"l":"scatter","k":"function","d":"(dim, index, src) -> Tensor","s":"Out-of-place version of :meth:`torch.Tensor.scatter_`"},{"l":"scatter_","k":"function","d":"(dim, index, src, *, reduce=None) -> Tensor","s":"Writes all values from the tensor :attr:`src` into :attr:`self` at the indices"},{"l":"scatter_add","k":"function","d":"(dim, index, src) -> Tensor","s":"Out-of-place version of :meth:`torch.Tensor.scatter_add_`"},{"l":"scatter_add_","k":"function","d":"(dim, index, src) -> Tensor","s":"Adds all values from the tensor :attr:`src` into :attr:`self` at the indices"},{"l":"scatter_reduce","k":"function","d":"(dim, index, src, reduce, *, include_self=True) -> Tensor","s":"Out-of-place version of :meth:`torch.Tensor.scatter_reduce_`"},{"l":"scatter_reduce_","k":"function","d":"(dim, index, src, reduce, *, include_self=True) -> Tensor","s":"Reduces all values from the :attr:`src` tensor to the indices specified in"},{"l":"select","k":"function","d":"(dim, index) -> Tensor","s":"See :func:`torch.select`"},{"l":"select_scatter","k":"function","d":"(src, dim, index) -> Tensor","s":"See :func:`torch.select_scatter`"},{"l":"set_","k":"function","d":"(source=None, storage_offset=0, size=None, stride=None) -> Tensor","s":"Sets the underlying storage, size, and strides. If :attr:`source` is a tensor,"},{"l":"sgn","k":"function","d":"() -> Tensor","s":"See :func:`torch.sgn`"},{"l":"sgn_","k":"function","d":"() -> Tensor","s":"In-place version of :meth:`~Tensor.sgn`"},{"l":"shape","k":"property","s":"Returns the size of the :attr:`self` tensor. Alias for :attr:`size`."},{"l":"share_memory_","k":"function","d":"(self)","s":"Moves the underlying storage to shared memory."},{"l":"short","k":"function","d":"(memory_format=torch.preserve_format) -> Tensor","s":"``self.short()`` is equivalent to ``self.to(torch.int16)``. See :func:`to`."},{"l":"sigmoid","k":"function","d":"() -> Tensor","s":"See :func:`torch.sigmoid`"},{"l":"sigmoid_","k":"function","d":"() -> Tensor","s":"In-place version of :meth:`~Tensor.sigmoid`"},{"l":"sign","k":"function","d":"() -> Tensor","s":"See :func:`torch.sign`"},{"l":"sign_","k":"function","d":"() -> Tensor","s":"In-place version of :meth:`~Tensor.sign`"},{"l":"signbit","k":"function","d":"() -> Tensor","s":"See :func:`torch.signbit`"},{"l":"sin","k":"function","d":"() -> Tensor","s":"See :func:`torch.sin`"},{"l":"sin_","k":"function","d":"() -> Tensor","s":"In-place version of :meth:`~Tensor.sin`"},{"l":"sinc","k":"function","d":"() -> Tensor","s":"See :func:`torch.sinc`"},{"l":"sinc_","k":"function","d":"() -> Tensor","s":"In-place version of :meth:`~Tensor.sinc`"},{"l":"sinh","k":"function","d":"() -> Tensor","s":"See :func:`torch.sinh`"},{"l":"sinh_","k":"function","d":"() -> Tensor","s":"In-place version of :meth:`~Tensor.sinh`"},{"l":"size","k":"function","d":"(dim=None) -> torch.Size or int","s":"Returns the size of the :attr:`self` tensor. If ``dim`` is not specified,"},{"l":"slice_inverse","k":"function"},{"l":"slice_scatter","k":"function","d":"(src, dim=0, start=None, end=None, step=1) -> Tensor","s":"See :func:`torch.slice_scatter`"},{"l":"slogdet","k":"function","d":"() -> (Tensor, Tensor)","s":"See :func:`torch.slogdet`"},{"l":"smm","k":"function","d":"(mat) -> Tensor","s":"See :func:`torch.smm`"},{"l":"softmax","k":"function","d":"(dim) -> Tensor","s":"Alias for :func:`torch.nn.functional.softmax`."},{"l":"solve","k":"function","d":"(self, other)"},{"l":"sort","k":"function","d":"(dim=-1, descending=False) -> (Tensor, LongTensor)","s":"See :func:`torch.sort`"},{"l":"sparse_dim","k":"function","d":"() -> int","s":"Return the number of sparse dimensions in a :ref:`sparse tensor ` :attr:`self`."},{"l":"sparse_mask","k":"function","d":"(mask) -> Tensor","s":"Returns a new :ref:`sparse tensor ` with values from a"},{"l":"sparse_resize_","k":"function","d":"(size, sparse_dim, dense_dim) -> Tensor","s":"Resizes :attr:`self` :ref:`sparse tensor ` to the desired"},{"l":"sparse_resize_and_clear_","k":"function","d":"(size, sparse_dim, dense_dim) -> Tensor","s":"Removes all specified elements from a :ref:`sparse tensor"},{"l":"split","k":"function","d":"(self, split_size, dim=0)","s":"See :func:`torch.split`"},{"l":"split_with_sizes","k":"function"},{"l":"sqrt","k":"function","d":"() -> Tensor","s":"See :func:`torch.sqrt`"},{"l":"sqrt_","k":"function","d":"() -> Tensor","s":"In-place version of :meth:`~Tensor.sqrt`"},{"l":"square","k":"function","d":"() -> Tensor","s":"See :func:`torch.square`"},{"l":"square_","k":"function","d":"() -> Tensor","s":"In-place version of :meth:`~Tensor.square`"},{"l":"squeeze","k":"function","d":"(dim=None) -> Tensor","s":"See :func:`torch.squeeze`"},{"l":"squeeze_","k":"function","d":"(dim=None) -> Tensor","s":"In-place version of :meth:`~Tensor.squeeze`"},{"l":"sspaddmm","k":"function","d":"(mat1, mat2, *, beta=1, alpha=1) -> Tensor","s":"See :func:`torch.sspaddmm`"},{"l":"std","k":"function","d":"(dim=None, *, correction=1, keepdim=False) -> Tensor","s":"See :func:`torch.std`"},{"l":"stft","k":"function","d":"(self, n_fft: int, hop_length: int | None = None, win_length: int | None = None, window: 'Tensor | None' = None, center: bool = True, pad_mode: str = 'reflect', normalized: bool = False, onesided: bool | None = None, return_complex: bool | None = None, align_to_window: bool | None = None)","s":"See :func:`torch.stft`"},{"l":"storage","k":"function","d":"(self)","s":"Returns the underlying :class:`TypedStorage`."},{"l":"storage_offset","k":"function","d":"() -> int","s":"Returns :attr:`self` tensor's offset in the underlying storage in terms of"},{"l":"storage_type","k":"function","d":"(self)","s":"Returns the type of the underlying storage."},{"l":"stride","k":"function","d":"(dim) -> tuple or int","s":"Returns the stride of :attr:`self` tensor."},{"l":"sub","k":"function","d":"(other, *, alpha=1) -> Tensor","s":"See :func:`torch.sub`."},{"l":"sub_","k":"function","d":"(other, *, alpha=1) -> Tensor","s":"In-place version of :meth:`~Tensor.sub`"},{"l":"subtract","k":"function","d":"(other, *, alpha=1) -> Tensor","s":"See :func:`torch.subtract`."},{"l":"subtract_","k":"function","d":"(other, *, alpha=1) -> Tensor","s":"In-place version of :meth:`~Tensor.subtract`."},{"l":"sum","k":"function","d":"(dim=None, keepdim=False, dtype=None) -> Tensor","s":"See :func:`torch.sum`"},{"l":"sum_to_size","k":"function","d":"(*size) -> Tensor","s":"Sum ``this`` tensor to :attr:`size`."},{"l":"svd","k":"function","d":"(some=True, compute_uv=True) -> (Tensor, Tensor, Tensor)","s":"See :func:`torch.svd`"},{"l":"swapaxes","k":"function","d":"(axis0, axis1) -> Tensor","s":"See :func:`torch.swapaxes`"},{"l":"swapaxes_","k":"function","d":"(axis0, axis1) -> Tensor","s":"In-place version of :meth:`~Tensor.swapaxes`"},{"l":"swapdims","k":"function","d":"(dim0, dim1) -> Tensor","s":"See :func:`torch.swapdims`"},{"l":"swapdims_","k":"function","d":"(dim0, dim1) -> Tensor","s":"In-place version of :meth:`~Tensor.swapdims`"},{"l":"symeig","k":"function","d":"(self, eigenvectors=False)"},{"l":"t","k":"function","d":"() -> Tensor","s":"See :func:`torch.t`"},{"l":"t_","k":"function","d":"() -> Tensor","s":"In-place version of :meth:`~Tensor.t`"},{"l":"take","k":"function","d":"(indices) -> Tensor","s":"See :func:`torch.take`"},{"l":"take_along_dim","k":"function","d":"(indices, dim) -> Tensor","s":"See :func:`torch.take_along_dim`"},{"l":"tan","k":"function","d":"() -> Tensor","s":"See :func:`torch.tan`"},{"l":"tan_","k":"function","d":"() -> Tensor","s":"In-place version of :meth:`~Tensor.tan`"},{"l":"tanh","k":"function","d":"() -> Tensor","s":"See :func:`torch.tanh`"},{"l":"tanh_","k":"function","d":"() -> Tensor","s":"In-place version of :meth:`~Tensor.tanh`"},{"l":"tensor_split","k":"function","d":"(indices_or_sections, dim=0) -> List of Tensors","s":"See :func:`torch.tensor_split`"},{"l":"tile","k":"function","d":"(dims) -> Tensor","s":"See :func:`torch.tile`"},{"l":"to","k":"function","d":"(*args, **kwargs) -> Tensor","s":"Performs Tensor dtype and/or device conversion. A :class:`torch.dtype` and :class:`torch.device` are"},{"l":"to_dense","k":"function","d":"(dtype=None, *, masked_grad=True) -> Tensor","s":"Creates a strided copy of :attr:`self` if :attr:`self` is not a strided tensor, otherwise returns :attr:`self`."},{"l":"to_mkldnn","k":"function","d":"() -> Tensor","s":"Returns a copy of the tensor in ``torch.mkldnn`` layout."},{"l":"to_padded_tensor","k":"function","d":"(padding, output_size=None) -> Tensor","s":"See :func:`to_padded_tensor`"},{"l":"to_sparse","k":"function","d":"(sparseDims) -> Tensor","s":"Returns a sparse copy of the tensor. PyTorch supports sparse tensors in"},{"l":"to_sparse_bsc","k":"function","d":"(blocksize, dense_dim) -> Tensor","s":"Convert a tensor to a block sparse column (BSC) storage format of"},{"l":"to_sparse_bsr","k":"function","d":"(blocksize, dense_dim) -> Tensor","s":"Convert a tensor to a block sparse row (BSR) storage format of given"},{"l":"to_sparse_coo","k":"function","d":"(self)","s":"Convert a tensor to :ref:`coordinate format `."},{"l":"to_sparse_csc","k":"function","d":"() -> Tensor","s":"Convert a tensor to compressed column storage (CSC) format. Except"},{"l":"to_sparse_csr","k":"function","d":"(dense_dim=None) -> Tensor","s":"Convert a tensor to compressed row storage format (CSR). Except for"},{"l":"tolist","k":"function","d":"() -> list or number","s":"Returns the tensor as a (nested) list. For scalars, a standard"},{"l":"topk","k":"function","d":"(k, dim=None, largest=True, sorted=True) -> (Tensor, LongTensor)","s":"See :func:`torch.topk`"},{"l":"trace","k":"function","d":"() -> Tensor","s":"See :func:`torch.trace`"},{"l":"transpose","k":"function","d":"(dim0, dim1) -> Tensor","s":"See :func:`torch.transpose`"},{"l":"transpose_","k":"function","d":"(dim0, dim1) -> Tensor","s":"In-place version of :meth:`~Tensor.transpose`"},{"l":"triangular_solve","k":"function","d":"(A, upper=True, transpose=False, unitriangular=False) -> (Tensor, Tensor)","s":"See :func:`torch.triangular_solve`"},{"l":"tril","k":"function","d":"(diagonal=0) -> Tensor","s":"See :func:`torch.tril`"},{"l":"tril_","k":"function","d":"(diagonal=0) -> Tensor","s":"In-place version of :meth:`~Tensor.tril`"},{"l":"triu","k":"function","d":"(diagonal=0) -> Tensor","s":"See :func:`torch.triu`"},{"l":"triu_","k":"function","d":"(diagonal=0) -> Tensor","s":"In-place version of :meth:`~Tensor.triu`"},{"l":"true_divide","k":"function","d":"(value) -> Tensor","s":"See :func:`torch.true_divide`"},{"l":"true_divide_","k":"function","d":"(value) -> Tensor","s":"In-place version of :meth:`~Tensor.true_divide_`"},{"l":"trunc","k":"function","d":"() -> Tensor","s":"See :func:`torch.trunc`"},{"l":"trunc_","k":"function","d":"() -> Tensor","s":"In-place version of :meth:`~Tensor.trunc`"},{"l":"type","k":"function","d":"(dtype=None, non_blocking=False, **kwargs) -> str or Tensor","s":"Returns the type if `dtype` is not provided, else casts this object to"},{"l":"type_as","k":"function","d":"(tensor) -> Tensor","s":"Returns this tensor cast to the type of the given tensor."},{"l":"unbind","k":"function","d":"(dim=0) -> seq","s":"See :func:`torch.unbind`"},{"l":"unflatten","k":"function","d":"(self, dim, sizes)","s":"See :func:`torch.unflatten`."},{"l":"unfold","k":"function","d":"(dimension, size, step) -> Tensor","s":"Returns a view of the original tensor which contains all slices of size :attr:`size` from"},{"l":"uniform_","k":"function","d":"(from=0, to=1, *, generator=None) -> Tensor","s":"Fills :attr:`self` tensor with numbers sampled from the continuous uniform"},{"l":"unique","k":"function","d":"(self, sorted=True, return_inverse=False, return_counts=False, dim=None)","s":"Returns the unique elements of the input tensor."},{"l":"unique_consecutive","k":"function","d":"(self, return_inverse=False, return_counts=False, dim=None)","s":"Eliminates all but the first element from every consecutive group of equivalent elements."},{"l":"unsafe_chunk","k":"function","d":"(chunks, dim=0) -> List of Tensors","s":"See :func:`torch.unsafe_chunk`"},{"l":"unsafe_split","k":"function","d":"(split_size, dim=0) -> List of Tensors","s":"See :func:`torch.unsafe_split`"},{"l":"unsafe_split_with_sizes","k":"function"},{"l":"unsqueeze","k":"function","d":"(dim) -> Tensor","s":"See :func:`torch.unsqueeze`"},{"l":"unsqueeze_","k":"function","d":"(dim) -> Tensor","s":"In-place version of :meth:`~Tensor.unsqueeze`"},{"l":"untyped_storage","k":"function","d":"() -> torch.UntypedStorage","s":"Returns the underlying :class:`UntypedStorage`."},{"l":"values","k":"function","d":"() -> Tensor","s":"Return the values tensor of a :ref:`sparse COO tensor `."},{"l":"var","k":"function","d":"(dim=None, *, correction=1, keepdim=False) -> Tensor","s":"See :func:`torch.var`"},{"l":"vdot","k":"function","d":"(other) -> Tensor","s":"See :func:`torch.vdot`"},{"l":"view","k":"function","d":"(*shape) -> Tensor","s":"Returns a new tensor with the same data as the :attr:`self` tensor but of a"},{"l":"view_as","k":"function","d":"(other) -> Tensor","s":"View this tensor as the same size as :attr:`other`."},{"l":"volatile","k":"property"},{"l":"vsplit","k":"function","d":"(split_size_or_sections) -> List of Tensors","s":"See :func:`torch.vsplit`"},{"l":"where","k":"function","d":"(condition, y) -> Tensor","s":"``self.where(condition, y)`` is equivalent to ``torch.where(condition, self, y)``."},{"l":"xlogy","k":"function","d":"(other) -> Tensor","s":"See :func:`torch.xlogy`"},{"l":"xlogy_","k":"function","d":"(other) -> Tensor","s":"In-place version of :meth:`~Tensor.xlogy`"},{"l":"xpu","k":"function","d":"(device=None, non_blocking=False, memory_format=torch.preserve_format) -> Tensor","s":"Returns a copy of this object in XPU memory."},{"l":"zero_","k":"function","d":"() -> Tensor","s":"Fills :attr:`self` tensor with zeros."}]}} diff --git a/web/src/lib/pythonCompletions.ts b/web/src/lib/pythonCompletions.ts new file mode 100644 index 0000000..ea4cf55 --- /dev/null +++ b/web/src/lib/pythonCompletions.ts @@ -0,0 +1,188 @@ +/** + * Python completions for the Monaco editor. + * + * Monaco ships a Python *tokenizer*, not a language service, so out of the box + * the only suggestions are words that already appear in the buffer -- typing + * `np.` or `torch.` offers nothing. This registers a completion provider backed + * by `pythonCompletions.json`, which `scripts/gen_completions.py` generates by + * introspecting the exact modules the grading sandbox injects into every + * submission (see `grading_service/main.py`): torch, nn, F, np, math, Tensor. + * + * The data is ~300 KB, so it is imported dynamically: it lands in the same lazy + * chunk as the editor itself and never reaches the initial page bundle. + */ + +import type * as Monaco from 'monaco-editor'; + +type Kind = 'function' | 'class' | 'module' | 'constant' | 'property'; + +interface Entry { + /** label */ + l: string; + /** kind */ + k: Kind; + /** detail: signature for callables, value for constants */ + d?: string; + /** summary: first line of the docstring */ + s?: string; +} + +interface CompletionData { + versions: Record; + keywords: string[]; + builtins: string[]; + namespaces: Record; +} + +/** + * Dotted prefixes that resolve to a generated namespace. The sandbox binds the + * short aliases, but people type the long form out of habit. + */ +const ALIASES: Record = { + torch: 'torch', + nn: 'nn', + 'torch.nn': 'nn', + F: 'F', + 'nn.functional': 'F', + 'torch.nn.functional': 'F', + np: 'np', + numpy: 'np', + math: 'math', + Tensor: 'Tensor', + 'torch.Tensor': 'Tensor', +}; + +/** `foo.bar` / `foo.` — captures the dotted receiver left of the final dot. */ +const MEMBER_ACCESS = /([A-Za-z_][A-Za-z0-9_.]*)\.\s*[A-Za-z0-9_]*$/; + +let registration: Monaco.IDisposable | null = null; + +function kindOf(monaco: typeof Monaco, kind: Kind): Monaco.languages.CompletionItemKind { + const K = monaco.languages.CompletionItemKind; + switch (kind) { + case 'function': + return K.Function; + case 'class': + return K.Class; + case 'module': + return K.Module; + case 'property': + return K.Property; + default: + return K.Constant; + } +} + +/** + * True when the cursor sits inside a string or a comment, where API + * suggestions are noise. Deliberately cheap: it only inspects the current line, + * so it misses triple-quoted blocks spanning lines. + */ +function inStringOrComment(linePrefix: string): boolean { + let single = 0; + let double = 0; + for (let i = 0; i < linePrefix.length; i++) { + const c = linePrefix[i]; + if (c === '\\') { + i++; + } else if (c === "'" && double % 2 === 0) { + single++; + } else if (c === '"' && single % 2 === 0) { + double++; + } else if (c === '#' && single % 2 === 0 && double % 2 === 0) { + return true; + } + } + return single % 2 === 1 || double % 2 === 1; +} + +export async function registerPythonCompletions(monaco: typeof Monaco): Promise { + if (registration) return; // every editor instance shares one provider + registration = { dispose: () => {} }; // claim the slot before the await + + const data = ((await import('./pythonCompletions.json')) as unknown as { default: CompletionData }) + .default; + + const build = ( + entries: Entry[], + range: Monaco.IRange + ): Monaco.languages.CompletionItem[] => + entries.map((e) => ({ + label: e.l, + kind: kindOf(monaco, e.k), + detail: e.d, + documentation: e.s ? { value: e.s } : undefined, + insertText: e.l, + range, + })); + + registration = monaco.languages.registerCompletionItemProvider('python', { + triggerCharacters: ['.'], + + provideCompletionItems(model, position) { + const linePrefix = model.getValueInRange({ + startLineNumber: position.lineNumber, + startColumn: 1, + endLineNumber: position.lineNumber, + endColumn: position.column, + }); + + if (inStringOrComment(linePrefix)) return { suggestions: [] }; + + const word = model.getWordUntilPosition(position); + const range: Monaco.IRange = { + startLineNumber: position.lineNumber, + endLineNumber: position.lineNumber, + startColumn: word.startColumn, + endColumn: word.endColumn, + }; + + const member = MEMBER_ACCESS.exec(linePrefix); + if (member) { + const receiver = member[1]; + const namespace = + ALIASES[receiver] ?? ALIASES[receiver.split('.').pop() ?? ''] ?? null; + + if (namespace) { + return { suggestions: build(data.namespaces[namespace] ?? [], range) }; + } + + // Unknown receiver. In these problems essentially every local is a + // tensor, so Tensor members are the useful guess -- and far better than + // the editor's only alternative, which is other words in the file. + return { suggestions: build(data.namespaces.Tensor ?? [], range) }; + } + + // Top level: the sandbox globals, then keywords and builtins. + const suggestions: Monaco.languages.CompletionItem[] = Object.keys(data.namespaces).map( + (alias) => ({ + label: alias, + kind: monaco.languages.CompletionItemKind.Module, + detail: alias === 'F' ? 'torch.nn.functional' : undefined, + insertText: alias, + range, + }) + ); + + for (const kw of data.keywords) { + suggestions.push({ + label: kw, + kind: monaco.languages.CompletionItemKind.Keyword, + insertText: kw, + range, + }); + } + for (const fn of data.builtins) { + suggestions.push({ + label: fn, + kind: monaco.languages.CompletionItemKind.Function, + detail: 'builtin', + insertText: fn, + range, + }); + } + + return { suggestions }; + }, + }); +}