Manuel de référence PyTorch torch

Le package PyTorch contient des structures de données pour les tenseurs multidimensionnels et définit les opérations mathématiques effectuées sur ces tenseurs. En outre, il fournit de nombreux outils utilitaires pour sérialiser efficacement les tenseurs et des types de données arbitraires, ainsi que d'autres utilitaires utiles.

Il dispose également d'une version CUDA qui vous permet d'exécuter des calculs tensoriels sur des GPU NVIDIA avec une capacité de calcul >= 3.0.

Manuel de l'API torch de PyTorch

Vérifications de type de tenseur

Fonction	Description
`torch.is_tensor(obj)`	Vérifier`obj`s'il s'agit d'un tenseur PyTorch.
`torch.is_storage(obj)`	Vérifier`obj`s'il s'agit d'un objet de stockage PyTorch.
`torch.is_complex(input)`	Vérifier`input`si le type de données est un type de données complexe.
`torch.is_conj(input)`	Vérifier`input`s'il s'agit d'un tenseur conjugué.
`torch.is_floating_point(input)`	Vérifier`input`si le type de données est un type de données à virgule flottante.
`torch.is_nonzero(input)`	Vérifier`input`s'il s'agit d'un tenseur à un seul élément non nul.
`torch.set_default_dtype(d)`	Définir le type de données à virgule flottante par défaut sur`d`。
`torch.get_default_dtype()`	Obtenir le type de données à virgule flottante par défaut actuel`torch.dtype`。
`torch.set_default_device(device)`	Définir la valeur par défaut`torch.Tensor`périphérique alloué à`device`。
`torch.get_default_device()`	Obtenir la valeur par défaut`torch.Tensor`périphérique alloué.
`torch.set_default_tensor_type(tensor_type)`	Définir le type de tenseur par défaut sur`tensor_type`。
`torch.numel(input)`	Retour`input`le nombre total d'éléments dans le tenseur.
`torch.set_printoptions(...)`	Définir les options d'affichage des tenseurs.

Création de tenseur

Fonction	Description
`torch.tensor(data, dtype, device, requires_grad)`	Créer un tenseur à partir de données, en copiant les données, sans historique autograd.
`torch.as_tensor(data, dtype, device)`	Convertir des données en tenseur, en partageant les données et en préservant l'historique autograd.
`torch.asarray(data, dtype, device)`	Convertir des données en tableau de tenseurs.
`torch.from_numpy(ndarray)`	Créer un tenseur à partir d'un tableau NumPy (mémoire partagée).
`torch.from_dlpack(ext_tensor)`	Créer un tenseur PyTorch à partir d'un tenseur dlpack.
`torch.frombuffer(buffer, dtype, count, offset)`	Créer un tenseur 1-D à partir d'un buffer.
`torch.zeros(*size, dtype, device, requires_grad)`	Créer un tenseur rempli de zéros.
`torch.zeros_like(input, dtype, device, requires_grad)`	Créer un tenseur de zéros ayant la même forme que l'entrée.
`torch.ones(*size, dtype, device, requires_grad)`	Créer un tenseur rempli de uns.
`torch.ones_like(input, dtype, device, requires_grad)`	Créer un tenseur de uns ayant la même forme que l'entrée.
`torch.empty(*size, dtype, device, requires_grad)`	Créer un tenseur non initialisé.
`torch.empty_like(input, dtype, device, requires_grad)`	Créer un tenseur non initialisé ayant la même forme que l'entrée.
`torch.empty_strided(size, stride, dtype, device)`	Créer un tenseur non initialisé avec les strides spécifiés.
`torch.arange(start, end, step, dtype, device, requires_grad)`	Créer un tenseur de séquence arithmétique.
`torch.range(start, end, step, dtype, device, requires_grad)`	Créer un tenseur de séquence arithmétique qui inclut la valeur de fin.
`torch.linspace(start, end, steps, dtype, device, requires_grad)`	Créer un tenseur de séquence à espacement régulier.
`torch.logspace(start, end, steps, base, dtype, device, requires_grad)`	Créer un tenseur de séquence à espacement logarithmique.
`torch.eye(n, m, dtype, device, requires_grad)`	Créer une matrice identité.
`torch.full(size, fill_value, dtype, device, requires_grad)`	Créer un tenseur rempli d'une valeur spécifiée.
`torch.full_like(input, fill_value, dtype, device, requires_grad)`	Créez un tenseur rempli d'une valeur et ayant la même forme que l'entrée.
`torch.rand(*size, dtype, device, requires_grad)`	Créez un tenseur aléatoire à distribution uniforme (plage [0, 1)).
`torch.rand_like(input, dtype, device, requires_grad)`	Créez un tenseur aléatoire à distribution uniforme ayant la même forme que l'entrée.
`torch.randn(*size, dtype, device, requires_grad)`	Créez un tenseur aléatoire suivant une distribution normale standard.
`torch.randn_like(input, dtype, device, requires_grad)`	Créez un tenseur aléatoire suivant une distribution normale standard ayant la même forme que l'entrée.
`torch.randint(low, high, size, dtype, device, requires_grad)`	Créez un tenseur aléatoire d'entiers.
`torch.randint_like(input, low, high, dtype, device, requires_grad)`	Créez un tenseur aléatoire d'entiers ayant la même forme que l'entrée.
`torch.randperm(n, dtype, device, requires_grad)`	Créez une permutation aléatoire de 0 à n-1.
`torch.sparse_coo_tensor(indices, values, size, dtype, device, requires_grad)`	À la`indices`position spécifiée, construisez un tenseur COO creux.
`torch.sparse_csr_tensor(crow_indices, col_indices, values, size, dtype, device)`	Construisez un tenseur CSR creux.
`torch.sparse_csc_tensor(ccol_indices, row_indices, values, size, dtype, device)`	Construisez un tenseur CSC creux.
`torch.quantize_per_tensor(input, scale, zero_point, dtype)`	Créer un tenseur quantifié (par tenseur).
`torch.quantize_per_channel(input, scales, zero_points, axis, dtype)`	Créer un tenseur quantifié (par canal).
`torch.dequantize(input)`	Déquantifier un tenseur.
`torch.complex(real, imag)`	Créer un tenseur complexe à partir des parties réelle et imaginaire.
`torch.polar(abs, angle)`	Créer un tenseur complexe à partir de coordonnées polaires.
`torch.heaviside(input, values)`	Calculer la fonction de Heaviside.

Opérations d'indexation, de découpage, d'assemblage et de mutation.

Fonction	Description
`torch.cat(tensors, dim, out)`	Concaténer des tenseurs le long d'une dimension spécifiée.
`torch.concat(tensors, dim, out)`	Concaténer des tenseurs le long d'une dimension spécifiée (identique à cat).
`torch.concatenate(tensors, dim, out)`	Concaténer des tenseurs le long d'une dimension spécifiée (identique à cat).
`torch.stack(tensors, dim, out)`	Empiler des tenseurs le long d'une nouvelle dimension.
`torch.split(tensor, split_size, dim)`	Diviser un tenseur le long d'une dimension spécifiée.
`torch.chunk(tensor, chunks, dim)`	Découper un tenseur en blocs le long d'une dimension spécifiée.
`torch.reshape(input, shape)`	Changer la forme d'un tenseur.
`torch.transpose(input, dim0, dim1)`	Échanger deux dimensions d'un tenseur.
`torch.t(input)`	Transposer un tenseur 2-D.
`torch.squeeze(input, dim)`	Supprimer une dimension de taille 1.
`torch.unsqueeze(input, dim)`	Insérer une dimension de taille 1 à une position spécifiée.
`torch.permute(input, dims)`	Réorganiser les dimensions d'un tenseur.
`torch.movedim(input, source, destination)`	Déplacer une dimension du tenseur vers une nouvelle position.
`torch.moveaxis(input, source, destination)`	Déplacer un axe du tenseur vers une nouvelle position.
`torch.narrow(input, dim, start, length)`	Renvoyer une tranche d'un tenseur.
`torch.narrow_copy(input, dim, start, length)`	Renvoyer une copie d'une tranche d'un tenseur.
`torch.select(input, dim, index)`	Sélectionner les tranches correspondant aux indices le long d'une dimension spécifiée.
`torch.slice_scatter(input, src, dim, start, end)`	Disperser src dans les tranches de input.
`torch.select_scatter(input, src, dim, index)`	Répartir src dans les positions d'index spécifiées.
`torch.diagonal_scatter(input, src, offset, dim1, dim2)`	Répartir les valeurs dans les positions diagonales.
`torch.expand(input, size)`	Étendre la taille d'un tenseur (vue de copie).
`torch.expand_as(input, other)`	Étendre le tenseur à la même taille que other.
`torch.masked_select(input, mask)`	Sélectionner les éléments selon un masque booléen.
`torch.index_select(input, dim, index)`	Sélectionner les éléments correspondant aux indices le long d'une dimension spécifiée.
`torch.gather(input, dim, index, sparse_grad)`	Rassembler les éléments aux indices spécifiés le long d'une dimension spécifiée.
`torch.scatter(input, dim, index, src, reduce)`	va`src`répartir les valeurs de ... vers`input`les positions spécifiées de ...
`torch.scatter_add(input, dim, index, src)`	Ajouter les valeurs de src aux positions spécifiées.
`torch.scatter_reduce(input, dim, index, src, reduce, include_self)`	Agréger les valeurs de src aux positions spécifiées de la manière spécifiée.
`torch.index_add(input, dim, index, source, alpha)`	Ajouter source aux positions spécifiées par index.
`torch.index_copy(input, dim, index, source)`	Copier la source vers les positions spécifiées par index.
`torch.index_reduce(input, dim, index, source, reduce, include_self)`	Agréger la source vers les positions spécifiées par index de la manière spécifiée.
`torch.take(input, index)`	Obtenir l'élément à la position d'index donnée.
`torch.take_along_dim(input, indices, dim)`	Obtenir les éléments aux positions d'index le long d'une dimension spécifiée.
`torch.nonzero(input)`	Renvoyer les indices des éléments non nuls.
`torch.argwhere(input)`	Renvoyer les indices des éléments qui satisfont la condition.
`torch.where(condition, input, other)`	Renvoyer les éléments selon une condition.
`torch.unbind(tensor, dim)`	Diviser en un tuple le long d'une dimension spécifiée.
`torch.split_with_sizes(tensor, split_sizes, dim)`	Diviser un tenseur par tailles.
`torch.tensor_split(tensor, indices_or_sections, dim)`	Diviser un tenseur par indices ou nombre de segments.
`torch.hsplit(tensor, indices_or_sections)`	Diviser un tenseur horizontalement.
`torch.vsplit(tensor, indices_or_sections)`	Diviser un tenseur verticalement.
`torch.dsplit(tensor, indices_or_sections)`	Diviser un tenseur en profondeur.
`torch.hstack(tensors, dim, out)`	Empiler des tenseurs horizontalement.
`torch.vstack(tensors, out)`	Empiler des tenseurs verticalement.
`torch.dstack(tensors, out)`	Empiler des tenseurs en profondeur.
`torch.column_stack(tensors, out)`	Empiler des tenseurs par colonnes.
`torch.row_stack(tensors, out)`	Empiler des tenseurs par lignes (identique à vstack).
`torch.tile(input, dims)`	Répéter un tenseur plusieurs fois.
`torch.repeat_interleave(input, repeats, dim)`	Répéter des éléments le long d'une dimension spécifiée.
`torch.flip(input, dims)`	Inverser un tenseur le long d'une dimension spécifiée.
`torch.fliplr(input)`	Inverser un tenseur de gauche à droite.
`torch.flipud(input)`	Inverser un tenseur de haut en bas.
`torch.rot90(input, k, dims)`	Faire pivoter un tenseur de 90 degrés.
`torch.linalg.matrix_transpose(input)`	Transposition de matrice.
`torch.adjoint(input)`	Renvoyer l'adjoint d'un tenseur.
`torch.resolve_conj(input)`	Résoudre le tenseur conjugué.
`torch.resolve_neg(input)`	Résoudre le tenseur négatif.
`torch.view_as_real(input)`	Traiter un tenseur complexe comme un tenseur réel.
`torch.view_as_complex(input)`	Traiter un tenseur réel comme un tenseur complexe.
`torch.unravel_index(indices, shape)`	Convertir des indices aplatis en indices multidimensionnels.

Génération de nombres aléatoires

Fonction	Description
`torch.manual_seed(seed)`	Définir la graine aléatoire (CPU).
`torch.seed()`	Définir la graine aléatoire et renvoyer la nouvelle valeur de graine.
`torch.initial_seed()`	Renvoyer la graine aléatoire actuelle.
`torch.get_rng_state()`	Renvoyer l'état du générateur de nombres aléatoires.
`torch.set_rng_state(state)`	Définir l'état du générateur de nombres aléatoires.
`torch.rand(*size, dtype, device, requires_grad)`	Créez un tenseur aléatoire à distribution uniforme (plage [0, 1)).
`torch.rand_like(input, dtype, device, requires_grad)`	Créez un tenseur aléatoire à distribution uniforme ayant la même forme que l'entrée.
`torch.randn(*size, dtype, device, requires_grad)`	Créez un tenseur aléatoire suivant une distribution normale standard.
`torch.randn_like(input, dtype, device, requires_grad)`	Créez un tenseur aléatoire suivant une distribution normale standard ayant la même forme que l'entrée.
`torch.randint(low, high, size, dtype, device, requires_grad)`	Créez un tenseur aléatoire d'entiers.
`torch.randint_like(input, low, high, dtype, device, requires_grad)`	Créez un tenseur aléatoire d'entiers ayant la même forme que l'entrée.
`torch.randperm(n, dtype, device, requires_grad)`	Créez une permutation aléatoire de 0 à n-1.
`torch.bernoulli(input, *, generator)`	Générer des nombres aléatoires selon une loi de Bernoulli.
`torch.multinomial(input, num_samples, replacement, generator)`	Échantillonnage multinomial.
`torch.normal(mean, std, out)`	Générer des nombres aléatoires à partir d'une distribution normale.
`torch.poisson(input, generator)`	Générer des nombres aléatoires à partir d'une distribution de Poisson.

Sérialisation

Fonction	Description
`torch.save(obj, f, pickle_module, pickle_protocol)`	Enregistrer un objet dans un fichier.
`torch.load(f, map_location, pickle_module, weights_only)`	Charger un objet à partir d'un fichier.

Contrôle des gradients

Fonction	Description
`torch.no_grad()`	Gestionnaire de contexte qui désactive le calcul des gradients.
`torch.enable_grad()`	Gestionnaire de contexte qui active le calcul des gradients.
`torch.set_grad_enabled(grad)`	Définir si le calcul des gradients est activé.
`torch.is_grad_enabled()`	Vérifier si le calcul des gradients est activé.
`torch.inference_mode()`	Gestionnaire de contexte pour le mode inférence (désactive les gradients et autograd).
`torch.is_inference_mode_enabled()`	Vérifier si le mode inférence est activé.

Opérations mathématiques - opérations point par point

Fonction	Description
`torch.abs(input, out)`	Valeur absolue élément par élément.
`torch.absolute(input, out)`	Valeur absolue élément par élément (identique à abs).
`torch.acos(input, out)`	Arccosinus élément par élément.
`torch.arccos(input, out)`	Arccosinus élément par élément (identique à acos).
`torch.acosh(input, out)`	Cosinus hyperbolique inverse élément par élément.
`torch.arccosh(input, out)`	Cosinus hyperbolique inverse élément par élément (identique à acosh).
`torch.add(input, other, alpha, out)`	Addition élément par élément (avec mise à l'échelle alpha optionnelle).
`torch.addcdiv(input, tensor1, tensor2, value, out)`	Exécute input + value * (tensor1 / tensor2).
`torch.addcmul(input, tensor1, tensor2, value, out)`	Exécute input + value * (tensor1 * tensor2).
`torch.angle(input, out)`	Renvoie l'angle de phase d'un tenseur complexe.
`torch.asin(input, out)`	Arcsinus élément par élément.
`torch.arcsin(input, out)`	Arcsinus élément par élément (identique à asin).
`torch.asinh(input, out)`	Sinus hyperbolique inverse élément par élément.
`torch.arcsinh(input, out)`	Sinus hyperbolique inverse élément par élément (identique à asinh).
`torch.atan(input, out)`	Arctangente élément par élément.
`torch.arctan(input, out)`	Arctangente élément par élément (identique à atan).
`torch.atan2(input, other, out)`	Arctangente à deux arguments élément par élément.
`torch.arctan2(input, other, out)`	Arctangente à deux arguments élément par élément (identique à atan2).
`torch.atanh(input, out)`	Tangente hyperbolique inverse élément par élément.
`torch.arctanh(input, out)`	Tangente hyperbolique inverse élément par élément (identique à atanh).
`torch.bitwise_not(input, out)`	NON bit à bit élément par élément.
`torch.bitwise_and(input, other, out)`	ET bit à bit élément par élément.
`torch.bitwise_or(input, other, out)`	OU bit à bit élément par élément.
`torch.bitwise_xor(input, other, out)`	OU exclusif bit à bit élément par élément.
`torch.bitwise_left_shift(input, other, out)`	Décalage à gauche élément par élément.
`torch.bitwise_right_shift(input, other, out)`	Décalage à droite élément par élément.
`torch.ceil(input, out)`	Arrondi à l'entier supérieur élément par élément.
`torch.clamp(input, min, max, out)`	Limite les valeurs du tenseur à une plage spécifiée.
`torch.clip(input, min, max, out)`	Limite les valeurs du tenseur à une plage spécifiée (identique à clamp).
`torch.conj_physical(input, out)`	Conjugué physique élément par élément.
`torch.copysign(input, other, out)`	Copie du signe élément par élément.
`torch.cos(input, out)`	Cosinus élément par élément.
`torch.cosh(input, out)`	Cosinus hyperbolique élément par élément.
`torch.deg2rad(input, out)`	Convertit les angles de degrés en radians.
`torch.div(input, other, rounding_mode, out)`	Division élément par élément.
`torch.divide(input, other, rounding_mode, out)`	Division élément par élément (identique à div).
`torch.digamma(input, out)`	Fonction digamma élément par élément (dérivée logarithmique).
`torch.erf(input, out)`	Fonction d'erreur élément par élément.
`torch.erfc(input, out)`	Fonction d'erreur complémentaire élément par élément.
`torch.erfinv(input, out)`	Fonction d'erreur inverse élément par élément.
`torch.exp(input, out)`	Fonction exponentielle élément par élément.
`torch.exp2(input, out)`	Puissance de 2 élément par élément.
`torch.expm1(input, out)`	exp(x) - 1 élément par élément.
`torch.fake_quantize_per_channel_affine(input, scale, zero_point, axis, quant_min, quant_max)`	Simule la quantification par canal.
`torch.fake_quantize_per_tensor_affine(input, scale, zero_point, quant_min, quant_max)`	Simule la quantification par tenseur.
`torch.fix(input, out)`	Partie entière élément par élément (troncature vers zéro).
`torch.float_power(input, exponent, out)`	Puissance en virgule flottante élément par élément.
`torch.floor(input, out)`	Plancher élément par élément.
`torch.floor_divide(input, other, out)`	Division entière élément par élément.
`torch.fmod(input, other, out)`	Modulo (reste) élément par élément.
`torch.frac(input, out)`	Partie fractionnaire élément par élément.
`torch.frexp(input, out)`	Décompose les nombres à virgule flottante en mantisse et exposant.
`torch.gradient(input, dim, spacing, edge_order)`	Calcule le gradient d'un tenseur.
`torch.imag(input, out)`	Renvoie la partie imaginaire d'un tenseur complexe.
`torch.ldexp(input, other, out)`	Calcule élément par élément input * 2**other.
`torch.lerp(input, end, weight, out)`	Interpolation linéaire élément par élément.
`torch.lgamma(input, out)`	Logarithme élément par élément de la fonction gamma.
`torch.log(input, out)`	Logarithme népérien élément par élément.
`torch.log10(input, out)`	Logarithme en base 10 élément par élément.
`torch.log1p(input, out)`	log(1 + x) élément par élément.
`torch.log2(input, out)`	logarithme de base 2 élément par élément.
`torch.logaddexp(input, other, out)`	log(exp(input) + exp(other)) élément par élément.
`torch.logaddexp2(input, other, out)`	log2(2input + 2other) élément par élément.
`torch.logical_and(input, other, out)`	ET logique élément par élément.
`torch.logical_not(input, out)`	NON logique élément par élément.
`torch.logical_or(input, other, out)`	OU logique élément par élément.
`torch.logical_xor(input, other, out)`	OU exclusif logique élément par élément.
`torch.logit(input, eps, out)`	fonction logit élément par élément.
`torch.hypot(input, other, out)`	fonction hypot élément par élément sqrt(input^2 + other^2).
`torch.i0(input, out)`	fonction de Bessel modifiée élément par élément (première espèce, ordre 0).
`torch.igamma(input, other, out)`	fonction gamma incomplète élément par élément.
`torch.igammac(input, other, out)`	Fonction gamma incomplète complémentaire élément par élément.
`torch.mul(input, other, out)`	Multiplication élément par élément.
`torch.multiply(input, other, out)`	Multiplication élément par élément (identique à mul).
`torch.mvlgamma(input, p, out)`	Logarithme élément par élément de la fonction gamma multivariée.
`torch.nan_to_num(input, nan, posinf, neginf, out)`	Remplace NaN par une valeur spécifiée.
`torch.neg(input, out)`	Négation élément par élément.
`torch.negative(input, out)`	Négation élément par élément (identique à neg).
`torch.nextafter(input, other, out)`	Renvoie, élément par élément, le nombre à virgule flottante représentable suivant.
`torch.polygamma(input, n, out)`	Fonction polygamma élément par élément.
`torch.positive(input, out)`	Positif élément par élément.
`torch.pow(input, exponent, out)`	Puissance élément par élément.
`torch.quantized_batch_norm(input, weight, bias, mean, var, eps, output_scale, output_zero_point)`	Normalisation par lots quantifiée.
`torch.quantized_max_pool1d(input, kernel_size, stride, padding, dilation, ceil_mode)`	Max pooling quantifié (1D).
`torch.quantized_max_pool2d(input, kernel_size, stride, padding, dilation, ceil_mode)`	Max pooling quantifié (2D).
`torch.rad2deg(input, out)`	Convertit les angles de radians en degrés.
`torch.real(input, out)`	Renvoie la partie réelle d'un tenseur complexe.
`torch.reciprocal(input, out)`	Réciproque élément par élément.
`torch.remainder(input, other, out)`	Reste élément par élément.
`torch.round(input, decimals, out)`	Arrondi élément par élément à l'entier le plus proche.
`torch.rsqrt(input, out)`	Racine carrée réciproque élément par élément.
`torch.sigmoid(input, out)`	Fonction sigmoïde élément par élément.
`torch.sign(input, out)`	Renvoie élément par élément le signe (-1, 0, 1).
`torch.sgn(input, out)`	Renvoie élément par élément le vecteur de signes.
`torch.signbit(input, out)`	Vérifie élément par élément le bit de signe.
`torch.sin(input, out)`	Sinus élément par élément.
`torch.sinc(input, out)`	Fonction sinc élément par élément sin(pix)/(pix).
`torch.sinh(input, out)`	Sinus hyperbolique élément par élément.
`torch.softmax(input, dim, dtype)`	Fonction softmax élément par élément.
`torch.sqrt(input, out)`	Racine carrée élément par élément.
`torch.square(input, out)`	Carré élément par élément.
`torch.sub(input, other, alpha, out)`	Soustraction élément par élément.
`torch.subtract(input, other, alpha, out)`	Soustraction élément par élément (identique à sub).
`torch.tan(input, out)`	Tangente élément par élément.
`torch.tanh(input, out)`	Tangente hyperbolique élément par élément.
`torch.true_divide(input, other, out)`	Division vraie élément par élément.
`torch.trunc(input, out)`	Troncature élément par élément (partie entière).
`torch.xlogy(input, other, out)`	Calcule élément par élément input * log(other).

Opérations mathématiques - opérations de réduction

Fonction	Description
`torch.argmax(input, dim, keepdim)`	Renvoie l’indice de la valeur maximale selon une dimension.
`torch.argmin(input, dim, keepdim)`	Renvoie l’indice de la valeur minimale selon une dimension.
`torch.amax(input, dim, keepdim, out)`	Renvoie la valeur maximale selon une dimension.
`torch.amin(input, dim, keepdim, out)`	Renvoie la valeur minimale selon une dimension.
`torch.aminmax(input, dim, keepdim, out)`	Renvoie les valeurs minimale et maximale selon une dimension.
`torch.all(input, dim, keepdim, out)`	Teste si tous les éléments sont True.
`torch.any(input, dim, keepdim, out)`	Teste si au moins un élément est True.
`torch.max(input, dim, keepdim, out)`	Calcule le maximum selon une dimension spécifiée.
`torch.min(input, dim, keepdim, out)`	Calcule le minimum selon une dimension spécifiée.
`torch.dist(input, other, p)`	Calcule la distance de norme p entre deux tenseurs.
`torch.logsumexp(input, dim, keepdim, out)`	Calcule log-sum-exp.
`torch.mean(input, dim, keepdim, out)`	Calcule la moyenne selon une dimension spécifiée.
`torch.nanmean(input, dim, keepdim, out)`	Calcule la moyenne selon une dimension spécifiée (en ignorant les NaN).
`torch.median(input, dim, keepdim, out)`	Calcule la médiane selon une dimension spécifiée.
`torch.nanmedian(input, dim, keepdim, out)`	Calcule la médiane selon une dimension spécifiée (en ignorant les NaN).
`torch.mode(input, dim, keepdim, out)`	Calcule le mode selon une dimension spécifiée.
`torch.norm(input, p, dim, keepdim, out)`	Calcule la norme p.
`torch.nansum(input, dim, keepdim, out)`	Calcule la somme selon une dimension spécifiée (en ignorant les NaN).
`torch.prod(input, dim, keepdim, dtype, out)`	Calcule le produit selon une dimension spécifiée.
`torch.quantile(input, q, dim, keepdim, out, method)`	Calcule le quantile.
`torch.nanquantile(input, q, dim, keepdim, out, method)`	Calcule le quantile (en ignorant les NaN).
`torch.std(input, dim, unbiased, keepdim, out)`	Calcule l'écart type.
`torch.std_mean(input, dim, unbiased, keepdim)`	Calcule l'écart-type et la moyenne.
`torch.sum(input, dim, keepdim, dtype, out)`	Calcule la somme selon une dimension spécifiée.
`torch.unique(input, sorted, return_inverse, return_counts, dim)`	Renvoie les éléments uniques.
`torch.unique_consecutive(input, sorted, return_inverse, return_counts, dim)`	Renvoie les éléments uniques consécutifs.
`torch.var(input, dim, unbiased, keepdim, out)`	Calcule la variance.
`torch.var_mean(input, dim, unbiased, keepdim)`	Calcule la variance et la moyenne.
`torch.count_nonzero(input, dim)`	Compte le nombre d'éléments non nuls.
`torch.hash_tensor(input)`	Calcule la valeur de hachage d'un tenseur.

Opérations mathématiques - opérations de comparaison

Fonction	Description
`torch.allclose(input, other, rtol, atol, equal_nan)`	Vérifie si deux tenseurs sont proches (tous les éléments).
`torch.argsort(input, dim, descending, stable)`	Renvoie les indices qui trient le tenseur.
`torch.eq(input, other, out)`	Comparaison d'égalité élément par élément.
`torch.equal(input, other)`	Vérifie si deux tenseurs sont exactement égaux.
`torch.ge(input, other, out)`	Comparaison élément par élément supérieure ou égale.
`torch.greater_equal(input, other, out)`	Comparaison élément par élément supérieure ou égale (identique à ge).
`torch.gt(input, other, out)`	Comparaison élément par élément supérieure.
`torch.greater(input, other, out)`	Comparaison élément par élément supérieure (identique à gt).
`torch.isclose(input, other, rtol, atol, equal_nan)`	Vérifie si deux tenseurs sont proches (élément par élément).
`torch.isfinite(input, out)`	Vérifie si les valeurs sont finies.
`torch.isin(elements, test_elements, assume_unique, invert)`	Vérifie si les éléments sont dans un ensemble.
`torch.isinf(input, out)`	Vérifie si les valeurs sont infinies.
`torch.isposinf(input, out)`	Vérifie si les valeurs sont l'infini positif.
`torch.isneginf(input, out)`	Vérifie si les valeurs sont l'infini négatif.
`torch.isnan(input, out)`	Vérifie si les valeurs sont NaN.
`torch.isreal(input, out)`	Vérifie si les valeurs sont réelles.
`torch.kthvalue(input, k, dim, keepdim, out)`	Renvoie le k-ième plus petit élément et son indice.
`torch.le(input, other, out)`	Comparaison élément par élément avec l'opérateur inférieur ou égal.
`torch.less_equal(input, other, out)`	Comparaison élément par élément avec l'opérateur inférieur ou égal (identique à « le »).
`torch.lt(input, other, out)`	Comparaison élément par élément avec l'opérateur inférieur.
`torch.less(input, other, out)`	Comparaison élément par élément avec l'opérateur inférieur (identique à « lt »).
`torch.maximum(input, other, out)`	Maximum élément par élément.
`torch.minimum(input, other, out)`	Minimum élément par élément.
`torch.fmax(input, other, out)`	Maximum élément par élément (en ignorant les NaNs).
`torch.fmin(input, other, out)`	Minimum élément par élément (en ignorant les NaNs).
`torch.ne(input, other, out)`	Comparaison élément par élément avec l'opérateur d'inégalité.
`torch.not_equal(input, other, out)`	Comparaison élément par élément avec l'opérateur d'inégalité (identique à « ne »).
`torch.sort(input, dim, descending, stable, out)`	Trie selon une dimension spécifiée.
`torch.topk(input, k, dim, largest, sorted, out)`	Renvoie les k plus grands éléments et leurs indices.
`torch.msort(input, out)`	Trie selon la dernière dimension (renvoie le tenseur trié).

Opérations mathématiques - opérations spectrales

Fonction	Description
`torch.stft(input, n_fft, hop_length, win_length, window, center, normalized, onesided, return_complex)`	Transformée de Fourier à court terme.
`torch.istft(input, n_fft, hop_length, win_length, window, center, normalized, onesided, length, return_complex)`	Transformée de Fourier à court terme inverse.
`torch.bartlett_window(window_length, periodic, dtype, device)`	Fenêtre de Bartlett.
`torch.blackman_window(window_length, periodic, dtype, device)`	Fenêtre de Blackman.
`torch.hamming_window(window_length, periodic, alpha, beta, dtype, device)`	Fenêtre de Hamming.
`torch.hann_window(window_length, periodic, dtype, device)`	Fenêtre de Hann.
`torch.kaiser_window(window_length, periodic, beta, dtype, device)`	Fenêtre de Kaiser.

Opérations mathématiques - autres opérations

Fonction	Description
`torch.atleast_1d(*tensors)`	Convertit l'entrée en un tenseur d'au moins 1 dimension.
`torch.atleast_2d(*tensors)`	Convertit l'entrée en un tenseur d'au moins 2 dimensions.
`torch.atleast_3d(*tensors)`	Convertit l'entrée en un tenseur d'au moins 3 dimensions.
`torch.bincount(input, weights, minlength)`	Compte les occurrences d'entiers non négatifs.
`torch.block_diag(*tensors)`	Construit une matrice diagonale par blocs à partir du tenseur d'entrée.
`torch.broadcast_tensors(*tensors)`	Diffuse l'entrée vers une forme commune.
`torch.broadcast_to(input, shape)`	Diffuse le tenseur vers une forme spécifiée.
`torch.broadcast_shapes(*shapes)`	Diffuse les formes pour qu'elles soient compatibles pour les opérations.
`torch.bucketize(input, boundaries, right)`	Mappe l'entrée vers des indices de compartiment.
`torch.cartesian_prod(*tensors)`	Calcule le produit cartésien.
`torch.cdist(x1, x2, p, compute_mode)`	Calcule les distances par paires.
`torch.clone(input, memory_format)`	Renvoie une copie du tenseur.
`torch.combinations(input, r, with_replacement)`	Calcule les combinaisons.
`torch.corrcoef(input)`	Calcule la matrice des coefficients de corrélation.
`torch.cov(input, correction, fweights, aweights)`	Calcule la matrice de covariance.
`torch.cross(input, dim, out)`	Calcule le produit vectoriel.
`torch.cummax(input, dim, out)`	Accumule la valeur maximale selon une dimension.
`torch.cummin(input, dim, out)`	Accumule la valeur minimale selon une dimension.
`torch.cumprod(input, dim, out)`	Accumule le produit selon une dimension.
`torch.cumsum(input, dim, out, dtype)`	Accumule la somme selon une dimension.
`torch.diag(input, diagonal, out)`	Crée une matrice diagonale ou extrait la diagonale.
`torch.diag_embed(input, offset, dim1, dim2, out)`	Intègre l’entrée sous forme de diagonale.
`torch.diagflat(input, offset, out)`	Crée une matrice diagonale (entrée aplatie).
`torch.diagonal(input, offset, dim1, dim2, out)`	Extrait les éléments diagonaux.
`torch.diff(input, n, dim, prepend, append, out)`	Calcule la différence.
`torch.einsum(equation, *operands)`	Convention de sommation d'Einstein.
`torch.flatten(input, start_dim, end_dim, out)`	Aplatit le tenseur.
`torch.ravel(input, out)`	Aplatit en un tenseur unidimensionnel.
`torch.kron(input, other, out)`	Calcule le produit de Kronecker.
`torch.meshgrid(*tensors, indexing)`	Crée une grille.
`torch.lcm(input, other, out)`	Plus petit commun multiple élément par élément.
`torch.logcumsumexp(input, dim, out)`	Log-sum-exp cumulatif le long d'une dimension.
`torch.renorm(input, p, dim, maxnorm, out)`	Renormalise vers une norme spécifiée.
`torch.roll(input, shifts, dims)`	Décale les éléments du tenseur.
`torch.searchsorted(sorted_sequence, values, side, sorter)`	Recherche les positions dans une séquence triée.
`torch.tensordot(a, b, dims)`	Calcule le produit scalaire tensoriel.
`torch.trace(input, out)`	Calcule la trace d'une matrice.
`torch.tril(input, diagonal, out)`	Extrait la matrice triangulaire inférieure.
`torch.tril_indices(row, column, offset, dtype, device, layout)`	Génère les indices triangulaires inférieurs.
`torch.triu(input, diagonal, out)`	Extrait la matrice triangulaire supérieure.
`torch.triu_indices(row, column, offset, dtype, device, layout)`	Génère les indices triangulaires supérieurs.
`torch.unflatten(input, dim, sizes)`	Déplie le tenseur.
`torch.vander(x, N, increasing, out)`	Crée une matrice de Vandermonde.

Algèbre linéaire (BLAS et LAPACK)

Fonction	Description
`torch.addbmm(input, batch1, batch2, beta, alpha, out)`	Multiplication-addition matrice-matrice par lots.
`torch.addmm(input, mat1, mat2, beta, alpha, out)`	Multiplication-addition matricielle.
`torch.addmv(input, mat, vec, beta, alpha, out)`	Multiplication-addition matrice-vecteur.
`torch.addr(input, vec1, vec2, beta, alpha, out)`	Addition de produit extérieur de vecteurs.
`torch.baddbmm(input, batch1, batch2, beta, alpha, out)`	Multiplication-addition matricielle par lots (bmm + add).
`torch.bmm(input, mat2, out)`	Multiplication matricielle par lots.
`torch.chain_matmul(*matrices)`	Multiplication matricielle chaînée.
`torch.cholesky(input, upper, out)`	Décomposition de Cholesky.
`torch.cholesky_inverse(input, upper, out)`	Inverse par décomposition de Cholesky.
`torch.cholesky_solve(input, input2, upper, out)`	Résolution d'équations linéaires par décomposition de Cholesky.
`torch.dot(input, other, out)`	Calcule le produit scalaire de deux vecteurs.
`torch.geqrf(input, out)`	Décomposition QR (geqrf).
`torch.ger(input, other, out)`	Calcule le produit extérieur de vecteurs.
`torch.inner(input, other, out)`	Calcule le produit intérieur.
`torch.inverse(input, out)`	Calcule l'inverse d'une matrice.
`torch.det(input, out)`	Calcule le déterminant d'une matrice.
`torch.logdet(input, out)`	Calcule le logarithme du déterminant.
`torch.slogdet(input, out)`	Calcule le signe et le logarithme de la valeur absolue du déterminant.
`torch.lu(input, pivot, get_infos, out)`	Décomposition LU.
`torch.lu_solve(input, LU_data, LU_pivots, out)`	Résolution par décomposition LU.
`torch.lu_unpack(LU_data, LU_pivots, unpack_data, unpack_pivots)`	Déballe le résultat de la décomposition LU.
`torch.matmul(input, other, out)`	Multiplication matricielle (prend en charge différentes dimensions).
`torch.matrix_power(input, n, out)`	Puissance de matrice.
`torch.matrix_exp(input, out)`	Exponentielle de matrice.
`torch.mm(input, mat2, out)`	Multiplication matricielle (2D).
`torch.mv(input, vec, out)`	Multiplication matrice-vecteur.
`torch.orgqr(input, q, out)`	Reconstruit Q à partir de la décomposition QR.
`torch.ormqr(input, mat, vec, left, transpose, out)`	Opération ormqr.
`torch.outer(input, other, out)`	Calcule le produit extérieur de vecteurs.
`torch.pinverse(input, rcond, out)`	Calcule le pseudo-inverse de Moore-Penrose.
`torch.qr(input, out)`	Décomposition QR.
`torch.svd(input, some, compute_uv, out)`	Décomposition en valeurs singulières.
`torch.svd_lowrank(input, q, niter, M)`	Approximation SVD de rang faible.
`torch.pca_lowrank(input, q, center, niter)`	Approximation ACP de rang faible.
`torch.lobpcg(input, K, B, X, M, P, max_iter, tol, debug, ortho_iparams, fpfloor)`	Solveur de valeurs propres LOBPCG.
`torch.trapz(y, x, dim, out)`	Intégration trapézoïdale (obsolète, utiliser trapezoid).
`torch.trapezoid(y, x, dim, out)`	Intégration trapézoïdale.
`torch.cumulative_trapezoid(y, x, dim, out)`	Intégration trapézoïdale cumulative.
`torch.triangular_solve(input, A, upper, transpose, unitriangular, out)`	Résolution de matrice triangulaire.
`torch.vdot(input, other, out)`	Calcule le produit scalaire de vecteurs (gère les nombres complexes).

Gestion des appareils

Fonction	Description
`torch.cuda.is_available()`	Vérifie si CUDA est disponible.
`torch.cuda.device_count()`	Renvoie le nombre de périphériques CUDA.
`torch.cuda.current_device()`	Renvoie l’indice du périphérique CUDA actuel.
`torch.cuda.device(name)`	Crée un objet périphérique.
`torch.cuda.device_context(device)`	Crée un contexte de périphérique.
`torch.device(device)`	Crée un objet périphérique (par ex.,`'cpu'`ou`'cuda:0'`）。
`torch.Tensor.to(device)`	Déplace le tenseur vers le périphérique spécifié.
`torch.get_device_module(device_type)`	Obtient le module de périphérique (par ex., cuda, mps).

Calcul parallèle

Fonction	Description
`torch.get_num_threads()`	Obtient le nombre total de threads pour les opérations CPU.
`torch.set_num_threads(int)`	Définit le nombre de threads pour les opérations CPU.
`torch.get_num_interop_threads()`	Obtient le nombre de threads parallèles inter-op.
`torch.set_num_interop_threads(int)`	Définit le nombre de threads parallèles inter-op.

Fonctions utilitaires

Fonction	Description
`torch.compiled_with_cxx11_abi()`	Vérifie si le code est compilé avec l'ABI C++11.
`torch.result_type(tensor, other)`	Renvoie le dtype du résultat de l'opération.
`torch.can_cast(from_dtype, to_dtype)`	Vérifie si les types de données peuvent être convertis.
`torch.promote_types(type1, type2)`	Renvoie le type de données promu.
`torch.use_deterministic_algorithms(mode, warn_only)`	Active/désactive les algorithmes déterministes.
`torch.are_deterministic_algorithms_enabled()`	Vérifie si les algorithmes déterministes sont activés.
`torch.is_deterministic_algorithms_warn_only_enabled()`	Vérifie si les algorithmes déterministes sont en mode avertissement.
`torch.set_deterministic_debug_mode(debug_mode)`	Définit le mode de débogage déterministe.
`torch.get_deterministic_debug_mode()`	Obtient le mode de débogage déterministe.
`torch.set_float32_matmul_precision(precision)`	Définit la précision pour la multiplication matricielle float32.
`torch.get_float32_matmul_precision()`	Obtient la précision pour la multiplication matricielle float32.
`torch.set_warn_always(enabled)`	Définit s'il faut toujours afficher les avertissements.
`torch.is_warn_always_enabled()`	Vérifie si les avertissements sont toujours affichés.
`torch.vmap(fn, in_dims, out_dims, randomness, chunk_size)`	Mappage vectorisé.
`torch._assert(condition, message)`	Vérification d'assertion (usage interne).
`torch.typename(t)`	Renvoie la représentation sous forme de chaîne du type.

Optimisation de compilation

Fonction	Description
`torch.compile(model, backend, options, dynamic)`	Compile un modèle PyTorch pour l'optimisation.

Exemple

import torch

# Créer un tenseur
x = torch.tensor([1, 2, 3])
y = torch.zeros(2, 3)

# Opérations mathématiques
z = torch.add(x, 1) # Addition élément par élément 1
print(z)

# Indexation et découpage
mask = x > 1
selected = torch.masked_select(x, mask)
print(selected)

# Gestion des périphériques
if torch.cuda.is_available():
device = torch.device('cuda')
x = x.to(device)
print(x.device)

# Opérations matricielles
a = torch.randn(3, 4)
b = torch.randn(4, 5)
c = torch.matmul(a, b)
print(c.shape)

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

Sortie :

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

Pour plus d'informations détaillées, veuillez consulterDocumentation officielle PyTorch。

Autres extensions