Comienza a usar la API de Prompt

En esta página, se describe cómo hacer lo siguiente:

  • Configurar tu proyecto para usar la API de Prompt
  • Proporcionar entrada de solo texto y recibir una respuesta
  • Proporcionar una entrada de imagen con una entrada de texto relacionada y recibir una respuesta

Para obtener más detalles sobre la API de Prompt, consulta la documentación de referencia para Kotlin (com.google.mlkit.genai.prompt) y Java (com.google.mlkit.genai.prompt.java, com.google.mlkit.genai.prompt).

Configurar proyecto

Agrega la API de Prompt de ML Kit como una dependencia en tu configuración de build.gradle:

implementation("com.google.mlkit:genai-prompt:1.0.0-beta2")

Implementar el modelo generativo

Para implementar el código en tu proyecto, sigue estos pasos:

  • Crea un objeto generativeModel:

    Kotlin

    // Get a GenerativeModel instance
val generativeModel = Generation.getClient()

    Java

    // Get a GenerativeModel instance
GenerativeModelFutures generativeModelFutures = GenerativeModelFutures
    .from(Generation.INSTANCE.getClient());

  • Verifica si Gemini Nano está AVAILABLE, DOWNLOADABLE o UNAVAILABLE. Luego, descarga la función si se puede descargar:

    Kotlin

    val status = generativeModel.checkStatus()
when (status) {
    FeatureStatus.UNAVAILABLE -> {
        // Gemini Nano not supported on this device or device hasn't fetched the latest configuration to support it
    }

    FeatureStatus.DOWNLOADABLE -> {
        // Gemini Nano can be downloaded on this device, but is not currently downloaded
        generativeModel.download().collect { status ->
            when (status) {
                is DownloadStatus.DownloadStarted ->
                    Log.d(TAG, "starting download for Gemini Nano")

                is DownloadStatus.DownloadProgress ->
                    Log.d(TAG, "Nano ${status.totalBytesDownloaded} bytes downloaded")

                DownloadStatus.DownloadCompleted -> {
                    Log.d(TAG, "Gemini Nano download complete")
                    modelDownloaded = true
                }

                is DownloadStatus.DownloadFailed -> {
                    Log.e(TAG, "Nano download failed ${status.e.message}")
                }
            }
        }
    }

    FeatureStatus.DOWNLOADING -> {
        // Gemini Nano currently being downloaded
    }

    FeatureStatus.AVAILABLE -> {
        // Gemini Nano currently downloaded and available to use on this device
    }
}

    Java

    ListenableFuture<Integer> status = generativeModelFutures.checkStatus();
Futures.addCallback(generativeModelFutures.checkStatus(), new FutureCallback<>() {
    @Override
    public void onSuccess(Integer featureStatus) {
        switch (featureStatus) {
            case FeatureStatus.AVAILABLE - > {
                // Gemini Nano currently downloaded and available to use on this device
            }
            case FeatureStatus.UNAVAILABLE - > {
                // Gemini Nano not supported on this device or device hasn't fetched the latest configuration to support it
            }
            case FeatureStatus.DOWNLOADING - > {
                // Gemini Nano currently being downloaded
            }
            case FeatureStatus.DOWNLOADABLE - > {
                generativeModelFutures.download(new DownloadCallback() {
                    @Override
                    public void onDownloadStarted(long l) {
                        Log.d(TAG, "starting download for Gemini Nano");
                    }
                    @Override
                    public void onDownloadProgress(long l) {
                        Log.d(TAG, "Nano " + l + " bytes downloaded");
                    }
                    @Override
                    public void onDownloadCompleted() {
                        Log.d(TAG, "Gemini Nano download complete");
                    }
                    @Override
                    public void onDownloadFailed(@NonNull GenAiException e) {
                        Log.e(TAG, "Nano download failed: " + e.getMessage());
                    }
                });
            }
        }
    }
    @Override
    public void onFailure(@NonNull Throwable t) {
        // Failed to check status
    }
}, ContextCompat.getMainExecutor(context));

Proporcionar entrada de solo texto

Kotlin

val response = generativeModel.generateContent("Write a 3 sentence story about a magical dog.")

Java

GenerateContentResponse response = generativeModelFutures.generateContent(
  new GenerateContentRequest.Builder(
    new TextPart("Write a 3 sentence story about a magical dog."))
  .build())
  .get();

Como alternativa, agrega parámetros opcionales:

Kotlin

val response = generativeModel.generateContent(
    generateContentRequest(
        TextPart("Write a 3 sentence story about a magical dog."),
    ) {
        // Optional parameters
        temperature = 0.2f
        topK = 10
        candidateCount = 3
    },
)

Java

GenerateContentRequest.Builder requestBuilder =
        new GenerateContentRequest.Builder(
                new TextPart("Write a 3 sentence story about a magical dog."));
requestBuilder.setTemperature(.2f);
requestBuilder.setTopK(10);
requestBuilder.setCandidateCount(3);

GenerateContentResponse response =
        generativeModelFutures.generateContent(requestBuilder.build()).get();

Para obtener más información sobre los parámetros opcionales, consulta Configuración opcional.

Proporcionar entrada multimodal (imagen y texto)

Agrupa una imagen y una entrada de texto en la función generateContentRequest(), con la instrucción de texto como una pregunta o un comando relacionado con la imagen:

Kotlin

val response = generativeModel.generateContent(
    generateContentRequest(ImagePart(bitmap), TextPart(textPrompt)) {
        // optional parameters
        ...
    },
)

Java

GenerateContentResponse response = generativeModelFutures.generateContent(
    new GenerateContentRequest.Builder(
        new ImagePart(bitmap),
        new TextPart("textPrompt"))
    // optional parameters
    .build())
.get();

Procesar el resultado de la inferencia

  • Ejecuta la inferencia y recupera el resultado. Puedes esperar el resultado completo o transmitir la respuesta a medida que se genera para las instrucciones de solo texto y multimodales.

    • Esto usa la inferencia sin transmisión, que recupera todo el resultado del modelo de IA antes de mostrarlo:

    Kotlin

    // Call the AI model to generate content and store the complete
// in a new variable named 'response' once it's finished
val response = generativeModel.generateContent("Write a 3 sentence story about a magical dog")

    Java

    GenerateContentResponse response = generativeModelFutures.generateContent(
        new GenerateContentRequest.Builder(
                new TextPart("Write a 3 sentence story about a magical dog."))
                .build())
        .get();

    • Los siguientes fragmentos son ejemplos del uso de la inferencia de transmisión, que recupera el resultado en fragmentos a medida que se genera:

    Kotlin

    // Streaming inference
var fullResponse = ""
generativeModel.generateContentStream("Write a 3 sentence story about a magical dog").collect { chunk ->
    val newChunkReceived = chunk.candidates[0].text
    print(newChunkReceived)
    fullResponse += newChunkReceived
}

    Java

    // Streaming inference
StringBuilder fullResponse = new StringBuilder();
generativeModelFutures.generateContent(new GenerateContentRequest.Builder(
    (new TextPart("Write a 3 sentence story about a magical dog"))).build(),
        chunk -> {
            Log.d(TAG, chunk);
            fullResponse.append(chunk);
        });

Para obtener más información sobre la inferencia de transmisión y sin transmisión, consulta Transmisión versus sin transmisión.

Optimización de latencia

Para optimizar la primera llamada de inferencia, tu aplicación puede llamar a warmup() de forma opcional. Esto carga Gemini Nano en la memoria y, luego, inicializa los componentes del tiempo de ejecución.

Configuración opcional

Como parte de cada GenerateContentRequest, puedes establecer los siguientes parámetros opcionales:

  • temperature : Controla el grado de aleatorización en la selección de tokens.
  • seed : Permite generar resultados estables y deterministas.
  • topK : Controla la aleatorización y la diversidad en los resultados.
  • candidateCount : Solicita la cantidad de respuestas únicas que se muestran. Ten en cuenta que la cantidad exacta de respuestas puede no ser la misma que candidateCount, ya que las respuestas duplicadas se quitan automáticamente.
  • maxOutputTokens : Define la cantidad máxima de tokens que se pueden generar en la respuesta.

Para obtener más orientación sobre cómo establecer configuraciones opcionales, consulta GenerateContentRequest.

Funciones y limitaciones admitidas

  • La entrada debe tener menos de 4,000 tokens (o aproximadamente 3,000 palabras en inglés). Para obtener más información, consulta la countTokens referencia.
  • Se deben evitar los casos de uso que requieren una salida larga (más de 256 tokens).
  • AICore aplica una cuota de inferencia por app. Para obtener más información, consulta Cuota por aplicación.
  • Se validaron los siguientes idiomas para la API de Prompt:
    • Inglés
    • Coreano

Problemas comunes de configuración

Las APIs de IA generativa de ML Kit dependen de la app de AICore de Android para acceder a Gemini Nano. Cuando se configura un dispositivo (incluido el restablecimiento) o se restablece la app de AICore (p.ej., borrar datos, desinstalar y volver a instalar), es posible que la app de AICore no tenga suficiente tiempo para finalizar la inicialización (incluida la descarga de las configuraciones más recientes del servidor). Como resultado, es posible que las APIs de IA generativa de ML Kit no funcionen según lo esperado. Estos son los mensajes de error de configuración comunes que puedes ver y cómo controlarlos:

Ejemplo de mensaje de error Cómo controlarlo
AICore failed with error type 4-CONNECTION_ERROR and error code 601-BINDING_FAILURE: AICore service failed to bind. Esto puede suceder cuando instalas la app con las APIs de IA generativa de ML Kit inmediatamente después de la configuración del dispositivo o cuando se desinstala AICore después de instalar la app. Actualizar la app de AICore y, luego, volver a instalar la app debería solucionar el problema.
AICore failed with error type 3-PREPARATION_ERROR and error code 606-FEATURE_NOT_FOUND: Feature ... is not available. Esto puede suceder cuando AICore no terminó de descargar las configuraciones más recientes. Cuando el dispositivo está conectado a Internet, suele tardar unos minutos o unas horas en actualizarse. Reiniciar el dispositivo puede acelerar la actualización.

Ten en cuenta que, si el bootloader del dispositivo está desbloqueado, también verás este error. Esta API no admite dispositivos con bootloaders desbloqueados.
AICore failed with error type 1-DOWNLOAD_ERROR and error code 0-UNKNOWN: Feature ... failed with failure status 0 and error esz: UNAVAILABLE: Unable to resolve host ... Mantén la conexión de red, espera unos minutos y vuelve a intentarlo.