Gemma 2'yi İnce Ayarlama ve Yerel Olarak Kullanma

Bu eğitimde, Gemma 2 modelini hasta ve doktor konuşmaları veri seti üzerinde nasıl ince ayar yapacağımızı öğreneceğiz. Ayrıca modeli GGUF biçimine dönüştürerek dizüstü bilgisayarda çevrimdışı olarak yerel kullanımını sağlayacağız. 

İnce ayara geçmeden önce Gemma 2 ve önceki nesillere göre getirdiği iyileştirmeleri ele alacağız. Ardından kaydedilen adaptörü temel modelle birleştirip tam modeli Hugging Face Hub'a yükleyecek, modeli dönüştürmek ve kuantize etmek için bir Hugging Face Space kullanacağız. Son olarak kuantize edilmiş modeli indirip Jan uygulamasıyla yerelde kullanacağız. 

Görsel: Yazar

Gemma 2'yi Anlamak

Gemma 2, Google'ın açık büyük dil modeli (LLM) ailesi Gemma'nın en son sürümüdür. Ticari kullanıma uygun bir lisans altında, 9 milyar (9B) ve 27 milyar (27B) parametre olmak üzere iki boyutta araştırmacı ve geliştiricilerin kullanımına sunulmuştur. Bu, modeli özel veri setiniz üzerinde ince ayarlayıp, herhangi bir kısıtlama olmaksızın üretime alabileceğiniz anlamına gelir. 

Kaynak: Google, Gemma 2'yi duyurdu

Gemma 2, performans ve çıkarım verimliliğinde önemli gelişmeler sunar. Yeniden tasarlanan mimarisi, çeşitli donanım kurulumlarında son derece hızlı çıkarım ve Hugging Face Transformers, JAX, PyTorch ve TensorFlow gibi başlıca yapay zeka çatılarıyla sorunsuz entegrasyon sağlar. 

Gemma 2 ayrıca etik yapay zeka dağıtımı için güçlü güvenlik önlemleri ve araçlar içerir. Çeşitli kıyaslamalarda Llama 3 ve Groq-1'i geride bırakır ve zahmetsiz ince ayar ile model çıkarımı için geliştirilmiş Keras 3 entegrasyonuyla gelir. 

Gemma modellerinin ilk nesli hakkında bilgi edinmek isterseniz, kapsamlı bir kaynak olan şu eğitimimize göz atın: Google Gemma’yı İnce Ayarlama: Özelleştirilmiş Talimatlarla LLM’leri Geliştirme. Bu kaynak, Gemma 7b-it gibi Gemma modellerinin belirli veri setleri ve görevlerde nasıl ince ayarlanacağına dair kapsamlı bir rehber sunar. 

Gemma 2'ye Erişim

Bu bölümde modeli indirecek, 4-bit kuantizasyonla yükleyecek ve ardından bir GPU üzerinde çıkarım çalıştıracağız. 

1. Gerekli tüm Python paketlerini yükleyin. 

%%capture
%pip install -U bitsandbytes
%pip install -U transformers
%pip install -U accelerate

2. Geliştirme ortamı olarak Kaggle kullanıyoruz. "Secrets" işleviyle bir ortam değişkeni oluşturup etkinleştirmemiz gerekiyor. Bu ortam değişkeni, Hugging Face web sitesine giriş yaparak oluşturabileceğiniz bir Hugging Face belirteci (token) içerir. 

3. Hugging Face belirtecini Kaggle Secrets üzerinden güvenli bir şekilde alın ve Hugging Face CLI'a giriş yapmak için kullanın. Giriş yapmak, kısıtlı modellere ve veri setlerine erişip indirmemize yardımcı olacaktır. 

from huggingface_hub import login
from kaggle_secrets import UserSecretsClient
user_secrets = UserSecretsClient()

hf_token = user_secrets.get_secret("HUGGINGFACE_TOKEN")
login(token = hf_token)

4. Hugging Face üzerindeki Gemma 2 model deposu bağlantısını kullanarak tokenleştiriciyi yükleyin. 
5. Modeli model adı, 4-bit kuantizasyon ayarları ve aygıt haritasını kullanarak yükleyin. Önce tam model dosyalarını indirecek, ardından hesaplama ve belleği optimize etmek için modeli 4-bit olarak yükleyecektir. 

Not: Gemma 2 9B-It modeli büyüktür ve 16 GB GPU belleğiyle bile tam modeli yükleyemiyoruz. Bu nedenle modeli 4-bit kuantizasyon ile yüklüyoruz. 

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig, AutoConfig

modelName = "google/gemma-2-9b-it"

bnbConfig = BitsAndBytesConfig(
    load_in_4bit = True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16,
)

tokenizer = AutoTokenizer.from_pretrained(modelName)

model = AutoModelForCausalLM.from_pretrained(
    modelName,
    device_map = "auto",
    quantization_config=bnbConfig
)

6. Sistem talimatlarını ve kullanıcının sorusunu kullanarak istemi (prompt) oluşturun.
7. İstemleri, tokenleştiriciler aracılığıyla belirteçlere dönüştürün.
8. Yanıtı üretin ve okunabilir İngilizce metne çözümleyin.
9. Sonucu, Markdown biçimini HTML biçimine dönüştürerek görüntüleyin. 

from IPython.display import Markdown, display

system =  "You are a skilled software architect who consistently creates system designs for various applications."
user = "Design a system with the ASCII diagram for the customer support application."

prompt = f"System: {system} \n User: {user} \n AI: "
    
inputs = tokenizer(prompt, return_tensors='pt', padding=True, truncation=True).to("cuda")

outputs = model.generate(**inputs, max_length=500, num_return_sequences=1)

text = tokenizer.decode(outputs[0], skip_special_tokens=True)

Markdown(text.split("AI:")[1])

Görüldüğü gibi, Gemma 2 modeli harika bir iş çıkardı. 

Yukarıdaki kodu çalıştırmakta sorun yaşıyorsanız, lütfen şu Kaggle defterine bakın: GPU'da Gemma 2 Basit Çıkarım.

LoRA Kullanarak Gemma 2'yi İnce Ayarlama

Bu bölümde, hasta ve doktorlar arasındaki konuşmalardan oluşan sağlık veri seti üzerinde Gemma 2 9B-It modelini ince ayarlayacağız. Model ve tokenleştiriciyi yükleyecek, veri setini indirecek, dönüştürecek, eğitim argümanlarıyla modeli kuracak ve Weights and Biases API'siyle model performansını takip edeceğiz.  

İnce ayar kuramının nasıl çalıştığını anlamakla ilgileniyorsanız, şu rehberimizi okuyun: LLM’leri İnce Ayarlamaya Giriş Rehberi.

1. Kurulum

Modeli sağlık veri seti üzerinde yüklemek, ince ayarlamak ve değerlendirmek için gerekli Python paketlerini kurun. 

%%capture
%pip install -U transformers 
%pip install -U datasets 
%pip install -U accelerate 
%pip install -U peft 
%pip install -U trl 
%pip install -U bitsandbytes 
%pip install -U wandb

Gerekli Python paketlerini ve işlevleri yükleyin. 

from transformers import (
    AutoModelForCausalLM,
    AutoTokenizer,
    BitsAndBytesConfig,
    HfArgumentParser,
    TrainingArguments,
    pipeline,
    logging,
)
from peft import (
    LoraConfig,
    PeftModel,
    prepare_model_for_kbit_training,
    get_peft_model,
)
import os, torch, wandb
from datasets import load_dataset
from trl import SFTTrainer, setup_chat_format

Kaggle Secrets kullanarak kaydettiğimiz API anahtarıyla Hugging Face CLI'a giriş yapın. 

from huggingface_hub import login
from kaggle_secrets import UserSecretsClient
user_secrets = UserSecretsClient()

hf_token = user_secrets.get_secret("HUGGINGFACE_TOKEN")
login(token = hf_token)

Model performans takibini başlatmak için Weights and Biases API anahtarını Kaggle Secrets’tan yükleyin. 

wb_token = user_secrets.get_secret("wandb")

wandb.login(key=wb_token)
run = wandb.init(
    project='Fine-tune Gemma-2-9b-it on HealthCare Dataset', 
    job_type="training", 
    anonymous="allow"
)

Modeli ve veri setini Hugging Face Hub’dan yükleyebilmek için kimliklerini ayarlıyoruz. Ayrıca ince ayarlı modelin adını belirleyip Hugging Face üzerinde bir depo oluşturacak ve modeli oraya göndereceğiz.

base_model = "google/gemma-2-9b-it"
dataset_name = "lavita/ChatDoctor-HealthCareMagic-100k"
new_model = "Gemma-2-9b-it-chat-doctor"

2. Model ve tokenleştiriciyi yükleme

GPU'ya bağlı olarak veri türü ve dikkat (attention) uygulamasını ayarlama. 

if torch.cuda.get_device_capability()[0] >= 8:
    !pip install -qqq flash-attn
    torch_dtype = torch.bfloat16
    attn_implementation = "flash_attention_2"
else:
    torch_dtype = torch.float16
    attn_implementation = "eager"

Modeli 4-bit hassasiyetle yükleyebilmek, bellek kullanımını azaltmak ve ince ayar sürecini hızlandırmak için QLoRA yapılandırmasını oluşturmalıyız.

# QLoRA config
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch_dtype,
    bnb_4bit_use_double_quant=True,
)

Model URL’si, LoRA yapılandırması ve attention uygulamasını kullanarak Gemma 2 9B-It modelini ve tokenleştiriciyi yükleyin.

# Load model
model = AutoModelForCausalLM.from_pretrained(
    base_model,
    quantization_config=bnb_config,
    device_map="auto",
    attn_implementation=attn_implementation
)

# Load tokenizer
tokenizer = AutoTokenizer.from_pretrained(base_model, trust_remote_code=True)

3. Adaptörü katmana ekleme

Modeli kullanacak ve tüm lineer modüllerin adlarını çıkaracak Python işlevini oluşturun. 

import bitsandbytes as bnb

def find_all_linear_names(model):
    cls = bnb.nn.Linear4bit
    lora_module_names = set()
    for name, module in model.named_modules():
        if isinstance(module, cls):
            names = name.split('.')
            lora_module_names.add(names[0] if len(names) == 1 else names[-1])
    if 'lm_head' in lora_module_names:  # needed for 16 bit
        lora_module_names.remove('lm_head')
    return list(lora_module_names)

modules = find_all_linear_names(model)

Tüm modeli ince ayarlamak uzun sürecektir; bu nedenle eğitim sürecini hızlandırmak için bir adaptör katmanı oluşturup ekleyeceğiz; böylece süreç daha hızlı ve bellek açısından verimli olacaktır. 

Adaptasyon katmanı hedef modüller ve görev türü kullanılarak oluşturulur. Ardından model ve tokenleştirici için sohbet biçimini (chat format) ayarlıyoruz. Son olarak temel modeli adaptöre ekleyerek Parametre Verimli İnce Ayar (PEFT) modelini oluşturuyoruz.

# LoRA config
peft_config = LoraConfig(
    r=16,
    lora_alpha=32,
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM",
    target_modules=modules
)
model, tokenizer = setup_chat_format(model, tokenizer)
model = get_peft_model(model, peft_config)

4. Veri setini yükleme

Şimdi Hugging Face hub'dan lavita/ChatDoctor-HealthCareMagic-100k veri setini yükleyeceğiz. Veri seti üç sütundan oluşur:

1. instruction: Sistem talimatı içerir. 
2. input: Ayrıntılı hasta sorusu.
3. output: Doktorun hastanın sorusuna yanıtı. 

Veri setini yükledikten sonra karıştırıp eğitim süresini daha da azaltmak için 1000 örnek seçeceğiz. Son olarak varsayılan sohbet şablonunu kullanarak sohbet biçimini oluşturup “text” sütununu yaratacağız. 

#Importing the dataset
dataset = load_dataset(dataset_name, split="all")
dataset = dataset.shuffle(seed=65).select(range(1000)) # Only use 1000 samples for quick demo

def format_chat_template(row):
    row_json = [{"role": "system", "content": row["instruction"]},
               {"role": "user", "content": row["input"]},
               {"role": "assistant", "content": row["output"]}]
    row["text"] = tokenizer.apply_chat_template(row_json, tokenize=False)
    return row

dataset = dataset.map(
    format_chat_template,
    num_proc= 4,
)

dataset

Çıktı: 

Dataset({
    features: ['instruction', 'input', 'output', 'text'],
    num_rows: 1000
})

3. satırın “text” sütununu inceleyelim. 

dataset['text'][3]

“text” sütunu, OpenAI stilinde talimatları, hastanın sorusunu ve doktorun yanıtını içerir.

Model değerlendirmesi için veri setini eğitim ve test olarak böleceğiz. 

dataset = dataset.train_test_split(test_size=0.1)

5. Modeli derleme ve eğitme

Şimdi eğitim argümanlarını ve SFT parametrelerini ayarlayıp eğitimi başlatacağız. 

Ortamınıza, hesap gücüne ve belleğe göre çeşitli hiperparametreleri değiştirebilirsiniz. Aşağıdaki hiperparametreler Kaggle defteri için optimize edilmiştir. Aynısını Google Colab'de çalıştırmak isterseniz, eğitim algoritmalarıyla denemeler yapmayı düşünün. 

# Setting Hyperparamter
training_arguments = TrainingArguments(
    output_dir=new_model,
    per_device_train_batch_size=1,
    per_device_eval_batch_size=1,
    gradient_accumulation_steps=2,
    optim="paged_adamw_32bit",
    num_train_epochs=1,
    eval_strategy="steps",
    eval_steps=0.2,
    logging_steps=1,
    warmup_steps=10,
    logging_strategy="steps",
    learning_rate=2e-4,
    fp16=False,
    bf16=False,
    group_by_length=True,
    report_to="wandb"
)
# Setting sft parameters
trainer = SFTTrainer(
    model=model,
    train_dataset=dataset["train"],
    eval_dataset=dataset["test"],
    peft_config=peft_config,
    max_seq_length= 512,
    dataset_text_field="text",
    tokenizer=tokenizer,
    args=training_arguments,
    packing= False,
)

model.config.use_cache = False
trainer.train()

Modeli ince ayarlamak yaklaşık 25 dakika sürdü ve görüldüğü üzere eğitim ve doğrulama kaybı kademeli olarak azaldı. Daha iyi performans için modeli tam veri seti üzerinde en az üç dönem (epoch) eğitmeyi deneyin.

İnce ayar, yeni başlayanlar ve teknik olmayanlar için biraz teknik olabilir. Daha basit bir çözüm arıyorsanız şu eğitime göz atmalısınız: OpenAI'nin GPT-4’ünü İnce Ayarlama: Adım Adım Rehber. Bu eğitim, OpenAI API'sini kullanarak SOTA bir modeli basit şekilde ince ayarlamayı kapsar.

6. Model değerlendirme

Bir değerlendirme raporu üretecek olan Weights and Biases deneyini bitireceğiz. 

wandb.finish()
model.config.use_cache = True

Ayrıntılı raporu görüntülemek için Weights and Biases hesabınıza gidin ve "Fine-tune Gemma-2-9b-it on Healthcare Dataset" proje adına tıklayın.

Ekran görüntüsü: wandb.ai

7. Değişiklikleri kaydetme

İnce ayarlı adaptörü şimdi yerelde kaydedip Hugging Face hub’a da göndereceğiz. 

trainer.model.save_pretrained(new_model)
trainer.model.push_to_hub(new_model, use_temp_dir=False)

Kaydedilmiş adaptörü başka bir Kaggle defterinde kullanmak için defteri kaydetmemiz gerekir. Bunu sağ üstteki “Save Version”a tıklayarak yapabiliriz. Ardından “Quick Save” ve “Quick Save oluştururken çıktıyı her zaman kaydet” seçeneklerini işaretleyip “Save” düğmesine basın. 

Kodu çalıştırmakta sorun yaşıyorsanız, lütfen Kaggle Defterini klonlayıp çalıştırın. Hugging Face ve Weights & Biases API anahtarını Kaggle Secrets ile ayarlamanız gerekir.

İnce ayarın mı yoksa Retrieval-Augmented Generation (RAG) yaklaşımının mı kullanım durumunuza daha uygun olduğunu belirlemek için RAG ve İnce Ayar Karşılaştırması blog yazısını okumanızı önemle tavsiye ederim. 

Temel Modeli Adaptörle Birleştirme

Şimdi adaptörü temel modelle birleştirip tam modeli Hugging Face hub’a göndereceğiz.

CPU hızlandırıcılı yeni bir Kaggle defteri oluşturun ve gerekli Python paketlerini kurun.

Neden hızlandırıcı olarak CPU kullanıyoruz? Yavaş olmaz mı? Evet, ancak Kaggle’daki GPU makinesi bize yalnızca 16 GB GPU belleği sağlıyor; bu, 7 milyar parametreli bir model için yeterli olsa da 9 milyar parametreli bir model için yeterli değil. Öte yandan CPU makinesi 30 GB sağlıyor; bu da hem temel modeli hem adaptörü yüklemek için yeterli.

%%capture
%pip install -U bitsandbytes
%pip install -U transformers
%pip install -U accelerate
%pip install -U peft
%pip install -U trl

API anahtarını Kaggle Secrets’tan alın ve Hugging Face CLI’a giriş yapın. 

from huggingface_hub import login
from kaggle_secrets import UserSecretsClient
user_secrets = UserSecretsClient()

hf_token = user_secrets.get_secret("HUGGINGFACE_TOKEN")
login(token = hf_token)

Kaydedilmiş modele erişmek için kaydedilen Kaggle defterini içe aktarmanız gerekir. Bunu yapmak için sağ üstteki “Add Input” düğmesine tıklayın ve “Your Work” sekmesini seçin. Ardından, kaydedilen defterin yanındaki artı düğmesine tıklayarak tüm dosyalarına erişin. 

Temel model URL’sini Hugging Face depo adını vererek ayarlayın. Ayrıca adaptör URL’sini, adaptörün kaydedildiği yerel dizini belirterek yapılandırın.

base_model_url = "google/gemma-2-9b-it"
new_model_url = "/kaggle/input/fine-tune-gemma-2-9b-it-on-healthcare-dataset/Gemma-2-9b-it-chat-doctor/"

Tokenleştiriciyi ve tam modeli temel model URL’sini kullanarak yükleyin. Aygıtı “cpu” ve veri türünü “float16” olarak ayarladığınızdan emin olun.

from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig, pipeline
from peft import PeftModel
import torch
from trl import setup_chat_format


# Reload tokenizer and model
tokenizer = AutoTokenizer.from_pretrained(base_model_url)

base_model_reload= AutoModelForCausalLM.from_pretrained(
    base_model_url,
    low_cpu_mem_usage=True,
    return_dict=True,
    torch_dtype=torch.float16,
    device_map="cpu",
)

Sohbet biçimini yeni yüklenen temel modele ayarlayın ve adaptörle birleştirin. Sonunda adaptörü temel modele yükleyip birleştireceğiz. 

merge_and_unload() işlevi, adaptör ağırlıklarını temel modelle birleştirmemize ve modeli bağımsız olarak kullanmamıza yardımcı olacaktır.

base_model_reload, tokenizer = setup_chat_format(base_model_reload, tokenizer)
model = PeftModel.from_pretrained(base_model_reload, new_model_url)

model = model.merge_and_unload()

Tam modeli ve tokenleştiriciyi yerelde kaydedin.

model.save_pretrained("Gemma-2-9b-it-chat-doctor")
tokenizer.save_pretrained("Gemma-2-9b-it-chat-doctor")

Ayrıca tüm model dosyalarını ve tokenleştiriciyi Hugging Face hub’a gönderin. 

model.push_to_hub("Gemma-2-9b-it-chat-doctor", use_temp_dir=False)
tokenizer.push_to_hub("Gemma-2-9b-it-chat-doctor", use_temp_dir=False)

Hugging Face model deponuza gidip tüm dosyaları görüntüleyebilirsiniz. 

Kaynak: kingabzpro/Gemma-2-9b-it-chat-doctor · Hugging Face

Modelleri CPU kullanarak birleştirme konusunda sorun yaşıyorsanız, lütfen Kaggle Defterine bakın.

Hugging Face Space Kullanarak Kuantizasyon

GGUF My Repo Hugging Face Space'i ile model dönüştürme ve kuantizasyon kolay ve hızlı hale geldi. Tek yapmanız gereken giriş yapmak ve model kimliğini vermek. 

Kaynak: GGUF My Repo - ggml-org tarafından bir Hugging Face Space

Sizin için kuantize edilmiş model dosyasının bulunduğu yeni bir model deposu oluşturacak; daha sonra indirip yerelde kullanabilirsiniz. Bu kadar basit. 

Kuantizasyonun arkasındaki kuramı öğrenmek için Büyük Dil Modelleri (LLM’ler) için Kuantizasyon: Yapay Zeka Modellerini Verimli Şekilde Küçültme başlıklı makalemizi okuyabilirsiniz.

Kaynak: kingabzpro/Gemma-2-9b-it-chat-doctor-Q4_K_M-GGUF · Hugging Face

Ancak işleri bizzat yapmak ve kendi başınıza llama.cpp betiklerini çalıştırmak isterseniz, şu eğitime göz atın: Llama 3’ü İnce Ayarlama ve Yerelde Kullanma.

İnce Ayarlı Modeli Yerelde Kullanma

Kuantize modeli yerelde kullanmak için:

1. Önce resmi web sitesinden Jan uygulamasını indirip kurmamız gerekir. 
2. Uygulamayı başlatın ve “Model Hub”a gidin. Sol üstteki Windows “🪟” düğmesine tıklayarak menülere erişebilirsiniz. 
3. İnce ayarlı model depo bağlantısını arama çubuğuna yapıştırıp enter’a basın: "kingabzpro/Gemma-2-9b-it-chat-doctor-Q4_K_M-GGUF"

4. Doğrudan modeli indirebileceğimiz yeni bir menüye yönlendirileceğiz. 

5. “Thread” menüsüne gidin ve sağ üstteki “Model” sekmesinden ince ayarlı modeli seçin.  

6. Yapay zekâ asistanına sorular sormaya başlayın ve özelleştirilmiş yanıtlar alın. 

7. Görüldüğü gibi, ilk yanıt vasat. Bazı model parametrelerini değiştirmemiz gerekiyor. “Model” sekmesine gidin ve şu argümanları ayarlamaya başlayın:

• Stop: <endofstring>, Saygılarımla, Chat Doctor.
• Frekans Cezası: 0.5
• Maksimum Token:  680

8. “Assistant” sekmesine gidin ve Instructions kısmını “Bir doktorsanız, lütfen hastanın açıklamasına dayanarak tıbbi soruları yanıtlayın.” olarak değiştirin.
9. Modeli birden çok soruyla test edin ve yüksek kaliteli, doğrudan konuya giren sonuçlar elde edin.

Sonuç

Gemma 2 harika bir modeldir ve dağıtık ince ayar ile model çıkarımı için Keras 3 çerçevesini kullanırsanız daha da iyi olabilir. Transformers çerçevesine kıyasla daha hızlı eğitim ve çıkarım süreleri elde edersiniz. 

Gemma modelini nasıl ince ayarlayacağınızı ve Keras 3 kullanarak model çıkarımı yapmayı öğrenmek için Google’ın Gemma Modelini TPU ile İnce Ayarlama ve Çıkarım Çalıştırma adlı eğitimi takip edebilirsiniz.

Bu eğitimde, Gemma 2 modellerini ve onlara Transformer kütüphanesiyle nasıl erişileceğini öğrendik. Ayrıca modeli hasta-doktor konuşmaları üzerinde ince ayarlamayı, adaptörü temel modelle birleştirmeyi, tam modeli Hugging Face hub’a göndermeyi, modeli Hugging Face Space kullanarak dönüştürüp kuantize etmeyi, kuantize modeli indirip Jan uygulamasıyla dizüstü bilgisayarda yerelde çalıştırmayı öğrendik. 

Bu, yapay zekâ meraklılarının mutlaka denemesi gereken eğlenceli bir projedir. Büyük dil modellerini ince ayarlarken ortaya çıkan sorunları giderme becerilerini geliştirecektir. Başlıca zorluklar genellikle bellek ve hesaplama kısıtları ile kaybı en aza indirmeyi içerir.

Kendi LLM’lerinizi PyTorch ve Hugging Face ile geliştirmeyi de Büyük Dil Modelleri Geliştirme kursunda DataCamp üzerinden öğrenebilirsiniz.