j'avais oublié de faire des commit oups

main.py

@@ -3,6 +3,7 @@ import torch
 import torch.nn as nn
 import argparse
 import numpy as np
+from matplotlib import pyplot as plt
 
 import data
 import musicgenerator as mg
@@ -11,24 +12,31 @@ device = "cuda" if torch.cuda.is_available() else "cpu"
 
 if __name__ == '__main__':
     parser = argparse.ArgumentParser()
-    parser.add_argument('--lr', type=float, default=20, help='initial learning rate')
+    parser.add_argument('--lr', type=float, default=1, help='initial learning rate')
     parser.add_argument('--epochs', type=int, default=100, help='upper epoch limit')
-    parser.add_argument('--batch_size', type=int, default=16, help='batch size')
-    parser.add_argument('--sequence_length', type=int, default=32, help='sequence length')
-    parser.add_argument('--dimension_model', type=int, default=128, help='size of word embeddings')
+    parser.add_argument('--batch_size', type=int, default=8, help='batch size')
+    parser.add_argument('--sequence_length', type=int, default=128, help='sequence length')
+    parser.add_argument('--dimension_model', type=int, default=64, help='size of word embeddings')
     parser.add_argument('--nhead', type=int, default=4, help='the number of heads in the encoder/decoder of the transformer model')
-    parser.add_argument('--dropout', type=float, default=0.2, help='dropout applied to layers (0 = no dropout)')
-    parser.add_argument('--nhid', type=int, default=200, help='number of hidden units per layer')
-    parser.add_argument('--nlayers', type=int, default=2, help='number of layers')
+    parser.add_argument('--dropout', type=float, default=0.6, help='dropout applied to layers (0 = no dropout)')
+    parser.add_argument('--nhid', type=int, default=50, help='number of hidden units per layer')
+    parser.add_argument('--nlayers', type=int, default=10, help='number of layers')
+    parser.add_argument('--temperature', type=float, default=1.0, help='temperature used to generate result')
+    parser.add_argument('--data_path', type=str, default='./training_data/classical_music/', help='path to folder with training data')
+    parser.add_argument('--model_path', type=str, default=None, help='path to saved model')
+    parser.add_argument('--plot_result', type=bool, default=True, help='plot a graph of the evolution of the loss')
     args = parser.parse_args()
     ###############################################################################
     # Paramètres
     ###############################################################################
-    data_path = os.path.normpath('./training_data/classical_music/')
+    data_path = os.path.normpath(args.data_path)
+    assert os.path.exists(data_path), f"Error: The path '{data_path}' does not exist."
     learning_rate = args.lr
     batch_size = args.batch_size
     split_train_test_valid = (0.8, 0.1, 0.1)
-    model_path = None  # os.path.join(data_path, 'model.pt')
+    model_path = os.path.normpath(args.model_path) if args.model_path else None
+    if args.model_path:
+        assert os.path.exists(model_path), f"Error: The path '{model_path}' does not exist."
     sequence_length = args.sequence_length
     dim_model = args.dimension_model
     num_head = args.nhead
@@ -37,8 +45,8 @@ if __name__ == '__main__':
     dropout = args.dropout
     epochs = args.epochs
     nb_log_epoch = 5
-    nb_words = 100
-    temperature = 1.0
+    nb_words = 300
+    temperature = args.temperature
 
     print("device :", device)
 
@@ -62,7 +70,7 @@ if __name__ == '__main__':
     else:
         model = mg.MusicGenerator(vocab_size=ntokens, dim_model=dim_model, num_head=num_head, nhid=num_hid, nlayers=num_layers, dropout=dropout).to(
             device)
-        criterion = nn.NLLLoss()
+        criterion = nn.CrossEntropyLoss()
 
         ###############################################################################
         # Entraîne le modèle
@@ -78,7 +86,8 @@ if __name__ == '__main__':
             lr=learning_rate,
             epochs=epochs,
             log_interval=(len(train_data) // sequence_length) // nb_log_epoch,
-            data_path=data_path
+            data_path=data_path,
+            plot_result = args.plot_result
         )
 
     ###############################################################################
@@ -100,4 +109,4 @@ if __name__ == '__main__':
         data_path=data_path,
         bpm=bpm,
         ts=ts
-    )
+    )
\ No newline at end of file

musicgenerator.py

@@ -6,6 +6,8 @@ import torch
 import torch.nn as nn
 import torch.nn.functional as F
 
+import matplotlib.pyplot as plt
+
 import data
 
 
@@ -29,7 +31,8 @@ class PositionalEncoding(nn.Module):
 
 class MusicGenerator(nn.Transformer):
     def __init__(self, vocab_size: int, dim_model: int, num_head: int, nhid: int, nlayers: int, dropout: float):
-        super(MusicGenerator, self).__init__(d_model=dim_model, nhead=num_head, dim_feedforward=nhid, num_encoder_layers=nlayers)
+        super(MusicGenerator, self).__init__(d_model=dim_model, nhead=num_head, dim_feedforward=nhid,
+                                             num_encoder_layers=nlayers)
         self.model_type = 'Transformer'
         self.src_mask = None
         self.pos_encoder = PositionalEncoding(dim_model, dropout)
@@ -91,7 +94,7 @@ def evaluate(model: MusicGenerator,
 
 
 def train(model: MusicGenerator,
-          criterion: nn.NLLLoss,
+          criterion: nn.Module,
           ntokens: int,
           train_data: torch.Tensor,
           test_data: torch.Tensor,
@@ -100,11 +103,12 @@ def train(model: MusicGenerator,
           lr: float,
           epochs: int,
           log_interval: int,
-          data_path: str
+          data_path: str,
+          plot_result: bool
           ) -> None:
     # Loop over epochs.
     best_val_loss = None
-
+    plot_result_loss = []
     # At any point you can hit Ctrl + C to break out of training early.
     try:
         for epoch in range(1, epochs + 1):
@@ -124,12 +128,22 @@ def train(model: MusicGenerator,
             else:
                 # Anneal the learning rate if no improvement has been seen in the validation dataset.
                 lr /= 4.0
+            if plot_result:
+                plot_result_loss.append(val_loss)
+
         test_loss = evaluate(model, criterion, test_data, ntokens, sequence_length)
         print('=' * 89)
         print('| End of training | test loss {:5.2f} | test ppl {:8.2f}'.format(
             test_loss, math.exp(test_loss)))
         print('=' * 89)
 
+        if plot_result:
+            plt.title("évolution du taux d'erreur de validation")
+            plt.plot(list(range(epochs)), plot_result_loss)
+            plt.xlabel("Epoch number")
+            plt.ylabel("validaiton loss")
+
+            plt.show()
 
     except KeyboardInterrupt:
         print('-' * 89)
@@ -137,7 +151,7 @@ def train(model: MusicGenerator,
 
 
 def __train(model: MusicGenerator,
-            criterion: nn.NLLLoss,
+            criterion: nn.Module,
             ntokens: int,
             train_data: torch.Tensor,
             sequence_length: int,

parameter_finder.py

 from matplotlib import pyplot as plt
 import subprocess
-import itertools
-import time
 import re
 import os
 
-lr = ['0.1', '1', '100']
-epochs = ['20', '50', '100']
-batch_size = ['4', '16', '64']
-sequence_length = ['8', '32', '128']
-dimension_model = ['64', '256', '512']
-nhead = ['2', '4', '8']
-dropout = ['0.0', '0.3', '0.6']
-nhid = ['50', '100', '500']
-nlayers = ['2', '6', '10']
-
 params = {
     '--lr': ['0.1', '1', '100'],
     '--epochs': ['20', '50', '100'],
@@ -36,7 +24,9 @@ if __name__ == '__main__':
     else:  # For Unix or MacOS
         venv_python = os.path.join(venv_path, 'bin', 'python')
 
+    i = 0
     for param, param_vals in params.items():
+        losses = []
         for param_val in param_vals:
             res = subprocess.run([venv_python, 'main.py', param, param_val],
                                  stdout=subprocess.PIPE,
@@ -44,9 +34,20 @@ if __name__ == '__main__':
                                  )
             res_stdout = res.stdout.decode()
             res_stderr = res.stderr.decode()
-            match = re.search(r'test ppl\s+([0-9.]+)', res_stdout)
+            match = re.search(r'test loss\s+([0-9.]+)', res_stdout)
             if match:
-                test_ppl = float(match.group(1))
-                print(param, param_val, test_ppl)
+                test_loss = float(match.group(1))
+                losses.append(test_loss)
+                print(param, param_val, test_loss)
             else:
                 print("ERROR:", res_stdout, res_stderr)
+
+        plt.figure(i)
+        plt.title(f"Influence du paramètre {param}")
+        plt.plot(param_vals, losses)
+        plt.xlabel(param)
+        plt.ylabel("loss")
+        plt.savefig(f"{param}.png")
+        i += 1
+
+    plt.show()

requirements.txt

 music21==9.1.0
 numpy==1.26.4
 torch==2.3.1
+matplotlib