Manual de referencia de Pytorch torch

El paquete de software PyTorch contiene estructuras de datos para tensores multidimensionales y define operaciones matemáticas que se ejecutan sobre estos tensores. Además, proporciona muchas utilidades para serializar eficientemente tensores y datos de cualquier tipo, así como otras herramientas útiles.

También tiene una versión CUDA que te permite ejecutar cálculos con tensores en GPUs NVIDIA con capacidad de cómputo >= 3.0.

Manual de API de PyTorch torch

Comprobación de tipos de tensores

Función	Descripción
`torch.is_tensor(obj)`	Comprobar`obj`si es un tensor de PyTorch.
`torch.is_storage(obj)`	Comprobar`obj`si es un objeto Storage de PyTorch.
`torch.is_complex(input)`	Comprobar`input`si el tipo de datos es un tipo de datos complejo.
`torch.is_conj(input)`	Comprobar`input`si es un tensor conjugado.
`torch.is_floating_point(input)`	Comprobar`input`si el tipo de datos es un tipo de datos de coma flotante.
`torch.is_nonzero(input)`	Comprobar`input`si es un tensor de un solo elemento distinto de cero.
`torch.set_default_dtype(d)`	Establecer el tipo de datos de coma flotante predeterminado a`d`。
`torch.get_default_dtype()`	Obtener el tipo de coma flotante predeterminado actual`torch.dtype`。
`torch.set_default_device(device)`	Establecer el predeterminado`torch.Tensor`el dispositivo asignado a`device`。
`torch.get_default_device()`	Obtener el predeterminado`torch.Tensor`dispositivo asignado.
`torch.set_default_tensor_type(tensor_type)`	Establecer el tipo de tensor predeterminado a`tensor_type`。
`torch.numel(input)`	Devuelve`input`el número total de elementos en el tensor.
`torch.set_printoptions(...)`	Establece las opciones de impresión de tensores.

Creación de tensores

Función	Descripción
`torch.tensor(data, dtype, device, requires_grad)`	Crea un tensor a partir de datos, copiando los datos, sin historial de autograd.
`torch.as_tensor(data, dtype, device)`	Convierte los datos a un tensor, compartiendo los datos y conservando el historial de autograd.
`torch.asarray(data, dtype, device)`	Convierte los datos en un tensor (array).
`torch.from_numpy(ndarray)`	Crea un tensor a partir de un array de NumPy (memoria compartida).
`torch.from_dlpack(ext_tensor)`	Crea un tensor de PyTorch a partir de un tensor dlpack.
`torch.frombuffer(buffer, dtype, count, offset)`	Crea un tensor unidimensional a partir de un buffer.
`torch.zeros(*size, dtype, device, requires_grad)`	Crea un tensor de ceros.
`torch.zeros_like(input, dtype, device, requires_grad)`	Crea un tensor de ceros con la misma forma que la entrada.
`torch.ones(*size, dtype, device, requires_grad)`	Crea un tensor de unos.
`torch.ones_like(input, dtype, device, requires_grad)`	Crea un tensor de unos con la misma forma que la entrada.
`torch.empty(*size, dtype, device, requires_grad)`	Crea un tensor no inicializado.
`torch.empty_like(input, dtype, device, requires_grad)`	Crea un tensor no inicializado con la misma forma que la entrada.
`torch.empty_strided(size, stride, dtype, device)`	Crea un tensor no inicializado con el stride especificado.
`torch.arange(start, end, step, dtype, device, requires_grad)`	Crea un tensor con una progresión aritmética.
`torch.range(start, end, step, dtype, device, requires_grad)`	Crea un tensor con una progresión aritmética que incluye el valor end.
`torch.linspace(start, end, steps, dtype, device, requires_grad)`	Crea un tensor con una secuencia de espaciado uniforme.
`torch.logspace(start, end, steps, base, dtype, device, requires_grad)`	Crea un tensor con una secuencia de espaciado logarítmico.
`torch.eye(n, m, dtype, device, requires_grad)`	Crea una matriz identidad.
`torch.full(size, fill_value, dtype, device, requires_grad)`	Crea un tensor rellenado con el valor especificado.
`torch.full_like(input, fill_value, dtype, device, requires_grad)`	Crea un tensor rellenado con la misma forma que la entrada.
`torch.rand(*size, dtype, device, requires_grad)`	Crea un tensor aleatorio de distribución uniforme (rango [0, 1)).
`torch.rand_like(input, dtype, device, requires_grad)`	Crea un tensor aleatorio de distribución uniforme con la misma forma que la entrada.
`torch.randn(*size, dtype, device, requires_grad)`	Crea un tensor aleatorio de distribución normal estándar.
`torch.randn_like(input, dtype, device, requires_grad)`	Crea un tensor aleatorio de distribución normal estándar con la misma forma que la entrada.
`torch.randint(low, high, size, dtype, device, requires_grad)`	Crea un tensor de enteros aleatorios.
`torch.randint_like(input, low, high, dtype, device, requires_grad)`	Crea un tensor de enteros aleatorios con la misma forma que la entrada.
`torch.randperm(n, dtype, device, requires_grad)`	Crea una permutación aleatoria de 0 a n-1.
`torch.sparse_coo_tensor(indices, values, size, dtype, device, requires_grad)`	En las posiciones especificadas`indices`construye un tensor disperso COO.
`torch.sparse_csr_tensor(crow_indices, col_indices, values, size, dtype, device)`	Construye un tensor disperso CSR.
`torch.sparse_csc_tensor(ccol_indices, row_indices, values, size, dtype, device)`	Construye un tensor disperso CSC.
`torch.quantize_per_tensor(input, scale, zero_point, dtype)`	Crea un tensor cuantizado (per-tensor).
`torch.quantize_per_channel(input, scales, zero_points, axis, dtype)`	Crea un tensor cuantizado (per-channel).
`torch.dequantize(input)`	Descuantifica un tensor.
`torch.complex(real, imag)`	Crea un tensor complejo a partir de la parte real y la parte imaginaria.
`torch.polar(abs, angle)`	Crea un tensor complejo a partir de coordenadas polares.
`torch.heaviside(input, values)`	Calcula la función escalón de Heaviside.

Operaciones de indexado, rebanado, concatenación y mutación

Función	Descripción
`torch.cat(tensors, dim, out)`	Concatena tensores a lo largo de la dimensión especificada.
`torch.concat(tensors, dim, out)`	Concatena tensores a lo largo de la dimensión especificada (igual que cat).
`torch.concatenate(tensors, dim, out)`	Concatena tensores a lo largo de la dimensión especificada (igual que cat).
`torch.stack(tensors, dim, out)`	Apila tensores a lo largo de una nueva dimensión.
`torch.split(tensor, split_size, dim)`	Divide los tensores a lo largo de la dimensión especificada.
`torch.chunk(tensor, chunks, dim)`	Divide el tensor en bloques a lo largo de la dimensión especificada.
`torch.reshape(input, shape)`	Cambia la forma del tensor.
`torch.transpose(input, dim0, dim1)`	Intercambia dos dimensiones del tensor.
`torch.t(input)`	Transpone un tensor bidimensional.
`torch.squeeze(input, dim)`	Elimina las dimensiones de tamaño 1.
`torch.unsqueeze(input, dim)`	Inserta una dimensión de tamaño 1 en la posición especificada.
`torch.permute(input, dims)`	Reordena las dimensiones del tensor.
`torch.movedim(input, source, destination)`	Mueve las dimensiones del tensor a nuevas posiciones.
`torch.moveaxis(input, source, destination)`	Mueve los ejes del tensor a nuevas posiciones.
`torch.narrow(input, dim, start, length)`	Devuelve un slice del tensor.
`torch.narrow_copy(input, dim, start, length)`	Devuelve una copia del slice del tensor.
`torch.select(input, dim, index)`	Selecciona el slice correspondiente al índice a lo largo de la dimensión especificada.
`torch.slice_scatter(input, src, dim, start, end)`	Dispersa src en los slices de input.
`torch.select_scatter(input, src, dim, index)`	Dispersa src en las posiciones de índice especificadas.
`torch.diagonal_scatter(input, src, offset, dim1, dim2)`	Dispersa valores en las posiciones diagonales.
`torch.expand(input, size)`	Expande el tamaño del tensor (vista).
`torch.expand_as(input, other)`	Expande el tensor al mismo tamaño que other.
`torch.masked_select(input, mask)`	Selecciona elementos según una máscara booleana.
`torch.index_select(input, dim, index)`	Selecciona elementos correspondientes a los índices a lo largo de la dimensión especificada.
`torch.gather(input, dim, index, sparse_grad)`	Recoge los elementos en los índices especificados a lo largo de la dimensión especificada.
`torch.scatter(input, dim, index, src, reduce)`	va a`src`Dispersa los valores de`input`en las posiciones especificadas de.
`torch.scatter_add(input, dim, index, src)`	Suma los valores de src en las posiciones especificadas.
`torch.scatter_reduce(input, dim, index, src, reduce, include_self)`	Acumula los valores de src en las posiciones especificadas según el modo especificado.
`torch.index_add(input, dim, index, source, alpha)`	Suma source en las posiciones especificadas por index.
`torch.index_copy(input, dim, index, source)`	Copia source en las posiciones especificadas por index.
`torch.index_reduce(input, dim, index, source, reduce, include_self)`	Acumula source en las posiciones especificadas por index según el modo especificado.
`torch.take(input, index)`	Obtiene los elementos en las posiciones de índice dadas.
`torch.take_along_dim(input, indices, dim)`	Obtiene los elementos en las posiciones de índice a lo largo de la dimensión especificada.
`torch.nonzero(input)`	Devuelve los índices de los elementos distintos de cero.
`torch.argwhere(input)`	Devuelve los índices de los elementos que cumplen la condición.
`torch.where(condition, input, other)`	Devuelve elementos según la condición.
`torch.unbind(tensor, dim)`	Divide el tensor en una tupla a lo largo de la dimensión especificada.
`torch.split_with_sizes(tensor, split_sizes, dim)`	Divide el tensor por tamaños.
`torch.tensor_split(tensor, indices_or_sections, dim)`	Divide el tensor por índices o número de segmentos.
`torch.hsplit(tensor, indices_or_sections)`	Divide el tensor horizontalmente.
`torch.vsplit(tensor, indices_or_sections)`	Divide el tensor verticalmente.
`torch.dsplit(tensor, indices_or_sections)`	Divide el tensor en profundidad.
`torch.hstack(tensors, dim, out)`	Apila tensores horizontalmente.
`torch.vstack(tensors, out)`	Apila tensores verticalmente.
`torch.dstack(tensors, out)`	Apila tensores en profundidad.
`torch.column_stack(tensors, out)`	Apila tensores por columnas.
`torch.row_stack(tensors, out)`	Apila tensores por filas (igual que vstack).
`torch.tile(input, dims)`	Repite el tensor varias veces.
`torch.repeat_interleave(input, repeats, dim)`	Repite elementos a lo largo de la dimensión especificada.
`torch.flip(input, dims)`	Invierte el tensor a lo largo de la dimensión especificada.
`torch.fliplr(input)`	Invierte el tensor de izquierda a derecha.
`torch.flipud(input)`	Invierte el tensor de arriba hacia abajo.
`torch.rot90(input, k, dims)`	Rota el tensor 90 grados.
`torch.linalg.matrix_transpose(input)`	Transpone la matriz.
`torch.adjoint(input)`	Devuelve la matriz adjunta del tensor.
`torch.resolve_conj(input)`	Resuelve el tensor conjugado.
`torch.resolve_neg(input)`	Resuelve el tensor negativo.
`torch.view_as_real(input)`	Trata un tensor complejo como un tensor real.
`torch.view_as_complex(input)`	Trata un tensor real como un tensor complejo.
`torch.unravel_index(indices, shape)`	Convierte índices aplanados en índices multidimensionales.

Generación de números aleatorios

Función	Descripción
`torch.manual_seed(seed)`	Establece la semilla aleatoria (CPU).
`torch.seed()`	Establece la semilla aleatoria y devuelve el nuevo valor de semilla.
`torch.initial_seed()`	Devuelve la semilla aleatoria actual.
`torch.get_rng_state()`	Devuelve el estado del generador de números aleatorios.
`torch.set_rng_state(state)`	Establece el estado del generador de números aleatorios.
`torch.rand(*size, dtype, device, requires_grad)`	Crea un tensor aleatorio de distribución uniforme (rango [0, 1)).
`torch.rand_like(input, dtype, device, requires_grad)`	Crea un tensor aleatorio de distribución uniforme con la misma forma que la entrada.
`torch.randn(*size, dtype, device, requires_grad)`	Crea un tensor aleatorio de distribución normal estándar.
`torch.randn_like(input, dtype, device, requires_grad)`	Crea un tensor aleatorio de distribución normal estándar con la misma forma que la entrada.
`torch.randint(low, high, size, dtype, device, requires_grad)`	Crea un tensor de enteros aleatorios.
`torch.randint_like(input, low, high, dtype, device, requires_grad)`	Crea un tensor de enteros aleatorios con la misma forma que la entrada.
`torch.randperm(n, dtype, device, requires_grad)`	Crea una permutación aleatoria de 0 a n-1.
`torch.bernoulli(input, *, generator)`	Genera números aleatorios a partir de la distribución de Bernoulli.
`torch.multinomial(input, num_samples, replacement, generator)`	Realiza un muestreo multinomial.
`torch.normal(mean, std, out)`	Genera números aleatorios a partir de la distribución normal.
`torch.poisson(input, generator)`	Genera números aleatorios a partir de la distribución de Poisson.

Serialización

Función	Descripción
`torch.save(obj, f, pickle_module, pickle_protocol)`	Guarda un objeto en un archivo.
`torch.load(f, map_location, pickle_module, weights_only)`	Carga un objeto desde un archivo.

Control de gradientes

Función	Descripción
`torch.no_grad()`	Administrador de contexto que desactiva el cálculo de gradientes.
`torch.enable_grad()`	Administrador de contexto que activa el cálculo de gradientes.
`torch.set_grad_enabled(grad)`	Establece si el cálculo de gradientes está habilitado.
`torch.is_grad_enabled()`	Comprueba si el cálculo de gradientes está habilitado.
`torch.inference_mode()`	Administrador de contexto, modo de inferencia (desactiva gradientes y autograd).
`torch.is_inference_mode_enabled()`	Comprueba si el modo de inferencia está habilitado.

Operaciones matemáticas - Operaciones puntuales

Función	Descripción
`torch.abs(input, out)`	Valor absoluto elemento a elemento.
`torch.absolute(input, out)`	Valor absoluto elemento a elemento (igual que abs).
`torch.acos(input, out)`	Arcocoseno elemento a elemento.
`torch.arccos(input, out)`	Arcocoseno elemento a elemento (igual que acos).
`torch.acosh(input, out)`	Arco coseno hiperbólico elemento a elemento.
`torch.arccosh(input, out)`	Arco coseno hiperbólico elemento a elemento (igual que acosh).
`torch.add(input, other, alpha, out)`	Suma elemento a elemento (con escalado alpha opcional).
`torch.addcdiv(input, tensor1, tensor2, value, out)`	Realiza input + value * (tensor1 / tensor2).
`torch.addcmul(input, tensor1, tensor2, value, out)`	Realiza input + value * (tensor1 * tensor2).
`torch.angle(input, out)`	Devuelve el ángulo de fase de un tensor complejo.
`torch.asin(input, out)`	Arcoseno elemento a elemento.
`torch.arcsin(input, out)`	Arcoseno elemento a elemento (igual que asin).
`torch.asinh(input, out)`	Arco seno hiperbólico elemento a elemento.
`torch.arcsinh(input, out)`	Arco seno hiperbólico elemento a elemento (igual que asinh).
`torch.atan(input, out)`	Arcotangente elemento a elemento.
`torch.arctan(input, out)`	Arcotangente elemento a elemento (igual que atan).
`torch.atan2(input, other, out)`	Arcotangente bidimensional elemento a elemento.
`torch.arctan2(input, other, out)`	Arcotangente bidimensional elemento a elemento (igual que atan2).
`torch.atanh(input, out)`	Arco tangente hiperbólico elemento a elemento.
`torch.arctanh(input, out)`	Arco tangente hiperbólico elemento a elemento (igual que atanh).
`torch.bitwise_not(input, out)`	Negación bit a bit elemento a elemento.
`torch.bitwise_and(input, other, out)`	AND bit a bit elemento a elemento.
`torch.bitwise_or(input, other, out)`	OR bit a bit elemento a elemento.
`torch.bitwise_xor(input, other, out)`	XOR bit a bit elemento a elemento.
`torch.bitwise_left_shift(input, other, out)`	Desplazamiento a la izquierda elemento a elemento.
`torch.bitwise_right_shift(input, other, out)`	Desplazamiento a la derecha elemento a elemento.
`torch.ceil(input, out)`	Redondeo hacia arriba elemento a elemento.
`torch.clamp(input, min, max, out)`	Limita los valores del tensor al rango especificado.
`torch.clip(input, min, max, out)`	Limita los valores del tensor al rango especificado (igual que clamp).
`torch.conj_physical(input, out)`	Calcula el conjugado físico elemento a elemento.
`torch.copysign(input, other, out)`	Copia el signo elemento a elemento.
`torch.cos(input, out)`	Coseno elemento a elemento.
`torch.cosh(input, out)`	Coseno hiperbólico elemento a elemento.
`torch.deg2rad(input, out)`	Convierte grados a radianes.
`torch.div(input, other, rounding_mode, out)`	División elemento a elemento.
`torch.divide(input, other, rounding_mode, out)`	División elemento a elemento (igual que div).
`torch.digamma(input, out)`	Calcula la función psi (derivada logarítmica) elemento a elemento.
`torch.erf(input, out)`	Función de error elemento a elemento.
`torch.erfc(input, out)`	Función de error complementaria elemento a elemento.
`torch.erfinv(input, out)`	Función de error inversa elemento a elemento.
`torch.exp(input, out)`	Función exponencial elemento a elemento.
`torch.exp2(input, out)`	Potencia de 2 elemento a elemento.
`torch.expm1(input, out)`	exp(x) - 1 elemento a elemento.
`torch.fake_quantize_per_channel_affine(input, scale, zero_point, axis, quant_min, quant_max)`	Simula la cuantización por canal.
`torch.fake_quantize_per_tensor_affine(input, scale, zero_point, quant_min, quant_max)`	Simula la cuantización por tensor.
`torch.fix(input, out)`	Toma la parte entera elemento a elemento (truncamiento hacia cero).
`torch.float_power(input, exponent, out)`	Potencia de punto flotante elemento a elemento.
`torch.floor(input, out)`	Redondeo hacia abajo elemento a elemento.
`torch.floor_divide(input, other, out)`	División entera elemento a elemento.
`torch.fmod(input, other, out)`	Módulo (resto) elemento a elemento.
`torch.frac(input, out)`	Parte fraccionaria elemento a elemento.
`torch.frexp(input, out)`	Descompone números de punto flotante en mantisa y exponente.
`torch.gradient(input, dim, spacing, edge_order)`	Calcula el gradiente de un tensor.
`torch.imag(input, out)`	Devuelve la parte imaginaria de un tensor complejo.
`torch.ldexp(input, other, out)`	Calcula input * 2**other elemento a elemento.
`torch.lerp(input, end, weight, out)`	Interpolación lineal elemento a elemento.
`torch.lgamma(input, out)`	Logaritmo de la función gamma elemento a elemento.
`torch.log(input, out)`	Logaritmo natural elemento a elemento.
`torch.log10(input, out)`	Logaritmo en base 10 elemento a elemento.
`torch.log1p(input, out)`	log(1 + x) elemento a elemento.
`torch.log2(input, out)`	Logaritmo en base 2 elemento a elemento.
`torch.logaddexp(input, other, out)`	log(exp(input) + exp(other)) elemento a elemento.
`torch.logaddexp2(input, other, out)`	log2(2input + 2other) elemento a elemento.
`torch.logical_and(input, other, out)`	AND lógico elemento a elemento.
`torch.logical_not(input, out)`	NOT lógico elemento a elemento.
`torch.logical_or(input, other, out)`	OR lógico elemento a elemento.
`torch.logical_xor(input, other, out)`	XOR lógico elemento a elemento.
`torch.logit(input, eps, out)`	Función logit elemento a elemento.
`torch.hypot(input, other, out)`	Función hypot elemento a elemento: sqrt(input^2 + other^2).
`torch.i0(input, out)`	Función de Bessel modificada (primera especie, orden 0) elemento a elemento.
`torch.igamma(input, other, out)`	Función gamma incompleta elemento a elemento.
`torch.igammac(input, other, out)`	Función gamma incompleta complementaria elemento a elemento.
`torch.mul(input, other, out)`	Multiplicación elemento a elemento.
`torch.multiply(input, other, out)`	Multiplicación elemento a elemento (igual que mul).
`torch.mvlgamma(input, p, out)`	Logaritmo de la función gamma multivariante elemento a elemento.
`torch.nan_to_num(input, nan, posinf, neginf, out)`	Reemplaza NaN por un valor especificado.
`torch.neg(input, out)`	Negación elemento a elemento.
`torch.negative(input, out)`	Negación elemento a elemento (igual que neg).
`torch.nextafter(input, other, out)`	Devuelve el siguiente número de punto flotante representable elemento a elemento.
`torch.polygamma(input, n, out)`	Función poligamma elemento a elemento.
`torch.positive(input, out)`	Valor positivo elemento a elemento.
`torch.pow(input, exponent, out)`	Potencia elemento a elemento.
`torch.quantized_batch_norm(input, weight, bias, mean, var, eps, output_scale, output_zero_point)`	Normalización por lotes cuantizada.
`torch.quantized_max_pool1d(input, kernel_size, stride, padding, dilation, ceil_mode)`	Agrupación máxima cuantizada (1D).
`torch.quantized_max_pool2d(input, kernel_size, stride, padding, dilation, ceil_mode)`	Agrupación máxima cuantizada (2D).
`torch.rad2deg(input, out)`	Convierte radianes a grados.
`torch.real(input, out)`	Devuelve la parte real de un tensor complejo.
`torch.reciprocal(input, out)`	Recíproco elemento a elemento.
`torch.remainder(input, other, out)`	Resto elemento a elemento.
`torch.round(input, decimals, out)`	Redondeo elemento a elemento.
`torch.rsqrt(input, out)`	Recíproco de la raíz cuadrada elemento a elemento.
`torch.sigmoid(input, out)`	Función sigmoide elemento a elemento.
`torch.sign(input, out)`	Devuelve el signo elemento a elemento (-1, 0, 1).
`torch.sgn(input, out)`	Devuelve el vector de signos elemento a elemento.
`torch.signbit(input, out)`	Comprueba el bit de signo elemento a elemento.
`torch.sin(input, out)`	Seno elemento a elemento.
`torch.sinc(input, out)`	Función sinc elemento a elemento: sin(pix)/(pix).
`torch.sinh(input, out)`	Seno hiperbólico elemento a elemento.
`torch.softmax(input, dim, dtype)`	Función softmax elemento a elemento.
`torch.sqrt(input, out)`	Raíz cuadrada elemento a elemento.
`torch.square(input, out)`	Cuadrado elemento a elemento.
`torch.sub(input, other, alpha, out)`	Resta elemento a elemento.
`torch.subtract(input, other, alpha, out)`	Resta elemento a elemento (igual que sub).
`torch.tan(input, out)`	Tangente elemento a elemento.
`torch.tanh(input, out)`	Tangente hiperbólica elemento a elemento.
`torch.true_divide(input, other, out)`	División real elemento a elemento.
`torch.trunc(input, out)`	Truncamiento elemento a elemento (parte entera).
`torch.xlogy(input, other, out)`	Calcula input * log(other) elemento a elemento.

Operaciones matemáticas - Operaciones de reducción

Función	Descripción
`torch.argmax(input, dim, keepdim)`	Devuelve los índices de los valores máximos a lo largo de una dimensión.
`torch.argmin(input, dim, keepdim)`	Devuelve los índices de los valores mínimos a lo largo de una dimensión.
`torch.amax(input, dim, keepdim, out)`	Devuelve los valores máximos a lo largo de una dimensión.
`torch.amin(input, dim, keepdim, out)`	Devuelve los valores mínimos a lo largo de una dimensión.
`torch.aminmax(input, dim, keepdim, out)`	Devuelve los valores mínimo y máximo a lo largo de una dimensión.
`torch.all(input, dim, keepdim, out)`	Determina si todos los elementos son True.
`torch.any(input, dim, keepdim, out)`	Determina si algún elemento es True.
`torch.max(input, dim, keepdim, out)`	Calcula el máximo a lo largo de la dimensión especificada.
`torch.min(input, dim, keepdim, out)`	Calcula el mínimo a lo largo de la dimensión especificada.
`torch.dist(input, other, p)`	Calcula la distancia de norma p entre dos tensores.
`torch.logsumexp(input, dim, keepdim, out)`	Calcula log-sum-exp.
`torch.mean(input, dim, keepdim, out)`	Calcula la media a lo largo de la dimensión especificada.
`torch.nanmean(input, dim, keepdim, out)`	Calcula la media a lo largo de la dimensión especificada (ignorando NaN).
`torch.median(input, dim, keepdim, out)`	Calcula la mediana a lo largo de la dimensión especificada.
`torch.nanmedian(input, dim, keepdim, out)`	Calcula la mediana a lo largo de la dimensión especificada (ignorando NaN).
`torch.mode(input, dim, keepdim, out)`	Calcula la moda a lo largo de la dimensión especificada.
`torch.norm(input, p, dim, keepdim, out)`	Calcula la norma p.
`torch.nansum(input, dim, keepdim, out)`	Calcula la suma a lo largo de la dimensión especificada (ignorando NaN).
`torch.prod(input, dim, keepdim, dtype, out)`	Calcula el producto a lo largo de la dimensión especificada.
`torch.quantile(input, q, dim, keepdim, out, method)`	Calcula cuantiles.
`torch.nanquantile(input, q, dim, keepdim, out, method)`	Calcula cuantiles (ignorando NaN).
`torch.std(input, dim, unbiased, keepdim, out)`	Calcula la desviación estándar.
`torch.std_mean(input, dim, unbiased, keepdim)`	Calcula la desviación estándar y la media.
`torch.sum(input, dim, keepdim, dtype, out)`	Calcula la suma a lo largo de la dimensión especificada.
`torch.unique(input, sorted, return_inverse, return_counts, dim)`	Devuelve los elementos únicos.
`torch.unique_consecutive(input, sorted, return_inverse, return_counts, dim)`	Devuelve los elementos únicos consecutivos.
`torch.var(input, dim, unbiased, keepdim, out)`	Calcula la varianza.
`torch.var_mean(input, dim, unbiased, keepdim)`	Calcula la varianza y la media.
`torch.count_nonzero(input, dim)`	Cuenta el número de elementos distintos de cero.
`torch.hash_tensor(input)`	Calcula el valor hash de un tensor.

Operaciones matemáticas - Operaciones de comparación

Función	Descripción
`torch.allclose(input, other, rtol, atol, equal_nan)`	Comprueba si dos tensores son cercanos (todos los elementos).
`torch.argsort(input, dim, descending, stable)`	Devuelve los índices ordenados.
`torch.eq(input, other, out)`	Comparación de igualdad elemento a elemento.
`torch.equal(input, other)`	Comprueba si dos tensores son exactamente iguales.
`torch.ge(input, other, out)`	Comparación mayor o igual que elemento a elemento.
`torch.greater_equal(input, other, out)`	Comparación mayor o igual que elemento a elemento (igual que ge).
`torch.gt(input, other, out)`	Comparación mayor que elemento a elemento.
`torch.greater(input, other, out)`	Comparación mayor que elemento a elemento (igual que gt).
`torch.isclose(input, other, rtol, atol, equal_nan)`	Comprueba si dos tensores son cercanos (elemento a elemento).
`torch.isfinite(input, out)`	Comprueba si los valores son finitos.
`torch.isin(elements, test_elements, assume_unique, invert)`	Comprueba si los elementos están en un conjunto.
`torch.isinf(input, out)`	Comprueba si los valores son infinitos.
`torch.isposinf(input, out)`	Comprueba si es infinito positivo.
`torch.isneginf(input, out)`	Comprueba si es infinito negativo.
`torch.isnan(input, out)`	Comprueba si es NaN.
`torch.isreal(input, out)`	Comprueba si es un número real.
`torch.kthvalue(input, k, dim, keepdim, out)`	Devuelve el k-ésimo elemento más pequeño y su índice.
`torch.le(input, other, out)`	Comparación menor o igual que elemento a elemento.
`torch.less_equal(input, other, out)`	Comparación menor o igual que elemento a elemento (igual que le).
`torch.lt(input, other, out)`	Comparación menor que elemento a elemento.
`torch.less(input, other, out)`	Comparación menor que elemento a elemento (igual que lt).
`torch.maximum(input, other, out)`	Toma el máximo elemento a elemento.
`torch.minimum(input, other, out)`	Toma el mínimo elemento a elemento.
`torch.fmax(input, other, out)`	Toma el máximo elemento a elemento (ignorando NaN).
`torch.fmin(input, other, out)`	Toma el mínimo elemento a elemento (ignorando NaN).
`torch.ne(input, other, out)`	Comparación de desigualdad elemento a elemento.
`torch.not_equal(input, other, out)`	Comparación de desigualdad elemento a elemento (igual que ne).
`torch.sort(input, dim, descending, stable, out)`	Ordena a lo largo de la dimensión especificada.
`torch.topk(input, k, dim, largest, sorted, out)`	Devuelve los k elementos más grandes y sus índices.
`torch.msort(input, out)`	Ordena a lo largo de la última dimensión (devuelve el tensor ordenado).

Operaciones matemáticas - Operaciones espectrales

Función	Descripción
`torch.stft(input, n_fft, hop_length, win_length, window, center, normalized, onesided, return_complex)`	Transformada de Fourier de tiempo corto.
`torch.istft(input, n_fft, hop_length, win_length, window, center, normalized, onesided, length, return_complex)`	Transformada de Fourier de tiempo corto inversa.
`torch.bartlett_window(window_length, periodic, dtype, device)`	Ventana Bartlett.
`torch.blackman_window(window_length, periodic, dtype, device)`	Ventana Blackman.
`torch.hamming_window(window_length, periodic, alpha, beta, dtype, device)`	Ventana Hamming.
`torch.hann_window(window_length, periodic, dtype, device)`	Ventana Hann.
`torch.kaiser_window(window_length, periodic, beta, dtype, device)`	Ventana Kaiser.

Operaciones matemáticas - Otras operaciones

Función	Descripción
`torch.atleast_1d(*tensors)`	Convierte la entrada en un tensor de al menos 1 dimensión.
`torch.atleast_2d(*tensors)`	Convierte la entrada en un tensor de al menos 2 dimensiones.
`torch.atleast_3d(*tensors)`	Convierte la entrada en un tensor de al menos 3 dimensiones.
`torch.bincount(input, weights, minlength)`	Cuenta el número de apariciones de enteros no negativos.
`torch.block_diag(*tensors)`	Construye una matriz de bloques diagonal a partir de tensores de entrada.
`torch.broadcast_tensors(*tensors)`	Transmite las entradas a la misma forma.
`torch.broadcast_to(input, shape)`	Transmite el tensor a una forma especificada.
`torch.broadcast_shapes(*shapes)`	Transmite formas para operaciones compatibles.
`torch.bucketize(input, boundaries, right)`	Asigna las entradas a índices de cubeta (bucket).
`torch.cartesian_prod(*tensors)`	Calcula el producto cartesiano.
`torch.cdist(x1, x2, p, compute_mode)`	Calcula distancias por pares.
`torch.clone(input, memory_format)`	Devuelve una copia del tensor.
`torch.combinations(input, r, with_replacement)`	Calcula combinaciones.
`torch.corrcoef(input)`	Calcula la matriz de coeficientes de correlación.
`torch.cov(input, correction, fweights, aweights)`	Calcula la matriz de covarianza.
`torch.cross(input, dim, out)`	Calcula el producto vectorial (producto cruz).
`torch.cummax(input, dim, out)`	Acumula el máximo a lo largo de una dimensión.
`torch.cummin(input, dim, out)`	Acumula el mínimo a lo largo de una dimensión.
`torch.cumprod(input, dim, out)`	Acumula el producto a lo largo de una dimensión.
`torch.cumsum(input, dim, out, dtype)`	Acumula la suma a lo largo de una dimensión.
`torch.diag(input, diagonal, out)`	Crea una matriz diagonal o extrae la diagonal.
`torch.diag_embed(input, offset, dim1, dim2, out)`	Incrusta la entrada como una diagonal.
`torch.diagflat(input, offset, out)`	Crea una matriz diagonal (entrada plana).
`torch.diagonal(input, offset, dim1, dim2, out)`	Extrae los elementos de la diagonal.
`torch.diff(input, n, dim, prepend, append, out)`	Calcula diferencias.
`torch.einsum(equation, *operands)`	Convención de suma de Einstein.
`torch.flatten(input, start_dim, end_dim, out)`	Aplana el tensor.
`torch.ravel(input, out)`	Aplana a un tensor unidimensional.
`torch.kron(input, other, out)`	Calcula el producto de Kronecker.
`torch.meshgrid(*tensors, indexing)`	Crea una cuadrícula (meshgrid).
`torch.lcm(input, other, out)`	Mínimo común múltiplo elemento a elemento.
`torch.logcumsumexp(input, dim, out)`	Acumula log-sum-exp a lo largo de una dimensión.
`torch.renorm(input, p, dim, maxnorm, out)`	Renormaliza a una norma especificada.
`torch.roll(input, shifts, dims)`	Desplaza (roll) los elementos del tensor.
`torch.searchsorted(sorted_sequence, values, side, sorter)`	Busca posiciones en una secuencia ordenada.
`torch.tensordot(a, b, dims)`	Calcula el producto punto de tensores.
`torch.trace(input, out)`	Calcula la traza de la matriz.
`torch.tril(input, diagonal, out)`	Extrae la matriz triangular inferior.
`torch.tril_indices(row, column, offset, dtype, device, layout)`	Genera índices triangulares inferiores.
`torch.triu(input, diagonal, out)`	Extrae la matriz triangular superior.
`torch.triu_indices(row, column, offset, dtype, device, layout)`	Genera índices triangulares superiores.
`torch.unflatten(input, dim, sizes)`	Expande el tensor.
`torch.vander(x, N, increasing, out)`	Crea una matriz de Vandermonde.

Álgebra lineal (BLAS y LAPACK)

Función	Descripción
`torch.addbmm(input, batch1, batch2, beta, alpha, out)`	Multiplicación de matrices por lotes con suma.
`torch.addmm(input, mat1, mat2, beta, alpha, out)`	Multiplicación de matrices con suma.
`torch.addmv(input, mat, vec, beta, alpha, out)`	Multiplicación matriz-vector con suma.
`torch.addr(input, vec1, vec2, beta, alpha, out)`	Producto exterior de vectores con suma.
`torch.baddbmm(input, batch1, batch2, beta, alpha, out)`	Multiplicación de matrices por lotes con suma (bmm + add).
`torch.bmm(input, mat2, out)`	Multiplicación de matrices por lotes.
`torch.chain_matmul(*matrices)`	Multiplicación de matrices encadenada.
`torch.cholesky(input, upper, out)`	Descomposición de Cholesky.
`torch.cholesky_inverse(input, upper, out)`	Inversión mediante descomposición de Cholesky.
`torch.cholesky_solve(input, input2, upper, out)`	Resolución de ecuaciones lineales mediante descomposición de Cholesky.
`torch.dot(input, other, out)`	Calcula el producto punto de dos vectores.
`torch.geqrf(input, out)`	Descomposición QR (geqrf).
`torch.ger(input, other, out)`	Calcula el producto exterior de vectores.
`torch.inner(input, other, out)`	Calcula el producto interno.
`torch.inverse(input, out)`	Calcula la inversa de la matriz.
`torch.det(input, out)`	Calcula el determinante de la matriz.
`torch.logdet(input, out)`	Calcula el logaritmo del determinante.
`torch.slogdet(input, out)`	Calcula el signo y el logaritmo del valor absoluto del determinante.
`torch.lu(input, pivot, get_infos, out)`	Descomposición LU.
`torch.lu_solve(input, LU_data, LU_pivots, out)`	Resolución mediante descomposición LU.
`torch.lu_unpack(LU_data, LU_pivots, unpack_data, unpack_pivots)`	Desempaqueta el resultado de la descomposición LU.
`torch.matmul(input, other, out)`	Multiplicación de matrices (admite diferentes dimensiones).
`torch.matrix_power(input, n, out)`	Potencia de matrices.
`torch.matrix_exp(input, out)`	Exponencial de matrices.
`torch.mm(input, mat2, out)`	Multiplicación de matrices (bidimensional).
`torch.mv(input, vec, out)`	Multiplicación matriz-vector.
`torch.orgqr(input, q, out)`	Reconstruye Q a partir de la descomposición QR.
`torch.ormqr(input, mat, vec, left, transpose, out)`	Operación ormqr.
`torch.outer(input, other, out)`	Calcula el producto exterior de vectores.
`torch.pinverse(input, rcond, out)`	Calcula la pseudoinversa de Moore-Penrose.
`torch.qr(input, out)`	Descomposición QR.
`torch.svd(input, some, compute_uv, out)`	Descomposición en valores singulares.
`torch.svd_lowrank(input, q, niter, M)`	Aproximación SVD de rango bajo.
`torch.pca_lowrank(input, q, center, niter)`	Aproximación PCA de rango bajo.
`torch.lobpcg(input, K, B, X, M, P, max_iter, tol, debug, ortho_iparams, fpfloor)`	Solucionador de autovalores LOBPCG.
`torch.trapz(y, x, dim, out)`	Integración trapezoidal (obsoleta, use trapezoid).
`torch.trapezoid(y, x, dim, out)`	Integración trapezoidal.
`torch.cumulative_trapezoid(y, x, dim, out)`	Integración trapezoidal acumulativa.
`torch.triangular_solve(input, A, upper, transpose, unitriangular, out)`	Resolución de matrices triangulares.
`torch.vdot(input, other, out)`	Calcula el producto punto de vectores (compatible con complejos).

Gestión de dispositivos

Función	Descripción
`torch.cuda.is_available()`	Comprueba si CUDA está disponible.
`torch.cuda.device_count()`	Devuelve el número de dispositivos CUDA.
`torch.cuda.current_device()`	Devuelve el índice del dispositivo CUDA actual.
`torch.cuda.device(name)`	Crea un objeto de dispositivo.
`torch.cuda.device_context(device)`	Crea un contexto de dispositivo.
`torch.device(device)`	Crea un objeto de dispositivo (por ejemplo,`'cpu'`o`'cuda:0'`）。
`torch.Tensor.to(device)`	Mueve el tensor al dispositivo especificado.
`torch.get_device_module(device_type)`	Obtiene el módulo del dispositivo (por ejemplo, cuda, mps).

Computación paralela

Función	Descripción
`torch.get_num_threads()`	Obtiene el número total de hilos para operaciones de CPU.
`torch.set_num_threads(int)`	Establece el número de hilos para operaciones de CPU.
`torch.get_num_interop_threads()`	Obtiene el número de hilos paralelos inter-operación (inter-op).
`torch.set_num_interop_threads(int)`	Establece el número de hilos paralelos inter-operación (inter-op).

Funciones de utilidad

Función	Descripción
`torch.compiled_with_cxx11_abi()`	Comprueba si está compilado con ABI de C++11.
`torch.result_type(tensor, other)`	Devuelve el dtype del resultado de la operación.
`torch.can_cast(from_dtype, to_dtype)`	Comprueba si se puede convertir el tipo de datos.
`torch.promote_types(type1, type2)`	Devuelve el tipo de datos promovido.
`torch.use_deterministic_algorithms(mode, warn_only)`	Habilita/deshabilita algoritmos deterministas.
`torch.are_deterministic_algorithms_enabled()`	Comprueba si los algoritmos deterministas están habilitados.
`torch.is_deterministic_algorithms_warn_only_enabled()`	Comprueba si el algoritmo determinista está en modo de advertencia.
`torch.set_deterministic_debug_mode(debug_mode)`	Establece el modo de depuración determinista.
`torch.get_deterministic_debug_mode()`	Obtiene el modo de depuración determinista.
`torch.set_float32_matmul_precision(precision)`	Establece la precisión de la multiplicación de matrices float32.
`torch.get_float32_matmul_precision()`	Obtiene la precisión de la multiplicación de matrices float32.
`torch.set_warn_always(enabled)`	Establece si siempre se muestran advertencias.
`torch.is_warn_always_enabled()`	Comprueba si siempre se muestran advertencias.
`torch.vmap(fn, in_dims, out_dims, randomness, chunk_size)`	Mapeo vectorizado.
`torch._assert(condition, message)`	Verificación de aserción (uso interno).
`torch.typename(t)`	Devuelve la representación en cadena del tipo.

Optimización de compilación

Función	Descripción
`torch.compile(model, backend, options, dynamic)`	Compila el modelo de PyTorch para optimización.

Ejemplos

import torch

# Crear un tensor
x = torch.tensor([1, 2, 3])
y = torch.zeros(2, 3)

# Operaciones matemáticas
z = torch.add(x, 1) # Sumar 1 elemento a elemento
print(z)

# Indexación y segmentación (slicing)
mask = x > 1
selected = torch.masked_select(x, mask)
print(selected)

# Gestión de dispositivos
if torch.cuda.is_available():
device = torch.device('cuda')
x = x.to(device)
print(x.device)

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

# Cálculo de gradientes
x = torch.tensor([1., 2., 3.], requires_grad=True)
y = x.sum()
y.backward()
print(x.grad)

Resultado de salida:

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

Si se necesita información más detallada, se puede consultarDocumentación oficial de PyTorch。

Otras extensiones