TinyLlama 1.1B – Ukuran Tidak Penting

Pengantar

Dalam lanskap kecerdasan buatan dan pembelajaran mesin yang berkembang pesat, TinyLlama 1.1B muncul sebagai perkembangan yang patut diperhatikan. Di era ketika kendala komputasi menimbulkan tantangan dalam menjalankan model yang lebih kompleks, TinyLlama menonjol karena melampaui ekspektasi. Ini menampilkan performa luar biasa dari model kompak.

Artikel ini bertujuan untuk memberikan analisis TinyLlama 1.1B, model bahasa kompak dan besar. Kami akan mempelajari aspek intinya, seperti bagaimana mereka dilatih dalam tolok ukur kinerja dan implementasi praktis menggunakan platform Hugging Face. Kami bahkan akan menjalankan model ini di Google Colab gratis dan menguji kemampuan matematika dan penalarannya.

Tujuan Pembelajaran

• Dapatkan pemahaman komprehensif tentang TinyLlama 1.1B
• Jelajahi proses pelatihan rumit yang telah dilalui model tersebut
• Analisis kinerja dan hasil tolok ukur untuk menilai kemanjurannya
• Pelajari langkah-langkah praktis untuk mengimplementasikan TinyLlama 1.1B menggunakan contoh coding

Artikel ini diterbitkan sebagai bagian dari Blogathon Ilmu Data.

Apa itu TinyLlama 1.1B?

TinyLlama 1.1B, bagian dari proyek Llama yang lebih luas, merupakan bukti kemajuan pemodelan bahasa. Ini adalah model dengan 1.1 miliar parameter, dilatih pada 3 triliun token, yang menempatkannya pada posisi unik dalam lanskap AI. Berbeda dengan versi yang lebih besar, TinyLlama 1.1B dirancang agar lebih efisien dan mudah dikelola, menjadikannya pilihan yang baik untuk aplikasi dengan sumber daya komputasi terbatas.

Model sumber terbuka ini mendemokratisasikan akses terhadap teknologi AI yang canggih, memungkinkan banyak pengembang dan peneliti untuk mengeksplorasi dan berinovasi di bidang pemrosesan bahasa alami. Ini adalah model yang dikenal karena kemampuannya menyeimbangkan kinerja dengan konsumsi sumber daya, yang merupakan pertimbangan penting dalam lingkungan komputasi yang beragam saat ini.

Proses Pelatihan TinyLlama 1.1B

Proses pelatihan TinyLlama 1.1B sangat menarik, seperti modelnya sendiri. Pelatihan TinyLlama berlangsung hanya selama 90 hari, dilatih pada 16 GPU A100-40G. Pra-pelatihan dilakukan pada 3 Triliun Token, dan Tim TinyLlama telah menerbitkan model perantara antara masing-masing setengah triliun. 

Sedangkan untuk datanya diambil Slimpajama dan Starcoderdata dengan gabungan ukuran dataset sebesar 950 Miliar Token. Rasio bahasa alami dan kode dipertahankan pada 7:3, yaitu 70% data adalah bahasa alami, dan 30% adalah kode. Oleh karena itu, untuk mencapai angka 3 Triliun Token untuk penyesuaian, TinyLlama menjalani 3 periode pelatihan untuk kumpulan data ini. 

Bahkan ada versi obrolan TinyLlama yang disebut TinyLlama-Chat yang dirilis. Awalnya, model ini mengalami penyempurnaan pada kumpulan data UltraChat, yang berisi beragam percakapan sintetis yang dihasilkan oleh ChatGPT. Langkah ini penting dalam membuat model untuk menangani konteks dan gaya percakapan yang berbeda.

Penyempurnaan lebih lanjut dicapai dengan menggunakan DPOTrainer pada kumpulan data UltraFeedback. Fase pelatihan ini berfokus pada menyelaraskan respons model agar selaras dengan pola percakapan yang mirip manusia. Hasilnya adalah model yang tidak hanya menangkap informasi tentang berbagai topik namun bahkan berinteraksi dengan cara yang alami dan menarik.

Anda juga bisa membaca: Memulai LlaMA 2: Panduan Pemula

Hasil Kinerja dan Tolok Ukur

Mengevaluasi kinerja TinyLlama 1.1B menunjukkan kemampuannya dalam memberikan respons berkualitas tinggi dengan cepat. Pelatihannya telah memberikannya kemampuan untuk melayani aplikasi multibahasa, sebuah fitur penting dalam dunia global kita. Meskipun ukurannya lebih kecil, TinyLlama 1.1B masih bisa mengejar rekan-rekannya yang lebih besar dalam hal kualitas dan kecepatan respons, menjadikannya alat yang ampuh dalam berbagai aplikasi AI.

Tolok ukur untuk TinyLlama 1.1B, meskipun kurang ekstensif dibandingkan model yang lebih besar, masih menunjukkan kemahirannya dalam menangani tugas bahasa yang kompleks. Kemampuannya untuk menghasilkan respons yang koheren dan relevan secara kontekstual dalam berbagai bahasa sangatlah mengesankan. Model ini diuji pada berbagai benchmark seperti HellaSwag, WinoGrande, ARC, MMLU, dan lainnya. Skor rata-rata gabungan menjadi 52.99. Ini jauh lebih baik dibandingkan Model 1 Miliar Parameter lainnya, yaitu Pythia 1B, yang mencapai skor rata-rata 48.3. Tabel ini menggambarkan skor individual dari setiap tolok ukur

TinyLlama – Memulai

Di sini, di bagian ini, kita akan mengunduh TinyLlama Chat versi terkuantisasi dan menjalankannya di Google Colab. Sebelum mendownload modelnya, kita harus mendownload dan menginstal Paket Python berikut

!CMAKE_ARGS="-DLLAMA_CUBLAS=on" FORCE_CMAKE=1 pip3 install llama-cpp-python 
!pip3 install huggingface-hub 

• Grafik CMAKE_ARGS=”-DLLAMA_CUBLAS=aktif” dan KEKUATAN_CMAKE=1, akan mengizinkan llama_cpp_python menggunakan GPU Nvidia yang tersedia dalam versi colab gratis.
• Kemudian kita menginstal llama_cpp_python paket melalui pip3
• Kami bahkan mengunduhnya memeluk hub wajah, yang dengannya kita akan mengunduh Obrolan TinyLlama 1.1B yang terkuantisasi

Untuk menguji model Obrolan TinyLlama 1.1B, kita perlu mengunduh versi terkuantisasinya terlebih dahulu. Untuk mendownloadnya, kita akan menjalankan kode berikut

from huggingface_hub import hf_hub_download

# specifying the model name
model_name = "TheBloke/TinyLlama-1.1B-Chat-v1.0-GGUF"
# specifying the type of quantization of the model
model_file = "tinyllama-1.1b-chat-v1.0.Q8_0.gguf"

# download the model by specifying the model name and quantized model name
model_path = hf_hub_download(model_name, filename=model_file)

Ini, pelukan_face_hub perpustakaan akan menangani proses pengunduhan model terkuantisasi. Untuk ini, kami mengimpor hf_hub_download yang mengambil parameter berikut:

• nama model: Ke variabel ini, kita meneruskan model yang ingin kita unduh. Di sini kami ingin mengunduh model TinyLlama 1.1B Chat GGUF.
• model_file: Di sini kita menentukan jenis model terkuantisasi yang ingin kita unduh. Di sini kita akan mengunduh Obrolan TinyLlama 8B versi terkuantisasi 1.1-bit.
• Terakhir, kami meneruskan parameter ini ke hf_hub_download, yang mengambil parameter ini dan mengunduh model yang ditentukan. Setelah diunduh, ia mengembalikan jalur tempat model diunduh.
• Jalur yang dikembalikan ini sedang disimpan di model_jalur variabel.

Sekarang, kita dapat memuat model ini melalui llama_cpp_python perpustakaan. Kode untuk memuat model akan seperti di bawah ini.

from llama_cpp import Llama
llm = Llama(
    model_path=model_path,
    n_ctx=512,  # the number of i/p tokens the model can take
    n_threads=8, # the number of threads to use
    n_gpu_layers=40# how many layers of the model to offload to the GPU
)

Kami mengimpor Llama kelas dari llama_cpp, yang mengambil parameter berikut

• jalur_model: Variabel ini mengambil jalur tempat model kita disimpan. Kami telah memperoleh jalur dari langkah sebelumnya, yang akan kami berikan di sini
• n_ctx: Di sini, kami memberikan panjang konteks untuk model tersebut. Untuk saat ini, kami menyediakan 512 token sebagai panjang konteks
• n_utas: Di sini kami menyebutkan jumlah thread yang akan digunakan oleh Llama kelas
• n_gpu_layers: Kami menentukan ini jika kami memiliki GPU yang berjalan, yang kami lakukan jika menggunakan colab gratis. Untuk ini, kami melewati 40, yang menyiratkan bahwa kami ingin memindahkan seluruh model ke GPU dan tidak ingin ada bagian yang dijalankan di RAM sistem.
• Terakhir, kita membuat objek dari ini Llama kelas dan berikan ke variabel llm

Menjalankan kode ini akan memuat model terkuantisasi Obrolan TinyLlama 1.1B ke GPU dan mengatur panjang konteks yang sesuai. Sekarang saatnya melakukan beberapa kesimpulan pada model ini. Untuk ini, kami bekerja dengan kode di bawah ini

output = llm(
  "<|im_start|>usernWho are you?<|im_end|>n<|im_start|>assistantn", # User Prompt
  max_tokens=512,  # Number of output tokens generated
  stop=["</s>"],   # Token which tells the LLM to stop
)
print(output['choices'][0]['text']) # Model generated text

Untuk menyimpulkan model, kami meneruskan parameter berikut ke LLM:

• templat cepat/obrolan: Ini adalah Templat Prompt yang diperlukan untuk mengobrol dengan model. Templat yang disebutkan di atas(yaitu , ) adalah salah satu yang berfungsi untuk model Obrolan TinyLlama 1.1B. Dalam templat, kalimat setelah Pengguna adalah Perintah Pengguna, dan pembuatannya akan dihasilkan setelah Asisten.
• max_tokens: Ke variabel ini, kami meneruskan nilai yang menentukan jumlah maksimum token yang dapat dihasilkan oleh Model Bahasa Besar ketika Prompt diberikan. Untuk saat ini, kami membatasinya hingga 512 token.
• berhenti: Ke variabel ini, kita meneruskan token stop. Token berhenti memberitahu Model Bahasa Besar untuk berhenti menghasilkan token lebih lanjut. Untuk Obrolan TinyLlama 1.1B, token penghentiannya adalah

Teks yang dihasilkan disimpan dalam variabel keluaran saat kita menjalankan ini. Hasilnya dihasilkan dalam format yang mirip dengan panggilan OpenAI API. Oleh karena itu, kita dapat mengakses generasi tersebut melalui pernyataan cetak yang diberikan, mirip dengan cara kita mengakses generasi dari respons OpenAI. Output yang dihasilkan dapat dilihat dibawah ini

Untuk model sebesar ini, respons yang dihasilkannya adalah yang terbaik. Hal ini tidak terduga dari model sebesar ini; tata bahasa dan nadanya terlihat baik-baik saja, dan tidak ada tanda-tanda pengulangan kalimat. Mari kita coba menguji kemampuan penalaran model tersebut

output = llm(
  "<|im_start|>usernIf all students who study hard get good grades, 
  and John got good grades, can we conclude that John studied hard?
  <|im_end|>n<|im_start|>assistantn",
  max_tokens=512,
  stop=["</s>"],
)


print(output['choices'][0]['text'])

output = llm(
  "<|im_start|>usernHow fast can a snake fly?n<|im_end|>n<|im_start|>assistantn",
  max_tokens=512,
  stop=["</s>"],
)


print(output['choices'][0]['text'])

Sejauh ini bagus. Dari contoh yang telah kita lihat, model tersebut menghasilkan jawaban yang baik. Namun hal ini mungkin tidak berlaku di semua kasus karena kami hanya mengujinya pada sejumlah pertanyaan terbatas. Mari kita uji model tersebut pada kemampuan penalaran matematikanya

output = llm(
  "<|im_start|>usernJohn is twice as old as Sarah, and Sarah is three years 
  older than Mary. If Mary is 10 years old, how old is John?n<|im_end|>n<|im_start|>assistantn",
  max_tokens=512,
  stop=["</s>"],
)


print(output['choices'][0]['text'])

output = llm(
  "<|im_start|>usernWhat is the missing number in this pattern: 
  1, 4, 9, 16, __, 36?n<|im_end|>n<|im_start|>assistantn",
  max_tokens=512,
  stop=["</s>"],
)


print(output['choices'][0]['text'])

Dari contoh yang telah kita lihat, jelas bahwa TinyLlamaChat berkinerja sangat buruk dalam menjawab pertanyaan bakat sederhana dalam matematika. Hal ini diperkirakan terjadi karena model belum dilatih sebelumnya pada kumpulan data matematika apa pun. Kualitas generasi dapat ditingkatkan dengan menyempurnakannya pada kumpulan data matematika

Dalam hal penyempurnaan, TinyLlama adalah pilihan tepat bagi mereka yang memiliki perangkat keras terbatas dan ingin menyempurnakan model bahasa besar pada kumpulan data spesifik mereka.

Kasus Penggunaan dan Aplikasi Potensial

Mengingat ukurannya yang kompak Llama Kecil, yang memiliki 1.1 miliar parameter, penerapannya terutama disesuaikan dengan lingkungan di mana model yang lebih besar mungkin tidak layak digunakan karena keterbatasan perangkat keras atau efisiensi yang lebih besar. Berikut beberapa kasus penggunaan spesifik yang mempertimbangkan ukurannya:

Aplikasi Seluler: Ukuran TinyLlama yang lebih kecil menjadikannya pilihan yang baik untuk diintegrasikan ke dalam aplikasi seluler yang memerlukan pemrosesan pada perangkat. Ini termasuk aplikasi terjemahan bahasa, fitur asisten pribadi, dan chatbot yang dapat beroperasi secara efisien di ponsel pintar.

Sistem Tertanam di Perangkat IoT: Di bidang Internet of Things (IoT), sumber daya komputasi seringkali terbatas; TinyLlama dapat digunakan untuk menambahkan kemampuan pemrosesan bahasa cerdas ke berbagai peralatan seperti asisten rumah pintar, teknologi yang dapat dikenakan, dan peralatan terhubung lainnya.

Komputasi Tepi: Untuk aplikasi yang mendapatkan keuntungan dari pemrosesan data yang lebih dekat ke sumbernya dibandingkan di lingkungan cloud terpusat, TinyLlama dapat digunakan secara efektif. Ini mencakup pemrosesan bahasa real-time dalam sistem otomotif, peralatan manufaktur, dan perangkat canggih lainnya.

Penelitian Bahasa dengan Sumber Daya Rendah: Karena ukurannya yang lebih kecil dan kebutuhan komputasi yang lebih rendah, TinyLlama dapat menjadi alat yang berharga dalam penelitian linguistik, terutama untuk bahasa yang kekurangan sumber daya sehingga pelatihan model skala besar tidak dapat dilakukan.

Alat Pendidikan: Dalam lingkungan pendidikan, terutama yang memiliki akses terbatas terhadap sumber daya komputasi kelas atas, TinyLlama dapat digunakan untuk mengembangkan aplikasi pembelajaran bahasa, alat pendidikan interaktif, dan alat bantu pembelajaran lainnya.

Pembuatan Konten untuk Usaha Kecil: Usaha kecil dengan sumber daya terbatas dapat menggunakan TinyLlama untuk menghasilkan konten, seperti deskripsi produk, salinan pemasaran, dan korespondensi pelanggan, tanpa memerlukan daya komputasi yang besar.

Pembuatan Prototipe dan Eksperimen: Pengembang dan peneliti yang ingin bereksperimen dengan model bahasa tetapi tidak memiliki akses ke sumber daya komputasi berdaya tinggi dapat menggunakan TinyLlama untuk membuat prototipe dan mengembangkan aplikasi NLP baru.

Analisis Data yang Efisien: TinyLlama dapat digunakan untuk analisis teks dan ekstraksi data dalam skenario yang memerlukan pemrosesan cepat dan efisien, seperti menganalisis masukan pelanggan, respons survei, atau interaksi media sosial.

Kesimpulan

TinyLlama 1.1B merupakan bukti kemajuan di bidang AI dan pemrosesan bahasa alami. Pengembangan dan ketersediaannya secara luas sangat penting untuk menciptakan model bahasa inferensi yang lebih efisien, kecil, dan cepat. Dengan menyeimbangkan jejak parameter yang lebih kecil dengan kinerja yang kuat, TinyLlama 1.1B menjawab kebutuhan kritis akan model yang kuat dan praktis untuk beragam aplikasi. Kemampuannya untuk memahami dan menghasilkan bahasa dengan cara yang mirip manusia dan cukup ringan untuk berbagai lingkungan komputasi menjadikannya pilihan tepat bagi orang-orang yang kesulitan menjalankan Model Bahasa Besar di mesin mereka. Model ini dapat disesuaikan dengan mudah pada kumpulan data dan dapat dilatih dengan sumber daya komputasi terbatas. 

Poin Penting Dari Artikel ini Termasuk

• Dirancang untuk efisiensi, TinyLlama 1.1B tersedia untuk khalayak yang lebih luas, termasuk mereka yang memiliki sumber daya komputasi terbatas, sehingga cocok untuk beberapa aplikasi.
• Model ini menjalani proses pelatihan ekstensif, termasuk pelatihan 3 triliun token selama 90 hari menggunakan 16 GPU A100-40G.
• Meskipun ukurannya lebih kecil, TinyLlama 1.1B memberikan respons berkualitas tinggi dan relevan secara kontekstual dalam berbagai bahasa, menjadikannya model yang perlu dipertimbangkan.
• Ini adalah pilihan yang baik untuk aplikasi seluler, peralatan IoT, alat pendidikan, dan banyak lagi, ukurannya yang ringkas dan efisiensinya memungkinkan aplikasi yang luas.
• Persyaratan komputasinya yang lebih rendah menjadikannya alat yang berharga dalam penelitian linguistik, terutama untuk bahasa yang kekurangan sumber daya.
• Model ini merupakan pilihan yang baik bagi mereka yang bereksperimen dengan model bahasa atau mengembangkan Aplikasi NLP baru, terutama di lingkungan dengan daya komputasi terbatas.

Tanya Jawab Umum (FAQ)

Media yang ditampilkan dalam artikel ini bukan milik Analytics Vidhya dan digunakan atas kebijaksanaan Penulis.

terkait

• Konten Bertenaga SEO & Distribusi PR. Dapatkan Amplifikasi Hari Ini.
• PlatoData.Jaringan Vertikal Generatif Ai. Berdayakan Diri Anda. Akses Di Sini.
• PlatoAiStream. Intelijen Web3. Pengetahuan Diperkuat. Akses Di Sini.
• PlatoESG. Karbon, teknologi bersih, energi, Lingkungan Hidup, Tenaga surya, Penanganan limbah. Akses Di Sini.
• PlatoHealth. Kecerdasan Uji Coba Biotek dan Klinis. Akses Di Sini.
• Sumber: https://www.analyticsvidhya.com/blog/2024/01/tinyllama-1-1b-size-doesnt-matter/