Upload 12 files

CornetAI_SavedModel/keras_metadata.pb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:69cb17ed575d1ebf501ab47830662ea63d84fcc81403e805869d3e3b619ca519
+size 44482

CornetAI_SavedModel/saved_model.pb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:517731222471a9be9a9e7ee66f3d1946efc32fb948da6aa199490fdc5e2f049c
+size 783876

models/CornetaAI.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c3e5cdfe18c7ae75059174ea221ed24add93a8ab27ab7356f3871ec016f749e0
+size 306636

src/calificador.py

@@ -0,0 +1,154 @@
+import os
+import sys
+import numpy as np
+import pretty_midi
+import mir_eval
+import matplotlib.pyplot as plt
+from basic_pitch.inference import predict
+
+# --- CONFIGURACIÓN ---
+MODEL_PATH = "CornetAI_SavedModel" 
+ONSET_TOL = 0.150  
+CEILING_F1 = 0.858 
+
+def get_friendly_score(f1_value):
+    score = (f1_value / CEILING_F1) * 10
+    return min(10.0, round(score, 1))
+
+def midi_a_espanol_corneta(midi_num):
+    """Mapeo específico simplificado para corneta."""
+    n = midi_num % 12
+    mapping = {7: 'Sol', 8: 'La', 0: 'Do', 1: 'Re', 4: 'Mi'}
+    nombres_base = ['Do', 'Re', 'Re', 'Re', 'Mi', 'Fa', 'Fa', 'Sol', 'La', 'La', 'Si', 'Si']
+    return mapping.get(n, nombres_base[n])
+
+def plot_piano_rolls(pm_ref, pm_est, puntuacion, fallos_texto, output_filename):
+    """Genera la comparativa y la guarda como imagen con el informe incluido."""
+    fig = plt.figure(figsize=(15, 8))
+    ax = fig.add_axes([0.1, 0.1, 0.6, 0.8])
+    
+    # 1. MIDI DE REFERENCIA
+    for i, note in enumerate(pm_ref.instruments[0].notes):
+        ax.barh(note.pitch, note.end - note.start, left=note.start, 
+                 height=0.4, color='green', alpha=0.3, 
+                 edgecolor='black', linewidth=1.5,
+                 label="Partitura (Referencia)" if i == 0 else "")
+                 
+    # 2. MIDI DE EJECUCIÓN
+    for i, note in enumerate(pm_est.instruments[0].notes):
+        ax.barh(note.pitch, note.end - note.start, left=note.start, 
+                 height=0.4, color='blue', alpha=0.5, 
+                 label="Tu Ejecución (CornetAI)" if i == 0 else "")
+    
+    # Obtener todas las notas MIDI únicas y crear etiquetas en español
+    all_pitches = set()
+    for note in pm_ref.instruments[0].notes:
+        all_pitches.add(note.pitch)
+    for note in pm_est.instruments[0].notes:
+        all_pitches.add(note.pitch)
+    
+    all_pitches = sorted(all_pitches)
+    ytick_labels = [midi_a_espanol_corneta(p) for p in all_pitches]
+    
+    ax.set_yticks(all_pitches)
+    ax.set_yticklabels(ytick_labels)
+                 
+    ax.set_xlabel("Tiempo (segundos)")
+    ax.set_ylabel("Nota")
+    ax.set_title(f"Informe de Evaluación CornetAI - {output_filename}")
+    ax.legend(loc='upper left')
+    ax.grid(axis='x', linestyle='--', alpha=0.3)
+
+    # 3. PANEL DE TEXTO (INFORME)
+    info_text = f"PUNTUACIÓN: {puntuacion}/10\n\n"
+    info_text += "CORRECCIONES:\n"
+    info_text += fallos_texto
+    
+    fig.text(0.72, 0.85, " RESULTADOS", fontsize=16, fontweight='bold', color='darkblue')
+    fig.text(0.72, 0.5, info_text, fontsize=12, va='center', 
+             bbox=dict(boxstyle='round', facecolor='wheat', alpha=0.5))
+
+    img_name = output_filename.replace(".wav", "_resultado.png")
+    plt.savefig(img_name, dpi=300, bbox_inches='tight')
+    print(f"✅ Imagen de resultados guardada como: {img_name}")
+    
+    plt.show()
+
+def evaluar_ejecucion(audio_path, midi_gt_path):
+    if not os.path.exists(audio_path) or not os.path.exists(midi_gt_path):
+        print("❌ Error: Archivos no encontrados.")
+        return
+
+    print(f"Analizando interpretación...")
+    
+    try:
+        _, midi_data, _ = predict(audio_path, model_or_model_path=MODEL_PATH)
+    except Exception as e:
+        print(f"Error en la inferencia: {e}")
+        return
+
+    pm_ref = pretty_midi.PrettyMIDI(midi_gt_path)
+    pm_est = midi_data 
+    
+    ref_notes = pm_ref.instruments[0].notes
+    est_notes = pm_est.instruments[0].notes
+    
+    if not est_notes:
+        print("No se han detectado notas.")
+        return
+
+    ref_int = np.array([[n.start, n.end] for n in ref_notes])
+    ref_pit = np.array([pretty_midi.note_number_to_hz(n.pitch) for n in ref_notes])
+    est_int = np.array([[n.start, n.end] for n in est_notes])
+    est_pit = np.array([pretty_midi.note_number_to_hz(n.pitch) for n in est_notes])
+    
+    metrics = mir_eval.transcription.evaluate(
+        ref_int, ref_pit, est_int, est_pit,
+        onset_tolerance=ONSET_TOL, offset_ratio=None
+    )
+    
+    puntuacion = get_friendly_score(metrics['F-measure_no_offset'])
+    
+    # Identificar notas falladas basándose en el onset (150ms)
+    fallados_idx = []
+    for i, ref_note in enumerate(ref_notes):
+        ref_onset = ref_note.start
+        # Buscar si hay alguna nota estimada dentro del margen de tolerancia
+        tiene_match_temporal = False
+        for est_note in est_notes:
+            est_onset = est_note.start
+            if abs(ref_onset - est_onset) <= ONSET_TOL:
+                tiene_match_temporal = True
+                break
+        
+        if not tiene_match_temporal:
+            fallados_idx.append(i)
+    #Lista de fallos
+    fallos_lista = []
+    print("\n" + "="*45)
+    print(f"EVALUACIÓN DE CORNETAI")
+    print("="*45)
+    print(f">> NOTA FINAL: {puntuacion} / 10 <<")
+    print("="*45)
+
+    if fallados_idx:
+        for idx in fallados_idx[:8]: #Máximo 8 fallos listados
+            nota_es = midi_a_espanol_corneta(ref_notes[idx].pitch)
+            tiempo = round(ref_notes[idx].start, 2)
+            fallos_lista.append(f"- Revisa {nota_es} ({tiempo}s)")
+            print(f"   - Revisa el {nota_es} en el segundo {tiempo}")
+        
+        if len(fallados_idx) > 6:
+            fallos_lista.append(f"... y {len(fallados_idx)-6} más.")
+    else:
+        fallos_lista.append("¡Interpretación Perfecta!")
+
+    fallos_texto = "\n".join(fallos_lista)
+
+    plot_piano_rolls(pm_ref, pm_est, puntuacion, fallos_texto, os.path.basename(audio_path))
+
+if __name__ == "__main__":
+    if len(sys.argv) == 3:
+        evaluar_ejecucion(sys.argv[1], sys.argv[2])
+    else:
+        print("Uso: python evaluador_individual.py <audio.wav> <referencia.mid>")

src/entrenar.py

@@ -0,0 +1,143 @@
+import os
+import numpy as np
+import tensorflow as tf
+import pretty_midi
+import librosa
+from basic_pitch.models import model as bp_model
+from basic_pitch import ICASSP_2022_MODEL_PATH
+from sklearn.model_selection import train_test_split
+
+# --- CONFIGURACIÓN DE RUTAS ---
+PATH_DATASET_WAV = "dataset_wavs"
+PATH_DATASET_MIDI = "dataset_midis"
+MODEL_SAVE_PATH = "CornetaAI.h5"
+
+# IDENTIFICADOR DE ARCHIVOS REALES
+FILTRO_REAL = "ejercicio" 
+
+# Parámetros Técnicos
+SAMPLE_RATE = 22050
+SAMPLES_PER_CLIP = 43844 
+HOP_LENGTH = 256
+ANNOTATIONS_FPS = SAMPLE_RATE / HOP_LENGTH
+N_FREQ_BINS = 88       
+N_FREQ_BINS_CONTOUR = 264 
+TRAIN_DURATION = SAMPLES_PER_CLIP / SAMPLE_RATE
+
+# Hiperparámetros Optimizados
+BATCH_SIZE = 8
+EPOCHS = 50 
+LEARNING_RATE = 0.0003 
+
+# --- FUNCIÓN DE PÉRDIDA BALANCEADA (95/5) ---
+def weighted_binary_crossentropy(y_true, y_pred):
+    epsilon = tf.keras.backend.epsilon()
+    y_pred = tf.clip_by_value(y_pred, epsilon, 1.0 - epsilon)
+    loss = -(0.95 * y_true * tf.math.log(y_pred) + 0.05 * (1.0 - y_true) * tf.math.log(1.0 - y_pred))
+    return tf.reduce_mean(loss)
+
+def get_data(wav, midi, frames_output, augment=False):
+    """Carga audio/midi con Pitch Shifting aleatorio para robustez."""
+    try:
+        audio, _ = librosa.load(wav, sr=SAMPLE_RATE)
+        if len(audio) < SAMPLES_PER_CLIP:
+            audio = np.pad(audio, (0, SAMPLES_PER_CLIP - len(audio)))
+        
+        max_start = len(audio) - SAMPLES_PER_CLIP
+        start_sample = np.random.randint(0, max_start + 1)
+        audio_crop = audio[start_sample : start_sample + SAMPLES_PER_CLIP]
+        
+        if augment:
+            n_steps = np.random.uniform(-0.5, 0.5)
+            audio_crop = librosa.effects.pitch_shift(audio_crop, sr=SAMPLE_RATE, n_steps=n_steps)
+            audio_crop += np.random.normal(0, 0.001, audio_crop.shape)
+
+        if np.max(np.abs(audio_crop)) > 0:
+            audio_crop = audio_crop / np.max(np.abs(audio_crop))
+
+        pm = pretty_midi.PrettyMIDI(midi)
+        start_time, end_time = start_sample / SAMPLE_RATE, (start_sample / SAMPLE_RATE) + TRAIN_DURATION
+        
+        targets = {
+            "note": np.zeros((frames_output, N_FREQ_BINS), dtype=np.float32),
+            "onset": np.zeros((frames_output, N_FREQ_BINS), dtype=np.float32),
+            "contour": np.zeros((frames_output, N_FREQ_BINS_CONTOUR), dtype=np.float32)
+        }
+
+        for note in pm.instruments[0].notes:
+            if note.end < start_time or note.start > end_time: continue
+            rel_start, rel_end = max(0.0, note.start - start_time), min(TRAIN_DURATION, note.end - start_time)
+            s, e = int(rel_start * ANNOTATIONS_FPS), int(rel_end * ANNOTATIONS_FPS)
+            p = note.pitch - 21
+            if 0 <= p < N_FREQ_BINS:
+                s, e = max(0, min(s, frames_output - 1)), max(0, min(e, frames_output))
+                if s < e:
+                    targets["note"][s:e, p] = 1.0
+                    if note.start >= start_time:
+                        targets["onset"][max(0, s-1):min(frames_output, s+2), p] = 1.0
+                    c = p * 3 + 1
+                    targets["contour"][s:e, c] = 1.0
+                    if c > 0: targets["contour"][s:e, c-1] = 0.5
+                    if c < 263: targets["contour"][s:e, c+1] = 0.5
+        return audio_crop[:, np.newaxis], targets
+    except Exception: return None, None
+
+class MasterGenerator(tf.keras.utils.Sequence):
+    def __init__(self, wavs, midis, frames_output, augment=False):
+        self.wavs, self.midis, self.frames_output, self.augment = wavs, midis, frames_output, augment
+        self.indices = np.arange(len(self.wavs))
+        self.on_epoch_end()
+    def __len__(self): return int(np.ceil(len(self.wavs)/BATCH_SIZE))
+    def __getitem__(self, idx):
+        batch_indices = self.indices[idx * BATCH_SIZE : (idx + 1) * BATCH_SIZE]
+        audios, notes, onsets, contours = [], [], [], []
+        for i in batch_indices:
+            a, t = get_data(self.wavs[i], self.midis[i], self.frames_output, augment=self.augment)
+            if a is not None:
+                audios.append(a); notes.append(t["note"]); onsets.append(t["onset"]); contours.append(t["contour"])
+        return np.array(audios), {"note": np.array(notes), "onset": np.array(onsets), "contour": np.array(contours)}
+    def on_epoch_end(self): np.random.shuffle(self.indices)
+
+if __name__ == "__main__":
+    print("--- FINE-TUNING: VALIDACIÓN REAL PURA (25 Train / 10 Val) ---")
+    
+    # 1. Cargar y clasificar archivos
+    all_wavs = [f for f in os.listdir(PATH_DATASET_WAV) if f.endswith(".wav")]
+    wav_real, midi_real, wav_sint, midi_sint = [], [], [], []
+
+    for w in all_wavs:
+        m = w.replace(".wav", ".mid")
+        if os.path.exists(os.path.join(PATH_DATASET_MIDI, m)):
+            path_w, path_m = os.path.join(PATH_DATASET_WAV, w), os.path.join(PATH_DATASET_MIDI, m)
+            if FILTRO_REAL.lower() in w.lower():
+                wav_real.append(path_w); midi_real.append(path_m)
+            else:
+                wav_sint.append(path_w); midi_sint.append(path_m)
+
+    # 2. Split de Reales (25 para entrenar, 10 para validar)
+    tr_rw, val_w, tr_rm, val_m = train_test_split(wav_real, midi_real, test_size=10, random_state=42)
+    
+    # 3. Mezcla de Entrenamiento (500 sintéticos + 25 reales)
+    train_w, train_m = wav_sint + tr_rw, midi_sint + tr_rm
+
+    # 4. Configurar Modelo
+    model = bp_model()
+    model.load_weights(ICASSP_2022_MODEL_PATH)
+    frames_out = model(np.zeros((1, SAMPLES_PER_CLIP, 1))).get('note').shape[1]
+
+    for l in model.layers: l.trainable = 'cqt' not in l.name
+    model.compile(optimizer=tf.keras.optimizers.Adam(LEARNING_RATE),
+                  loss={"note": "binary_crossentropy", "onset": weighted_binary_crossentropy, "contour": "binary_crossentropy"},
+                  loss_weights={"note": 1.0, "onset": 1.5, "contour": 0.5})
+
+    train_gen = MasterGenerator(train_w, train_m, frames_out, augment=True)
+    val_gen = MasterGenerator(val_w, val_m, frames_out, augment=False)
+
+    callbacks = [
+        tf.keras.callbacks.EarlyStopping(monitor='val_loss', patience=8, restore_best_weights=True),
+        tf.keras.callbacks.ReduceLROnPlateau(monitor='val_loss', factor=0.5, patience=3),
+        tf.keras.callbacks.ModelCheckpoint(MODEL_SAVE_PATH, monitor='val_loss', save_best_only=True)
+    ]
+
+    print(f"📊 Train: {len(train_w)} (500 sint + 25 real) | Val: {len(val_w)} (10 real).")
+    model.fit(train_gen, validation_data=val_gen, epochs=EPOCHS, callbacks=callbacks)

src/evaluador.py

@@ -0,0 +1,85 @@
+import os
+import pretty_midi
+import mir_eval
+import numpy as np
+import pandas as pd
+
+# --- CONFIGURACIÓN ---
+DIR_GT = "dataset_evaluación/midis_gt"
+DIR_PRED_MY = "dataset_evaluación/resultados_midis/cornetai"
+DIR_PRED_OFF = "dataset_evaluación/resultados_midis/official_bp"
+
+# Tolerancias
+ONSET_TOL = 0.150  
+OFFSET_RATIO_VAL = 0.5 
+FS = 100  # Frecuencia de muestreo para piano roll (hops de 10ms)
+
+def get_frame_accuracy(pm_ref, pm_est):
+    """Calcula la precisión por frame (Acc) comparando piano rolls."""
+    # Obtener piano rolls (binarizados)
+    pr_ref = (pm_ref.get_piano_roll(fs=FS) > 0).astype(int)
+    pr_est = (pm_est.get_piano_roll(fs=FS) > 0).astype(int)
+    
+    # Alinear longitudes
+    max_len = max(pr_ref.shape[1], pr_est.shape[1])
+    pr_ref = np.pad(pr_ref, ((0,0), (0, max_len - pr_ref.shape[1])))
+    pr_est = np.pad(pr_est, ((0,0), (0, max_len - pr_est.shape[1])))
+    
+    # Calcular TP, FP, FN a nivel de frame/pitch
+    tp = np.sum((pr_ref == 1) & (pr_est == 1))
+    fp = np.sum((pr_ref == 0) & (pr_est == 1))
+    fn = np.sum((pr_ref == 1) & (pr_est == 0))
+    
+    return (tp / (tp + fp + fn)) * 100 if (tp + fp + fn) > 0 else 0
+
+def get_full_metrics(path_ref, path_est):
+    try:
+        pm_ref = pretty_midi.PrettyMIDI(path_ref)
+        pm_est = pretty_midi.PrettyMIDI(path_est)
+        
+        # 1. Note Metrics (Fno y F)
+        ref_int = np.array([[n.start, n.end] for n in pm_ref.instruments[0].notes])
+        ref_pit = np.array([pretty_midi.note_number_to_hz(n.pitch) for n in pm_ref.instruments[0].notes])
+        est_int = np.array([[n.start, n.end] for n in pm_est.instruments[0].notes])
+        est_pit = np.array([pretty_midi.note_number_to_hz(n.pitch) for n in pm_est.instruments[0].notes])
+        
+        sc = mir_eval.transcription.evaluate(ref_int, ref_pit, est_int, est_pit, 
+                                            onset_tolerance=ONSET_TOL, offset_ratio=OFFSET_RATIO_VAL)
+        
+        # 2. Frame Accuracy (Acc)
+        acc = get_frame_accuracy(pm_ref, pm_est)
+        
+        return acc, sc['F-measure_no_offset'] * 100, sc['F-measure'] * 100
+    except Exception: return 0, 0, 0
+
+def main():
+    print("--- 📊 EVALUACIÓN FINAL TFG (ESTILO PAPER SPOTIFY) ---")
+    res = []
+    gts = [f for f in os.listdir(DIR_GT) if f.endswith(".mid")]
+
+    for gt_file in gts:
+        name = os.path.splitext(gt_file)[0]
+        c_acc, c_fno, c_f = get_full_metrics(os.path.join(DIR_GT, gt_file), os.path.join(DIR_PRED_MY, name + ".mid"))
+        o_acc, o_fno, o_f = get_full_metrics(os.path.join(DIR_GT, gt_file), os.path.join(DIR_PRED_OFF, name + ".mid"))
+        
+        res.append({
+            "Archivo": name,
+            "CAI_Acc": c_acc, "CAI_Fno": c_fno, "CAI_F": c_f,
+            "OFF_Acc": o_acc, "OFF_Fno": o_fno, "OFF_F": o_f
+        })
+
+    df = pd.DataFrame(res)
+    m = df.mean(numeric_only=True)
+    
+    print("\n" + "="*50)
+    print(f"{'Model':<20} | {'Acc':<8} | {'Fno':<8} | {'F':<8}")
+    print("-" * 50)
+    print(f"{'CornetAI (V3)':<20} | {m['CAI_Acc']:<8.2f} | {m['CAI_Fno']:<8.2f} | {m['CAI_F']:<8.2f}")
+    print(f"{'Basic Pitch':<20} | {m['OFF_Acc']:<8.2f} | {m['OFF_Fno']:<8.2f} | {m['OFF_F']:<8.2f}")
+    print("="*50)
+    
+    df.to_csv("Tabla_TFG_Estilo_Paper.csv", index=False)
+    print("\n Tabla final generada: 'Tabla_TFG_Estilo_Paper.csv'")
+
+if __name__ == "__main__":
+    main()

src/generadores/generador_maestro_midis.py

@@ -0,0 +1,108 @@
+import pretty_midi
+import random
+import os
+
+# --- CONFIGURACIÓN ---
+OUTPUT_FOLDER = "dataset_midis"
+CANTIDAD_RITMICOS = 250
+CANTIDAD_LEGATOS = 250
+ALLOWED_PITCHES = [67, 68, 72, 73, 76] 
+
+def get_dynamic_level():
+    niveles = [
+        (45, 60),   # Piano (Suave)
+        (65, 85),   # Mezzoforte (Normal)
+        (90, 127),  # Fortissimo (Fuerte)
+    ]
+    # Se da más peso al Mezzoforte y Fortissimo, pero incluimos Piano
+    return random.choices(niveles, weights=[0.2, 0.5, 0.3])[0]
+
+def get_next_stepwise(current_pitch):
+    idx = ALLOWED_PITCHES.index(current_pitch)
+    moves = []
+    if idx > 0: moves.append(idx - 1)
+    if idx < len(ALLOWED_PITCHES) - 1: moves.append(idx + 1)
+    return ALLOWED_PITCHES[random.choice(moves)]
+
+def generar_ritmico(index):
+    pm = pretty_midi.PrettyMIDI()
+    inst = pretty_midi.Instrument(program=0, name="Corneta Ritmica")
+    current = 0.5
+    
+    while current < 15.0:
+        # Cambio de dinámica cada cierto tiempo
+        min_v, max_v = get_dynamic_level()
+        
+        # Frase de 4 a 8 notas con esa dinámica
+        notas_frase = random.randint(4, 8)
+        
+        for _ in range(notas_frase):
+            pitch = random.choice(ALLOWED_PITCHES)
+            dur = random.choice([0.2, 0.4, 0.6]) # Staccato rápido
+            
+            # Velocidad dentro del rango dinámico actual
+            vel = random.randint(min_v, max_v)
+            
+            note = pretty_midi.Note(velocity=vel, pitch=pitch, start=current, end=current+dur)
+            inst.notes.append(note)
+            
+            gap = random.uniform(0.1, 0.3)
+            current += dur + gap
+            
+            if current > 15.0: break
+        
+        # Silencio entre frases de distinta dinámica
+        current += random.uniform(0.5, 1.5)
+        
+    pm.instruments.append(inst)
+    return pm
+
+def generar_legato(index):
+    pm = pretty_midi.PrettyMIDI()
+    inst = pretty_midi.Instrument(program=0, name="Corneta Legato")
+    current = 0.5
+    
+    while current < 14.0:
+        num_notas = random.randint(3, 6)
+        pitch = random.choice(ALLOWED_PITCHES)
+        
+        # Elegir dinámica para toda la frase (ej. un solo piano)
+        min_v, max_v = get_dynamic_level()
+        
+        for n in range(num_notas):
+            dur = random.uniform(1.2, 3.0) # Notas muy largas
+            start = current
+            end = current + dur + 0.05 # Solapamiento generoso para legato
+            
+            # Pequeña variación humana dentro de la frase
+            vel = random.randint(min_v, max_v)
+            
+            note = pretty_midi.Note(velocity=vel, pitch=pitch, start=start, end=end)
+            inst.notes.append(note)
+            
+            current += dur
+            if n < num_notas - 1:
+                pitch = get_next_stepwise(pitch)
+        
+        current += random.uniform(1.5, 2.5)
+        
+    pm.instruments.append(inst)
+    return pm
+
+if __name__ == "__main__":
+    if not os.path.exists(OUTPUT_FOLDER): os.makedirs(OUTPUT_FOLDER)
+    
+    # Limpieza previa opcional (descomentar si quieres borrar los viejos)
+    # for f in os.listdir(OUTPUT_FOLDER): os.remove(os.path.join(OUTPUT_FOLDER, f))
+
+    print(f"--- Generando {CANTIDAD_RITMICOS + CANTIDAD_LEGATOS} archivos con Dinámicas ---")
+
+    for i in range(CANTIDAD_RITMICOS):
+        midi = generar_ritmico(i)
+        midi.write(os.path.join(OUTPUT_FOLDER, f"dinamico_ritmico_{i:03d}.mid"))
+        
+    for i in range(CANTIDAD_LEGATOS):
+        midi = generar_legato(i)
+        midi.write(os.path.join(OUTPUT_FOLDER, f"dinamico_legato_{i:03d}.mid"))
+        
+    print("Dataset generado.")

src/generadores/generadoraudio.py

@@ -0,0 +1,47 @@
+import os
+import subprocess
+import pretty_midi
+
+# --- CONFIGURA ESTO ---
+SOUNDFONT_PATH = r"C:\Users\pampi\Documents\corneta.sf2"
+INPUT_FOLDER = "a"
+OUTPUT_FOLDER = "b"
+TARGET_PROGRAM = 40  # Preset de tu corneta (0-127)
+# ----------------------
+
+def synthesize():
+    if not os.path.exists(OUTPUT_FOLDER): os.makedirs(OUTPUT_FOLDER)
+    
+    # Limpiar WAVs viejos si existen
+    for f in os.listdir(OUTPUT_FOLDER): os.remove(os.path.join(OUTPUT_FOLDER, f))
+
+    files = [f for f in os.listdir(INPUT_FOLDER) if f.endswith('.mid')]
+    print(f"Sintetizando {len(files)} archivos...")
+
+    for midi_file in files:
+        # Parchear MIDI
+        midi_path = os.path.join(INPUT_FOLDER, midi_file)
+        pm = pretty_midi.PrettyMIDI(midi_path)
+        for inst in pm.instruments:
+            inst.program = TARGET_PROGRAM
+        
+        temp_midi = os.path.join(INPUT_FOLDER, "temp.mid")
+        pm.write(temp_midi)
+        
+        # Convertir
+        wav_name = midi_file.replace(".mid", ".wav")
+        wav_path = os.path.join(OUTPUT_FOLDER, wav_name)
+        
+        cmd = [
+            'fluidsynth', '-ni', '-F', wav_path, '-r', '22050', '-g', '1.0', 
+            SOUNDFONT_PATH, temp_midi
+        ]
+        
+        subprocess.run(cmd, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        print(f"-> {wav_name}")
+
+    if os.path.exists(temp_midi): os.remove(temp_midi)
+    print("Paso 2: WAVs generados.")
+
+if __name__ == "__main__":
+    synthesize()

src/generadores/genmidisreales.py

@@ -0,0 +1,54 @@
+import pretty_midi
+import random
+import os
+
+# --- CONFIGURACIÓN ---
+OUTPUT_FOLDER = "dataset_midis_guia"
+NUM_FILES = 20  
+ALLOWED_PITCHES = [67, 68, 72, 73] # Sol4, Lab4, Do5, Reb5
+
+def generate_human_guides():
+    if not os.path.exists(OUTPUT_FOLDER):
+        os.makedirs(OUTPUT_FOLDER)
+        
+    print(f"Generando {NUM_FILES} partituras guía para grabación...")
+    
+    for i in range(NUM_FILES):
+        pm = pretty_midi.PrettyMIDI()
+        instrument = pretty_midi.Instrument(program=0, name="Corneta Guia")
+        
+        # Empezamos en el segundo 2.0
+        current_time = 2.0
+        total_duration = 15.0 
+        
+        while current_time < total_duration:
+            # LÓGICA MÁS MUSICAL
+            pitch = random.choice(ALLOWED_PITCHES)
+            
+            # 0.5s, 1.0s, 2.0s
+            duration_choice = random.choice([0.5, 0.8, 1.2, 2.0])
+            
+            # Variamos la intensidad (Dinámica)
+            velocity = random.randint(95, 120) 
+            
+            note = pretty_midi.Note(
+                velocity=velocity, 
+                pitch=pitch, 
+                start=current_time, 
+                end=current_time + duration_choice
+            )
+            instrument.notes.append(note)
+            
+            # TIEMPO DE RESPIRACIÓN
+            gap = random.uniform(0.3, 0.8) 
+            current_time += duration_choice + gap
+            
+        pm.instruments.append(instrument)
+        filename = f"guia_{i:02d}.mid"
+        pm.write(os.path.join(OUTPUT_FOLDER, filename))
+        print(f"-> {filename}")
+
+    print("¡Listos! Ahora conviértelos a WAV y úsalos de backing track.")
+
+if __name__ == "__main__":
+    generate_human_guides()