지식을 늘려보세요! 논리적 규칙을 사용한 머신러닝

정밀도-재현율 곡선에서는 동일한 점이 서로 다른 축으로 표시됩니다. 경고: 왼쪽의 첫 번째 빨간색 점(0% 재현율, 100% 정밀도)은 0개 규칙에 해당합니다. 왼쪽의 두 번째 점이 첫 번째 규칙입니다.

Skope-rules는 트리 모델을 사용하여 규칙 후보를 생성합니다. 먼저 몇 가지 의사결정 트리를 구축하고 루트 노드에서 내부 노드 또는 리프 노드까지의 경로를 규칙 후보로 고려합니다. 그런 다음 이러한 후보 규칙은 정밀도 및 재현율과 같은 사전 정의된 기준에 따라 필터링됩니다. 정밀도와 재현율이 임계값을 초과하는 항목만 유지됩니다. 마지막으로, 다양성이 충분한 규칙을 선택하기 위해 유사성 필터링이 적용됩니다. 일반적으로 Skope-rules는 각 근본 원인에 대한 기본 규칙을 학습하는 데 적용됩니다.

프로젝트 주소: https://github.com/scikit-learn-contrib/skope-rules

• Skope-rules는 3절 BSD에 따라 scikit-learn을 기반으로 구축된 Python 기계 학습 모듈입니다. 허가.
• Skope-rules는 대상 카테고리를 "정의"하기 위한 논리적이고 해석 가능한 규칙을 학습하는 것, 즉 이 카테고리의 인스턴스를 높은 정확도로 감지하는 것을 목표로 합니다.
• Skope 규칙은 의사결정 트리의 해석 가능성과 Random Forest의 모델링 기능 간의 균형입니다.

schema

Installation

pip를 사용하여 최신 리소스를 얻을 수 있습니다:

pip install skope-rules

빠른 시작

SkopeRules는 논리적 규칙이 있는 클래스를 설명하는 데 사용할 수 있습니다:

from sklearn .datasets import load_iri s UFrom Skrules Import Skoperules

dataset = Load_iris ()
Feature_names = ['SEPAL_LENGTH', 'SEPAL_WIDTH', 'Petal_length', 'Petal_width'] KClf = Skoperules (MAX_DEPTH_DUPLICATINOTALOW = 2,
n_estimators 30,
Precision_min = 0.3 ,
call_min=0.1,
feature_names=feature_names)

idx의 경우 enumerate의 종(dataset.target_names):
X, y = 데이터 세트.data, 데이터 세트.target
clf.fit(X, y == idx)
rule = clf.rules_[0:3]
print("붓꽃에 대한 규칙", 종)
규칙의 규칙:
print(rule)
print()
print(20*'=')
print ()

참고:

다음 오류가 발생하는 경우:

해결책:

Python 가져오기 오류 정보: 'sklearn.externals'에서 'six' 이름을 가져올 수 없습니다. Yun Duojun이 유사한 오류를 찾았습니다. 스택 오버플로 질문: https://stackoverflow.com/questions/61867945/

해결책은 다음과 같습니다

import six

sys.modules['sklearn.externals.six'] = six
import mlrose

개인 테스트가 유효합니다!

SkopeRules는 "score_top_rules" 방법을 사용하는 경우 예측 변수로 사용할 수도 있습니다.

from sklearn.datasets import load_boston

from matplotlib import pyplot as plt
from skrules import SkopeRules

dataset = load_boston ( )
clf = SkopeRules(max_length_duplicatinotallow=None,
n_estimators=30,
정밀도_min=0.2,
presents_min=0.01,
feature_names=dataset.feature_names)

X, y = 데이터세트.데이터, 데이터세트.대상 > , 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) # 각 테스트 예시에 대한 위험 점수를 가져옵니다
precision, presents, _ = Precision_recall_curve(y_test, y_score)
plt.plot(recall , 정밀도)
plt.xlabel('Recall')
plt.ylabel('Precision')
plt.title('Precision Recall curve')
plt.show()

실용 사례

• 이진 분류 문제 해결
• 해석 가능한 결정 규칙 추출

이 사례는 5개 부분으로 나뉩니다.

• 관련 라이브러리 가져오기
• 데이터 준비
• 모델 학습(ScopeRules().score_top_rules() 메서드 사용)
• "생존 규칙"에 대한 설명(SkopeRules().rules_property 사용)
• 성능 분석(SkopeRules.predict_top_rules() 메소드 사용).

관련 라이브러리 가져오기

# skope-rules 가져오기
from skrules import SkopeRules

# 라이브러리 가져오기
pd로 팬더 가져오기
from sklearn.ensemble import GradientBoostingClassifier, RandomForestClassifier
from sklearn.model_selection import train_test_sp 조명
sklearn.tree에서 가져오기 DecisionTreeClassifier
import matplotlib.pyplot as plt
from sklearn.metrics import roc_curve, Precision_recall_curve
from matplotlib import cm
import numpy as np
from sklearn.metrics import 혼란_matrix
from IPython.display import display

# 타이타닉 데이터 가져오기
data = pd.read_csv('../data/titanic-train.csv')

데이터 준비

# 연령이 누락된 행 삭제
data = data.query('Age == Age')
# 변수 성별에 대한 인코딩 생성 Value
data['is Female'] = (data['Sex'] == 'female') * 1
# Unvaried Embarked는 인코딩된 값을 생성합니다
data = pd.concat(
[data,
pd.get_dummies(data.loc) [:,'Embarked'],
dummy_na=False,
prefix='Embarked',
prefix_sep='_')],
axis=1
)
# 사용하지 않는 변수 삭제
data = data.drop( ['이름 ', 'Ticket', 'Cabin',
'PassengerId', 'Sex', 'Embarked'],
axis = 1)
# 훈련 및 테스트 세트 생성
X_train, X_test, y_train, y_test = train_test_split(
data. drop(['Survived'], axis=1),
data['Survived'],
test_size=0.25, random_state=42)
feature_names = X_train.columns

print('열 이름은 ' + ' '입니다. Join(feature_names.tolist())+'.')
print('훈련 세트의 형태: ' + str(X_train.shape) + '.')

열 이름: Pclass Age SibSp Parch Fare
is Female Embarked_C Embarked_Q Embarked_S.
훈련 세트의 모양은 다음과 같습니다: (535, 9).

Model training

# 벤치마크 테스트를 위한 그래디언트 부스팅 분류기 훈련
gradient_boost_clf = GradientBoostingClassifier(random_state=42, n_estimators=30, max_length = 5)
gradient_boost_clf .fit(X_train, y_train)

# 벤치마킹을 위한 무작위 포레스트 분류기 훈련
random_forest_clf = RandomForestClassifier(random_state=42, n_estimators=30, max_length = 5)
random_forest_clf.fit(X_train , y_train)

# 의사결정 트리 훈련 벤치마킹을 위한 분류자
decision_tree_clf = DecisionTreeClassifier(random_state=42, max_length = 5)
decision_tree_clf.fit(X_train, y_train)

# skope-rules-boosting 분류 훈련
skope_rules_clf = SkopeRules(feature_names=feature_names, random_state= 42, n_추정자 =30,
Remember_min=0.05, Precision_min=0.9,
max_samples=0.7,
max_length_duplicatinotallow= 4, max_length = 5)
skope_rules_clf.fit(X _train, y_train)


# 예측 점수 계산
gradient_boost_scoring 그래디언트_boost_clf.predict_proba( X_test)[:, 1]
random_forest_scoring = random_forest_clf.predict_proba(X_test)[:, 1]
decision_tree_scoring = Decision_tree_clf.predict_proba(X_test )[:, 1]

skope_rules_scoring = skope_rules_clf.score_top_rules (n")

# 인쇄 this rule

"3세 미만, 37세 미만 여성, 1등 또는 2등. "
"3세 이상의 여성은 1등석 또는 2등석으로 여행하며 요금이 26유로 이상입니다. "
"1등석 또는 2등석으로 여행하고 29유로 이상을 지불하는 여성. "
"39세 이상이며 1등석 또는 2등석으로 여행하는 여성입니다. "
]
print('가장 성능이 뛰어난 네 가지 "타이타닉 생존 규칙"은 다음과 같습니다:/n')
i_rule의 경우 enumerate(skope_rules_clf.rules_[:4])
print(rule[ 0])
의 규칙입니다. print('->'+rules_explanations[i_rule]+ 'n')

SkopeRules를 사용하여 9개의 규칙 만들기

최고의 4가지 "타이타닉 생존 규칙"은 다음과 같습니다:
Age 및 Pclass 37세 미만, 1등급 또는 2등급

Age > 26.125
;= 2.5 및 is여성 > 0.5
-> 1등석 또는 2등석으로 여행하고 26유로 이상을 지불하는 여성.

요금 > 29.356250762939453
및 Pclass 0.5
-> 1등석 또는 2등석 탑승, 여성 요금 29유로 이상.

나이 > 38.5 및 P클래스 및 여성 > 0.5
-> 39세 이상이며 1등석 또는 2등석으로 여행하는 여성.

def Compute_y_pred_from_query(X, 규칙):
score = np.zeros(X.shape[0])
X = X.reset_index(drop=True)
score[list(X.query(rule).index)] = 1
return(점수)

def Compute_performances_from_y_pred(y_true, y_pred, index_name='default_index'):
df = pd.DataFrame(data=
{
'precision':[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, = pd.concat([
performances ,
compute_performances_from_y_pred(y_train, y_train_pred, 'train_set')],
axis=0)
performances = pd.concat([
performances,
compute_performance s_from_y_pred( y_test, y_test_pred, 'test_set')],
axis=0)

return(performances)


print('정밀도 = 0.96은 규칙에 의해 식별된 사람 중 96%가 생존자임을 의미합니다.')
print(' 재현율 = 0.12는 규칙에 따라 식별된 생존자가 전체 생존자의 12%를 차지한다는 것을 의미합니다.')

for i in range(4):
print('Rule '+str(i+1)+':')
display(compute_train_test_query_performances(X_train, y_train,
X_test, y_test,
skope_rules_clf.rules_[i][ 0])
)

Precision = 0.96은 규칙에 의해 결정된 사람들 중 96%가 생존자임을 의미합니다.
재현율 = 0.12는 규칙에 따라 식별된 생존자가 전체 생존자의 12%를 차지한다는 의미입니다.

모델 성능 테스트

labels_with_line=['Gradient Boosting', 'Random Forest', 'Decision Tree'],labels_with_points=[ 'skope-rules']):

color_list = [ 그래디언트의 x에 대한 cm.tab10(x) ]

fig, 축 = plt.subplots(1, 2, figsize=(12, 5),
sharex=True, sharey=True)
ax = axis[0]
n_line = 0
i_score의 경우 열거된 점수(scores_with_line):
n_line = n_line + 1
fpr, tpr, _ = roc_curve(y_true, 점수)
ax.plot(fpr, tpr, linestyle='-.', c=color_list[i_score], lw=1, label=labels_with_line[i_score])
i_score의 경우, 열거된 점수( Score_with_points):
fpr, tpr, _ = roc_curve(y_true, 점수)
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('거짓 긍정률', fnotallow=18)
ax.set_ylabel('참 긍정률(재현율)', fnotallow=18 )
ax.legend(loc='lower center', fnotallow=8)

ax = axis[1]
n_line = 0
i_score의 경우 열거 점수(scores_with_line):
n_line = n_line + 1
정밀도, 재현율 , _ = 정밀도_recall_curve(y_true, 점수)
ax.step(recall, 정밀도, linestyle='-.', c=color_list[i_score], lw=1, where='post', label=labels_with_line[i_score])
i_score의 경우 열거형 점수(scores_with_points):
precision, presents, _ = 정밀도_recall_curve(y_true, 점수)
ax.scatter(recall, 정밀도, c=color_list[n_line + i_score], s=10, label=labels_with_points[i_score ])
ax.set_title("정밀도-재현율", fnotallow=20)
ax.set_xlabel('재현율(참양성률)', fnotallow=18)
ax.set_ylabel('정밀도', fnotallow=18)
ax .legend(loc='하단 중앙', fnotallow=8)
plt.show()

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




ROC 곡선에서 각 빨간색 점은 활성화된 규칙(skope-rules에서) 수에 해당합니다. 예를 들어 가장 낮은 점수는 1개의 규칙(최고)의 결과 점수입니다. 두 번째로 낮은 지점은 2개의 규칙 결과 지점입니다.
정밀도-재현율 곡선에서는 동일한 점이 다른 축으로 표시됩니다. 경고: 왼쪽의 첫 번째 빨간색 점(0% 재현율, 100% 정밀도)은 0개 규칙에 해당합니다. 왼쪽의 두 번째 점이 첫 번째 규칙입니다.

이 예에서 몇 가지 결론을 도출할 수 있습니다.

• skope-rule은 의사결정 트리보다 더 나은 성능을 발휘합니다.
• skope-rules는 랜덤 포레스트/그라디언트 부스팅(이 예에서는)과 유사하게 수행됩니다.
• 4가지 규칙을 사용하면 매우 좋은 성능(61% 재현율, 94% 정밀도)을 얻을 수 있습니다(이 예에서는).

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

print('발견된 '+str(n_rule_chosen)+' 규칙으로 도달한 성능은 다음과 같습니다.')
compute_performances_from_y_pred(y_test, y_pred, ' test_set')

predict_top_rules(new_data, n_r) 메소드는 첫 번째 n_r 범위 규칙 규칙을 포함하는 new_data의 예측을 계산하는 데 사용됩니다.

위 내용은 지식을 늘려보세요! 논리적 규칙을 사용한 머신러닝의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!