v0

.gitignore

@@ -0,0 +1,4 @@
+__pycache__
+output/*
+temp.ipynb
+output*

app.py

@@ -0,0 +1,46 @@
+import torch
+import torch.nn as nn
+import numpy as np
+import gradio as gr
+from model import MusicLSTM
+from train import DataLoader, Config, generate_song as generate_ABC_notation
+from utils import load_vocab
+from convert import abc_to_audio
+
+class GradioApp():
+    def __init__(self):
+        # Set up configuration and data
+        self.config = Config()
+        self.CHECKPOINT_FILE = "checkpoint/model.pth"
+        self.data_loader = DataLoader(self.config.INPUT_FILE, self.config)
+        self.checkpoint = torch.load(self.CHECKPOINT_FILE, weights_only=False)
+        char_idx, char_list = load_vocab()
+        self.model = MusicLSTM(
+            input_size=len(char_idx),
+            hidden_size=self.config.HIDDEN_SIZE,
+            output_size=len(char_idx),
+        )
+        self.model.load_state_dict(self.checkpoint)
+        self.model.eval()
+
+        #Setup Interface
+        self.input = gr.Button("")
+        self.output = gr.Audio(label="Generated Music")
+        # self.output = gr.Textbox("")
+        self.interface = gr.Interface(fn=self.generate_music, inputs=self.input, outputs=self.output, title="AI Music Generator", description="Generate a new song using a trained RNN model.")
+    
+    def launch(self):
+        self.interface.launch()
+
+    def generate_music(self, input):
+        """Generate a new song using the trained model."""
+        abc_notation = generate_ABC_notation(self.model, self.data_loader)
+        abc_notation = abc_notation.strip("<start>").strip("<end>").strip()
+        audio = abc_to_audio(abc_notation)
+        return audio
+
+if __name__ == '__main__':
+    app = GradioApp()
+    app.launch()
+
+    

app.txt

@@ -0,0 +1,3 @@
+libfluidsynth-dev
+libsndfile1
+abc2midi  

config/vocab.json

@@ -0,0 +1 @@
+{"char_idx": "<]=_4Xl)uq5CBw#d(~H}scntZ!hIF6p'\\E/g&?fTW{^-v9MA710+oK\tJS[\n,Q \"G2a:L|mxVNbPRk*jYyD3e.8Oi>Uzr@", "char_list": ["<", "]", "=", "_", "4", "X", "l", ")", "u", "q", "5", "C", "B", "w", "#", "d", "(", "~", "H", "}", "s", "c", "n", "t", "Z", "!", "h", "I", "F", "6", "p", "'", "\\", "E", "/", "g", "&", "?", "f", "T", "W", "{", "^", "-", "v", "9", "M", "A", "7", "1", "0", "+", "o", "K", "\t", "J", "S", "[", "\n", ",", "Q", " ", "\"", "G", "2", "a", ":", "L", "|", "m", "x", "V", "N", "b", "P", "R", "k", "*", "j", "Y", "y", "D", "3", "e", ".", "8", "O", "i", ">", "U", "z", "r", "@"]}

convert.py

@@ -0,0 +1,33 @@
+from music21 import converter, stream
+from midi2audio import FluidSynth
+import subprocess
+
+def abc_to_audio(abc_notation, output_format='wav',sound_font="FluidR3_GM.sf2"):
+    """ Convert ABC notation to wav file. """
+    abc_file = 'output.abc'
+    with open(abc_file, 'w') as f:
+        f.write(abc_notation)
+    subprocess.run(['abc2midi', abc_file, '-o', "output.midi"])
+    fs = FluidSynth()
+    fs.midi_to_audio("output.midi", "output.wav")
+    return "output.wav"
+
+
+if __name__ == '__main__':
+    abc_to_audio("""X:12
+T:Byrne: Triop
+C:Trad Figne
+Z:id:hn-hornpipe-53
+M:C|
+K:G
+(3DFB d2dc | def2 edef | e2a2 df | g4- gdBG | A4G | A4 :|
+|: ae edc | edcB A2B2 | A2G2 | G6 d2 | e4^c4 | d4 d4 | ed e2 | d4 ||
+P:variations:
+|: ABA AGE|F2A d2A|d2g d2:|
+a2f fef aba|a2f g2e fed|c2A GBd|f2g g2a|bgb aag|dcB B2G|A2G A2G:|
+|:F2A A2G|AGE G2d||
+P:variations
+|: AGF GBd | cde d2B | c2c c2A :|
+|: de fe | fdfe dFAd | A2AG A2f2 | g2ag e2B2 | A2AB ^cdce | d2d>c | B4z2 | B4 | A4G2 | ^F4G4 | G4 :|
+|: G^F G2 | c4 ||
+GBdB | c2 ded2 | c2B2c2 | d2c2B2 | c2d2 | c2B2 | A4 :|""")

data/sample-music.txt

@@ -0,0 +1,25 @@
+X:3
+T:Badine
+O:France
+A:Provence
+Z:Transcrit et/ou corrig? par Michel BELLON - 2005-04-01
+Z:Pour toute observation mailto:galouvielle@free.fr
+M:C|
+L:1/8
+Q: "Allegro"
+K:Bb
+V:1 name=G
+d2 (cB) | d2 (cB) f2 ed | f4 g2 g2 | feed eddc | d2B2 d2cB | d2cB f2ed |
+f4 g2g2 | fedc d2!+!c2 | B4 :: FBcB | B2AB cd ec | d2 B2 df dB |
+cf cA Bd cB | B2 A2 f2 f2 | (ABcd) e2 d2 | e2 dc dcde | fefg fefg | 
+Te4 d2cB | d2cB f2ed | f4 g2g2 | feed eddc | d2B2 d2cB | d2cB f2ed |
+f4 g2g2 | fedc d2!+!c2 | B4   !fine!   :: [K:Bbm] c2de | d2ef B2cd |
+c2F2 dc Bc | !+!=A2 B2 c2 d2 | d2 c2 d2ef | g2g2 c2de | f2f2 B=ABc | F2Bc d2c2 |
+B4:| fefg | f2e=d e2f2 | {f2}g4 edef | e2dc d2e2 | {e2}f4 Bc=Ac |
+B2F2 dece | d2c2 dcde | f6 ed |c4 !D.C.! |]
+V:2 name=V
+z4 | z4  d2cB | d2cB e4 | B4 f2f2 | b2B2 z4 | z4 d2cB | d2cB e4 | d2B2 f2F2 | B4 ::
+z4 | f4f2f2 | B2b2 b2b2 | a2f2 g2=e2 | f2F2 z4 | f2f2 A2B2 | c2f2 B2B2 | B2b2 b2b2 | 
+a4 b2B2 | z4 d2cB | d2cB e4 | B4 f2f2 | b2B2 z4 | z4 d2cB | d2cB e4 | d2B2 f2F2 | B4 :: 
+[K:Bbm] b2b2 | b4 g2e2 | f2F2 B2B2 | e2d2 c2B2 | f4 b2b2 | e2fg a2a2 | d4 g2g2 | fede f2F2 | B4 :|
+b2b2 | b3a g2f2 | e4 a2a2 | a3g f2e2 | d4 z4 | z4 (bc')(=ac') | b2f2 B2Bc | dcde d2e2 | f4 |]

model.py

@@ -0,0 +1,66 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.optim as optim
+from torch.autograd import Variable
+
+class MusicLSTM(nn.Module):
+    def __init__(self, input_size, hidden_size, output_size, model='lstm', num_layers=1, dropout_p=0):
+        super(MusicLSTM, self).__init__()
+        self.model = model
+        self.input_size = input_size
+        self.hidden_size = hidden_size
+        self.output_size = output_size
+        self.num_layers = num_layers
+
+        self.embeddings = nn.Embedding(input_size, hidden_size)
+        if self.model == 'lstm':
+            self.rnn = nn.LSTM(hidden_size, hidden_size, num_layers)
+        elif self.model == 'gru':
+            self.rnn = nn.GRU(hidden_size, hidden_size, num_layers)
+        else:
+            raise NotImplementedError
+
+        self.out = nn.Linear(self.hidden_size, self.output_size)
+        self.drop = nn.Dropout(p=dropout_p)
+
+    def init_hidden(self, batch_size=1):
+        """Initialize hidden states."""
+        if self.model == 'lstm':
+            self.hidden = (
+                torch.zeros(self.num_layers, batch_size, self.hidden_size),
+                torch.zeros(self.num_layers, batch_size, self.hidden_size)
+            )
+        elif self.model == 'gru':
+            self.hidden = torch.zeros(self.num_layers, batch_size, self.hidden_size)
+
+        return self.hidden
+
+    def forward(self, x):
+        """Forward pass."""
+        # Ensure x is 2D (sequence length, batch size)
+        if x.dim() > 2:
+            x = x.squeeze()
+
+        batch_size = 1 if x.dim() == 1 else x.size(0)
+        x = x.long()
+
+        # Embed the input
+        embeds = self.embeddings(x)
+
+        # Initialize hidden state if not already done
+        if not hasattr(self, 'hidden'):
+            self.init_hidden(batch_size)
+
+        # Ensure embeds is 3D for RNN input (sequence length, batch size, embedding size)
+        if embeds.dim() == 2:
+            embeds = embeds.unsqueeze(1)
+
+        # RNN processing
+        rnn_out, self.hidden = self.rnn(embeds, self.hidden)
+
+        # Dropout and output layer
+        rnn_out = self.drop(rnn_out.squeeze(1))
+        output = self.out(rnn_out)
+
+        return output

requirments.txt

@@ -0,0 +1,3 @@
+music21
+midi2audio
+pyfluidsynth

train.py

@@ -0,0 +1,294 @@
+import os
+import sys
+import time
+import random
+import json
+import numpy as np
+import matplotlib.pyplot as plt
+from model import MusicLSTM as MusicRNN
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torch.autograd import Variable
+from utils import seq_to_tensor, load_vocab, save_vocab
+
+
+def logger(active=True):
+    """Simple logging utility."""
+    def log(*args, **kwargs):
+        if active:
+            print(*args, **kwargs)
+    return log
+
+# Configuration
+class Config:
+    SAVE_EVERY = 20
+    SEQ_SIZE = 25
+    RANDOM_SEED = 11
+    VALIDATION_SIZE = 0.15
+    LR = 1e-3
+    N_EPOCHS = 100
+    NUM_LAYERS = 1
+    HIDDEN_SIZE = 150
+    DROPOUT_P = 0
+    MODEL_TYPE = 'lstm'
+    INPUT_FILE = 'data/music.txt'
+    RESUME = False
+    BATCH_SIZE = 1
+
+# Utility functions
+def tic():
+    """Start timer."""
+    return time.time()
+
+def toc(start_time, msg=None):
+    """Calculate elapsed time."""
+    s = time.time() - start_time
+    m = int(s / 60)
+    if msg:
+        return f'{m}m {int(s - (m * 60))}s {msg}'
+    return f'{m}m {int(s - (m * 60))}s'
+
+class DataLoader:
+    def __init__(self, input_file, config):
+        self.config = config
+        self.char_idx, self.char_list = self._load_chars(input_file)
+        self.data = self._load_data(input_file)
+        self.train_idxs, self.valid_idxs = self._split_data()
+        log = logger(True)
+        log(f"Total songs: {len(self.data)}")
+        log(f"Training songs: {len(self.train_idxs)}")
+        log(f"Validation songs: {len(self.valid_idxs)}")
+    
+    def _load_chars(self, input_file):
+        """Load unique characters from the input file."""
+        with open(input_file, 'r') as f:
+            char_idx = ''.join(set(f.read()))
+        return char_idx, list(char_idx)
+
+    def _load_data(self, input_file):
+        """Load song data from input file."""
+        with open(input_file, "r") as f:
+            data, buffer = [], ''
+            for line in f:
+                if line == '<start>\n':
+                    buffer += line
+                elif line == '<end>\n':
+                    buffer += line
+                    data.append(buffer)
+                    buffer = ''
+                else:
+                    buffer += line
+
+        # Filter songs shorter than sequence size
+        data = [song for song in data if len(song) > self.config.SEQ_SIZE + 10]
+        return data
+
+    def _split_data(self):
+        """Split data into training and validation sets."""
+        num_train = len(self.data)
+        indices = list(range(num_train))
+
+        np.random.seed(self.config.RANDOM_SEED)
+        np.random.shuffle(indices)
+
+        split_idx = int(np.floor(self.config.VALIDATION_SIZE * num_train))
+        train_idxs = indices[split_idx:]
+        valid_idxs = indices[:split_idx]
+
+        return train_idxs, valid_idxs
+
+    def rand_slice(self, data, slice_len=None):
+        """Get a random slice of data."""
+        if slice_len is None:
+            slice_len = self.config.SEQ_SIZE
+
+        d_len = len(data)
+        s_idx = random.randint(0, d_len - slice_len)
+        e_idx = s_idx + slice_len + 1
+        return data[s_idx:e_idx]
+
+    def seq_to_tensor(self, seq):
+        """Convert sequence to tensor."""
+        out = torch.zeros(len(seq)).long()
+        for i, c in enumerate(seq):
+            out[i] = self.char_idx.index(c)
+        return out
+
+    def song_to_seq_target(self, song):
+        """Convert a song to sequence and target."""
+        try:
+            a_slice = self.rand_slice(song)
+            seq = self.seq_to_tensor(a_slice[:-1])
+            target = self.seq_to_tensor(a_slice[1:])
+            return seq, target
+        except Exception as e:
+            print(f"Error in song_to_seq_target: {e}")
+            print(f"Song length: {len(song)}")
+            raise    
+
+def train_model(config, data_loader, model, optimizer, loss_function):
+    """Training loop for the model."""
+    log = logger(True)
+    time_since = tic()
+    losses, v_losses = [], []
+
+    for epoch in range(config.N_EPOCHS):
+        # Training phase
+        epoch_loss = 0
+        model.train()
+
+        for i, song_idx in enumerate(data_loader.train_idxs):
+            try:
+                seq, target = data_loader.song_to_seq_target(data_loader.data[song_idx])
+
+                # Reset hidden state and gradients
+                model.init_hidden()
+                optimizer.zero_grad()
+
+                # Forward pass
+                outputs = model(seq)
+                loss = loss_function(outputs, target)
+
+                # Backward pass and optimization
+                loss.backward()
+                optimizer.step()
+
+                epoch_loss += loss.item()
+
+                msg = f'\rTraining Epoch: {epoch}, {(i+1)/len(data_loader.train_idxs)*100:.2f}% iter: {i} Time: {toc(time_since)} Loss: {loss.item():.4f}'
+                sys.stdout.write(msg)
+                sys.stdout.flush()
+
+            except Exception as e:
+                log(f"Error processing song {song_idx}: {e}")
+                continue
+
+        print()
+        losses.append(epoch_loss / len(data_loader.train_idxs))
+
+        # Validation phase
+        model.eval()
+        val_loss = 0
+        with torch.no_grad():
+            for i, song_idx in enumerate(data_loader.valid_idxs):
+                try:
+                    seq, target = data_loader.song_to_seq_target(data_loader.data[song_idx])
+
+                    # Reset hidden state
+                    model.init_hidden()
+
+                    # Forward pass
+                    outputs = model(seq)
+                    loss = loss_function(outputs, target)
+
+                    val_loss += loss.item()
+
+                    msg = f'\rValidation Epoch: {epoch}, {(i+1)/len(data_loader.valid_idxs)*100:.2f}% iter: {i} Time: {toc(time_since)} Loss: {loss.item():.4f}'
+                    sys.stdout.write(msg)
+                    sys.stdout.flush()
+
+                except Exception as e:
+                    log(f"Error processing validation song {song_idx}: {e}")
+                    continue
+
+        print()
+        v_losses.append(val_loss / len(data_loader.valid_idxs))
+
+        # Checkpoint saving
+        if epoch % config.SAVE_EVERY == 0 or epoch == config.N_EPOCHS - 1:
+            log('=======> Saving..')
+            state = {
+                'model': model.state_dict(),
+                'optimizer': optimizer.state_dict(),
+                'loss': losses[-1],
+                'v_loss': v_losses[-1],
+                'losses': losses,
+                'v_losses': v_losses,
+                'epoch': epoch,
+            }
+            os.makedirs('checkpoint', exist_ok=True)
+            torch.save(model, f'checkpoint/ckpt_mdl_{config.MODEL_TYPE}_ep_{config.N_EPOCHS}_hsize_{config.HIDDEN_SIZE}_dout_{config.DROPOUT_P}.t{epoch}')
+
+    return losses, v_losses
+
+def plot_losses(losses, v_losses):
+    """Plot training and validation losses."""
+    plt.figure(figsize=(10, 5))
+    plt.plot(losses, label='Training Loss')
+    plt.plot(v_losses, label='Validation Loss')
+    plt.xlabel('Epoch')
+    plt.ylabel('Loss')
+    plt.title('Loss per Epoch')
+    plt.legend()
+    plt.show()
+
+def generate_song(model, data_loader, prime_str='<start>', max_len=1000, temp=0.8):
+    """Generate a new song using the trained model."""
+    model.eval()
+    model.init_hidden()
+    creation = prime_str
+    char_idx, char_list = load_vocab()
+
+    # Build up hidden state
+    prime = seq_to_tensor(creation, char_idx)
+
+    with torch.no_grad():
+        for _ in range(len(prime)-1):
+            _ = model(prime[_:_+1])
+
+        # Generate rest of sequence
+        for _ in range(max_len):
+            last_char = prime[-1:]
+            out = model(last_char).squeeze()
+
+            out = torch.exp(out/temp)
+            dist = out / torch.sum(out)
+
+            # Sample from distribution
+            next_char_idx = torch.multinomial(dist, 1).item()
+            next_char = char_idx[next_char_idx]
+
+            creation += next_char
+            prime = torch.cat([prime, torch.tensor([next_char_idx])], dim=0)
+
+            if creation[-5:] == '<end>':
+                break
+
+    return creation
+
+def main():
+    """Main execution function."""
+    # Set up configuration and data
+    global model, data_loader
+    config = Config()
+    data_loader = DataLoader(config.INPUT_FILE, config)
+
+    # Model setup
+    in_size = out_size = len(data_loader.char_idx)
+    model = MusicRNN(
+        in_size,
+        config.HIDDEN_SIZE,
+        out_size,
+        config.MODEL_TYPE,
+        config.NUM_LAYERS,
+        config.DROPOUT_P
+    )
+
+    # Optimizer and loss
+    optimizer = torch.optim.Adam(model.parameters(), lr=config.LR)
+    loss_function = nn.CrossEntropyLoss()
+
+    # Train the model
+    losses, v_losses = train_model(config, data_loader, model, optimizer, loss_function)
+
+    # Plot losses
+    plot_losses(losses, v_losses)
+    save_vocab(data_loader)
+
+    # Generate a song
+    generated_song = generate_song(model, data_loader)
+    print("Generated Song:", generated_song)
+
+if __name__ == "__main__":
+    main()

utils.py

@@ -0,0 +1,91 @@
+import os
+import sys
+import time
+import json
+import torch
+
+# Only do the function below if verbose
+def logger(verbose):
+    def log(*msg):
+        if verbose: print(*msg)
+    return log
+
+
+last_time = time.time()
+begin_time = last_time
+
+def progress_bar(current, total, msg=None):
+    global last_time, begin_time
+    if current == 0:
+        begin_time = time.time()  # Reset for new bar.
+    cur_time = time.time()
+    step_time = cur_time - last_time
+    last_time = cur_time
+    tot_time = cur_time - begin_time
+
+    L = []
+    L.append('  Step: %s' % format_time(step_time))
+    L.append(' | Tot: %s' % format_time(tot_time))
+    if msg:
+        L.append(' | ' + msg)
+    msg = ''.join(L)
+    sys.stdout.write(msg)
+    sys.stdout.write('\r')
+    #if current < total-1:
+    #
+    #else:
+        #sys.stdout.write('\n')
+    sys.stdout.flush()
+
+def format_time(seconds):
+    days = int(seconds / 3600/24)
+    seconds = seconds - days*3600*24
+    hours = int(seconds / 3600)
+    seconds = seconds - hours*3600
+    minutes = int(seconds / 60)
+    seconds = seconds - minutes*60
+    secondsf = int(seconds)
+    seconds = seconds - secondsf
+    millis = int(seconds*1000)
+
+    f = ''
+    i = 1
+    if days > 0:
+        f += str(days) + 'D'
+        i += 1
+    if hours > 0 and i <= 2:
+        f += str(hours) + 'h'
+        i += 1
+    if minutes > 0 and i <= 2:
+        f += str(minutes) + 'm'
+        i += 1
+    if secondsf > 0 and i <= 2:
+        f += str(secondsf) + 's'
+        i += 1
+    if millis > 0 and i <= 2:
+        f += str(millis) + 'ms'
+        i += 1
+    if f == '':
+        f = '0ms'
+    return f
+
+def save_vocab(data_loader, vocab_filename="config/vocab.json"):
+    """Save vocabulary to a JSON file."""
+    vocab = {
+        'char_idx': data_loader.char_idx,
+        'char_list': data_loader.char_list
+    }
+    with open(vocab_filename, 'w') as f:
+        json.dump(vocab, f)
+
+def load_vocab(vocab_filename='config/vocab.json'):
+    with open(vocab_filename, 'r') as f:
+        vocab = json.load(f)
+    return vocab['char_idx'], vocab['char_list']
+
+def seq_to_tensor(seq, char_idx):
+        """Convert sequence to tensor."""
+        out = torch.zeros(len(seq)).long()
+        for i, c in enumerate(seq):
+            out[i] = char_idx.index(c)
+        return out