Generador de texto automático con Python

Seguramente esta nueva entrega sobre Machine Learning no te dejará indiferente. Se trata sobre la creación de un generador de texto automático con Python. Sí, lo has leído bien, serás capaz de tener tu propio modelo ML con el que le podrás pedir que te genere texto a partir de una frase. Y lo mejor de todo: ¡el texto es único! No está copiado de ningún sitio, el propio modelo genera las palabras adecuadas para darle sentido a un nuevo contenido.

Si te apetece leer las primeras entregas de Machine Learning, te explico en los links cómo utilizar Natural Language de Google, y cómo generar un modelo de Machine Learning con AutoML también de Google.

¿Qué es la generación de texto automático?

Las noticias, webs, blogs, anuncios, etc. Existen muchos mercados en los que generar contenido (texto) es la base primordial para destacar dentro de un mercado. No sólo cuenta quién genera más contenido, sino también la relevancia y la forma de expresión de éste mismo.

Las empresas invierten en un gran número de recursos para que generen contenido durante todo el día y se vaya publicando en Internet. Por ejemplo: un diario deportivo online necesita generar 100 noticias al día sobre la actualidad del mundo del deporte. Seguramente tendrá 30-50 empleados para buscar la noticia, redactarla en un lenguaje natural y publicarla. ¿Te imaginas que estas tareas las realice una máquina? Y no sólo eso, lo más espeluznante es: ¿y si esta máquina es capaz de hacer el mismo trabajo que estas 30-50 personas, incluso mejor?

Sé que estás pensando que vamos directos a un mundo sin vuelta atrás, es posible. Pero, es alucinante, ¿no? Una empresa que gran parte de su cadena de valor es generar contenido de calidad y se haya adaptado con tecnologías como la que vas a ver en este artículo, es muy probable que vaya 100 pasos por delante que su competencia.

Automated Content con GPT-2 Python

Como es habitual, te acompaño y te explico en este vídeo todos los pasos y pre-requisitos que necesitas realizar para poder tener listo tu generador de texto automático. Es muy importante que lo mires hasta el final.

Preparación

Y pensarás: “¿cómo es posible que sea tan sencillo poseer tal herramienta a mi disposición?”. Es así. Te recapitulo las librerías que debemos instalar:

pip install tensorflow-gpu==1.12.0
pip install fire>=0.1.3
pip install regex==2017.4.5
pip install requests==2.21.0
pip install tqdm==4.31.1

Una vez tenemos instalados todas estas librerías, ya seremos capaces de utilizar la librería “gpt-2” para la generación y utilización de nuestro modelo de generación de texto. Para ello, nos debemos descargar el proyecto “gpt-2” de GitHub en este link.

Para el ejemplo que te he enseñado en el vídeo, yo me descargué el modelo ya preparado que contiene 345M de contenido de texto entrenado. Para descargarte el modelo que quieras, en el link del GitHub que te he indicado en el párrafo anterior, encontrarás un script “download_model.py” con el que te podrás descargar el modelo que quieras: 117M, 345M, 762M o 1542M.

python download_model.py 345M

O el modelo que queráis, cuanto más grande es significa que se ha entrenado con mayor número de textos y por tanto te devolverá mejores resultados.

Último apunte antes de lanzar frases a nuestro modelo, debemos especificar a nuestro entorno de python que utilizamos el encoding UTF-8, por tanto os recomiendo en vuestro código que añadáis al principio lo siguiente:

import os
os.environ['PYTHONIOENCODING'] = "UTF-8"

Ejecución

Ya tienes todos los requisitos para interactuar con el modelo descargado. El siguiente código es para utilizar el modelo que te hayas descargado. Luego si quieres puedes adaptarlo para entrenar dicho modelo en tu propia máquina.

import json
import os
import numpy as np
import tensorflow as tf
import model, sample, encoder

def interact_model(
    model_name,
    seed,
    nsamples,
    batch_size,
    length,
    temperature,
    top_k,
    models_dir
):
    models_dir = os.path.expanduser(os.path.expandvars(models_dir))
    if batch_size is None:
        batch_size = 1
    assert nsamples % batch_size == 0

    enc = encoder.get_encoder(model_name, models_dir)
    hparams = model.default_hparams()
    with open(os.path.join(models_dir, model_name, 'hparams.json')) as f:
        hparams.override_from_dict(json.load(f))

    if length is None:
        length = hparams.n_ctx // 2
    elif length > hparams.n_ctx:
        raise ValueError("Can't get samples longer than window size: %s" % hparams.n_ctx)

    with tf.Session(graph=tf.Graph()) as sess:
        context = tf.placeholder(tf.int32, [batch_size, None])
        np.random.seed(seed)
        tf.set_random_seed(seed)
        output = sample.sample_sequence(
            hparams=hparams, length=length,
            context=context,
            batch_size=batch_size,
            temperature=temperature, top_k=top_k
        )

        saver = tf.train.Saver()
        ckpt = tf.train.latest_checkpoint(os.path.join(models_dir, model_name))
        saver.restore(sess, ckpt)

        while True:
            raw_text = input("Model prompt >>> ")
            while not raw_text:
                print('Prompt should not be empty!')
                raw_text = input("Model prompt >>> ")
            context_tokens = enc.encode(raw_text)
            generated = 0
            for _ in range(nsamples // batch_size):
                out = sess.run(output, feed_dict={
                    context: [context_tokens for _ in range(batch_size)]
                })[:, len(context_tokens):]
                for i in range(batch_size):
                    generated += 1
                    text = enc.decode(out[i])
                    print("=" * 40 + " SAMPLE " + str(generated) + " " + "=" * 40)
                    print(text)
            print("=" * 80)

Aquí hemos definido nuestra funcion de interacción con el modelo, ahora simplemente le llamaremos e introduciremos nuestros parámetros.

interact_model(
    '345M',
    None,
    1,
    1,
    300,
    1,
    1,
    '/content/gpt-2/models'
)

Te dejo la definición de cada parámetro para que te quede claro cómo utilizarlos:

• model_name: nombre del modelo descargado.
• seed: semilla para la generación aleatoria de texto
• nsamples: número de texto ejemplo que quieres que te devuelva la prueba.
• batch_size: número de generaciones en paralelo. Debe ser igual que nsamples.
• length: número de palabras que contiene cada sample.
• temperature: es el número de aleatoriedad dentro de un rango de la distribución Boltzmann. Cuanto más bajo, más determinístico será el texto.
• top_k: controla la diversidad. Si el valor es 1 significa que 1 palabra es considerada en cada paso (token).
• models_dir: path dónde se encuentra nuestro modelo descargado.

Espero que hayas podido ver el resultado en el vídeo, de este espectacular modelo y que te lo hayas configurado tú mismo y puedas experimentar.

Aplicaciones de GPT-2

Es un proyecto que se paró en su momento debido al mal uso de esta herramienta como la generación de spam constante. Sin embargo, lo tenemos disponible para nuestro uso personal y experimental. Aunque seguramente te podría decir que si tenemos este tipo de herramientas a tan fácil alcance para nosotros, puedes imaginarte que organizaciones globales tendrán esta tecnología multiplicada por 100.

Si que es verdad, que GPT-2 intenta seguir en forma de historia el texto que le introduces. Funciona muy bien si necesitas generar un contenido tipo narración, siempre y cuando hablemos de los modelos que tenemos para descargarnos. Si eres más aventurero y te gustaría generar uno propio, seguramente podrías llegar a montar un modelo para generación de anuncios o bien que lea una red social y te genere un texto resumido sobre lo que se comenta (ideas que se me acaban de ocurrir).

Una vez más, esto es una muestra de la capacidad que tienen las empresas de ya adentrarse en este mundo y adaptar sus operaciones y procesos con modelos de Inteligencia Artificial y Machine Learning.

Espero que te haya gustado, siéntete libre de dejar tus dudas o opinión en la sección de comentarios o bien puedes contactarme.