Generación de texto:
Para generar texto con Python, podemos utilizar modelos conocidos como Redes Neuronales Recurrentes (RNN). Este tipo de redes son capaces de predecir, a partir de una secuencia dada de palabras, la siguiente palabra que podría aparecer en la secuencia. Para ello, utilizaríamos un conjunto de datos para entrenar el modelo. Aquí te muestro un ejemplo sencillo, utilizando la biblioteca TensorFlow:
import tensorflow as tf
from tensorflow.keras.layers import LSTM, Dense, Embedding
from tensorflow.keras.models import Sequential
from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.preprocessing.sequence import pad_sequences
import numpy as np
# Definimos nuestros datos de entrenamiento
sentences = ['Llevo años estudiando ingeniería.', 'Me gusta programar en Python.', 'El deep learning me apasiona.']
# Tokenizamos las palabras de las frases
tokenizer = Tokenizer()
tokenizer.fit_on_texts(sentences)
sequences = tokenizer.texts_to_sequences(sentences)
# Ajustamos las secuencias al tamaño máximo de palabras
max_sequence_length = max([len(seq) for seq in sequences])
sequences = pad_sequences(sequences, maxlen=max_sequence_length, padding='post')
# Creamos pares de entrada y salida para el modelo
input_sequences = []
target_words = []
for sequence in sequences:
for i in range(1, len(sequence)):
input_sequence = sequence[:i]
target_word = sequence[i]
input_sequences.append(input_sequence)
target_words.append(target_word)
# Convertimos los datos a arrays numpy
input_sequences = pad_sequences(input_sequences, maxlen=max_sequence_length-1, padding='post')
target_words = np.array(target_words)
# Definimos nuestro modelo RNN básico
vocab_size = len(tokenizer.word_index) + 1
model = Sequential()
model.add(Embedding(input_dim=vocab_size, output_dim=64, input_length=max_sequence_length-1))
model.add(LSTM(128, dropout=0.2))
model.add(Dense(vocab_size, activation='softmax'))
# Compilamos el modelo y lo entrenamos
model.compile(loss='sparse_categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
model.fit(input_sequences, target_words, epochs=50, verbose=0)
# Generamos texto a partir de una secuencia dada
seed_text = 'Me gusta'
next_words = 10
for _ in range(next_words):
token_list = tokenizer.texts_to_sequences([seed_text])[0]
token_list = pad_sequences([token_list], maxlen=max_sequence_length-1, padding='post')
prediction = model.predict(token_list, verbose=0)
predicted_word_index = np.argmax(prediction)
output_word = ""
for word, index in tokenizer.word_index.items():
if index == predicted_word_index:
output_word = word
break
seed_text += " " + output_word
print(seed_text)
En este ejemplo, entrenamos un modelo para dar continuidad a una secuencia de palabras, generando texto a partir de ella. Al pasar como `seed_text` la frase "Me gusta", el modelo va a predecir cuál es la siguiente palabra. En este caso, el resultado es: "Me gusta programar en Python y el deep learning me apasiona".
Generación de voz:
Para generar voz con Python, podemos utilizar la biblioteca PyDub, que permite manipular archivos de audio de forma sencilla. Podemos crear archivos de audio a partir de una serie de datos de entrada, y posteriormente exportarlos como archivos MP3 o WAV. Aquí te muestro un ejemplo sencillo:
from pydub import AudioSegment
from pydub.generators import Sine
# Generamos una señal de audio sinusoidal
duration = 2000
frequency = 440
volume = 0.5 # Reducimos la amplitud máxima de la señal
sine_wave = Sine(frequency).to_audio_segment(duration=duration)
# Normalizamos la señal
sine_wave = sine_wave.normalize(headroom=0.1)
# Ajustamos el volumen
sine_wave = sine_wave + volume
# Reproducimos la señal de audio
sine_wave.export("sine_wave.mp3", format="mp3")
En este ejemplo, generamos una señal de audio sinusoidal a una frecuencia de 440 Hz y una duración de 2000 ms, y la reproducimos. Posteriormente, la exportamos como un archivo MP3 llamado "sine_wave.mp3".