audio2midi 0.1.0__py2.py3-none-any.whl

audio2midi/crepe_pitch_detector.py

@@ -0,0 +1,130 @@
+from math import ceil as math_ceil
+from typing import Callable
+from numpy.lib.stride_tricks import as_strided
+from keras.layers import Input, Reshape, Conv2D, BatchNormalization
+from keras.layers import MaxPool2D, Dropout, Permute, Flatten, Dense
+from keras.models import Model
+from keras.callbacks import Callback
+from hmmlearn.hmm import CategoricalHMM
+from librosa import load as librosa_load
+from pretty_midi_fix import PrettyMIDI , PitchBend , Note ,Instrument
+import numpy as np
+from huggingface_hub import hf_hub_download
+
+class PredictProgressCallback(Callback):
+    def __init__(self, total_batches,progress_callback: Callable[[int, int], None] = None):
+        super().__init__()
+        self.total_batches = total_batches
+        self.progress_callback = progress_callback
+    def on_predict_begin(self, logs=None):
+        self.progress_callback(0,self.total_batches)
+    def on_predict_batch_end(self, batch, logs=None):
+        self.progress_callback(batch,self.total_batches)
+    def on_predict_end(self, logs=None):
+        self.progress_callback(self.total_batches,self.total_batches)
+
+
+class Crepe():
+    def __init__(self,model_type="full",model_path=None):
+        if not model_path:
+            model_path = hf_hub_download("shethjenil/Audio2Midi_Models",f"crepe_{model_type}.h5")
+        model_type_importance = {'tiny': 4, 'small': 8, 'medium': 16, 'large': 24, 'full': 32}[model_type]
+        filters = [n * model_type_importance for n in [32, 4, 4, 4, 8, 16]]
+        widths = [512, 64, 64, 64, 64, 64]
+        strides = [(4, 1), (1, 1), (1, 1), (1, 1), (1, 1), (1, 1)]
+        x = Input(shape=(1024,), name='input', dtype='float32')
+        y = Reshape(target_shape=(1024, 1, 1), name='input-reshape')(x)
+        layers = [1, 2, 3, 4, 5, 6]
+        for l, f, w, s in zip(layers, filters, widths, strides):
+            y = Conv2D(f, (w, 1), strides=s, padding='same', activation='relu', name="conv%d" % l)(y)
+            y = BatchNormalization(name="conv%d-BN" % l)(y)
+            y = MaxPool2D(pool_size=(2, 1), strides=None, padding='valid', name="conv%d-maxpool" % l)(y)
+            y = Dropout(0.25, name="conv%d-dropout" % l)(y)
+        y = Permute((2, 1, 3), name="transpose")(y)
+        y = Flatten(name="flatten")(y)
+        y = Dense(360, activation='sigmoid', name="classifier")(y)
+        self.model = Model(inputs=x, outputs=y)
+        self.model.load_weights(model_path)
+        self.model.compile('adam', 'binary_crossentropy')
+        self.cents_mapping=(np.linspace(0, 7180, 360) + 1997.3794084376191)
+
+    def to_local_average_cents(self, salience, center=None):
+        if salience.ndim == 1:
+            if center is None:
+                center = int(np.argmax(salience))
+            start = max(0, center - 4)
+            end = min(len(salience), center + 5)
+            salience = salience[start:end]
+            product_sum = np.sum(salience * self.cents_mapping[start:end])
+            weight_sum = np.sum(salience)
+            return product_sum / weight_sum
+        if salience.ndim == 2:
+            return np.array([self.to_local_average_cents(salience[i, :]) for i in range(salience.shape[0])])
+        raise Exception("label should be either 1d or 2d ndarray")
+
+    def to_viterbi_cents(self,salience):
+        starting = np.ones(360) / 360
+        xx, yy = np.meshgrid(range(360), range(360))
+        transition = np.maximum(12 - abs(xx - yy), 0)
+        transition = transition / np.sum(transition, axis=1)[:, None]
+        self_emission = 0.1
+        emission = (np.eye(360) * self_emission + np.ones(shape=(360, 360)) * ((1 - self_emission) / 360))
+        model = CategoricalHMM(360, starting, transition)
+        model.startprob_, model.transmat_, model.emissionprob_ = starting, transition, emission
+        observations = np.argmax(salience, axis=1)
+        path = model.predict(observations.reshape(-1, 1), [len(observations)])
+        return np.array([self.to_local_average_cents(salience[i, :], path[i]) for i in range(len(observations))])
+
+    def get_activation(self,audio:np.ndarray,center, step_size, progress_callback,batch_size):
+        if center:
+            audio = np.pad(audio, 512, mode='constant', constant_values=0)
+        hop_length = int(16000 * step_size / 1000)
+        n_frames = 1 + int((len(audio) - 1024) / hop_length)
+        frames = as_strided(audio, shape=(1024, n_frames),strides=(audio.itemsize, hop_length * audio.itemsize))
+        frames = frames.transpose().copy()
+        frames -= np.mean(frames, axis=1)[:, np.newaxis]
+        frames /= np.clip(np.std(frames, axis=1)[:, np.newaxis], 1e-8, None)
+        return self.model.predict(frames,batch_size,0,callbacks=[PredictProgressCallback(math_ceil(len(frames) / batch_size),progress_callback)])
+    
+    def model_predict(self,audio:np.ndarray,viterbi, center, step_size,progress_callback,batch_size):
+        activation = self.get_activation(audio.astype(np.float32), center, step_size,progress_callback,batch_size)
+        confidence = activation.max(axis=1)
+        cents = self.to_viterbi_cents(activation) if viterbi else self.to_local_average_cents(activation)
+        frequency = 10 * 2 ** (cents / 1200)
+        frequency[np.isnan(frequency)] = 0
+        time = np.arange(confidence.shape[0]) * step_size / 1000.0
+        return time, frequency, confidence
+
+    def predict(self,audio_path,viterbi=False, center=True, step_size=10,min_confidence=0.8,batch_size=32,progress_callback: Callable[[int, int], None] = None,output_file= "output.mid"):
+        time, frequency, confidence = self.model_predict(librosa_load(audio_path, sr=16000, mono=True)[0],viterbi,center,step_size,progress_callback,batch_size)
+        mask = confidence > min_confidence
+        times = time[mask]
+        frequencies = frequency[mask]
+        midi_floats = 69 + 12 * np.log2(frequencies / 440.0)
+        midi_notes = np.round(midi_floats).astype(int)
+        pitch_offsets = midi_floats - midi_notes  # in semitones
+        midi = PrettyMIDI()
+        instrument = Instrument(program=40)  # e.g., Violin for pitch bend demo
+        if len(times) > 0:
+            current_note = midi_notes[0]
+            note_start = times[0]
+            for i in range(1, len(times)):
+                if midi_notes[i] != current_note or i == len(times) - 1:
+                    note_end = times[i]
+                    if 0 <= current_note <= 127:
+                        note = Note(velocity=100,pitch=int(current_note),start=note_start,end=note_end)
+                        instrument.notes.append(note)
+                        seg_mask = (times >= note_start) & (times <= note_end)
+                        seg_times = times[seg_mask]
+                        seg_offsets = pitch_offsets[seg_mask]
+                        for t, offset in zip(seg_times, seg_offsets):
+                            # Assuming pitch bend range is +/- 2 semitones
+                            bend_value = int(offset / 2.0 * 8192)  # Scale to -8192 to +8191
+                            bend_value = np.clip(bend_value, -8192, 8191)
+                            pb = PitchBend(pitch=bend_value, time=t)
+                            instrument.pitch_bends.append(pb)
+                    current_note = midi_notes[i]
+                    note_start = times[i]
+        midi.instruments.append(instrument)
+        midi.write(output_file)
+        return output_file

audio2midi/librosa_pitch_detector.py

@@ -0,0 +1,153 @@
+from typing import Callable
+import librosa
+from pretty_midi_fix import Instrument , PrettyMIDI , Note
+import numpy as np
+
+
+class Normal_Pitch_Det:
+    def smooth_pitch_sequence(self, pitches, magnitudes, threshold):
+        midi_sequence = []
+        for i in range(pitches.shape[1]):
+            index = np.argmax(magnitudes[:, i])
+            pitch_mag = magnitudes[index, i]
+            pitch = pitches[index, i]
+            if pitch_mag < threshold or np.isnan(pitch) or pitch <= 0:
+                midi_sequence.append(None)
+            else:
+                midi_note = int(round(librosa.hz_to_midi(pitch)))
+                midi_sequence.append(midi_note)
+        return midi_sequence
+
+    def clean_midi_sequence(self, sequence, min_note_length):
+        cleaned = []
+        current_note = None
+        count = 0
+        for note in sequence + [None]:
+            if note == current_note:
+                count += 1
+            else:
+                if current_note is not None and count >= min_note_length:
+                    cleaned.extend([current_note] * count)
+                else:
+                    cleaned.extend([None] * count)
+                current_note = note
+                count = 1
+        return cleaned
+
+    def predict(self, input_file, tempo_bpm=120, hop_length=512,min_note_length=2,threshold=0.1,output_file="output.mid"):
+        wav, sr = librosa.load(input_file)
+        audio_duration = len(wav) / sr
+        pitches, magnitudes = librosa.piptrack(y=wav, sr=sr, hop_length=hop_length)
+        midi_sequence = self.clean_midi_sequence(self.smooth_pitch_sequence(pitches, magnitudes,threshold),min_note_length)
+        time_per_frame = audio_duration / len(midi_sequence)
+        pm = PrettyMIDI(initial_tempo=tempo_bpm)
+        instrument = Instrument(program=0)  # Acoustic Grand Piano
+        last_note = None
+        start_time = 0
+        for i, note in enumerate(midi_sequence):
+            current_time = i * time_per_frame
+            if note != last_note:
+                if last_note is not None:
+                    end_time = current_time
+                    instrument.notes.append(Note(velocity=100,pitch=last_note,start=start_time,end=end_time))
+                if note is not None:
+                    start_time = current_time
+                last_note = note
+
+        if last_note is not None:
+            end_time = len(midi_sequence) * time_per_frame
+            instrument.notes.append(Note(velocity=100,pitch=last_note,start=start_time,end=end_time))
+
+        pm.instruments.append(instrument)
+        pm.write(output_file)
+        return output_file
+
+
+class Guitar_Pitch_Det:
+    def __init__(self):
+        # nfft=2048
+        # overlap=0.5
+        # self.HOP_LENGTH = int(nfft * (1 - overlap))
+        self.FMIN = librosa.note_to_hz('C1')
+
+    def calc_cqt(self,audio, sr, mag_exp):
+        """Compute CQT and convert to dB."""
+        return librosa.amplitude_to_db(np.abs(librosa.cqt(audio, sr=sr, hop_length=self.HOP_LENGTH, fmin=self.FMIN, n_bins=self.N_BINS, bins_per_octave=self.BINS_PER_OCTAVE)) ** mag_exp, ref=np.max)
+
+    def cqt_thresholded(self,cqt_db, threshold_db):
+        """Threshold CQT in dB."""
+        cqt_copy = np.copy(cqt_db)
+        cqt_copy[cqt_copy < threshold_db] = -120
+        return cqt_copy
+
+    def calc_onset(self,cqt_db, sr, pre_post_max, backtrack):
+        """Detect onsets using the onset envelope from thresholded CQT."""
+        onset_env = librosa.onset.onset_strength(S=cqt_db, sr=sr, hop_length=self.HOP_LENGTH, aggregate=np.mean)
+        onset_frames = librosa.onset.onset_detect(onset_envelope=onset_env, sr=sr, hop_length=self.HOP_LENGTH,units='frames', backtrack=backtrack,pre_max=pre_post_max, post_max=pre_post_max)
+        boundaries = np.concatenate([[0], onset_frames, [cqt_db.shape[1]]])
+        return boundaries, onset_env
+
+    def estimate_segment_note(self,cqt_db, boundaries, i, sr, tempo_bpm, threshold_db,round_to_sixteenth):
+        """Estimate pitch for one onset segment and generate note."""
+        n0, n1 = int(boundaries[i]), int(boundaries[i + 1])
+        # Pass the CQT segment directly to estimate_pitch
+        segment_cqt = np.mean(cqt_db[:, n0:n1], axis=1)
+        f0_info = self.estimate_pitch(segment_cqt, sr, threshold_db)
+        return self.generate_note(cqt_db, tempo_bpm, f0_info, sr, n1 - n0,round_to_sixteenth)
+
+    def generate_note(self,cqt_db, tempo_bpm, f0_info, sr, n_duration,round_to_sixteenth):
+        """Generate sinewave, MIDI note data, and Note or Rest."""
+        f0, amplitude = f0_info
+        # Remap amplitude based on the range of cqt_db values for velocity mapping
+        duration_beats = librosa.frames_to_time(n_duration, sr=sr, hop_length=self.HOP_LENGTH) * (tempo_bpm / 60)
+        if round_to_sixteenth:
+            duration_beats = round(duration_beats * 16) / 16
+        # Remap amplitude based on the range of cqt_db values for MIDI velocity
+        return None if f0 is None else int(np.round(librosa.hz_to_midi(f0))), duration_beats, int(np.clip(self.remap(amplitude, cqt_db.min(), cqt_db.max(), 0, 127), 0, 127))
+
+    def estimate_pitch(self,segment_cqt, sr, threshold_db):
+        """Estimate pitch from CQT segment."""
+        # Analyze the CQT segment to find the dominant frequency
+        # Find the frequency bin with the maximum energy in the segment
+        max_bin = np.argmax(segment_cqt)
+        # Convert the bin index to frequency (Hz)
+        pitch_hz = librosa.cqt_frequencies(n_bins=self.N_BINS, fmin=self.FMIN, bins_per_octave=self.BINS_PER_OCTAVE)[max_bin]
+        amplitude = segment_cqt[max_bin] # Use the amplitude from the CQT bin
+
+        if pitch_hz is not None and amplitude > threshold_db:
+            return pitch_hz, amplitude
+        else:
+            return None, 0
+
+    def remap(self,x, in_min, in_max, out_min, out_max):
+        """Remap a value or array from one range to another."""
+        return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min
+
+    def predict(self,audio_path, mag_exp=4,threshold_db=-61,pre_post_max=6,backtrack=False,round_to_sixteenth=False,hop_length=1024,n_bins=72,bins_per_octave=12,output_file="output.mid"):
+        self.BINS_PER_OCTAVE = bins_per_octave
+        self.HOP_LENGTH = hop_length
+        self.N_BINS = n_bins
+        audio , sr = librosa.load(audio_path, sr=None)
+        cqt_db = self.calc_cqt(audio, sr, mag_exp)
+        cqt_thresh = self.cqt_thresholded(cqt_db, threshold_db)
+        boundaries, onset_env = self.calc_onset(cqt_thresh, sr, pre_post_max, backtrack)
+        tempo_bpm, beats = librosa.beat.beat_track(onset_envelope=onset_env, sr=sr,hop_length=self.HOP_LENGTH)
+        tempo_bpm = round(tempo_bpm[0])
+        # Process all segments
+        notes_data = [self.estimate_segment_note(cqt_db, boundaries, i, sr, tempo_bpm, threshold_db,round_to_sixteenth) for i in range(len(boundaries) - 1)]
+        pm = PrettyMIDI(initial_tempo=tempo_bpm)
+        piano = Instrument(program=40)
+        note_time = 0.0
+        for (pitch, duration, velocity) in notes_data:
+            if pitch is not None:
+                # Convert duration in beats to duration in seconds for PrettyMIDI
+                duration_sec = duration * (60 / tempo_bpm)
+                piano.notes.append(Note(velocity, pitch, note_time, note_time + duration_sec))
+                note_time += duration_sec # Increment note_time by duration in seconds
+            else:
+                # If it's a rest, just advance the time
+                duration_sec = duration * (60 / tempo_bpm)
+                note_time += duration_sec
+        pm.instruments.append(piano)
+        pm.write(output_file)
+        return output_file

audio2midi/melodia_pitch_detector.py

@@ -0,0 +1,58 @@
+import numpy as np
+from scipy.signal import medfilt
+from pretty_midi_fix import PrettyMIDI,Instrument,Note
+from librosa import load as librosa_load
+from vamp import collect as vamp_collect
+
+class Melodia():
+    def midi_to_notes(self,midi, fs, smooth, minduration,hop=128):
+        if (smooth > 0):
+            filter_duration = smooth
+            filter_size = int(filter_duration * fs / float(hop))
+            if filter_size % 2 == 0:
+                filter_size += 1
+            midi_filt = medfilt(midi, filter_size)
+        else:
+            midi_filt = midi
+        notes = []
+        p_prev = 0
+        duration = 0
+        onset = 0
+        for n, p in enumerate(midi_filt):
+            if p == p_prev:
+                duration += 1
+            else:
+                if p_prev > 0:
+                    duration_sec = duration * hop / float(fs)
+                    if duration_sec >= minduration:
+                        onset_sec = onset * hop / float(fs)
+                        notes.append((onset_sec, duration_sec, p_prev))
+                onset = n
+                duration = 1
+                p_prev = p
+        if p_prev > 0:
+            duration_sec = duration * hop / float(fs)
+            onset_sec = onset * hop / float(fs)
+            notes.append((onset_sec, duration_sec, p_prev))
+        return notes
+
+    def hz2midi(self,hz:np.ndarray):
+        hz_nonneg = hz.copy()
+        idx = hz_nonneg <= 0
+        hz_nonneg[idx] = 1
+        midi = 69 + 12*np.log2(hz_nonneg/440.)
+        midi[idx] = 0
+        midi = np.round(midi)
+        return midi
+
+    def predict(self,audio, tempo=120, smooth=0.25, minduration=0.1,hop=128,output_file="output.mid"):
+        data, sr = librosa_load(audio, sr=44100, mono=True)
+        pm = PrettyMIDI(initial_tempo=tempo)
+        instrument = Instrument(program=40)
+        seconds_per_beat = 60.0 / tempo
+        for onset_beats, duration_beats, pitch in self.midi_to_notes(self.hz2midi(np.insert(vamp_collect(data, sr, "mtg-melodia:melodia",parameters={"voicing": 0.2})['vector'][1], 0, [0]*8)), 44100, smooth, minduration,hop):
+            start = onset_beats * seconds_per_beat
+            instrument.notes.append(Note(100,int(pitch),start,start + (duration_beats * seconds_per_beat)))
+        pm.instruments.append(instrument)
+        pm.write(output_file)
+        return output_file