> For the complete documentation index, see [llms.txt](https://pycoders-nl.gitbook.io/pycoders-handbook/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://pycoders-nl.gitbook.io/pycoders-handbook/~/changes/YTi8eWfJe4r0epZkSSSg/extra-documentation/week25.md).

# ML

## Decision Tree - Karar Agaclari

![Decision Tree](https://2843449504-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-MXS9gjR6N_CAer7Mflk%2F-MeHHXVit8BCpKERUfcg%2F-MeHIpc_HpWc3RCaJenM%2Fimage.png?alt=media\&token=5306fc79-8996-4152-b31c-b7d0711123a1)

Karar ağaçları ile ilgili detaylı ve anlaşılır bir video;&#x20;

{% embed url="<https://www.youtube.com/watch?v=E8UrmG3xD60>" %}

Karar ağaçları, sınıflama, özellik ve hedefe göre karar düğümlerinden oluşan, ağaç yapısı  formunda model oluşturan bir sınıflandırma yöntemidir ama **regresyon** modellerinde de kullanılabilir.

{% hint style="info" %}
Karar ağaçlarının ilk hücrelerine **kök** (root veya root node) denir. Her bir gözlem kökteki koşula göre “Evet” veya “Hayır” olarak sınıflandırılır.
{% endhint %}

Kök hücrelerinin altında **düğümler** (interval nodes veya nodes) bulunur. Her bir gözlem düğümler yardımıyla sınıflandırılır. Düğüm sayısı arttıkça modelin karmaşıklığı da artar.

&#x20;Karar ağacının en altında **yapraklar** (leaf nodes veya leaves) bulunur. Yapraklar, bize sonucu verir.

&#x20;Ağaç tabanlı öğrenme algoritmaları, en çok kullanılan gözetimli öğrenme algorimalarındandır. Genel itibariyle ele alınan bütün problemlerin (sınıflandırma ve regression) çözümüne uyarlanabilirler.

&#x20;Karar agaçları, tesadüfi orman (Random Forest), gradyen güçlendirme (gradient boosting) gibi yöntemler, her türlü veri bilimi problemlerinde yaygın bir şekilde kullanılmaktadırlar. Bu nedenle veri analistleri için bu algoritmaları öğrenmek ve kullanmak çok önemlidir.

&#x20;Bir karar ağacı, çok sayıda kayıt içeren bir veri kümesini, bir dizi karar kuralları uygulayarak daha küçük kümelere bölmek için kullanılan bir yapıdır. Yani basit karar verme adımları uygulanarak, büyük miktarlardaki kayıtları, çok küçük kayıt gruplarına bölerek kullanılan bir yapıdır.<br>

### **Peki ya kök hücreyi nasıl seçiyoruz?**

&#x20;Burada seçeceğimiz kökün veri setimizi olabildiğince çok açıklamasını isteriz. Örneğin yukarıdaki örnek karar ağacına bakarsak, bu kişi için iş teklifinde en önemli etken maaşmış.

Köke tabi ki biz karar vermiyoruz.

&#x20;Buna karar vermek için çeşitli değerler var.  **Karar ağaçları ağaç yapısını oluştururken düğüm noktalarına kategorik değişkenler için** **Entropy , Information Gain ve Gini, sürekli değişkenler için ise** **En Küçük Kareler** **gibi değerleri kullanarak karar verir.**

&#x20;Regresyon problemleri için En küçük kareler yönteminden bahsetmiştik. Burda sınıflandırma problemleri için kullanılan yöntemlerin detaylarını inceleyelim.  Bunlardan bazıları:

**Gini: Alt kümenin saflık değeri**

![Gini formul](https://2843449504-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-MXS9gjR6N_CAer7Mflk%2F-MeHHXVit8BCpKERUfcg%2F-MeHJrefSXGfsqjzh_nv%2Fimage.png?alt=media\&token=b04461d0-2776-4ccb-9eb3-f97c95cd2242)

\
pj, j sınıfının gerçekleşme olasılığıdır. Her sınıf için hesaplanır ve çıkan sonuçların karelerinin toplamı birden çıkartılır. Gini değeri 0 ile 1 arasında bir sonuç alır ve sonuç 0’a ne kadar yakınsa o kadar iyi ayrım yapmış olur.<br>

![gini orneklem](https://2843449504-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-MXS9gjR6N_CAer7Mflk%2F-MeHHXVit8BCpKERUfcg%2F-MeHJkkvx_Yd7YSWmyj8%2Fimage.png?alt=media\&token=f0845b31-c0e8-48c6-bfb0-52c1c2586380)

Daha anlaşılır olması için ilk önce Gini değerinin nasıl hesaplandığını anlatacağım. Daha sonra Karar Ağaçları içerisindeki kullanımından bahsedeceğim.

Elimizde Kırmızı ve Mavi renkte 4 topumuz olduğunu varsayalım;

![](blob:https://app.gitbook.com/3a654d70-79fe-47c0-bab6-90eef004a9b0)

Şimdi Karar Ağaçlarına bakalım. Bakalım düğümlerimiz veri setimizi nasıl ayırabiliyor.

![page3image58884720](blob:https://app.gitbook.com/d6612a46-0975-4b8b-adba-03387b7d9a6b)

Kök (root) hücreyi bulabilmek için her düğüm için Gini değerini hesaplamamız gerekiyor.

![](blob:https://app.gitbook.com/0ee81fcc-950e-4552-972b-d6451705b013)

Maaş için inceleyelim. Öncelikle “Evet/Hayır” olarak ağacımızı ikiye ayırıyoruz. Maaş 50.000 $’dan fazla olduğunda; 512 kişinin 478'i işi kabul ederken 34 kişi işi reddediyor. Ardından 1 - maaş 50.000 $’dan yüksek iken işin kabul edilme olasılığı - maaş 50.000 $’dan yüksek iken işin reddedilme olasılığı işlemini yaparak cevabı “Evet” olanların Gini değerini bulmuş oluyoruz. Aynı işlemi cevabı “Hayır” olanlar için tekrarlıyoruz. Son olarak (işi kabul edenlerin veri setindeki oranı \* işi kabul edenlerin Gini değeri) + (işi reddedenlerin veri setindeki oranı \* işi reddedenlerin Gini değeri) işlemini yapıyoruz ve maaş için 0,1278 değerini buluyoruz.

Diğerleri içinde aynı işlemleri yapıyoruz.

![page4image58837856](blob:https://app.gitbook.com/833d9370-6d1b-4889-8720-97e4d6abf2d0)

![page4image58843680](blob:https://app.gitbook.com/36bc4fb3-837a-4c7e-a4c8-fe90060fee5d)

Değerlere baktığımızda 0'a en yakın olanın Maaş olduğunu görüyoruz. Bu bize Maaş düğümü ile yapılan ayrımın veri setini diğerlerine göre daha iyi ayrıştırdığını gösteriyor. Bu yüzden kök (root) hücre olarak Maaş düğümünü seçiyoruz.

Kök hücreden sonra hangisinin geleceğini de aynı şekilde karar veriyoruz. Örnek olması için:

![page5image59047936](blob:https://app.gitbook.com/69d39363-8e0a-4cb5-921a-c2aaefbf423d)

Entropy: Temel fikir, bir gruplamanın bozukluğunu hedef değişkene göre ölçmektir ama bunu log2 tabanında yapar.

![page5image59060208](blob:https://app.gitbook.com/545ff676-dc68-446d-aef5-427deff18d5e)

Entropi hesabı ile ilgili detaylı bir örnek için alttaki videodan 26:12'den itibaren izleyebilirsiniz.

{% embed url="<https://www.youtube.com/watch?v=fxHeEWRY9P8>" %}

Gini ile arasında çok büyük bir fark yoktur. Entropi daha dengeli bir ağaç çıkarmaya meyilli iken Gini, frekansı fazla olan sınıfı ayrıştırmaya meyillidir.

### Bilgi Kazancı(Infomation Gain)

Bir özniteliğin ne kadar bilgi sakladığının ölçütü olarak kullanılır. Karar ağacı yapıları, bilgi kazancı büyük öznitelikten ağaç dallarını oluşturmaya başlanır.

Bilgi kazancı formülü:.

![page6image58959616](blob:https://app.gitbook.com/693a605d-0c41-47ae-8e21-8fc6bb4fb09a)

{% embed url="<https://www.youtube.com/watch?v=AHEtFwVxrlA>" %}

### Eğitim Algoritmaları:

Scikit-learn Karar Ağaçlarını eğitirken CART (Classification and Regression Tree) algoritmasını kullanır. Bu algoritma veri setini ikiye ayırarak ayrıştırmaya çalışır. Diğer algoritmalar ile karşılaştırmak için şöyle bir tablo oluşturdum:

### Hiperparametreler:

Aşırı uyum (overfitting) veya öğrenememe(underfitting) gibi sorunlarla karşı karşıya iseniz hiperparametre değerleri ile biraz oynamanız gerekebilir.

max\_depth= Karar Ağacının maksimum derinliğini ifade eder. Değer girilmezse limitsiz olur. Model overfit(aşırı uyum) olmuşsa düşürülmesi gerekir.

min\_samples\_split=Bir düğümün bölünmeden önce sahip olması gereken minimum örnek sayısıdır.min\_samples\_leaf=Bir yaprağın sahip olması gereken minimum örnek sayısıdır.

min\_weight\_fraction= min\_samples\_leaf’e benzer.Ağırlıklı örneklerin, toplam örnekler içerisindeki oranı. Ağacın dengeli gitmesi için kullanılır.

max\_leaf\_nodes= Maksimum yaprak sayısı.

max\_features= En iyi bölünmeyi ararken göz önünde bulundurulması gereken featureların sayısı.

&#x20;

![page6image58961280](blob:https://app.gitbook.com/e6e10622-8e64-416a-ae24-05cfaaec6743)

### Karar ağaç modellerinin bazı özellikleri

\
1-) Sınıflandırma ve Regresyon problemlerinde çok çıktılı bir şekilde çalışabilir.\
2-)Karmaşık veri setlerinde kullanılabilir.

3-) Scale etmeye ve çok fazla Veri Ön İşleme’ye gerek duymaz.

4-) Kök hücreyi seçerken veri setini mümkün olduğunca anlamlı şekilde ayrıştırabilen sütun seçilmeye çalışır.

5-) Karar Ağacı, önceden tanımlanmış olan max\_depth hiperparametresine ulaştığında veya daha saf bir alt küme elde edemediğinde durur.

6-) Gini ve Entropi arasında çok büyük bir fark yoktur. Entropi daha dengeli bir ağaç çıkarmaya meyilli iken Gini frekansı fazla olan sınıfı ayrıştırmaya meyillidir.

7-) Model overfit (aşırı uyum) olmuşsa genellikle önce max\_depth hiperparametresi düşürülür.

Karar Ağaçları CART model için Regresyon ve Sınıflandırma uygulamalarını Jupiter Notebook da yapalım.....

{% embed url="<https://www.kaggle.com/pycodersnl/decision-tree-regression>" %}

{% embed url="<https://www.kaggle.com/pycodersnl/decision-tree-classifier>" %}

## Random Forest Modelling

{% hint style="success" %}
**Tarihçesi** : Random Forests 2001 yılında Leo Breiman tarafından geliştirilmiştir.RF algoritması yine Brieman'ın 1996 yılında geliştirdiği Bagging yöntemi ve Kim Ho tarafından geliştirilen Random Subspace yöntemlerinin birleşimidir. Amit ve Geman tarafından 1997’de tanımlanan, her düğüm için en iyi ayrımın rastgele bir seçim üzerinden belirlendiği belirtilen bir çalışmadan da etkilenmiştir.
{% endhint %}

Tek bir karar ağacının kavramsallaştırılması kolaydır ancak tipik olarak yüksek varyanstan zarar görür ve bu da onları doğruluk açısından rekabetçi yapmaz.

Bu sınırlamanın üstesinden gelmenin bir yolu, rastgeleleştirme tabanlı topluluk yöntemleri bağlamında aynı eğitim setinin her seferinde farklı bir alt kümesini seçerek tek bir karar ağacının birçok varyantını üretmektir (Breiman, 2001).

![page1image59234816](blob:https://app.gitbook.com/e38612ba-39c3-4de3-835a-d3e591267445)

### **Random Forest modelinin özellikleri**

Mükemmel bir geçerlilik sunar. Pek çok veri seti için Adaboost ve Destek Vektör Makinelerinden (Support Vector Machines) daha kesin sonuçlara sahiptir. • Oldukça kısa sürede sonuç verir. 100 değişkenli 100 ağaçlık bir karar ormanı, arka arkaya kurulan 3 tekil CART ile aynı sürede oluşturulur. • Binlerce değişkene ve fazla sayıda sınıf etiketine sahip kategorik değişken içeren, kayıp verili veya dengesiz bir dağılım sergileyen veri setlerini kullanarak sonuçlar verir. • Topluluğa ağaçlar eklendikçe, test setine ait hata tahmini için yanlılığı düşük sonuçlar vermeye başlar. • Gürültülü verilerden arındırır.

RF yönteminin tahminlerinin kesin olması nedenleri sapması düşük sonuçlar vermesi ve ağaçlar arasındaki düşük korelasyondur. Düşük sapma miktarı, oldukça büyük ağaçların

oluşturulması sonucu elde edilir. Mümkün olduğunca birbirinden farklı ağaçlar oluşturarak da düşük korelasyon yapısında bir topluluk elde edilir.

Birbirinden farklı olarak kurulan sınıflama ve regresyon karar ağaçları bizi sonuca götürecek karar ormanı topluluğunu oluşturur. Karar ormanı oluşumu sırasında elde edilen sonuçlar bir araya getirilerek en son tahmin yapılır.

RF yönteminde ağaçlar, seçilen bootstrap örneklemleri ve her düğüm ayrımında rastgele seçilen m adet tahminci ile oluşturulur. m adet tahmincinin toplam tahminci sayısından oldukça küçük olmasına dikkat edilir. Oluşturulan her bir karar ağacı en geniş haliyle bırakılır ve budanmaz.

Sınıflandırma için ağaçlar; her yaprak düğümü sadece bir sınıfın üyelerini içerecek şekilde oluşturulurlar. Regresyon için ise; yaprak düğümde az sayıda birim kalana kadar ağaçlar bölünmeye devam ederler.

Random Forest algoritmasının en önemli iki parametresi. max\_features : en iyi bölünmeyi belirlemek için her bir düğümde kullanılan değişkenlerin sayısı. n\_estimators : geliştirilecek ağaç sayısıdır.

### Algoritmanın Kurgulanması :

* –  İlk olarak eğitim veri setinin 2/3’ünden önyükleme örnekleri oluşturulur. Out of-bag (OOB) verisi olarak da adlandırılan, eğitim veri setinin 1/3’lük geri kalan kısmı hataları test etmek için kullanılır.
* –  Her bir düğümde m değişkenleri tüm değişkenler arasından rastgele olarak seçilir ve bu değişkenler arasından en iyi dal belirlenir. M adet değişken sayısının kare köküne eşit alınan m değişken sayısı genel olarak optimum sonuca en yakın sonucu verir.
* –  Sınıfların homojenliğini ölçmek için GINI indeksi hesaplanır. GINI indeksi ne kadar düşük olursa sınıf o kadar homojendir. Bir alt düğümün GINI indeksi bir üst düğümün GINI indeksinden daha az olduğunda o dal başarılıdır.
* –  Gini indeksi belirlendikten sonra test veri setlerimiz gini indeksi baz alınarak sınıfları belirlenir. Çıkan sonuçlar bütününde en uygun sınıflandırma yapılmış olur.

{% embed url="<https://www.kaggle.com/pycodersnl/random-forest-regression?scriptVersionId=68004978>" %}

{% embed url="<https://www.kaggle.com/pycodersnl/random-forest-classifier>" %}

## GBM - Gradient Boosting Machine

> Boosting yöntemini temel alan Karar Ağaçları modellerine geçmeden önce, öğrendiğimiz Bagging yöntemi ile farkına bakalım
>
> BOOSTING ve BAGGING FARKI
>
> Karar Ağaçları algoritmalarında Bagging (Torbalama) yöntemini gördükten sonra GBM modeli ile farklı bir yöntem olan Boosting (sıralama) yöntemine giriş yapacağız. Bu yüzden öncelikle her iki yöntemin farklarından biraz bahsedelim.
>
> Bir topluluk(ensemble), nihai bir tahmin vermek için bir araya gelen (tüm tahminlerin ortalaması) bir tahminci koleksiyonudur. Ensemble kullanmamızın nedeni, aynı hedef değişkeni tahmin etmeye çalışan birçok farklı belirleyicinin, tek başına herhangi bir tek tahminciden daha iyi bir iş çıkaracağıdır. Ensemble teknikleri daha çok Bagging ve Boosting olarak sınıflandırılmıştır.
>
> Bagging, birçok bağımsız belirleyici/model/öğrenici inşa ettiğimiz ve bazı model ortalama teknikleri kullanarak bunları birleştirdiğimiz basit bir toplama tekniğidir. (ör. ağırlıklı ortalama, çoğunluk oyu veya normal ortalama)
>
> Boosting , tahminlerin bağımsız olarak değil, sırayla yapıldığı bir topluluktur. Bu teknik, sonraki tahmincilerin önceki tahmincilerin hatalarından öğrendiği mantığı kullanır. Bu nedenle, gözlemlerin sonraki modellerde görülme olasılığı eşit değildir ve en yüksek hataya sahip olanlar en çok görünür. (Bu yüzden gözlemler bootstrap işlemine göre değil, hataya göre seçilir). Tahminciler karar ağaçları, regresörler, sınıflandırıcılar vb. gibi bir dizi modelden seçilebilir. Yeni tahminciler önceki tahmincilerin yaptığı hatalardan ders aldıklarından, gerçek kestirimlere yakın ulaşmak için daha az zaman / yineleme gerektirir. Fakat durma kriterlerini dikkatli bir şekilde seçmeliyiz ya da eğitim verilerinin aşırı yüklenmesine yol açabiliriz. Gradyan Artırma, hızlandırma algoritmasının bir örneğidir.

![page1image58901728](blob:https://app.gitbook.com/eea53340-4b64-4cba-b25e-fe928ccaaf88)

![page2image59072432](blob:https://app.gitbook.com/3618a699-90bb-4950-a6f8-7e7399ccc222)

### Gradient Boosting Machines (GBM)

Genel prensip olarak boosting algoritmaları her iterasyonda elde edilen zayıf öğrenicileri (weak learner), belli kurallar çerçevesinde birleştirerek güçlü bir öğrenici (strong learner) elde etmeye çalışır. Bunun ne demek olduğunu önce Adaboost algoritması üstünden bir sınıflandırma probleminde gösterelim. Ardından da Gradient Boosting ile devam edelim.

ADABOOST

1996 yılında Robert Schapire ve Yoav Freund tarafından geliştirilen Adaboost, ilk başarılı boosting algoritması olarak prestijli Gödel ödülünü kazanmıştır.

![page2image59072640](blob:https://app.gitbook.com/31a3fe04-dbc6-4922-96a5-eac2082680f6)

> Elimizde soldaki şekilde mavi ve kırmızı noktaları ayırmaya çalıştığımız bir sınıflandırma (classification) problemi olduğunu varsayalım.
>
> Görselleştirebildiğimizde çözüm çok kolay görünüyor ancak çoğu zaman bu şekilde 2 boyutlu görselleştirilebilen bir veri ile uğraşma şansımız olmuyor

![page3image59004192](blob:https://app.gitbook.com/1f9d0a69-cc2c-4765-ae48-5387d6e50b88)

> Algoritma bütün noktaların eşit ağırlıkta olduğu ilk iterasyonda en iyi çözümünü çizecektir. Bu durumda soldaki şekilde bir ayrım oluşacaktır. Görebileceğiniz üzere sarı ile işaretlediğim 3 nokta yanlış tarafta duruyorlar. Bu sebeple 2. iterasyon için bunların ağırlığını arttırmamız gerekiyor. Ancak nasıl?
>
> 1\. iterasyonda 7 doğruya karşı 3 hatalı sınıflandırmamız var. Eğer çözümümüzün %50– 50 dağılımunda bir sonuca getirmek istersek hatalı sınıflandırdığımız noktaların ağırlığını (doğru adet / yanlış adet) yani (7/3 ≈ 2.33) ile çarpmamız gerekecektir. Hatalı sınıflandırılan 3 noktanın ağırlığını 2.33 yaparsak modelimiz %50–50 ağırlığında olacaktır. 1. iterasyonun sonucunu hafızamıza kaybedip yeni ağırlıklar ile 2. iterasyona gidiyoruz.

![page3image59000448](blob:https://app.gitbook.com/e26240d9-75b3-4912-bf8d-2777fbaf80b6)

> 2\. iterasyonda en iyi çözüm soldaki şekilde olmaktadır. Doğru sınıflandırılan ağırlığı 11 iken, hatalı sınıflandırılanların ağırlığı 3 olarak oluşmuştur.
>
> Modeli bir kez daha %50–50 eşitliğine getirmek için, sarı ile işaretlenmiş hatalı sınıflandırılan ağırlığını (11/3 ≈ 3.66) ile çarpmamız gerekiyor.
>
> Yeni ağırlıklar ile modelimizi 3. iterasyona götürebiliriz.

![page4image58806128](blob:https://app.gitbook.com/8809fc1b-554d-4825-84e9-0bcb4046ec4e)

> 3\. iterasyonun en iyi çözümü ise soldaki şekilde olmaktadır. Doğru noktaların ağırlığı 19 iken, yanlış sınıflandırılan noktaların ağırlığı 3 olmuştur.
>
> İterasyonlara devam edebiliriz ancak burada sona erdirdiğimizi farzedelim

Şimdi 3 iterasyonda elde ettiğimiz zayıf öğrenicileri (weak learner) birleştirme aşamasına geldik. Ancak bunu nasıl yapacağız?

ln(doğru/yanlış) formülü bize istediğimiz katsayıları verecek gibi duruyor.\
Eğer biraz düşünürsek, eşit sayıda doğru ve yanlış veren bir çözüm bizim işimize yaramayacaktır.

ln(1)→0 olduğu için bu isteğimizi karşılıyor.

Doğru sayısı arttıkça formülün katsayısı pozitif sonsuza doğru giderek artacak, bütün sonuçları doğru veren bir çözümün ağırlığı sonsuz olacaktır - ln(∞)→∞.

Doğrudan çok yanlış veren bir model de işimize yarar. Sadece modeli ters çevirmemiz gerekmektedir. Hiç doğru sonuç vermeyen bir modelin ağırlığı ln(0)→-∞ olduğu için negatif sonsuz olacaktır

.

![page5image58872496](blob:https://app.gitbook.com/d176bc4a-e788-4d91-b58e-abd76a733906)

| ![page5image58875616](blob:https://app.gitbook.com/efa2ace6-1aca-4b34-83fe-fb874c2b68d6) | <p>Eğer modellerin mavi olarak belirlediği bölgeyi pozitif, kırmızı bölgeyi de negatif olarak değerlendirirsek; 3 iterasyonun sonucunu soldaki şekilde birleştirebiliriz.</p><p>Oluşan bölümlerin her bir iterasyonda aldığı değeri, ağırlıkları ile topladığımızda sonuç yavaş yavaş çıkmaya başlıyor. Toplamı pozitif olan bölümleri mavi, negatifleri de kırmızı yaparsak algoritmamızın sonucunu görebiliriz.</p> |
| ---------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

![page6image59003776](blob:https://app.gitbook.com/877e393c-05d6-46ad-a66e-02cb26bfbd99)

> Adaboost’un çalışma mantığını gösterdiğimiz bu örnek, görülebileceği üzere elimizdeki problemi harika şekilde çözdü.
>
> Bu örneği oluştururken Udacity Machine Learning Engineer Nanodegree’deki Adaboost öğretiminden yola çıktım. Çözümde 3 iterasyonlu AdaBoostClassifier’ı, maksimum derinliği 1 olan DecisionTreeClassifier ile kullanıyoruz. Kodumuz aşağıdaki gibidir.

{% hint style="success" %}
[Kaynak](https://medium.com/@sertacozker/boosting-algoritmaları-nasıl-çalışır-edac1174e971)
{% endhint %}

**Gradient Boosting Machines (GBM) :**

Gradient Boosting’de öncelikli olarak ilk yaprak(initial leaf) oluşturulur. Sonrasında tahmin hataları göz önüne alınarak yeni ağaçlar oluşturulur. Bu durum karar verilen ağaç sayısına ya da modelden daha fazla gelişme kaydedilemeyinceye kadar devam eder.

Konu örnek veri seti üzerinden uygulama ile anlatılacaktır. Bu sebeple aşağıda veri seti tanımlanmış ve kullanıma hazır hale getirilmiştir. Veri setine <https://www.kaggle.com/camnugent/california-> housing-prices ten ulaşabilirsiniz.

İlk olarak tahminlenecek değişkenin(hedef değişken) ortalaması alınır. Bu sayı ilk tahmin girişimimiz olan ilk yapraktır.![page6image57140416](blob:https://app.gitbook.com/6fa7ba19-ccdd-4bfc-a830-3eea5971f680) ![page6image57133312](blob:https://app.gitbook.com/f9e8d8bd-f800-457c-abd6-479faf840036)![page6image57139264](blob:https://app.gitbook.com/4ff1c55b-bde0-40b0-8490-7410586b90f2) ![page6image57136192](blob:https://app.gitbook.com/58df1689-0f54-4b13-8070-69420185a6f7)![page6image57133888](blob:https://app.gitbook.com/cdd24fb3-3cf7-48b7-9395-99715116d3a4) ![page6image57133120](blob:https://app.gitbook.com/48c4ca2d-7228-4040-8ce5-8fd599028fc2) ![page6image58999824](blob:https://app.gitbook.com/4aac2275-760d-4879-937e-23999c0140cd)![page7image58870832](blob:https://app.gitbook.com/d7948f69-506b-4313-a0bc-921704dc560f)

Bu değer ile hedef değişken karşılaştırılarak ne kadar hatalı tahminleme yapıldığı gözlemlenir. Hata(residual), gözlemlenen değerden tahmin edilen değerin çıkarılması ile bulunmaktadır.

1.ağaç, ilk yaprak sonucunda elde edilen hataları tahminleyen bir model olarak kurulacaktır.![page7image58882064](blob:https://app.gitbook.com/7241bbd5-e592-4fee-99f4-9b5c5d23850f)![page8image58826880](blob:https://app.gitbook.com/3ac753ea-ef12-4969-a24c-37b480ea65fd)

İlk tahmin ve ilk ağaçtan çıkan sonuçları toplarsak hedef değişkeni %100 doğru tahmin edebiliriz. (Ağaçlarda yapraklardan daha fazla residual olabilir, bazı residuallar aynı yaprağın içine girecektir. Bu olduğunda, ortalamaları hesaplanır ve yaprak içine yerleştirilir. Bu sebeple her zaman %100 doğru tahmin gerçekleşmeyebilir.) Ancak bu durum aşırı öğrenmedir.

Gradient Boosting bu sorunu aşmak için ağaçlara öğrenme oranı (learning rate) ekler. Bu değer 0 ile 1 arasındadır.

Bu çalışmada learning rate 0,1 olarak tanımlanmıştır. Sonuç olarak tahmin ilk yaprak + learning rate\*1.ağaç olarak hesaplanacaktır.![page8image58833744](blob:https://app.gitbook.com/5dee067d-4db9-45e6-9731-d4c6c3bc78af)![page9image58878320](blob:https://app.gitbook.com/bdcb4b3c-ff06-4f43-823c-71b96f2b566d)

Learning rate ile ölçeklendirilmiş tahmine göre hata hesaplandığında sonuç aşağıdaki gibidir.![page9image58872080](blob:https://app.gitbook.com/923bea8f-4213-4225-87e4-ca028fcd4215)

residual1 ve residual2 kolonları incelendiğinde doğru tahmine yaklaşıldığı, daha az hata yapıldığı görülmektedir.

Gradient Boosting’i geliştiren istatistikçi Jerome H. Friedman’a göre hedefe ulaşmak için birçok küçük adım kullanmak test datasında daha iyi sonuç vermekte, varyansı düşürmektedir.

3\. adım olarak doğru tahmine daha çok yaklaşabilmek adına bir önceki ağacın hataları baz alınarak yeni ağaç kurulur.![page9image58879776](blob:https://app.gitbook.com/a697cec2-2432-450d-8913-18d8979f9bfc)

Şimdi ilk yaprak, önceki ağaç ve yeni ağaç kombinlenerek yeni tahmin elde edilecektir. Hesaplama, ilk yaprak + learning rate\*1.ağaç+ learning rate\*2.ağaç şeklinde olacaktır.![page10image58883520](blob:https://app.gitbook.com/32c51e46-487e-4921-aa54-bf4257abf0f6)

Doğru sonuca ulaşmak için ufak bir adım daha atılmıştır.

Yeni ağaç üretimi, daha önce belirtildiği gibi, belirlenen ağaç sayısına ya da ağaç eklenmesi anlamlı olmayıncaya kadar devam edecektir.\
TEORİ

Gradient Boosted Regresyon Ağaçları 4 adımda hesaplanmaktadır.

1.Adım

Kayıp fonksiyonu(loss function) tanımlanır. Kayıp fonksiyonu, modelin katsayılarının temel alınan veriye uymada ne kadar iyi olduğunu gösteren bir ölçüdür.

Aşağıdaki formül ile gösterilir.

yi gözlemlenen değer, F(x) tahmin edilen değerdir.

Bir çok kayıp fonksiyonu vardır. Gradient Boosted Regresyon Ağaçları’nda yaygın olarak kullanılanı 1⁄2(gözlemlenen değer – tahminlenen değer)^2 formülü ile elde edilendir. Yazıda bu kayıp fonksiyonu ile çalışılmıştır.

Gradient Boosting hesaplamasında türev çok fazla kullanılır. Bu formülün tahminlenen değere göre türevi alındığında 1⁄2 değeri yok olur ve –(gözlemlenen değer-tahminlenen değer) sonucuna ulaşılır. Bu kolaylık sebebiyle formülün başına 1⁄2 getirilmektedir.\
2.Adım

Sabit değişken belirlenir.![page10image58874160](blob:https://app.gitbook.com/30c42abe-a313-4513-9372-7a1b6ca091c5) ![page10image58873952](blob:https://app.gitbook.com/3f21d454-52ff-4c4b-9800-b5cfc635a651)

Formülde sigma’nın içindeki değer kayıp fonksyonudur. yi gözlemlenen değer, Y(gamma) tahminlenen değeridir.

Tüm gözlemler için kayıp fonksiyonu toplanacak ve değerinin minimum hali bulunacaktır. Bunun için kayıp fonksiyonunun türevi alınır, değerler toplanır ve sıfıra eşitlenir. Sonuç olarak initial leaf bulunur. Bu değer hedef değişkendeki tüm değerlerin ortalamasına eşittir.\
3.Adım

3\. adım 4 aşamada gerçekleşmektedir ve tüm ağaçlarda uygulanacak bir döngüdür.

Önceki tahmine göre hatalar hesaplanır.

•![page11image58861312](blob:https://app.gitbook.com/2e920d59-5e7f-486a-acd4-03266ec54e80)

Formülde r, residual anlamına gelmektedir. i gözlem numarası, m kurulan ağacın numarasını ifade eder.

Parantez içi türevi alınmış kayıp fonksiyonudur. Parantez dışında bakıldığında F(x) değerinin bir önceki ağacın çıktısını ifade ettiği görülmektedir.

Bu formül ile tüm gözlemler için kalıntılar hesaplanır.\
Sonrasında residual’lar için karar ağacı oluşturulur ve her yaprağın değeri bulunur.

Formül her yaprak için hatayı minimize eder. (2. Adımda olduğu gibi, ancak burada formül Fm-1’i yani bir önceki tahmin değerini kullanır.)

Yine aynı şekilde kayıp fonksiyonunun türevi alınır ve değerler toplanıp sınıfa eşitlenir. Çıkan sayı yaprağın değeridir.\
Her gözlem için tahmin oluşturulur.![page11image58866096](blob:https://app.gitbook.com/6051151d-3b54-484c-aa3a-fa0373d4b1be)![page12image58749120](blob:https://app.gitbook.com/62066b9f-6a39-4bff-8ae7-2b3eaede3578)

Formül incelendiğinde F(x)=önceki ağacın sonuçları + learning rate\*yeni ağaç olduğu görülmektedir.\
Döngü bu şekilde devam edecektir.

Kaynak : <https://www.veribilimiokulu.com/gradient-boosted-regresyon-agaclari/>

{% embed url="<https://www.kaggle.com/pycodersnl/gbm-regression>" %}

{% embed url="<https://www.kaggle.com/pycodersnl/gbm-classifier>" %}

## XGBoost (eXtreme Gradient Boosting)

Gradient Boosting algoritmasının çeşitli düzenlemeler ile optimize edilmiş yüksek performanslı halidir. Tianqi Chen ve Carlos Guestrin’in 2016 yılında yayınladıkları “XGBoost: A Scalable Tree Boosting System” adlı makale ile hayatımıza dahil olmuştur. Algortimanın en önemli özellikleri yüksek tahmin gücü elde edebilmesi, aşırı öğrenmenin önüne geçebilmesi, boş verileri yönetebilmesi ve bunları hızlı yapabilmesidir. Tianqi’ye göre XGBoost diğer popüler algoritmalardan 10 kat daha hızlı çalışmaktadır.

### NEDEN DAHA İYİ PERFORMANS GÖSTERİR?

Gradient Boosting ve XGBoost aynı prensiple çalışmaktadır. Aralarındaki farklar detaylardadır. XGBoost, farklı teknikler kullanarak daha yüksek tahmin başarısı gösterir ve büyük veri setlerinde çalışmak için optimize edilmiştir.

Gradient Boosting’den ayrıştığı başlıca konular aşağıdadır. •Regülarizasyon

•Budama

•Boş Değerler ile Çalışılabilesi

•Sistem Optimizasyonu\
Bu maddelerden regülarizasyon ve budama yukarıda detaylıca anlatılmıştır.

#### Boş Değerlerle Çalışılabilmesi

Veri setlerinin en büyük problemlerinden biri boş değerlerin olmasıdır. Kimi zaman teknik sorunlarla kimi zaman veri akışının yapısı gereği boş veriler olabilmektedir. Her ne sebeple olursa olsun birçok algortimayı kullanabilmek için bu veriler doldurulmalı ya da ilgili satır veri setinden kaldırılmalıdır. XGBoost’un farklılıklarından biri boş değerler ile çalışılabilmesidir.

XGBoost’un arka planında ilk tahmin varsayılan 0,5 olarak atandığı için tahmin sonucunda hata(residual) değerleri boş verilerin olduğu satırlar için de oluşturulacaktır. İkinci tahmin için oluşturulan karar ağacında, boş verilerin olduğu satırlardaki hata değerleri olabilecek tüm olasılıklar için farklı dallara yerleştirilir ve her durum için kazanç skoru hesaplanır. Skor hangi durumda fazla ise boş değerler o dallara atanacaktır.

#### Sistem Optimizasyonlari

1.Parallel Calistirma: XGBoost, karar agaclarini olustururken paralelizasyon yaparak cok daha hizli olusturulmasini sagliyor. Bunu yapabilmesinin altinda temel-ogrenenleri (base- learners) olustururken, ic ve dis donguler arasinda gecis yapabiliyor olmasi. Normalde dis

donguler, karar-agacinin yapraklarini olustururken ic donguler oznitelikleri hesaplar. Ancak, ic donguler bitmeden dis donguler tamamlanamayacagi icin yani oznitelikler hesaplanmadan agacin yapraklari olusmayacagi icin paralelizasyon sinirlanir. XGBoost, ic ve dis dongulere ayrilan hesaplama gucunu degistirerek runtime hizlandiriyor ve paralelizasyon overhead’ini oldukca dusuruyor.

2.Agac-Budama: GBM’lerde agac dallarini ayirirken negatif-kayip kriterine gore ayirmayi durdurur. XGBoost, bunun aksine en basindan max\_depth parametresi ile agacin derinligini belirleyerek, eger agac asagi yonde fazla ilerledi ise geriye dogru budama yapar. XGBoost derinlige oncelik verdigi icin karmasikligi, dolayisiyla hesaplama performansini onemli olcude artirir.

3.Donanim Optimizasyonu: XGBoost, en basta gelistirilirken donanim kaynaklarini daha iyi kullanmak uzere tasarlanmistir. Ornegin, her ‘thread’ kendi icinde bir buffer ve bu bufferda egim istatistiklerini (gradient statistics) tutarak, onbellegin doluluguu goz onunde bulunduruyor. Bunun disinda, “out-of-core” hesaplama gibi iyilestirmeler sayesinde disk alanini optimize ederek daha buyuk verileri bellege sigdirabiliyor.

#### Algoritmik Iyilestirmeler

1.Regularizasyon: Hem LASSO hem de Ridge regularizasyonu kullanarak over-fitting engellenebiliyor.\
2.Seyreklik Uyumu: Gercek hayatta veri setleri maalesef bir cok eksik deger bulunduruyor. XGBoost, zayif-ogrenenler ile kayip degeri egitim kaybina bakarak en dogru sekilde ogrenebiliyor. Ya da bazen, veri seti belirli bir duzen icerisinde eksik degerlere sahip oluyor (sensor/iletisim hatalari vb.) bu durumlarda XGBoost durumu toparlayabiliyor.

3.Agirlikli Ceyrek Cizim: XGBoost’un en buyuk avantajlarindan biri agaclara ayirirken en dogru noktadan ayirabilmek icin veri setindeki gozlem noktalarini agirliklandirarak kullaniyor olmasi.

#### Ağırlıklandırılmış Quantile Sketch

-XGBoost her değişkene göre kazanç skorunu en yüksek yapacak şekilde olası tüm senaryolarda karar ağaçları kurar. Bu tür algoritmalara “Greedy Algorithm” denir. Enine boyuna büyük veri setlerinde bu işlem çok uzun sürebilir.

-XGBoost, verideki her değeri incelemek yerine veriyi parçalara(quantile) böler ve bu parçalara göre çalışır. Parça miktarı arttırıldıkça algoritma daha küçük aralıklara bakacak ve daha iyi tahminleme yapacaktır. Tabi ki bu durum modelin öğrenme süresi de artacaktır.

-Parça sayısı varsayılan olarak 33 tanedir.

-Bu yaklaşımın problemi tabii ki performans sorunudur. Parçaları belirlemek için her bir kolon sıralanmalı, parçaların sınırları belirlenmeli ve ağaçlar kurulmalıdır. Bu durum yavaşlığa sebep olur.

-Sorunu aşmak için “Sketches” adı verilen algoritma kullanılır. Amacı parçaları bulmak için yakınsama yapmasıdır.

-XGboost Ağırlıklandırılmış Sketches Algoritması ile parçaların sınırlarını belirler.

-Ağırlık = Önceki Değer \* (1 – Önceki Değer) olarak belirlenir. Ağırlık ne kadar fazlaysa tahmin o kadar kararsızdır. Parçalar bu ağırlıklara göre belirlenir. Ağırlıklar yaklaşık olacak şekilde parçalara bölünür. Bu sayede kararsız tahmin değerlerinin olduğu dallar daha küçük aralıklara bölünmüş olur. Bu durum daha doğru tahminlemeye yardımcı olacaktır.

4.Capraz-dogrulama: XGBoost, kendi icinde cross-validation (cv) uygulamasi ile geliyor yani disaridan scikit-learn vs. kullanarak cv yapmaniza gerek yok. Ayrica her calistirmada kac iterasyon yapacagini belirtmenize de gerek yok.

{% embed url="<https://www.kaggle.com/pycodersnl/xgboost-regression>" %}

{% embed url="<https://www.kaggle.com/pycodersnl/xgboost-classifier>" %}

## LightGBM Modeli

Son yıllarda veri boyutu ve çeşitliliğin hızla artması ile algoritma optimizasyonlarına verilen önem giderek artmaktadır. Bu sebeple Gradient Boosting algoritmasına alternatif olarak XGBoost, LightGBM, Catboost gibi Gradient Boosting’in versiyonları kabul edilebilecek algoritmalar geliştirilmiştir. Bu algoritmalar ile daha hızlı eğitim ve daha yüksek doğruluk elde edilmesi amaçlanmıştır.

LightGBM, Microsoft DMTK (Distributed Machine Learning Toolkit) projesi kapsamında 2017 yılında geliştirilmiş bir boosting algoritmasıdır. Diğer boosting algoritmaları ile karşılaştırıldığında yüksek işlem hızı, büyük verileri işleyebilmesi, daha az kaynak(RAM) kullanımı, yüksek tahmin oranı, paralel öğrenme ve GPU öğrenimini desteklemesi gibi avantajları vardır. Modelin tanıtıldığı “LightGBM: A Highly Efficient Gradient Boosting Decision Tree” makalesine göre, yapılan çalışmalarda LightGBM’in diğer modellere göre 20 kat daha hızlı olduğu sonucuna ulaşılmıştır.

### NASIL ÇALIŞIR?

LightGBM, histogram tabanlı çalışan bir algoritmadır. Sürekli değere sahip olan değişkenleri kesikli(discrete bin) hale getirerek hesaplama maliyetini azaltır. Karar ağaçlarının eğitim süresi yapılan hesaplama ve dolayısıyla bölünme sayısı ile doğru orantılıdır. Bu yöntem sayesinde hem eğitim süresi kısalmakta hem de kaynak kullanımı düşmektedir.

Karar ağaçlarında öğreniminde seviye odaklı (level-wise or depth-wise) veya yaprak odaklı(leaf-wise) olarak iki strateji kullanılabilir. Seviye odaklı stratejide ağaç büyürken ağacın dengesi korunur. Yaprak odaklı stratejide ise kaybı azaltan yapraklardan bölünme işlemi devam eder. LightGBM bu özelliği sayesinde diğer boosting algoritmalarından ayrılmaktadır. Model yaprak odaklı strateji ile daha az hata oranına sahip olur ve daha hızlı öğrenir. Ancak yaprak odaklı büyüme stratejisi veri sayısının az olduğu durumlarda modelin aşırı öğrenmeye yatkın olmasına sebebiyet verir. Bu nedenle algoritma büyük verilerde kullanılmak için daha uygundur. Ayrıca ağaç derinliği, yaprak sayısı gibi parametreler optimize edilip aşırı öğrenmenin önüne geçmeye çalışılabilir.

LightGBM ayrıca diğer algoritmalardan farklı iki teknik kullanmaktadır. Bunlar, veri örneklerinin ve değişkenlerin sayısı ile ilgilenen Gradyan Tabanlı Tek Yönlü Örnekleme ve Özel Değişken Paketi’dir.

**Gradyan Tabanlı Tek Yönlü Örnekleme (Gradient-based One-Side Sampling –GOSS)**: GOSS, karar ağaçlarının doğruluk oranını korurken veri sayısını azaltmayı amaçlamaktadır. Geleneksel Gradient Boosting her bir değişken(feature) için bilgi kazancını (information gain) hesaplamak adına tüm veri örneklerini tarar, ancak GOSS yalnızca önemli verileri kullanır. Böylece, verinin dağılımını fazla etkilemeden veri sayısını azaltılır.

**Özel Değişken Paketi (Exclusive Feature Bundling – EFB): EFB,** doğruluk oranına zarar vermeden değişken sayısını azaltmayı ve buna bağlı olarak model eğitiminin verimliliğini arttırmayı amaçlamaktadır. EFB’nin iki işlem adımı vardır. Bunlar, paket oluşturmak ve değişkenleri aynı pakette birleştirmektir. EFB ile seyrek özellikleri birleştirilip daha yoğun özellikler oluşturulur. Buna bağlı olarak karmaşıklığın azalmasına ve daha düşük bellek tüketimi ile birlikte daha hızlı eğitim sürecine yol açar.

Özetle, GOSS daha az önemli sayılabilecek verileri ihmal ederek bilgi kazanımını hesaplamak için veri boyutunu azaltırken, EFB boyutsallığı azaltmak için değişkenleri bir araya getirir. Bu iki işlev ile LightGBM eğitim sürecinin verimliliğini arttırır.

### PARAMETRE OPTİMİZASYONU

\
LightGBM’de aşırı öğrenmeyi engellemek için learning\_rate, max\_dept, num\_leaves,

parametreleri optimize edilebilir.

**Num\_leaves,** ağaçta bulunacak yaprak sayısıdır. Ağacın karmaşıklığını kontrol etmede kullanılan en önemli parametredir. Aşırı öğrenmeden kaçınmak için 2^(max\_dept)’den küçük olması gerekmektedir. Örneğin, max\_depth = 7 olduğunda, num\_leaves değerini 127 olarak ayarlamak aşırı öğrenmeye neden olabilir. 70 veya 80 olarak ayarlamak daha iyi doğruluk elde edebilir.

**Max\_dept,** kurulacak ağacın derinliğini limitlemek için kullanılır. Aşırı öğrenmeden kaçınmak için optimum seviyeye getirilmelidir. Çok dallanma aşırı öğrenmeye, az dallanma eksik öğrenmeye sebep olacaktır.

**Learning\_rate**, kurulan ağaçları ölçeklendirmek için 0-1 arasında verilen bir değerdir. Bu değerin küçük olması daha iyi tahmin gücüne yardımcı olacaktır. Ancak öğrenim süresini arttıracak ve aşırı öğrenme ihtimalini arttıracaktır.

## CATBOOST Modeli (Yandex 2017)

Catboost, Yandex şirketi tarafından geliştirilmiş olan Gradient Boosting tabanlı açık kaynak kodlu bir makine öğrenmesi algoritmasıdır. Gradient Boosting’in performansını arttırmak amacıyla geliştirilen XGBoost ve LightGBM’e alternatif olarak Nisan 2017 tarihinde “CatBoost: unbiased boosting with categorical features” makalesiyle tanıtılmıştır. Adı “Category” ve “Boosting” kelimelerinin birleşiminden gelmektedir.

Yüksek öğrenme hızı, hem sayısal hem kategorik hem de metin verileri ile çalışılabilmesi, GPU desteği ve görselleştirme seçenekleri sunması diğer algoritmalardan en çok ayrılan özellikleridir.

### DİĞER BOOSTING ALGORİTMALARINDAN FARKI NELERDİR?

CatBoost, veri hazırlığı evresini kısaltması ile önemli bir konuma sahiptir. Boş veriler ile başa çıkabilir, kategorik verilere kodlama(encoding) uygular.

Kategorik veriler ile yüksek performanslı çalışabilmesinin nedeni kendine has bir kodlama metoduna sahip olmasıdır. Yani veri hazırlığı yaparken ayrıca bir kodlama işlemi yapılmasına gerek duyulmamaktadır. Hatta kodlama yapılmaması özellikle tavsiye edilir. Bu hem öğrenme hızını hem de sonuçların kalitesini etkileyecektir.

Ayrıca Catboost simetrik ağaçlar kurar. Bu sayede çok derin ağaçlar kurmadan yüksek tahmin oranı yakalar ve aşırı öğrenme sorununu aşar.

Eğer aşırı öğrenme meydana gelirse algoritma parametrelerde belirtilen özelliklere(örneğin belirtilen ağaç sayısına) ulaşmadan önce öğrenmeyi durdurur. Bu seçenek başlangıç parametrelerinden ayarlanmaktadır.

Algoritma GPU ile öğrenim (training) yapabilmektedir. Bu sayede öğrenim süresi kısalmaktadır. Algoritmanın GPU üzerinde çalışabilmesi için NVIDIA Driver version 418 ya da üstü ekran kartına sahip olunması gerekmektedir.

Öğrenme sırasında CatBoost bellek kopyaları alır. Eğer bilgisayarın bir anda kapanması gibi beklenmedik bir sorun yaşanırsa öğrenme aşaması kaldığı yerden devam eder. Bellek kopyası alınması durumu parametrelerle kontrol edilebilir. Bu özellik kullanılabilir ya da kapatılabilir. Bu özellik büyük hacimli verilerle çalışırken öğrenim süresi çok uzun olacağı için oldukça önemlidir.

Kaydedilen modelin tekrar başlaması için sadece çalışmanın aynı dosyada tekrar başlatılması ve aynı parametrelerin kullanılması gerekmektedir.

Veri bilimi çalışmalarında doğru tahmin oranı kadar önemli olan bir diğer konu da modelin açıklanabilmesidir. Ipywidgets kütüphanesinin yüklenmesi sonrası Jupyter Notebook’ta CatBoost’a özel bir grafik gösterimi yapılabilr.

### MODEL PARAMETRELERİ

Yukarıda anlatıldığı gibi CatBoost algoritmasının birçok özelliği bulunmaktadır. Bu özellikleri kullanmak için çeşitli parametre tanımları yapılmalıdır. Sıklıklar kullanılan parametrelerin açıklamaları aşağıdadır.

**Max\_Depth**: Ağacın dallarının aşağı doğru uzamasının değeridir. Diğer bir anlatımla ağacın derinliğidir. Aşırı öğrenmeden kaçınmak için optimum seviyeye getirilmelidir. Çok dallanma aşırı öğrenmeye, az dallanma eksik öğrenmeye sebep olacaktır.

**Learning\_rate**: Kurulan ağaçları ölçeklendirmek için 0-1 arasında verilen bir değerdir. Bu değerin küçük olması daha iyi tahmin gücüne yardımcı olacaktır. Ancak öğrenim süresini ve aşırı öğrenme ihtimalini arttıracaktır.

**Iterations**:Oluşturulacak ağaç sayısıdır. Farklı algoritmalarda “num\_boost\_round”, “n\_estimators”, “num\_trees” isimleri ile de kullanılır. Az olması eksik öğrenmeye, fazla olması aşırı öğrenmeye neden olabilir. Ayrıca sayının artması eğitim süresini de arttıracaktır.

**Eval\_set**: Aşırı öğrenme tespiti için kullanılacak veri setlerinin tanımlandığı parametredir.

**Eval\_metric**: Aşırı öğrenmeyi tespit etmek için kullanılan bir parametredir.

Cat\_features: Algoritmanın kategorik veriler ile çalışabilmesi için modeli kurmadan önce kategorik verilerin tanıtılması gerekmektedir. Bu parametrede kategorik verilerin index’leri belirtilmelidir.

**Early\_stopping\_rounds**: Aşırı öğrenmeyi engellemek için kullanılan parametredir. En uygun adımı bulduktan sonra kaç kez deneme yapacağı belirtilmelidir. Örneğin bu değer 100 ile model en uygun olduğu andan sonra 100 iterasyon daha yapar ve hedef parametreler yakalanmasa bile model öğrenmeyi durdurur. Örneğin başlangıç parametresinde iterasyon sayısı 2000 verilmiş olsun, en uygun ana 1000. iterasyonda ulaştıysa model burada duracaktır.

**Save\_snapshot**: Modelin öğrenme aşamasında bellek kopyasının oluşmasını sağlayan parametredir. Etkinleşirse her 600 saniyede 1 kayıt alır. Bu süreyi değiştirmek için “snapshot\_interval” parametresi kullanılabilir.

**Snapshot\_file**: Bellek kopyasının saklanacağı dosyanın belirtildiği parametredir.

**Verbose**: Her iterasyonda çıktısı olarak modelin öğrenim durumu, toplam süre ve kalan süre bilgisi gelmektedir. Bu çıktı çok iterasyonun olduğu durumda ekranda çok fazla alan kaplamakta ve buna değecek kadar bilgi vermemektedir. Verbose parametresi ile bu çıktıların sayısı azaltılabilmektedir ya da tamamen kaldırılabilir. Örneğin verbose=50 olan durumda, model her 50 iterasyon için 1 çıktı verecektir. verbose=False diyerek ise çıktıların görünmesini engelleyebilirsiniz.