AI Models

results = google_search_custom("clima en guadalajara")
print(results)
# Output: "Rosario, encontré esto: [snippet 1] [snippet 2] [snippet 3]"

import librosa
import numpy as np

# Load audio file
audio, sr = librosa.load('wake_word.wav', sr=16000, duration=5)

# Extract features
mfcc_features = extract_features(audio)
print(mfcc_features.shape)  # (time_steps, 13)

X_train, y_train = prepare_dataset()
print(f"Training samples: {len(X_train)}")
print(f"Feature shape: {X_train[0].shape}")
print(f"Labels: {np.unique(y_train)}")

X_train, y_train = prepare_dataset()
model = build_model(X_train[0].shape)

# Train the model
model.fit(
    X_train, y_train,
    epochs=40,
    batch_size=8,
    validation_split=0.2
)

# Save the model
model.save('wake_word_model.h5')

import sounddevice as sd
import tensorflow as tf

# Load trained model
model = tf.keras.models.load_model('wake_word_model.h5')

threshold = 0.8  # Confidence threshold

while True:
    # Record 5 seconds of audio
    rec = sd.rec(
        int(DURATION * SAMPLE_RATE),
        samplerate=SAMPLE_RATE,
        channels=CHANNELS
    )
    sd.wait()
    audio_chunk = rec.flatten()
    
    # Extract features and predict
    feat = extract_features(audio_chunk)
    feat = np.expand_dims(feat, axis=0)
    
    prediction = model.predict(feat, verbose=0)[0][0]
    
    if prediction > threshold:
        print(f"Wake word detected! (confidence: {prediction:.2f})")
        # Trigger action here

data = cargar_datos('/path/to/dataset.json')
print(f"Loaded {len(data)} training examples")

modelo = joblib.load('modelo_entrenado.pkl')

# Single prediction
intencion = modelo.predict(["pon música relajante"])[0]
print(f"Intent: {intencion}")

# Batch prediction
textos = [
    "busca películas de acción",
    "apaga las luces",
    "cuál es el clima"
]
intenciones = modelo.predict(textos)
for texto, intent in zip(textos, intenciones):
    print(f"{texto} -> {intent}")

modelo = joblib.load('modelo_entrenado.pkl')

texto = "abre netflix por favor"
intencion = modelo.predict([texto])[0]
probabilidades = modelo.predict_proba([texto])
confianza = max(probabilidades[0])

print(f"Intent: {intencion}")
print(f"Confidence: {confianza:.2%}")

# Output:
# Intent: open_app
# Confidence: 94.32%

import joblib

modelo = joblib.load('modelo_entrenado.pkl')
iniciar_interfaz_chat(modelo)

# Interactive prompt:
# Tú: abre netflix
# Intención detectada: [open_app] (Confianza: 95.23%)
# ------------------------------

CONFIG = {
    "model_path": "modelo_ia_ligero.pth",
    "dataset_dir": "kamutini/datasets",
    "batch_size": 16,        
    "block_size": 256,       # Context window
    "n_embd": 512,           # Embedding dimension
    "n_head": 8,             # Attention heads
    "n_layer": 8,            # Transformer layers
    "dropout": 0.1,          
    "learning_rate": 5e-4,   
    "max_steps": 2000,       
    "temperature": 0.7,      # Generation randomness
    "top_k": 50,             # Top-k sampling
    "max_new_tokens": 500,   # Max generation length
    "eos_token": "<|endoftext|>"
}

def get_best_device():
    """
    Returns:
        "cuda" if NVIDIA GPU available
        "mps" if Apple Silicon GPU available
        "cpu" otherwise
    """
    if torch.cuda.is_available():
        return "cuda"
    elif hasattr(torch.backends, "mps") and torch.backends.mps.is_available():
        return "mps"
    else:
        return "cpu"

DEVICE = get_best_device()

class LocalOptimizedDataset(Dataset):
    def __init__(self, directory_path, block_size, simple_load=False, chars_fixed=None):
        # Initialize DataNormalizer
        self.normalizer = info.DataNormalizer(eos_token=CONFIG['eos_token'])
        
        formatted_lines = []
        files = [f for f in os.listdir(directory_path) 
                if f.endswith(('.json', '.csv'))]
        
        print(f"Loading and normalizing {len(files)} files...")
        
        for filename in files:
            # Process JSON files
            if filename.endswith('.json'):
                with open(filepath, 'r', encoding='utf-8') as f:
                    raw_data = json.load(f)
                    if not isinstance(raw_data, list):
                        raw_data = [raw_data]
                    
                    for item in raw_data:
                        norm_text = self.normalizer.normalize_entry(item)
                        if norm_text:
                            formatted_lines.append(norm_text)
            
            # Process CSV files
            elif filename.endswith('.csv'):
                df = pd.read_csv(filepath)
                for item in df.to_dict('records'):
                    norm_text = self.normalizer.normalize_entry(item)
                    if norm_text:
                        formatted_lines.append(norm_text)
        
        text_data = "\n\n".join(formatted_lines)
        # Tokenization follows...

# Load dataset
dataset = LocalOptimizedDataset(
    directory_path="kamutini/datasets",
    block_size=CONFIG['block_size']
)

# Create data loader
loader = DataLoader(
    dataset,
    batch_size=CONFIG['batch_size'],
    shuffle=True
)

# Train for specified steps
for step in range(CONFIG['max_steps']):
    x, y = next(iter(loader))
    x, y = x.to(DEVICE), y.to(DEVICE)
    
    logits, loss = model(x, y)
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    
    if step % 100 == 0:
        print(f"Step {step}: Loss = {loss.item():.4f}")

# Save model
torch.save(model.state_dict(), CONFIG['model_path'])

def generate_text(model, prompt, max_tokens=500, temperature=0.7, top_k=50):
    """
    Generate text continuation from a prompt.
    
    Args:
        prompt: Starting text
        max_tokens: Maximum tokens to generate
        temperature: Randomness (0.0 = deterministic, 1.0 = creative)
        top_k: Sample from top-k most likely tokens
    
    Returns:
        Generated text string
    """
    model.eval()
    with torch.no_grad():
        # Encode prompt
        tokens = encode(prompt)
        x = torch.tensor([tokens], dtype=torch.long).to(DEVICE)
        
        # Generate
        for _ in range(max_tokens):
            logits = model(x)
            logits = logits[:, -1, :] / temperature
            
            # Top-k filtering
            if top_k > 0:
                v, _ = torch.topk(logits, top_k)
                logits[logits < v[:, [-1]]] = -float('Inf')
            
            probs = F.softmax(logits, dim=-1)
            next_token = torch.multinomial(probs, num_samples=1)
            x = torch.cat([x, next_token], dim=1)
            
            # Check for EOS
            if decode([next_token.item()]) == CONFIG['eos_token']:
                break
        
        return decode(x[0].tolist())

# Usage
response = generate_text(
    model,
    prompt="### Humano: ¿Cómo estás?### Asistente:",
    temperature=0.7,
    top_k=50
)
print(response)