Error when switching to gpu for training

Mumak_Orrr: <p>Hi, I created a network and started training it without any noticeable errors. To go further and get better performance, I decided to switch to my GPU, and that’s when I got an error during training:</p>
<p>Traceback (most recent call last):</p>
<p>File ~\anaconda3\lib\site-packages\spyder_kernels\py3compat.py:356 in compat_exec<br>
exec(code, globals, locals)</p>
<p>File e:\documents\ia\cryptoboy\scripts\réseau de neurones\premier réseau propre 2.py:215<br>
predictions = cryptoboy(donnees)</p>
<p>File ~\anaconda3\lib\site-packages\torch\nn\modules\module.py:1519 in _wrapped_call_impl<br>
return self._call_impl(*args, **kwargs)</p>
<p>File ~\anaconda3\lib\site-packages\torch\nn\modules\module.py:1528 in _call_impl<br>
return forward_call(*args, **kwargs)</p>
<p>File e:\documents\ia\cryptoboy\scripts\réseau de neurones\premier réseau propre 2.py:135 in forward<br>
X11, _ = self.lstm1(x)</p>
<p>File ~\anaconda3\lib\site-packages\torch\nn\modules\module.py:1519 in _wrapped_call_impl<br>
return self._call_impl(*args, **kwargs)</p>
<p>File ~\anaconda3\lib\site-packages\torch\nn\modules\module.py:1528 in _call_impl<br>
return forward_call(*args, **kwargs)</p>
<p>File ~\anaconda3\lib\site-packages\torch\nn\modules\rnn.py:881 in forward<br>
result = _VF.lstm(input, hx, self._flat_weights, self.bias, self.num_layers,</p>
<p>RuntimeError: shape ‘[1792, 1]’ is invalid for input of size 17920</p>
<p>Here is my code:</p>
<p>import torch<br>
from torch.utils.data import Dataset, DataLoader<br>
import torch.nn as nn<br>
from torch.nn import functional as F<br>
import torch.optim as optim<br>
from torch.utils.data import DataLoader, TensorDataset<br>
from random import *<br>
from random import shuffle<br>
from random import sample<br>
import numpy as np<br>
import pandas as pd<br>
import math</p>
<p><span class="hashtag-raw">#Import</span> des données</p>
<p>MinaEURJour = “E:\Documents\IA\CryptoBoy\Data\MINA\MINAEUR_1440.csv”<br>
L=<span class="chcklst-box fa fa-square-o fa-fw"></span></p>
<p>with open(MinaEURJour) as f:<br>
for ligne in f:<br>
c=ligne.split(“,”)<br>
x=[float(item) for item in c]<br>
L.append(x)</p>
<h1><a name="gestion-et-cration-de-la-base-de-donne-1" class="anchor" href="#gestion-et-cration-de-la-base-de-donne-1"></a>Gestion et création de la base de donnée</h1>
<p>def Préparation_data(L,i):<br>
U=<span class="chcklst-box fa fa-square-o fa-fw"></span><br>
for k in range(0, len(L)-i, i):<br>
T=<span class="chcklst-box fa fa-square-o fa-fw"></span><br>
for n in range(i):<br>
T.append(L[k+n])<br>
U.append(T)<br>
return U</p>
<p>def Slice_liste(L, n):<br>
if n &lt;= 0:<br>
return “Le nombre de morceaux doit être supérieur à zéro.”</p>
<pre><code>longueur = len(L)
taille_morceau = longueur // n
morceaux = []

for i in range(n):
    debut = i * taille_morceau
    fin = (i + 1) * taille_morceau if i &lt; n - 1 else longueur
    morceaux.append(L[debut:fin])

return morceaux
</code></pre>
<p>def Recup_labels (L,n):<br>
U=<span class="chcklst-box fa fa-square-o fa-fw"></span><br>
for k in range(len(L)):<br>
T=<span class="chcklst-box fa fa-square-o fa-fw"></span><br>
for i in range(n):<br>
T.append(L[k][len(L[k])-n+i])<br>
U.append(T)<br>
return U</p>
<p>def Recup_datas (L,n):<br>
U=<span class="chcklst-box fa fa-square-o fa-fw"></span><br>
for k in range(len(L)):<br>
T=<span class="chcklst-box fa fa-square-o fa-fw"></span><br>
for i in range(n):<br>
T.append(L[k][i])<br>
U.append(T)<br>
return U</p>
<p>nb_entrees = 10<br>
nb_sorties = 3</p>
<p>D=Préparation_data(L,nb_entrees + nb_sorties) # Regroupe en liste les entrées et les sorties correspondantes</p>
<p>SD=sample(D,len(D)) # Mélange des données (pourrait être évité car possibilité de le faire dans le dataloader)</p>
<p>nb_partitions = 3<br>
Datasetbrut=Slice_liste(SD, nb_partitions) <span class="hashtag-raw">#Partitionne</span> le jeu de données en plusieurs morceau pour la validation et le test</p>
<h1><a name="cration-des-liste-de-donnees-et-de-labels-2" class="anchor" href="#cration-des-liste-de-donnees-et-de-labels-2"></a>Création des liste de donnees et de labels</h1>
<p>Data=Recup_datas(Datasetbrut[0], nb_entrees)<br>
Labels=Recup_labels(Datasetbrut[0], nb_sorties)</p>
<h1><a name="formatage-en-array-numpy-de-dimension-1-nb_entrees-7-et-1-nb_sorties-7-3" class="anchor" href="#formatage-en-array-numpy-de-dimension-1-nb_entrees-7-et-1-nb_sorties-7-3"></a>Formatage en array numpy de dimension [-1, nb_entrees, 7] et [-1, nb_sorties, 7]</h1>
<p>donnees = np.array(Data)<br>
labels = np.array(Labels)</p>
<h1><a name="suppression-des-colonnes-date-volume-et-nb-transactions-indices-colonne-respectifs-056-4" class="anchor" href="#suppression-des-colonnes-date-volume-et-nb-transactions-indices-colonne-respectifs-056-4"></a>suppression des colonnes date, volume et nb transactions indices colonne respectifs [0,5,6]</h1>
<p>colonnes_a_supprimer = [0,5,6]<br>
labels = np.delete(labels, colonnes_a_supprimer, axis=2)</p>
<p><span class="hashtag-raw">#conversion</span> en tenseur<br>
torch_donnees = torch.FloatTensor(donnees)<br>
torch_labels = torch.FloatTensor(labels)</p>
<h1><a name="dimension-des-entres-et-sorties-5" class="anchor" href="#dimension-des-entres-et-sorties-5"></a>Dimension des entrées et sorties</h1>
<p>dim_entrees = torch_donnees.size(2)<br>
dim_sorties = torch_labels.size(2)</p>
<p><span class="hashtag-raw">#dataset</span><br>
dataset = TensorDataset(torch_donnees, torch_labels)</p>
<p><span class="hashtag-raw">#dataloader</span><br>
batch_size = 3<br>
dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=False)</p>
<p><span class="hashtag-raw">#Calcul</span> du nombre de batch si besoin<br>
n_batch = math.ceil(torch_donnees.size(0)/batch_size)</p>
<p><span class="hashtag-raw">#Définition</span> du modèle de réseau de neurones<br>
class Réseau0(nn.Module):<br>
def <strong>init</strong>(self, nb_entree, dim_entree, taille_lstm, nb_sortie, dim_sortie):<br>
super(Réseau0, self).<strong>init</strong>()<br>
self.nb_entree = nb_entree<br>
self.dim_entree = dim_entree<br>
self.taille_lstm = taille_lstm<br>
self.dim_sortie = dim_sortie<br>
self.nb_sortie = nb_sortie</p>
<pre><code>    self.lstm1 = nn.LSTM(input_size = nb_entree*dim_entree, hidden_size = taille_lstm, num_layers = 5, batch_first=True)  # Couche LSTM 1
    self.pooling = nn.MaxPool2d(kernel_size=(4, 1), stride=(3, 1))
    self.batchnorm = nn.BatchNorm1d(nb_sortie)
    self.out1 = nn.Linear(taille_lstm, dim_sortie)  # Couche linéaire de sortie 1
    self.lstm2 = nn.LSTM(input_size = nb_sortie*dim_sortie, hidden_size = taille_lstm, num_layers = 3, batch_first=True)  # Couche LSTM 2
    self.out2 = nn.Linear(taille_lstm, dim_sortie)  # Couche linéaire de sortie 2

def forward(self, x):
    #premier réseau
    X11, _ = self.lstm1(x)
    X12 = X11.reshape(-1,self.nb_entree,self.taille_lstm)
    X1r = F.relu(X12)
    X13 = self.pooling(X1r)
    X1n = self.batchnorm(X13)
    X1 = self.out1(X1n)
    
    #second réseau
    X21, _ = self.lstm2(X1)
    X22 = X21.reshape(-1,self.nb_sortie,self.taille_lstm)
    X2r = F.relu(X22)
    X2 = self.out2(X2r)
    
    return X2
</code></pre>
<p><span class="hashtag-raw">#création</span> du réseau<br>
taille_lstm = 64<br>
cryptoboy = Réseau0(nb_entrees, dim_entrees, taille_lstm, nb_sorties, dim_sorties)<br>
crypotoboy = cryptoboy.to(‘cuda’)<br>
crypotoboy.lstm1.flatten_parameters()<br>
crypotoboy.lstm2.flatten_parameters()</p>
<h1><a name="dfinir-une-fonction-de-perte-loss-function-6" class="anchor" href="#dfinir-une-fonction-de-perte-loss-function-6"></a>Définir une fonction de perte (loss function)</h1>
<p>criteres = nn.MSELoss()<br>
criteres = criteres.to(‘cuda’)</p>
<h1><a name="dfinir-un-optimiseur-7" class="anchor" href="#dfinir-un-optimiseur-7"></a>Définir un optimiseur</h1>
<p>optimiseur = optim.SGD(cryptoboy.parameters(), lr=0.001)</p>
<h1><a name="dfinir-la-prcision-du-modle-8" class="anchor" href="#dfinir-la-prcision-du-modle-8"></a>Définir la précision du modèle</h1>
<p>def precision(predictions_batch, labels_batch, batch_size):</p>
<h1><a name="rcupration-des-diffrents-prdictions-du-modles-colonnes-close-high-low-qui-contiennent-autant-dlments-que-les-labels-ont-de-lignes-9" class="anchor" href="#rcupration-des-diffrents-prdictions-du-modles-colonnes-close-high-low-qui-contiennent-autant-dlments-que-les-labels-ont-de-lignes-9"></a>Récupération des différents prédictions du modèles (colonnes close, high, low qui contiennent autant d’éléments que les labels ont de lignes)</h1>
<pre><code>closes_predictions = predictions_batch[:,:,3]
SC = 0*closes_predictions[0,:]
highs_predictions = predictions_batch[:,:,1]
SH = 0*highs_predictions[0,:]
lows_predictions = predictions_batch[:,:,2]
SL = 0*lows_predictions[0,:]
</code></pre>
<h1><a name="cration-dun-tenseur-pour-chaque-catgorie-close-high-low-faisant-la-moyenne-des-carts-relatifs-des-prdictions-par-rapport-aux-labels-10" class="anchor" href="#cration-dun-tenseur-pour-chaque-catgorie-close-high-low-faisant-la-moyenne-des-carts-relatifs-des-prdictions-par-rapport-aux-labels-10"></a>Création d’un tenseur pour chaque catégorie (close, high, low) faisant la moyenne des écarts relatifs des prédictions par rapport aux labels</h1>
<h1><a name="autant-dlments-par-tenseur-que-de-lignes-dans-les-labels-la-moyenne-est-ralise-sur-un-batch-11" class="anchor" href="#autant-dlments-par-tenseur-que-de-lignes-dans-les-labels-la-moyenne-est-ralise-sur-un-batch-11"></a>autant d’éléments par tenseur que de lignes dans les labels. La moyenne est réalisée sur un batch</h1>
<pre><code>for i, closes_prediction in enumerate(closes_predictions):
    LC = torch.abs(labels_batch[i,:,3] - closes_prediction) / torch.abs(labels_batch[i,:,3])
    SC += LC
precision_moyenne_closes = SC/batch_size*100

for i, highs_prediction in enumerate(highs_predictions):
    LH = torch.abs(labels_batch[i,:,1] - highs_prediction) / torch.abs(labels_batch[i,:,1])
    SH += LH
precision_moyenne_highs = SH/batch_size*100

for i, lows_prediction in enumerate(closes_predictions):
    LL = torch.abs(labels_batch[i,:,2] - lows_prediction) / torch.abs(labels_batch[i,:,2])
    SL += LL
precision_moyenne_lows = SL/batch_size*100
</code></pre>
<h1><a name="cration-du-tableau-pandas-12" class="anchor" href="#cration-du-tableau-pandas-12"></a>Création du tableau pandas</h1>
<pre><code>Precisions = pd.DataFrame({
'Précisions moyenne closz': precision_moyenne_closes,
'Précisions moyenne high': precision_moyenne_highs,
'Précisions moyenne low': precision_moyenne_lows
</code></pre>
<p>})</p>
<pre><code>return Precisions
</code></pre>
<h1><a name="entraner-le-modle-13" class="anchor" href="#entraner-le-modle-13"></a>Entraîner le modèle</h1>
<p>epochs = 100<br>
for epoch in range(epochs):<br>
for i, batch in enumerate(dataloader):<br>
donnees, labels = batch<br>
donnees = donnees.to(‘cuda’)<br>
donnees = donnees.view(batch_size, nb_entrees, -1)<br>
labels = labels.to(‘cuda’)</p>
<pre><code>    # Remettre à zéro les gradients
    optimiseur.zero_grad()

    # Propagation avant (forward)
    predictions = cryptoboy(donnees)

    # Calcul de la perte
    perte = criteres(predictions, labels)

    # Rétropropagation (backward)
    perte.backward()

    # Mise à jour des poids
    optimiseur.step()
    
    with torch.no_grad():
        print(f'Époque {epoch+1}/{epochs}, Batch {i+1}/{n_batch} \n {precision(predictions,labels,batch_size)} Perte: {perte.item()}')
</code></pre>

ptrblck: <p>Your code is unfortunately not properly formatted and thus hard to read. Could you post a minimal and executable code snippet reproducing the issue?</p>

Mumak_Orrr: <p>yes, sorry it’s my first post, i’ll do that</p>

Mumak_Orrr: <p>Okay, here’s a simplified version :</p>
<pre><code class="lang-auto">import torch
from torch.utils.data import Dataset, DataLoader
from torch.utils.data import DataLoader, TensorDataset
import torch.nn as nn
from torch.nn import functional as F
import torch.optim as optim
from random import sample
import numpy as np
import pandas as pd
import math

n_lignes = 10
n_colonnes = 7
n_profondeur = 4

donnees = np.random.randint(0, 101, size=(n_profondeur, n_lignes, n_colonnes))

n_llabels = 3
n_clabels = 4

labels = np.random.randint(0, 101, size=(n_profondeur, n_llabels, n_clabels))

torch_donnees = torch.FloatTensor(donnees)
torch_labels = torch.FloatTensor(labels)

dim_entrees = torch_donnees.size(2)
dim_sorties = torch_labels.size(2)

dataset = TensorDataset(torch_donnees, torch_labels)

batch_size = 2
dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=False)

n_batch = math.ceil(torch_donnees.size(0)/batch_size)

class Réseau0(nn.Module):
    def __init__(self, nb_entree, dim_entree, taille_lstm, nb_sortie, dim_sortie):
        super(Réseau0, self).__init__()
        self.nb_entree = nb_entree
        self.dim_entree = dim_entree
        self.taille_lstm = taille_lstm
        self.dim_sortie = dim_sortie
        self.nb_sortie = nb_sortie
        
        self.lstm1 = nn.LSTM(input_size = nb_entree*dim_entree, hidden_size = taille_lstm, num_layers = 5, batch_first=True)
        self.pooling = nn.MaxPool2d(kernel_size=(4, 1), stride=(3, 1))
        self.batchnorm = nn.BatchNorm1d(nb_sortie)
        self.out1 = nn.Linear(taille_lstm, dim_sortie)  
   
    def forward(self, x):
        X11, _ = self.lstm1(x)
        X12 = X11.reshape(-1,self.nb_entree,self.taille_lstm)
        X1r = F.relu(X12)
        X13 = self.pooling(X1r)
        X1n = self.batchnorm(X13)
        X1 = self.out1(X1n)   
        return X1

nb_entrees = 10
nb_sorties = 3
taille_lstm = 64

cryptoboy = Réseau0(nb_entrees, dim_entrees, taille_lstm, nb_sorties, dim_sorties)
crypotoboy = cryptoboy.to('cuda')

criteres = nn.MSELoss()
criteres = criteres.to('cuda')

optimiseur = optim.SGD(cryptoboy.parameters(), lr=0.001)

epochs = 100
for epoch in range(epochs):
    for i, batch in enumerate(dataloader):
        donnees, labels = batch
        donnees = donnees.to('cuda')
        donnees = donnees.view(batch_size, nb_entrees, -1)
        labels = labels.to('cuda')

        optimiseur.zero_grad()

        predictions = cryptoboy(donnees)

        perte = criteres(predictions, labels)

        perte.backward()

        optimiseur.step()
        
        with torch.no_grad():
            print(f'Époque {epoch+1}/{epochs}, Batch {i+1}/{n_batch} \n Perte: {perte.item()}')
</code></pre>