README.md

---
datasets:
- amaai-lab/MidiCaps
- projectlosangeles/Los-Angeles-MIDI-Dataset
base_model:
- meta-llama/Llama-3.2-1B-Instruct
---

### Write music scores with llama

### Try the model online: https://huggingface.co/spaces/dx2102/llama-midi

This model is finetuned from the `Llama-3.2-1B` language model.

It learns to write MIDI music scores with a text representation.

Optionally, the score title can also be used as a text prompt.

To use this model, you can simply take existing code and replace `meta-llama/Llama-3.2-1B` with `dx2102/llama-midi`.

```python
import torch
from transformers import pipeline

pipe = pipeline(
    "text-generation", 
    model="dx2102/llama-midi", 
    torch_dtype=torch.bfloat16, 
    device="cuda", # cuda/mps/cpu
)

txt = pipe(
'''
Bach
pitch duration wait velocity instrument
'''.strip(),
    max_new_tokens=10,
    temperature=1.0,
    top_p=1.0,
)[0]['generated_text']
print(txt)
```


To convert the text representation back to a midi file, try this:

```bash
# install this midi library
pip install symusic
```

[symusic](https://github.com/Yikai-Liao/symusic) is a fast C++/Python library for efficient MIDI manipulation.

```python
import symusic

# For example
txt = '''pitch duration wait velocity instrument

71 1310 0 20 0
48 330 350 20 0
55 330 350 20 0
64 1310 690 20 0
74 660 690 20 0
69 1310 0 20 0
48 330 350 20 0
57 330 350 20 0
66 1310 690 20 0
67 330 350 20 0
69 330 350 20 0
71 1310 0 20 0
48 330 350 20 0
55 330 350 20 0
64 1310 690 20 0
74 660 690 20 0
69 1970 0 20 0
48 330 350 20 0
'''

def postprocess(txt, path):
    # assert txt.startswith(prompt)
    txt = txt.split('\n\n')[-1]

    tracks = {}

    now = 0
    # we need to ignore the invalid output by the model
    try:
        for line in txt.split('\n'):
            pitch, duration, wait, velocity, instrument = line.split()
            pitch, duration, wait, velocity = [int(x) for x in [pitch, duration, wait, velocity]]
            if instrument not in tracks:
                tracks[instrument] = symusic.core.TrackSecond()
                if instrument != 'drum':
                    tracks[instrument].program = int(instrument)
                else:
                    tracks[instrument].is_drum = True
            # Eg. Note(time=7.47, duration=5.25, pitch=43, velocity=64, ttype='Second')
            tracks[instrument].notes.append(symusic.core.NoteSecond(
                time=now/1000,
                duration=duration/1000,
                pitch=int(pitch),
                velocity=int(velocity * 4),
            ))
            now += wait
    except Exception as e:
        print('Postprocess: Ignored error:', e)
    
    print(f'Postprocess: Got {sum(len(track.notes) for track in tracks.values())} notes')

    try:
        score = symusic.Score(ttype='Second')
        score.tracks.extend(tracks.values())
        score.dump_midi(path)
    except Exception as e:
        print('Postprocess: Ignored postprocessing error:', e)

postprocess(txt, './result.mid')
```



Similarly, to convert a midi file to the text representation:

```python
def preprocess(path):
    # turn the midi into a custom format and write it to ./example/output.txt
    # midi files may be broken
    try:
        score = symusic.Score(path, ttype='Second')
    except Exception as e:
        print('Ignored midi loading error:', e)
        return ''
    
    # prolong notes to the end of the current pedal
    score = score.copy()
    for track in score.tracks:
        notes = track.notes
        pedals = track.pedals
        track.pedals = []
        j = 0
        for i, note in enumerate(notes):
            while j < len(pedals) and pedals[j].time + pedals[j].duration < note.time:
                j += 1
            if j < len(pedals) and pedals[j].time <= note.time <= pedals[j].time + pedals[j].duration:
                # adjust the duration
                note.duration = max(
                    note.duration, 
                    pedals[j].time + pedals[j].duration - note.time,
                )
    
    notes = []
    for track in score.tracks:
        instrument = str(track.program)   # program id. `instrument` is always a string.
        if track.is_drum:
            instrument = 'drum'
        for note in track.notes:
            notes.append((note.time, note.duration, note.pitch, note.velocity, instrument))
    # dedup
    notes = list({
        (time, duration, pitch): (time, duration, pitch, velocity, instrument) 
        for time, duration, pitch, velocity, instrument in notes
    }.values())
    # merge channels, sort by start time. If notes start at the same time, the higher pitch comes first.
    notes.sort(key=lambda x: (x[0], -x[2]))
    # Translate start time to the delta time format: 
    # ie. 'pitch duration wait', in milliseconds.
    notes1 = []
    
    txt = []
    for note in notes1:
        txt.append(' '.join(map(str, note)))
    txt = '\n'.join(txt)
    return txt

txt = preprocess('./test.mid')
```