Tingkatkan pengetahuan anda! Pembelajaran mesin dengan peraturan logik

Pada lengkung ingat-kejituan, titik yang sama diplot dengan paksi yang berbeza. Amaran: Titik merah pertama di sebelah kiri (0% ingat, 100% ketepatan) sepadan dengan 0 peraturan. Titik kedua di sebelah kiri ialah peraturan pertama, dan seterusnya.

Skope-rules menggunakan model pokok untuk menjana calon peraturan. Mula-mula bina beberapa pepohon keputusan dan pertimbangkan laluan dari nod akar ke nod dalaman atau nod daun sebagai calon peraturan. Peraturan calon ini kemudiannya ditapis oleh beberapa kriteria yang telah ditetapkan seperti ketepatan dan ingat semula. Hanya mereka yang mempunyai ketepatan dan ingatan di atas ambang mereka dikekalkan. Akhir sekali, penapisan persamaan digunakan untuk memilih peraturan dengan kepelbagaian yang mencukupi. Secara umum, Skope-rules digunakan untuk mempelajari peraturan asas bagi setiap punca.

Alamat projek: https://github.com/scikit-learn-contrib/skope-rules

• Skope-rules ialah binaan Modul pembelajaran mesin Python di atas pembelajaran scikit, dikeluarkan di bawah lesen BSD 3 fasal.
• Peraturan Skope bertujuan untuk mempelajari peraturan yang logik dan boleh ditafsir untuk "mendefinisikan" kategori sasaran, iaitu, mengesan kejadian kategori ini dengan ketepatan yang tinggi.
• Peraturan Skope ialah pertukaran antara kebolehtafsiran pokok keputusan dan keupayaan pemodelan hutan rawak.

skema

Pemasangan

Anda boleh menggunakan pip untuk mendapatkan sumber terkini:

pemasangan pip skope-rules

Quick Start

SkopeRules boleh digunakan untuk menerangkan kelas dengan peraturan logik:

dari sklearn.datasets import load_iris
dari skrules import SkopeRules

set data = load_iris()
feature_names = ['sepal_length', 'sepal_width', 'petal_length', 'petal_width']
clf = SkopeRules(max_depth_duplicatinotallow=2,
= n
> precision_min=0.3 ,
recall_min=0.1,
feature_names=feature_names)

untuk idx, spesies dalam enumerate(dataset.target_names):
X, y = dataset.data, dataset. target
clf.fit(X, y == idx)
peraturan = clf.rules_[0:3]
print("Peraturan untuk iris", spesies)
untuk peraturan dalam peraturan:
print( peraturan)
print()
print(20*'=')
print()

Nota:

jika Ralat berikut:

Penyelesaian:

Mengenai ralat import Python: tidak boleh mengimport nama 'enam' daripada 'sklearn.externals' , Yun Duojun pada Stack Overflow Menemui soalan yang sama pada: https://stackoverflow.com/questions/61867945/

Penyelesaian adalah seperti berikut

import enam
import sys
sys. modul['sklearn .externals.six'] = enam
import mlrose

Ujian peribadi berfungsi!

SkopeRules juga boleh digunakan sebagai peramal jika menggunakan kaedah "score_top_rules":

daripada sklearn.datasets import load_boston
daripada sklearn.metrics import precision_recall_curve
from pytplotplotlibrom plt
dari skrules import SkopeRules

set data = load_boston()
clf = SkopeRules(max_depth_duplicatinotallow=Tiada,
n_estimators=30,
precision_min🎜> precision_min🎜> ,
feature_names=dataset.feature_names)

X, y = dataset.data, dataset.target > 25
X_train, y_train = X[:len(y)//2], y [:len(y)//2]
X_test, y_test = X[len(y)//2:], y[len(y)//2:]
clf.fit(X_train, y_train )
y_score = clf.score_top_rules(X_test) # Dapatkan skor risiko untuk setiap contoh ujian
precision, recall, _ = precision_recall_curve(y_test, y_score)
plt.plot(recall, precision)
plt.xlabel('Recall')
plt.ylabel('Precision')
plt.title('Precision Recall curve')
plt.show()

Kes Praktikal

Kes ini menunjukkan penggunaan peraturan skope pada set data Titanic yang terkenal.

situasi terpakai peraturan-skope:

• Menyelesaikan masalah klasifikasi binari
• Mengekstrak peraturan keputusan yang boleh ditafsir

Kes ini dibahagikan kepada 5 bahagian

• Import perpustakaan berkaitan
• Penyediaan data
• Latihan model (menggunakan kaedah ScopeRules().score_top_rules()
• Penjelasan tentang "peraturan survival" (menggunakan SkopeRules().rules_property).
• Analisis prestasi (menggunakan kaedah SkopeRules.predict_top_rules()).

Import perpustakaan berkaitan

# Import skope-rules
dari skrules import SkopeRules

# Import perpustakaan
import panda sebagai pd
from import sklearn.ensemble GradientBoostingClassifier, RandomForestClassifier
daripada sklearn.model_selection import train_test_split
daripada sklearn.tree import DecisionTreeClassifier
import matplotlib.py🎜>import matplotlib.py🎜seleksi import _recall_curve
dari matplotlib import cm
import numpy sebagai np
daripada sklearn.metrics import confusion_matrix
daripada paparan import IPython.display

# Import data Titanic
data = pd.read_csv('../ data/titanic-train.csv')
Penyediaan data

# Padamkan baris dengan umur yang hilang

data = data.query('Umur == Umur')
# untuk Pembolehubah Sex mencipta nilai yang dikodkan
data['isFemale'] = (data['Sex'] == 'female') * 1
# Pembolehubah Embarked mencipta nilai yang dikodkan
data = pd. concat(
[data,
pd.get_dummies(data.loc[:,'Embarked'],
dummy_na=False,
prefix='Embarked',
prefix_sep='_' )],
paksi=1
)
# Padamkan pembolehubah yang tidak digunakan
data = data.drop(['Nama', 'Tiket', 'Kabin',
'PassengerId', ' Sex ', 'Embarked'],
axis = 1)
# Cipta set latihan dan ujian
X_train, X_test, y_train, y_test = train_test_split(
data.drop(['Survived'], paksi =1),
data['Survived'],
test_size=0.25, random_state=42)
feature_names = X_train.columns

print('Nama lajur ialah: ' + ' ' .join(feature_names.tolist())+'.')
print('Bentuk set latihan ialah: ' + str(X_train.shape) + '.')
Nama lajur ialah: Pclass Age SibSp Parch Fare

is Female Embarked_C Embarked_Q Embarked_S.
Bentuk set latihan ialah: (535, 9).
Latihan model

# Latih pengelas penggalak kecerunan dengan For penanda aras

gradient_boost_clf = GradientBoostingClassifier(random_state=42, n_estimators=30, max_depth = 5)
gradient_boost_clf.fit(X_train, y_train)

Test abenchmarking forest lf = RandomForestClassifier(random_state=42, n_estimators=30, max_depth = 5)
random_forest_clf.fit(X_train, y_train)

# Latih pengelas pokok keputusan untuk penandaarasan
random_forest_clf.fit(X_train, y_train)

# Latih pengelas pokok keputusan untuk penanda aras
pembetulan keputusan_keadaan_4C2 , max_depth = 5)
decision_tree_clf.fit(X_train, y_train)

# Latih pengelas skope-rules-boosting
skope_rules_clf = SkopeRules, random_state_names(feature_names=feature_0names=3
recall_min=0.05, precision_min=0.9,
max_samples=0.7,
max_depth_duplicatinotallow= 4, max_depth = 5)
skope_rules_clf.fit(y_🎜>gradient_boost_scoring = gradient_boost_clf.predict_proba(X_test)[:, 1]
random_forest_scoring = rawak_forest_clf.predict_proba(X_test)[:, 1]<_tre_predict_decision>
skope_rules_scoring = skope_rules_clf.score_top_rules(X_test)

Pengeluaran "Peraturan Kelangsungan Hidup"
# Dapatkan peraturan kelangsungan hidup yang dicipta Nombor Scetak("Peraturan Kelangsungan Hidup" + str(len(skope_rules_clf.rules_)) + "rules n")

# Cetak peraturan ini

rules_explanations = [
"3 Wanita di bawah umur 37 tahun ke bawah, melancong dahulu atau kelas kedua. "
"Wanita berumur lebih 3 tahun mengembara dalam kelas pertama atau kedua dan membayar lebih daripada 26 euro. "
"Seorang wanita yang mengembara kelas pertama atau kedua dan membayar lebih daripada 29 euro. "
"Perempuan yang berumur lebih 39 tahun dan melancong dalam kelas pertama atau kedua. "
]
print('Empat "Peraturan survival Titanic" yang berprestasi terbaik adalah seperti berikut:/n')
untuk i_rule, peraturan dalam enumerate(skope_rules_clf.rules_[:4] )
print(rule[0])
print('->'+rules_explanations[i_rule]+ 'n')

Mencipta 9 peraturan menggunakan SkopeRules >Empat "Titanic Survival Rules" yang berprestasi terbaik. adalah seperti berikut:

Umur 2.5 dan Pclass , dalam kelas pertama atau kedua

Umur > 2.5 dan Tambang > dan Pclass
Tambang > 29.356250762939453
dan Pclass ->

Umur > 38.5 dan Pclass dan adalah Perempuan >->

def compute_y_pred_from_query(X, rule):skor = np.zeros(X.shape[0])

X = X.reset_index(drop=True)
skor[senarai( X.query(rule).index)] = 1
pulangan(skor)

def compute_performances_from_y_pred(y_true, y_pred, index_name='default_index'):
df = pd.DataFrame(data=Frame
{
'ketepatan':[sum(y_true * y_pred)/sum(y_pred)],
'recall':[sum(y_true * y_pred)/sum(y_true)]
},
index=[index_name],
columns=['precision', 'recall']
)
return(df)

def compute_train_test_query_performances(X_train, y_train, X_test, y_train, X_test, y_train, X_test, y_train , peraturan):

y_train_pred = compute_y_pred_from_query(X_train, peraturan)
y_test_pred = compute_y_pred_from_query(X_test, rule)

prestasi = p
prestasi = p
d. >prestasi,
compute_prestasis_from_y_pred(y_train, y_train_pred, 'train_set')],
axis=0)
prestasi = pd.concat([
prestasis,
prestasi_red_p_y,
pred, ' set_test')],
axis=0)

pulangan(prestasi)


print('Ketepatan = 0.96 bermakna 96% daripada orang yang ditentukan oleh peraturan adalah yang terselamat . ')
print('Recall = 0.12 bermakna pemandiri yang dikenal pasti oleh peraturan menyumbang 12% daripada jumlah bilangan yang terselamat n')

untuk i dalam julat(4):
cetak ('Peraturan '+ str(i+1)+':')
paparan(compute_train_test_query_performances(X_train, y_train,
X_test, y_test,
skope_rules_clf.rules_[i][0]>) )

Ketepatan = 0.96 bermakna 96% daripada orang yang ditentukan oleh peraturan adalah yang terselamat. Imbas kembali = 0.12 bermakna pemandiri yang dikenal pasti mengikut peraturan menyumbang 12% daripada jumlah yang terselamat.

Pengesanan prestasi model

def plot_titanic_scores(y_true, scores_with_line=[], scores_with_points=[],

labels_with_line=['Gradient_line=[] Boosting', 'Random Forest', 'Decision Tree'],

labels_with_points=['skope-rules']):
gradient = np.linspace(0, 1, 10)
color_list = [ cm .tab10(x) untuk x dalam kecerunan ]

rajah, paksi = plt.subplots(1, 2, figsize=(12, 5),
sharex=True, sharey=True)
ax = paksi[0]
n_line = 0
untuk i_score, markah dalam enumerate(scores_with_line):
n_line = n_line + 1
fpr, tpr, _ = roc_curve(y_true, score)
ax.plot(fpr, tpr, linestyle='-.', c=color_list[i_score], lw=1, label=labels_with_line[i_score])
untuk i_score, markah dalam enumerate(skor_dengan_mata):
fpr, tpr, _ = roc_curve(y_true, score)
ax.scatter(fpr[:-1], tpr[:-1], c=color_list[n_line + i_score], s=10, label=labels_with_points[ i_score])
ax.set_title("ROC", fnotallow=20)
ax.set_xlabel('Kadar Positif Palsu', fnotallow=18)
ax.set_ylabel('Kadar Positif Sebenar (Panggil Balik)' , fnotallow=18)
ax.legend(loc='lower center', fnotallow=8)

ax = axes[1]
n_line = 0
untuk i_score, markah dalam enumerate (skor_dengan_garis):
n_line = n_line + 1
precision, recall, _ = precision_recall_curve(y_true, score)
ax.step(recall, precision, linestyle='-.', c=color_list[i_score] ], lw=1, where='post', label=labels_with_line[i_score])
untuk i_score, score in enumerate(scores_with_points):
precision, recall, _ = precision_recall_curve(y_true, score)
ax.scatter(recall, precision, c=color_list[n_line + i_score], s=10, label=labels_with_points[i_score])
ax.set_title("Precision-Recall", fnotallow=20)
ax. set_xlabel('Recall (Kadar Positif Sebenar)', fnotallow=18)
ax.set_ylabel('Precision', fnotallow=18)
ax.legend(loc='lower center', fnotallow=8)
plt.show()

plot_titanic_scores(y_test,
scores_with_line=[gradient_boost_scoring, random_forest_scoring, decision_tree_scoring],
scores_with_points=[skope_rules_scoring]


Pada lengkung ROC, setiap titik merah sepadan dengan bilangan peraturan yang diaktifkan (daripada peraturan-skope). Sebagai contoh, titik terendah ialah titik hasil 1 peraturan (yang terbaik). Titik terendah kedua ialah titik hasil 2 peraturan, dan seterusnya.

Pada lengkung ingat-kepersisan, titik yang sama diplot dengan paksi yang berbeza. Amaran: Titik merah pertama di sebelah kiri (0% ingat, 100% ketepatan) sepadan dengan 0 peraturan. Titik kedua di sebelah kiri ialah peraturan pertama, dan seterusnya.

Beberapa kesimpulan boleh dibuat daripada contoh ini.

• peraturan skope berfungsi lebih baik daripada pokok keputusan.
• Prestasi peraturan skope adalah serupa dengan peningkatan hutan/kecerunan rawak (dalam contoh ini).
• Menggunakan 4 peraturan boleh mencapai prestasi yang sangat baik (61% ingat, 94% ketepatan) (dalam contoh ini).

n_rule_chosen = 4
y_pred = skope_rules_clf.predict_top_rules(X_test, n_rule_chosen)

print('Persembahan yang dicapai dengan '+str(n_rule)'+peraturan' berikut:')
compute_performances_from_y_pred(y_test, y_pred, 'test_set')

predict_top_rules(new_data, n_r) kaedah digunakan untuk mengira data_ramalan yang mana peraturan n_r skope-rules sebelumnya.

Atas ialah kandungan terperinci Tingkatkan pengetahuan anda! Pembelajaran mesin dengan peraturan logik. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!