Pytorch: RuntimeError : erreur d'exécution cuda (2) : mémoire insuffisante dans /data/users/soumith/miniconda2/conda-bld/pytorch-0.1.9_1487346124464/work/torch/lib/THC/generic/THCStorage.cu:66

Vous manquez de mémoire sur le GPU. Ce n'est pas un bogue.

@apaszke
Je viens d'écrire un code de test simple comme suit, et il se produit l'erreur 'mémoire insuffisante .....', la dimension des données d'entrée de test est 49200.
mais quand j'ai essayé une dimension de données inférieure de 49200 à 1000, le code fonctionne correctement.
Existe-t-il une configuration de paramètres dans pytorch que je dois modifier?

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.dropout = nn.Dropout(p=0.2)
        self.relu = nn.ReLU()
        self.fc1 = nn.Linear(49200, 49200)
        self.fc2 = nn.Linear(49200, 49200)
        self.fc3 = nn.Linear(49200, 3)
        self.out = nn.Sequential(
            self.fc1,
            self.relu,
            self.dropout,
            self.fc1,
            self.relu,
            self.dropout,
            self.fc3
            )
    def forward(self, premise, hypothesis):
        return self.out(torch.cat([premise, hypothesis], 1))

net = Net().cuda()
print (net)
premise = Variable(torch.randn(64, 82, 300))
hypothesis = Variable(torch.randn(64, 82, 300))
premise = premise.cuda()
hypothesis = hypothesis.cuda()
out = net(premise.contiguous().view(64,-1), hypothesis.contiguous().view(64,-1))
print(out)

Entre les paramètres et leurs gradients des deux grosses couches FC, votre réseau (de taille 49200) nécessite 40Go de mémoire...

@jekbradbury Pouvez-vous expliquer vos calculs ? combien de mémoire prend chaque calque en ce qui concerne les paramètres et les dégradés ? Merci.

Si vous ne considérez que les poids d'une seule couche linéaire de ce modèle. Vous obtenez

49200^2 = 2 420 640 000

éléments + chaque élément prend 4 octets, ce qui vous donne

2 420 640 000 * 4 / 1024^3 = 9,01GB

pour les poids seuls. Ensuite, vous avez besoin d'un autre morceau de mémoire de cette taille pour stocker les dégradés. Vous devez également enregistrer les résultats intermédiaires afin de pouvoir calculer le gradient.

Salut, j'ai la même erreur mais elle ne vient que pour la validation. L'ensemble du processus de formation a parfaitement fonctionné. J'essaie de faire un apprentissage par transfert en utilisant inception v3. Est-ce que quelqu'un peut m'aider s'il vous plaît ? Merci

@tabibusairam J'ai également rencontré le même problème : le processus de formation a bien fonctionné (avec une mémoire cuda 6G et mon GPU a une mémoire 12G) mais le processus d'évaluation qui passe par le même réseau a reçu une information d'erreur comme suit :

THCudaCheck FAIL file=/opt/conda/conda-bld/pytorch_1503965122592/work/torch/lib/THC/generic/THCStorage.cu line=66 error=2 : out of memory
Traceback (most recent call last):
  File "evaluate.py", line 132, in <module>
    evaluate(pnet, args)
  File "evaluate.py", line 94, in evaluate
    predictions = pnet(X_test, initial_states)
  File "/home/zcrwind/.conda/envs/condapython3.6/lib/python3.6/site-packages/torch/nn/modules/module.py", line 224, in __call__
    result = self.forward(*input, **kwargs)
  File "/home/zcrwind/workspace/pro/predict/zcr/pnet.py", line 497, in forward
    output, hidden_states = self.step(A0, hidden_states)
  File "/home/zcrwind/workspace/pro/predict/zcr/pnet.py", line 377, in step
    forget_gate = hard_sigmoid(self.conv_layers['f'][lay](inputs))
  File "/home/zcrwind/workspace/pro/predict/zcr/pnet.py", line 28, in hard_sigmoid
    x = F.threshold(-x, 0, 0)
  File "/home/zcrwind/.conda/envs/condapython3.6/lib/python3.6/site-packages/torch/nn/functional.py", line 459, in threshold
    return _functions.thnn.Threshold.apply(input, threshold, value, inplace)
  File "/home/zcrwind/.conda/envs/condapython3.6/lib/python3.6/site-packages/torch/nn/_functions/thnn/auto.py", line 174, in forward
    getattr(ctx._backend, update_output.name)(ctx._backend.library_state, input, output, *args)
RuntimeError: cuda runtime error (2) : out of memory at /opt/conda/conda-bld/pytorch_1503965122592/work/torch/lib/THC/generic/THCStorage.cu:66

Avez-vous travaillé? Merci.

Le graphe de calcul tandis que la validation est différente comme dans le train comme le
les paramètres ne sont pas formés à la validation. Essayez d'utiliser la commande -
nvidia-smi pour voir les besoins en mémoire GPU lors de la validation.

Essayez de réduire la taille du lot (si vous ne travaillez que sur un seul GPU), le
la mémoire requise est moindre pour les petites tailles de lot.

Le dimanche 14 janvier 2018 à 11h17, Chenrui Zhang [email protected]
a écrit:

@tabibusairam https://github.com/tabibusairam J'ai aussi rencontré le
même problème: le processus de formation a bien fonctionné (avec la mémoire cuda 6G et mon
GPU a 12G de mémoire) mais le processus d'évaluation qui passe par le même
réseau a reçu une information d'erreur comme suit :

THCudaCheck FAIL file=/opt/conda/conda-bld/pytorch_1503965122592/work/torch/lib/THC/generic/THCStorage.cu line=66 error=2 : mémoire insuffisante
Traceback (dernier appel le plus récent) :
Fichier "evaluate.py", ligne 132, dans
évaluer (prednet, args)
Fichier "evaluate.py", ligne 94, dans evaluation
prédictions = prednet(X_test, initial_states)
Fichier "/home/zcrwind/.conda/envs/condapython3.6/lib/python3.6/site-packages/torch/nn/modules/module.py", ligne 224, dans __call__
result = self.forward( input, * kwargs)
Fichier "/home/zcrwind/workspace/ijcai2018/predict/zcrPredNet/prednet.py", ligne 497, en avant
sortie, états_cachés = self.step(A0, états_cachés)
Fichier "/home/zcrwind/workspace/ijcai2018/predict/zcrPredNet/prednet.py", ligne 377, à l'étape
forget_gate = hard_sigmoid(self.conv_layers['f'][lay](inputs))
Fichier "/home/zcrwind/workspace/ijcai2018/predict/zcrPredNet/prednet.py", ligne 28, dans hard_sigmoid
x = F.seuil(-x, 0, 0)
Fichier "/home/zcrwind/.conda/envs/condapython3.6/lib/python3.6/site-packages/torch/nn/functional.py", ligne 459, dans le seuil
return _functions.thnn.Threshold.apply(input, threshold, value, inplace)
Fichier "/home/zcrwind/.conda/envs/condapython3.6/lib/python3.6/site-packages/torch/nn/_functions/thnn/auto.py", ligne 174, en avant
getattr(ctx._backend, update_output.name)(ctx._backend.library_state, entrée, sortie, *args)
RuntimeError : erreur d'exécution cuda (2) : mémoire insuffisante sur /opt/conda/conda-bld/pytorch_1503965122592/work/torch/lib/THC/generic/THCStorage.cu:66

Avez-vous travaillé? Merci.

—
Vous recevez ceci parce que vous avez été mentionné.
Répondez directement à cet e-mail, consultez-le sur GitHub
https://github.com/pytorch/pytorch/issues/958#issuecomment-357490369 ,
ou couper le fil
https://github.com/notifications/unsubscribe-auth/AMHzdCQ_jJ9ogDm1jaNSLB6wCbfP08XOks5tKZT8gaJpZM4MW6we
.

@tabibusairam Merci beaucoup. J'ai réduit la taille du lot et le code d'évaluation fonctionne assez bien maintenant.

@tabibusairam Écrivez -vous votre code de transfert comme exemple dans pytorch.org? Si c'est le cas, j'ai une autre idée pour y remédier.

Oui, j'ai écrit le code dans ce format.
J'ai également ajouté nn.DataParallel au modèle
Toute autre idée est surement la bienvenue

Le 22 janvier 2018 à 5h32, "Tommeychang" [email protected] a écrit :

@tabibusairam https://github.com/tabibusairam Écrivez-vous votre
transférer le code penché comme exemple dans le pytorch.org? Si oui, j'ai
une autre idée pour y remédier.

—
Vous recevez ceci parce que vous avez été mentionné.
Répondez directement à cet e-mail, consultez-le sur GitHub
https://github.com/pytorch/pytorch/issues/958#issuecomment-359294050 ,
ou couper le fil
https://github.com/notifications/unsubscribe-auth/AMHzdN8mRJKNr_0czrXDd-p66-iJImubks5tM9AggaJpZM4MW6we
.

@tabibusairam La même erreur m'est survenue dans la même situation. Il a été résolu en changeant "volatile" dans Variable() lors de l'inférence. Si nous définissons volatile=True, le graphe de calcul sera conservé pendant l'inférence. En temps d'inférence, nous n'avons pas besoin de conserver les graphes de calcul. C'est très gourmand en mémoire.
Vous pouvez simplement définir les drapeaux de volatile sur True comme ceci, `Variable(x, volatile=True).

Dans l'exemple, deux modèles seront générés respectivement pour la formation et la validation. Avec ce paramètre, un autre modèle sera exécuté dans le GPU lors de la validation, et le GPU manquera de mémoire même si vous enveloppez les données de validation avec un paramètre volatil.
Je résous ce problème en ne définissant qu'un seul modèle et en enveloppant les données de validation avec un paramètre volatil pour réduire le calcul. @tabibusairam

Merci, @TommeyChang. J'ai vérifié l'échantillon d'apprentissage par transfert, mais je n'ai pas compris où le modèle est également défini dans la validation. Pourriez-vous nous montrer où le modèle est défini dans le code ?

Ce problème peut être causé par le pytorch et non par le code. Les codes sont comme ci-dessous :
si phase == 'train' :
planificateur.step()
model.train(True) # Mettre le modèle en mode d'entraînement
autre:
model.train(False) # Définir le modèle pour évaluer le mode
Si vous tracez la statistique du GPU avec watch -n 1 -d nvidia-smi, vous verrez que l'utilisation de la mémoire augmentera lors de la première période de validation.

Comment avez-vous sélectionné le même modèle pour la validation à la fois pour le train et la validation ?

Le 27 janvier 2018 à 11h44, "Tommeychang" [email protected] a écrit :

Ce problème peut être causé par le pytorch et non par le code. Les codes sont comme
au dessous de:
si phase == 'train' :
planificateur.step()
model.train(True) # Mettre le modèle en mode d'entraînement
autre:
model.train(False) # Définir le modèle pour évaluer le mode
Si vous tracez la statistique GPU avec watch -n 1 -d nvidia-smi, vous verrez le
l'utilisation de la mémoire augmentera lors de la première période de validation.

—
Vous recevez ceci parce que vous avez été mentionné.
Répondez directement à cet e-mail, consultez-le sur GitHub
https://github.com/pytorch/pytorch/issues/958#issuecomment-360963591 ,
ou couper le fil
https://github.com/notifications/unsubscribe-auth/AMHzdBKY_UCQ3QMtnUhdHoahxUx-oG4eks5tOr6ugaJpZM4MW6we
.

Si nous ne définissons pas le mode du modèle, ce sera le mode d'entraînement implicite. Donc, nous n'avons pas besoin des lignes de mode set, mais encapsulons le tenseur dans une variable avec un paramètre volatil lors de la phase de validation. Mes codes sont comme ci-dessous:

if phase == 'train':
scheduler.step()

........

for data in dataloaders[phase]:  ## Iterate over data.

inputs, labels = data  ## get the inputs

if use_gpu:  ## pass them into GPU
inputs = inputs.cuda()
labels = labels.cuda()

if phase == 'train':  ## wrap them in Variable
inputs, labels = Variable(inputs), Variable(labels)
else:
inputs = Variable(inputs, volatile=True)
labels = Variable(labels, volatile=True)

Merci. Mais je crains que si nous ne définissons pas l'indicateur de train sur False même pendant la validation, nous ne puissions pas obtenir de résultats appropriés car BatchNormalization et Dropout se comportent différemment dans la phase de train/validation.

Oui je suis d'accord avec toi. Et j'ai testé mon modèle avec train flag False, les performances s'améliorent. Merci pour vos conseils.

J'ai essayé volatile=True et ça marche pour moi. Merci de m'avoir appris ça @jekbradbury

@TommeyChang @tabibusairam Je rencontre la même erreur, mais dans un cas différent. J'ajoute un nouveau terme de régularisation dans mon modèle, via cette fonction :

def l2_reg(mdl):
        l2_reg = None
        for W in mdl.parameters():
                if W.ndimension() < 2:
                        continue
                else:   
                        if l2_reg is None:
                                l2_reg = (torch.max(torch.abs(W)))**2
                        else:   
                                l2_reg = l2_reg + (torch.max(torch.abs(W)))**2

        return l2_reg

Ce que j'observe, c'est que même si je change la taille de mon lot de 128 à 8, l'erreur survient juste après la 1ère époque, et si je change simplement la régularisation et renvoie une régularisation l2. Je ne comprends pas cette erreur.
Toute suggestion/commentaire serait vraiment apprécié !

@TommeyChang vous voulez généralement différencier le terme de régularisation (après tout, il est là pour affecter la valeur du gradient) donc je ne veux probablement pas le faire comme vous l'avez suggéré

@apaszke bonjour ~ J'ai la même question, mais je peux former le modèle correctement au début. Après peut-être 600 étapes, j'ai eu l'erreur "RuntimeError: cuda runtime error (2) : out of memory at /opt/conda/conda-bld/pytorch_1518243271935/work/torch/lib/THC/generic/THCStorage.cu:58" .

Pendant l'entraînement, la mémoire ne coûte que 7G (mon GPU a 11G). Normalement, à mon avis, s'entraîner correctement au début signifie que mon code est correct. Est-ce correct? Y a-t-il d'autres choses accumulées par le processus de formation vers l'avant ? Merci beaucoup!!

Certaines variables s'accumulent et prennent de plus en plus d'espace en tant que modèle
trains plus loin .. essayez de trouver cette variable et voyez que vous n'économisez pas
tous les indésirables

Le samedi 21 avril 2018 à 7 h 35, EricKani [email protected] a écrit :

@apaszke https://github.com/apaszke bonjour ~ J'ai la même question, mais
Je peux former le modèle correctement au début. Après peut-être 600 étapes, j'ai
a obtenu l'erreur "RuntimeError: erreur d'exécution cuda (2) : mémoire insuffisante à
/opt/conda/conda-bld/pytorch_1518243271935/work/torch/lib/THC/generic/THCStorage.cu:58
".

—
Vous recevez ceci parce que vous avez été mentionné.
Répondez directement à cet e-mail, consultez-le sur GitHub
https://github.com/pytorch/pytorch/issues/958#issuecomment-383259455 ,
ou couper le fil
https://github.com/notifications/unsubscribe-auth/AMHzdN8KuyZIjewB6gkY1MvswGWuF1QMks5tqpPegaJpZM4MW6we
.

@tabibusairam Merci beaucoup, tout d'abord. C'est l'une des principales raisons de nombreux problèmes d'oom. Mais je n'ai pas trouvé le problème de mon réseau. Lorsque je forme mon réseau sans validation (réseau de transformation d'image), la mémoire du GPU est stable tout le temps. Mais lorsqu'il y a une étape de validation, la mémoire de mon premier GPU (validation sur ce GPU) augmentera deux fois.
Par exemple, au début de ma première époque, ma mémoire Gpu consomme 7G, puis passe à 9G après la première époque avec le début de validation. Après validation à la deuxième époque, la consommation de mémoire devient 10G. Depuis, la mémoire se stabilise. Je suis très confus...

Exécutez-vous la validation avec des variables volatile (en 0.3) ou dans un contexte torch.no_grad (si vous utilisez le maître) ?

@apaszke @tabibusairam bonjour, je trouve cette erreur lorsque j'utilise pytorch pour construire GAN avec GP, et je suis bloqué ici depuis 2 jours, j'ai déjà essayé plusieurs méthodes pour résoudre ce problème, mais aucune ne fonctionne. J'ai vraiment besoin d'aide svp.
l'erreur est :
_RuntimeError : erreur d'exécution cuda (2) : mémoire insuffisante à xx\torch\lib\thc\generic/THCStorage.cu:66_
quand je fais marche arrière

_Fichier "xxx/train_extractor.py", ligne 128, dans
gradient_penalty.backward()
Fichier "xxx\lib\site-packages\torch\autograd\variable.py", ligne 156, à l'envers
torche.autograd.backward (soi, gradient, conserver_graphe, créer_graphe, conserver_variables)
Fichier "xxx\lib\site-packages\torch\autograd__init__.py", ligne 98, à l'envers
variables, grad_variables, retention_graph)_

Cela se produit à la 12ème époque de mon processus de formation à chaque fois, et j'ai déjà réduit le batch_size et la taille dans mes filets.
Il n'y a pas de procédure de validation.
voici une petite partie de mon code :
alpha = torche.rand(conf.batch_size,1).expand(X.size())
x_hat = autograd.Variable(alpha real.data.cpu()+(1-alpha) (real.data.cpu()+0.5 real.data.std() torch.rand(real.size())),requires_grad = Vrai)
x_hat = x_hat.cuda() si conf.cuda sinon x_hat
pred_hat,_ = Dis(x_hat)
étiquette = torch.ones(pred_hat.size())
label = label.cuda() si conf.cuda sinon label
dégradés = autograd.grad (sorties = pred_hat, entrées = x_hat, grad_outputs = étiquette, create_graph = True, retention_graph = True, only_inputs = True) [0]
gradient_penalty = conf.gp_lambda ((gradients.norm(2,dim=1)-1) 2).mean()* gradient_penalty.backward()

Réduire la taille du lot de 64 à 32 a fonctionné pour moi.

@lyakaap Variable(x, volatile=True). C'est du travail pour moi. Merci beaucoup.

@EricKani ,
bonjour, avez-vous resolu ce probleme?
Je reçois également la même question.
pouvez-vous m'indiquer la méthode ?

@ qlwang25 @EricKani La situation la plus probable est que des gradients sont accumulés par inadvertance lors du calcul des pertes comme ci-dessous.

loss = criterion(y_, y)
loss.backward()
loss_meter += loss  # incorrect
# loss_meter += loss.item()  # correct

@lyakaap
Merci beaucoup, tout d'abord.
J'écris la même chose que vous avez mentionné.
Après chaque batch de validation, la consommation mémoire du GPU augmente, donc le prochain train sera erreur :

THCudaCheck FAIL file=/pytorch/aten/src/THC/generic/THCStorage.cu line=58 error=2 : out of memory
Traceback (most recent call last):
  File "train.py", line 290, in <module>
    main()
  File "train.py", line 263, in main
    train(i)
  File "train.py", line 152, in train
    loss, num_total, num_correct = model.train_model(src, src_len, src_sent_len, tgt, tgt_len, optim)
  File "/home/wangqianlong/model/bytecup/models/seq2seq.py", line 110, in train_model
    loss.backward()
  File "/home/wangqianlong/.local/lib/python3.6/site-packages/torch/tensor.py", line 93, in backward
    torch.autograd.backward(self, gradient, retain_graph, create_graph)
  File "/home/wangqianlong/.local/lib/python3.6/site-packages/torch/autograd/__init__.py", line 89, in backward
    allow_unreachable=True)  # allow_unreachable flag
RuntimeError: cuda runtime error (2) : out of memory at /pytorch/aten/src/THC/generic/THCStorage.cu:58

Flux général de code :

def train_model(self, data):
    outputs = self(data)
    loss = self.criterion(outputs, y)
    loss.backward()
    optim.step()
    return loss

def sample(self, data):
    src, src_len = data
        with torch.no_grad():
                bos = torch.ones(src.size(0)).long().fill_(dict.BOS)
        if self.use_cuda:
            src = src.cuda()
            src_len = src_len.cuda()
            bos = bos.cuda()

        contexts = other_function(src, src_len)
            samples = self.decoder.sample([bos], contexts)
            return samples

def train(i):
    model.train()
    global train_dataloader
    for data in train_dataloader:
        model.zero_grad()
        loss = model.train_model(data)

        count_loss += loss.item()
        if ...:
            # not important
            print(count_loss)

def eval(i):
    model.eval()
    for batch in eval_dataloader:
        samples = model.sample(data)
        print(samples)

def main():
    global train_dataloader
    for i in range(epoch):
        train_dataloader = load(data_(i%9)) 
        train(i)

        eval(i)

La rame est relativement grande, je l'ai divisée en huit (data_0, data_1, ...., data_8)
Peut-tu me faire des suggestions ?
Merci beaucoup.

@ qlwang25 J'ai vérifié votre code mais je n'ai pas trouvé quelle était la pièce qui ne va pas.
J'imagine deux possibilités :

1. utilisez optimiser.zero_grad() à la place model.zero_grad()
2. certaines variables dans gpu ont une référence persistante et donc ces variables ne libèrent jamais la mémoire gpu. Que diriez-vous de revoir votre sample().

@lyakaap
Tout d'abord merci pour votre réponse si rapide.
Je peux comprendre votre premier point.
Cependant, ces variables ne libèrent jamais la mémoire GPU me rend confus.
quelle variable ? Pouvez-vous donner un exemple?
Comment libérer ces variables. torch.cuda.empty_cache() est utile ?

@ qlwang25
Je n'ai aucune idée de quelles variables, mais src, bos, sont probables.
AFAIK, torch.cuda.empty_cache() ne libère pas les variables référencées. Vous devez localiser les variables qui sont les causes et écrire del {var_name} avant d'appeler cette fonction.

@lyakaap
Merci beaucoup!
Je connais déjà votre suggestion.
Merci encore pour votre réponse.

@ladyrick
Merci beaucoup!
Je connais déjà votre suggestion.
Merci encore pour votre réponse.

Je pense que tu veux dire @lyakaap , non ?
haha

J'ai essayé volatile - n'a pas fonctionné (plus tard, j'ai compris que c'était parce que j'étais dans pytroch 1.01 et "UserWarning: volatile a été supprimé et n'a plus d'effet. Utilisez with torch.no_grad(): la place.")
Mais un simple redémarrage a également réglé les choses pour moi...

J'ai eu le même problème, j'ai donc essayé de réduire la taille du lot au minimum, car mon modèle était capable de s'entraîner. de plus, vous pouvez augmenter votre époque, votre taux d'apprentissage, votre échantillon d'entraînement pour maintenir le compromis en termes de précision

Ce problème peut être causé par la taille énorme de l'ensemble de données de validation, vous pouvez sélectionner un petit ensemble de données, puis tester en entrée l'énorme ensemble de données.

Le graphe de calcul pendant la validation est différent comme dans le train car les paramètres ne sont pas formés à la validation. Essayez d'utiliser la commande - nvidia-smi pour voir les besoins en mémoire GPU lors de la validation. Essayez de réduire la taille du lot (si vous ne travaillez que sur un seul processeur graphique), les besoins en mémoire sont moindres pour les petites tailles de lot.
…
Le dimanche 14 janvier 2018 à 11 h 17, Chenrui Zhang @ . * > a écrit : @tabibusairam https://github.com/tabibusairam J'ai également rencontré le même problème : le processus de formation a bien fonctionné (avec une mémoire cuda 6G et mon GPU a une mémoire 12G) mais le processus d'évaluation qui passe par le même réseau a obtenu une information d'erreur comme suit : THCudaCheck FAIL file=/opt/conda/conda-bld/pytorch_1503965122592/work/torch/lib/THC/generic/THCStorage.cu line=66 error=2 : out of memory Traceback (dernier appel le plus récent ): Fichier "evaluate.py", ligne 132, dansévalue(prednet, args) Fichier "evaluate.py", ligne 94, dans les prédictions d'évaluation = prednet(X_test, initial_states) Fichier "/home/zcrwind/.conda/envs/condapython3.6/lib/python3.6/site- packages/torch/nn/modules/module.py", ligne 224, dans __call__ result = self.forward( input, * kwargs) File "/home/zcrwind/workspace/ijcai2018/predict/zcrPredNet/prednet.py", ligne 497, en sortie directe, hidden_states = self.step(A0, hidden_states) Fichier "/home/zcrwind/workspace/ijcai2018/predict/zcrPredNet/prednet.py", ligne 377, à l'étape forget_gate = hard_sigmoid(self.conv_layers[' f'][lay](inputs)) File "/home/zcrwind/workspace/ijcai2018/predict/zcrPredNet/prednet.py", ligne 28, in hard_sigmoid x = F.threshold(-x, 0, 0) File " /home/zcrwind/.conda/envs/condapython3.6/lib/python3.6/site-packages/torch/nn/functional.py", ligne 459, dans le seuil return _functions.thnn.Threshold.apply(input, threshold , valeur, inplace) Fichier "/home/zcrwind/.conda/envs/condapython3.6/lib/python3.6/site-packages/torch/nn/_functions/thnn/auto. py", ligne 174, en avant getattr(ctx._backend, update_output.name)(ctx._backend.library_state, input, output, *args) RuntimeError : erreur d'exécution cuda (2) : mémoire insuffisante à /opt/conda/ conda-bld/pytorch_1503965122592/work/torch/lib/THC/generic/THCStorage.cu:66 Avez-vous fait de l'exercice ? Merci. — Vous recevez ceci parce que vous avez été mentionné. Répondez directement à cet e-mail, consultez-le sur GitHub < #958 (commentaire) > ou désactivez le fil https://github.com/notifications/unsubscribe-auth/AMHzdCQ_jJ9ogDm1jaNSLB6wCbfP08XOks5tKZT8gaJpZM4MW6we .

Cela a fonctionné. Merci beaucoup.