Hace unos días hablé de Fue bien recibido y refrescante poder dar una charla donde las aplicaciones móviles pueden obtener una ventaja del aumento en el uso del modelo de idioma. Executar en dispositivos SLMs en aplicaciones Después de la charla, tuve algunos comentarios de los asistentes a lo largo de las líneas de “Sería bueno ver un ejemplo de una aplicación usando un SLM alimentado por RAG”. Estos son comentarios justos.Lo complicado aquí es el tiempo que tarda en configurar un modelo y mostrar algo significativo a los desarrolladores en un tiempo limitado. Si estás buscando pasos para agregar un modelo de lenguaje alimentado por RAG a tu aplicación Android, este es el post para ti! ¿Qué es RAG? Si no estás familiarizado con el término, RAG significa Es una técnica para que los modelos de idiomas accedan a información externa que no está disponible en su conjunto de datos después del entrenamiento. Esto permite que los modelos estén conscientes de la información actualizada que pueden usar para proporcionar respuestas más precisas a las solicitudes. Retrieval Augmented Generation Imagínese que tiene dos modelos de idiomas, uno de ellos está utilizando RAG para obtener información externa sobre las capitales de Europa, mientras que el otro se basa únicamente en su propio conocimiento. You are an expert on the geography of Europe. 

Give me the name of 3 capital cities.

Also give me an interesting fact for each of them.
 El resultado podría parecer algo así: Como muestra el diagrama, es más probable que obtenga una respuesta útil del modelo de lenguaje utilizando RAG, en lugar de que el modelo confíe en su propio conocimiento. ¡Eso es realmente todo lo que necesita saber sobre RAG a un alto nivel!Siguiente, vamos a profundizar y escribir algún código para habilitar su propio modelo de lenguaje alimentado por RAG dentro de su aplicación! Configurar tu aplicación Android Digamos que desea crear una aplicación usando un modelo de idioma para jugar el juego de Simon Says. desea que el modelo sea Simon, y utiliza RAG para acceder a una fuente de datos de tareas para ayudar a decidir qué pedir al usuario. La forma más sencilla de hacer esto en Android es con , una colección de herramientas para ayudar a su aplicación a utilizar técnicas de IA y aprendizaje automático. Para empezar, agrega la dependencia de MediaPipe a su aplicación : MediaPipé build.gradle dependencies {
  implementation("com.google.mediapipe:tasks-genai:0.10.27")
  implementation("com.google.ai.edge.localagents:localagents-rag:0.3.0")
}
 A continuación, debe agregar un modelo de idioma a su dispositivo de prueba a través de su ordenador. , un modelo de lenguaje ligero que contiene mil millones de parámetros valiosos de información. Gemma3 - 1B 
 
 Nota lateral: Antes de descargar el modelo, es posible que tenga que registrarse en Kaggle y aceptar los Términos y Condiciones de IA de Google. Side Note: Before downloading the model, you may have to sign upto Kaggle and agree to Google’s AI Terms and Conditions. Una vez descargado el modelo, es hora de agregar el modelo a su dispositivo. Puede hacerlo a través de adb: $ adb shell mkdir -p /data/local/tmp/slm/ # Create a folder to store the model
$ adb push output_path /data/local/tmp/slm/gemma3-1B-it-int4.task # Copy the model over to the file
 Alternativamente, puede utilizar el usando Android Studio para crear las carpetas usted mismo y arrastrar el modelo en su dispositivo. Archivo Explorer Con el modelo añadido, puede seguir construyendo la tubería RAG para alimentar a Gemma con información. Creación de Embeddings Los modelos de lenguaje de información que se basan en realizar RAG no son la misma información que se transmite a ella. . Embeddings Estas son cadenas matemáticas que representan el significado semántico del texto.Cuando el modelo recibe un prompt, lo utilizará para buscar la información más relevante que le corresponda y la utilizará junto a su propia información para proporcionar una respuesta. . Embedder Los embeddings son un tema entero por sí solos; te animamos a leer sobre ellos. Para este post, solo necesitas saber cómo crearlos. . Gecko Embedder En primer lugar, descarga el Tokenizer y el Embedder archivos de modelo a su ordenador. Después, presiona a su dispositivo: sentencepiece.model Gecko_256_f32.tflite $ adb push sentencepiece.model /data/local/tmp/slm/sentencepiece.model # Push the tokenizer to the device
$ adb push Gecko_256_f32.tflite /data/local/tmp/slm/Gecko_256_f32.tflite # Push the embedder model to the device
 Con el embedder instalado en su dispositivo, es hora de proporcionar un archivo de muestra para crear los embeddings desde. Crear un archivo llamado Luego, en el archivo, añade el siguiente texto: assets simon_says_responses.txt <chunk_splitter>
Go for a walk
<chunk_splitter>
Jump and down 10 times
<chunk_splitter>
Sing your favourite song!
<chunk_splitter>
Text your best friend a funny meme
<chunk_splitter>
Do 10 press ups!
<chunk_splitter>
 El archivo contiene un par de respuestas diferentes que se podrían dar en un juego de Simon Says, cada una dividida con una Esto da al embedder una señal para saber cómo separar cada respuesta al dividir el texto en embeddings. <chunk_splitter> Este proceso se llama y puede tener un gran impacto en lo bien que RAG realiza a través del modelo de lenguaje. Se anima a experimentar con fragmentos y respuestas de diferentes tamaños para encontrar la combinación correcta para sus necesidades! chunking Una cosa a tener en cuenta es el almacenamiento de aplicaciones. Recuerda, ya has instalado un modelo de idioma y un embedder en tu dispositivo. Estos ocupan gigabytes de espacio, así que asegúrate de no hinchar más un dispositivo usando un archivo de texto que es demasiado grande! Desea considerar almacenar el archivo de muestra en la nube y descargarlo a través de la red para reducir los problemas con el almacenamiento. Con el archivo de texto en su lugar, es hora de inicializar el embedder: private const val GeckoEmbedderPath = "/data/local/tmp/slm/gecko_256_f32.tflite"
private const val TokenizerModelPath = "/data/local/tmp/slm/sentencepiece.model"
private const val UseGpuForEmbeddings = true

val embedder: Embedder<String> = GeckoEmbeddingModel(
    GeckoEmbedderPath,
    TokenizerModelPath,
    UseGpuForEmbeddings,
  )
 El embedder toma tres parámetros: el camino del embedder y el tokenizer en el dispositivo, con un parámetro final para establecer si el embedder puede usar la GPU del dispositivo al crear embeddings. Esta configuración acelerará la creación de las incorporaciones si una GPU está disponible. Asegúrese de comprobar las capacidades del dispositivo antes de decidir activar este valor. A continuación, crea una instancia del modelo de idioma: private const val GemmaModelPath = "/data/local/tmp/slm/gemma3-1B-it-int4.task"

val llmInferenceOptions = LlmInferenceOptions.builder()
            .setModelPath(GemmaModelPath)
            .setPreferredBackend(LlmInference.Backend.CPU) // Change to GPU if you have a GPU powered device.
            .setMaxTokens(1200)
            .build()

val llmInferenceSessionOptions = LlmInferenceSessionOptions.builder()
            .setTemperature(0.6f)
            .setTopK(5000)
            .setTopP(1f)
            .build()

val languageModel = MediaPipeLlmBackend(
            context, // This is the application context
            languageModelOptions,
            languageModelSessionOptions)

    languageModel.initialize().get()
 Hay muchos parámetros involucrados anteriormente; no te preocupes por estos por ahora. Con el modelo de idioma creado, puede centrarse de nuevo en las incorporaciones. El modelo necesita un lugar para recuperar las incorporaciones cada vez que recibe un mensaje. MediaPipe ofrece un SQLite , que es una herramienta común para almacenar embeddings. Vamos a crear uno: Vector Store private const val PromptTemplate: String = """
    You are Simon in a game of Simon Says.
    
    Your task is to ask the player to perform a task from the following list: {0}.
    
    Your response must only contain the task that the player must do.
    
    Your response must be based on the players request: {1}. 
    
    Do not ask the player to do the same thing twice.
    
    You must not ask the player to do anything that is dangerous, unethical or unlawful.
"""

val chainConfig = ChainConfig.create(
    languageModel, PromptBuilder(PromptTemplate),
    DefaultSemanticTextMemory(
    SqliteVectorStore(768), embedder
    )
)
 Aquí, todo comienza a conectarse como el modelo de idioma y el embedder se pasan a ChainConfig. es el tamaño de cada "vector" que la base de datos puede almacenar. se utiliza para proporcionar un prompt para ayudar a impulsar el proceso RAG. 786 PromptBuilder Por último, vamos a cargar el archivo de texto que hemos creado anteriormente en la carpeta de activos en el embedder. Primero, cargue el archivo desde el dispositivo y divida el texto en una lista de cadenas: // This is an extension function to read the file from disk.
val gameResponses: List<String> = context.getTextFromFile("simon_says_responses.txt")
 A continuación, carga las respuestas en el chainConfig creado anteriormente. chainConfig.semanticMemory.getOrNull()
    ?.recordBatchedMemoryItems(ImmutableList.copyOf(gameResponses))
    ?.get()
 Dependiendo de su dispositivo y el tamaño del archivo de texto, esto puede tardar unos segundos a unos minutos en completarse.Una buena regla del pulgar es evitar que el modelo de lenguaje se utilice mientras esto ocurre. También puede ejecutar esta operación en un hilo de IO para evitar bloquear el hilo principal. Con esto, acaba de convertir su archivo de texto en un conjunto de incorporaciones almacenadas en una tienda de vectores. También ha vinculado su modelo de idioma a la tienda para que ahora pueda recuperar información! La siguiente sección mostrará cómo usar esas incorporaciones al pasar el modelo de idioma a sus solicitudes. Pasar Prompts a su modelo RAG Powered Con la mayoría de la configuración compleja completa, pasar un prompt al modelo de idioma es sorprendentemente fácil. usar la cadena config y invocarla. RetrievalAndInferenceChain val retrievalAndInferenceChain = RetrievalAndInferenceChain(chainConfig)
 A continuación, crea una solicitud y transmítela a la cadena. val prompt = "Tell me something to do Simon involving jumping!"

val retrievalRequest =
    RetrievalRequest.create(
        prompt,
        RetrievalConfig.create(
            50, // topK
            0.1f, // minSimilarityScore
            RetrievalConfig.TaskType.RETRIEVAL_QUERY
        )
    )

val response = retrievalAndInferenceChain!!.invoke(retrievalRequest).get().text
 Durante el procesamiento, se referirá a las incorporaciones en su tienda de vectores para proporcionar lo que cree que es la respuesta más precisa. Como podría esperar, lo que le preguntes al modelo resultará en respuestas diferentes. Como las incorporaciones contienen una variedad de respuestas de Simon dice, es probable que obtenga una buena respuesta! ¿Qué pasa con los casos en los que recibe un resultado inesperado?En este punto, necesita volver y ajustar finamente los parámetros de sus objetos de la sección anterior. Lo haremos en la siguiente sección. Fine-Tuning su modelo de lenguaje RAG Powered Si hay una cosa que hemos aprendido a lo largo de los años de Generative AI, es que no es una ciencia exacta. Sin duda has visto historias en las que los modelos de idiomas se han “comportado mal” y han producido un resultado menos que el deseado, causando vergüenza y daño de reputación a las empresas. Esto es el resultado de que no se realizan pruebas suficientes para asegurarse de que se esperen las respuestas de un modelo.La prueba no solo ayuda a evitar la vergüenza, sino que también puede ayudar a experimentar con la salida del modelo de idioma para que funcione aún mejor! Vamos a echar un vistazo a qué levantes podemos ajustar para ajustar mejor nuestro modelo de lenguaje alimentado por RAG. : LLmInferenceOptions.Builder LlmInferenceOptions.builder()
    .setModelPath(GemmaModelPath)
    .setPreferredBackend(LlmInference.Backend.CPU) // Change to GPU if you have a GPU powered device.
    .setMaxTokens(1200)
    .build()
 El primer parámetro que se puede cambiar es el Esta es la cantidad de “entrada” o “salida” que el modelo de lenguaje puede manejar.Cuanto mayor sea el valor, más datos puede manejar el modelo de lenguaje a la vez. setMaxTokens() En nuestro ejemplo, esto significa que el modelo puede manejar una entrada de texto y generar una salida que consiste en 1200 tokens. de un valor menor. MaxTokens Tenga cuidado con este valor, ya que puede encontrar que su modelo maneja inesperadamente más tokens que espera. Vamos a movernos hacia : LlmInferenceSessionOptions.Builder() llmInferenceSessionOptions = LlmInferenceSessionOptions.builder()
    .setTemperature(0.6f)
    .setTopK(5000)
    .setTopP(1f)
    .build()
 Aquí puedes establecer un par de parámetros diferentes. , de , y Vamos a sumergirlos en cada uno de ellos. .setTemperature() .setTopK() .setTopP() Se puede pensar en lo “random” que pueden ser las respuestas del modelo de lenguaje.Cuanto más bajo sea el valor, más “predecibles” pueden ser las respuestas del modelo.Cuanto mayor sea el valor, más “creativas” serán las respuestas, lo que conduce a más respuestas inesperadas. .setTemperature() Para este ejemplo, se ha establecido , lo que significa que el modelo proporcionará respuestas semi-creativas, pero no inimaginables. 0.6 La temperatura es un buen valor para experimentar con, ya que puede encontrar diferentes valores que proporcionan mejores respuestas dependiendo de su caso de uso. Es una forma de decir “sólo considere los mejores resultados K para volver al usuario”.Los modelos de idiomas, mientras procesan una solicitud, generan un número de respuestas, potencialmente miles! .setTopK() Cada una de estas respuestas tiene una probabilidad de ser la respuesta correcta.Para limitar el número de respuestas a considerar, el el valor se puede ajustar para ayudar a enfocar el modelo.Si está satisfecho con las respuestas menos probables que se están considerando, desea establecer este valor alto. topK Puede encontrarse que el modelo funciona mejor con menos o más respuestas a considerar, dependiendo de sus necesidades. Para un juego de Simon Says, queremos que el modelo esté pensando en muchas respuestas diferentes para mantener el juego fresco. Parece un buen valor. 5000 en el límite establecido por Como se mencionó anteriormente, los modelos de lengua asignan una probabilidad a cada respuesta que genera en cuanto a la probabilidad de que pueda ser. significa que el modelo puede descartar fácilmente cualquier respuesta que no tenga la probabilidad mínima necesaria. .setTopP() topK topP Por ejemplo, si el modelo tiene un Establecimiento y estaba considerando las siguientes respuestas: topP 0.4 Simons Says clap 5 times! = 0.7 // This response has a probablility of 0.7 of being correct

Simons Says jump up and down! = 0.5

Find a car and drive it. = 0.3
 Las dos primeras respuestas serían consideradas porque la probabilidad es mayor que la La respuesta sobre el coche sería descartada, ya que sólo tiene una probabilidad de . 0.4 0.3 similares a y , de Si desea considerar respuestas menos probables a las promesas, la configuración de un valor P bajo ayudará. temperature topK topP En nuestro ejemplo, se establece Eso es porque queremos que el modelo esté absolutamente seguro de sus respuestas. ¡después de todo, está jugando a un juego infantil! 1.0 Experimentar con estos valores generará resultados muy diferentes de sus modelos de idioma. ¿Dónde ir a continuación? Espero que hayas disfrutado de esta experiencia de cómo agregar un modelo de lenguaje con RAG a tu aplicación Android!Si estás buscando aprender más sobre RAG y Android, aquí están algunos enlaces que recomiendo: 
 
 
 
 
 
  Clone and run the   for this blog post to see it in action. It shows how to setup the RAG pipeline with Gemma using Android architecture best practices. Simons Says App: sample code 
 
 : Check out the RAG section on the MediaPipe   - Highly recommended reading. MediaPipe RAG Google Developer docs 
 
 : Learn more about how setting the Temperature, TopK, and TopP values can   the results from language models. Another highly recommended article. Setting Temperature, TopK, and TopP in LLMs help control

This story contains new, firsthand information uncovered by the writer.

Buy Me a Coffee

Read My Stories

Hire Me

Software Engineer

Este audio es producido en el idioma original de la historia!

Cómo ejecutar un modelo de lenguaje RAG en Android con la ayuda de MediaPipe

About Author

COMENTARIOS

ETIQUETAS

ESTE ARTÍCULO FUE PRESENTADO EN

Related Stories

Crecimiento de las criptomonedas: creación de perfiles de usuarios eficaces

Telegram: el puente de Crypto Island hacia el continente

El modelo Bitcoin UTXO, impulsando un ecosistema único

Las capas invisibles: por qué las entrevistas con los usuarios son un activo irremplazable

Crecimiento de las criptomonedas: creación de perfiles de usuarios eficaces

Telegram: el puente de Crypto Island hacia el continente

El modelo Bitcoin UTXO, impulsando un ecosistema único

Las capas invisibles: por qué las entrevistas con los usuarios son un activo irremplazable

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps