Update app.py

app.py

@@ -1,94 +1,71 @@
 import gradio as gr
 import numpy as np
 import librosa
-from scipy.signal import find_peaks
-from sklearn.cluster import KMeans
-import torch
+from scipy.fft import fft, fftfreq
 from transformers import AutoModelForCausalLM, AutoTokenizer
+import torch
+
+# ---- ABECEDARIO DE FRECUENCIAS ----
+ABECEDARIO = {
+    'A': 300,'B': 400,'C': 500,'D': 600,'E': 700,'F': 800,'G': 900,'H': 1000,
+    'I': 1100,'J': 1200,'K': 1300,'L': 1400,'M': 1500,'N': 1600,'O': 1700,
+    'P': 1800,'Q': 1900,'R': 2000,'S': 2100,'T': 2200,'U': 2300,'V': 2400,
+    'W': 2500,'X': 2600,'Y': 2700,'Z': 2800,' ': 0
+}
 
-# ---- Modelo GPT-2 ----
+FRECUENCIAS = np.array(list(ABECEDARIO.values()))
+LETRAS = list(ABECEDARIO.keys())
+
+# ---- IA GPT-2 ----
 MODEL_NAME = "gpt2"
 tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
 model = AutoModelForCausalLM.from_pretrained(MODEL_NAME)
 
-# ---- Decodificador de Tonos ----
-class DigitalToneDecoder:
-    def __init__(self, frame_ms=40, min_freq=300, max_freq=4000, peak_threshold=0.2, symbols=16):
-        self.frame_ms = frame_ms
-        self.min_freq = min_freq
-        self.max_freq = max_freq
-        self.peak_threshold = peak_threshold
-        self.symbols = symbols
-        self.sr = None
-        self.y = None
+# ---- DSP: Decodificación de audio ----
+def decodificar_audio(audio_path, progress=gr.Progress()):
+    if audio_path is None:
+        return "⚠️ Sin audio"
 
-    def cargar_audio(self, path):
-        y, sr = librosa.load(path, sr=None, mono=True)
-        self.sr = sr
-        self.y = y
-        return y, sr
+    y, sr = librosa.load(audio_path, sr=None, mono=True)
+    n = len(y)
+    yf = fft(y)
+    xf = fftfreq(n, 1/sr)[:n//2]
+    magnitud = np.abs(yf[0:n//2])
 
-    def calcular_stft(self):
-        n_fft = int(self.sr * 0.05)
-        n_fft = 2 ** int(np.ceil(np.log2(n_fft)))
-        hop_length = int(self.sr * self.frame_ms / 1000)
-        stft = np.abs(librosa.stft(self.y, n_fft=n_fft, hop_length=hop_length, window="hann"))
-        freqs = librosa.fft_frequencies(sr=self.sr, n_fft=n_fft)
-        return stft, freqs
+    secuencia = ""
+    ventana_ms = 50
+    ventana_len = int(sr * ventana_ms / 1000)
 
-    def detectar_tonos(self, stft, freqs):
-        tonos = []
-        media_global = np.mean(stft)
-        for frame in stft.T:
-            if np.mean(frame) < media_global * 0.5:
-                continue
-            frame_norm = frame / np.max(frame)
-            peaks, _ = find_peaks(frame_norm, height=self.peak_threshold)
-            if len(peaks) == 0:
-                continue
-            peak = peaks[np.argmax(frame_norm[peaks])]
-            freq = freqs[peak]
-            if self.min_freq <= freq <= self.max_freq:
-                tonos.append(freq)
-        return np.array(tonos)
+    for start in range(0, n, ventana_len):
+        frame = y[start:start+ventana_len]
+        if len(frame) == 0:
+            continue
+        yf_frame = fft(frame)
+        magn = np.abs(yf_frame[:len(frame)//2])
+        freqs = fftfreq(len(frame), 1/sr)[:len(frame)//2]
 
-    def crear_simbolos(self, tonos):
-        if len(tonos) == 0:
-            return []
-        if len(tonos) < self.symbols:
-            return sorted(np.unique(tonos))
-        tonos_2d = tonos.reshape(-1,1)
-        kmeans = KMeans(n_clusters=self.symbols, n_init=10, random_state=42)
-        kmeans.fit(tonos_2d)
-        return sorted(kmeans.cluster_centers_.flatten())
+        idx_max = np.argmax(magn)
+        freq_max = freqs[idx_max]
 
-    def decodificar(self, tonos, centros):
-        letras = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-        out=""
-        if len(centros)==0:
-            return out
-        for f in tonos:
-            dist = [abs(f-c) for c in centros]
-            idx = dist.index(min(dist))
-            out += letras[idx % len(letras)]
-        return out
+        idx_letra = (np.abs(FRECUENCIAS - freq_max)).argmin()
+        letra = LETRAS[idx_letra]
+        secuencia += letra
 
-# ---- Preprocesamiento de letras ----
-def limpiar_repeticiones(texto, max_len=30):
-    resultado = ""
+    # Eliminar repeticiones consecutivas
+    secuencia_limpia = ""
     prev = None
-    for c in texto:
+    for c in secuencia:
         if c != prev:
-            resultado += c
+            secuencia_limpia += c
             prev = c
-    return resultado[:max_len]
 
-# ---- Generador de palabras/frases con IA ----
-def generar_texto_ia(letras):
-    letras = limpiar_repeticiones(letras)
-    prompt = f"""Secuencia de letras: {letras}
-Interpreta estas letras como posibles palabras inventadas y combina en frases legibles. 
-Genera solo palabras y frases cortas, sin URLs, ni texto irrelevante:\n"""
+    # Limitar longitud para IA
+    seq_ia = secuencia_limpia[:30]
+
+    # ---- Generar palabras y frases con IA ----
+    prompt = f"""Secuencia de letras: {seq_ia}
+Usa solo estas letras para formar palabras y luego frases coherentes. 
+No agregues letras nuevas, solo combina las detectadas. Devuelve palabras y frases legibles:\n"""
     input_ids = tokenizer(prompt, return_tensors="pt").input_ids
     out = model.generate(
         input_ids,
@@ -98,39 +75,22 @@ Genera solo palabras y frases cortas, sin URLs, ni texto irrelevante:\n"""
         top_p=0.92,
         top_k=50
     )
-    texto = tokenizer.decode(out[0], skip_special_tokens=True)
-    return texto
-
-# ---- Función principal ----
-def analizar(audio_path, progress=gr.Progress()):
-    if audio_path is None:
-        return "Sin audio"
-
-    decoder = DigitalToneDecoder()
-    progress(0.2)
-    decoder.cargar_audio(audio_path)
-    progress(0.4)
-    stft, freqs = decoder.calcular_stft()
-    progress(0.6)
-    tonos = decoder.detectar_tonos(stft, freqs)
-    progress(0.8)
-    centros = decoder.crear_simbolos(tonos)
-    seq = decoder.decodificar(tonos, centros)
-    ia_text = generar_texto_ia(seq)
+    texto_ia = tokenizer.decode(out[0], skip_special_tokens=True)
 
-    reporte = ""
-    reporte += "SECUENCIA DETECTADA\n"
-    reporte += seq + "\n\n"
-    reporte += "TEXTO GENERADO POR IA\n"
-    reporte += ia_text
+    reporte = "SECUENCIA DETECTADA\n"
+    reporte += secuencia + "\n\n"
+    reporte += "SECUENCIA LIMPIA\n"
+    reporte += secuencia_limpia + "\n\n"
+    reporte += "PALABRAS Y FRASES GENERADAS\n"
+    reporte += texto_ia
     return reporte
 
 # ---- Interfaz Gradio ----
 with gr.Blocks() as demo:
-    gr.Markdown("# Decodificador + Generador de Palabras/Frases con GPT-2")
+    gr.Markdown("# Decodificador de Frecuencias + IA de Palabras")
     audio = gr.Audio(type="filepath", sources=["upload","microphone"])
-    boton = gr.Button("Procesar")
+    btn = gr.Button("Procesar")
     salida = gr.Textbox(lines=15)
-    boton.click(analizar, inputs=audio, outputs=salida)
+    btn.click(decodificar_audio, inputs=audio, outputs=salida)
 
 demo.launch()