Beberapa bulan yang lalu, saya telah membincangkan tentang Ia telah diterima dengan baik dan menyegarkan untuk dapat memberikan perbualan di mana aplikasi mudah alih boleh mendapat manfaat daripada peningkatan penggunaan model bahasa. Menjalankan SLM pada peranti dalam aplikasi Selepas pembicaraan, saya mempunyai beberapa umpan balik daripada peserta di sepanjang baris "Itu akan menjadi baik untuk melihat contoh aplikasi yang menggunakan SLM yang dikendalikan oleh RAG." Perkara yang rumit di sini ialah masa utama yang diperlukan untuk menubuhkan model dan menunjukkan sesuatu yang bermakna kepada pengembang dalam masa yang terhad. Jika anda sedang mencari langkah-langkah untuk menambah model bahasa bertenaga RAG kepada aplikasi Android anda, ini adalah post untuk anda! Apa itu RAG? Jika anda tidak akrab dengan istilah ini, RAG bermaksud Ia adalah teknik untuk model bahasa untuk mengakses maklumat luaran yang tidak tersedia dalam set data mereka selepas latihan. Ini membolehkan model untuk menyedari maklumat terkini yang mereka boleh gunakan untuk memberikan jawapan yang lebih tepat kepada permintaan. Retrieval Augmented Generation Bayangkan anda mempunyai dua model bahasa, satu model menggunakan RAG untuk mendapatkan maklumat luaran mengenai ibu kota di Eropah, manakala yang lain hanya bergantung kepada pengetahuan sendiri. 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.
 Hasilnya boleh kelihatan seperti ini: Seperti diagram menunjukkan, anda lebih cenderung untuk mendapatkan jawapan yang berguna daripada model bahasa menggunakan RAG, daripada model bergantung kepada pengetahuan sendiri. Itu benar-benar semua yang anda perlukan untuk tahu tentang RAG pada tahap yang tinggi.Selepas itu, mari kita pergi lebih dalam dan menulis beberapa kod untuk mengaktifkan model bahasa RAG anda sendiri di dalam aplikasi anda! Menubuhkan aplikasi Android anda Katakanlah anda ingin mencipta aplikasi menggunakan model bahasa untuk memainkan permainan Simon Says. Anda mahu model itu Simon, dan menggunakan RAG untuk mengakses sumber data tugas untuk membantu memutuskan apa yang perlu diminta pengguna. Cara paling mudah untuk melakukannya pada Android ialah dengan , koleksi alat untuk membantu aplikasi anda menggunakan teknik AI dan pembelajaran mesin. Untuk memulakan, tambahkan ketergantungan MediaPipe kepada aplikasi anda : MediaPip build.gradle dependencies {
  implementation("com.google.mediapipe:tasks-genai:0.10.27")
  implementation("com.google.ai.edge.localagents:localagents-rag:0.3.0")
}
 Seterusnya, anda perlu menambah model bahasa kepada peranti ujian anda melalui komputer anda. , model bahasa ringan yang mempunyai 1 bilion parameter bernilai maklumat. Merdeka1b 
 
 Nota sampingan: Sebelum memuat turun model, anda mungkin perlu mendaftar ke Kaggle dan bersetuju dengan Terma dan Syarat AI Google. Side Note: Before downloading the model, you may have to sign upto Kaggle and agree to Google’s AI Terms and Conditions. Sebaik sahaja model dimuat turun, ia adalah masa untuk menambah model kepada peranti anda. anda boleh melakukan ini melalui 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
 Sebagai alternatif, anda boleh menggunakan menggunakan Android Studio untuk mencipta folder anda sendiri dan tarik model ke peranti anda. Penyelidik fail Dengan model yang ditambahkan, anda boleh terus membina paip RAG untuk memberi maklumat kepada Gemma.Selepas itu, mari kita lihat menambah maklumat yang Gemma akan bergantung kepada untuk menjawab prompts. Mencipta Embeddings Model bahasa maklumat yang bergantung kepada untuk melaksanakan RAG bukanlah maklumat yang sama yang anda hantar ke dalamnya. . Embeddings Ini adalah string matematik yang mewakili makna semantik teks. Apabila model menerima prompt, ia akan menggunakannya untuk mencari maklumat yang paling relevan yang cocok dengannya dan menggunakannya di samping maklumatnya sendiri untuk memberikan jawapan. . Embedder Embeddings adalah subjek keseluruhan dengan sendirinya; anda digalakkan untuk membaca tentang mereka. Untuk post ini, anda hanya perlu tahu bagaimana untuk mencipta mereka. . Gecko Menghantar Pertama, download daripada Tokenizer dan yang embedder fail model ke komputer anda. Kemudian tekan mereka ke peranti anda: 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
 Dengan embedder dipasang pada peranti anda, ia adalah masa untuk menyediakan fail sampel untuk mencipta embeddings daripada. folder, mencipta fail yang dipanggil Kemudian, dalam fail, tambahkan teks berikut: 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>
 Fail ini mengandungi beberapa jawapan yang berbeza yang boleh diberikan dalam permainan Simon Says, masing-masing dibahagikan dengan Ini memberi embedder isyarat untuk tahu bagaimana untuk memisahkan setiap respons apabila membahagikan teks ke dalam embeddings. <chunk_splitter> Proses ini dinamakan dan boleh mempunyai kesan yang besar pada seberapa baik RAG berprestasi melalui model bahasa. percubaan dengan keping dan respons saiz yang berbeza digalakkan untuk mencari gabungan yang betul untuk keperluan anda! chunking Satu perkara yang perlu dipertimbangkan ialah penyimpanan aplikasi. Ingat, anda telah memasang model bahasa dan embedder pada peranti anda. Ini mengambil gigabyte ruang, jadi pastikan untuk tidak membebani peranti dengan menggunakan fail teks yang terlalu besar! Anda ingin mempertimbangkan menyimpan fail sampel dalam awan dan muat turun melalui rangkaian untuk mengurangkan masalah dengan penyimpanan. Dengan fail teks di tempat, ia adalah masa untuk memulakan 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,
  )
 Embedder mengambil tiga parameter: laluan embedder dan tokenizer pada peranti, dengan parameter akhir untuk menetapkan sama ada embedder boleh menggunakan GPU peranti semasa mewujudkan embeddings. Menetapkan ini kepada benar akan mempercepatkan penciptaan embeddings jika GPU tersedia. Pastikan anda memeriksa keupayaan peranti sebelum memutuskan untuk mengaktifkan nilai ini. Seterusnya, buat contoh model bahasa: 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()
 Terdapat banyak parameter yang terlibat di atas; jangan risau tentang ini untuk masa ini. Dengan model bahasa yang dicipta, anda boleh memberi tumpuan semula kepada embeddings. model memerlukan tempat untuk mendapatkan embeddings setiap kali ia menerima prompt. MediaPipe menyediakan SQLite , yang merupakan alat biasa untuk menyimpan embeddings. mari kita cipta satu: 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
    )
)
 Di sini, segala-galanya mula terhubung bersama-sama kerana model bahasa dan embedder kedua-duanya dihantar ke dalam ChainConfig. ialah saiz setiap "vektor" yang boleh disimpan dalam pangkalan data. digunakan untuk menyediakan prompt untuk membantu memacu proses RAG. 786 PromptBuilder Akhirnya, mari kita muat naik fail teks yang kami cipta sebelum ini dalam folder aset ke dalam embedder. Pertama, muat naik fail dari peranti dan membahagikan teks ke dalam senarai string: // This is an extension function to read the file from disk.
val gameResponses: List<String> = context.getTextFromFile("simon_says_responses.txt")
 Kemudian, muat naik jawapan ke dalam chainConfig yang dicipta sebelum ini. chainConfig.semanticMemory.getOrNull()
    ?.recordBatchedMemoryItems(ImmutableList.copyOf(gameResponses))
    ?.get()
 Bergantung kepada peranti anda dan saiz fail teks, ini boleh mengambil beberapa saat hingga beberapa minit untuk diselesaikan. A peraturan yang baik ialah untuk mengelakkan model bahasa daripada digunakan semasa ini berlaku. Anda juga boleh menjalankan operasi ini pada benang IO untuk mengelakkan menghalang benang utama. Dengan itu, anda baru sahaja menukar fail teks anda kepada satu set embeddings yang disimpan dalam kedai vektor. anda juga telah mengaitkan model bahasa anda dengan kedai supaya ia kini boleh mendapatkan maklumat! Seksyen seterusnya akan menunjukkan bagaimana untuk menggunakan embeddings itu dengan melepasi model bahasa yang anda minta. Meneruskan Prompts kepada model RAG Powered anda Dengan kebanyakan setup yang rumit selesai, melepaskan prompt ke dalam model bahasa sangat mudah. menggunakan rantaian config dan memanggilnya. RetrievalAndInferenceChain val retrievalAndInferenceChain = RetrievalAndInferenceChain(chainConfig)
 Seterusnya, mencipta permintaan dan menghantarnya ke rantaian. 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
 Semasa pemprosesan, ia akan merujuk kepada embeddings dalam kedai vektor anda untuk memberikan apa yang dianggap sebagai jawapan yang paling tepat. Seperti yang anda harapkan, apa yang anda tanyakan kepada model akan membawa kepada jawapan yang berbeza.Sebagai embeddings mengandungi pelbagai jawapan simon berkata, ia adalah mungkin bahawa anda akan mendapat jawapan yang baik! Bagaimana dengan kes-kes di mana anda menerima hasil yang tidak dijangka? Pada titik ini, anda perlu kembali dan menyesuaikan parameter objek anda dari bahagian sebelumnya. Mari kita lakukan itu dalam bahagian seterusnya. Fine-Tuning anda RAG Powered Model Bahasa Sekiranya terdapat satu perkara yang telah kita pelajari selama bertahun-tahun daripada Generative AI, ia adalah bahawa ia bukan sains yang tepat. Anda tidak diragukan lagi telah melihat cerita di mana model bahasa telah "berkelakuan salah" dan menghasilkan hasil yang kurang daripada yang diingini, menyebabkan rasa malu dan kerosakan reputasi kepada syarikat. Ini adalah hasil daripada ujian yang tidak mencukupi yang dijalankan untuk memastikan jawapan daripada model dijangka. pengujian bukan sahaja membantu mengelakkan rasa malu, ia juga boleh membantu untuk bereksperimen dengan output model bahasa anda supaya ia berfungsi lebih baik! Mari kita lihat apa lever yang kita boleh menyesuaikan untuk menyesuaikan model bahasa RAG kami. : LLmInferenceOptions.Builder LlmInferenceOptions.builder()
    .setModelPath(GemmaModelPath)
    .setPreferredBackend(LlmInference.Backend.CPU) // Change to GPU if you have a GPU powered device.
    .setMaxTokens(1200)
    .build()
 Parameter pertama yang boleh diubah ialah parameter. Ini ialah jumlah "input" atau "output" model bahasa boleh menangani. Semakin besar nilai, semakin banyak data model bahasa boleh menangani pada satu masa. setMaxTokens() Dalam contoh kami, ini bermakna model ini boleh menangani input teks dan menghasilkan output yang terdiri daripada 1200 token. kepada nilai yang lebih kecil. MaxTokens Berhati-hatilah dengan nilai ini, kerana anda boleh mendapati model anda secara tidak terduga menangani lebih banyak token daripada yang dijangkakan. Mari kita bergerak ke : LlmInferenceSessionOptions.Builder() llmInferenceSessionOptions = LlmInferenceSessionOptions.builder()
    .setTemperature(0.6f)
    .setTopK(5000)
    .setTopP(1f)
    .build()
 Di sini, anda boleh menetapkan beberapa parameter yang berbeza. daripada dan Mari kita letakkan mereka dalam setiap satu daripada mereka. .setTemperature() .setTopK() .setTopP() boleh dipikirkan betapa "akurat" jawapan daripada model bahasa boleh menjadi. Semakin rendah nilai, semakin "dijangka" jawapan daripada model boleh menjadi. Semakin tinggi nilai, semakin "kreatif" jawapan akan menjadi, yang membawa kepada lebih banyak jawapan yang tidak dijangka. .setTemperature() Sebagai contoh, ia telah ditetapkan untuk , yang bermakna model ini akan memberikan jawapan semi-kreatif, tetapi tidak tidak dapat dibayangkan. 0.6 Suhu adalah nilai yang baik untuk bereksperimen dengan, kerana anda mungkin mendapati nilai yang berbeza memberikan respons yang lebih baik bergantung kepada kes penggunaan anda. adalah satu cara untuk mengatakan "hanya pertimbangkan hasil K teratas untuk kembali kepada pengguna." model bahasa, manakala memproses prompt, menghasilkan sejumlah jawapan, berpotensi beribu-ribu! .setTopK() Tiap-tiap jawapan ini diberi probabiliti seberapa mungkin mereka adalah jawapan yang betul. untuk mengehadkan bilangan jawapan yang nilai boleh ditetapkan untuk membantu memberi tumpuan kepada model.Jika anda berpuas hati dengan jawapan yang kurang mungkin dipertimbangkan, anda ingin menetapkan nilai ini tinggi. topK Anda mungkin mendapati bahawa model bekerja lebih baik dengan lebih sedikit atau lebih banyak respons untuk dipertimbangkan, bergantung kepada keperluan anda. Untuk permainan Simon Says, kami mahu model itu memikirkan banyak tindak balas yang berbeza untuk menjaga permainan segar. Ia kelihatan sebagai nilai yang baik. 5000 Membina di atas had yang ditetapkan oleh dengan mengatakan “hanya pertimbangkan hasil yang mempunyai kebarangkalian P”. seperti yang dinyatakan sebelum ini, model bahasa menetapkan kebarangkalian kepada setiap jawapan yang dihasilkan mengenai seberapa mungkin ia boleh menjadi. bermakna model boleh dengan mudah membuang sebarang jawapan yang tidak mempunyai kebarangkalian minimum yang diperlukan. .setTopP() topK topP Sebagai contoh, jika model mempunyai Sediakan 2 dan sedang mempertimbangkan jawapan berikut: 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
 Kedua-dua jawapan pertama akan dipertimbangkan kerana kebarangkalian lebih tinggi daripada Jawapan mengenai kereta akan dibuang, kerana ia hanya mempunyai kemungkinan . 0.4 0.3 yang serupa dan daripada membolehkan anda menentukan betapa kreatif model bahasa anda boleh.Jika anda ingin mempertimbangkan tindak balas yang kurang mungkin kepada panggilan, menetapkan nilai P yang rendah akan membantu. temperature topK topP Dalam contoh ini, ia ditetapkan untuk Itu kerana kami mahu model itu benar-benar yakin tentang tindak balasnya.Ia bermain permainan kanak-kanak selepas semua! 1.0 Bereksperimen dengan nilai-nilai ini akan menghasilkan hasil yang sangat berbeza daripada model bahasa anda. Ke mana nak pergi seterusnya? Saya harap anda telah menikmati laluan ini tentang bagaimana untuk menambah model bahasa bertenaga RAG kepada Aplikasi Android anda!Jika anda sedang mencari untuk mempelajari lebih lanjut tentang RAG dan Android, di sini adalah beberapa pautan yang saya cadangkan: 
 
 
 
 
 
  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

Audio ini dihasilkan dalam bahasa asal cerita!

Bagaimana untuk menjalankan model bahasa RAG Powered pada Android dengan bantuan MediaPipe

About Author

KOMEN

GANTUNG TANDA

ARTIKEL INI DIBENTANGKAN DALAM

Related Stories

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps