Python'da TPOT

Bu eğitimde, Python'da oldukça benzersiz bir kütüphane olan tpot'u nasıl kullanacağınızı öğreneceksiniz. Bu kütüphanenin benzersiz olmasının nedeni, tüm Makine Öğrenimi hattını otomatikleştirmesi ve size en iyi performans gösteren makine öğrenimi modelini sunmasıdır. Daha özel olarak, şunları öğreneceksiniz:

• Otomatikleştirilmiş Makine Öğrenimi fikri
• TPOT'un en iyi makine öğrenimi modelini seçmek için Genetik Programlamayı nasıl kullandığı
• Python'da bir veri kümesi üzerinde TPOT kullanımı
• TPOT'un sınırlamaları

Haydi başlayalım!

Giriş

Bir makine öğrenimi problemini çözmeden önce göz önünde bulundurmanız gereken çok sayıda bileşen vardır; bunlara veri hazırlama, özellik seçimi, özellik mühendisliği, model seçimi ve doğrulama, hiperparametre ayarlama vb. dahildir. Teoride, bu bileşenlerin her biri için çok sayıda teknik bulup uygulayabilirsiniz, ancak bunların tümü farklı veri kümeleri için farklı performans gösterebilir. Zorluk, tahminlerinizdeki hatayı en aza indirmek için en iyi performans gösteren teknikler kombinasyonunu bulmaktır. Bu, günümüzde insanların Auto-ML algoritmaları ve platformları geliştirmek için çalışmasının başlıca nedenidir; böylece herhangi biri, makine öğrenimi uzmanlığı olmadan, çok fazla zaman veya çaba harcamadan modeller oluşturabilir. Bu tür bir platform Python kütüphanesi olarak mevcuttur: TPOT. TPOT'u Veri Bilimi Asistanınız olarak düşünebilirsiniz. TPOT, genetik programlama kullanarak makine öğrenimi hatlarını optimize eden otomatik bir Makine Öğrenimi aracıdır. Veriniz için en iyi hattı bulmak amacıyla binlerce olası hattı akıllıca keşfederek makine öğreniminin en zahmetli kısmını otomatikleştirir.

from IPython.core.display import Image
Image(filename="/home/manishpathak/DataCamp/tpot/tpot-ml-pipeline.png",width=800,height=800)
Altyapı:

TPOT aramayı tamamladığında, bulduğu en iyi hat için Python kodunu size sağlar; böylece oradan hattı kurcalayabilirsiniz.

Kurulum

Sisteminizde tpot'u kurmak için, komut satırı terminalinde sudo pip install tpot komutunu çalıştırabilir veya bu bağlantıya göz atabilirsiniz. tpot, numpy, scipy, scikit-learn, DEAP, update_checker, tqdm, stopit, pandas gibi mevcut çeşitli Python kütüphanelerinin üzerine inşa edilmiştir. Gerekli Python paketlerinin çoğu Anaconda Python dağıtımı ile kurulabilir veya ayrı ayrı da yükleyebilirsiniz. İsteğe bağlı olarak, tpot'un eXtreme Gradient Boosting modellerini kullanmasını istiyorsanız XGBoost'u da kurabilirsiniz.

Genetik Programlama

Doğru veri, hesaplama gücü ve makine öğrenimi modeli ile herhangi bir probleme çözüm bulabilirsiniz; ancak o kadar çok model varken (Karar Ağaçları, SVM, KNN vb.) hangisini kullanacağınızı bilmek sizin için zor olabilir. İşte genetik programlamanın burada büyük fayda sağladığı yer. Genetik algoritmalar, Darwinci Doğal Seçilim sürecinden esinlenmiştir ve bilgisayar biliminde optimizasyon ve arama problemlerine çözümler üretmek için kullanılır.

Genel olarak, Genetik Algoritmaların üç özelliği vardır:

• Seçilim: Verilen bir probleme ait olası çözümlerden oluşan bir popülasyon ve bir uygunluk fonksiyonunuz vardır. Her yinelemede, her çözümün uygunluğunu uygunluk fonksiyonunuzla değerlendirirsiniz.
• Çaprazlama: Sonra en uygun olanları seçer ve yeni bir popülasyon oluşturmak için çaprazlama yaparsınız.
• Mutasyon: Bu çocukları alır ve bazı rastgele değişikliklerle mutasyona uğratır, sonra en uygun veya en iyi çözüme ulaşana kadar süreci tekrar edersiniz.

Genetik Programlama başlı başına bilgisayar biliminde büyük bir konudur; ancak genetik algoritmalara daha derinlemesine inmek isterseniz bu video serisine göz atın.

Peki tüm bunlar veri bilimine nasıl oturuyor?

Şöyle ki, doğru makine öğrenimi modelini ve o model için en iyi hiperparametreleri seçmek başlı başına genetik programlamanın kullanılabileceği bir optimizasyon problemidir. scikit-learn üzerine kurulu Python kütüphanesi tpot, makine öğrenimi hattınızı optimize etmek için genetik programlama kullanır. Örneğin, makine öğreniminde, verinizi hazırladıktan sonra modelinize hangi özellikleri gireceğinizi ve bu özellikleri nasıl inşa etmeniz gerektiğini bilmeniz gerekir. Bu özellikleri elde ettikten sonra modelinizi eğitmek için onları modele verirsiniz ve ardından en iyi sonuçları almak için hiperparametrelerinizi ayarlarsınız. Tüm bunları deneme yanılma yoluyla kendiniz yapmak yerine, TPOT bu adımları genetik programlama ile sizin için otomatikleştirir ve iş bittiğinde size en iyi kodu çıktılar.

Daha iyi anlamak için, açık kaynaklı bir veri kümesi üzerinde tpot kütüphanesini kullanarak alıştırma yapacaksınız. Kullanacağınız veri kümesi MAGIC Gama Teleskobu Veri Kümesidir. Veriler, görüntüleme tekniği kullanılarak yer tabanlı atmosferik Çerenkov gama teleskobunda yüksek enerjili gama parçacıklarının kaydının simüle edilmesi için üretilmiştir. Veri kümesi açıklaması hakkında tam bilgi için bu bağlantıya bakın. Veri kümesi şu özniteliklere/sıfatlara sahiptir:

1. fLength: sürekli # elipsin büyük ekseni [mm]
2. fWidth: sürekli # elipsin küçük ekseni [mm]
3. fSize: sürekli # tüm piksellerin içeriğinin toplamının 10-log'u [#phot cinsinden]
4. fConc: sürekli # en yüksek iki pikselin toplamının fSize'a oranı [oran]
5. fConc1: sürekli # en yüksek pikselin fSize'a oranı [oran]
6. fAsym: sürekli # en yüksek pikselden merkeze olan mesafe, büyük eksene izdüşümü [mm]
7. fM3Long: sürekli # büyük eksen boyunca üçüncü momentin küp kökü [mm]
8. fM3Trans: sürekli # küçük eksen boyunca üçüncü momentin küp kökü [mm]
9. fAlpha: sürekli # büyük eksenin, orijine olan vektörle yaptığı açı [derece]
10. fDist: sürekli # orijinden elipsin merkezine olan mesafe [mm]
11. class: g,h # gama (sinyal), hadron (arka plan) (hedef değişken)

Amaç, verilen özniteliklere göre bir gözlemi istenen sinyal olan gama ya da arka plan gürültüsü olan hadron olarak sınıflandırmaktır.

Veriyi okumak ve üzerinde hesaplamalar yapmak için sırasıyla pandas ve numpy kütüphanelerini içe aktararak başlayacaksınız.

import pandas as pd
import numpy as np
Altyapı:

Veri kümesini bir DataFrame olarak okumak için pandas'ın read_csv() fonksiyonunu kullanın. Ayrıca veri kümesinde henüz sütun adları olmadığı için header = None parametresini belirtin.

telescope_data=pd.read_csv('https://archive.ics.uci.edu/ml/machine-learning-databases/magic/magic04.data',header=None)
Altyapı:

DataFrame'in içeriğini head() yöntemiyle kontrol edin.

telescope_data.head()
Altyapı:

DataFrame'in sütunlarına ad vermek için, pandas DataFrame üzerindeki columns özniteliğini kullanabilir ve sütun adlarını içeren bir liste atayabilirsiniz.

telescope_data.columns = ['fLength', 'fWidth','fSize','fConc','fConcl','fAsym','fM3Long','fM3Trans','fAlpha','fDist','class']
Altyapı:

telescope_data.head()
Altyapı:

Artık DataFrame'inizde sütun adları da mevcut.

DataFrame hakkında sütun başına değer sayısı, veri türü, count, ortalama vb. gibi gerekli bilgileri almak için pandas'ın info() ve describe() yöntemlerini kullanabilirsiniz.

telescope_data.info()
Altyapı:

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 19020 entries, 0 to 19019
Data columns (total 11 columns):
fLength     19020 non-null float64
fWidth      19020 non-null float64
fSize       19020 non-null float64
fConc       19020 non-null float64
fConcl      19020 non-null float64
fAsym       19020 non-null float64
fM3Long     19020 non-null float64
fM3Trans    19020 non-null float64
fAlpha      19020 non-null float64
fDist       19020 non-null float64
class       19020 non-null object
dtypes: float64(10), object(1)
memory usage: 1.6+ MB
Altyapı:

telescope_data.describe()
Altyapı:

Görünüşe göre DataFrame'deki tüm özellikler doğası gereği süreklidir. Ancak hedef değişken/özellik olan class kategoriktir. Hedef değişkendeki her sınıfın sayımlarını value_counts() yöntemiyle kontrol edebilirsiniz.

telescope_data['class'].value_counts()
Altyapı:

g    12332
h     6688
Name: class, dtype: int64
Altyapı:

Genellikle, veride herhangi bir sıralamayı önlemek için başlamadan önce verileri rastgele karıştırmak iyi bir fikirdir. DataFrame'deki verileri numpy'nın random ve permutation() fonksiyonunu kullanarak yeniden düzenleyebilirsiniz. Karıştırmadan sonra indeks numaralarını sıfırlamak için reset_index() yöntemini drop = True parametresiyle kullanın.

telescope_shuffle=telescope_data.iloc[np.random.permutation(len(telescope_data))]
tele=telescope_shuffle.reset_index(drop=True)
tele.head()
Altyapı:

tpot'u kullanmadan önce, DataFrame'inizdeki kategorik değişkenlerin etiketlenmesini yapmanız şarttır. Kategorik değişkenlerin etiketlenmesi hakkında daha fazla bilgi için bu eğitime göz atın. Burada yalnızca hedef değişken class kategorik bir özelliktir; dolayısıyla işlem o sütuna uygulanmalıdır. g sınıfını (sinyal) sayısal değer 0 ile ve h sınıfını (arka plan) sayısal değer 1 ile değiştireceksiniz. Bu, hedef değişkenin sınıflarının ilgili eşlemesini tutan bir sözlüğü argüman olarak alan map() fonksiyonu ile yapılabilir.

tele['class']=tele['class'].map({'g':0,'h':1})

tele.head()
Altyapı:

Şimdi, tahmin etmeniz gereken sınıf etiketlerini ayrı bir değişkende tele_class saklayın.

tele_class = tele['class'].values
Altyapı:

tpot'u kullanmadan önce eksik değer işlemesi de yapmalısınız. Sütun bazında eksik değer sayısını kontrol etmek için aşağıdakini çalıştırabilirsiniz:

pd.isnull(tele).any()
Altyapı:

fLength     False
fWidth      False
fSize       False
fConc       False
fConcl      False
fAsym       False
fM3Long     False
fM3Trans    False
fAlpha      False
fDist       False
class       False
dtype: bool
Altyapı:

Bu veri kümesinde eksik değer yok. Not eksik değer içeren veri kümelerinde dropna() yöntemiyle satırları/sütunları düşebilir veya fillna() yöntemiyle eksik değeri bir sahte değerle değiştirebilirsiniz. Örneğin, aşağıdaki kod parçası NA değerlerini -999 sahte değeriyle değiştirecektir.

tele = tele.fillna(-999)
Altyapı:

Şimdi, tıpkı herhangi bir makine öğrenimi modellemesi yaparken olduğu gibi DataFrame'i bir eğitim seti ve bir test setine böleceksiniz. Bunu sklearn'ün cross_validation train_test_split'i ile yapabilirsiniz. Parametreler olarak, DataFrame'in indeksleri için tele.index, eğitim setinde verinin %75'ini tutmak için train_size = 0.75, geri kalan %25'i test setinde tutmak için test_size = 0.25 ve veri kümesindeki sınıf etiketlerinin değerleri için stratify = tele_class kullanılır. Not doğrulama seti, test seti hatasına dair bir fikir vermek içindir. Burada test setiyle aynı tutulmuştur.

from sklearn.cross_validation import train_test_split
training_indices, validation_indices = training_indices, testing_indices = train_test_split(tele.index,
                                                                                            stratify = tele_class,
                                                                                            train_size=0.75, test_size=0.25)
Altyapı:

Eğitim setinin ve doğrulama setinin boyutunu size özniteliği ile kontrol edebilirsiniz.

training_indices.size, validation_indices.size
Altyapı:

(14265, 4755)
Altyapı:

Şimdi bu ikili sınıflandırma problemi için bize en iyi hattı önermesi amacıyla tpot kütüphanesini kullanma zamanı. Bunu yapmak için tpot kütüphanesinden TPOTClassifier sınıfını içe aktarmanız gerekir. Eğer bu bir regresyon problemi olsaydı TPOTRegressor sınıfını içe aktarırdınız.

TPOTClassifier'ın çok çeşitli parametreleri vardır; bunların tümünü burada okuyabilirsiniz. Ancak bilmeniz gereken en önemlileri şunlardır:

• generations: Boru hattı optimizasyon sürecinin çalıştırılacağı yineleme sayısı. Varsayılan 100'dür.
• population_size: Her nesilde genetik programlama popülasyonunda tutulacak birey sayısı. Varsayılan 100'dür.
• offspring_size: Her genetik programlama neslinde üretilecek yavru sayısı. Varsayılan 100'dür.
• mutation_rate: [0.0, 1.0] aralığında genetik programlama algoritması için mutasyon oranı. Bu parametre, GP algoritmasına her nesilde kaç hatta rastgele değişiklik uygulanacağını söyler. Varsayılan 0.9'dur.
• crossover_rate: [0.0, 1.0] aralığında genetik programlama algoritması için çaprazlama oranı. Bu parametre, genetik programlama algoritmasına her nesilde kaç hattın "eşleştirileceğini" söyler.
• scoring: accuracy, average_precision, roc_auc, recall vb. gibi sınıflandırma problemi için verilen bir hattın kalitesini değerlendirmede kullanılan fonksiyon. Varsayılan accuracy'dir.
• cv: Hatlar değerlendirilirken kullanılan çapraz doğrulama stratejisi. Varsayılan 5'tir.
• random_state: TPOT'ta kullanılan sözde rastgele sayı üretecinin tohumu. TPOT'un aynı veri kümesi üzerinde her çalıştırmada aynı sonuçları vermesini sağlamak için bu parametreyi kullanın.

Ayrıca not edin: mutation_rate + crossover_rate 1.0'ı aşamaz.

Burada generations = 5 ile tpot kullanacak ve diğer parametreleri varsayılan değerlerinde bırakacaksınız. verbosity = 2 parametresi, TPOT'un çalışırken ne kadar bilgi vereceğini belirtir.

Ardından fit() yöntemini, eğitim seti (hedef sütun olmadan) ve hedef sütunu argümanlarıyla çağıracaksınız.

Not aşağıdaki hücredeki kodu çalıştırmak tamamlanması için birkaç saat alacaktır. Verilen TPOT ayarlarıyla (100 nüfus büyüklüğüne sahip 5 nesil) TPOT, bitirmeden önce 500 hat yapılandırmasını değerlendirecektir. Bu sayıyı bağlama oturtmak için, bir makine öğrenimi algoritması için 500 hiperparametre kombinasyonundan oluşan bir ızgara aramasını ve bu ızgara aramasının ne kadar süreceğini düşünün. Bu, 5 katlı çapraz doğrulama ile değerlendirilecek 500 model yapılandırması demektir; bu da tek bir ızgara aramasında kabaca 2500 modelin eğitim verisi üzerinde eğitilip değerlendirilmesi anlamına gelir. Bu zaman alan bir işlemdir! Daha sonra, TPOT'un bitirme süresini kontrol etmek için TPOTClassifier'a geçebileceğiniz bazı ek argümanları öğreneceksiniz.

from tpot import TPOTClassifier
from tpot import TPOTRegressor

tpot = TPOTClassifier(generations=5,verbosity=2)

tpot.fit(tele.drop('class',axis=1).loc[training_indices].values,
         tele.loc[training_indices,'class'].values)
Altyapı:

Optimization Progress:  33%|███▎      | 200/600 [41:43<1:51:41, 16.75s/pipeline]

Generation 1 - Current best internal CV score: 0.880266061124

Optimization Progress:  50%|█████     | 300/600 [1:14:37<46:57,  9.39s/pipeline]  

Generation 2 - Current best internal CV score: 0.880266061124

Optimization Progress:  67%|██████▋   | 400/600 [1:59:17<2:21:21, 42.41s/pipeline]

Generation 3 - Current best internal CV score: 0.880266061124

Optimization Progress:  84%|████████▎ | 501/600 [3:01:12<1:02:16, 37.74s/pipeline]

Generation 4 - Current best internal CV score: 0.881597992166

Generation 5 - Current best internal CV score: 0.881597992166

Best pipeline: GradientBoostingClassifier(RobustScaler(PolynomialFeatures(input_matrix, degree=2, include_bias=False, interaction_only=False)), learning_rate=0.1, max_depth=6, max_features=0.6000000000000001, min_samples_leaf=12, min_samples_split=3, n_estimators=100, subsample=0.55)

TPOTClassifier(config_dict={'sklearn.ensemble.GradientBoostingClassifier': {'max_features': array([0.05, 0.1 , 0.15, 0.2 , 0.25, 0.3 , 0.35, 0.4 , 0.45, 0.5 , 0.55,
       0.6 , 0.65, 0.7 , 0.75, 0.8 , 0.85, 0.9 , 0.95, 1.  ]), 'learning_rate': [0.001, 0.01, 0.1, 0.5, 1.0], 'min_samples_leaf': [1, 2, 3, 4, 5, 6, 7...  0.6 , 0.65, 0.7 , 0.75, 0.8 , 0.85, 0.9 , 0.95, 1.  ])}, 'sklearn.preprocessing.RobustScaler': {}},
        crossover_rate=0.1, cv=5, disable_update_check=False,
        early_stop=None, generations=5, max_eval_time_mins=5,
        max_time_mins=None, memory=None, mutation_rate=0.9, n_jobs=1,
        offspring_size=100, periodic_checkpoint_folder=None,
        population_size=100, random_state=None, scoring=None,
        subsample=1.0, verbosity=2, warm_start=False)
Altyapı:

Yukarıda, 5 nesil hesaplanmış ve her biri eğitim seti üzerinde uyumlanan modelin eğitim verimliliğini vermiştir. Görüldüğü gibi, en iyi hat, %88,16'lık CV doğruluk puanına sahip olandır. Bu sonucu üreten model; girdi verisine sentetik özellikler ekleyen ve onları normalleştiren PloynomialFeatures ve ardından RobustScaler gibi ön işleme tekniklerinden oluşan ve son tahminleri oluşturmak için bir Gradient Boosting sınıflandırıcısı tarafından kullanılan bir hattır. Ayrıca tpot'un sınıflandırıcıyla birlikte learning_rate, max_depth vb. gibi çeşitli hiperparametre değerlerini de verdiğini fark edebilirsiniz.

Sonraki adımda, doğrulama amacıyla test hatası hesaplanır.

tpot.score(tele.drop('class',axis=1).loc[validation_indices].values,
           tele.loc[validation_indices, 'class'].values)
Altyapı:

0.885173501577287
Altyapı:

Görüldüğü gibi, test doğruluğu %88,51'dir.

Son olarak, TPOT'a, optimize edilmiş hat için karşılık gelen Python kodunu export işleviyle bir metin dosyasına aktarmasını söyleyebilirsiniz:

tpot.export('tpot_MAGIC_Gamma_Telescope_pipeline.py')
Altyapı:

True
Altyapı:

## This is the pipeline that tpot generated: tpot_MAGIC_Gamma_Telescope_pipeline.py
import numpy as np
import pandas as pd
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.model_selection import train_test_split
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import PolynomialFeatures, RobustScaler

# NOTE: Make sure that the class is labeled 'target' in the data file
tpot_data = pd.read_csv('PATH/TO/DATA/FILE', sep='COLUMN_SEPARATOR', dtype=np.float64)
features = tpot_data.drop('target', axis=1).values
training_features, testing_features, training_target, testing_target = \
            train_test_split(features, tpot_data['target'].values, random_state=42)

# Score on the training set was:0.881597992166
exported_pipeline = make_pipeline(
    PolynomialFeatures(degree=2, include_bias=False, interaction_only=False),
    RobustScaler(),
    GradientBoostingClassifier(learning_rate=0.1, max_depth=6, max_features=0.6, min_samples_leaf=12, min_samples_split=3, n_estimators=100, subsample=0.55)
)

exported_pipeline.fit(training_features, training_target)
results = exported_pipeline.predict(testing_features)
Altyapı:

Harika değil mi? En iyi modeli elde etmek için bir sürü parametre ve seçeneği kurcalamadan, TPOT size yalnızca en iyi model hakkında bilgi vermekle kalmadı, aynı zamanda bunun için çalışan bir kod da sağladı!

Daha önce belirtildiği gibi, son TPOT çalıştırması tamamlanması için birkaç saat aldı. TPOT'un çalışma süresini kontrol etmek için belirtebileceğiniz bazı parametreler vardır; ancak bir ödünleşimle. TPOT'un çalışma süresini sınırlayacağınız için, TPOT tüm olası hatları keşfedemeyecek ve dolayısıyla sınırlı sürenin sonunda TPOT'un önerdiği en iyi model, o veri kümesi için mümkün olan en iyi model olmayabilir. Yine de yeterli zaman verilirse, en iyi modele bir hayli yakın olacaktır. Bazı parametreler şunlardır:

• max_time_mins: TPOT'un hattı optimize etmek için sahip olduğu dakika sayısı. None değilse, bu ayar generations parametresini geçersiz kılar ve TPOT'un max_time_mins dakika dolana kadar çalışmasına izin verir.
• max_eval_time_mins: TPOT'un tek bir hattı değerlendirmek için sahip olduğu dakika sayısı. Bu parametreyi daha yüksek değerlere ayarlamak, TPOT'un daha karmaşık hatları değerlendirmesine olanak tanır; ancak TPOT'un daha uzun süre çalışmasına da neden olur. TPOT'un zaman alıcı hatları değerlendirmeye zaman harcamasını önlemeye yardımcı olmak için bu parametreyi kullanın. Varsayılan 5'tir.
• early_stop: TPOT'un optimizasyon sürecinde iyileşme olmadığını kontrol ettiği nesil sayısı. Verilen nesil sayısında iyileşme yoksa optimizasyon sürecini sonlandırır.
• n_jobs: TPOT optimizasyon süreci sırasında hatları paralel olarak değerlendirmek için kullanılacak süreç sayısı. n_jobs=-1 ayarı, bilgisayardaki mevcut çekirdek sayısı kadarını kullanır. Aynı makinede birden çok yöntemin kullanılması, büyük veri kümeleri için bellek sorunlarına yol açabilir. Varsayılan 1'dir.
• subsample: TPOT optimizasyon süreci sırasında kullanılan eğitim örneklerinin oranı. (0.0, 1.0] aralığında olmalıdır. Varsayılan 1'dir.

Sadece alıştırma amacıyla, bu kez population_size = 15 azaltılmış şekilde ek argümanlar max_time_mins = 2 ve max_eval_time_mins = 0.04 ile TPOT'u yeniden çalıştıracaksınız.

tpot = TPOTClassifier(verbosity=2, max_time_mins=2, max_eval_time_mins=0.04, population_size=15)
tpot.fit(tele.drop('class',axis=1).loc[training_indices].values, tele.loc[training_indices,'class'].values)
Altyapı:

Optimization Progress: 42pipeline [00:42,  1.17s/pipeline]                  

Generation 1 - Current best internal CV score: 0.86119902629

Optimization Progress: 64pipeline [01:03,  1.04s/pipeline]                  

Generation 2 - Current best internal CV score: 0.86119902629

Optimization Progress: 83pipeline [01:21,  1.14s/pipeline]

Generation 3 - Current best internal CV score: 0.861689811492

Optimization Progress: 104pipeline [01:45,  1.03pipeline/s]

Generation 4 - Current best internal CV score: 0.861759642796

2.03228221667 minutes have elapsed. TPOT will close down.
TPOT closed prematurely. Will use the current best pipeline.

Best pipeline: XGBClassifier(RobustScaler(SelectPercentile(input_matrix, percentile=85)), learning_rate=0.1, max_depth=2, min_child_weight=4, n_estimators=100, nthread=1, subsample=0.1)

TPOTClassifier(config_dict={'sklearn.ensemble.GradientBoostingClassifier': {'max_features': array([0.05, 0.1 , 0.15, 0.2 , 0.25, 0.3 , 0.35, 0.4 , 0.45, 0.5 , 0.55,
       0.6 , 0.65, 0.7 , 0.75, 0.8 , 0.85, 0.9 , 0.95, 1.  ]), 'learning_rate': [0.001, 0.01, 0.1, 0.5, 1.0], 'min_samples_leaf': [1, 2, 3, 4, 5, 6, 7...  0.6 , 0.65, 0.7 , 0.75, 0.8 , 0.85, 0.9 , 0.95, 1.  ])}, 'sklearn.preprocessing.RobustScaler': {}},
        crossover_rate=0.1, cv=5, disable_update_check=False,
        early_stop=None, generations=1000000, max_eval_time_mins=0.04,
        max_time_mins=2, memory=None, mutation_rate=0.9, n_jobs=1,
        offspring_size=15, periodic_checkpoint_folder=None,
        population_size=15, random_state=None, scoring=None, subsample=1.0,
        verbosity=2, warm_start=False)
Altyapı:

Dikkat edebileceğiniz gibi, belirtilen süre içinde en iyi performans gösteren sınıflandırıcı bu kez, ön işleme adımları olarak SelectPercentile() ve RobustScaler() ile birlikte XGBoost oldu.

Sınırlamalar

• TPOT'un aramasını bitirmesi uzun sürebilir

TPOT'u çalıştırmak, veri kümesi üzerinde tek bir modeli uyarlamak kadar basit değildir. Bir hattın içinde birden fazla makine öğrenimi algoritmasını (rastgele ormanlar, doğrusal modeller, SVM'ler vb.), çok sayıda ön işleme adımını (eksik değer atama, ölçekleme, PCA, özellik seçimi vb.), tüm modeller ve ön işleme adımları için hiperparametreleri ve ayrıca algoritmaları hatta birleştirmenin veya istif etmenin birden çok yolunu değerlendirir. Bu nedenle genellikle yürütülmesi uzun sürer ve büyük veri kümeleri için uygulanabilir değildir.

• TPOT aynı veri kümesi için farklı çözümler önerebilir

Oldukça karmaşık bir veri kümesi ile çalışıyorsanız veya TPOT'u kısa bir süre için çalıştırırsanız, farklı TPOT çalıştırmaları farklı hat önerileriyle sonuçlanabilir. İki TPOT çalıştırması farklı hatlar önerdiğinde, bu TPOT çalıştırmalarının zaman yetersizliği nedeniyle yakınsamadığını veya birden fazla hattın veri kümeniz üzerinde aşağı yukarı aynı performansı gösterdiğini ifade eder.

Sonuç

Yaşasın! Bu eğitimin sonuna geldiniz. Otomatikleştirilmiş Makine Öğrenimi platformlarının ardındaki fikre kısa bir girişle başladınız. Ardından Genetik Programlamayı ve TPOT'un makine öğrenimi hattı oluşturma sürecini otomatikleştirmek için bunu nasıl kullandığını biraz keşfettiniz. Ayrıca Python'da bir veri kümesi üzerinde TPOT kütüphanesini kullanma pratiği yaptınız ve sunduğu işlevler hakkında bilgi edindiniz. Gelecekte TPOT'u kullanmayı planlıyorsanız, mükemmel dokümantasyonuna bakmanızı şiddetle öneririm. İyi keşifler!

Python'da Makine Öğrenimi hakkında daha fazla bilgi edinmek isterseniz, DataCamp'in Python'da Ağaç Tabanlı Modellerle Makine Öğrenimi kursunu alın. Ayrıca DataCamp'in Python'da Makine Öğrenimine Giriş eğitimine de göz atın.
 

Bu eğitimi yazarken aşağıdaki web sayfalarından yararlanılmıştır.

• Sınıflandırma
• AutoML yazılımından ne beklemeli