Data Processing

import sounddevice as sd
import numpy as np

# Record audio
recording = sd.rec(
    int(DURATION * SAMPLE_RATE),  # Total frames
    samplerate=SAMPLE_RATE,        # Sample rate (Hz)
    channels=CHANNELS               # Mono
)
sd.wait()  # Wait until recording is finished

# Convert to 1D array
audio_data = recording.flatten()
print(f"Recorded {len(audio_data)} samples")
print(f"Duration: {len(audio_data) / SAMPLE_RATE:.2f} seconds")

import librosa

# Load audio file
audio, sr = librosa.load(
    'audio_file.wav',
    sr=SAMPLE_RATE,      # Resample to target rate
    duration=DURATION     # Load only first N seconds
)

print(f"Audio shape: {audio.shape}")
print(f"Sample rate: {sr} Hz")
print(f"Duration: {len(audio) / sr:.2f} seconds")

import librosa
import numpy as np

def extract_features(audio_data, sample_rate=16000, duration=5, n_mfcc=13):
    """Extract MFCC features from audio."""
    # Normalize audio length
    target_len = int(sample_rate * duration)
    
    if len(audio_data) < target_len:
        # Pad with zeros if too short
        audio_data = np.pad(audio_data, (0, target_len - len(audio_data)))
    else:
        # Truncate if too long
        audio_data = audio_data[:target_len]
    
    # Extract MFCCs
    mfcc = librosa.feature.mfcc(
        y=audio_data,
        sr=sample_rate,
        n_mfcc=n_mfcc
    )
    
    return mfcc.T  # Transpose to (time_steps, n_mfcc)

# Example
audio, sr = librosa.load('sample.wav', sr=16000)
features = extract_features(audio)
print(f"Feature shape: {features.shape}")  # (time_steps, 13)

import librosa
import librosa.display
import matplotlib.pyplot as plt
import numpy as np

# Load and extract features
audio, sr = librosa.load('sample.wav', sr=16000)
mfcc = librosa.feature.mfcc(y=audio, sr=sr, n_mfcc=13)

# Create visualization
plt.figure(figsize=(12, 6))
librosa.display.specshow(
    mfcc,
    x_axis='time',
    sr=sr,
    hop_length=512
)
plt.colorbar(format='%+2.0f dB')
plt.title('MFCC Features')
plt.xlabel('Time')
plt.ylabel('MFCC Coefficient')
plt.tight_layout()
plt.savefig('mfcc_visualization.png')

import os
import numpy as np
import librosa

def prepare_dataset(
    path_positive='audios',
    path_negative='audios bad',
    sample_rate=16000,
    duration=5,
    n_mfcc=13
):
    """Prepare dataset from audio files."""
    X = []
    y = []
    
    # Process positive samples (wake word)
    for path, label in [(path_positive, 1), (path_negative, 0)]:
        print(f"Loading {'positive' if label == 1 else 'negative'} samples...")
        
        if not os.path.exists(path):
            print(f"Warning: {path} does not exist")
            continue
        
        for filename in os.listdir(path):
            if filename.endswith('.wav'):
                filepath = os.path.join(path, filename)
                
                try:
                    # Load audio
                    audio, _ = librosa.load(
                        filepath,
                        sr=sample_rate,
                        duration=duration
                    )
                    
                    # Extract features
                    features = extract_features(audio)
                    
                    X.append(features)
                    y.append(label)
                    
                except Exception as e:
                    print(f"Error processing {filename}: {e}")
    
    return np.array(X), np.array(y)

# Usage
X_train, y_train = prepare_dataset()
print(f"Dataset shape: {X_train.shape}")
print(f"Labels: {np.unique(y_train, return_counts=True)}")

from sklearn.feature_extraction.text import TfidfVectorizer

vectorizer = TfidfVectorizer(
    ngram_range=(1, 2),    # Use unigrams and bigrams
    lowercase=True,         # Convert text to lowercase
    stop_words=None,        # Keep all words (Spanish)
    max_features=None,      # No feature limit
    min_df=1,              # Minimum document frequency
    max_df=1.0             # Maximum document frequency
)

# Fit on training data
texts = [
    "abre netflix",
    "busca videos de gatos",
    "apaga la televisión"
]
vectorizer.fit(texts)

# Transform new text
features = vectorizer.transform(["abre youtube"])
print(f"Feature shape: {features.shape}")
print(f"Vocabulary size: {len(vectorizer.vocabulary_)}")

from sklearn.feature_extraction.text import TfidfVectorizer
import pandas as pd

# Create and fit vectorizer
vectorizer = TfidfVectorizer(ngram_range=(1, 2))
texts = [
    "abre netflix",
    "busca videos en youtube",
    "apaga la televisión"
]
vectorizer.fit(texts)

# Get vocabulary
vocab = vectorizer.vocabulary_
print(f"Vocabulary size: {len(vocab)}")
print("\nTop 10 features:")
for term, idx in sorted(vocab.items(), key=lambda x: x[1])[:10]:
    print(f"  {term}: {idx}")

# Get IDF values
idf_values = vectorizer.idf_
feature_names = vectorizer.get_feature_names_out()

idf_df = pd.DataFrame({
    'feature': feature_names,
    'idf': idf_values
}).sort_values('idf', ascending=False)

print("\nTop 10 IDF scores:")
print(idf_df.head(10))

import json
import sys

def cargar_datos(ruta_archivo):
    """Load dataset from JSON file."""
    try:
        with open(ruta_archivo, 'r', encoding='utf-8') as f:
            data = json.load(f)
        return data
    except FileNotFoundError:
        print(f"Error: File not found at {ruta_archivo}")
        sys.exit(1)
    except json.JSONDecodeError:
        print("Error: Invalid JSON format")
        sys.exit(1)

# Usage
data = cargar_datos('dataset.json')
print(f"Loaded {len(data)} examples")

import re

def limpiar_texto_para_audio(texto):
    """Clean text for text-to-speech."""
    # Remove command tags
    texto = re.sub(r'/\*.*?\*/', '', texto)
    
    # Remove markdown formatting
    texto = texto.replace('*', '').replace('#', '').replace('_', ' ')
    
    # Remove URLs
    texto = re.sub(r'http\S+', '', texto)
    
    # Normalize whitespace
    texto = " ".join(texto.split())
    
    return texto

# Example
raw_text = "/*app(netflix)*/ Abriendo Netflix para ti, Rosario. https://netflix.com"
cleaned = limpiar_texto_para_audio(raw_text)
print(cleaned)  # "Abriendo Netflix para ti, Rosario."