Generación de imágenes con IA utilizando OpenAI DALL·E 3 en Java

1. Visión general

La inteligencia artificial está cambiando la forma en que construimos aplicaciones web. Una aplicación emocionante de la IA es generar una imagen a partir de una descripción basada en texto. DALL·E 3 de OpenAI es un modelo popular de texto a imagen que nos ayuda a lograrlo.

En este tutorial, exploraremos cómo generar imágenes con el modelo DALL·E 3 de OpenAI utilizando Spring AI.

Para seguir este tutorial, necesitaremos una clave de API de OpenAI.

2. Configuración del Proyecto

Antes de poder comenzar a generar imágenes de IA, necesitaremos incluir una dependencia Spring Boot starter y configurar correctamente nuestra aplicación.

2.1. Dependencias

Comencemos añadiendo la dependencia spring-ai-openai-spring-boot-starter al archivo pom.xml de nuestro proyecto:

<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-openai-spring-boot-starter</artifactId>
    <version>1.0.0-M3</version>
</dependency>

Dado que la versión actual, 1.0.0-M3, es una versión de hito, también necesitaremos añadir el repositorio Spring Milestones a nuestro pom.xml:

<repositories>
    <repository>
        <id>spring-milestones</id>
        <name>Spring Milestones</name>
        <url>https://repo.spring.io/milestone</url>
        <snapshots>
            <enabled>false</enabled>
        </snapshots>
    </repository>
</repositories>

Este repositorio es donde se publican las versiones de hito, en lugar del repositorio estándar de Maven Central.

La dependencia del iniciador anterior nos proporciona las clases necesarias para interactuar con el servicio de OpenAI desde nuestra aplicación y generar imágenes de IA utilizando su modelo DALL·E 3.

2.2. Configuración de una clave API de OpenAI

Ahora, para interactuar con el servicio de OpenAI, necesitamos configurar nuestra clave API en el archivo application.yaml:

spring:
  ai:
    openai:
      api-key: ${OPENAI_API_KEY}

Usamos el marcador de posición de propiedad ${} para cargar el valor de nuestra propiedad desde una variable de entorno.

Al configurar una clave API válida, Spring AI creará automáticamente un bean ImageModel para nosotros. Lo inyectaremos en nuestra capa de servicio y enviaremos solicitudes para generar imágenes de IA.

2.3. Configuración de las Opciones de Imagen Predeterminadas

A continuación, también configuraremos algunas opciones de imagen predeterminadas que se utilizarán para generar nuestras imágenes:

spring:
  ai:
    openai:
      image:
        options:
          model: dall-e-3
          size: 1024x1024
          style: vivid
          quality: standard
          response-format: url

Primero configuramos dall-e-3 como el modelo que utilizaremos para la generación de imágenes.

Para obtener una imagen cuadrada perfecta, especificamos 1024×1024 como el tamaño. Las otras 2 opciones de tamaño permitidas son 1792×1024 y 1024×1792.

A continuación, establecemos el estilo como vivid — eso indica al modelo de IA que genere imágenes hiperrealistas y dramáticas. La otra opción disponible es natural, que podemos usar para generar imágenes más naturales y menos hiperrealistas.

Para la opción quality, la configuramos a standard, lo cual funciona para la mayoría de los casos de uso. Sin embargo, si necesitamos imágenes con detalles mejorados y mayor consistencia, podemos establecer el valor a hd. Cabe señalar que las imágenes de calidad hd tardarán más tiempo en generarse.

Finalmente, establecemos la opción response-format a url. La imagen generada será accesible mediante una URL válida por 60 minutos. Alternativamente, podemos establecer su valor a b64_json para recibir la imagen como una cadena Base64-encoded.

Veremos cómo anular estas opciones de imagen predeterminadas más adelante en el tutorial.

3. Generación de Imágenes de IA con DALL·E 3

Ahora que hemos configurado nuestra aplicación, creemos una clase ImageGenerator. Inyectaremos el bean ImageModel y lo utilizaremos para generar imágenes de IA:

public String generate(String prompt) {
    ImagePrompt imagePrompt = new ImagePrompt(prompt);
    ImageResponse imageResponse = imageModel.call(imagePrompt);
    return resolveImageContent(imageResponse);
}

private String resolveImageContent(ImageResponse imageResponse) {
    Image image = imageResponse.getResult().getOutput();
    return Optional
      .ofNullable(image.getUrl())
      .orElseGet(image::getB64Json);
}

Aquí, creamos un método generate() que recibe un String prompt, representando la descripción textual de la imagen que deseamos generar.

A continuación, creamos un objeto ImagePrompt con nuestro parámetro prompt. Luego, lo pasamos al método call() de nuestro bean ImageModel para enviar la solicitud de generación de imagen.

La imageResponse contendrá ya sea una URL o una representación String Base64-encoded de la imagen, dependiendo de la opción response-format que configuramos anteriormente en nuestro archivo application.yaml. Para resolver la propiedad de salida correcta, creamos un método auxiliar resolveImageContent() y lo devolvemos como respuesta.

4. Anulación de las Opciones de Imagen Predeterminadas

En algunos casos, es posible que deseemos anular las opciones de imagen predeterminadas que configuramos en nuestro archivo application.yaml.

Echemos un vistazo a cómo podemos hacer esto sobrecargando nuestro método generate():

public String generate(ImageGenerationRequest request) {
    ImageOptions imageOptions = OpenAiImageOptions
      .builder()
      .withUser(request.username())
      .withHeight(request.height())
      .withWidth(request.width())
      .build();
    ImagePrompt imagePrompt = new ImagePrompt(request.prompt(), imageOptions);
    
    ImageResponse imageResponse = imageModel.call(imagePrompt);
    return resolveImageContent(imageResponse);
}

record ImageGenerationRequest(
    String prompt,
    String username,
    Integer height,
    Integer width
) {}

Primero creamos un registro ImageGenerationRequest, que, además de contener nuestro prompt, incluye el nombre de usuario y la altura y anchura deseadas de la imagen.

Utilizamos estos valores adicionales para crear una instancia de ImageOptions y pasarla al constructor de ImagePrompt. Es importante señalar que la clase OpenAiImageOptions no tiene una propiedad size, por lo que proporcionamos los valores de altura y anchura por separado.

La opción user nos ayuda a vincular la solicitud de generación de imagen con un usuario final específico. Se recomienda como una práctica de seguridad para prevenir abusos.

Según sea necesario, también podemos anular otras opciones de imagen como style, quality y response-format en nuestro objeto ImageOptions.

5. Ponemos a Prueba Nuestra Clase ImageGenerator

Ahora que hemos implementado nuestra clase ImageGenerator, probémosla:

String prompt = """
    A cartoon depicting a gangster donkey wearing 
    sunglasses and eating grapes in a city street.
""";
String response = imageGenerator.generate(prompt);

Aquí, pasamos nuestro prompt al método generate() de ImageGenerator. Después de un breve tiempo de procesamiento, recibiremos una respuesta que contiene la URL o la cadena Base64-encoded de nuestra imagen generada, según la propiedad response-format configurada.

Echemos un vistazo a lo que DALL·E 3 generó para nosotros:

Como se puede ver, la imagen generada coincide con precisión con nuestro prompt. Esto demuestra el poder de DALL·E 3 para comprender descripciones en lenguaje natural y convertirlas en una imagen.

6. Conclusión

En este artículo, exploramos cómo generar imágenes de IA a partir de una descripción textual utilizando Spring AI. Utilizamos el modelo DALL·E 3 de OpenAI bajo el capó.

Revisamos las configuraciones necesarias y desarrollamos una clase de servicio para generar imágenes de IA. Además, examinamos las opciones de imagen predeterminadas y cómo anularlas dinámicamente.

Al integrar DALL·E 3 en nuestras aplicaciones Java a través de Spring AI, podemos agregar fácilmente capacidades de generación de imágenes sin la carga de entrenar y alojar nuestros propios modelos.