Précision mixte automatique
torch.amp fournit des méthodes pratiques pour une précision mixte, où certaines opérations utilisent le type de données torch.float32 (float), tandis que d'autres utilisent un type de données float de précision inférieure (lower_precision_fp) : torch.float16 (half) ou torch .bfloat16. Certaines opérations, comme les couches linéaires et les convolutions, sont beaucoup plus rapides dans lower_precision_fp. D'autres opérations, comme la réduction d'échelle, nécessitent souvent la plage dynamique de float32. La précision mixte essaie de faire correspondre chaque opération à son type de données approprié.
En règle générale, "Automatic Mixed Precision Training" avec le type de données torch.float16 utilise torch.autocast et torch.cuda.amp.GradScaler ensemble. Et torch.autocast et torch.cuda.amp.GradScaler sont modulaires et peuvent être utilisés séparément si nécessaire.
Pour CUDA et CPU, l'API est également fournie séparément :
torch.autocast("cuda", args...) est équivalent à torch.cuda.amp.autocast(args...) .
torch.autocast("cpu", args...) est équivalent à torch.cpu.amp.autocast(args...) . Pour le CPU, seul le type de données à virgule flottante de précision inférieure de torch.bfloat16 est actuellement pris en charge.
Conversion automatique (diffusion automatique)
torch.autocast( device_type , dtype=None , enabled=True , cache_enabled=None )
Paramètres :
device_type (str, obligatoire) - utilisez 'cuda' ou 'cpu' périphérique
activé (bool, facultatif) - s'il faut activer la diffusion automatique dans la zone. Par défaut : True
dtype (torch_dtype, facultatif) – Que ce soit pour utiliser torch.float16 ou torch.bfloat16.
cache_enabled (bool, facultatif) - Indique s'il faut activer la mise en cache du poids interne de la diffusion automatique. Par défaut : Vrai
autocast peut être utilisé comme gestionnaire de contexte ou décorateur, permettant aux étendues de script de s'exécuter avec une précision variable.
Dans ces régions, les opérations de données sont exécutées sur le dtype choisi par autocast qui est spécifique à cette opération, pour améliorer les performances tout en maintenant la précision.
Les tenseurs peuvent être de n'importe quel type lorsqu'ils entrent dans une région activée pour la diffusion automatique. Lorsque vous utilisez la diffusion automatique, vous ne devez pas appeler half() ou bfloat16() sur le modèle ou l'entrée. la diffusion automatique ne doit envelopper que la passe directe du réseau, y compris le calcul de la perte. Le backpassing sous autocast n'est pas recommandé. Les opérations en arrière prennent le même type d'exécution que la diffusion automatique utilise pour les opérations en avant correspondantes.
Exemple CUDA :
# Creates model and optimizer in default precision
model = Net().cuda()
optimizer = optim.SGD(model.parameters(), ...)
for input, target in data:
optimizer.zero_grad()
# Enables autocasting for the forward pass (model + loss)
with autocast():
output = model(input)
loss = loss_fn(output, target)
# Exits the context manager before backward()
loss.backward()
optimizer.step()
Le tenseur à virgule flottante résultant peut être float16 dans les régions où l'autoconversion est activée. Leur utilisation avec des tenseurs à virgule flottante de différents dtypes peut entraîner des erreurs de non-concordance de type après le retour dans une région où la conversion automatique est désactivée. Si c'est le cas, reconvertissez le tenseur résultant dans la zone d'auto-conversion en float32 (ou autre dtype, si nécessaire). Si le tenseur de la région auto-convertie est déjà float32, la conversion est sans opération et n'entraîne aucune surcharge supplémentaire.
Exemple CUDA :
# Creates some tensors in default dtype (here assumed to be float32)
a_float32 = torch.rand((8, 8), device="cuda")
b_float32 = torch.rand((8, 8), device="cuda")
c_float32 = torch.rand((8, 8), device="cuda")
d_float32 = torch.rand((8, 8), device="cuda")
with autocast():
# torch.mm is on autocast's list of ops that should run in float16.
# Inputs are float32, but the op runs in float16 and produces float16 output.
# No manual casts are required.
e_float16 = torch.mm(a_float32, b_float32)
# Also handles mixed input types
f_float16 = torch.mm(d_float32, e_float16)
# After exiting autocast, calls f_float16.float() to use with d_float32
g_float32 = torch.mm(d_float32, f_float16.float())
Exemple de formation CPU :
# Creates model and optimizer in default precision
model = Net()
optimizer = optim.SGD(model.parameters(), ...)
for epoch in epochs:
for input, target in data:
optimizer.zero_grad()
# Runs the forward pass with autocasting.
with torch.autocast(device_type="cpu", dtype=torch.bfloat16):
output = model(input)
loss = loss_fn(output, target)
loss.backward()
optimizer.step()
Exemple d'inférence CPU :
# Creates model in default precision
model = Net().eval()
with torch.autocast(device_type="cpu", dtype=torch.bfloat16):
for input in data:
# Runs the forward pass with autocasting.
output = model(input)
Exemple d'inférence de CPU utilisant jit trace :
class TestModel(nn.Module):
def __init__(self, input_size, num_classes):
super().__init__()
self.fc1 = nn.Linear(input_size, num_classes)
def forward(self, x):
return self.fc1(x)
input_size = 2
num_classes = 2
model = TestModel(input_size, num_classes).eval()
# For now, we suggest to disable the Jit Autocast Pass,
# As the issue: https://github.com/pytorch/pytorch/issues/75956
torch._C._jit_set_autocast_mode(False)
with torch.cpu.amp.autocast(cache_enabled=False):
model = torch.jit.trace(model, torch.randn(1, input_size))
model = torch.jit.freeze(model)
# Models Run
for _ in range(3):
model(torch.randn(1, input_size))
Les sous-régions autocast(enabled=False) peuvent être imbriquées dans des régions activées pour la diffusion automatique. La désactivation partielle de la diffusion automatique est utile lorsque vous forcez des sous-régions sur des types de données spécifiques. La désactivation de la diffusion automatique donne un contrôle explicite sur le type d'exécution. Dans les sous-régions, les entrées des régions environnantes doivent être converties dans le type de données spécifié avant d'être utilisées.
# 在默认数据类型（这里假设为float32）中创建一些张量
a_float32 = torch.rand((8, 8), device="cuda")
b_float32 = torch.rand((8, 8), device="cuda")
c_float32 = torch.rand((8, 8), device="cuda")
d_float32 = torch.rand((8, 8), device="cuda")
with autocast():
e_float16 = torch.mm(a_float32, b_float32)
with autocast(enabled=False):
# 调用e_float16.float()以确保使用float32执行
# （这是必需的，因为e_float16是在autocast区域中创建的）
f_float32 = torch.mm(c_float32, e_float16.float())
# 当重新进入启用autocast的区域时，无需手动转换类型。
# torch.mm仍然以float16运行并产生float16的输出，不受输入类型的影响。
g_float16 = torch.mm(d_float32, f_float32)
L'état de diffusion automatique est thread-local. Si vous souhaitez l'activer dans un nouveau thread, vous devez appeler le gestionnaire de contexte ou le décorateur dans ce thread.
torch.cuda.amp.autocast(enabled=True, dtype=torch.float16, cache_enabled=True)
torch.cuda.amp.autocast(args…)等同于torch.autocast(“cuda”, args…)
* torch.cuda.amp.custom_fwd(fwd=None, , cast_inputs=None)
Décorateur auxiliaire pour la méthode directe de la fonction autograd personnalisée (sous-classe de torch.autograd.Function).
Paramètres :
cast_inputs (torch.dtype ou None, facultatif, default=None) - Si ce n'est pas None, lors de l'exécution vers l'avant dans une région activée pour la diffusion automatique, convertissez le tenseur CUDA à virgule flottante entrant en type de données cible (les tenseurs à virgule non flottante sont non affecté), puis effectuez un transfert avec la diffusion automatique désactivée. Si aucun, les opérations internes de transfert seront effectuées en fonction de l'état d'autodiffusion actuel
Mise à l'échelle du dégradé
Si la passe avant d'un op a des entrées float16, la passe arrière de cet op produira des gradients float16. Les valeurs de gradient avec de petites amplitudes peuvent ne pas être représentables en tant que float16. Ces valeurs seront mises à zéro ("underflow"), donc les mises à jour des paramètres correspondants seront perdues.
Pour éviter le sous-dépassement, la "mise à l'échelle du gradient" fonctionne en multipliant la perte du réseau par un facteur de mise à l'échelle et en effectuant un retour en arrière sur la perte mise à l'échelle. Les gradients propagés à travers le réseau sont également mis à l'échelle par le même facteur. En d'autres termes, les valeurs de gradient ont de grandes amplitudes, elles ne sont donc pas mises à zéro.
Les dégradés (propriétés .grad) de chaque paramètre doivent être restaurés avant que l'optimiseur ne mette à jour les paramètres afin de garantir que le facteur d'échelle n'interfère pas avec le paramètre de taux d'apprentissage.
torch.cuda.amp.GradScaler(init_scale=65536.0, growth_factor=2.0, backoff_factor=0.5, growth_interval=2000, enabled=True)
get_backoff_factor() renvoie un flottant Python contenant le facteur d'attente de mise à l'échelle.
get_growth_factor() renvoie un flottant Python contenant le facteur de croissance de mise à l'échelle.
get_growth_interval() renvoie un entier Python contenant l'intervalle de croissance.
get_scale() renvoie un flottant Python contenant le facteur de mise à l'échelle actuel, ou 1,0 si la mise à l'échelle est désactivée.
**ATTENTION :** get_scale() générera une synchronisation CPU-GPU.
is_enabled() renvoie un booléen indiquant si cette instance est activée.
load_state_dict(state_dict) état du scaler de charge. Si cette instance est désactivée, load_state_dict() ne fait rien.
Paramètres : state_dict (dict) – état du scaler. Doit être l'objet renvoyé en appelant state_dict().
scale(outputs) met à l'échelle un tenseur ou une liste de tenseurs par un facteur d'échelle.
Renvoie la sortie mise à l'échelle. Renvoie une sortie non modifiée si l'instance de GradScaler n'est pas activée.
Paramètres : sorties (Tensor ou itérable de Tensors) – sorties à l'échelle.
set_backoff_factor(new_factor) Paramètres : new_factor (float) – valeur à utiliser comme nouveau facteur de mise à l'échelle de la temporisation.
set_growth_factor(new_factor) Paramètres : new_factor (float) – valeur à utiliser comme nouveau facteur de croissance de mise à l'échelle.
set_growth_interval(new_interval) Paramètres : new_interval (int) – valeur à utiliser comme nouvel intervalle de croissance.
state_dict() renvoie l'état du scaler sous forme de dictionnaire. Il contient cinq entrées :
"scale" - un flottant Python contenant l'échelle actuelle
"growth_factor" - un flottant Python contenant le facteur de croissance actuel
"backoff_factor" - un flottant Python contenant le facteur de backoff actuel
"growth_interval" - un entier Python contenant l'intervalle de croissance actuel
"_growth_tracker" - un entier Python contenant le nombre d'étapes non ignorées consécutives les plus récentes.
Renvoie un dictionnaire vide si cette instance n'est pas activée.
Remarque : Si vous souhaitez vérifier l'état du décompteur de points après une itération spécifique, vous devez appeler state_dict() après update().
étape(optimiseur, *args, **kwargs)
step() effectue les deux opérations suivantes :
1 appelle unscale_(optimizer) en interne (sauf si unscale_() a été explicitement appelé auparavant dans l'itération). Dans le cadre de unscale_(), il est vérifié si le dégradé contient inf/NaN.
2 Si aucun gradient inf/NaN n'est trouvé, l'optimizer.step() est appelé avec des gradients non mis à l'échelle. Sinon, optimiser.step() sera ignoré pour éviter de corrompre les paramètres.
*args et **kwargs seront transmis à l'optimizer.step().
Renvoie la valeur de retour de l'optimiseur.step(*args, **kwargs).
Paramètres : optimiseur (torch.optim.Optimizer) – l'optimiseur auquel appliquer les dégradés.
args – tous les arguments.
kwargs – Tous les arguments de mots-clés.
avertir
L'utilisation de la fermeture n'est actuellement pas prise en charge.
unscale_(optimizer) divise ("unscales") le tenseur de gradient de l'optimiseur par un facteur d'échelle.
unscale_() est facultatif et convient aux cas où les gradients sont modifiés ou inspectés entre la rétropropagation et l'étape ( step() ). Les dégradés seront automatiquement non mis à l'échelle lors d'une étape ( step() ) si unscale_() n'est pas appelé explicitement.
Exemple simple, utilisant unscale_() pour activer le découpage des dégradés non mis à l'échelle :
… scaler.scale(loss).backward() scaler.unscale_(optimizer) torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm) scaler.step(optimizer) scaler.update() Paramètres : optimiseur (torch. optim.Optimizer) - l'optimiseur avec des gradients à unscale.
Avis
unscale_() ne génère pas de synchronisation CPU-GPU.
avertir
Chaque appel à unscale_() doit être appelé exactement une fois par appel step() par optimiseur, et seulement après que tous les gradients ont été accumulés pour les paramètres assignés à cet optimiseur. Appeler unscale_() deux fois de suite pour un optimiseur donné entre chaque step() lèvera une RuntimeError.
avertir
unscale_() peut annuler l'échelle des dégradés clairsemés de manière irréversible, en remplaçant l'attribut .grad.
update(new_scale=None)[SOURCE] Mettre à jour le facteur d'échelle.
Si des étapes de l'optimiseur sont ignorées, il est réduit de backoff_factor multiplié par le facteur de mise à l'échelle. S'il y a des itérations growth_interval non ignorées dans une ligne, augmentez-la en multipliant growth_factor par le facteur de mise à l'échelle.
Passer new_scale définit manuellement la nouvelle valeur d'échelle. (new_scale n'est pas utilisé directement, mais est utilisé pour remplir le tenseur de mise à l'échelle interne de GradScaler. Par conséquent, si new_scale est un tenseur, les modifications sur place apportées à ce tenseur n'affecteront pas davantage l'échelle utilisée en interne par GradScaler.)
Paramètres : new_scale (float ou torch.cuda.FloatTensor, facultatif, par défaut Aucun) – nouveau facteur d'échelle.
avertir
update() ne doit être appelé qu'à la fin d'une itération où scaler.step(optimizer) a été appelé pour tous les optimiseurs utilisés.
Référence relative à Autocast Op
Admissibilité à l'opération de diffusion automatique
Que la diffusion automatique soit activée ou non, les opérations qui fonctionnent sur des types float64 ou non flottants ne sont pas diffusées automatiquement, elles seront exécutées sur le type d'origine. autocast n'affecte que les opérations hors place et les méthodes de tenseur. Les opérations et les appels sur place qui fournissent explicitement out=...tensor sont autorisés dans les régions activées pour la diffusion automatique, mais ils ne passeront pas la diffusion automatique. Par exemple, dans une région où la transition automatique est activée, a.addmm(b,c) peut être automatiquement converti, mais pas a.addmm_(b,c,out=d). Pour des performances et une stabilité optimales, préférez les opérations déplacées dans les régions où la diffusion automatique est activée. Les opérations qui appellent explicitement dtype=... ne sont pas éligibles pour l'utilisation de la diffusion automatique et généreront une sortie pour l'argument dtype.
Comportement spécifique à CUDA Op
La liste suivante décrit le comportement des opérations éligibles dans les régions où la transition automatique est activée. Ces opérations sont toujours converties automatiquement, qu'elles soient appelées dans le cadre d'un torch.nn.Module, d'une fonction ou d'une méthode torch.Tensor. Si des fonctions sont exposées dans plusieurs espaces de noms, elles sont automatiquement converties quel que soit l'espace de noms.
Les opérations non répertoriées ci-dessous ne sont pas automatiquement converties. Ils fonctionnent selon le type défini par leur entrée. Cependant, les conversions automatiques peuvent toujours modifier le type d'opérations exécutées par des opérations non répertoriées si elles sont en aval de l'opération convertie automatiquement.
Si une opération n'est pas répertoriée, nous supposons qu'elle est numériquement stable dans float16. Veuillez signaler un problème si vous pensez qu'une opération non répertoriée est numériquement instable dans float16.
CUDA Ops qui peut se convertir automatiquement en float16
matmul, addbmm, addmm, addmv, addr, baddbmm, bmm, chain_matmul, multi_dot, conv1d, conv2d, conv3d, conv_transpose1d, conv_transpose2d, conv_transpose3d, GRUCell, linéaire, LSTMCell, mat mul、mm、mv、prelu、RNNCell
CUDA Ops qui peut se convertir automatiquement en float32
pow、rdiv、rpow、rtruediv、acos、asin、binary_cross_entropy_with_logits、cosh、cosine_embedding_loss、cdist、cosine_similarity、cross_entropy、cumprod、cumsum、dist、erfinv、exp、expm1 、group_norm、hinge_embedding_loss、kl_div、l1_loss、layer_norm、log、log_softmax、 log10, log1p, log2, marge_ranking_loss, mse_loss, multilabel_margin_loss, multi_margin_loss, nll_loss, norme, normalize, pdist, poisson_nll_loss, pow, prod, réciproque, rsqrt, sinh, smooth_l1_ perte 、 soft_margin_loss 、 softmax 、 softmin 、 softplus 、 somme 、 renorm 、 tan 、 triplet_margin_loss
CUDA Ops qui peut booster la plus large gamme de types d'entrée
Ces opérations ne nécessitent pas de type de données spécifique pour la stabilité, mais nécessitent plusieurs entrées et nécessitent que les types de données des entrées correspondent. Si toutes les entrées sont float16, l'opération fonctionne dans float16. Si l'une des entrées est float32, autoconvert convertit toutes les entrées en float32 et exécute l'opération dans float32.
addcdiv, addcmul, atan2, bilinéaire, croisé, point, grille_échantillon, index_put, scatter_add, tensordot
Certaines opérations non répertoriées ici (par exemple, les opérations binaires telles que l'ajout) peuvent favoriser la saisie par elles-mêmes sans l'intervention de la conversion automatique. Si l'entrée est un mélange de bfloat16 et float32, ces opérations fonctionneront dans float32 et produiront une sortie float32, que la conversion automatique soit activée ou non.
Préférez binary_cross_entropy_with_logits à binary_cross_entropy
La rétropropagation de torch.nn.functional.binary_cross_entropy() (et torch.nn.BCEloss qui l'enveloppe) peut produire des gradients qui ne peuvent pas être représentés dans float16. Dans les régions où l'autoconversion est activée, l'entrée directe peut être float16, ce qui signifie que les gradients pour la rétropropagation doivent être représentables dans float16 (la conversion automatique d'une entrée directe float16 en float32 est inutile car la conversion doit être inversée en rétropropagation). Par conséquent, binary_cross_entropy et BCELoss génèrent une erreur dans les régions où la transition automatique est activée.
De nombreux modèles utilisent une couche sigmoïde avant la couche d'entropie croisée binaire. Dans ce cas, utilisez torch.nn.functional.binary_cross_entropy_with_logits() ou torch.nn.BCEWithLogitsLoss pour combiner les deux couches. binary_cross_entropy_with_logits et BCEWithLogits peuvent être convertis automatiquement en toute sécurité.
Comportement spécifique à l'opération CPU
La liste suivante décrit le comportement des opérations éligibles dans les régions où la transition automatique est activée. Ces opérations sont toujours converties automatiquement, qu'elles soient appelées dans le cadre d'un torch.nn.Module, d'une fonction ou d'une méthode torch.Tensor. Si des fonctions sont exposées dans plusieurs espaces de noms, elles sont automatiquement converties quel que soit l'espace de noms.
Les opérations non répertoriées ci-dessous ne sont pas automatiquement converties. Ils fonctionnent selon le type défini par leur entrée. Cependant, les conversions automatiques peuvent toujours modifier le type d'opérations exécutées par des opérations non répertoriées si elles sont en aval de l'opération convertie automatiquement.
Si une opération n'est pas répertoriée, nous supposons qu'elle est numériquement stable dans bfloat16. Veuillez signaler un problème si vous pensez qu'une opération non répertoriée est numériquement instable dans bfloat16.
CPU Ops qui peuvent être automatiquement convertis en bfloat16
conv1d, conv2d, conv3d, bmm, mm, baddbmm, addmm, addbmm, linéaire, matmul, _convolution
CPU qui peuvent se convertir automatiquement en float32
Opérationsconv_transpose1d、conv_transpose2d、conv_transpose3d、avg_pool3d、binary_cross_entropy、grid_sampler、grid_sampler_2d、_grid_sampler_2d_cpu_fallback、grid_sampler_3d、polar、prod、quantile、nanquantile、 stft、cdist、trace、view_as_complex、cholesky、cholesky_inverse、cholesky_solve、inverse、lu_solve、orgqr、inverse、ormqr、 pinverse, max_pool3d, max_unpool2d, max_unpool3d, adaptive_avg_pool3d, reflection_pad1d, reflection_pad2d, replication_pad1d, replication_pad2d, replication_pad3d, mse_loss, ctc_loss, kl_div, multilabel_margin_loss, ff t_fft、fft_ifft、fft_fft2、fft_ifft2、fft_fftn、fft_ifftn、fft_rfft、fft_irfft、fft_rfft2、fft_irfft2、fft_rfftn、 fft_irfftn、fft_hfft、fft_ihfft、linalg_matrix_norm、linalg_cond、linalg_matrix_rank、linalg_solve、linalg_cholesky、linalg_svdvals、linalg_eigvals、linalg_eigvalsh、linalg_inv、lin alg_householder_product、linalg_tensorinv、linalg_tensorsolve、fake_quantize_per_tensor_affine、eig、geqrf、lstsq、_lu_with_info、qr、solve、svd、symeig、triangular_solve、fractional_max_pool2d、fractional_max_pool3d、adaptive_max_pool3d、multilabel_margin_loss_forward、linalg_qr 、linalg_cholesky_ex、linalg_svd、linalg_eig、linalg_eigh、linalg_lstsq、linalg_inv_ex
CPU Ops qui peut être boosté au type d'entrée le plus large
Ces opérations ne nécessitent pas de type de données spécifique pour la stabilité, mais nécessitent plusieurs entrées et nécessitent que les types de données des entrées correspondent. Si toutes les entrées sont bfloat16, l'opération fonctionne dans bfloat16. Si une entrée est float32, autoconvert convertit toutes les entrées en float32 et exécute l'opération dans float32.
chat、pile、index_copy
Certaines opérations non répertoriées ici (par exemple, les opérations binaires telles que l'ajout) peuvent favoriser la saisie par elles-mêmes sans l'intervention de la conversion automatique. Si l'entrée est un mélange de bfloat16 et float32, ces opérations fonctionneront dans float32 et produiront une sortie float32, que la conversion automatique soit activée ou non.
Supplément : Compréhension de inplace et out of inplace (comprendre en place pour comprendre)
inplace=True signifie effectuer une opération sur place et choisir d'effectuer une opération de couverture sur place. Par exemple, x+=1 consiste à opérer sur la valeur d'origine x, puis à écraser directement la valeur avec le résultat obtenu. y=x+5, x=y n'est pas une opération sur place sur x.
L'avantage de l'opération inplace=True est qu'elle peut économiser de la mémoire de calcul et enregistrer d'autres variables non pertinentes.
Remarque : Lorsque inplace=True est utilisé, le tenseur transmis depuis le réseau supérieur sera directement modifié pour modifier les données d'entrée. La signification spécifique est illustrée dans l'exemple suivant :
import torch
import torch.nn as nn
relu = nn.ReLU(inplace=True)
input = torch.randn(7)
print("输入数据：",input)
output = relu(input)
print("ReLU输出：", output)
print("ReLU处理后，输入数据：")
print(input)
torch.autograd.gradLa fonction est l'une des fonctions utilisées dans PyTorch pour calculer les gradients. Il est utilisé pour calculer le gradient d'une ou plusieurs fonctions scalaires par rapport à un ensemble de variables.
La signature de la fonction est la suivante :
mathematicaCopy code
torch.autograd.grad(outputs, inputs, grad_outputs=None, retain_graph=None, create_graph=False, only_inputs=True, allow_unused=False)
Description du paramètre :
outputs: Tenseur ou liste de tenseurs contenant des fonctions scalaires dont les gradients doivent être calculés.inputs: Tenseur ou liste de tenseurs de variables dont les gradients doivent être calculés.grad_outputs:outputsTenseur ou liste de tenseurs de même forme, utilisé pour spécifier le gradient extérieur lors du calcul du gradient. La valeur par défaut est Aucun, ce qui signifie utiliser un gradient d'unité (c'est-à-dire 1).retain_graph: valeur booléenne, spécifie s'il faut conserver le graphique de calcul pour les calculs suivants après le calcul du gradient. La valeur par défaut est Aucun, ce qui signifie qu'il juge automatiquement s'il faut conserver le graphique de calcul.create_graph: valeur booléenne, spécifiant s'il faut créer un nouveau graphe de calcul pour calculer les dérivées d'ordre supérieur. Le défaut est faux.only_inputs: booléen, spécifie s'il faut calculer uniquement le gradient de l'entrée. La valeur par défaut est True, ce qui signifie que seul le gradient de l'entrée est calculé.allow_unused: booléen spécifiant s'il faut autoriser les entrées inutilisées lors du calcul des gradients. La valeur par défaut est False, ce qui signifie que les entrées inutilisées ne sont pas autorisées.
La fonction renvoie un inputstenseur ou une liste de tenseurs de même forme que , représentant inputsle gradient par rapport à . Si aucun gradient n'est requis pour une entrée, le gradient pour la position correspondante sera Aucun.
Voici un exemple d'utilisation :
pythonCopy codeimport torch
x = torch.tensor([2.0], requires_grad=True)
y = x ** 2
grads = torch.autograd.grad(y, x)
print(grads) # 输出 [tensor([4.])]
Dans l'exemple ci-dessus, nous avons calculé le gradient y = x ** 2par rapport à xet torch.autograd.gradobtenu le résultat grâce à la fonction. Dans cet exemple, gradsune valeur de 4,0 signifie que le gradient yrelatif xà est de 4,0.