tech explorers, welcome!

Categoría: IA

Inteligencia Artificial

🐸Coqui-AI/TTS: ultra rápida generación y clonación de voz a partir de texto multilenguaje

Hace unos meses traía el repositorio TorToiSe-TTS que facilitaba muchísmo la generación de voz a partir de texto, aunque solo se disponía de modelos en inglés.

https://theroamingworkshop.cloud/b/2066

Pero el mundo de la IA avanza tan rápido, que hoy os traigo una evolución que desbanca por completo al anterior post, con generación de voces complejas en cuestión de segundos y multilenguaje: Coqui-AI TTS.

https://github.com/coqui-ai/TTS

Versión web

Si tienes prisa y no quieres liarte, puedes usar el espacio gratuito de huggingface, y tendrás tu clonación de voz en pocos segundos:

https://huggingface.co/spaces/coqui/xtts

  1. Escribe el texto a generar
  2. Selecciona el idioma
  3. Sube tu fichero de referencia
  4. Configura el resto de opciones (marca las casillas: Cleanup Reference Voice, Do not use language auto-detect, Agree)
  5. Solicita tu clonación al servidor (Send)

Instalación

En cuanto a la instalación local:

  • Necesitarás python > 3.9, < 3.12.
  • RAM: no necesita tanta como para generación de imágenes. 4GB deberían bastar.
  • Crea una carpeta para el proyecto, por ejemplo "text-2-speech". Usando un terminal de Linux:
    mkdir text-2-speech
  • Es conveniente crear un entorno de python específico para evitar incompatibilidad de paquetes, para lo que debes instalar el paquete python3-venv. Yo crearé el entorno TTSenv:
    cd text-2-speech
    python3 -m venv TTSenv
  • Activa el entorno en el terminal:
    source TTSenv/bin/activate
  • Si solo necesitas generación de voz (sin clonación ni entrenamiento), instala directamente TTS en python:
    pip install TTS
  • Sin embargo, yo instalaré el repositorio completo de Coqui-AI TTS:
    git clone https://github.com/coqui-ai/TTS
    cd TTS
    pip install -e .[all]

Comprobación de modelos de lenguaje y voces

Lo primero que puedes hacer es comprobar los modelos disponibles para transformar tu texto a voz en distintos idiomas.

En el terminal escribe lo siguiente:

tts --list_models

No API token found for 🐸Coqui Studio voices - https://coqui.ai
Visit 🔗https://app.coqui.ai/account to get one.
Set it as an environment variable `export COQUI_STUDIO_TOKEN=`


Name format: type/language/dataset/model
1: tts_models/multilingual/multi-dataset/xtts_v2 [already downloaded]
2: tts_models/multilingual/multi-dataset/xtts_v1.1 [already downloaded]
3: tts_models/multilingual/multi-dataset/your_tts
4: tts_models/multilingual/multi-dataset/bark [already downloaded]
5: tts_models/bg/cv/vits
6: tts_models/cs/cv/vits
7: tts_models/da/cv/vits
8: tts_models/et/cv/vits
9: tts_models/ga/cv/vits
10: tts_models/en/ek1/tacotron2
11: tts_models/en/ljspeech/tacotron2-DDC
12: tts_models/en/ljspeech/tacotron2-DDC_ph
13: tts_models/en/ljspeech/glow-tts
14: tts_models/en/ljspeech/speedy-speech
15: tts_models/en/ljspeech/tacotron2-DCA
16: tts_models/en/ljspeech/vits
17: tts_models/en/ljspeech/vits--neon
18: tts_models/en/ljspeech/fast_pitch
19: tts_models/en/ljspeech/overflow
20: tts_models/en/ljspeech/neural_hmm
21: tts_models/en/vctk/vits
22: tts_models/en/vctk/fast_pitch
23: tts_models/en/sam/tacotron-DDC
24: tts_models/en/blizzard2013/capacitron-t2-c50
25: tts_models/en/blizzard2013/capacitron-t2-c150_v2
26: tts_models/en/multi-dataset/tortoise-v2
27: tts_models/en/jenny/jenny
28: tts_models/es/mai/tacotron2-DDC [already downloaded]
29: tts_models/es/css10/vits [already downloaded]
30: tts_models/fr/mai/tacotron2-DDC
31: tts_models/fr/css10/vits
32: tts_models/uk/mai/glow-tts
33: tts_models/uk/mai/vits
34: tts_models/zh-CN/baker/tacotron2-DDC-GST
35: tts_models/nl/mai/tacotron2-DDC
36: tts_models/nl/css10/vits
37: tts_models/de/thorsten/tacotron2-DCA
38: tts_models/de/thorsten/vits
39: tts_models/de/thorsten/tacotron2-DDC
40: tts_models/de/css10/vits-neon
41: tts_models/ja/kokoro/tacotron2-DDC
42: tts_models/tr/common-voice/glow-tts
43: tts_models/it/mai_female/glow-tts
44: tts_models/it/mai_female/vits
45: tts_models/it/mai_male/glow-tts
46: tts_models/it/mai_male/vits
47: tts_models/ewe/openbible/vits
48: tts_models/hau/openbible/vits
49: tts_models/lin/openbible/vits
50: tts_models/tw_akuapem/openbible/vits
51: tts_models/tw_asante/openbible/vits
52: tts_models/yor/openbible/vits
53: tts_models/hu/css10/vits
54: tts_models/el/cv/vits
55: tts_models/fi/css10/vits
56: tts_models/hr/cv/vits
57: tts_models/lt/cv/vits
58: tts_models/lv/cv/vits
59: tts_models/mt/cv/vits
60: tts_models/pl/mai_female/vits
61: tts_models/pt/cv/vits
62: tts_models/ro/cv/vits
63: tts_models/sk/cv/vits
64: tts_models/sl/cv/vits
65: tts_models/sv/cv/vits
66: tts_models/ca/custom/vits
67: tts_models/fa/custom/glow-tts
68: tts_models/bn/custom/vits-male
69: tts_models/bn/custom/vits-female
70: tts_models/be/common-voice/glow-tts

Name format: type/language/dataset/model
1: vocoder_models/universal/libri-tts/wavegrad
2: vocoder_models/universal/libri-tts/fullband-melgan [already downloaded]
3: vocoder_models/en/ek1/wavegrad
4: vocoder_models/en/ljspeech/multiband-melgan
5: vocoder_models/en/ljspeech/hifigan_v2
6: vocoder_models/en/ljspeech/univnet
7: vocoder_models/en/blizzard2013/hifigan_v2
8: vocoder_models/en/vctk/hifigan_v2
9: vocoder_models/en/sam/hifigan_v2
10: vocoder_models/nl/mai/parallel-wavegan
11: vocoder_models/de/thorsten/wavegrad
12: vocoder_models/de/thorsten/fullband-melgan
13: vocoder_models/de/thorsten/hifigan_v1
14: vocoder_models/ja/kokoro/hifigan_v1
15: vocoder_models/uk/mai/multiband-melgan
16: vocoder_models/tr/common-voice/hifigan
17: vocoder_models/be/common-voice/hifigan
Name format: type/language/dataset/model
1: voice_conversion_models/multilingual/vctk/freevc24 [already downloaded]

O fíltralo según tu idioma con grep, por ejemplo para español:

tts --list_models | grep "/es"

28: tts_models/es/mai/tacotron2-DDC [already downloaded]
29: tts_models/es/css10/vits [already downloaded]

Texto a voz

Con esto ya puedes generar voz a partir de texto en cuestión de segundos y en el idioma que prefieras.

En el terminal, escribe lo siguiente, especificando el modelo adecuado:

tts --text "Ahora puedo hablar en español!" --model_name "tts_models/es/css10/vits" --out_path output/tts-es.wav

Asegúrate de que el directorio de salida existe, y de que eliges el nombre dle modelo correto. La primera vez se descargarán los archivos necesarios y deberás aceptar la licencia de Coqui-AI. Después la generación se realiza en cuestión de segundos:

Clonación de voz

Por último, lo realmente impresionante de este modelo es la clonación de voz a partir de unos pocos segundos de grabación de audio.

Igual que en el post anterior, yo he tomado unos 30 segundos de la voz de Ultrón de escenas de la película Los Vengadores: la era de Ultrón.

Muestra en español:

Muestra en inglés:

Ahora, preparamos un script de python donde parametrizaremos todo lo necesario, que a grandes rasgos hará lo siguiente:

  • Importar torch y TTS
    import torch
    from TTS.api import TTS
  • Definir dispositivo de memoria (cuda o cpu). Con usar cpu sobra. Cuda puede petar.
    device="cpu"
  • Definir el texto a generar.
    txt="Voz generada a partir de texto"
  • Definir la muestra de audio de referencia (archivos .wav de unos 30 segundos)
    sample="/voice-folder/voice.wav"
  • Llamada al modelo TTS
    tts1=TTS("model_name").to(device)
  • Creación del fichero
    tts1.tts_to_file(txt, speaker_wav=sample, language="es", file_path="output-folder/output-file.wav")

Yo lo he llamado TRW-clone.py y queda así:

import torch
from TTS.api import TTS

# Get device ('cuda' or 'cpu')
device="cpu"

#Define text
txt="Bienvenido a este nuevo artículo del blog. Disfruta de tu visita."
#txt="Welcome to this new block post... Enjoy your visit!"

#Define audio sample
sample="../my-voices/ultron-es/mix.wav"
#sample="../my-voices/ultron-en/mix.wav"

#Run cloning
tts1 = TTS("tts_models/multilingual/multi-dataset/xtts_v2").to(device)

tts1.tts_to_file(txt, speaker_wav=sample, language="es", file_path="../output/ultron-es.wav")

Ejecútalo desde la carpeta TTS donde se encuentra el repositorio completo:

cd TTS
python3 TRW-clone.py

Resultados

Aquí te dejo los resultados obtenidos en mis primeras pruebas.

Español:

Inglés:

Con un par de iteraciones podrás obtener resultados realmente espectaculares.

Cualquier duda o comentario aún la puedes dejar en Twitter/X

🐦 @RoamingWorkshop

🐢TorToiSe-TTS: generación de voz a partir de texto con IA

La moda de la IA va para largo, y hoy se habla mucho de Vall-E y su futura combinación con GPT-3. Pero hay que recordar que todos estos productos de Inteligencia Artificial provienen de investigaciones colaborativas que han sido de código abierto, por lo que siempre encontraremos un equivalente de software libre, y deberíamos estar agradecidos por ello.

Es el caso de TorToiSe-TTS (text to speech), un generador de voz a partir de texto mediante IA totalmente gratuito para usar en tu ordenador.

https://github.com/neonbjb/tortoise-tts

Aquí te dejo un anticipo de la voz de Morgan Freeman:

Instalación

Lo más fácil es usar el script en la nube de Google Collab que ha habilitado su desarrollador:

https://colab.research.google.com/drive/1wVVqUPqwiDBUVeWWOUNglpGhU3hg_cbR?usp=sharing

Solo tendremos que iniciar sesión e ir dándole al "play" ▶ para ejecutar cada bloque de código.

Pero seguro que quieres ejecutar TorToiSe-TTS de forma local, sin necesidad de internet, y guardar los audios en tu disco duro, así que seguimos.

Instalar python3

Como muchas aplicaciones de IA, TorToiSe-TTS se ejecuta en python, por lo que debes instalar python3 en tu ordenador. Ya sabes que yo siempre recomiendo el uso de Linux, pero podrás ejecutarlo también en un terminal de Windows.

https://www.python.org/downloads/

En Linux podrás instalarlo desde el repositorio de tu distribución:

sudo apt-get update
sudo apt-get install python3.11

Y también necesitarás el módulo venv para virtualizar un entorno de python (en Windows suele venir con el instalador):

sudo apt-get install python3.11-venv

Descargar repositorio

Deberás descargar el repositorio oficial:

https://github.com/neonbjb/tortoise-tts

Bien como archivo comprimido:

O usando git:

git clone https://github.com/neonbjb/tortoise-tts

También puedes descargar mi repositorio, donde añado instrucciones más detalladas, un lanzador de interfaz en terminal y las voces de prueba de Ultrón (si, el androide maligno de Tony Stark) que verás más abajo.

https://github.com/TheRoam/tortoise-tts-linuxLauncher

Crear entorno virtual de python

A continuación tendremos que instalar una serie de módulos necesarios para arrancar TorToiSe-TTS, pero antes vamos a crear una versión virtual de python, para que la instalación de esos módulos no afecte al resto de la instalación de python. Verás que al final esto es muy útil cuando utilizas diferentes apps de IA que utilizan distintas versiones de cada módulo.

En un terminal escribimos lo siguiente, de forma que creamos el entorno "TTS":

cd tortoise-tts
python3 -m venv TTS

Y lo activamos así:

source TTS/bin/activate

Ahora verás que tu terminal hace referencia al entorno TTS:

(TTS) abc@123:~$ |

Instalar módulos de python

Vamos a instalar los módulos de python necesarios, siguiendo las indicaciones del collab:

https://colab.research.google.com/drive/1wVVqUPqwiDBUVeWWOUNglpGhU3hg_cbR?usp=sharing#scrollTo=Gen09NM4hONQ

pip3 install -U scipy
pip3 install transformers==4.19.0
pip3 install -r requirements.txt
python3 setup.py install

Con esto podemos probar a ejecutar TorToiSe-TTS, pero te adelantó que fallarán algunas librerías, dependiendo de tu instalación de python:

python3 scripts/tortoise_tts.py "This is The Roaming Workshop" -v "daniel" -p "fast" -o "test1.wav"

Probamos el comando anterior hasta que no falle. En mi caso he tenido que añadir los siguientes módulos:

pip3 install torch
pip3 install torchaudio
pip3 install llvmlite
pip3 install numpy==1.23

Y listo, ese test1.wav suena así en la voz de daniel (que resulta ser Daniel Craig):

Uso de TorToiSe-TTS

El programa más sencillo de TorToiSe-TTS se encuentra en la carpeta scripts/tortoise_tts.py y estos son sus principales argumentos:

python3 scripts/tortoise_tts.py "texto" -v "voz" -V "ruta/a/carpeta/de/voces" --seed semilla -p "fast" -o "fichero-de-salida.wav" 
  • "texto": cadena de texto que se convertirá en voz
  • -v: voz a utilizar para convertir el texto. Debe ser el nombre de una de las carpetas disponibles en /tortoise/voices/
  • -V: especifica una carpeta para las voces, para el caso de usar una personalizada. Podemos crear nuevas carpetas en /tortoise/voices/
  • --seed: semilla para caracterizar el algoritmo (cualquier número vale)
  • -p: modo predefinido para determinar la calidad ("ultra_fast", "fast", "standard", "high_quality").
  • -o: ruta y nombre del fichero de salida. Se debe especificar el formato del archivo, que será .wav

Si usas el script de mi repositorio TTS.sh se te pedirán estos argumentos por pantalla y se ejecutará el algoritmo automáticamente.

Añade tus propias voces

Puedes añadir más voces a TurToiSe-TTS. Yo por ejemplo he querido añadir la voz de Ultrón, el supervillano de Marvel, siguiendo las indicaciones del desarrollador Neonbjb:

  • Debes recopilar unas 3 grabaciones "limpias" (sin ruidos de fondo ni música, preferiblemente) de unos 10 segundos de duración.
  • El formato debe ser WAV de 16bits de coma flotante con 22500 de frecuencia de muestreo (puedes usar Audacity)
  • Crea una nueva carpeta en la ruta /tortoise/voices (o realmente donde quieras) y guarda ahí las grabaciones.
  • Al ejecutar TorToiSe-TTS, deberás indicar la ruta de la carpeta de voces con el argumento -V y la nueva voz con el argumento -v

Por ejemplo, para usar mis grabaciones de Ultrón:

python3 sripts/tortoise_tts.py "This is The Roaming Workshop" -V "./tortoise/voices" -v "ultron-en" -p "fast" --seed 17 -o "./wavs/TRW_ultron3.wav"

Que suena así:

Yo he tomado recortes de una escena de Vengadores: la era de Ultrón, tanto en inglés (ultron-en) como en español (ultron-es) que puedes descargar de mi repositorio.

"Ultron supervillain" by Optimised Stable Diffusion + Upscayl 2. The Roaming Workshop 2023.

Por ahora el modelo de TorToiSe-TTS está entrenado solo en inglés, por lo que solo funciona adecuadamente en este idioma.

Puedes introducir texto en otro idioma, y la IA intentará leerlo, aunque usará la pronunciación que ha aprendido del inglés y sonará bastante extraño.

Si te animas a entrenar un modelo para tu idioma (necesitas mucha GPU y varios meses), contacta con el desarrollador, ya que tiene bastante interés en ampliar el proyecto.

Mientras tanto, puedes dejar tus dudas y comentarion en 🐦 Twitter o 🐤 Koo!

🐦 @RoamingWorkshop

🐤 @TheRoamingWorkshop

Dalle-playground: un servidor local de Dall·E para PCs con pocos recursos

La generación de imágenes mediante IA tiene un alto coste computacional. Que no te engañe la velocidad de la API de Dall·E 2 que vimos en este otro post; si estos servicios habitualmente son de pago es por algo y, fuera de los servicios online que ya vimos, ejecutar IA en tu ordenador no es tan sencillo.

Después de probar, en vano, algunas alternativas open-source como Pixray o Dalle-Flow, finalmente te traigo la más simple de todas: dalle-playground. Esta es una versión primeriza de Dalle, por lo que no se obtienen los mejores resultados.

Aun así, pronto traeré una alternativa a Dall·E (Stable Diffusion de stability.ai), que también cuenta con una versión optimizada por la comunidad para PCs con pocos recursos.

Requisitos

"Computer hardware elements" by dalle-playground

Hardware

Para que te hagas una idea, Pixray recomienda mínimo 16GB de VRAM y Dalle-Flow 21GB. VRAM o virtual RAM es la memoria de acceso rápido que tiene tu tarjeta gráfica (no confundir con la memoria RAM de toda la vida).

Un portátil estándar como el mío tiene una Nvidia GeForce GTX1050Ti con 3GB de VRAM dedicada, más luego 8GB de RAM en placa.

Con este requisito mínimo, y un poco de paciencia, podrás ejecutar Dalle-playground localmente en tu PC, aunque también requiere una conexión a internet para comprobar que los módulos python y el punto de control de la IA están actualizados.

Si tienes alguna o varias gráficas más potentes yo te recomiendo probar Pixray, ya que se instala relativamente fácil y está muy extendido y documentado.

https://github.com/pixray/pixray#usage

Software

Los requisitos de software tampoco son triviales. Principalmente necesitarás python y Node.js. Yo enseñaré los pasos principales de Linux, que tiene mucha más flexibilidad a la hora de instalar todo tipo de paquetes de este tipo, pero es igualmente válido para Windows o Mac si te manejas con la terminal o usando docker.

Descarga dalle-playground

Casualmente descubrí este repositorio antes de que fuese actualizado a Stable Diffusion V2 (allá por noviembre de 2022) y tuve la perspicacia de clonarlo.

Accede y descarga todo el repositorio desde mi github:

https://github.com/TheRoam/dalle-playground-DalleMINI-localLinux

Opcionalmente, puedes descargar el repositorio original, aunque Stable Diffusion V2 requiere bastante más VRAM:

https://github.com/saharmor/dalle-playground/

Si usas git puedes clonarlo directamente a un directorio desde el terminal con:

git clone https://github.com/TheRoam/dalle-playground-DalleMINI-localLinux

Yo renombré el directorio simplemente a dalle-playground.

Instala python3 y los módulos requeridos

Todo el algoritmo trabaja con python en un backend. En el repositorio solo se menciona el uso de python3, por lo que asumo que versiones anteriores no funcionarán. Comprueba tu versión de python con:

>> python3 -V
Python 3.10.6

O instálalo, si no lo tienes, de su fuente oficial (creo que ya vamos por python 3.11, así que comprueba cuál es la última disponible para tu sistema operativo):

https://www.python.org/downloads/

O de tu repositorio de Linux:

sudo apt-get install python3.10

También necesitarás el módulo venv para virtualizar el entorno de trabajo de dalle-playground y no alterar toda tu instalación de python (lo siguiente es para Linux, en Windows viene incluído en su instalador):

sudo apt-get install python3.10-venv

En la carpeta de backend, crea un entorno virtual de python, que yo llamaré dalleP:

cd dalle-playground/backend
python3 -m venv dalleP

Ahora, activa este entorno virtual (verás que aparece el nombre al inicio de la línea del terminal):

(dalleP) abc@123: ~dalle-playground/backend$

Instala el resto de módulos de python que requiere dalle-playground y que se indican en el fichero dalle-playground/backend/requirements.txt

pip3 install -r requirements.txt

Aparte, si no lo tienes ya, necesitarás pyTorch:

pip3 intall torch

Instala npm

Node.js ejecutará un servidor web local que servirá de app. Instálalo de la fuente oficial:

https://nodejs.org/en/download/

O de tu repositorio de Linux:

sudo apt-get install npm

Ahora ve a la carpeta del frontend dalle-playground/interface e instala los módulos necesarios de Node.js :

cd dalle-playground/interface
npm install

Lanzar el backend

Con todo instalado lanzamos los servidores, empezando por el backend.

Primero activamos el entorno virtual de python3 en la carpeta dalle-playground/backend (si acabas de instalarlo, lo tendrás ya activado del paso anterior)

cd dalle-playground/backend
source dalleP/bin/activate

Lanzamos la aplicación de backend:

python3 app.py --port 8080 --model_version mini

El backend tardará varios minutos en arrancar (de 2 a 5 min). Esperamos a que salga un mensaje como el siguiente y nos fijamos en las direcciones IP que nos aparecen al final:

--> DALL-E Server is up and running!
--> Model selected - DALL-E ModelSize.MINI
 * Serving Flask app 'app' (lazy loading)
 * Environment: production
   WARNING: This is a development server. Do not use it in a production deployment.
   Use a production WSGI server instead.
 * Debug mode: off
INFO:werkzeug:WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead.
 * Running on all addresses (0.0.0.0)
 * Running on http://127.0.0.1:8080
 * Running on http://192.168.1.XX:8080

Lanzar frontend

Ahora lanzamos el servidor web local de Node.js, para lo que ejecutamos una nueva terminal:

cd dalle-playground/interfaces
npm start

En cuanto acabe, se abrirá un navegador web y nos mostrará el menú gráfico de la aplicación.

Lanzador automático

En Linux puedes usar mi script launch.sh que lanza backend y frontend automáticamente siguiendo los pasos de arriba. Solo siéntate a esperar a que cargue.

launch.sh

#!/bin/bash
#Launcher for dalle-playground in Linux terminal

#Launchs backend and frontend scripts in one go
$(bash ./frontend.sh && bash ./backend.sh &)

#Both scripts will run in one terminal.
#Close this terminal to stop the programm.

backend.sh

#!/bin/bash
#Backend launcher for dalle-playground in Linux terminal

#move to backend folder
echo "------ MOVING TO BACKEND FOLDER ------"
cd ./backend

#set python virtual environment
echo "------ SETTING UP PYTHON VIRTUAL ENVIRONMENT ------"
python3 -m venv dalleP
source dalleP/bin/activate

#launch backend
echo "------ LAUNCHING DALLE-PLAYGROUND BACKEND ------"
python3 app.py --port 8080 --model_version mini &

frontend.sh

#!/bin/bash
#Frontend launcher for dalle-playground in Linux terminal

#move to frontend folder
echo "------ MOVING TO FRONTEND FOLDER ------"
cd ./interface

#launch frontend
echo "------ LAUNCHING DALLE-PLAYGROUND FRONTEND ------"
npm start &

App dalle-playground

En el primer campo introduciremos la dirección IP del servidor de backend que vimos anteriormente. Si accedes desde el mismo PC puedes usar la primera:

http://127.0.0.1:8080

Pero puedes acceder desde otro dispositivo de tu red local mediante la segunda:

http://192.168.1.XX:8080

Ahora introducimos la descripción de la imagen a generar en el segundo campo, y por último definimos el número de imágenes que queremos que se generen (a mayor número, más tiempo tardará).

Pulsamos [enter] y esperamos a que se genere la imagen (sobre 5 minutos por imagen).

Y aquí está nuestra primera imagen generada por IA en nuestro ordenador. Yo os dejo una pequeña galería de resultados. Y en el próxmo post veremos cómo obtener mejores resultados mediante Stable Diffusion, también usando menos de 4GB de VRAM.

Ya sabes que espero tus dudas y comentarios en 🐦 Twitter!

🐦 @RoamingWorkshop

Galería: Dalle-playground

Nota: imágenes originales de 256x256 píxeles, ampliadas con Upscayl.

Dall·E 2 Beta: generación de imágenes mediante inteligencia artificial (IA)

Tenía esto en el tintero desde hace tiempo, y es que a raíz de algunos Tweets y del proyecto GOIA de Iker Jiménez, me parecía que la generación de imágenes mediante IA se había vuelto bastante accesible. Y lo es. Se avanza a pasos de gigante. Pero todo tiene un precio.

La generación de imágenes de OpenAI, uno de los gigantes de Elon Musk, bautizada como Dall·E, lanzó su API abierta para que todo el mundo la pruebe.

Tienes 18$ para usar durante 3 meses solo con registrarte. El resto hay que pasarlo por caja, pero te dará para bastantes pruebas, y luego solo cuesta 0.02$ la imagen. Además es bastante fácil de usar y los resultados son geniales.

Merece la pena probarlo para saber cuál es el top y al final os diré qué podemos usar el resto de los mortales para el día a día.

Pero antes… arrancamos con una imagen del volcán Teide en Tenerife. ¿Es real o es virtual?

Foto del Teide, Tenerife, creada con Dall·E 2 de OpenAI. The Roaming Workshop 2022.

OpenAI API

Bueno, rápidamente, OpenAI es el megaproyecto de Inteligencia Artificial (IA) de Elon Musk & Co. Dentro de las muchas capacidades de estas redes neuronales virtuales está la generación de imágenes a partir de un texto en lenguaje natural, pero hay mucho más.

La IA va a facilitar muchas cosas en el futuro, así que échale un vistazo a todos los ejemplos que hay abiertos en sus pruebas Beta:

https://beta.openai.com/examples/

Básicamente se "entrena" a un ordenador con ejemplos reales bien caracterizados para que, a partir de ellos, pueda generar contenido nuevo siguiendo una petición.

La máquina no va a generar lo que tú quieres o piensas, algo esperable, sino que a partir de tu orden y su aprendizaje, generará un resultado propio.

La generación de imágenes a partir del lenguaje natural es quizás la aplicación más gráfica, pero el potencial es inimaginable. Arriba simplemente le pedí a Dall·E la palabra "Teide". Pero, ¿qué pasa si nos planteamos cosas que no han ocurrido, que no hemos visto, o simples elucubraciones? Pues que la IA es capaz de darle vida a nuestro pensamiento. Lo que imaginamos en nuestra mente se traslada a la pantalla.

Pero bueno basta de rollo filosófico y vamos al grano.

Dall·E 2 API

Para "vendernos" el futuro, OpenAI nos lo ha puesto muy fácil. Disponemos de muchísima documentación para curiosear una versión de pruebas Beta completamente abierta durante tres meses, y solo tendremos que darles nuestro correo electrónico.

Regístrate para usar Dall·E 2 a través de su página web, pulsando el botón de Sign Up.

https://openai.com/dall-e-2/

Tendrás que verificar tu correo electrónico y ya podrás entrar a tu cuenta. Cuidado por que te puede redirigir a la página comercial https://labs.openai.com

La versión de prueba es esta:

https://beta.openai.com

Crear API key

Desde el menú superior, pinchamos sobre nuestro perfil y seleccionamos View API keys.

Como acabamos de registrarnos, tendremos que generar una y copiarla en algún sitio, ya que será necesaria para el uso de la API.

Uso de Dall·E 2

Y ya está. No hay más requisitos. ¡A jugar!

Vamos a ver cómo generar una imagen según su documentación:

https://beta.openai.com/docs/api-reference/images/create

Para no liarnos, podemos usar curl, para lo que necesitas abrir un terminal, ya sea de Window, MacOS o Linux. El código que nos indican es este:

curl https://api.openai.com/v1/images/generations \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_API_KEY' \
  -d '{
  "prompt": "A cute baby sea otter",
  "n": 2,
  "size": "1024x1024"
}'

Donde deberemos introducir nuestra clave secreta en lugar de YOUR_API_KEY.

También indicaremos en prompt la descripción de la imagen que queremos.

Con n definimos el número de imágenes a generar con esta orden.

Y size es el tamaño de la imagen, estando disponibles 256x256, 512x512, o 1024x1024.

Yo voy a probar con "un mapa de Marte en papel".

curl https://api.openai.com/v1/images/generations -H "Content-Type: application/json" -H "Authorization: Bearer sk-TuApiKeyAqui" -d "{\"prompt\":\"A map of Mars in paper\",\"n\":1,\"size\":\"1024x1024\"}"

TIP! Copia y pega este código en tu terminal, cambiando tu clave secreta "sk-..." y el prompt.

Obtendrás una URL como respuesta al comando, que es un enlace web a la imagen generada.

Abre el enlace para ver el resultado:

"Un mapa de Marte en papel" con OpenAI. The Roaming WorkShop 2022.

¡Impresionante!

Tarifas

Bueno, bueno... Volvamos ahora a la Tierra. No pensarás que esta rapidez y esta calidad van a ser gratis, ¿verdad? Si vuelves a tu cuenta de OpenAI, podrás ver el uso que haces de la API y cómo vas gastando tu crédito.

https://beta.openai.com/account/usage

Como decía anteriormente, la Beta ofrece 18$ para gastar durante 3 meses y cada imagen a 1024px sale a unos 0,065$.

Todas las grandes plataformas de este estilo (Midjourney, Nightcafe, DreamAI, etc) funcionan de esta manera, a base de crédito por uso, y es que los procesadores que generan estas imágenes tan espectaculares son muy potentes.

Alternativas (gratuitas)

Hay varias alternativas de código abierto y totalmente gratuitas. Yo te invito a probarlas todas y elegir la que más te guste, pero te advierto que los requisitos de software y hardware son muchos; sobre todo necesitas una buena, o incluso varias, tarjetas gráficas. Al fin y al cabo pon en la balanza cuánto vas a usar la IA, y si no te merece más la pena pagar unos pocos céntimos por 4 imágenes de alta calidad cada par de meses.

De las 4 recomendaciones que te voy a hacer solo he probado con éxito las dos últimas y más flojas:

1. Pixray

https://github.com/pixray/pixray

Se presenta prometedor por la simplicidad de la instalación y del uso. Aunque no te fies de la imagen de arriba (es su módulo de pixelado) porque cuenta con complejas opciones de generación de imágenes detalladas.

Existe además buena documentación hecha por los usuarios y con soporte en Discord.

Por otro lado, recomiendan unos 16GB de VRAM (RAM virtual de la GPU de tu tarjeta gráfica). A mi me petó por falta de memoria sin poder ver el resultado...

2. Dalle-Flow

https://github.com/jina-ai/dalle-flow#Client

Muy técnico y complicado. Los resultados parecen brillantes, pero no he pasado de la instalación. Usa varios paquetes muy específicos de python que supuestamente se ejecutan en Google Colab. O no tiene continuidad y está roto, o la documentación es mala o yo soy un auténtico inútil... Además recomiendan unos 21GB de VRAM aunque por lo visto mediante Colab se puede repartir esta carga... nunca lo pude comprobar.

3. Craiyon

https://www.craiyon.com/

El antiguo Dalle-mini creado por Boris Dayma tiene una práctica versión web totalmente gratuita (sin crédito ni pagos, solo algún que otro anuncio).

Aunque sus resultados no son brillantes de inicio, luego los podremos mejorar con Upscayl (ya te hablaré de él).

4. Dalle-playground

https://github.com/saharmor/dalle-playground/

Uno de los muchos repositorios derivados de dalle-mini, en este caso en un práctico paquete que podremos usar libremente y de forma gratuita en nuestro PC de casa con muy pocos requisitos de hardware o software. Se ejecuta como una webapp local en tu navegador generando un servidor para que puedas acceder desde cualquier parte de tu red.

Junto con Upscayl, hacen un buen tándem para generar imágenes de IA en tu propio PC de forma gratuita.

Galería: Dall·E 2

Galería: Dalle-playground+Upscayl preview

En el próximo artículo veremos cómo generar estás imágenes en un PC ordinario, con Dalle-playground y Upscayl.

Esto es todo por ahora! Cualquier duda o comentario sobre este post de Dall·E te espero en 🐦 Twitter!

🐦 @RoamingWorkshop