Cómo convertí un peluche 🧸 en un chatbot usando Python y GPT-3

En 2017, durante el sketch en uno de mis videos en YouTube, se me ocurrió convertir a un oso de peluche 🧸 en un personaje. Bauticé más adelante al oso como “Pequeñin”. Ahora es el símbolo de mi comunidad, pero además es una plataforma de inteligencia artificial que combina tecnologías de NLP, GPT-3, Python, Django, c#, Unity, Rust, text-to-speech, big data y mucho más.

Hola, soy Hector Pulido y te mostraré en este post cómo funciona este oso de peluche “venido del futuro” con presencia en Twitter, Discord y Twitch. Dejaremos la parte social y de crecimiento personal que representa tener a Pequeñín en mi vida y en mi comunidad en otro momento si os interesa, dejadlo en los comentarios 👀.

Qué tecnología usé para crear este ecosistema

Bot de Twitter con Python ¿Pequeñín/Twitter?

El bot de Twitter por el momento solo hace retweet a artículos sobre inteligencia artificial, data science y desarrollo de videojuegos. Quiero añadir crypto, no obstante es un poco complicado quedarme únicamente con la parte tecnológica, ignorar la parte económica y sobre todo evitar a los estafadores.

Este bot está hecho con Python, Django y para conectarse con Twitter usa *weepy. El reto tecnológico más importante actualmente es esquivar personas hablando de temas polémicos, esotéricos y fake news. Es por eso que guardo en Django todos los tweets que Pequeñín retuitea, el objetivo es clasificarlos y generar un dataset que reconozca ese tipo de tweets.

Ahora mismo este (y el resto de las piezas del bot) están subidas a Heroku, lo que acarrea un problema: tengo espacio limitado en la base de datos. Es por eso que el bot se conecta con mi cuenta de Google Drive y ahí guarda el dataset.

Si el bot detecta que una persona coloca tweets interesantes y tienen mucha interacción, el bot automáticamente decide seguir a esa persona, curiosamente ha ganado más de 600 seguidores en esa Red social desde que empezó a seguir a gente. Cosas de la plataforma supongo 🤔, Ya sabes qué hacer si quieres obtener seguidores más rápido.

defretweet(self, tweets):for tweet in tweets:
        tweet.retweeted = True
        tweet.save()
        tweet.user.retweet_count += 1
        tweet.user.save()
        try:
            self.api.retweet(tweet.tweet_id)
            time.sleep(self.sleep_time)
        except:
            print(
                f"Error retweeting tweet from: {tweet.user.user_profile}, {tweet.text[:20]}"
            )
            continue

Código para hacer los retweets, más código en el repositorio de pequenin/Twitter

Eso es pequenin/Twitter, bueno lo será por poco tiempo más, ya que pronto se integrará con la próxima pieza en este rompecabezas y una de las partes más interesantes.

Inteligencia artificial con GPT-3 ¿Pequenin/Brain?

Pequenin/Brain es un microservicio que recibe datos provenientes de Discord como recursos o memes. Además de eso, puede servir esos datos mediante una interfaz de texto NLP con comandos como “Muéstrame un meme” o “Dame información sobre Rust”. No solo eso, sino que también está conectado a GPT-3 para tener todo tipo de hilarantes conversaciones (ejemplos más abajo 👇).

Esta pieza está hecha con Python, Django y, por seguridad, se conecta mediante API a los demás microservicios. Por ahora solamente con Discord, pero pronto haré que se conecte con Twitter y pueda hacer cosillas interesantes en esa Red social.

En este caso, las interacciones no quedan guardadas más que por poco tiempo para que el robot pueda tener una memoria a corto plazo.

intents = {
    "doubts": doubts,
    "search": search_resource,
    "meme": get_random_meme,
    None: gpt3_response,
}

defpost(self, request, *args, **kwargs):
    ...

    parsing = settings.CHATBOT.predict(query)

    try:
        intent = parsing["intent"]["intentName"]
    except:
        intent = Noneif intent notin self.intents:
        intent = None

    parsing["history"] = request.data.get("history")
    response = self.get_text(intent, parsing)

    ...

    return Response(response, status=status.HTTP_200_OK)

Código que decide que tipo de respuesta debe tener Pequeñín*, más información en el repositorio de pequenin/brain*

Chatbot de discord con Rust ¿Pequenin/Discord?

Pequenin/Discord tiene el stack más interesante y es que esta parte en específico está totalmente hecha en Rust; es tremendamente veloz y eficiente. Se conecta a brain para guardar los datos del servidor, como recursos, ofertas de empleo y sobre todo memes, pero también detecta cuando lo mencionan para tener conversaciones con los miembros del grupo.

Bots de Discord: todo lo que necesitas saber.

Respuesta NO escrita por un humano…

Aquí una representación su increíble sentido para los memes…

Otra cosa curiosa es que tuve que desarrollar mi propio Dockerfile para poder subir Rust a Heroku, ya que no hay mucha información de eso en la web. Os mostré una versión simplificada de ese archivo en uno de los anteriores posts sobre rust.

async fnmanage_mentions(&self, ctx: &Context, msg: &Message) {
    let content = clean_text(&msg.content);
    self.add_msg_to_history(
        &ctx,
        "H".to_string(),
        &content,
        msg.channel_id.0.to_string(),
    )
    .await;

    let history = self.show_msg_history(ctx, msg).await;
    let endpoint = format!("{}phrase/", self.endpoint);

    letmut map = get_credentials(&self);
    map.insert("query", &content);
    map.insert("history", &history);

    let resp = self.client.post(endpoint).json(&map)
        .send().await.unwrap().text().await.unwrap();

    let resp = post_process(&resp, &msg);

    for phrase in resp {
        let clean_phrase = clean_text(&phrase);
        self.add_msg_to_history(
            &ctx,
            "P".to_string(),
            &clean_phrase,
            msg.channel_id.0.to_string(),
        )
        .await;
        ifletErr(why) = msg.channel_id.say(&ctx.http, phrase).await {
            println!("Error sending message: {:?}", why);
        }
    }
}

Código que se conecta con pequenin/brain y responde acorde a lo que este último responde, más información en el repositorio de pequenin/Discord.

Chatbot para Twitch con GPT-2 y Python ¿Pequenin/Twitch?

Por último, pero no menos importante Pequenin/Twitch este fue el primer bot que hice, está basado en GPT-2. Este es la única pieza de código que no está en Heroku, puesto que sobrepasa los límites de la plataforma y, aunque sí está hecho en Python, hay también una versión en C# que se conecta con Unity. Cada vez que hago stream, se enciende en segundo plano el bot para que interactuar con el chat.

Como tecnologías clave utiliza hugging face y twitchio. Tiene un montón de características y, además de las capacidades de chatbot conversacional, tiene comandos interesantes, entre ellos, uno en donde elige dos miembros del chat al azar y predice quién de los dos ganaría en una pelea. También integra text to speech para cuando llegan donaciones y muchísimas características más.

asyncdefhandle_custom_commands(self, message):
    text = message.content.lower()
    for key, command in self.custom_commands.items():
        if text.startswith(self.bot_prefix + key.lower()):
            if type(command) is str:
                returnawait message.channel.send(command)
            returnawait command(message, self)

Código que decide que comando se ejecutará, más información en el repositorio de pequeñín/Twitch

Y esas son las caras de Pequeñín hasta ahora. Tiene bastante tecnología a coste casi 0, pero por supuesto que todavía no ha acabado. Estoy trabajando muy fuerte con un grupo de artistas en una colección nft con la que el propio Pequeñín interactuará. Por supuesto, tengo muchos proyectos más. Cuéntame en los comentarios qué opinas de este proyecto y qué parte de esto te gustaría ver en un curso a más detalle.

Mientras tanto os invito a mi curso de desarrollo de videojuegos multijugador en donde hablaremos sobre el desarrollo de los juegos multijugador, desde counter strike hasta WOW.