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:
Traceback (most recent call last):
File ~\anaconda3\lib\site-packages\spyder_kernels\py3compat.py:356 in compat_exec
exec(code, globals, locals)
File e:\documents\ia\cryptoboy\scripts\réseau de neurones\premier réseau propre 2.py:215
predictions = cryptoboy(donnees)
File ~\anaconda3\lib\site-packages\torch\nn\modules\module.py:1519 in _wrapped_call_impl
return self._call_impl(*args, **kwargs)
File ~\anaconda3\lib\site-packages\torch\nn\modules\module.py:1528 in _call_impl
return forward_call(*args, **kwargs)
File e:\documents\ia\cryptoboy\scripts\réseau de neurones\premier réseau propre 2.py:135 in forward
X11, _ = self.lstm1(x)
File ~\anaconda3\lib\site-packages\torch\nn\modules\module.py:1519 in _wrapped_call_impl
return self._call_impl(*args, **kwargs)
File ~\anaconda3\lib\site-packages\torch\nn\modules\module.py:1528 in _call_impl
return forward_call(*args, **kwargs)
File ~\anaconda3\lib\site-packages\torch\nn\modules\rnn.py:881 in forward
result = _VF.lstm(input, hx, self._flat_weights, self.bias, self.num_layers,
RuntimeError: shape ‘[1792, 1]’ is invalid for input of size 17920
Here is my code:
import torch
from torch.utils.data import Dataset, DataLoader
import torch.nn as nn
from torch.nn import functional as F
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset
from random import *
from random import shuffle
from random import sample
import numpy as np
import pandas as pd
import math
#Import des données
MinaEURJour = “E:\Documents\IA\CryptoBoy\Data\MINA\MINAEUR_1440.csv”
L=
with open(MinaEURJour) as f:
for ligne in f:
c=ligne.split(“,”)
x=[float(item) for item in c]
L.append(x)
Gestion et création de la base de donnée
def Préparation_data(L,i):
U=
for k in range(0, len(L)-i, i):
T=
for n in range(i):
T.append(L[k+n])
U.append(T)
return U
def Slice_liste(L, n):
if n <= 0:
return “Le nombre de morceaux doit être supérieur à zéro.”
longueur = len(L)
taille_morceau = longueur // n
morceaux = []
for i in range(n):
debut = i * taille_morceau
fin = (i + 1) * taille_morceau if i < n - 1 else longueur
morceaux.append(L[debut:fin])
return morceaux
def Recup_labels (L,n):
U=
for k in range(len(L)):
T=
for i in range(n):
T.append(L[k][len(L[k])-n+i])
U.append(T)
return U
def Recup_datas (L,n):
U=
for k in range(len(L)):
T=
for i in range(n):
T.append(L[k][i])
U.append(T)
return U
nb_entrees = 10
nb_sorties = 3
D=Préparation_data(L,nb_entrees + nb_sorties) # Regroupe en liste les entrées et les sorties correspondantes
SD=sample(D,len(D)) # Mélange des données (pourrait être évité car possibilité de le faire dans le dataloader)
nb_partitions = 3
Datasetbrut=Slice_liste(SD, nb_partitions) #Partitionne le jeu de données en plusieurs morceau pour la validation et le test
Création des liste de donnees et de labels
Data=Recup_datas(Datasetbrut[0], nb_entrees)
Labels=Recup_labels(Datasetbrut[0], nb_sorties)
Formatage en array numpy de dimension [-1, nb_entrees, 7] et [-1, nb_sorties, 7]
donnees = np.array(Data)
labels = np.array(Labels)
suppression des colonnes date, volume et nb transactions indices colonne respectifs [0,5,6]
colonnes_a_supprimer = [0,5,6]
labels = np.delete(labels, colonnes_a_supprimer, axis=2)
#conversion en tenseur
torch_donnees = torch.FloatTensor(donnees)
torch_labels = torch.FloatTensor(labels)
Dimension des entrées et sorties
dim_entrees = torch_donnees.size(2)
dim_sorties = torch_labels.size(2)
#dataset
dataset = TensorDataset(torch_donnees, torch_labels)
#dataloader
batch_size = 3
dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=False)
#Calcul du nombre de batch si besoin
n_batch = math.ceil(torch_donnees.size(0)/batch_size)
#Définition du modèle de réseau de neurones
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) # 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
#création du réseau
taille_lstm = 64
cryptoboy = Réseau0(nb_entrees, dim_entrees, taille_lstm, nb_sorties, dim_sorties)
crypotoboy = cryptoboy.to(‘cuda’)
crypotoboy.lstm1.flatten_parameters()
crypotoboy.lstm2.flatten_parameters()
Définir une fonction de perte (loss function)
criteres = nn.MSELoss()
criteres = criteres.to(‘cuda’)
Définir un optimiseur
optimiseur = optim.SGD(cryptoboy.parameters(), lr=0.001)
Définir la précision du modèle
def precision(predictions_batch, labels_batch, batch_size):
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)
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,:]
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
autant d’éléments par tenseur que de lignes dans les labels. La moyenne est réalisée sur un batch
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
Création du tableau pandas
Precisions = pd.DataFrame({
'Précisions moyenne closz': precision_moyenne_closes,
'Précisions moyenne high': precision_moyenne_highs,
'Précisions moyenne low': precision_moyenne_lows
})
return Precisions
Entraîner le modèle
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’)
# 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()}')