Google’ın Gemma Modelini TPU’ları Kullanarak İnce Ayarlayın ve Daha Yüksek Hız ve Performans için Çıkarım Çalıştırın

Bu makale, gelişmiş teknikler kullanarak büyük dil modellerini ince ayar (“fine-tuning”) için kapsamla bir eğiticidir. Tensor Processing Unit’ler (TPU), LoRA adlı bir teknik ve dağıtık hesaplama örnekleri üzerinden ilerleyeceğiz—hepsi hız ve verimliliği artırmak için. Tekniklerimizi göstermek için, Google tarafından oluşturulan, hafif ve güncel teknolojiyi temsil eden yeni bir LLM ailesi olan Gemma modellerine erişecek ve bunları ince ayar edeceğiz.

Eğiticinin sonunda, Google Cloud’da kullanılabilen TPU’ları kullanarak herhangi bir büyük dil modeli üzerinde ince ayar yapma ve çıkarım çalıştırma becerilerine sahip olacaksınız. Buna ulaşmak için aşağıdaki konuları sırayla ele alacağız:

• Hesaplama Türlerine Giriş: TPU’ları ve neden önemli olduklarını öğreneceğiz. 

• Gemma’yı TPU’larla Kullanma: TPU kullanmak için bir Kaggle ortamını nasıl kuracağımızı öğreneceğiz.

• Model Kurulumu ve Çıkarım: Python’da Keras kütüphanesiyle Gemma’yı çalıştıracağız.

• Fine-Tuning: Gemma modelini LoRA adlı bir teknikle ince ayar edeceğiz. 

• Dağıtık Eğitim: Eğitim verimliliği için dağıtık ince ayar uygulayacağız. 

Yapay zekâ ve LLM’lere yeniyseniz, bu eğiticide geçen kavramlara alışmak için kapsamla AI Fundamentals beceri yolunu değerlendirebilirsiniz. 

Başlayalım!

Google’ın Gemma Modeli Nedir?

Google Gemma logosu

Google’ın Gemma modeli, Google tarafından geliştirilen ve 2024’te tanıtılan açık kaynaklı ve hafif büyük dil modelleri ailesinin bir parçasıdır. Gemma, Google Gemini modelleriyle aynı araştırma ve teknolojiyi kullanarak oluşturulmuştur ve Gemini gibi, Keras ve Pytorch gibi başlıca makine öğrenmesi çerçeveleriyle uyumludur. 2B veya 7B parametreli iki boyutta sunulur.

Gemini ağırlıklı olarak son kullanıcılara doğrudan uygulamalar ve API’ler aracılığıyla yöneltilirken, Gemma geliştiriciler tarafından geniş ölçekte değiştirme ve entegrasyon için açık kaynaklıdır. Gemma modelleri ayrıca daha küçüktür; bu da onları daha taşınabilir ve maliyet etkin kılar. 

Tensor Processing Unit (TPU) Nedir?

CPU, GPU, TPU görselleri: Freepik ve Flaticon

Bağlam sağlamak için makine öğrenmesi için farklı donanım seçeneklerini karşılaştıralım. Donanım, işlem ve hesaplamada uzmanlaşmış rollere göre sınıflandırılır. 

• Merkezi İşlem Birimi (CPU): CPU’lar, neredeyse tüm bilişim aygıtlarında işletim sistemlerini çalıştırır. Görevleri ardışık olarak işlemeleriyle bilinirler.

• Grafik İşlem Birimi (GPU): GPU’lar, birden fazla görevi eşzamanlı işler; bu da onları grafik oluşturma için ideal kılar.

• Tensor Processing Unit (TPU): TPU’lar, Google tarafından makine öğrenmesinde kullanılmak üzere geliştirilen özel işlemcilerdir. Sinir ağı eğitimi ve çalıştırmasında kritik olan matris hesaplamalarını hızla yapmak ücin tasarlanmışlardır.

Bu eğitici açısından en önemli kategori TPU’lardır. TPU’lar, derin sinir ağı eğitimi ve çıkarımında GPU’lardan daha hızlıdır; ayrıca daha az güç tüketirler. Dezavantaj olarak, TPU ekosistemi daha az olgundur ve daha az araç/çerçeve bulunur. Mevcut çerçeveler arasında Google Cloud Platform, Colab ve Kaggle yer alır.

Makine öğrenmesi donanım karşılaştırma tablosu

TPU’larla Google Gemma’ya Erişme

Gemma modelleri, dağıtık hesaplama kurulumlarıyla kullanıldığında çok ölçeklenebilir ve verimli olacak şekilde tasarlanmıştır; bu da özellikle büyük veri hacimlerini ve karmaşık mimarileri işlerken performansı ve hızı belirgin şekilde artırabilir.

Keras kütüphanesi bu durumda iyi çalışır; çü̈nkü TensorFlow ve PyTorch dahil çoklu arka uç uygulamasını (multi-backend) kullanarak Gemma modellerinin dağıtık eğitimini destekler.

Bu bölünde TPU’ları destekleyecek şekilde Kaggle defterimizi (notebook) yapılandıracağız ve sorunsuz çalışma için gerekli tüm kütüphane ve bağımlılıkları yükleyeceğiz. Ardından keras-nlp paketini kullanarak Gemma 2B veya 7B modelini yükleyeceğiz. Son olarak, TPU’nun güçlü hesaplama yeteneklerinden yararlanarak görevler gerçekleştirmek üzere modeli devreye alacak ve yanıtları verimli bir şekilde işleyeceğiz. 

Kurulum

Ortamımızı hazırlamak için Gemma modelinin Keras sürümünü entegre etmemiz ve daha iyi performans için hesaplama ivmelendiricimizi TPU’ya geçirmemiz gerekir. keras-nlp gibi temel paketleri yükleyecek, Keras‑ın arka ucu olarak TensorFlow’u seçecek ve model eğitimi ve çalışmasının sorunsuz olması için TPU bellek ayırımını optimize edeceğiz.

Gemma modeline Keras uygulaması ekleyin

Ortamı hazırlamak için Gemma modeline Keras uygulaması eklememiz gerekir. Bu, TensorFlow API’leriyle sorunsuz entegrasyon sağlamak için Gemma’nın Keras uyumlu sürümünü dahil edeceğimiz anlamına gelir.

Keras uygulamasını eklemek için şu adımları izliyoruz:

• Kaggle’da yeni bir defter oluşturun.

• Sağ paneldeki "Input" bölüme gidin.

• Gemma modelinin Keras uygulamasını eklemek için “+ Add Input”’a tıklayın.

Gemma modeline Keras uygulaması ekleme

İvmelendiriciyi TPU olarak değiştirin

Sonra, ivmelendiriciyi TPU olarak değiştirmemiz gerekir; yani defter ayarlarında hesaplama ivmelendiricisini TPU’ya çevirerek eğitim ve çıkarım için işlem gücünden yararlanacağız.

İvmelendiriciyi değiştirmek için şu adımları izliyoruz. Ortamın yeniden yüklenmesi birkaç dakika alırsa bu normaldir.

• "Session options" bölüme gidin.
• İvmelendiriciyi "None" seçeneğinden "TPU VM v3-8" seçeneğine değiştirin.

TPU’yu ivmelendirici olarak ayarlama

İnce ayar ve çıkarım için gereken Python paketlerini yükleyin

Şimdi, TensorFlow ve keras-nlp dahil, ince ayar ve çıkarım için kullanacağımız güncel Python paketlerini yüklüyoruz. 

!pip install -q tensorflow-cpu!pip install -q -U keras-nlp tensorflow-hub!pip install -q -U keras==3.1.1Altyapı:

Keras arka ucunu ayarlayın

TPU’lara kesintisiz erişim için Keras arka ucunu JAX olarak ayarlıyoruz. Dilerseniz TensorFlow veya PyTorch’u da deneyebilirsiniz.  

TPU belleğini önceden ayırın

Son olarak, model çalışması sırasında performansı optimize etmek ve çalışma zamanı sorunlarını önlemek için TPU belleğini önceden ayırıyoruz. Burada, JAX arka ucunda bellek parçalanmasını önlemek için toplam TPU belleğinin %100’ünü önceden ayırıyoruz. 

import osos.environ["KERAS_BACKEND"] = "jax"os.environ["XLA_PYTHON_CLIENT_MEM_FRACTION"]="1.00"Altyapı:

Modeli yükleme

Model çıkarımı için gerekli Python paketlerini yüklüyoruz. 

import kerasimport keras_nlpAltyapı:

Ardından modelimizi yükleyip model özetini gösteriyoruz. 

gemma_lm = keras_nlp.models.GemmaCausalLM.from_preset("gemma_instruct_2b_en")gemma_lm.summary()Altyapı:

Yalnızca tek bir komutla hem belirteçleyiciyi (tokenizer) hem modeli başarıyla yükledik. Bu etkileyici; çünkü en küçük Gemma modelinin bile 2,5 milyar parametresi ve 9,34 GB boyutu var. 

Gemma model özeti

Defteri çalıştırmak ve çok hızlı performans görmek için birkaç dakika beklemeniz gerekebilir. Bunun nedeni TPU’lara yüksek talep olmasıdır. Defterinizi gece çalıştırırsanız beklemeden kurtulabilirsiniz. 

TPU erişimi için sıraya girme

Model çıkarımı

Çıkarım çalıştırmak, modelimizi yeni ve görmedik girdi̇lere dayalı çıktılar üretmek için kullanma işlemini ifade eder. Bağlamımızda bu girdileri .generate() fonksiyonunu kullanarak metin ölçeğinde sağlayacağız. Yanıtı anında alacağız. 

print(gemma_lm.generate("What is DataCamp?", max_length=30))Altyapı:

What is DataCamp?DataCamp is a leading online data science education platform that empowers individuals and organizations to build data-driven careers. TheyAltyapı:

Ayrıca toplu çıkarımı da deneyebiliriz; yani birden fazla yanıt üretmek için birden fazla istem sağlayacağız. Çıktı bir liste olarak gelir. 

print(gemma_lm.generate(["How far is the Sun from earth", "What is the Sun made of?"], max_length=30))Altyapı:

['How far is the Sun from earth?\n\nThe Sun is about 149.6 million kilometers (93 million miles) away from', 'What is the Sun made of?\n\nThe Sun is primarily composed of hydrogen and helium. Hydrogen makes up about 73.4% of']Altyapı:

Sonraki adımda, modelimizi yönlendirmek için talimatlar ve yanıtlardan oluşan bir şablon oluşturmayı deneyeceğiz. Üretilen yanıtı değiştirmek için bir sistem istemi ya da başka bir başlangıç komutu ekleyebilirsiniz. 

.format() fonksiyonunu kullanarak şablon metnini kullanıcı argümanlarıyla dolduracağız. Sonuç olarak, Python öğrenmek için izleyebileceğimiz adım adım bir liste elde ediyoruz.

template = "Instruction:\n{instruction}\n\nResponse:\n{response}"prompt = template.format(    instruction="How do I start learning Python?",    response="",)print(gemma_lm.generate(prompt, max_length=250))Altyapı:

Instruction:How do I start learning Python?Response:**Step 1: Choose a learning path*** **Online Courses:**    * DataCamp    * Codecademy    * Coursera    * edX    * Udemy* **Books:**    * "Automate the Boring Stuff with Python" by Al Sweigart    * "Python Crash Course" by Eric Matthes    * "Head First Python" by Kathy Sierra and Bert Bates* **Video Tutorials.........Altyapı:

Eğer TPU kullanarak modeli yüklemekte ve yanıt üretmekte sorun yaşıyorsanız, bu Kaggle defterine bakabilirsiniz: TPU’ları kullanarak Gemma-instruct-2b-en’e erişim.

Gemma’yı kullanmada rahatsanız, Fine Tuning Google Gemma: Enhancing LLMs with Customized Instructions eğiticimize göz atarak Gemma’yı özelleştirilmiş talimatlarla nasıl geliştirebileceğinizi öğrenin.

TPU’larla Gemma’nın İnce Ayarı

Şimdi OpenHermes adlı herkese açık bir veri kümesini kullanarak Gemma modelini nasıl ince ayar edeceğimizi öğrenelim. OpenHermes veri kümesi, biri talimatlar diğeri yanıtlar için olmak üzere iki sütun içeren 242.000 satırdan oluşur ve hepsi GPT-4 modeli kullanılarak üretilmiştir.

Göreceğimiz üzere, bu veri kümesinin ince ayarı TPU kullansak bile çok zaman alacaktır. Süreci hızlandırmak için LoRA adlı bir teknik kullanacağız.

LoRA (Low-Rank Adaptation), büyük dil modellerinin ince ayarını daha verimli ve erişilebilir kılarak geliştirmek ücin tasarlanmıştır. Geleneksel ince ayar yöntemlerinin sıkça hesaplama ağır ve kaynak yoğun olmasından doğan zorlukları ele alır.

Teknik düzeyde LoRA, modelin önceden eğitilmiş ađırlıklarını sabitleyip (freeze) mimarinin belli kısımlarını değiştiren düşük rütbeli (low-rank) matrisler ekleyerek çalışır. Bu matrislere odaklanarak hesaplama kaynak ihtiyacını en aza indirir ve büyük modellerin daha mütevazı donanımlarda bile ince ayarını mümkün kılar.

Kurulum

Önceki model ortamı kurulumuna benzer şekilde, Keras arka ucunu ve bellek ön ayırımını ayarlayacağız. Ayrıca TPU aygıtlarının uygunluğunu denetlemek için jax. devices() fonksiyonunu kullanabiliriz. 

import osimport jaxos.environ["KERAS_BACKEND"] = "jax"os.environ["XLA_PYTHON_CLIENT_MEM_FRACTION"] = "0.9"jax.devices()Altyapı:

Hesaplama aygıtı sayısı

Modeli ve veri kümesini yükleme

Modeli yükleyip model özetini gösteriyoruz. 2,5B eğitilebilir parametreye sahibiz.

import kerasimport keras_nlpgemma_lm = keras_nlp.models.GemmaCausalLM.from_preset("gemma_2b_en")gemma_lm.summary()Altyapı:

Gemma model özeti

Sıradan veri kümesini deftere yükleyelim. Süreç, modeli eklemeye benzer. Şu adımları izliyoruz:

• "Add input" bölüme gidin. 
• OpenHermes veri kümesini aratın. 
• Veri kümesini ekleyin. Net olmak için, Volodymyr Pivoshenko tarafından barındırılanı seçiyoruz.

OpenHermes veri kümesini ekleme

Artık pandas kütüphanesini kullanarak veri kümesini okuyup ilk 5 satırı gösteriyoruz. İkisinden biri talimat, diğeri yanıt olan 2 sütunumuz olduğunu görüyoruz.

import pandas as pddf = pd.read_csv('/kaggle/input/openhermes/openhermes.csv')df.head()Altyapı:

OpenHermes veri kümesi

Modelimizi ve veri kümesini yüklediğimize göre, veri kümesini modele beslememiz gerekir. Bunu yapmak için veri kümesini talimat ve yanıt formatında bir dizi metne dönüştürmeliyiz.

Görüldüğü gibi, tüm veri kümesini eğitmek TPU’lar üzerinde bile yaklaşık 23 saat sürecektir. Bu nedenle eğitim süresini azaltmak için listeden yalnızca ilk 1.000 örnek seçeceğiz.

template = "Instruction:\n{instruction}\n\nResponse:\n{output}"data = [template.format(**row) for index, row in df.iterrows()]Altyapı:

data = data[:1000]print(data[0])Altyapı:

OpenHermes veri kümesinden ilk örnek

İnce ayardan önce çıkarım

Önce LoRA kullanımının başarısını karşılaştıracağımız bir temel çizgi (baseline) oluşturalım. Bunu yapmak için template.format() fonksiyonunu kullanarak yanıt üreteceğiz.

Dikkatle okuduğumuza, aşağıdaki çıktının temel yanıtın pek ayrıntılı olmadığını gösterdiğini fark edeceksiniz. Gemma, ilk yanıtın sonunda kendini tekrarlamaya bile başlıyor. Bu harika bir sonuç değil; ama modelimizi daha iyi yanıtlar için ince ayar etme ihtiyacını iyi gösteriyor.

prompt = template.format(    instruction="Plan a 5-day Bahamas trip.",    output="",)print(gemma_lm.generate(prompt, max_length=256))Altyapı:

Instruction:Plan a 5-day Bahamas trip.Response:Day 1:Fly to Nassau, Bahamas.Visit the Atlantis Resort.Day 2:Visit the Exuma Cays.Day 3:Visit the Lucayan National Park.Day 4:Visit the Great Abaco Islands.Day 5:Fly home.Instruction:Plan a 5-day Bahamas trip.Response:Day 1:Fly to Nassau, Bahamas.Visit the Atlantis Resort.Day 2:Visit the Exuma Cays.Day 3:Visit the Lucayan National Park.Day 4:Visit the Great Abaco Islands.Day 5:Fly home.Instruction:Plan a 5-day Bahamas trip.Response:Day 1:Fly to Nassau, Bahamas.Visit the Atlantis Resort.Day 2:Visit the Exuma Cays.Day 3:Visit the Lucayan National Park.Day 4:Visit the Great Abaco Islands.Day 5:Fly home.Instruction:Plan a 5-dayAltyapı:

İnce ayar için modeli derleme

Artık, aşağı akış görevleri için eğitilebilir parametre sayısını azaltan LoRA ile modelimizi geliştirelim. 

Bu örnekte, hesaplama açısından en verimli en düşük rütbe olan LoRA rütbe 4 ile ince ayar yapacağız. Model performansını artırmak isterseniz LoRA rütbe 8 veya 16 seçenekleri de vardır. LLaMA 2’yi İnce Ayarlama rehberini okuyarak LoRA ve niceleme (quantization) hakkında daha fazla bilgi edinin.

Ardından kullanacağımız optimize ediciyi (optimizer), kayıp fonksiyonunu ve doğruluk metriğini belirtiriz.

gemma_lm.backbone.enable_lora(rank=4)Altyapı:

gemma_lm.preprocessor.sequence_length = 512optimizer = keras.optimizers.AdamW(    learning_rate=5e-5,    weight_decay=0.01,)optimizer.exclude_from_weight_decay(var_names=["bias", "scale"])gemma_lm.compile(    loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),    optimizer=optimizer,    weighted_metrics=[keras.metrics.SparseCategoricalAccuracy()],)gemma_lm.summary()Altyapı:

Eğitilebilir parametrelerimiz 2,5 milyardan 1,3 milyona kayda değer şekilde düştü. Ve adaptör katmanının boyutu yalnızca 5,2 MB. 

Gemma modeli: toplam ve eğitilebilir parametreler

Modelin eğitimi

Şimdi verilerimizi modele uyduracağız (fit). Burada 1 epoch ve 1 batch boyutu seçiyoruz. Model performansını, tüm veri kümesini en az 5 epoch eğiterek artırabilirsiniz. 

gemma_lm.fit(data, epochs=1, batch_size=1)Altyapı:

İnce ayardan sonra çıkarım

Ölçüt olarak kullandığımız aynı istemi tekrar deneyelim ve modelimizin gelişip gelişmediğine bakalım. Bu kez, tek satırlı yanıtlar ve tekrar yerine modelimiz Bahamalar için ayrıntılı bir gezi planı sunuyor.

prompt = template.format(    instruction="Plan a 5-day Bahamas trip.",    output="",)print(gemma_lm.generate(prompt, max_length=256))Altyapı:

Instruction:Plan a 5-day Bahamas trip.Response:Day 1: Arrive in Nassau, BahamasUpon arrival in Nassau, you will be greeted by a local guide who will take you on a tour of the city. Visit the famous Straw Market, where you can shop for souvenirs and local crafts. Enjoy lunch at a local restaurant before heading to the Atlantis Resort for a day of fun and relaxation. Spend the afternoon exploring the resort's world-class amenities, including the Aquaventure Water Park, Dolphin Cay, and the massive marine habitat, The Dig.Day 2: Explore Paradise IslandOn day 2, you will explore Paradise Island, home to the world-famous Atlantis Resort. Visit the famous Atlantis Casino and enjoy a round of blackjack or roulette. Take a stroll along the beach and enjoy the crystal-clear waters of the Atlantic Ocean. Visit the Dolphin Cay, where you can swim with dolphins and other marine animals.Day 3: Snorkel at Cabbage BeachOn day 3, you will head to Cabbage Beach, a secluded beach located on Paradise Island. Snorkel in the crystal-clear waters and explore the coral reefs. Enjoy a delicious lunch at a local restaurant before heading back to Nassau.Altyapı:

Model ağırlıklarını çıkarım için kaydedebilir ve modeli prodüksiyona alabilirsiniz. 

gemma_lm.save_weights('gemma_2b_openhermes.weights.h5')Altyapı:

İnce ayar yapılmış modelimizin toplam boyutu 10,04 GB. 

Gemma ince ayar yapılıp kaydedilmiş model dosyası

Eğer modelinizi ince ayar etmekte zorluk yaşıyorsanız, referans olarak bu Kaggle defterine bakabilirsiniz: TPU’ları kullanarak Gemma’da ince ayar

TPU’larla Gemma’nın Dağıtık İnce Ayarı ve Çıkarımı

Son bölüm olarak, dağıtık ince ayara yakından bakacağız. Dağıtık ince ayar, tek bir modelin ağırlıklarını birden çok cihaza yayıp yatay ölçeklemeye imkan tanıyan ve eğitimi hızlandıran model paralelliği yoluyla gerçekleştirilir.

Bu kısımda, büyük bir modelde eğitim süresini belirgin ölçüde azaltacağız. Özellikle, TPUs üzerinde LoRA ve dağıtık eğitimle Gemma’ya ince ayar yapmak için JAX arka uçlu Keras kullanacağız. 

Kurulum

Burada yeni bir Kaggle defteri başlatıp gerekli kütüphaneleri yüklüyoruz. Ardından Keras arka ucunu ayarlayıp belleği önceden ayırıyoruz.

!pip install -q tensorflow-cpu!pip install -q -U keras-nlp tensorflow-hub!pip install -q -U keras==3.1.1Altyapı:

import osos.environ["KERAS_BACKEND"] = "jax"os.environ["XLA_PYTHON_CLIENT_MEM_FRACTION"] = "0.9"Altyapı:

8 TPU için Dağıtımı Ayarlama

Önce, model ağırlıklarını ve tensörleri birden çok TPU aygıtına dağıtarak yüklememize yardımcı olacak bir DeviceMesh oluşturacağız. Bu, veri ve model paralelliği sağlayarak LLM’lerin birden çok ivmelendirici üzerinde verimli ölçeklenmesini mümkün kılar.

(1, 8) şeklinde bir DeviceMesh oluşturun; böylece model ağırlıkları tüm 8 TPU’ya paylaştırılır.

import kerasimport keras_nlpdevice_mesh = keras.distribution.DeviceMesh(    (1, 8), ["batch", "model"], devices=keras.distribution.list_devices())Altyapı:

Sonraki adımda, ağırlıkların ve tensörlerin RegEx kullanılarak nasıl paylaştırılacağını ya da kopyalanacağını belirten bir yerleşim haritası (layout map) oluşturacağız.

Şu noktalara dikkat edin:

• token_embedding/embeddings ile eşleşen ağırlıklar paylaşılacaktır.

• Decoder içindeki attention, attention_output, ffw_gating ve ffw_linear katmanlarındaki query, key ve value matrislerini RegEx ile eşleştirin.

• Eşleşen tensörler DeviceMesh kullanılarak paylaşılacak, kalanlar tam kopyalanacaktır.

model_dim = "model"layout_map = keras.distribution.LayoutMap(device_mesh)layout_map["token_embedding/embeddings"] = (None, model_dim)layout_map["decoder_block.*attention.*(query|key|value).*kernel"] = (    None,    model_dim,    None,)layout_map["decoder_block.*attention_output.*kernel"] = (None, None, model_dim)layout_map["decoder_block.*ffw_gating.*kernel"] = (model_dim, None)layout_map["decoder_block.*ffw_linear.*kernel"] = (None, model_dim)Altyapı:

Artık device_mesh ve layout_map kullanarak model paralelliğini etkinleştireceğiz. 

model_parallel = keras.distribution.ModelParallel(    device_mesh, layout_map, batch_dim_name="batch")keras.distribution.set_distribution(model_parallel)Altyapı:

Modeli Yükleme

Model paralelliğini kurduktan sonra modelimizi yüklüyoruz. 

gemma_lm = keras_nlp.models.GemmaCausalLM.from_preset("gemma_7b_en")gemma_lm.summary()Altyapı:

Bu kez Gemma 7B modelini kullandığımız için 8,5 milyar eğitilebilir parametre görüyoruz. 

Gemma 7B model özeti

Modelin düzgün bir şekilde paylaştırıldığını doğrulamak için, decoder_block_1 katmanı ağırlıklarının path, shape ve spec bilgilerini yazdıracığız. 

decoder_block_1 = gemma_lm.backbone.get_layer('decoder_block_1')print(type(decoder_block_1))for variable in decoder_block_1.weights:  print(f'{variable.path:<58}  {str(variable.shape):<16}  {str(variable.value.sharding.spec)}')Altyapı:

Decoder bloğu

Veri Kümesini Yükleme

OpenHermes veri kümesini yükleyelim. Yine, veri çerçevesini (data frame) talimat ve yanıt şablonunu kullanarak bir metin listesine dönüştürüyor ve eğitim süresini hızlandırmak için yalnızca ilk 1.000 örneği seçiyoruz. 

import pandas as pddf = pd.read_csv('/kaggle/input/openhermes/openhermes.csv')# Format and convert the dataframe into a list of strings.template = "Instruction:\n{instruction}\n\nResponse:\n{output}"data = [template.format(**row) for index, row in df.iterrows()]# Select a subset of the dataset. data = data[:1000]Altyapı:

İnce Ayardan Önce Çıkarım

Biçimlendirilmiş istemi sağlayarak temel çıktıyı üreteceğiz. İlginç şekilde, yanıt küçük modelinkinden bile kötü; ancak devam edelim. 

prompt = template.format(    instruction="Plan a 5-day Bahamas trip.",    output="",)print(gemma_lm.generate(prompt, max_length=256))Altyapı:

 İnce ayardan önce çıkarım sonucu

İnce Ayar İçin Modeli Derleme

Modeli, aynı model yapılandırmaları, LoRA rütbesi, optimize edici, kayıp fonksiyonu ve doğruluk metriğiyle derleyeceğiz. Artık 42,22 MB boyutunda 11 milyon eğitilebilir parametreye sahibiz.

gemma_lm.backbone.enable_lora(rank=4)gemma_lm.preprocessor.sequence_length = 512optimizer = keras.optimizers.AdamW(    learning_rate=5e-5,    weight_decay=0.01,)optimizer.exclude_from_weight_decay(var_names=["bias", "scale"])gemma_lm.compile(    loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),    optimizer=optimizer,    weighted_metrics=[keras.metrics.SparseCategoricalAccuracy()],)gemma_lm.summary()Altyapı:

Gemma 7B LoRA model özeti

Modelin Eğitimi

Modelin büüklüğü göz önüne alındığında, bir epoch ince ayar için 305 saniye süre harikamız. 

gemma_lm.fit(data, epochs=1, batch_size=1)Altyapı:

Eğer ince ayarı zor buluyorsanız, OpenAI’nın API’sini kullanmayı öğrenebilir ve adım adım GPT-4 ince ayar rehberini izleyebilirsiniz. 

İnce Ayardan Sonra Çıkarım

Yanıtı üretelim ve temel sonuçla karşılaştıralım. 

prompt = template.format(    instruction="Plan a 5-day Bahamas trip.",    output="",)print(gemma_lm.generate(prompt, max_length=256))Altyapı:

İnce ayarlanmış model oldukça iyi. Beş günlük Bahamalar seyahatinizden keyif almak için yapmanız gerekenlerin bir listesini üreten bir yanıt oluşturdu. 

Not: Model paralelliği ile daha yavaş ama daha doğru tam parametreli ince ayar için LoRA’yı kapatabilirsiniz.

İnce ayardan sonra çıkarım sonucu

gemma_lm.save_weights('gemma_7b_openhermes.weights.h5')Altyapı:

Yine, dağıtık ince ayarda sorun yaşıyorsanız ek kaynak olarak bu Kaggle defterine bakabilirsiniz: TPU’ları kullanarak Gemma-instruct-2b-en’e erişim. 

Sonuç

Bu eğiticide TPU’ları ve LLM’lerin yanıt üretimini hızlandırmak için bunları nasıl kullanacağımızı öğrendik. Ayrıca TPU’lar ve dağıtık eğitim kullanarak Gemma modellerine OpenHermes veri kümesinde ince ayar yaptık.

LLM’lere TPU’larda ince ayar yapmak ve dağıtık öğrenme için model paralelliğini kullanmak, eğitim süresini hızlandırmanın önemli yollarıdır. Dağıtık öğrenmeyle, Gemma 7B gibi çok büyük modellerde bile ince ayar yapabilirsiniz. Özellikle yüksek performanslı makine öğrenmesi görevleri için tasarlanan TPU’lardan yararlanarak hem eğitim hem çıkarım aşamalarında kayda değer hız kazançları elde edebilirsiniz.

Bu eğiticiyi beğendiyseniz ve büyük dil modelleri dünyası hakkında daha fazla öğrenmek istiyorsanız, LLM uygulamaları, eğitim yöntemleri, etik boyutlar ve en yeni araştırmayı kapsayan Master Large Language Models (LLMs) Concepts kursunu alarak LLM’lerin tam potansiyelini keşfedin. Gemma ile rekabet eden diğer büyük dil modelleri ilginizi çekiyorsa, Mistral AI’ın yeni modeli ve seyrek uzman karışımı (SMoE) mimarisini öğrenmek için Mixtral 8X22B ile Başlangıç eğiticimize göz atın.