PyTorch torch-Referenzhandbuch

Das PyTorch-Paket enthält Datenstrukturen für mehrdimensionale Tensoren und definiert mathematische Operationen, die auf diesen Tensoren ausgeführt werden. Darüber hinaus bietet es viele Hilfsprogramme für die effiziente Serialisierung von Tensoren und beliebigen Datentypen sowie weitere nützliche Hilfsprogramme.

Es verfügt außerdem über eine CUDA-Version, mit der Sie Tensorberechnungen auf NVIDIA-GPUs mit Compute Capability >= 3.0 ausführen können.

PyTorch torch API-Handbuch

Tensor-Typüberprüfungen

Funktion	Beschreibung
`torch.is_tensor(obj)`	Prüfen`obj`ob es sich um einen PyTorch-Tensor handelt.
`torch.is_storage(obj)`	Prüfen`obj`ob es sich um ein PyTorch-Storage-Objekt handelt.
`torch.is_complex(input)`	Prüfen`input`ob der Datentyp ein komplexer Datentyp ist.
`torch.is_conj(input)`	Prüfen`input`ob es sich um einen konjugierten Tensor handelt.
`torch.is_floating_point(input)`	Prüfen`input`ob der Datentyp ein Gleitkomma-Datentyp ist.
`torch.is_nonzero(input)`	Prüfen`input`ob es sich um einen Tensor mit einem einzelnen Element ungleich null handelt.
`torch.set_default_dtype(d)`	Den standardmäßigen Gleitkomma-Datentyp festlegen auf`d`。
`torch.get_default_dtype()`	Den aktuellen standardmäßigen Gleitkomma-Datentyp abrufen`torch.dtype`。
`torch.set_default_device(device)`	Standard festlegen`torch.Tensor`zugewiesenes Gerät auf`device`。
`torch.get_default_device()`	Standard abrufen`torch.Tensor`zugewiesenes Gerät.
`torch.set_default_tensor_type(tensor_type)`	Standard-Tensor-Typ festlegen auf`tensor_type`。
`torch.numel(input)`	Return`input`die Gesamtzahl der Elemente im Tensor.
`torch.set_printoptions(...)`	Tensor-Druckoptionen festlegen.

Tensor-Erstellung

Funktion	Beschreibung
`torch.tensor(data, dtype, device, requires_grad)`	Einen Tensor aus Daten erstellen, wobei die Daten kopiert werden, ohne Autograd-Verlauf.
`torch.as_tensor(data, dtype, device)`	Daten in einen Tensor konvertieren, wobei Daten geteilt und der Autograd-Verlauf erhalten werden.
`torch.asarray(data, dtype, device)`	Daten in ein Tensor-Array konvertieren.
`torch.from_numpy(ndarray)`	Einen Tensor aus einem NumPy-Array erstellen (gemeinsam genutzter Speicher).
`torch.from_dlpack(ext_tensor)`	Erzeuge einen PyTorch-Tensor aus einem dlpack-Tensor.
`torch.frombuffer(buffer, dtype, count, offset)`	Erzeuge einen 1-D-Tensor aus einem Buffer.
`torch.zeros(*size, dtype, device, requires_grad)`	Erstellen Sie einen Tensor, der nur aus Nullen besteht.
`torch.zeros_like(input, dtype, device, requires_grad)`	Erzeuge einen Tensor aus lauter Nullen mit derselben Form wie die Eingabe.
`torch.ones(*size, dtype, device, requires_grad)`	Erstellen Sie einen Tensor, der nur aus Einsen besteht.
`torch.ones_like(input, dtype, device, requires_grad)`	Erzeuge einen Tensor aus lauter Einsen mit derselben Form wie die Eingabe.
`torch.empty(*size, dtype, device, requires_grad)`	Erstellen Sie einen nicht initialisierten Tensor.
`torch.empty_like(input, dtype, device, requires_grad)`	Erzeuge einen nicht initialisierten Tensor mit derselben Form wie die Eingabe.
`torch.empty_strided(size, stride, dtype, device)`	Erzeuge einen nicht initialisierten Tensor mit angegebenen Strides.
`torch.arange(start, end, step, dtype, device, requires_grad)`	Erzeuge einen Tensor mit arithmetischer Sequenz.
`torch.range(start, end, step, dtype, device, requires_grad)`	Erzeuge einen Tensor mit arithmetischer Sequenz, der den Endwert einschließt.
`torch.linspace(start, end, steps, dtype, device, requires_grad)`	Erzeuge einen Tensor mit gleichmäßig verteilter Sequenz.
`torch.logspace(start, end, steps, base, dtype, device, requires_grad)`	Erzeuge einen Tensor mit logarithmisch verteilter Sequenz.
`torch.eye(n, m, dtype, device, requires_grad)`	Erzeuge eine Einheitsmatrix.
`torch.full(size, fill_value, dtype, device, requires_grad)`	Erzeuge einen Tensor, der mit einem angegebenen Wert gefüllt ist.
`torch.full_like(input, fill_value, dtype, device, requires_grad)`	Erzeuge einen Tensor, der mit einem Wert gefüllt ist und dieselbe Form wie die Eingabe hat.
`torch.rand(*size, dtype, device, requires_grad)`	Erzeuge einen gleichverteilten Zufallstensor (Bereich [0, 1)).
`torch.rand_like(input, dtype, device, requires_grad)`	Erzeuge einen gleichverteilten Zufallstensor mit derselben Form wie die Eingabe.
`torch.randn(*size, dtype, device, requires_grad)`	Erzeuge einen standardnormalverteilten Zufallstensor.
`torch.randn_like(input, dtype, device, requires_grad)`	Erzeuge einen standardnormalverteilten Zufallstensor mit derselben Form wie die Eingabe.
`torch.randint(low, high, size, dtype, device, requires_grad)`	Erzeuge einen ganzzahligen Zufallstensor.
`torch.randint_like(input, low, high, dtype, device, requires_grad)`	Erzeuge einen ganzzahligen Zufallstensor mit derselben Form wie die Eingabe.
`torch.randperm(n, dtype, device, requires_grad)`	Erzeuge eine zufällige Permutation von 0 bis n-1.
`torch.sparse_coo_tensor(indices, values, size, dtype, device, requires_grad)`	An der angegebenen`indices`Position, konstruiere einen dünnbesetzten COO-Tensor.
`torch.sparse_csr_tensor(crow_indices, col_indices, values, size, dtype, device)`	Konstruiere einen dünnbesetzten CSR-Tensor.
`torch.sparse_csc_tensor(ccol_indices, row_indices, values, size, dtype, device)`	Konstruiere einen dünnbesetzten CSC-Tensor.
`torch.quantize_per_tensor(input, scale, zero_point, dtype)`	Einen quantisierten Tensor erstellen (pro Tensor).
`torch.quantize_per_channel(input, scales, zero_points, axis, dtype)`	Einen quantisierten Tensor erstellen (pro Kanal).
`torch.dequantize(input)`	Einen Tensor dequantisieren.
`torch.complex(real, imag)`	Einen komplexen Tensor aus Real- und Imaginärteilen erstellen.
`torch.polar(abs, angle)`	Einen komplexen Tensor aus Polarkoordinaten erstellen.
`torch.heaviside(input, values)`	Die Heaviside-Stufenfunktion berechnen.

Indizierungs-, Slicing-, Verknüpfungs- und Mutationsoperationen

Funktion	Beschreibung
`torch.cat(tensors, dim, out)`	Tensoren entlang einer angegebenen Dimension verketten.
`torch.concat(tensors, dim, out)`	Tensoren entlang einer angegebenen Dimension verketten (identisch mit cat).
`torch.concatenate(tensors, dim, out)`	Tensoren entlang einer angegebenen Dimension verketten (identisch mit cat).
`torch.stack(tensors, dim, out)`	Tensoren entlang einer neuen Dimension stapeln.
`torch.split(tensor, split_size, dim)`	Einen Tensor entlang einer angegebenen Dimension aufteilen.
`torch.chunk(tensor, chunks, dim)`	Einen Tensor entlang einer angegebenen Dimension in Blöcke aufteilen.
`torch.reshape(input, shape)`	Ändere die Form eines Tensors.
`torch.transpose(input, dim0, dim1)`	Vertausche zwei Dimensionen eines Tensors.
`torch.t(input)`	Transponiere einen 2-D-Tensor.
`torch.squeeze(input, dim)`	Entferne eine Dimension der Größe 1.
`torch.unsqueeze(input, dim)`	Füge eine Dimension der Größe 1 an einer angegebenen Position ein.
`torch.permute(input, dims)`	Ordne die Dimensionen eines Tensors neu an.
`torch.movedim(input, source, destination)`	Verschiebe eine Dimension des Tensors an eine neue Position.
`torch.moveaxis(input, source, destination)`	Verschiebe eine Achse des Tensors an eine neue Position.
`torch.narrow(input, dim, start, length)`	Gib einen Ausschnitt eines Tensors zurück.
`torch.narrow_copy(input, dim, start, length)`	Gib eine Kopie eines Ausschnitts eines Tensors zurück.
`torch.select(input, dim, index)`	Wähle Ausschnitte aus, die den Indizes entlang einer angegebenen Dimension entsprechen.
`torch.slice_scatter(input, src, dim, start, end)`	Streue src in die Ausschnitte von input.
`torch.select_scatter(input, src, dim, index)`	Streue src in die angegebenen Indexpositionen.
`torch.diagonal_scatter(input, src, offset, dim1, dim2)`	Streue Werte in diagonale Positionen.
`torch.expand(input, size)`	Erweitere die Größe eines Tensors (Kopie-Ansicht).
`torch.expand_as(input, other)`	Erweitere den Tensor auf dieselbe Größe wie other.
`torch.masked_select(input, mask)`	Wähle Elemente gemäß einer booleschen Maske aus.
`torch.index_select(input, dim, index)`	Wähle Elemente entsprechend den Indizes entlang einer angegebenen Dimension aus.
`torch.gather(input, dim, index, sparse_grad)`	Sammle Elemente an angegebenen Indizes entlang einer angegebenen Dimension.
`torch.scatter(input, dim, index, src, reduce)`	wird`src`streue die Werte von ... an`input`die angegebenen Positionen von ...
`torch.scatter_add(input, dim, index, src)`	Addiere die Werte von src zu den angegebenen Positionen.
`torch.scatter_reduce(input, dim, index, src, reduce, include_self)`	Aggregiere die Werte von src an den angegebenen Positionen auf die angegebene Weise.
`torch.index_add(input, dim, index, source, alpha)`	Addiere source zu den durch index angegebenen Positionen.
`torch.index_copy(input, dim, index, source)`	Kopiere die Quelle an die durch Index angegebenen Positionen.
`torch.index_reduce(input, dim, index, source, reduce, include_self)`	Aggregiere die Quelle zu den durch Index angegebenen Positionen auf die angegebene Weise.
`torch.take(input, index)`	Rufe das Element an der angegebenen Indexposition ab.
`torch.take_along_dim(input, indices, dim)`	Rufe die Elemente an Indexpositionen entlang einer angegebenen Dimension ab.
`torch.nonzero(input)`	Gib die Indizes der von null verschiedenen Elemente zurück.
`torch.argwhere(input)`	Gib die Indizes der Elemente zurück, die die Bedingung erfüllen.
`torch.where(condition, input, other)`	Gib Elemente gemäß einer Bedingung zurück.
`torch.unbind(tensor, dim)`	Teile entlang einer angegebenen Dimension in ein Tupel auf.
`torch.split_with_sizes(tensor, split_sizes, dim)`	Teile einen Tensor nach Größen auf.
`torch.tensor_split(tensor, indices_or_sections, dim)`	Teile einen Tensor nach Indizes oder Anzahl von Segmenten auf.
`torch.hsplit(tensor, indices_or_sections)`	Teile einen Tensor horizontal auf.
`torch.vsplit(tensor, indices_or_sections)`	Teile einen Tensor vertikal auf.
`torch.dsplit(tensor, indices_or_sections)`	Einen Tensor tiefenweise aufteilen.
`torch.hstack(tensors, dim, out)`	Tensoren horizontal stapeln.
`torch.vstack(tensors, out)`	Tensoren vertikal stapeln.
`torch.dstack(tensors, out)`	Tensoren tiefenweise stapeln.
`torch.column_stack(tensors, out)`	Tensoren spaltenweise stapeln.
`torch.row_stack(tensors, out)`	Tensoren zeilenweise stapeln (entspricht vstack).
`torch.tile(input, dims)`	Einen Tensor mehrfach wiederholen.
`torch.repeat_interleave(input, repeats, dim)`	Elemente entlang einer angegebenen Dimension wiederholen.
`torch.flip(input, dims)`	Einen Tensor entlang einer angegebenen Dimension umkehren.
`torch.fliplr(input)`	Einen Tensor links-rechts umkehren.
`torch.flipud(input)`	Einen Tensor oben-unten umkehren.
`torch.rot90(input, k, dims)`	Einen Tensor um 90 Grad drehen.
`torch.linalg.matrix_transpose(input)`	Matrix-Transposition.
`torch.adjoint(input)`	Gib den Adjungierten eines Tensors zurück.
`torch.resolve_conj(input)`	Ermittle den konjugierten Tensor.
`torch.resolve_neg(input)`	Ermittle den negativen Tensor.
`torch.view_as_real(input)`	Behandle einen komplexen Tensor als reellen Tensor.
`torch.view_as_complex(input)`	Behandle einen reellen Tensor als komplexen Tensor.
`torch.unravel_index(indices, shape)`	Konvertiere flache Indizes in mehrdimensionale Indizes.

Generierung von Zufallszahlen

Funktion	Beschreibung
`torch.manual_seed(seed)`	Setze den Zufallsstartwert (CPU).
`torch.seed()`	Setze den Zufallsstartwert und gib den neuen Startwert zurück.
`torch.initial_seed()`	Gib den aktuellen Zufallsstartwert zurück.
`torch.get_rng_state()`	Gib den Zustand des Zufallszahlengenerators zurück.
`torch.set_rng_state(state)`	Setze den Zustand des Zufallszahlengenerators.
`torch.rand(*size, dtype, device, requires_grad)`	Erzeuge einen gleichverteilten Zufallstensor (Bereich [0, 1)).
`torch.rand_like(input, dtype, device, requires_grad)`	Erzeuge einen gleichverteilten Zufallstensor mit derselben Form wie die Eingabe.
`torch.randn(*size, dtype, device, requires_grad)`	Erzeuge einen standardnormalverteilten Zufallstensor.
`torch.randn_like(input, dtype, device, requires_grad)`	Erzeuge einen standardnormalverteilten Zufallstensor mit derselben Form wie die Eingabe.
`torch.randint(low, high, size, dtype, device, requires_grad)`	Erzeuge einen ganzzahligen Zufallstensor.
`torch.randint_like(input, low, high, dtype, device, requires_grad)`	Erzeuge einen ganzzahligen Zufallstensor mit derselben Form wie die Eingabe.
`torch.randperm(n, dtype, device, requires_grad)`	Erzeuge eine zufällige Permutation von 0 bis n-1.
`torch.bernoulli(input, *, generator)`	Erzeuge Zufallszahlen aus einer Bernoulli-Verteilung.
`torch.multinomial(input, num_samples, replacement, generator)`	Multinomiales Sampling.
`torch.normal(mean, std, out)`	Zufallszahlen aus einer Normalverteilung generieren.
`torch.poisson(input, generator)`	Zufallszahlen aus einer Poisson-Verteilung generieren.

Serialisierung

Funktion	Beschreibung
`torch.save(obj, f, pickle_module, pickle_protocol)`	Ein Objekt in einer Datei speichern.
`torch.load(f, map_location, pickle_module, weights_only)`	Ein Objekt aus einer Datei laden.

Gradientensteuerung

Funktion	Beschreibung
`torch.no_grad()`	Kontextmanager, der die Gradientenberechnung deaktiviert.
`torch.enable_grad()`	Kontextmanager, der die Gradientenberechnung aktiviert.
`torch.set_grad_enabled(grad)`	Legt fest, ob die Gradientenberechnung aktiviert ist.
`torch.is_grad_enabled()`	Prüft, ob die Gradientenberechnung aktiviert ist.
`torch.inference_mode()`	Kontextmanager für den Inferenzmodus (deaktiviert Gradienten und autograd).
`torch.is_inference_mode_enabled()`	Prüft, ob der Inferenzmodus aktiviert ist.

Mathematische Operationen - punktweise Operationen

Funktion	Beschreibung
`torch.abs(input, out)`	Elementweiser Absolutwert.
`torch.absolute(input, out)`	Elementweiser Absolutwert (identisch mit abs).
`torch.acos(input, out)`	Elementweiser Arkuskosinus.
`torch.arccos(input, out)`	Elementweiser Arkuskosinus (identisch mit acos).
`torch.acosh(input, out)`	Elementweiser inverser hyperbolischer Kosinus.
`torch.arccosh(input, out)`	Elementweiser inverser hyperbolischer Kosinus (identisch mit acosh).
`torch.add(input, other, alpha, out)`	Elementweise Addition (mit optionaler Alpha-Skalierung).
`torch.addcdiv(input, tensor1, tensor2, value, out)`	Führt input + value * (tensor1 / tensor2) aus.
`torch.addcmul(input, tensor1, tensor2, value, out)`	Führt input + value * (tensor1 * tensor2) aus.
`torch.angle(input, out)`	Gibt den Phasenwinkel eines komplexen Tensors zurück.
`torch.asin(input, out)`	Elementweiser Arkussinus.
`torch.arcsin(input, out)`	Elementweiser Arkussinus (entspricht asin).
`torch.asinh(input, out)`	Elementweiser inverser hyperbolischer Sinus.
`torch.arcsinh(input, out)`	Elementweiser inverser hyperbolischer Sinus (entspricht asinh).
`torch.atan(input, out)`	Elementweiser Arkustangens.
`torch.arctan(input, out)`	Elementweiser Arkustangens (entspricht atan).
`torch.atan2(input, other, out)`	Elementweiser Arkustangens mit zwei Argumenten.
`torch.arctan2(input, other, out)`	Elementweiser Arkustangens mit zwei Argumenten (entspricht atan2).
`torch.atanh(input, out)`	Elementweiser inverser hyperbolischer Tangens.
`torch.arctanh(input, out)`	Elementweiser inverser hyperbolischer Tangens (entspricht atanh).
`torch.bitwise_not(input, out)`	Elementweises bitweises NICHT.
`torch.bitwise_and(input, other, out)`	Elementweises bitweises UND.
`torch.bitwise_or(input, other, out)`	Elementweises bitweises ODER.
`torch.bitwise_xor(input, other, out)`	Elementweises bitweises XOR.
`torch.bitwise_left_shift(input, other, out)`	Elementweise Linksverschiebung.
`torch.bitwise_right_shift(input, other, out)`	Elementweise Rechtsverschiebung.
`torch.ceil(input, out)`	Elementweises Aufrunden.
`torch.clamp(input, min, max, out)`	Begrenzt Tensorwerte auf einen angegebenen Bereich.
`torch.clip(input, min, max, out)`	Begrenzt Tensorwerte auf einen angegebenen Bereich (identisch mit clamp).
`torch.conj_physical(input, out)`	Elementweise physikalische Konjugation.
`torch.copysign(input, other, out)`	Elementweises Kopieren des Vorzeichens.
`torch.cos(input, out)`	Elementweiser Kosinus.
`torch.cosh(input, out)`	Elementweiser hyperbolischer Kosinus.
`torch.deg2rad(input, out)`	Wandelt Winkel von Grad in Bogenmaß um.
`torch.div(input, other, rounding_mode, out)`	Elementweise Division.
`torch.divide(input, other, rounding_mode, out)`	Elementweise Division (gleich wie div).
`torch.digamma(input, out)`	Elementweise Digamma-Funktion (logarithmische Ableitung).
`torch.erf(input, out)`	Elementweise Fehlerfunktion.
`torch.erfc(input, out)`	Elementweise komplementäre Fehlerfunktion.
`torch.erfinv(input, out)`	Elementweise inverse Fehlerfunktion.
`torch.exp(input, out)`	Elementweise Exponentialfunktion.
`torch.exp2(input, out)`	Elementweise Zweierpotenz.
`torch.expm1(input, out)`	Elementweise exp(x) - 1.
`torch.fake_quantize_per_channel_affine(input, scale, zero_point, axis, quant_min, quant_max)`	Simuliert die Quantisierung pro Kanal.
`torch.fake_quantize_per_tensor_affine(input, scale, zero_point, quant_min, quant_max)`	Simuliert die Quantisierung pro Tensor.
`torch.fix(input, out)`	Elementweise ganzzahliger Anteil (Abschneiden gegen Null).
`torch.float_power(input, exponent, out)`	Elementweise Gleitkomma-Potenz.
`torch.floor(input, out)`	Elementweises Abrunden.
`torch.floor_divide(input, other, out)`	Elementweise ganzzahlige Division.
`torch.fmod(input, other, out)`	Elementweises Modulo (Rest).
`torch.frac(input, out)`	Elementweiser Nachkommateil.
`torch.frexp(input, out)`	Zerlegt Gleitkommazahlen in Mantisse und Exponent.
`torch.gradient(input, dim, spacing, edge_order)`	Berechnet den Gradienten eines Tensors.
`torch.imag(input, out)`	Gibt den Imaginärteil eines komplexen Tensors zurück.
`torch.ldexp(input, other, out)`	Berechnet elementweise input * 2**other.
`torch.lerp(input, end, weight, out)`	Elementweise lineare Interpolation.
`torch.lgamma(input, out)`	Elementweiser Logarithmus der Gammafunktion.
`torch.log(input, out)`	Elementweiser natürlicher Logarithmus.
`torch.log10(input, out)`	Elementweiser Logarithmus zur Basis 10.
`torch.log1p(input, out)`	Elementweise log(1 + x).
`torch.log2(input, out)`	Elementweiser Logarithmus zur Basis 2.
`torch.logaddexp(input, other, out)`	Elementweise log(exp(input) + exp(other)).
`torch.logaddexp2(input, other, out)`	Elementweise log2(2input + 2other).
`torch.logical_and(input, other, out)`	Elementweise logisches UND.
`torch.logical_not(input, out)`	Elementweise logisches NICHT.
`torch.logical_or(input, other, out)`	Elementweise logisches ODER.
`torch.logical_xor(input, other, out)`	Elementweise logisches XOR.
`torch.logit(input, eps, out)`	Elementweise Logit-Funktion.
`torch.hypot(input, other, out)`	Elementweise hypot-Funktion sqrt(input^2 + other^2).
`torch.i0(input, out)`	Elementweise modifizierte Bessel-Funktion (erster Art, Ordnung 0).
`torch.igamma(input, other, out)`	Elementweise unvollständige Gammafunktion.
`torch.igammac(input, other, out)`	Elementweise komplementäre unvollständige Gammafunktion.
`torch.mul(input, other, out)`	Elementweise Multiplikation.
`torch.multiply(input, other, out)`	Elementweise Multiplikation (identisch mit mul).
`torch.mvlgamma(input, p, out)`	Elementweiser Logarithmus der multivariaten Gammafunktion.
`torch.nan_to_num(input, nan, posinf, neginf, out)`	Ersetzt NaN durch einen angegebenen Wert.
`torch.neg(input, out)`	Elementweise Negation.
`torch.negative(input, out)`	Elementweise Negation (identisch mit neg).
`torch.nextafter(input, other, out)`	Gibt elementweise die nächste darstellbare Gleitkommazahl zurück.
`torch.polygamma(input, n, out)`	Elementweise Polygammafunktion.
`torch.positive(input, out)`	Elementweise positiv.
`torch.pow(input, exponent, out)`	Elementweise Potenz.
`torch.quantized_batch_norm(input, weight, bias, mean, var, eps, output_scale, output_zero_point)`	Quantisierte Batch-Normalisierung.
`torch.quantized_max_pool1d(input, kernel_size, stride, padding, dilation, ceil_mode)`	Quantisiertes Max-Pooling (1D).
`torch.quantized_max_pool2d(input, kernel_size, stride, padding, dilation, ceil_mode)`	Quantisiertes Max-Pooling (2D).
`torch.rad2deg(input, out)`	Konvertiert Winkel von Bogenmaß in Grad.
`torch.real(input, out)`	Gibt den Realteil eines komplexen Tensors zurück.
`torch.reciprocal(input, out)`	Elementweiser Kehrwert.
`torch.remainder(input, other, out)`	Elementweiser Rest.
`torch.round(input, decimals, out)`	Elementweises Runden auf die nächste ganze Zahl.
`torch.rsqrt(input, out)`	Elementweise reziproke Quadratwurzel.
`torch.sigmoid(input, out)`	Elementweise Sigmoid-Funktion.
`torch.sign(input, out)`	Gibt elementweise das Vorzeichen (-1, 0, 1) zurück.
`torch.sgn(input, out)`	Gibt elementweise den Vorzeichenvektor zurück.
`torch.signbit(input, out)`	Prüft elementweise das Vorzeichenbit.
`torch.sin(input, out)`	Elementweise Sinus.
`torch.sinc(input, out)`	Elementweise Sinc-Funktion sin(pix)/(pix).
`torch.sinh(input, out)`	Elementweise hyperbolischer Sinus.
`torch.softmax(input, dim, dtype)`	Elementweise Softmax-Funktion.
`torch.sqrt(input, out)`	Elementweise Quadratwurzel.
`torch.square(input, out)`	Elementweise Quadrat.
`torch.sub(input, other, alpha, out)`	Elementweise Subtraktion.
`torch.subtract(input, other, alpha, out)`	Elementweise Subtraktion (identisch mit sub).
`torch.tan(input, out)`	Elementweise Tangens.
`torch.tanh(input, out)`	Elementweise hyperbolischer Tangens.
`torch.true_divide(input, other, out)`	Elementweise echte Division.
`torch.trunc(input, out)`	Elementweise Trunkierung (Ganzzahlanteil).
`torch.xlogy(input, other, out)`	Berechnet elementweise input * log(other).

Mathematische Operationen - Reduktionsoperationen

Funktion	Beschreibung
`torch.argmax(input, dim, keepdim)`	Gibt den Index des Maximalwerts entlang einer Dimension zurück.
`torch.argmin(input, dim, keepdim)`	Gibt den Index des Minimalwerts entlang einer Dimension zurück.
`torch.amax(input, dim, keepdim, out)`	Gibt den Maximalwert entlang einer Dimension zurück.
`torch.amin(input, dim, keepdim, out)`	Gibt den Minimalwert entlang einer Dimension zurück.
`torch.aminmax(input, dim, keepdim, out)`	Gibt die Minimal- und Maximalwerte entlang einer Dimension zurück.
`torch.all(input, dim, keepdim, out)`	Prüft, ob alle Elemente True sind.
`torch.any(input, dim, keepdim, out)`	Prüft, ob irgendein Element True ist.
`torch.max(input, dim, keepdim, out)`	Berechnet das Maximum entlang einer angegebenen Dimension.
`torch.min(input, dim, keepdim, out)`	Berechnet das Minimum entlang einer angegebenen Dimension.
`torch.dist(input, other, p)`	Berechnet den p-Norm-Abstand zwischen zwei Tensoren.
`torch.logsumexp(input, dim, keepdim, out)`	Berechnet Log-Sum-Exp.
`torch.mean(input, dim, keepdim, out)`	Berechnet den Mittelwert entlang einer angegebenen Dimension.
`torch.nanmean(input, dim, keepdim, out)`	Berechnet den Mittelwert entlang einer angegebenen Dimension (NaNs werden ignoriert).
`torch.median(input, dim, keepdim, out)`	Berechnet den Median entlang einer angegebenen Dimension.
`torch.nanmedian(input, dim, keepdim, out)`	Berechnet den Median entlang einer angegebenen Dimension (NaNs werden ignoriert).
`torch.mode(input, dim, keepdim, out)`	Berechnet den Modalwert entlang einer angegebenen Dimension.
`torch.norm(input, p, dim, keepdim, out)`	Berechnet die p-Norm.
`torch.nansum(input, dim, keepdim, out)`	Berechnet die Summe entlang einer angegebenen Dimension (NaNs werden ignoriert).
`torch.prod(input, dim, keepdim, dtype, out)`	Berechnet das Produkt entlang einer angegebenen Dimension.
`torch.quantile(input, q, dim, keepdim, out, method)`	Berechnet das Quantil.
`torch.nanquantile(input, q, dim, keepdim, out, method)`	Berechnet das Quantil (NaNs werden ignoriert).
`torch.std(input, dim, unbiased, keepdim, out)`	Berechnet die Standardabweichung.
`torch.std_mean(input, dim, unbiased, keepdim)`	Berechnet die Standardabweichung und den Mittelwert.
`torch.sum(input, dim, keepdim, dtype, out)`	Berechnet die Summe entlang einer angegebenen Dimension.
`torch.unique(input, sorted, return_inverse, return_counts, dim)`	Gibt eindeutige Elemente zurück.
`torch.unique_consecutive(input, sorted, return_inverse, return_counts, dim)`	Gibt aufeinanderfolgende eindeutige Elemente zurück.
`torch.var(input, dim, unbiased, keepdim, out)`	Berechnet die Varianz.
`torch.var_mean(input, dim, unbiased, keepdim)`	Berechnet die Varianz und den Mittelwert.
`torch.count_nonzero(input, dim)`	Zählt die Anzahl der Nicht-Null-Elemente.
`torch.hash_tensor(input)`	Berechnet den Hash-Wert eines Tensors.

Mathematische Operationen - Vergleichsoperationen

Funktion	Beschreibung
`torch.allclose(input, other, rtol, atol, equal_nan)`	Prüft, ob zwei Tensoren nahe beieinanderliegen (alle Elemente).
`torch.argsort(input, dim, descending, stable)`	Gibt die Indizes zurück, die den Tensor sortieren.
`torch.eq(input, other, out)`	Elementweiser Gleichheitsvergleich.
`torch.equal(input, other)`	Prüft, ob zwei Tensoren exakt gleich sind.
`torch.ge(input, other, out)`	Elementweiser Größer-gleich-Vergleich.
`torch.greater_equal(input, other, out)`	Elementweiser Größer-gleich-Vergleich (entspricht ge).
`torch.gt(input, other, out)`	Elementweiser Größer-als-Vergleich.
`torch.greater(input, other, out)`	Elementweiser Größer-als-Vergleich (entspricht gt).
`torch.isclose(input, other, rtol, atol, equal_nan)`	Prüft, ob zwei Tensoren (elementweise) nahe beieinanderliegen.
`torch.isfinite(input, out)`	Prüft, ob Werte endlich sind.
`torch.isin(elements, test_elements, assume_unique, invert)`	Prüft, ob Elemente in einer Menge enthalten sind.
`torch.isinf(input, out)`	Prüft, ob Werte unendlich sind.
`torch.isposinf(input, out)`	Prüft, ob Werte positiv unendlich sind.
`torch.isneginf(input, out)`	Prüft, ob Werte negativ unendlich sind.
`torch.isnan(input, out)`	Prüft, ob Werte NaN sind.
`torch.isreal(input, out)`	Prüft, ob Werte reell sind.
`torch.kthvalue(input, k, dim, keepdim, out)`	Gibt das k-te kleinste Element und seinen Index zurück.
`torch.le(input, other, out)`	Elementweiser Vergleich auf kleiner oder gleich.
`torch.less_equal(input, other, out)`	Elementweiser Vergleich auf kleiner oder gleich (entspricht le).
`torch.lt(input, other, out)`	Elementweiser Vergleich auf kleiner als.
`torch.less(input, other, out)`	Elementweiser Vergleich auf kleiner als (entspricht lt).
`torch.maximum(input, other, out)`	Elementweises Maximum.
`torch.minimum(input, other, out)`	Elementweises Minimum.
`torch.fmax(input, other, out)`	Elementweises Maximum (NaNs werden ignoriert).
`torch.fmin(input, other, out)`	Elementweises Minimum (NaNs werden ignoriert).
`torch.ne(input, other, out)`	Elementweiser Vergleich auf Ungleichheit.
`torch.not_equal(input, other, out)`	Elementweiser Vergleich auf Ungleichheit (entspricht ne).
`torch.sort(input, dim, descending, stable, out)`	Sortiert entlang einer angegebenen Dimension.
`torch.topk(input, k, dim, largest, sorted, out)`	Gibt die größten k Elemente und ihre Indizes zurück.
`torch.msort(input, out)`	Sortiert entlang der letzten Dimension (gibt den sortierten Tensor zurück).

Mathematische Operationen - Spektraloperationen

Funktion	Beschreibung
`torch.stft(input, n_fft, hop_length, win_length, window, center, normalized, onesided, return_complex)`	Kurzzeit-Fourier-Transformation.
`torch.istft(input, n_fft, hop_length, win_length, window, center, normalized, onesided, length, return_complex)`	Inverse Kurzzeit-Fourier-Transformation.
`torch.bartlett_window(window_length, periodic, dtype, device)`	Bartlett-Fenster.
`torch.blackman_window(window_length, periodic, dtype, device)`	Blackman-Fenster.
`torch.hamming_window(window_length, periodic, alpha, beta, dtype, device)`	Hamming-Fenster.
`torch.hann_window(window_length, periodic, dtype, device)`	Hann-Fenster.
`torch.kaiser_window(window_length, periodic, beta, dtype, device)`	Kaiser-Fenster.

Mathematische Operationen - Sonstige Operationen

Funktion	Beschreibung
`torch.atleast_1d(*tensors)`	Konvertiert die Eingabe in einen Tensor mit mindestens 1 Dimension.
`torch.atleast_2d(*tensors)`	Konvertiert die Eingabe in einen Tensor mit mindestens 2 Dimensionen.
`torch.atleast_3d(*tensors)`	Konvertiert die Eingabe in einen Tensor mit mindestens 3 Dimensionen.
`torch.bincount(input, weights, minlength)`	Zählt die Vorkommen nichtnegativer Ganzzahlen.
`torch.block_diag(*tensors)`	Konstruiert eine Blockdiagonalmatrix aus dem Eingabetensor.
`torch.broadcast_tensors(*tensors)`	Broadcastet die Eingabe auf eine gemeinsame Form.
`torch.broadcast_to(input, shape)`	Broadcastet den Tensor auf eine angegebene Form.
`torch.broadcast_shapes(*shapes)`	Broadcastet Formen, damit sie für Operationen kompatibel sind.
`torch.bucketize(input, boundaries, right)`	Ordnet die Eingabe Bucket-Indizes zu.
`torch.cartesian_prod(*tensors)`	Berechnet das kartesische Produkt.
`torch.cdist(x1, x2, p, compute_mode)`	Berechnet paarweise Abstände.
`torch.clone(input, memory_format)`	Gibt eine Kopie des Tensors zurück.
`torch.combinations(input, r, with_replacement)`	Berechnet Kombinationen.
`torch.corrcoef(input)`	Berechnet die Korrelationskoeffizientenmatrix.
`torch.cov(input, correction, fweights, aweights)`	Berechnet die Kovarianzmatrix.
`torch.cross(input, dim, out)`	Berechnet das Kreuzprodukt.
`torch.cummax(input, dim, out)`	Akkumuliert den Maximalwert entlang einer Dimension.
`torch.cummin(input, dim, out)`	Akkumuliert den Minimalwert entlang einer Dimension.
`torch.cumprod(input, dim, out)`	Akkumuliert das Produkt entlang einer Dimension.
`torch.cumsum(input, dim, out, dtype)`	Akkumuliert die Summe entlang einer Dimension.
`torch.diag(input, diagonal, out)`	Erstellt eine Diagonalmatrix oder extrahiert die Diagonale.
`torch.diag_embed(input, offset, dim1, dim2, out)`	Bettet die Eingabe als Diagonale ein.
`torch.diagflat(input, offset, out)`	Erstellt eine Diagonalmatrix (abgeflachte Eingabe).
`torch.diagonal(input, offset, dim1, dim2, out)`	Extrahiert diagonale Elemente.
`torch.diff(input, n, dim, prepend, append, out)`	Berechnet die Differenz.
`torch.einsum(equation, *operands)`	Einsteinsche Summenkonvention.
`torch.flatten(input, start_dim, end_dim, out)`	Flacht den Tensor ab.
`torch.ravel(input, out)`	Flacht zu einem eindimensionalen Tensor ab.
`torch.kron(input, other, out)`	Berechnet das Kronecker-Produkt.
`torch.meshgrid(*tensors, indexing)`	Erzeugt ein Gitter.
`torch.lcm(input, other, out)`	Elementweises kleinstes gemeinsames Vielfaches.
`torch.logcumsumexp(input, dim, out)`	Kumulatives Log-Sum-Exp entlang einer Dimension.
`torch.renorm(input, p, dim, maxnorm, out)`	Renormiert auf eine angegebene Norm.
`torch.roll(input, shifts, dims)`	Rollt Tensorelemente.
`torch.searchsorted(sorted_sequence, values, side, sorter)`	Sucht nach Positionen in einer sortierten Sequenz.
`torch.tensordot(a, b, dims)`	Berechnet das Tensor-Dot-Produkt.
`torch.trace(input, out)`	Berechnet die Spur einer Matrix.
`torch.tril(input, diagonal, out)`	Extrahiert die untere Dreiecksmatrix.
`torch.tril_indices(row, column, offset, dtype, device, layout)`	Erzeugt Indizes für die untere Dreiecksmatrix.
`torch.triu(input, diagonal, out)`	Extrahiert die obere Dreiecksmatrix.
`torch.triu_indices(row, column, offset, dtype, device, layout)`	Erzeugt Indizes für die obere Dreiecksmatrix.
`torch.unflatten(input, dim, sizes)`	Entfaltet den Tensor.
`torch.vander(x, N, increasing, out)`	Erstellt eine Vandermonde-Matrix.

Lineare Algebra (BLAS und LAPACK)

Funktion	Beschreibung
`torch.addbmm(input, batch1, batch2, beta, alpha, out)`	Stapel-Matrix-Matrix-Multiplizieren-und-Addieren.
`torch.addmm(input, mat1, mat2, beta, alpha, out)`	Matrix-Multiplizieren-und-Addieren.
`torch.addmv(input, mat, vec, beta, alpha, out)`	Matrix-Vektor-Multiplizieren-und-Addieren.
`torch.addr(input, vec1, vec2, beta, alpha, out)`	Vektor-Äußeres-Produkt-Addition.
`torch.baddbmm(input, batch1, batch2, beta, alpha, out)`	Batch-Matrix-Multiplikation mit Addition (bmm + add).
`torch.bmm(input, mat2, out)`	Batch-Matrix-Multiplikation.
`torch.chain_matmul(*matrices)`	Verkettete Matrix-Multiplikation.
`torch.cholesky(input, upper, out)`	Cholesky-Zerlegung.
`torch.cholesky_inverse(input, upper, out)`	Inverse der Cholesky-Zerlegung.
`torch.cholesky_solve(input, input2, upper, out)`	Cholesky-Zerlegung zum Lösen linearer Gleichungen.
`torch.dot(input, other, out)`	Berechnet das Skalarprodukt zweier Vektoren.
`torch.geqrf(input, out)`	QR-Zerlegung (geqrf).
`torch.ger(input, other, out)`	Berechnet das äußere Produkt von Vektoren.
`torch.inner(input, other, out)`	Berechnet das innere Produkt.
`torch.inverse(input, out)`	Berechnet die Inverse einer Matrix.
`torch.det(input, out)`	Berechnet die Determinante einer Matrix.
`torch.logdet(input, out)`	Berechnet den Logarithmus der Determinante.
`torch.slogdet(input, out)`	Berechnet das Vorzeichen und den Logarithmus des Absolutbetrags der Determinante.
`torch.lu(input, pivot, get_infos, out)`	LU-Zerlegung.
`torch.lu_solve(input, LU_data, LU_pivots, out)`	LU-Zerlegung lösen.
`torch.lu_unpack(LU_data, LU_pivots, unpack_data, unpack_pivots)`	Entpackt das Ergebnis der LU-Zerlegung.
`torch.matmul(input, other, out)`	Matrixmultiplikation (unterstützt unterschiedliche Dimensionen).
`torch.matrix_power(input, n, out)`	Matrixpotenz.
`torch.matrix_exp(input, out)`	Matrixexponential.
`torch.mm(input, mat2, out)`	Matrixmultiplikation (2D).
`torch.mv(input, vec, out)`	Matrix-Vektor-Multiplikation.
`torch.orgqr(input, q, out)`	Rekonstruiert Q aus der QR-Zerlegung.
`torch.ormqr(input, mat, vec, left, transpose, out)`	ormqr-Operation.
`torch.outer(input, other, out)`	Berechnet das äußere Produkt von Vektoren.
`torch.pinverse(input, rcond, out)`	Berechnet die Moore-Penrose-Pseudoinverse.
`torch.qr(input, out)`	QR-Zerlegung.
`torch.svd(input, some, compute_uv, out)`	Singulärwertzerlegung.
`torch.svd_lowrank(input, q, niter, M)`	SVD-Näherung mit niedrigem Rang.
`torch.pca_lowrank(input, q, center, niter)`	PCA-Näherung mit niedrigem Rang.
`torch.lobpcg(input, K, B, X, M, P, max_iter, tol, debug, ortho_iparams, fpfloor)`	LOBPCG-Eigenwertlöser.
`torch.trapz(y, x, dim, out)`	Trapezintegration (veraltet, verwenden Sie trapezoid).
`torch.trapezoid(y, x, dim, out)`	Trapezintegration.
`torch.cumulative_trapezoid(y, x, dim, out)`	Kumulative Trapezintegration.
`torch.triangular_solve(input, A, upper, transpose, unitriangular, out)`	Lösen eines Dreiecksmatrixsystems.
`torch.vdot(input, other, out)`	Berechnet das Skalarprodukt von Vektoren (komplexfähig).

Geräteverwaltung

Funktion	Beschreibung
`torch.cuda.is_available()`	Prüft, ob CUDA verfügbar ist.
`torch.cuda.device_count()`	Gibt die Anzahl der CUDA-Geräte zurück.
`torch.cuda.current_device()`	Gibt den Index des aktuellen CUDA-Geräts zurück.
`torch.cuda.device(name)`	Erstellt ein Geräteobjekt.
`torch.cuda.device_context(device)`	Erstellt einen Gerätekontext.
`torch.device(device)`	Erstellt ein Geräteobjekt (z. B.,`'cpu'`oder`'cuda:0'`）。
`torch.Tensor.to(device)`	Verschiebt den Tensor auf das angegebene Gerät.
`torch.get_device_module(device_type)`	Ruft das Gerätemodul ab (z. B. cuda, mps).

Paralleles Rechnen

Funktion	Beschreibung
`torch.get_num_threads()`	Ruft die Gesamtzahl der Threads für CPU-Operationen ab.
`torch.set_num_threads(int)`	Legt die Anzahl der Threads für CPU-Operationen fest.
`torch.get_num_interop_threads()`	Ruft die Anzahl der parallelen Inter-Op-Threads ab.
`torch.set_num_interop_threads(int)`	Legt die Anzahl der parallelen Inter-Op-Threads fest.

Hilfsfunktionen

Funktion	Beschreibung
`torch.compiled_with_cxx11_abi()`	Prüft, ob mit C++11 ABI kompiliert wurde.
`torch.result_type(tensor, other)`	Gibt den dtype des Operationsergebnisses zurück.
`torch.can_cast(from_dtype, to_dtype)`	Prüft, ob Datentypen konvertiert werden können.
`torch.promote_types(type1, type2)`	Gibt den hochgestuften Datentyp zurück.
`torch.use_deterministic_algorithms(mode, warn_only)`	Aktiviert/deaktiviert deterministische Algorithmen.
`torch.are_deterministic_algorithms_enabled()`	Prüft, ob deterministische Algorithmen aktiviert sind.
`torch.is_deterministic_algorithms_warn_only_enabled()`	Prüft, ob deterministische Algorithmen im Warnmodus sind.
`torch.set_deterministic_debug_mode(debug_mode)`	Setzt den deterministischen Debug-Modus.
`torch.get_deterministic_debug_mode()`	Ruft den deterministischen Debug-Modus ab.
`torch.set_float32_matmul_precision(precision)`	Legt die Genauigkeit für float32-Matrixmultiplikation fest.
`torch.get_float32_matmul_precision()`	Ruft die Genauigkeit für float32-Matrixmultiplikation ab.
`torch.set_warn_always(enabled)`	Legt fest, ob Warnungen immer angezeigt werden sollen.
`torch.is_warn_always_enabled()`	Prüft, ob Warnungen immer angezeigt werden.
`torch.vmap(fn, in_dims, out_dims, randomness, chunk_size)`	Vektorisierte Zuordnung.
`torch._assert(condition, message)`	Assertionsprüfung (interne Verwendung).
`torch.typename(t)`	Gibt die String-Darstellung des Typs zurück.

Kompilierungsoptimierung

Funktion	Beschreibung
`torch.compile(model, backend, options, dynamic)`	Kompiliert ein PyTorch-Modell zur Optimierung.

Beispiel

import torch

# Einen Tensor erstellen
x = torch.tensor([1, 2, 3])
y = torch.zeros(2, 3)

# Mathematische Operationen
z = torch.add(x, 1) # Elementweise Addition 1
print(z)

# Indizierung und Slicing
mask = x > 1
selected = torch.masked_select(x, mask)
print(selected)

# Geräteverwaltung
if torch.cuda.is_available():
device = torch.device('cuda')
x = x.to(device)
print(x.device)

# Matrixoperationen
a = torch.randn(3, 4)
b = torch.randn(4, 5)
c = torch.matmul(a, b)
print(c.shape)

# Gradientenberechnung
x = torch.tensor([1., 2., 3.], requires_grad=True)
y = x.sum()
y.backward()
print(x.grad)

Ausgabe:

tensor([2, 3, 4])
tensor([2, 3])

Für ausführlichere Informationen sieheoffizielle PyTorch-Dokumentation。

Andere Erweiterungen