scikit-learn-contrib/skope-rules là dự án Jupyter Notebook với 664 sao. machine learning with logical rules in Python
Tóm tắt dựng từ metadata GitHub của chính dự án — chưa có bài review TopGit. Trang sẽ tự động cập nhật khi bài review đầy đủ được xuất bản.
VÌ SAO CHƯA CÓ REVIEW
TopGit viết bài đầy đủ cho repo có nhiều sao nhất và được yêu cầu nhiều nhất. Trang này là snapshot trong thời gian chờ — xem README gốc ở tab READ ME.
Skope-rules is a Python machine learning module built on top of
scikit-learn and distributed under the 3-Clause BSD license.
Skope-rules aims at learning logical, interpretable rules for "scoping" a target
class, i.e. detecting with high precision instances of this class.
Skope-rules is a trade off between the interpretability of a Decision Tree
and the modelization power of a Random Forest.
See the AUTHORS.rst <AUTHORS.rst>_ file for a list of contributors.
.. image:: schema.png
Installation
You can get the latest sources with pip :
pip install skope-rules
Quick Start
SkopeRules can be used to describe classes with logical rules :
.. code:: python
from sklearn.datasets import load_iris
from skrules import SkopeRules
dataset = load_iris()
feature_names = ['sepal_length', 'sepal_width', 'petal_length', 'petal_width']
clf = SkopeRules(max_depth_duplication=2,
n_estimators=30,
precision_min=0.3,
recall_min=0.1,
feature_names=feature_names)
for idx, species in enumerate(dataset.target_names):
X, y = dataset.data, dataset.target
clf.fit(X, y == idx)
rules = clf.rules_[0:3]
print("Rules for iris", species)
for rule in rules:
print(rule)
print()
print(20*'=')
print()
::
SkopeRules can also be used as a predictor if you use the "score_top_rules" method :
.. code:: python
from sklearn.datasets import load_boston
from sklearn.metrics import precision_recall_curve
from matplotlib import pyplot as plt
from skrules import SkopeRules
dataset = load_boston()
clf = SkopeRules(max_depth_duplication=None,
n_estimators=30,
precision_min=0.2,
recall_min=0.01,
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) # Get a risk score for each test example
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()
::
For more examples and use cases please check our documentation <http://skope-rules.readthedocs.io/en/latest/>.
You can also check the demonstration notebooks <notebooks/>.
Links with existing literature
The main advantage of decision rules is that they are offering interpretable models. The problem of generating such rules has been widely considered in machine learning, see e.g. RuleFit [1], Slipper [2], LRI [3], MLRules[4].
A decision rule is a logical expression of the form "IF conditions THEN response". In a binary classification setting, if an instance satisfies conditions of the rule, then it is assigned to one of the two classes. If this instance does not satisfy conditions, it remains unassigned.
In [2, 3, 4], rules induction is done by considering each single decision rule as a base classifier in an ensemble, which is built by greedily minimizing some loss function.
In [1], rules are extracted from an ensemble of trees; a weighted combination of these rules is then built by solving a L1-regularized optimization problem over the weights as described in [5].
In this package, we use the second approach. Rules are extracted from tree ensemble, which allow us to take advantage of existing fast algorithms (such as bagged decision trees, or gradient boosting) to produce such tree ensemble. Too similar or duplicated rules are then removed, based on a similarity threshold of their supports..
The main goal of this package is to provide rules verifying precision and recall conditions. It still implement a score (decision_function) method, but which does not solve the L1-regularized optimization problem as in [1]. Instead, weights are simply proportional to the OOB associated precision of the rule.
This package also offers convenient methods to compute predictions with the k most precise rules (cf score_top_rules() and predict_top_rules() functions).
[1] Friedman and Popescu, Predictive learning via rule ensembles,Technical Report, 2005.
[2] Cohen and Singer, A simple, fast, and effective rule learner, National Conference on Artificial Intelligence, 1999.
[3] Weiss and Indurkhya, Lightweight rule induction, ICML, 2000.
[4] Dembczyński, Kotłowski and Słowiński, Maximum Likelihood Rule Ensembles, ICML, 2008.
[5] Friedman and Popescu, Gradient directed regularization, Technical Report, 2004.
Dependencies
skope-rules requires:
Python (>= 2.7 or >= 3.3)
NumPy (>= 1.10.4)
SciPy (>= 0.17.0)
Pandas (>= 0.18.1)
Scikit-Learn (>= 0.17.1)
For running the examples Matplotlib >= 1.1.1 is required.
Documentation
You can access the full project documentation here <http://skope-rules.readthedocs.io/en/latest/>_
You can also check the notebooks/ folder which contains some examples of utilization.
Đọc thêm về scikit-learn-contrib/skope-rules ở đâu?
Trang TopGit này là một snapshot — tab "Readme" hiển thị nguyên văn README của repo (đã bỏ link, giữ ảnh). Repo GitHub ở github.com/scikit-learn-contrib/skope-rules là nguồn chính thức.
scikit-learn-contrib/skope-rules có bao nhiêu sao?
scikit-learn-contrib/skope-rules có 664 sao GitHub — tải lại trang để xem số mới nhất, hoặc xem trực tiếp github.com/scikit-learn-contrib/skope-rules. TopGit phản chiếu số sao của GitHub nhưng không cam kết đến từng phút.
scikit-learn-contrib/skope-rules có tag gì không?
Bản đồng bộ chưa ghi nhận topic GitHub nào cho scikit-learn-contrib/skope-rules. GitHub topics hiển thị ở thanh bên phải trang repo — đó là nơi đáng kiểm tra nhất.
scikit-learn-contrib/skope-rules còn đang phát triển không?
Commit gần nhất trên scikit-learn-contrib/skope-rules là 2.8 năm trước (theo timestamp GitHub). Repo có 109 fork — một chỉ báo về mức độ quan tâm của cộng đồng.
scikit-learn-contrib/skope-rules viết bằng ngôn ngữ gì?
scikit-learn-contrib/skope-rules chủ yếu viết bằng Jupyter Notebook. Trường "language" của GitHub dựa trên phần lớn byte ở nhánh mặc định.
Đọc đầy đủ README ở tab phía trên.
Muốn nghe thêm một ý kiến về skope-rules?
Hỏi một AI đọc được trang này — một cú bấm là có ngay nhận định về skope-rules.